Improve Coin formatter naming

freqtrade/commands/optimize_commands.py

@@ -5,7 +5,7 @@ from freqtrade import constants
 from freqtrade.configuration import setup_utils_configuration
 from freqtrade.enums import RunMode
 from freqtrade.exceptions import OperationalException
-from freqtrade.util import round_coin_value
+from freqtrade.util import fmt_coin
 
 
 logger = logging.getLogger(__name__)
@@ -29,8 +29,8 @@ def setup_optimize_configuration(args: Dict[str, Any], method: RunMode) -> Dict[
         # tradable_balance_ratio
         if (config['stake_amount'] != constants.UNLIMITED_STAKE_AMOUNT
                 and config['stake_amount'] > wallet_size):
-            wallet = round_coin_value(wallet_size, config['stake_currency'])
+            wallet = fmt_coin(wallet_size, config['stake_currency'])
-            stake = round_coin_value(config['stake_amount'], config['stake_currency'])
+            stake = fmt_coin(config['stake_amount'], config['stake_currency'])
             raise OperationalException(
                 f"Starting balance ({wallet}) is smaller than stake_amount {stake}. "
                 f"Wallet is calculated as `dry_run_wallet * tradable_balance_ratio`."

freqtrade/optimize/hyperopt_tools.py

@@ -17,7 +17,7 @@ from freqtrade.exceptions import OperationalException
 from freqtrade.misc import deep_merge_dicts, round_dict, safe_value_fallback2
 from freqtrade.optimize.hyperopt_epoch_filters import hyperopt_filter_epochs
 from freqtrade.optimize.optimize_reports import generate_wins_draws_losses
-from freqtrade.util import round_coin_value
+from freqtrade.util import fmt_coin
 
 
 logger = logging.getLogger(__name__)
@@ -406,7 +406,7 @@ class HyperoptTools:
 
         trials[f"Max Drawdown{' (Acct)' if has_account_drawdown else ''}"] = trials.apply(
             lambda x: "{} {}".format(
-                round_coin_value(x['max_drawdown_abs'], stake_currency, keep_trailing_zeros=True),
+                fmt_coin(x['max_drawdown_abs'], stake_currency, keep_trailing_zeros=True),
                 (f"({x['max_drawdown_account']:,.2%})"
                     if has_account_drawdown
                     else f"({x['max_drawdown']:,.2%})"
@@ -421,7 +421,7 @@ class HyperoptTools:
 
         trials['Profit'] = trials.apply(
             lambda x: '{} {}'.format(
-                round_coin_value(x['Total profit'], stake_currency, keep_trailing_zeros=True),
+                fmt_coin(x['Total profit'], stake_currency, keep_trailing_zeros=True),
                 f"({x['Profit']:,.2%})".rjust(10, ' ')
             ).rjust(25 + len(stake_currency))
             if x['Total profit'] != 0.0 else '--'.rjust(25 + len(stake_currency)),

freqtrade/optimize/optimize_reports/bt_output.py

@@ -6,7 +6,7 @@ from tabulate import tabulate
 from freqtrade.constants import UNLIMITED_STAKE_AMOUNT, Config
 from freqtrade.optimize.optimize_reports.optimize_reports import generate_periodic_breakdown_stats
 from freqtrade.types import BacktestResultType
-from freqtrade.util import decimals_per_coin, round_coin_value
+from freqtrade.util import decimals_per_coin, fmt_coin
 
 
 logger = logging.getLogger(__name__)
@@ -81,7 +81,7 @@ def text_table_exit_reason(exit_reason_stats: List[Dict[str, Any]], stake_curren
         t.get('exit_reason', t.get('sell_reason')), t['trades'],
         generate_wins_draws_losses(t['wins'], t['draws'], t['losses']),
         t['profit_mean_pct'], t['profit_sum_pct'],
-        round_coin_value(t['profit_total_abs'], stake_currency, False),
+        fmt_coin(t['profit_total_abs'], stake_currency, False),
         t['profit_total_pct'],
     ] for t in exit_reason_stats]
     return tabulate(output, headers=headers, tablefmt="orgtbl", stralign="right")
@@ -134,7 +134,7 @@ def text_table_periodic_breakdown(days_breakdown_stats: List[Dict[str, Any]],
         'Losses',
     ]
     output = [[
-        d['date'], round_coin_value(d['profit_abs'], stake_currency, False),
+        d['date'], fmt_coin(d['profit_abs'], stake_currency, False),
         d['wins'], d['draws'], d['loses'],
     ] for d in days_breakdown_stats]
     return tabulate(output, headers=headers, tablefmt="orgtbl", stralign="right")
@@ -187,9 +187,9 @@ def text_table_add_metrics(strat_results: Dict) -> str:
              f"{strat_results.get('trade_count_short', 0)}"),
             ('Total profit Long %', f"{strat_results['profit_total_long']:.2%}"),
             ('Total profit Short %', f"{strat_results['profit_total_short']:.2%}"),
-            ('Absolute profit Long', round_coin_value(strat_results['profit_total_long_abs'],
+            ('Absolute profit Long', fmt_coin(strat_results['profit_total_long_abs'],
                                                       strat_results['stake_currency'])),
-            ('Absolute profit Short', round_coin_value(strat_results['profit_total_short_abs'],
+            ('Absolute profit Short', fmt_coin(strat_results['profit_total_short_abs'],
                                                        strat_results['stake_currency'])),
         ] if strat_results.get('trade_count_short', 0) > 0 else []
 
@@ -203,11 +203,11 @@ def text_table_add_metrics(strat_results: Dict) -> str:
             ('Absolute Drawdown (Account)', f"{strat_results['max_drawdown_account']:.2%}")
             if 'max_drawdown_account' in strat_results else (
                 'Drawdown', f"{strat_results['max_drawdown']:.2%}"),
-            ('Absolute Drawdown', round_coin_value(strat_results['max_drawdown_abs'],
+            ('Absolute Drawdown', fmt_coin(strat_results['max_drawdown_abs'],
                                                    strat_results['stake_currency'])),
-            ('Drawdown high', round_coin_value(strat_results['max_drawdown_high'],
+            ('Drawdown high', fmt_coin(strat_results['max_drawdown_high'],
                                                strat_results['stake_currency'])),
-            ('Drawdown low', round_coin_value(strat_results['max_drawdown_low'],
+            ('Drawdown low', fmt_coin(strat_results['max_drawdown_low'],
                                               strat_results['stake_currency'])),
             ('Drawdown Start', strat_results['drawdown_start']),
             ('Drawdown End', strat_results['drawdown_end']),
@@ -230,11 +230,11 @@ def text_table_add_metrics(strat_results: Dict) -> str:
             ('Total/Daily Avg Trades',
                 f"{strat_results['total_trades']} / {strat_results['trades_per_day']}"),
 
-            ('Starting balance', round_coin_value(strat_results['starting_balance'],
+            ('Starting balance', fmt_coin(strat_results['starting_balance'],
                                                   strat_results['stake_currency'])),
-            ('Final balance', round_coin_value(strat_results['final_balance'],
+            ('Final balance', fmt_coin(strat_results['final_balance'],
                                                strat_results['stake_currency'])),
-            ('Absolute profit ', round_coin_value(strat_results['profit_total_abs'],
+            ('Absolute profit ', fmt_coin(strat_results['profit_total_abs'],
                                                   strat_results['stake_currency'])),
             ('Total profit %', f"{strat_results['profit_total']:.2%}"),
             ('CAGR %', f"{strat_results['cagr']:.2%}" if 'cagr' in strat_results else 'N/A'),
@@ -249,9 +249,9 @@ def text_table_add_metrics(strat_results: Dict) -> str:
             ('Trades per day', strat_results['trades_per_day']),
             ('Avg. daily profit %',
              f"{(strat_results['profit_total'] / strat_results['backtest_days']):.2%}"),
-            ('Avg. stake amount', round_coin_value(strat_results['avg_stake_amount'],
+            ('Avg. stake amount', fmt_coin(strat_results['avg_stake_amount'],
                                                    strat_results['stake_currency'])),
-            ('Total trade volume', round_coin_value(strat_results['total_volume'],
+            ('Total trade volume', fmt_coin(strat_results['total_volume'],
                                                     strat_results['stake_currency'])),
             *short_metrics,
             ('', ''),  # Empty line to improve readability
@@ -263,9 +263,9 @@ def text_table_add_metrics(strat_results: Dict) -> str:
             ('Worst trade', f"{worst_trade['pair']} "
                             f"{worst_trade['profit_ratio']:.2%}"),
 
-            ('Best day', round_coin_value(strat_results['backtest_best_day_abs'],
+            ('Best day', fmt_coin(strat_results['backtest_best_day_abs'],
                                           strat_results['stake_currency'])),
-            ('Worst day', round_coin_value(strat_results['backtest_worst_day_abs'],
+            ('Worst day', fmt_coin(strat_results['backtest_worst_day_abs'],
                                            strat_results['stake_currency'])),
             ('Days win/draw/lose', f"{strat_results['winning_days']} / "
                 f"{strat_results['draw_days']} / {strat_results['losing_days']}"),
@@ -281,9 +281,9 @@ def text_table_add_metrics(strat_results: Dict) -> str:
             *entry_adjustment_metrics,
             ('', ''),  # Empty line to improve readability
 
-            ('Min balance', round_coin_value(strat_results['csum_min'],
+            ('Min balance', fmt_coin(strat_results['csum_min'],
                                              strat_results['stake_currency'])),
-            ('Max balance', round_coin_value(strat_results['csum_max'],
+            ('Max balance', fmt_coin(strat_results['csum_max'],
                                              strat_results['stake_currency'])),
 
             *drawdown_metrics,
@@ -292,9 +292,9 @@ def text_table_add_metrics(strat_results: Dict) -> str:
 
         return tabulate(metrics, headers=["Metric", "Value"], tablefmt="orgtbl")
     else:
-        start_balance = round_coin_value(strat_results['starting_balance'],
+        start_balance = fmt_coin(strat_results['starting_balance'],
                                          strat_results['stake_currency'])
-        stake_amount = round_coin_value(
+        stake_amount = fmt_coin(
             strat_results['stake_amount'], strat_results['stake_currency']
         ) if strat_results['stake_amount'] != UNLIMITED_STAKE_AMOUNT else 'unlimited'
 

freqtrade/optimize/optimize_reports/optimize_reports.py

@@ -11,7 +11,7 @@ from freqtrade.data.metrics import (calculate_cagr, calculate_calmar, calculate_
                                     calculate_expectancy, calculate_market_change,
                                     calculate_max_drawdown, calculate_sharpe, calculate_sortino)
 from freqtrade.types import BacktestResultType
-from freqtrade.util import decimals_per_coin, round_coin_value
+from freqtrade.util import decimals_per_coin, fmt_coin
 
 
 logger = logging.getLogger(__name__)
@@ -203,7 +203,7 @@ def generate_strategy_comparison(bt_stats: Dict) -> List[Dict]:
         # Update "key" to strategy (results_per_pair has it as "Total").
         tabular_data[-1]['key'] = strategy
         tabular_data[-1]['max_drawdown_account'] = result['max_drawdown_account']
-        tabular_data[-1]['max_drawdown_abs'] = round_coin_value(
+        tabular_data[-1]['max_drawdown_abs'] = fmt_coin(
             result['max_drawdown_abs'], result['stake_currency'], False)
     return tabular_data
 

freqtrade/rpc/telegram.py

@@ -33,7 +33,7 @@ from freqtrade.misc import chunks, plural
 from freqtrade.persistence import Trade
 from freqtrade.rpc import RPC, RPCException, RPCHandler
 from freqtrade.rpc.rpc_types import RPCEntryMsg, RPCExitMsg, RPCOrderMsg, RPCSendMsg
-from freqtrade.util import dt_humanize, round_coin_value
+from freqtrade.util import dt_humanize, fmt_coin
 
 
 MAX_MESSAGE_LENGTH = MessageLimit.MAX_TEXT_LENGTH
@@ -353,7 +353,7 @@ class Telegram(RPCHandler):
                        f"*Current Rate:* `{msg['current_rate']:.8f}`\n"
 
         profit_fiat_extra = self.__format_profit_fiat(msg, 'stake_amount')  # type: ignore
-        total = round_coin_value(msg['stake_amount'], msg['stake_currency'])
+        total = fmt_coin(msg['stake_amount'], msg['stake_currency'])
 
         message += f"*Total:* `{total}{profit_fiat_extra}`"
 
@@ -422,7 +422,7 @@ class Telegram(RPCHandler):
         if is_sub_trade:
             stake_amount_fiat = self.__format_profit_fiat(msg, 'stake_amount')
 
-            rem = round_coin_value(msg['stake_amount'], msg['stake_currency'])
+            rem = fmt_coin(msg['stake_amount'], msg['stake_currency'])
             message += f"\n*Remaining:* `{rem}{stake_amount_fiat}`"
         else:
             message += f"\n*Duration:* `{duration} ({duration_min:.1f} min)`"
@@ -556,7 +556,7 @@ class Telegram(RPCHandler):
             if order_nr == 1:
                 lines.append(
                     f"*Amount:* {cur_entry_amount:.8g} "
-                    f"({round_coin_value(order['cost'], quote_currency)})"
+                    f"({fmt_coin(order['cost'], quote_currency)})"
                 )
                 lines.append(f"*Average Price:* {cur_entry_average:.8g}")
             else:
@@ -566,7 +566,7 @@ class Telegram(RPCHandler):
                     lines.append("({})".format(dt_humanize(order["order_filled_date"],
                                                            granularity=["day", "hour", "minute"])))
                 lines.append(f"*Amount:* {cur_entry_amount:.8g} "
-                             f"({round_coin_value(order['cost'], quote_currency)})")
+                             f"({fmt_coin(order['cost'], quote_currency)})")
                 lines.append(f"*Average {wording} Price:* {cur_entry_average:.8g} "
                              f"({price_to_1st_entry:.2%} from 1st entry rate)")
                 lines.append(f"*Order Filled:* {order['order_filled_date']}")
@@ -652,12 +652,12 @@ class Telegram(RPCHandler):
             r['num_exits'] = len([o for o in r['orders'] if not o['ft_is_entry']
                                  and not o['ft_order_side'] == 'stoploss'])
             r['exit_reason'] = r.get('exit_reason', "")
-            r['stake_amount_r'] = round_coin_value(r['stake_amount'], r['quote_currency'])
+            r['stake_amount_r'] = fmt_coin(r['stake_amount'], r['quote_currency'])
-            r['max_stake_amount_r'] = round_coin_value(
+            r['max_stake_amount_r'] = fmt_coin(
                 r['max_stake_amount'] or r['stake_amount'], r['quote_currency'])
-            r['profit_abs_r'] = round_coin_value(r['profit_abs'], r['quote_currency'])
+            r['profit_abs_r'] = fmt_coin(r['profit_abs'], r['quote_currency'])
-            r['realized_profit_r'] = round_coin_value(r['realized_profit'], r['quote_currency'])
+            r['realized_profit_r'] = fmt_coin(r['realized_profit'], r['quote_currency'])
-            r['total_profit_abs_r'] = round_coin_value(
+            r['total_profit_abs_r'] = fmt_coin(
                 r['total_profit_abs'], r['quote_currency'])
             lines = [
                 "*Trade ID:* `{trade_id}`" +
@@ -800,7 +800,7 @@ class Telegram(RPCHandler):
         )
         stats_tab = tabulate(
             [[f"{period['date']:{val.dateformat}} ({period['trade_count']})",
-              f"{round_coin_value(period['abs_profit'], stats['stake_currency'])}",
+              f"{fmt_coin(period['abs_profit'], stats['stake_currency'])}",
               f"{period['fiat_value']:.2f} {stats['fiat_display_currency']}",
               f"{period['rel_profit']:.2%}",
               ] for period in stats['data']],
@@ -902,19 +902,19 @@ class Telegram(RPCHandler):
             # Message to display
             if stats['closed_trade_count'] > 0:
                 markdown_msg = ("*ROI:* Closed trades\n"
-                                f"∙ `{round_coin_value(profit_closed_coin, stake_cur)} "
+                                f"∙ `{fmt_coin(profit_closed_coin, stake_cur)} "
                                 f"({profit_closed_ratio_mean:.2%}) "
                                 f"({profit_closed_percent} \N{GREEK CAPITAL LETTER SIGMA}%)`\n"
-                                f"∙ `{round_coin_value(profit_closed_fiat, fiat_disp_cur)}`\n")
+                                f"∙ `{fmt_coin(profit_closed_fiat, fiat_disp_cur)}`\n")
             else:
                 markdown_msg = "`No closed trade` \n"
 
             markdown_msg += (
                 f"*ROI:* All trades\n"
-                f"∙ `{round_coin_value(profit_all_coin, stake_cur)} "
+                f"∙ `{fmt_coin(profit_all_coin, stake_cur)} "
                 f"({profit_all_ratio_mean:.2%}) "
                 f"({profit_all_percent} \N{GREEK CAPITAL LETTER SIGMA}%)`\n"
-                f"∙ `{round_coin_value(profit_all_fiat, fiat_disp_cur)}`\n"
+                f"∙ `{fmt_coin(profit_all_fiat, fiat_disp_cur)}`\n"
                 f"*Total Trade Count:* `{trade_count}`\n"
                 f"*Bot started:* `{stats['bot_start_date']}`\n"
                 f"*{'First Trade opened' if not timescale else 'Showing Profit since'}:* "
@@ -928,14 +928,14 @@ class Telegram(RPCHandler):
                 markdown_msg += (
                     f"\n*Avg. Duration:* `{avg_duration}`\n"
                     f"*Best Performing:* `{best_pair}: {best_pair_profit_ratio:.2%}`\n"
-                    f"*Trading volume:* `{round_coin_value(stats['trading_volume'], stake_cur)}`\n"
+                    f"*Trading volume:* `{fmt_coin(stats['trading_volume'], stake_cur)}`\n"
                     f"*Profit factor:* `{stats['profit_factor']:.2f}`\n"
                     f"*Max Drawdown:* `{stats['max_drawdown']:.2%} "
-                    f"({round_coin_value(stats['max_drawdown_abs'], stake_cur)})`\n"
+                    f"({fmt_coin(stats['max_drawdown_abs'], stake_cur)})`\n"
                     f"    from `{stats['max_drawdown_start']} "
-                    f"({round_coin_value(stats['drawdown_high'], stake_cur)})`\n"
+                    f"({fmt_coin(stats['drawdown_high'], stake_cur)})`\n"
                     f"    to `{stats['max_drawdown_end']} "
-                    f"({round_coin_value(stats['drawdown_low'], stake_cur)})`\n"
+                    f"({fmt_coin(stats['drawdown_low'], stake_cur)})`\n"
                 )
         await self._send_msg(markdown_msg, reload_able=True, callback_path="update_profit",
                              query=update.callback_query)
@@ -1003,9 +1003,9 @@ class Telegram(RPCHandler):
         output = ''
         if self._config['dry_run']:
             output += "*Warning:* Simulated balances in Dry Mode.\n"
-        starting_cap = round_coin_value(result['starting_capital'], self._config['stake_currency'])
+        starting_cap = fmt_coin(result['starting_capital'], self._config['stake_currency'])
         output += f"Starting capital: `{starting_cap}`"
-        starting_cap_fiat = round_coin_value(
+        starting_cap_fiat = fmt_coin(
             result['starting_capital_fiat'], self._config['fiat_display_currency']
         ) if result['starting_capital_fiat'] > 0 else ''
         output += (f" `, {starting_cap_fiat}`.\n"
@@ -1025,9 +1025,9 @@ class Telegram(RPCHandler):
                         f"\t`{curr['side']}: {curr['position']:.8f}`\n"
                         f"\t`Leverage: {curr['leverage']:.1f}`\n"
                         f"\t`Est. {curr['stake']}: "
-                        f"{round_coin_value(curr['est_stake'], curr['stake'], False)}`\n")
+                        f"{fmt_coin(curr['est_stake'], curr['stake'], False)}`\n")
                 else:
-                    est_stake = round_coin_value(
+                    est_stake = fmt_coin(
                         curr['est_stake' if full_result else 'est_stake_bot'], curr['stake'], False)
 
                     curr_output = (
@@ -1055,13 +1055,13 @@ class Telegram(RPCHandler):
                 f"{plural(total_dust_currencies, 'Currency', 'Currencies')} "
                 f"(< {balance_dust_level} {result['stake']}):*\n"
                 f"\t`Est. {result['stake']}: "
-                f"{round_coin_value(total_dust_balance, result['stake'], False)}`\n")
+                f"{fmt_coin(total_dust_balance, result['stake'], False)}`\n")
         tc = result['trade_count'] > 0
         stake_improve = f" `({result['starting_capital_ratio']:.2%})`" if tc else ''
         fiat_val = f" `({result['starting_capital_fiat_ratio']:.2%})`" if tc else ''
-        value = round_coin_value(
+        value = fmt_coin(
             result['value' if full_result else 'value_bot'], result['symbol'], False)
-        total_stake = round_coin_value(
+        total_stake = fmt_coin(
             result['total' if full_result else 'total_bot'], result['stake'], False)
         output += (
             f"\n*Estimated Value{' (Bot managed assets only)' if not full_result else ''}*:\n"
@@ -1340,7 +1340,7 @@ class Telegram(RPCHandler):
         for i, trade in enumerate(trades):
             stat_line = (
                 f"{i+1}.\t <code>{trade['pair']}\t"
-                f"{round_coin_value(trade['profit_abs'], self._config['stake_currency'])} "
+                f"{fmt_coin(trade['profit_abs'], self._config['stake_currency'])} "
                 f"({trade['profit_ratio']:.2%}) "
                 f"({trade['count']})</code>\n")
 
@@ -1372,7 +1372,7 @@ class Telegram(RPCHandler):
         for i, trade in enumerate(trades):
             stat_line = (
                 f"{i+1}.\t <code>{trade['enter_tag']}\t"
-                f"{round_coin_value(trade['profit_abs'], self._config['stake_currency'])} "
+                f"{fmt_coin(trade['profit_abs'], self._config['stake_currency'])} "
                 f"({trade['profit_ratio']:.2%}) "
                 f"({trade['count']})</code>\n")
 
@@ -1404,7 +1404,7 @@ class Telegram(RPCHandler):
         for i, trade in enumerate(trades):
             stat_line = (
                 f"{i+1}.\t <code>{trade['exit_reason']}\t"
-                f"{round_coin_value(trade['profit_abs'], self._config['stake_currency'])} "
+                f"{fmt_coin(trade['profit_abs'], self._config['stake_currency'])} "
                 f"({trade['profit_ratio']:.2%}) "
                 f"({trade['count']})</code>\n")
 
@@ -1436,7 +1436,7 @@ class Telegram(RPCHandler):
         for i, trade in enumerate(trades):
             stat_line = (
                 f"{i+1}.\t <code>{trade['mix_tag']}\t"
-                f"{round_coin_value(trade['profit_abs'], self._config['stake_currency'])} "
+                f"{fmt_coin(trade['profit_abs'], self._config['stake_currency'])} "
                 f"({trade['profit_ratio']:.2%}) "
                 f"({trade['count']})</code>\n")
 

freqtrade/util/__init__.py

@@ -1,7 +1,7 @@
 from freqtrade.util.datetime_helpers import (dt_floor_day, dt_from_ts, dt_humanize, dt_now, dt_ts,
                                              dt_ts_def, dt_utc, format_date, format_ms_time,
                                              shorten_date)
-from freqtrade.util.formatters import decimals_per_coin, round_coin_value, round_value
+from freqtrade.util.formatters import decimals_per_coin, fmt_coin, round_value
 from freqtrade.util.ft_precise import FtPrecise
 from freqtrade.util.periodic_cache import PeriodicCache
 from freqtrade.util.template_renderer import render_template, render_template_with_fallback  # noqa
@@ -22,5 +22,5 @@ __all__ = [
     'shorten_date',
     'decimals_per_coin',
     'round_value',
-    'round_coin_value',
+    'fmt_coin',
 ]

freqtrade/util/formatters.py

@@ -24,10 +24,10 @@ def round_value(value: float, decimals: int, keep_trailing_zeros=False) -> str:
     return val
 
 
-def round_coin_value(
+def fmt_coin(
         value: float, coin: str, show_coin_name=True, keep_trailing_zeros=False) -> str:
     """
-    Get price value for this coin
+    Format price value for this coin
     :param value: Value to be printed
     :param coin: Which coin are we printing the price / value for
     :param show_coin_name: Return string in format: "222.22 USDT" or "222.22"

tests/utils/test_formatters.py

@@ -1,4 +1,4 @@
-from freqtrade.util import decimals_per_coin, round_coin_value, round_value
+from freqtrade.util import decimals_per_coin, fmt_coin, round_value
 
 
 def test_decimals_per_coin():
@@ -8,21 +8,21 @@ def test_decimals_per_coin():
     assert decimals_per_coin('ETH') == 5
 
 
-def test_round_coin_value():
+def test_fmt_coin():
-    assert round_coin_value(222.222222, 'USDT') == '222.222 USDT'
+    assert fmt_coin(222.222222, 'USDT') == '222.222 USDT'
-    assert round_coin_value(222.2, 'USDT', keep_trailing_zeros=True) == '222.200 USDT'
+    assert fmt_coin(222.2, 'USDT', keep_trailing_zeros=True) == '222.200 USDT'
-    assert round_coin_value(222.2, 'USDT') == '222.2 USDT'
+    assert fmt_coin(222.2, 'USDT') == '222.2 USDT'
-    assert round_coin_value(222.12745, 'EUR') == '222.127 EUR'
+    assert fmt_coin(222.12745, 'EUR') == '222.127 EUR'
-    assert round_coin_value(0.1274512123, 'BTC') == '0.12745121 BTC'
+    assert fmt_coin(0.1274512123, 'BTC') == '0.12745121 BTC'
-    assert round_coin_value(0.1274512123, 'ETH') == '0.12745 ETH'
+    assert fmt_coin(0.1274512123, 'ETH') == '0.12745 ETH'
 
-    assert round_coin_value(222.222222, 'USDT', False) == '222.222'
+    assert fmt_coin(222.222222, 'USDT', False) == '222.222'
-    assert round_coin_value(222.2, 'USDT', False) == '222.2'
+    assert fmt_coin(222.2, 'USDT', False) == '222.2'
-    assert round_coin_value(222.00, 'USDT', False) == '222'
+    assert fmt_coin(222.00, 'USDT', False) == '222'
-    assert round_coin_value(222.12745, 'EUR', False) == '222.127'
+    assert fmt_coin(222.12745, 'EUR', False) == '222.127'
-    assert round_coin_value(0.1274512123, 'BTC', False) == '0.12745121'
+    assert fmt_coin(0.1274512123, 'BTC', False) == '0.12745121'
-    assert round_coin_value(0.1274512123, 'ETH', False) == '0.12745'
+    assert fmt_coin(0.1274512123, 'ETH', False) == '0.12745'
-    assert round_coin_value(222.2, 'USDT', False, True) == '222.200'
+    assert fmt_coin(222.2, 'USDT', False, True) == '222.200'
 
 
 def test_round_value():