def dump_tx(tx, netcode, verbose_signature, disassembly_level, do_trace,
use_pdb):
address_prefix = address_prefix_for_netcode(netcode)
missing_unspents = tx.missing_unspents()
traceback_f = make_trace_script(do_trace, use_pdb)
dump_header(tx)
dump_inputs(tx, netcode, verbose_signature, address_prefix, traceback_f,
disassembly_level)
def signature_for_hash_type_f(hash_type, script):
return tx.signature_hash(script, idx, hash_type)
print("Output%s:" % ('s' if len(tx.txs_out) != 1 else ''))
for idx, tx_out in enumerate(tx.txs_out):
amount_mbtc = satoshi_to_mbtc(tx_out.coin_value)
address = tx_out.bitcoin_address(netcode=netcode) or "(unknown)"
print("%4d: %34s receives %12.5f mBTC" % (idx, address, amount_mbtc))
if disassembly_level > 0:
for (pre_annotations, pc, opcode, instruction, post_annotations) in \
disassemble_scripts(b'', tx_out.script, tx.lock_time, signature_for_hash_type_f):
for l in pre_annotations:
print(" %s" % l)
if 1:
print(" %4x: %02x %s" % (pc, opcode, instruction))
for l in post_annotations:
print(" %s" % l)
dump_footer(tx, missing_unspents)
def dump_tx(tx, netcode, verbose_signature, disassembly_level, do_trace, use_pdb):
address_prefix = address_prefix_for_netcode(netcode)
missing_unspents = tx.missing_unspents()
traceback_f = make_trace_script(do_trace, use_pdb)
dump_header(tx)
dump_inputs(tx, netcode, verbose_signature, address_prefix, traceback_f, disassembly_level)
def signature_for_hash_type_f(hash_type, script):
return tx.signature_hash(script, idx, hash_type)
print("Output%s:" % ('s' if len(tx.txs_out) != 1 else ''))
for idx, tx_out in enumerate(tx.txs_out):
amount_mbtc = satoshi_to_mbtc(tx_out.coin_value)
address = tx_out.bitcoin_address(netcode=netcode) or "(unknown)"
print("%4d: %34s receives %12.5f mBTC" % (idx, address, amount_mbtc))
if disassembly_level > 0:
for (pre_annotations, pc, opcode, instruction, post_annotations) in \
disassemble_scripts(b'', tx_out.script, tx.lock_time, signature_for_hash_type_f):
for l in pre_annotations:
print(" %s" % l)
if 1:
print(" %4x: %02x %s" % (pc, opcode, instruction))
for l in post_annotations:
print(" %s" % l)
dump_footer(tx, missing_unspents)
def addresses_f(self, netcode=None):
from pycoin.networks import address_prefix_for_netcode
address_prefix = address_prefix_for_netcode(netcode)
addresses = [
encoding.hash160_sec_to_bitcoin_address(
h1, address_prefix=address_prefix) for h1 in self.hash160s()
]
return addresses
def address_f(netcode=netcode):
from pycoin.networks import address_prefix_for_netcode
from pycoin.networks.default import get_current_netcode
if netcode is None:
netcode = get_current_netcode()
address_prefix = address_prefix_for_netcode(netcode)
address = encoding.hash160_sec_to_bitcoin_address(self.hash160, address_prefix=address_prefix)
return address
def address_f(netcode=netcode):
from pycoin.networks import address_prefix_for_netcode
from pycoin.networks.default import get_current_netcode
if netcode is None:
netcode = get_current_netcode()
address_prefix = address_prefix_for_netcode(netcode)
address = encoding.hash160_sec_to_bitcoin_address(hash160, address_prefix=address_prefix)
return address
def addresses_f(self, netcode=None):
from pycoin.networks import address_prefix_for_netcode
from pycoin.networks.default import get_current_netcode
if netcode is None:
netcode = get_current_netcode()
address_prefix = address_prefix_for_netcode(netcode)
addresses = [encoding.hash160_sec_to_bitcoin_address(h1, address_prefix=address_prefix)
for h1 in self.hash160s()]
return addresses
def spendables_for_address(self, address):
if address == "mgMy4vmqChGT8XeKPb1zD6RURWsiNmoNvR":
script = ScriptPayToAddress(
bitcoin_address_to_hash160_sec(address, address_prefix_for_netcode('XTN')))
return [Spendable(coin_value=10000,
script=script.script(),
tx_out_index=0, tx_hash=b'2'*32)]
else:
return []
def address(self, use_uncompressed=None):
"""
Return the public address representation of this key, if available.
If use_uncompressed is not set, the preferred representation is returned.
"""
address_prefix = address_prefix_for_netcode(self._netcode)
hash160 = self.hash160(use_uncompressed=use_uncompressed)
if hash160:
return hash160_sec_to_bitcoin_address(hash160, address_prefix=address_prefix)
return None
def address(self, use_uncompressed=None):
"""
Return the public address representation of this key, if available.
If use_uncompressed is not set, the preferred representation is returned.
"""
address_prefix = address_prefix_for_netcode(self._netcode)
hash160 = self.hash160(use_uncompressed=use_uncompressed)
if hash160:
return hash160_sec_to_bitcoin_address(hash160, address_prefix=address_prefix)
return None
def addresses_f(self, netcode=None):
from pycoin.networks import address_prefix_for_netcode
from pycoin.networks.default import get_current_netcode
if netcode is None:
netcode = get_current_netcode()
address_prefix = address_prefix_for_netcode(netcode)
addresses = [
encoding.hash160_sec_to_bitcoin_address(
h1, address_prefix=address_prefix) for h1 in self.hash160s()
]
return addresses
def spendables_for_address(self, address):
if address == "mgMy4vmqChGT8XeKPb1zD6RURWsiNmoNvR":
script = ScriptPayToAddress(
bitcoin_address_to_hash160_sec(
address, address_prefix_for_netcode('XTN')))
return [
Spendable(coin_value=10000,
script=script.script(),
tx_out_index=0,
tx_hash=b'2' * 32)
]
else:
return []
def address_from_pubkey(pubkey, netcode="BTC"):
""" Get bitcoin address from given public key.
Args:
pubkey (str): Hex encoded 33Byte compressed public key
netcode (str): Netcode for resulting bitcoin address.
Return:
str: Bitcoin address
"""
prefix = networks.address_prefix_for_netcode(netcode)
public_pair = encoding.sec_to_public_pair(h2b(pubkey))
return encoding.public_pair_to_bitcoin_address(public_pair,
address_prefix=prefix)
def dump_tx(tx, netcode='BTC'):
address_prefix = address_prefix_for_netcode(netcode)
tx_bin = stream_to_bytes(tx.stream)
print("Version: %2d tx hash %s %d bytes " %
(tx.version, tx.id(), len(tx_bin)))
print("TxIn count: %d; TxOut count: %d" %
(len(tx.txs_in), len(tx.txs_out)))
if tx.lock_time == 0:
meaning = "valid anytime"
elif tx.lock_time < LOCKTIME_THRESHOLD:
meaning = "valid after block index %d" % tx.lock_time
else:
when = datetime.datetime.utcfromtimestamp(tx.lock_time)
meaning = "valid on or after %s utc" % when.isoformat()
print("Lock time: %d (%s)" % (tx.lock_time, meaning))
print("Input%s:" % ('s' if len(tx.txs_in) != 1 else ''))
missing_unspents = tx.missing_unspents()
for idx, tx_in in enumerate(tx.txs_in):
if tx.is_coinbase():
print("%4d: COINBASE %12.5f mBTC" %
(idx, satoshi_to_mbtc(tx.total_in())))
else:
suffix = ""
if tx.missing_unspent(idx):
address = tx_in.bitcoin_address(address_prefix=address_prefix)
else:
tx_out = tx.unspents[idx]
sig_result = " sig ok" if tx.is_signature_ok(
idx) else " BAD SIG"
suffix = " %12.5f mBTC %s" % (satoshi_to_mbtc(
tx_out.coin_value), sig_result)
address = tx_out.bitcoin_address(netcode=netcode)
t = "%4d: %34s from %s:%-4d%s" % (idx, address,
b2h_rev(tx_in.previous_hash),
tx_in.previous_index, suffix)
print(t.rstrip())
print("Output%s:" % ('s' if len(tx.txs_out) != 1 else ''))
for idx, tx_out in enumerate(tx.txs_out):
amount_mbtc = satoshi_to_mbtc(tx_out.coin_value)
address = tx_out.bitcoin_address(netcode=netcode) or "(unknown)"
print("%4d: %34s receives %12.5f mBTC" % (idx, address, amount_mbtc))
if not missing_unspents:
print("Total input %12.5f mBTC" % satoshi_to_mbtc(tx.total_in()))
print("Total output %12.5f mBTC" % satoshi_to_mbtc(tx.total_out()))
if not missing_unspents:
print("Total fees %12.5f mBTC" % satoshi_to_mbtc(tx.fee()))
def msg_verify(args, parser):
message_hash = get_message_hash(args)
try:
pair, is_compressed = pair_for_message(args.signature, msg_hash=message_hash, netcode=args.network)
except encoding.EncodingError:
pass
prefix = address_prefix_for_netcode(args.network)
ta = encoding.public_pair_to_bitcoin_address(pair, compressed=is_compressed, address_prefix=prefix)
if args.address:
if ta == args.address:
print("signature ok")
return 0
else:
print("bad signature, matches %s" % ta)
return 1
else:
print(ta)
def msg_verify(args, parser):
message_hash = get_message_hash(args)
try:
pair, is_compressed = pair_for_message(args.signature, msg_hash=message_hash, netcode=args.network)
except encoding.EncodingError:
pass
prefix = address_prefix_for_netcode(args.network)
ta = encoding.public_pair_to_bitcoin_address(pair, compressed=is_compressed, address_prefix=prefix)
if args.address:
if ta == args.address:
print("signature ok")
return 0
else:
print("bad signature, matches %s" % ta)
return 1
else:
print(ta)
def _calculate_all(self):
for attr in "_secret_exponent _public_pair _wif_uncompressed _wif_compressed _sec_compressed" \
" _sec_uncompressed _hash160_compressed _hash160_uncompressed _address_compressed" \
" _address_uncompressed _netcode".split():
setattr(self, attr, getattr(self, attr, None))
if self._hierarchical_wallet:
if self._hierarchical_wallet.is_private:
self._secret_exponent = self._hierarchical_wallet.secret_exponent
else:
self._public_pair = self._hierarchical_wallet.public_pair
self._netcode = self._hierarchical_wallet.netcode
wif_prefix = wif_prefix_for_netcode(self._netcode)
if self._secret_exponent:
self._wif_uncompressed = secret_exponent_to_wif(
self._secret_exponent, compressed=False, wif_prefix=wif_prefix)
self._wif_compressed = secret_exponent_to_wif(
self._secret_exponent, compressed=True, wif_prefix=wif_prefix)
self._public_pair = ecdsa.public_pair_for_secret_exponent(
ecdsa.generator_secp256k1, self._secret_exponent)
if self._public_pair:
self._sec_compressed = public_pair_to_sec(self._public_pair,
compressed=True)
self._sec_uncompressed = public_pair_to_sec(self._public_pair,
compressed=False)
self._hash160_compressed = hash160(self._sec_compressed)
self._hash160_uncompressed = hash160(self._sec_uncompressed)
address_prefix = address_prefix_for_netcode(self._netcode)
if self._hash160_compressed:
self._address_compressed = hash160_sec_to_bitcoin_address(
self._hash160_compressed, address_prefix=address_prefix)
if self._hash160_uncompressed:
self._address_uncompressed = hash160_sec_to_bitcoin_address(
self._hash160_uncompressed, address_prefix=address_prefix)
def address(self, use_uncompressed=None):
"""
Return the public address representation of this key, if available.
If use_uncompressed is not set, the preferred representation is returned.
"""
hash_160 = self.hash160(use_uncompressed=use_uncompressed)
if hash_160:
is_p2pwk = address_wit_for_netcode(self._netcode)
if is_p2pwk:
witness = ScriptPayToAddressWit(b'\0', hash_160)
return witness.info(self._netcode)['address_f']()
is_p2pwk_in_p2sh = pay_to_script_wit_for_netcode(self._netcode)
if is_p2pwk_in_p2sh:
address_prefix = pay_to_script_prefix_for_netcode(
self._netcode)
wit_script = ScriptPayToAddressWit(b'\0', hash_160).script()
hash_160 = hash160(wit_script)
else:
address_prefix = address_prefix_for_netcode(self._netcode)
return hash160_sec_to_bitcoin_address(
hash_160, address_prefix=address_prefix)
return None
def dump_tx(tx, netcode='BTC'):
address_prefix = address_prefix_for_netcode(netcode)
tx_bin = stream_to_bytes(tx.stream)
print("Version: %2d tx hash %s %d bytes " % (tx.version, tx.id(), len(tx_bin)))
print("TxIn count: %d; TxOut count: %d" % (len(tx.txs_in), len(tx.txs_out)))
if tx.lock_time == 0:
meaning = "valid anytime"
elif tx.lock_time < LOCKTIME_THRESHOLD:
meaning = "valid after block index %d" % tx.lock_time
else:
when = datetime.datetime.utcfromtimestamp(tx.lock_time)
meaning = "valid on or after %s utc" % when.isoformat()
print("Lock time: %d (%s)" % (tx.lock_time, meaning))
print("Input%s:" % ('s' if len(tx.txs_in) != 1 else ''))
missing_unspents = tx.missing_unspents()
for idx, tx_in in enumerate(tx.txs_in):
if tx.is_coinbase():
print("%3d: COINBASE %12.5f mBTC" % (idx, satoshi_to_mbtc(tx.total_in())))
else:
suffix = ""
if tx.missing_unspent(idx):
address = tx_in.bitcoin_address(address_prefix=address_prefix)
else:
tx_out = tx.unspents[idx]
sig_result = " sig ok" if tx.is_signature_ok(idx) else " BAD SIG"
suffix = " %12.5f mBTC %s" % (satoshi_to_mbtc(tx_out.coin_value), sig_result)
address = tx_out.bitcoin_address(netcode=netcode)
print("%3d: %34s from %s:%d%s" % (idx, address, b2h_rev(tx_in.previous_hash),
tx_in.previous_index, suffix))
print("Output%s:" % ('s' if len(tx.txs_out) != 1 else ''))
for idx, tx_out in enumerate(tx.txs_out):
amount_mbtc = satoshi_to_mbtc(tx_out.coin_value)
address = tx_out.bitcoin_address(netcode=netcode) or "(unknown)"
print("%3d: %34s receives %12.5f mBTC" % (idx, address, amount_mbtc))
if not missing_unspents:
print("Total input %12.5f mBTC" % satoshi_to_mbtc(tx.total_in()))
print( "Total output %12.5f mBTC" % satoshi_to_mbtc(tx.total_out()))
if not missing_unspents:
print("Total fees %12.5f mBTC" % satoshi_to_mbtc(tx.fee()))
def _calculate_all(self):
for attr in "_secret_exponent _public_pair _wif_uncompressed _wif_compressed _sec_compressed" \
" _sec_uncompressed _hash160_compressed _hash160_uncompressed _address_compressed" \
" _address_uncompressed _netcode".split():
setattr(self, attr, getattr(self, attr, None))
if self._hierarchical_wallet:
if self._hierarchical_wallet.is_private:
self._secret_exponent = self._hierarchical_wallet.secret_exponent
else:
self._public_pair = self._hierarchical_wallet.public_pair
self._netcode = self._hierarchical_wallet.netcode
wif_prefix = wif_prefix_for_netcode(self._netcode)
if self._secret_exponent:
self._wif_uncompressed = secret_exponent_to_wif(
self._secret_exponent, compressed=False, wif_prefix=wif_prefix)
self._wif_compressed = secret_exponent_to_wif(
self._secret_exponent, compressed=True, wif_prefix=wif_prefix)
self._public_pair = ecdsa.public_pair_for_secret_exponent(
ecdsa.generator_secp256k1, self._secret_exponent)
if self._public_pair:
self._sec_compressed = public_pair_to_sec(self._public_pair, compressed=True)
self._sec_uncompressed = public_pair_to_sec(self._public_pair, compressed=False)
self._hash160_compressed = hash160(self._sec_compressed)
self._hash160_uncompressed = hash160(self._sec_uncompressed)
address_prefix = address_prefix_for_netcode(self._netcode)
if self._hash160_compressed:
self._address_compressed = hash160_sec_to_bitcoin_address(
self._hash160_compressed, address_prefix=address_prefix)
if self._hash160_uncompressed:
self._address_uncompressed = hash160_sec_to_bitcoin_address(
self._hash160_uncompressed, address_prefix=address_prefix)
#!/usr/bin/python
import os
from pycoin.key.bip32 import Wallet
from pycoin.encoding import public_pair_to_hash160_sec, hash160_sec_to_bitcoin_address
from pycoin.networks import address_prefix_for_netcode, alternate_hash_for_netcode
secret = os.urandom(64)
wallet = Wallet.from_master_secret(bytes(secret), 'BLC')
sec = public_pair_to_hash160_sec(wallet.public_pair)
pubkey = ''.join('{:02x}'.format(ord(x)) for x in sec)
addr_blc = hash160_sec_to_bitcoin_address(sec, address_prefix=address_prefix_for_netcode('BLC'), internal_hash=alternate_hash_for_netcode('BLC'))
#addr_blc_test = hash160_sec_to_bitcoin_address(sec, address_prefix=address_prefix_for_netcode('TBLC'), internal_hash=alternate_hash_for_netcode('TBLC'))
addr_pho = hash160_sec_to_bitcoin_address(sec, address_prefix=address_prefix_for_netcode('PHO'), internal_hash=alternate_hash_for_netcode('PHO'))
#addr_pho_test = hash160_sec_to_bitcoin_address(sec, address_prefix=address_prefix_for_netcode('TPHO'), internal_hash=alternate_hash_for_netcode('TPHO'))
addr_bbtc = hash160_sec_to_bitcoin_address(sec, address_prefix=address_prefix_for_netcode('BBTC'), internal_hash=alternate_hash_for_netcode('BBTC'))
addr_xdq = hash160_sec_to_bitcoin_address(sec, address_prefix=address_prefix_for_netcode('XDQ'), internal_hash=alternate_hash_for_netcode('XDQ'))
addr_elt = hash160_sec_to_bitcoin_address(sec, address_prefix=address_prefix_for_netcode('ELT'), internal_hash=alternate_hash_for_netcode('ELT'))
addr_umo = hash160_sec_to_bitcoin_address(sec, address_prefix=address_prefix_for_netcode('UMO'), internal_hash=alternate_hash_for_netcode('UMO'))
wallet.netcode = 'BLC'
wif = wallet.wif()
import_command = "importprivkey %s MERGED_NOMP_REWARD false" % wif
print("Your public key is\n\n%s\n" % pubkey)
print("Use it as your username on the NOMP pool.\n\n")
print("To import the address to your wallet, use the following command on")
print("Help > Debug window > Console in each wallet of the Blake family:\n")
def addresses_f(self, netcode=None):
from pycoin.networks import address_prefix_for_netcode
address_prefix = address_prefix_for_netcode(netcode)
addresses = [encoding.hash160_sec_to_bitcoin_address(h1, address_prefix=address_prefix)
for h1 in self.hash160s()]
return addresses
def spendables_for_addresses(self, addresses):
results = {}
for address in addresses:
if address == "mgMy4vmqChGT8XeKPb1zD6RURWsiNmoNvR":
results[address] =\
[Spendable(coin_value=10000,
script=ScriptPayToAddress(bitcoin_address_to_hash160_sec(address, address_prefix_for_netcode('XTN'))).script(),
tx_out_index=0, tx_hash=b'2'*32)]
return results
import os
from pycoin.key.bip32 import Wallet
from pycoin.encoding import public_pair_to_hash160_sec, hash160_sec_to_bitcoin_address
from pycoin.networks import address_prefix_for_netcode, alternate_hash_for_netcode
from binascii import hexlify
import bitcoinrpc
import socket
secret = os.urandom(64)
wallet = Wallet.from_master_secret(bytes(secret), 'BLC')
sec = public_pair_to_hash160_sec(wallet.public_pair)
pubkey = ''.join('{:02x}'.format(ord(x)) for x in sec)
addr_blc = hash160_sec_to_bitcoin_address(sec, address_prefix=address_prefix_for_netcode('BLC'), internal_hash=alternate_hash_for_netcode('BLC'))
addr_pho = hash160_sec_to_bitcoin_address(sec, address_prefix=address_prefix_for_netcode('PHO'), internal_hash=alternate_hash_for_netcode('PHO'))
addr_bbtc = hash160_sec_to_bitcoin_address(sec, address_prefix=address_prefix_for_netcode('BBTC'), internal_hash=alternate_hash_for_netcode('BBTC'))
addr_xdq = hash160_sec_to_bitcoin_address(sec, address_prefix=address_prefix_for_netcode('XDQ'), internal_hash=alternate_hash_for_netcode('XDQ'))
addr_elt = hash160_sec_to_bitcoin_address(sec, address_prefix=address_prefix_for_netcode('ELT'), internal_hash=alternate_hash_for_netcode('ELT'))
addr_umo = hash160_sec_to_bitcoin_address(sec, address_prefix=address_prefix_for_netcode('UMO'), internal_hash=alternate_hash_for_netcode('UMO'))
addresses = {
'blakecoin': addr_blc,
'photon': addr_pho,
'blakebitcoin': addr_bbtc,
'dirac': addr_xdq,
'electron': addr_elt,
'universalmolecule': addr_umo
}
def spendables_for_addresses(self, addresses):
results = {}
for address in addresses:
if address == "mgMy4vmqChGT8XeKPb1zD6RURWsiNmoNvR":
results[address] =\
[Spendable(coin_value=10000,
script=ScriptPayToAddress(bitcoin_address_to_hash160_sec(address, address_prefix_for_netcode('XTN'))).script(),
tx_out_index=0, tx_hash=b'2'*32)]
return results
from pycoin.key.bip32 import Wallet
from pycoin.encoding import public_pair_to_hash160_sec, hash160_sec_to_bitcoin_address
from pycoin.networks import address_prefix_for_netcode, alternate_hash_for_netcode
from binascii import hexlify
import bitcoinrpc
import socket
secret = os.urandom(64)
wallet = Wallet.from_master_secret(bytes(secret), 'BLC')
sec = public_pair_to_hash160_sec(wallet.public_pair)
pubkey = ''.join('{:02x}'.format(ord(x)) for x in sec)
addr_blc = hash160_sec_to_bitcoin_address(
sec,
address_prefix=address_prefix_for_netcode('BLC'),
internal_hash=alternate_hash_for_netcode('BLC'))
addr_pho = hash160_sec_to_bitcoin_address(
sec,
address_prefix=address_prefix_for_netcode('PHO'),
internal_hash=alternate_hash_for_netcode('PHO'))
addr_bbtc = hash160_sec_to_bitcoin_address(
sec,
address_prefix=address_prefix_for_netcode('BBTC'),
internal_hash=alternate_hash_for_netcode('BBTC'))
addr_xdq = hash160_sec_to_bitcoin_address(
sec,
address_prefix=address_prefix_for_netcode('XDQ'),
internal_hash=alternate_hash_for_netcode('XDQ'))
addr_elt = hash160_sec_to_bitcoin_address(
sec,
def dump_tx(tx, netcode, verbose_signature, disassembly_level, do_trace):
address_prefix = address_prefix_for_netcode(netcode)
tx_bin = stream_to_bytes(tx.stream)
print("Version: %2d tx hash %s %d bytes " % (tx.version, tx.id(), len(tx_bin)))
print("TxIn count: %d; TxOut count: %d" % (len(tx.txs_in), len(tx.txs_out)))
if tx.lock_time == 0:
meaning = "valid anytime"
elif tx.lock_time < LOCKTIME_THRESHOLD:
meaning = "valid after block index %d" % tx.lock_time
else:
when = datetime.datetime.utcfromtimestamp(tx.lock_time)
meaning = "valid on or after %s utc" % when.isoformat()
print("Lock time: %d (%s)" % (tx.lock_time, meaning))
print("Input%s:" % ('s' if len(tx.txs_in) != 1 else ''))
missing_unspents = tx.missing_unspents()
traceback_f = trace_script if do_trace else None
for idx, tx_in in enumerate(tx.txs_in):
if disassembly_level > 0:
signature_for_hash_type_f = lambda hash_type, script: tx.signature_hash(
script, idx, hash_type)
if tx.is_coinbase():
print("%4d: COINBASE %12.5f mBTC" % (idx, satoshi_to_mbtc(tx.total_in())))
else:
suffix = ""
if tx.missing_unspent(idx):
tx_out = None
address = tx_in.bitcoin_address(address_prefix=address_prefix)
else:
tx_out = tx.unspents[idx]
sig_result = " sig ok" if tx.is_signature_ok(idx, traceback_f=traceback_f) else " BAD SIG"
suffix = " %12.5f mBTC %s" % (satoshi_to_mbtc(tx_out.coin_value), sig_result)
address = tx_out.bitcoin_address(netcode=netcode)
t = "%4d: %34s from %s:%-4d%s" % (idx, address, b2h_rev(tx_in.previous_hash),
tx_in.previous_index, suffix)
print(t.rstrip())
if disassembly_level > 0:
out_script = b''
if tx_out:
out_script = tx_out.script
for (pre_annotations, pc, opcode, instruction, post_annotations) in \
disassemble_scripts(tx_in.script, out_script, signature_for_hash_type_f):
for l in pre_annotations:
print(" %s" % l)
print( " %4x: %02x %s" % (pc, opcode, instruction))
for l in post_annotations:
print(" %s" % l)
if verbose_signature:
signatures = []
for opcode in opcode_list(tx_in.script):
if not opcode.startswith("OP_"):
try:
signatures.append(parse_signature_blob(h2b(opcode)))
except UnexpectedDER:
pass
if signatures:
sig_types_identical = (zip(*signatures)[1]).count(signatures[0][1]) == len(signatures)
i = 1 if len(signatures) > 1 else ''
for sig_pair, sig_type in signatures:
print(" r{0}: {1:#x}\n s{0}: {2:#x}".format(i, *sig_pair))
if not sig_types_identical and tx_out:
print(" z{}: {:#x} {}".format(i, tx.signature_hash(tx_out.script, idx, sig_type),
sighash_type_to_string(sig_type)))
if i: i += 1
if sig_types_identical and tx_out:
print(" z:{} {:#x} {}".format(' ' if i else '', tx.signature_hash(tx_out.script, idx, sig_type),
sighash_type_to_string(sig_type)))
print("Output%s:" % ('s' if len(tx.txs_out) != 1 else ''))
for idx, tx_out in enumerate(tx.txs_out):
amount_mbtc = satoshi_to_mbtc(tx_out.coin_value)
address = tx_out.bitcoin_address(netcode=netcode) or "(unknown)"
print("%4d: %34s receives %12.5f mBTC" % (idx, address, amount_mbtc))
if disassembly_level > 0:
for (pre_annotations, pc, opcode, instruction, post_annotations) in \
disassemble_scripts(b'', tx_out.script, signature_for_hash_type_f):
for l in pre_annotations:
print(" %s" % l)
print( " %4x: %02x %s" % (pc, opcode, instruction))
for l in post_annotations:
print(" %s" % l)
if not missing_unspents:
print("Total input %12.5f mBTC" % satoshi_to_mbtc(tx.total_in()))
print( "Total output %12.5f mBTC" % satoshi_to_mbtc(tx.total_out()))
if not missing_unspents:
print("Total fees %12.5f mBTC" % satoshi_to_mbtc(tx.fee()))
