mmgen/mmgen-wallet
1
0
Fork 0
Code Issues Pull requests Projects Releases 28 Packages Wiki Activity
mmgen-wallet/test/altcointest.py

465 lines
13 KiB
Python
Executable file
Raw Permalink Blame History

#!/usr/bin/env python3
#
# mmgen = Multi-Mode GENerator, a command-line 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': (
'BCH',
# broken: PIVX
'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 )
Reference in a new issue View git blame Copy permalink