mmgen-wallet/test/altcointest.py

#!/usr/bin/env python3
#
# MMGen Wallet, a terminal-based cryptocurrency wallet
# Copyright (C)2013-2024 The MMGen Project <mmgen@tuta.io>
# Licensed under the GNU General Public License, Version 3:
#   https://www.gnu.org/licenses
# Public project repositories:
#   https://github.com/mmgen/mmgen-wallet
#   https://gitlab.com/mmgen/mmgen-wallet

"""
altcointest.py - Test constants for Bitcoin-derived altcoins
"""

import sys

try:
	from include import test_init
except ImportError:
	from test.include import test_init

from mmgen.cfg import gc, Config
from mmgen.util import msg
from mmgen.altcoin.params import CoinInfo

def test_equal(desc, a, b, *cdata):
	if type(a) is int:
		a = hex(a)
		b = hex(b)
	(network, coin, _, b_desc, verbose) = cdata
	if verbose:
		msg(f'  {desc:20}: {a!r}')
	if a != b:
		raise ValueError(
			f'{desc.capitalize()}s for {coin.upper()} {network} do not match:\n  CoinInfo: {a}\n  {b_desc}: {b}')

class TestCoinInfo(CoinInfo):

	# Sources (see CoinInfo) that are in agreement for these coins
	# No check for segwit, p2sh check skipped if source doesn't support it
	cross_checks = {
		'2GIVE':  ['wn'],
		'42':     ['vg', 'wn'],
		'611':    ['wn'],
		'AC':     ['lb', 'vg'],
		'ACOIN':  ['wn'],
		'ALF':    ['wn'],
		'ANC':    ['vg', 'wn'],
		'APEX':   ['wn'],
		'ARCO':   ['wn'],
		'ARG':    ['pc'],
		'AUR':    ['vg', 'wn'],
		'BCH':    ['wn'],
		'BLK':    ['lb', 'vg', 'wn'],
		'BQC':    ['vg', 'wn'],
		'BSTY':   ['wn'],
		'BTC':    ['lb', 'vg', 'wn'],
		'BTCD':   ['lb', 'vg', 'wn'],
		'BUCKS':  ['wn'],
		'CASH':   ['wn'],
		'CBX':    ['wn'],
		'CCN':    ['lb', 'vg', 'wn'],
		'CDN':    ['lb', 'vg', 'wn'],
		'CHC':    ['wn'],
		'CLAM':   ['lb', 'vg'],
		'CON':    ['vg', 'wn'],
		'CPC':    ['wn'],
		'DASH':   ['lb', 'pc', 'vg', 'wn'],
		'DCR':    ['pc'],
		'DFC':    ['pc'],
		'DGB':    ['lb', 'vg'],
		'DGC':    ['lb', 'vg', 'wn'],
		'DOGE':   ['lb', 'pc', 'vg', 'wn'],
		'DOGED':  ['lb', 'vg', 'wn'],
		'DOPE':   ['lb', 'vg'],
		'DVC':    ['vg', 'wn'],
		'EFL':    ['lb', 'vg', 'wn'],
		'EMC':    ['vg'],
		'EMD':    ['wn'],
		'ESP':    ['wn'],
		'FAI':    ['pc'],
		'FC2':    ['wn'],
		'FIBRE':  ['wn'],
		'FJC':    ['wn'],
		'FLO':    ['wn'],
		'FLT':    ['wn'],
		'FST':    ['wn'],
		'FTC':    ['lb', 'pc', 'vg', 'wn'],
		'GCR':    ['lb', 'vg'],
		'GOOD':   ['wn'],
		'GRC':    ['vg', 'wn'],
		'GUN':    ['vg', 'wn'],
		'HAM':    ['vg', 'wn'],
		'HTML5':  ['wn'],
		'HYP':    ['wn'],
		'ICASH':  ['wn'],
		'INFX':   ['wn'],
		'IPC':    ['wn'],
		'JBS':    ['lb', 'pc', 'vg', 'wn'],
		'JUDGE':  ['wn'],
		'LANA':   ['wn'],
		'LAT':    ['wn'],
		'LDOGE':  ['wn'],
		'LMC':    ['wn'],
		'LTC':    ['lb', 'vg', 'wn'],
		'MARS':   ['wn'],
		'MEC':    ['pc', 'wn'],
		'MINT':   ['wn'],
		'MOBI':   ['wn'],
		'MONA':   ['lb', 'vg'],
		'MOON':   ['wn'],
		'MUE':    ['lb', 'vg'],
		'MXT':    ['wn'],
		'MYR':    ['pc'],
		'MYRIAD': ['vg', 'wn'],
		'MZC':    ['lb', 'pc', 'vg', 'wn'],
		'NEOS':   ['lb', 'vg'],
		'NEVA':   ['wn'],
		'NKA':    ['wn'],
		'NLG':    ['vg', 'wn'],
		'NMC':    ['lb', 'vg'],
		'NVC':    ['lb', 'vg', 'wn'],
		'OK':     ['lb', 'vg'],
		'OMC':    ['vg', 'wn'],
		'ONION':  ['vg', 'wn'],
		'PART':   ['wn'],
		'PINK':   ['vg', 'wn'],
		'PIVX':   ['wn'],
		'PKB':    ['lb', 'vg', 'wn'],
		'PND':    ['lb', 'vg', 'wn'],
		'POT':    ['lb', 'vg', 'wn'],
		'PPC':    ['lb', 'vg', 'wn'],
		'PTC':    ['vg', 'wn'],
		'PXC':    ['wn'],
		'QRK':    ['wn'],
		'RAIN':   ['wn'],
		'RBT':    ['wn'],
		'RBY':    ['lb', 'vg'],
		'RDD':    ['vg', 'wn'],
		'RIC':    ['pc', 'vg', 'wn'],
		'SDC':    ['lb', 'vg'],
		'SIB':    ['wn'],
		'SMLY':   ['wn'],
		'SONG':   ['wn'],
		'SPR':    ['vg', 'wn'],
		'START':  ['lb', 'vg'],
		'SYS':    ['wn'],
		'TAJ':    ['wn'],
		'TIT':    ['wn'],
		'TPC':    ['lb', 'vg'],
		'TRC':    ['wn'],
		'TTC':    ['wn'],
		'TX':     ['wn'],
		'UNO':    ['pc', 'vg', 'wn'],
		'VIA':    ['lb', 'pc', 'vg', 'wn'],
		'VPN':    ['lb', 'vg'],
		'VTC':    ['lb', 'vg', 'wn'],
		'WDC':    ['vg', 'wn'],
		'WISC':   ['wn'],
		'WKC':    ['vg', 'wn'],
		'WSX':    ['wn'],
		'XCN':    ['wn'],
		'XGB':    ['wn'],
		'XPM':    ['lb', 'vg', 'wn'],
		'XST':    ['wn'],
		'XVC':    ['wn'],
		'ZET':    ['wn'],
		'ZOOM':   ['lb', 'vg'],
		'ZRC':    ['lb', 'vg']
	}

	@classmethod
	def verify_leading_symbols(cls, quiet=False, verbose=False):

		for network in ('mainnet', 'testnet'):
			for coin in [e.symbol for e in cls.coin_constants[network]]:
				e = cls.get_entry(coin, network)
				cdata = (network, coin, e, 'Computed value', verbose)

				if not quiet:
					msg(f'{coin} {network}')

				vn_info = e.p2pkh_info
				ret = cls.find_addr_leading_symbol(vn_info[0])
				test_equal('P2PKH leading symbol', vn_info[1], ret, *cdata)

				vn_info = e.p2sh_info
				if vn_info:
					ret = cls.find_addr_leading_symbol(vn_info[0])
					test_equal('P2SH leading symbol', vn_info[1], ret, *cdata)

	@classmethod
	def verify_core_coin_data(cls, cfg, quiet=False, verbose=False):
		from mmgen.protocol import CoinProtocol, init_proto

		for network in ('mainnet', 'testnet'):
			for coin in gc.core_coins:
				e = cls.get_entry(coin, network)
				if e:
					proto = init_proto(cfg, coin, network=network)
					cdata = (network, coin, e, type(proto).__name__, verbose)
					if not quiet:
						msg(f'Verifying {coin.upper()} {network}')

					if coin != 'bch': # TODO
						test_equal('coin name', e.name, proto.name, *cdata)

					if e.trust_level != -1:
						test_equal('Trust level', e.trust_level, CoinProtocol.coins[coin].trust_level, *cdata)

					test_equal(
						'WIF version number',
						e.wif_ver_num,
						int.from_bytes(proto.wif_ver_bytes['std'], 'big'),
						*cdata)

					test_equal(
						'P2PKH version number',
						e.p2pkh_info[0],
						int.from_bytes(proto.addr_fmt_to_ver_bytes['p2pkh'], 'big'),
						*cdata)

					test_equal(
						'P2SH version number',
						e.p2sh_info[0],
						int.from_bytes(proto.addr_fmt_to_ver_bytes['p2sh'], 'big'),
						*cdata)

	# Data is one of the coin_constants lists above.  Normalize ints to hex of correct width, add
	# missing leading letters, set trust level from external_tests.
	# Insert a coin entry from outside source, set version info leading letters to '?' and trust level
	# to 0, then run TestCoinInfo.fix_table(data).  'has_segwit' field is updated manually for now.
	@classmethod
	def fix_table(cls, data):
		import re

		def myhex(n):
			return '0x{:0{}x}'.format(n, 2 if n < 256 else 4)

		def fix_ver_info(e, k):
			e[k] = list(e[k])
			e[k][0] = myhex(e[k][0])
			s1 = cls.find_addr_leading_symbol(int(e[k][0][2:], 16))
			m = f'Fixing leading address letter for coin {e["symbol"]} ({e[k][1]!r} --> {s1})'
			if e[k][1] != '?':
				assert s1 == e[k][1], f'First letters do not match! {m}'
			else:
				msg(m)
				e[k][1] = s1
			e[k] = tuple(e[k])

		old_sym = None
		for sym in sorted([e.symbol for e in data]):
			if sym == old_sym:
				msg(f'{sym!r}: duplicate coin symbol in data!')
				sys.exit(2)
			old_sym = sym

		tt = cls.create_trust_table()

		name_w = max(len(e.name) for e in data)
		fs = '\t({:%s} {:10} {:7} {:17} {:17} {:6} {}),' % (name_w+3)
		for e in data:
			e = e._asdict()
			e['wif_ver_num'] = myhex(e['wif_ver_num'])
			sym, trust = e['symbol'], e['trust_level']

			fix_ver_info(e, 'p2pkh_info')
			if isinstance(e['p2sh_info'], tuple):
				fix_ver_info(e, 'p2sh_info')

			for k in e.keys():
				e[k] = repr(e[k])
				e[k] = re.sub(r"'0x(..)'", r'0x\1', e[k])
				e[k] = re.sub(r"'0x(....)'", r'0x\1', e[k])
				e[k] = re.sub(r' ', r'', e[k]) + ('', ',')[k != 'trust_level']

			if trust != -1:
				if sym in tt:
					src = tt[sym]
					if src != trust:
						msg(f'Updating trust for coin {sym!r}: {trust} -> {src}')
						e['trust_level'] = src
				else:
					if trust != 0:
						msg(f'Downgrading trust for coin {sym!r}: {trust} -> 0')
						e['trust_level'] = 0

				if sym in cls.cross_checks:
					if int(e['trust_level']) == 0 and len(cls.cross_checks[sym]) > 1:
						msg(f'Upgrading trust for coin {sym!r}: {e["trust_level"]} -> 1')
						e['trust_level'] = 1

			print(fs.format(*e.values()))
		msg(f'Processed {len(data)} entries')

	@classmethod
	def find_addr_leading_symbol(cls, ver_num, verbose=False):

		if ver_num == 0:
			return '1'

		def phash2addr(ver_num, pk_hash):
			from mmgen.proto.btc.common import b58chk_encode
			bl = ver_num.bit_length()
			ver_bytes = int.to_bytes(ver_num, bl//8 + bool(bl%8), 'big')
			return b58chk_encode(ver_bytes + pk_hash)

		low = phash2addr(ver_num, b'\x00'*20)
		high = phash2addr(ver_num, b'\xff'*20)

		if verbose:
			print('low address:  ' + low)
			print('high address: ' + high)

		l1, h1 = low[0], high[0]
		return (l1, h1) if l1 != h1 else l1

	@classmethod
	def print_symbols(cls, include_names=False, reverse=False):
		for e in cls.coin_constants['mainnet']:
			if reverse:
				print(f'{e.symbol:6} {e.name}')
			else:
				name_w = max(len(e.name) for e in cls.coin_constants['mainnet'])
				print((f'{e.name:{name_w}} ' if include_names else '') + e.symbol)

	@classmethod
	def create_trust_table(cls):
		tt = {}
		mn = cls.external_tests['mainnet']
		for ext_prog in mn:
			assert len(set(mn[ext_prog])) == len(mn[ext_prog]), f'Duplicate entry in {ext_prog!r}!'
			for coin in mn[ext_prog]:
				if coin in tt:
					tt[coin] += 1
				else:
					tt[coin] = 1
		for k in cls.trust_override:
			tt[k] = cls.trust_override[k]
		return tt

	trust_override = {'BTC':3, 'BCH':3, 'LTC':3, 'DASH':1, 'EMC':2}

	@classmethod
	def get_test_support(cls, coin, addr_type, network, toolname=None, verbose=False):
		"""
		If requested tool supports coin/addr_type/network triplet, return tool name.
		If 'tool' is None, return tool that supports coin/addr_type/network triplet.
		Return None on failure.
		"""
		all_tools = [toolname] if toolname else list(cls.external_tests[network].keys())
		coin = coin.upper()

		for tool in all_tools:
			if coin in cls.external_tests[network][tool]:
				break
		else:
			if verbose:
				m1 = 'Requested tool {t!r} does not support coin {c} on network {n}'
				m2 = 'No test tool found for coin {c} on network {n}'
				msg((m1 if toolname else m2).format(t=tool, c=coin, n=network))
			return None

		if addr_type == 'zcash_z':
			if toolname in (None, 'zcash-mini'):
				return 'zcash-mini'
			else:
				if verbose:
					msg(f"Address type {addr_type!r} supported only by tool 'zcash-mini'")
				return None

		try:
			bl = cls.external_tests_blacklist[addr_type][tool]
		except:
			pass
		else:
			if bl is True or coin in bl:
				if verbose:
					msg(f'Tool {tool!r} blacklisted for coin {coin}, addr_type {addr_type!r}')
				return None

		if toolname: # skip whitelists
			return tool

		if addr_type in ('segwit', 'bech32'):
			st = cls.external_tests_segwit_whitelist
			if addr_type in st and coin in st[addr_type]:
				return tool
			else:
				if verbose:
					m1 = 'Requested tool {t!r} does not support coin {c}, addr_type {a!r}, on network {n}'
					m2 = 'No test tool found supporting coin {c}, addr_type {a!r}, on network {n}'
					msg((m1 if toolname else m2).format(t=tool, c=coin, n=network, a=addr_type))
				return None

		return tool

	external_tests = {
		'mainnet': {
			# List in order of preference.
			# If 'tool' is not specified, the first tool supporting the coin will be selected.
			'pycoin': (
				'DASH', # only compressed
				'BCH',
				'BTC', 'LTC', 'VIA', 'FTC', 'DOGE', 'MEC',
				'JBS', 'MZC', 'RIC', 'DFC', 'FAI', 'ARG', 'ZEC', 'DCR'),
			'keyconv': ( # broken: PIVX
				'BCH', '42', 'AC', 'AIB', 'ANC', 'ARS', 'ATMOS', 'AUR', 'BLK', 'BQC', 'BTC', 'TEST',
				'BTCD', 'CCC', 'CCN', 'CDN', 'CLAM', 'CNC', 'CNOTE', 'CON', 'CRW', 'DEEPONION', 'DGB',
				'DGC', 'DMD', 'DOGED', 'DOGE', 'DOPE', 'DVC', 'EFL', 'EMC', 'EXCL', 'FAIR', 'FLOZ', 'FTC',
				'GAME', 'GAP', 'GCR', 'GRC', 'GRS', 'GUN', 'HAM', 'HODL', 'IXC', 'JBS', 'LBRY', 'LEAF',
				'LTC', 'MMC', 'MONA', 'MUE', 'MYRIAD', 'MZC', 'NEOS', 'NLG', 'NMC', 'NVC', 'NYAN', 'OK',
				'OMC', 'PIGGY', 'PINK', 'PKB', 'PND', 'POT', 'PPC', 'PTC', 'PTS', 'QTUM', 'RBY', 'RDD',
				'RIC', 'SCA', 'SDC', 'SKC', 'SPR', 'START', 'SXC', 'TPC', 'UIS', 'UNO', 'VIA', 'VPN',
				'VTC', 'WDC', 'WKC', 'WUBS', 'XC', 'XPM', 'YAC', 'ZOOM', 'ZRC'),
			'ethkey': ('ETH', 'ETC'),
			'zcash-mini': ('ZEC',),
			'monero-python': ('XMR',),
		},
		'testnet': {
			'pycoin': {
				'DASH':'tDASH', # only compressed
				'BCH':'XTN',
				'BTC':'XTN', 'LTC':'XLT', 'VIA':'TVI', 'FTC':'FTX', 'DOGE':'XDT', 'DCR':'DCRT'
				},
			'ethkey': {},
			'keyconv': {}
		}
	}
	external_tests_segwit_whitelist = {
		# Whitelists apply to the *first* tool in cls.external_tests supporting the given coin/addr_type.
		# They're ignored if specific tool is requested.
		'segwit': ('BTC',), # LTC Segwit broken on pycoin: uses old fmt
		'bech32': ('BTC', 'LTC'),
		'compressed': (
			'BTC', 'LTC', 'VIA', 'FTC', 'DOGE', 'DASH', 'MEC', 'MYR', 'UNO',
			'JBS', 'MZC', 'RIC', 'DFC', 'FAI', 'ARG', 'ZEC', 'DCR', 'ZEC'
		),
	}
	external_tests_blacklist = {
		# Unconditionally block testing of the given coin/addr_type with given tool, or all coins if True
		'legacy': {},
		'segwit': {'keyconv': True},
		'bech32': {'keyconv': True},
	}

if __name__ == '__main__':

	opts_data = {
		'text': {
			'desc': 'Check altcoin data',
			'usage':'[opts]',
			'options': '-q, --quiet    Be quieter\n-v, --verbose  Be more verbose'
		}
	}

	cfg = Config(opts_data=opts_data, need_amt=False)

	msg('Checking CoinInfo WIF/P2PKH/P2SH version numbers and trust levels against protocol.py')
	TestCoinInfo.verify_core_coin_data(cfg, cfg.quiet, cfg.verbose)

	msg('Checking CoinInfo address leading symbols')
	TestCoinInfo.verify_leading_symbols(cfg.quiet, cfg.verbose)