From f6b7622dd287cb3ee50e8eed30e9c1202bb3ec31 Mon Sep 17 00:00:00 2001 From: Martin Milata Date: Tue, 25 Aug 2020 00:21:24 +0200 Subject: [PATCH] common/tools: add maxfee.py for updating maxfee_kb --- common/tools/README.md | 9 +++ common/tools/marketcap.py | 23 ++++--- common/tools/maxfee.py | 125 ++++++++++++++++++++++++++++++++++++++ 3 files changed, 150 insertions(+), 7 deletions(-) create mode 100644 common/tools/maxfee.py diff --git a/common/tools/README.md b/common/tools/README.md index ede0c7280..10b51b4af 100644 --- a/common/tools/README.md +++ b/common/tools/README.md @@ -85,6 +85,15 @@ See docstrings for the most important functions: `coin_info()` and `support_info The file `coindef.py` is a protobuf definition for passing coin data to Trezor from the outside. +### `marketcap.py` + +Module for obtaining market cap and price data used by `coins_details.py` and `maxfee.py`. + +### `maxfee.py` + +Updates the `maxfee_kb` coin property based on a specified maximum per-transaction fee. The command +fetches current price data from https://coinmarketcap.com/ to convert from fiat-denominated maximum +fee. # Release Workflow diff --git a/common/tools/marketcap.py b/common/tools/marketcap.py index fed82e0db..e28840b98 100644 --- a/common/tools/marketcap.py +++ b/common/tools/marketcap.py @@ -10,6 +10,7 @@ COINMAKETCAP_CACHE = os.path.join(os.path.dirname(__file__), "coinmarketcap.json COINMARKETCAP_API_BASE = "https://pro-api.coinmarketcap.com/v1/" MARKET_CAPS = {} +PRICES = {} def call(endpoint, api_key, params=None): @@ -20,7 +21,7 @@ def call(endpoint, api_key, params=None): def init(api_key, refresh=None): - global MARKET_CAPS + global MARKET_CAPS, PRICES force_refresh = refresh is True disable_refresh = refresh is False @@ -59,20 +60,24 @@ def init(api_key, refresh=None): except Exception as e: raise RuntimeError("market cap data unavailable") from e - coin_data = {} + cap_data = {} + price_data = {} for coin in coinmarketcap_data["data"]: slug = coin["slug"] + symbol = coin["symbol"] platform = coin["meta"]["platform"] market_cap = coin["quote"]["USD"]["market_cap"] + price = coin["quote"]["USD"]["price"] if market_cap is not None: - coin_data[slug] = int(market_cap) + cap_data[slug] = int(market_cap) + price_data[symbol] = price if platform is not None and platform["name"] == "Ethereum": address = platform["token_address"].lower() - coin_data[address] = int(market_cap) + cap_data[address] = int(market_cap) + price_data[symbol] = price - MARKET_CAPS = coin_data - - return coin_data + MARKET_CAPS = cap_data + PRICES = price_data def marketcap(coin): @@ -89,3 +94,7 @@ def marketcap(coin): if cap is None: cap = MARKET_CAPS.get(coin["shortcut"].lower()) return cap + + +def fiat_price(coin_symbol): + return PRICES.get(coin_symbol) diff --git a/common/tools/maxfee.py b/common/tools/maxfee.py new file mode 100644 index 000000000..b1df0830a --- /dev/null +++ b/common/tools/maxfee.py @@ -0,0 +1,125 @@ +#!/usr/bin/env python3 +"""Updates maxfee_kb in given JSON coin definitions.""" +import glob +import json +import logging +import math +import os.path +import re +import sys + +import click + +import coin_info +import marketcap + +DEFAULT_SKIP_RE = ( + r"^Bitcoin$", + r"^Regtest$", + r"Testnet", +) +MAX_DELTA_PERCENT = 25 + + +def round_sats(sats, precision=1): + """ + Truncates `sats` down to a number with more trailing zeros. + + The result is comprised of `precision`+1 of leading digits followed by rest of zeros. + + >>> round_sats(123456789, precision=2) + 123000000 + >>> round_sats(123456789, precision=0) + 100000000 + """ + exp = math.floor(math.log10(sats)) + div = 10 ** (exp - precision) + return sats // div * div + + +def compute_maxfee(maxcost, price, txsize): + coins_per_tx = maxcost / price + sats_per_tx = coins_per_tx * 10 ** 8 + tx_per_kb = 1024.0 / txsize + sats_per_kb = sats_per_tx * tx_per_kb + return int(sats_per_kb) + + +def delta_percent(old, new): + return int(abs(new - old) / old * 100.0) + + +def setup_logging(verbose): + log_level = logging.DEBUG if verbose else logging.WARNING + root = logging.getLogger() + root.setLevel(log_level) + handler = logging.StreamHandler(sys.stdout) + handler.setLevel(log_level) + root.addHandler(handler) + + +@click.command() +# fmt: off +@click.argument("filename", nargs=-1, type=click.Path(writable=True)) +@click.option("-m", "--cost", type=float, default=10.0, show_default=True, help="Maximum transaction fee in USD") +@click.option("-s", "--txsize", type=int, default=250, show_default=True, help="Transaction size in bytes") +@click.option("-S", "--skip", type=str, multiple=True, help="Regex of coin name to skip, can be used multiple times") +@click.option("-r", "--refresh", "refresh", flag_value=True, default=None, help="Force refresh market cap info") +@click.option("-R", "--no-refresh", "refresh", flag_value=False, default=None, help="Force use cached market cap info") +@click.option("-A", "--api-key", required=True, envvar="COINMARKETCAP_API_KEY", help="Coinmarketcap API key") +@click.option("-v", "--verbose", is_flag=True, help="Display more info") +# fmt: on +def main(filename, cost, skip, txsize, refresh, api_key, verbose): + """ + Updates maxfee_kb in JSON coin definitions. + + The new value is calculated from the --cost argument which specifies maximum + transaction fee in fiat denomination. The fee is converted to coin value + using current price data. Then per-kilobyte fee is computed using given + transaction size. + + If no filenames are provided, all definitions except Bitcoin and testnets + are updated. + """ + setup_logging(verbose) + marketcap.init(api_key, refresh=refresh) + + if len(filename) > 0: + coin_files = filename + else: + coin_files = glob.glob(os.path.join(coin_info.DEFS_DIR, "bitcoin", "*.json")) + if len(skip) == 0: + skip = DEFAULT_SKIP_RE + + for filename in sorted(coin_files): + coin = coin_info.load_json(filename) + short = coin["coin_shortcut"] + + if any(re.search(s, coin["coin_name"]) is not None for s in skip): + logging.warning("{}:\tskipping because --skip matches".format(short)) + continue + + price = marketcap.fiat_price(short) + if price is None: + logging.error("{}:\tno price data, skipping".format(short)) + continue + + old_maxfee_kb = coin["maxfee_kb"] + new_maxfee_kb = round_sats(compute_maxfee(cost, price, txsize)) + if old_maxfee_kb != new_maxfee_kb: + coin["maxfee_kb"] = new_maxfee_kb + with open(filename, "w") as fh: + json.dump(coin, fh, indent=2) + fh.write("\n") + logging.info( + "{}:\tupdated {} -> {}".format(short, old_maxfee_kb, new_maxfee_kb) + ) + delta = delta_percent(old_maxfee_kb, new_maxfee_kb) + if delta > MAX_DELTA_PERCENT: + logging.warning("{}:\tprice has changed by {} %".format(short, delta)) + else: + logging.info("{}:\tno change".format(short)) + + +if __name__ == "__main__": + main()