whitespace: proto (other)

mmgen/proto/bch/cashaddr.py

@@ -33,7 +33,7 @@ cashaddr_addr_types = {
 	'token_script': 3,
 	'unknown':      15,
 }
-addr_types_rev = {v:k for k,v in cashaddr_addr_types.items()}
+addr_types_rev = {v:k for k, v in cashaddr_addr_types.items()}
 
 data_sizes = (160, 192, 224, 256, 320, 384, 448, 512)
 

mmgen/proto/bch/params.py

@@ -20,10 +20,10 @@ from .cashaddr import cashaddr_decode_addr, cashaddr_encode_addr, cashaddr_addr_
 
 class mainnet(mainnet):
 	is_fork_of      = 'Bitcoin'
-	mmtypes         = ('L','C')
+	mmtypes         = ('L', 'C')
 	sighash_type    = 'ALL|FORKID'
 	forks = [
-		_finfo(478559,'000000000000000000651ef99cb9fcbe0dadde1d424bd9f15ff20136191a5eec','BTC',False)
+		_finfo(478559, '000000000000000000651ef99cb9fcbe0dadde1d424bd9f15ff20136191a5eec', 'BTC', False)
 	]
 	caps = ()
 	coin_amt        = 'BCHAmt'
@@ -74,15 +74,15 @@ class mainnet(mainnet):
 				if self.cfg.cashaddr else
 			b58chk_encode(self.addr_fmt_to_ver_bytes[addr_type] + pubhash))
 
-	def pubhash2redeem_script(self,pubhash):
+	def pubhash2redeem_script(self, pubhash):
 		raise NotImplementedError
 
-	def pubhash2segwitaddr(self,pubhash):
+	def pubhash2segwitaddr(self, pubhash):
 		raise NotImplementedError
 
 class testnet(mainnet):
-	addr_ver_info  = { '6f': 'p2pkh', 'c4': 'p2sh' }
-	wif_ver_num    = { 'std': 'ef' }
+	addr_ver_info  = {'6f': 'p2pkh', 'c4': 'p2sh'}
+	wif_ver_num    = {'std': 'ef'}
 	cashaddr_pfx   = 'bchtest'
 
 class regtest(testnet):

mmgen/proto/etc/params.py

@@ -15,13 +15,13 @@ proto.etc.params: Ethereum Classic protocol
 from ..eth.params import mainnet
 
 class mainnet(mainnet):
-	chain_names = ['classic','ethereum_classic']
+	chain_names = ['classic', 'ethereum_classic']
 	max_tx_fee  = '0.005'
 	coin_amt    = 'ETCAmt'
 	ignore_daemon_version = False
 
 class testnet(mainnet):
-	chain_names = ['morden','morden_testnet','classic-testnet']
+	chain_names = ['morden', 'morden_testnet', 'classic-testnet']
 
 class regtest(testnet):
 	chain_names = ['developmentchain']

mmgen/proto/ltc/params.py

@@ -16,9 +16,9 @@ from ..btc.params import mainnet
 
 class mainnet(mainnet):
 	block0          = '12a765e31ffd4059bada1e25190f6e98c99d9714d334efa41a195a7e7e04bfe2'
-	addr_ver_info   = { '30': 'p2pkh', '05': 'p2sh', '32': 'p2sh' } # new p2sh ver 0x32 must come last
-	wif_ver_num     = { 'std': 'b0' }
-	mmtypes         = ('L','C','S','B')
+	addr_ver_info   = {'30': 'p2pkh', '05': 'p2sh', '32': 'p2sh'} # new p2sh ver 0x32 must come last
+	wif_ver_num     = {'std': 'b0'}
+	mmtypes         = ('L', 'C', 'S', 'B')
 	coin_amt        = 'LTCAmt'
 	max_tx_fee      = '0.3'
 	base_coin       = 'LTC'
@@ -30,8 +30,8 @@ class mainnet(mainnet):
 
 class testnet(mainnet):
 	# addr ver nums same as Bitcoin testnet, except for 'p2sh'
-	addr_ver_info      = { '6f':'p2pkh', 'c4':'p2sh', '3a':'p2sh' }
-	wif_ver_num        = { 'std': 'ef' } # same as Bitcoin testnet
+	addr_ver_info      = {'6f': 'p2pkh', 'c4': 'p2sh', '3a': 'p2sh'}
+	wif_ver_num        = {'std': 'ef'} # same as Bitcoin testnet
 	bech32_hrp         = 'tltc'
 
 class regtest(testnet):

mmgen/proto/secp256k1/keygen.py

@@ -15,10 +15,10 @@ proto.secp256k1.keygen: secp256k1 public key generation backends for the MMGen s
 from ...key import PubKey
 from ...keygen import keygen_base
 
-def pubkey_format(vk_bytes,compressed):
+def pubkey_format(vk_bytes, compressed):
 	# if compressed, discard Y coord, replace with appropriate version byte
 	# even y: <0, odd y: >0 -- https://bitcointalk.org/index.php?topic=129652.0
-	return (b'\x02',b'\x03')[vk_bytes[-1] & 1] + vk_bytes[:32] if compressed else b'\x04' + vk_bytes
+	return (b'\x02', b'\x03')[vk_bytes[-1] & 1] + vk_bytes[:32] if compressed else b'\x04' + vk_bytes
 
 class backend:
 
@@ -26,24 +26,24 @@ class backend:
 
 		production_safe = True
 
-		def __init__(self,cfg):
+		def __init__(self, cfg):
 			super().__init__(cfg)
 			from .secp256k1 import pubkey_gen
 			self.pubkey_gen = pubkey_gen
 
-		def to_pubkey(self,privkey):
+		def to_pubkey(self, privkey):
 			return PubKey(
-				s = self.pubkey_gen( privkey, int(privkey.compressed) ),
-				compressed = privkey.compressed )
+				s = self.pubkey_gen(privkey, int(privkey.compressed)),
+				compressed = privkey.compressed)
 
 		@classmethod
-		def get_clsname(cls,cfg,silent=False):
+		def get_clsname(cls, cfg, silent=False):
 			try:
 				from .secp256k1 import pubkey_gen
-				if not pubkey_gen(bytes.fromhex('deadbeef'*8),1):
+				if not pubkey_gen(bytes.fromhex('deadbeef'*8), 1):
 					from ...util import die
-					die( 'ExtensionModuleError',
-						'Unable to execute pubkey_gen() from secp256k1 extension module' )
+					die('ExtensionModuleError',
+						'Unable to execute pubkey_gen() from secp256k1 extension module')
 				return cls.__name__
 			except ImportError as e:
 				if not silent:
@@ -56,22 +56,22 @@ class backend:
 
 		production_safe = False
 
-		def __init__(self,cfg):
+		def __init__(self, cfg):
 			super().__init__(cfg)
 			import ecdsa
 			self.ecdsa = ecdsa
 
-		def to_pubkey(self,privkey):
+		def to_pubkey(self, privkey):
 			"""
 			devdoc/guide_wallets.md:
 			Uncompressed public keys start with 0x04; compressed public keys begin with 0x03 or
 			0x02 depending on whether they're greater or less than the midpoint of the curve.
 			"""
-			def privnum2pubkey(numpriv,compressed=False):
-				pk = self.ecdsa.SigningKey.from_secret_exponent(numpriv,curve=self.ecdsa.SECP256k1)
+			def privnum2pubkey(numpriv, compressed=False):
+				pk = self.ecdsa.SigningKey.from_secret_exponent(numpriv, curve=self.ecdsa.SECP256k1)
 				# vk_bytes = x (32 bytes) + y (32 bytes) (unsigned big-endian)
-				return pubkey_format(pk.verifying_key.to_string(),compressed)
+				return pubkey_format(pk.verifying_key.to_string(), compressed)
 
 			return PubKey(
-				s = privnum2pubkey( int.from_bytes(privkey,'big'), compressed=privkey.compressed ),
-				compressed = privkey.compressed )
+				s = privnum2pubkey(int.from_bytes(privkey, 'big'), compressed=privkey.compressed),
+				compressed = privkey.compressed)

mmgen/proto/zec/addrgen.py

@@ -12,22 +12,22 @@
 proto.zec.addrgen: Zcash-Z address generation class for the MMGen suite
 """
 
-from ...addrgen import addr_generator,check_data
+from ...addrgen import addr_generator, check_data
 from ...addr import CoinAddr
 from ..btc.common import b58chk_encode
 
 class zcash_z(addr_generator.base):
 
 	@check_data
-	def to_addr(self,data):
+	def to_addr(self, data):
 		ret = b58chk_encode(
 			self.proto.addr_fmt_to_ver_bytes['zcash_z']
-			+ data.pubkey )
-		return CoinAddr( self.proto, ret )
+			+ data.pubkey)
+		return CoinAddr(self.proto, ret)
 
 	@check_data
-	def to_viewkey(self,data):
+	def to_viewkey(self, data):
 		return self.proto.viewkey(
 			b58chk_encode(
 				self.proto.addr_fmt_to_ver_bytes['viewkey']
-				+ data.viewkey_bytes ) )
+				+ data.viewkey_bytes))

mmgen/proto/zec/keygen.py

@@ -21,28 +21,28 @@ class backend:
 
 		production_safe = True
 
-		def __init__(self,cfg):
+		def __init__(self, cfg):
 			super().__init__(cfg)
 			from nacl.bindings import crypto_scalarmult_base
 			self.crypto_scalarmult_base = crypto_scalarmult_base
 			from ...sha2 import Sha256
 			self.Sha256 = Sha256
 
-		def zhash256(self,s,t):
+		def zhash256(self, s, t):
 			s = bytearray(s + bytes(32))
 			s[0] |= 0xc0
 			s[32] = t
-			return self.Sha256(s,preprocess=False).digest()
+			return self.Sha256(s, preprocess=False).digest()
 
-		def to_pubkey(self,privkey):
+		def to_pubkey(self, privkey):
 			return PubKey(
-				self.zhash256(privkey,0)
-				+ self.crypto_scalarmult_base(self.zhash256(privkey,1)),
+				self.zhash256(privkey, 0)
+				+ self.crypto_scalarmult_base(self.zhash256(privkey, 1)),
 				compressed = privkey.compressed
 			)
 
-		def to_viewkey(self,privkey):
-			vk = bytearray( self.zhash256(privkey,0) + self.zhash256(privkey,1) )
+		def to_viewkey(self, privkey):
+			vk = bytearray(self.zhash256(privkey, 0) + self.zhash256(privkey, 1))
 			vk[32] &= 0xf8
 			vk[63] &= 0x7f
 			vk[63] |= 0x40

mmgen/proto/zec/params.py

@@ -21,19 +21,19 @@ class ZcashViewKey(CoinAddr):
 
 class mainnet(mainnet):
 	base_coin      = 'ZEC'
-	addr_ver_info  = { '1cb8': 'p2pkh', '1cbd': 'p2sh', '169a': 'zcash_z', 'a8abd3': 'viewkey' }
-	wif_ver_num    = { 'std': '80', 'zcash_z': 'ab36' }
-	pubkey_types   = ('std','zcash_z')
-	mmtypes        = ('L','C','Z')
+	addr_ver_info  = {'1cb8': 'p2pkh', '1cbd': 'p2sh', '169a': 'zcash_z', 'a8abd3': 'viewkey'}
+	wif_ver_num    = {'std': '80', 'zcash_z': 'ab36'}
+	pubkey_types   = ('std', 'zcash_z')
+	mmtypes        = ('L', 'C', 'Z')
 	mmcaps         = ()
 	dfl_mmtype     = 'L'
 	avg_bdi        = 75
 
-	def __init__(self,*args,**kwargs):
-		super().__init__(*args,**kwargs)
-		self.coin_id = 'ZEC-Z' if self.cfg.type in ('zcash_z','Z') else 'ZEC-T'
+	def __init__(self, *args, **kwargs):
+		super().__init__(*args, **kwargs)
+		self.coin_id = 'ZEC-Z' if self.cfg.type in ('zcash_z', 'Z') else 'ZEC-T'
 
-	def get_wif_ver_bytes_len(self,key_data):
+	def get_wif_ver_bytes_len(self, key_data):
 		"""
 		vlen must be set dynamically since Zcash has variable-length version bytes
 		"""
@@ -42,14 +42,14 @@ class mainnet(mainnet):
 				return len(v)
 		raise ValueError('Invalid WIF version number')
 
-	def get_addr_len(self,addr_fmt):
-		return (20,64)[addr_fmt in ('zcash_z','viewkey')]
+	def get_addr_len(self, addr_fmt):
+		return (20, 64)[addr_fmt in ('zcash_z', 'viewkey')]
 
 	def decode_addr_bytes(self, addr_bytes):
 		"""
 		vlen must be set dynamically since Zcash has variable-length version bytes
 		"""
-		for ver_bytes,addr_fmt in self.addr_ver_bytes.items():
+		for ver_bytes, addr_fmt in self.addr_ver_bytes.items():
 			vlen = len(ver_bytes)
 			if addr_bytes[:vlen] == ver_bytes:
 				if len(addr_bytes[vlen:]) == self.get_addr_len(addr_fmt):
@@ -57,13 +57,13 @@ class mainnet(mainnet):
 
 		return False
 
-	def preprocess_key(self,sec,pubkey_type):
+	def preprocess_key(self, sec, pubkey_type):
 		if pubkey_type == 'zcash_z': # zero the first four bits
 			return bytes([sec[0] & 0x0f]) + sec[1:]
 		else:
-			return super().preprocess_key(sec,pubkey_type)
+			return super().preprocess_key(sec, pubkey_type)
 
-	def pubhash2addr(self,pubhash, addr_type):
+	def pubhash2addr(self, pubhash, addr_type):
 		hash_len = len(pubhash)
 		if hash_len == 20:
 			return super().pubhash2addr(pubhash, addr_type)
@@ -72,9 +72,9 @@ class mainnet(mainnet):
 		else:
 			raise ValueError(f'{hash_len}: incorrect pubkey hash length')
 
-	def viewkey(self,viewkey_str):
-		return ZcashViewKey.__new__(ZcashViewKey,self,viewkey_str)
+	def viewkey(self, viewkey_str):
+		return ZcashViewKey.__new__(ZcashViewKey, self, viewkey_str)
 
 class testnet(mainnet):
-	wif_ver_num  = { 'std': 'ef', 'zcash_z': 'ac08' }
-	addr_ver_info = { '1d25': 'p2pkh', '1cba': 'p2sh', '16b6': 'zcash_z', 'a8ac0c': 'viewkey' }
+	wif_ver_num  = {'std': 'ef', 'zcash_z': 'ac08'}
+	addr_ver_info = {'1d25': 'p2pkh', '1cba': 'p2sh', '16b6': 'zcash_z', 'a8ac0c': 'viewkey'}