def broadcast_tx(self, tx):
"""
Sends the tx to half our peers and waits for half of the remainder to
announce it via inv packets before calling back.
"""
def on_peer_anncounce(txid):
self.subscriptions[txhash]["announced"] += 1
if self.subscriptions[txhash]["announced"] >= self.subscriptions[
txhash]["ann_threshold"]:
if self.subscriptions[txid]["timeout"].active():
self.subscriptions[txid]["timeout"].cancel()
self.subscriptions[txid]["deferred"].callback(True)
d = defer.Deferred()
transaction = CTransaction.stream_deserialize(BytesIO(unhexlify(tx)))
txhash = transaction.GetHash()
self.inventory[txhash] = transaction
cinv = CInv()
cinv.type = 1
cinv.hash = txhash
inv_packet = msg_inv()
inv_packet.inv.append(cinv)
self.bloom_filter.insert(txhash)
self.subscriptions[txhash] = {
"announced": 0,
"ann_threshold": len(self.peers) / 4,
"callback": on_peer_anncounce,
"confirmations": 0,
"in_blocks": [],
"deferred": d,
"timeout": reactor.callLater(10, d.callback, False)
}
for peer in self.peers[len(self.peers) / 2:]:
peer.protocol.load_filter()
for peer in self.peers[:len(self.peers) / 2]:
peer.protocol.send_message(inv_packet)
return d
def broadcast_tx(self, tx):
"""
Sends the tx to half our peers and waits for half of the remainder to
announce it via inv packets before calling back.
"""
def on_peer_anncounce(txid):
self.subscriptions[txhash]["announced"] += 1
if self.subscriptions[txhash]["announced"] >= self.subscriptions[txhash]["ann_threshold"]:
if self.subscriptions[txid]["timeout"].active():
self.subscriptions[txid]["timeout"].cancel()
self.subscriptions[txid]["deferred"].callback(True)
d = defer.Deferred()
transaction = CTransaction.stream_deserialize(BytesIO(unhexlify(tx)))
txhash = transaction.GetHash()
self.inventory[txhash] = transaction
cinv = CInv()
cinv.type = 1
cinv.hash = txhash
inv_packet = msg_inv()
inv_packet.inv.append(cinv)
self.bloom_filter.insert(txhash)
self.subscriptions[txhash] = {
"announced": 0,
"ann_threshold": len(self.peers)/4,
"callback": on_peer_anncounce,
"confirmations": 0,
"in_blocks": [],
"deferred": d,
"timeout": reactor.callLater(10, d.callback, False)
}
for peer in self.peers[len(self.peers)/2:]:
peer.protocol.load_filter()
for peer in self.peers[:len(self.peers)/2]:
peer.protocol.send_message(inv_packet)
return d
def construct(
db,
tx_info,
encoding='auto',
fee_per_kb=config.DEFAULT_FEE_PER_KB,
estimate_fee_per_kb=None,
estimate_fee_per_kb_conf_target=config.ESTIMATE_FEE_CONF_TARGET,
estimate_fee_per_kb_mode=config.ESTIMATE_FEE_MODE,
estimate_fee_per_kb_nblocks=config.ESTIMATE_FEE_CONF_TARGET,
regular_dust_size=config.DEFAULT_REGULAR_DUST_SIZE,
multisig_dust_size=config.DEFAULT_MULTISIG_DUST_SIZE,
op_return_value=config.DEFAULT_OP_RETURN_VALUE,
exact_fee=None,
fee_provided=0,
provided_pubkeys=None,
dust_return_pubkey=None,
allow_unconfirmed_inputs=False,
unspent_tx_hash=None,
custom_inputs=None,
disable_utxo_locks=False,
extended_tx_info=False,
old_style_api=None,
segwit=False,
p2sh_source_multisig_pubkeys=None,
p2sh_source_multisig_pubkeys_required=None,
p2sh_pretx_txid=None,
):
if estimate_fee_per_kb is None:
estimate_fee_per_kb = config.ESTIMATE_FEE_PER_KB
global UTXO_LOCKS, UTXO_P2SH_ENCODING_LOCKS
# lazy assign from config, because when set as default it's evaluated before it's configured
if old_style_api is None:
old_style_api = config.OLD_STYLE_API
(source, destination_outputs, data) = tx_info
if dust_return_pubkey:
dust_return_pubkey = binascii.unhexlify(dust_return_pubkey)
if p2sh_source_multisig_pubkeys:
p2sh_source_multisig_pubkeys = [
binascii.unhexlify(p) for p in p2sh_source_multisig_pubkeys
]
# Source.
# If public key is necessary for construction of (unsigned)
# transaction, use the public key provided, or find it from the
# blockchain.
if source:
script.validate(source)
source_is_p2sh = script.is_p2sh(source)
# Normalize source
if script.is_multisig(source):
source_address = backend.multisig_pubkeyhashes_to_pubkeys(
source, provided_pubkeys)
else:
source_address = source
# Sanity checks.
if exact_fee and not isinstance(exact_fee, int):
raise exceptions.TransactionError('Exact fees must be in satoshis.')
if not isinstance(fee_provided, int):
raise exceptions.TransactionError('Fee provided must be in satoshis.')
'''Determine encoding method'''
if data:
desired_encoding = encoding
# Data encoding methods (choose and validate).
if desired_encoding == 'auto':
if len(data) + len(config.PREFIX) <= config.OP_RETURN_MAX_SIZE:
encoding = 'opreturn'
else:
encoding = 'p2sh' if not old_style_api and util.enabled(
'p2sh_encoding'
) else 'multisig' # p2sh is not possible with old_style_api
elif desired_encoding == 'p2sh' and not util.enabled('p2sh_encoding'):
raise exceptions.TransactionError('P2SH encoding not enabled yet')
elif encoding not in ('pubkeyhash', 'multisig', 'opreturn', 'p2sh'):
raise exceptions.TransactionError('Unknown encoding‐scheme.')
else:
# no data
encoding = None
'''Destinations'''
# Destination outputs.
# Replace multi‐sig addresses with multi‐sig pubkeys. Check that the
# destination output isn’t a dust output. Set null values to dust size.
destination_outputs_new = []
if encoding != 'p2sh':
for (address, value) in destination_outputs:
# Value.
if script.is_multisig(address):
dust_size = multisig_dust_size
else:
dust_size = regular_dust_size
if value == None:
value = dust_size
elif value < dust_size:
raise exceptions.TransactionError(
'Destination output is dust.')
# Address.
script.validate(address)
if script.is_multisig(address):
destination_outputs_new.append(
(backend.multisig_pubkeyhashes_to_pubkeys(
address, provided_pubkeys), value))
else:
destination_outputs_new.append((address, value))
destination_outputs = destination_outputs_new
destination_btc_out = sum(
[value for address, value in destination_outputs])
'''Data'''
if data:
# @TODO: p2sh encoding require signable dust key
if encoding == 'multisig':
# dust_return_pubkey should be set or explicitly set to False to use the default configured for the node
# the default for the node is optional so could fail
if (source_is_p2sh and dust_return_pubkey is None) or (
dust_return_pubkey is False
and config.P2SH_DUST_RETURN_PUBKEY is None):
raise exceptions.TransactionError(
"Can't use multisig encoding when source is P2SH and no dust_return_pubkey is provided."
)
elif dust_return_pubkey is False:
dust_return_pubkey = binascii.unhexlify(
config.P2SH_DUST_RETURN_PUBKEY)
# Divide data into chunks.
if encoding == 'pubkeyhash':
# Prefix is also a suffix here.
chunk_size = 20 - 1 - 8
elif encoding == 'multisig':
# Two pubkeys, minus length byte, minus prefix, minus two nonces,
# minus two sign bytes.
chunk_size = (33 * 2) - 1 - 8 - 2 - 2
elif encoding == 'p2sh':
chunk_size = p2sh_encoding.maximum_data_chunk_size()
elif encoding == 'opreturn':
chunk_size = config.OP_RETURN_MAX_SIZE
if len(data) + len(config.PREFIX) > chunk_size:
raise exceptions.TransactionError(
'One `OP_RETURN` output per transaction.')
data_array = list(chunks(data, chunk_size))
# Data outputs.
if encoding == 'multisig':
data_value = multisig_dust_size
elif encoding == 'p2sh':
data_value = 0 # this will be calculated later
elif encoding == 'opreturn':
data_value = op_return_value
else:
# Pay‐to‐PubKeyHash, e.g.
data_value = regular_dust_size
data_output = (data_array, data_value)
if not dust_return_pubkey:
if encoding == 'multisig' or encoding == 'p2sh' and not source_is_p2sh:
dust_return_pubkey = get_dust_return_pubkey(
source, provided_pubkeys, encoding)
else:
dust_return_pubkey = None
else:
data_value = 0
data_array = []
data_output = None
dust_return_pubkey = None
data_btc_out = data_value * len(data_array)
logger.getChild('p2shdebug').debug(
'data_btc_out=%s (data_value=%d len(data_array)=%d)' %
(data_btc_out, data_value, len(data_array)))
'''Inputs'''
btc_in = 0
final_fee = 0
# Calculate collective size of outputs, for fee calculation.
p2pkhsize = 25 + 9
if encoding == 'multisig':
data_output_size = 81 # 71 for the data
elif encoding == 'opreturn':
# prefix + data + 10 bytes script overhead
data_output_size = len(config.PREFIX) + 10
if data is not None:
data_output_size = data_output_size + len(data)
else:
data_output_size = p2pkhsize # Pay‐to‐PubKeyHash (25 for the data?)
outputs_size = (p2pkhsize * len(destination_outputs)) + (len(data_array) *
data_output_size)
if encoding == 'p2sh':
# calculate all the p2sh outputs
size_for_fee, datatx_necessary_fee, data_value, data_btc_out = p2sh_encoding.calculate_outputs(
destination_outputs, data_array, fee_per_kb)
# replace the data value
data_output = (data_array, data_value)
else:
sum_data_output_size = len(data_array) * data_output_size
size_for_fee = (
(25 + 9) * len(destination_outputs)) + sum_data_output_size
if not (encoding == 'p2sh' and p2sh_pretx_txid):
inputs, change_quantity, n_btc_in, n_final_fee = construct_coin_selection(
encoding, data_array, source, allow_unconfirmed_inputs,
unspent_tx_hash, custom_inputs, fee_per_kb, estimate_fee_per_kb,
estimate_fee_per_kb_nblocks, exact_fee, size_for_fee, fee_provided,
destination_btc_out, data_btc_out, regular_dust_size,
disable_utxo_locks)
btc_in = n_btc_in
final_fee = n_final_fee
else:
# when encoding is P2SH and the pretx txid is passed we can skip coinselection
inputs, change_quantity = None, None
'''Finish'''
if change_quantity:
change_output = (source_address, change_quantity)
else:
change_output = None
unsigned_pretx_hex = None
unsigned_tx_hex = None
pretx_txid = None
if encoding == 'p2sh':
assert not (segwit and p2sh_pretx_txid
) # shouldn't do old style with segwit enabled
if p2sh_pretx_txid:
pretx_txid = p2sh_pretx_txid if isinstance(
p2sh_pretx_txid,
bytes) else binascii.unhexlify(p2sh_pretx_txid)
unsigned_pretx = None
else:
destination_value_sum = sum(
[value for (destination, value) in destination_outputs])
source_value = destination_value_sum
if change_output:
# add the difference between source and destination to the change
change_value = change_output[1] + (destination_value_sum -
source_value)
change_output = (change_output[0], change_value)
unsigned_pretx = serializer.serialise_p2sh_pretx(
inputs,
source=source_address,
source_value=source_value,
data_output=data_output,
change_output=change_output,
pubkey=dust_return_pubkey,
multisig_pubkeys=p2sh_source_multisig_pubkeys,
multisig_pubkeys_required=p2sh_source_multisig_pubkeys_required
)
unsigned_pretx_hex = binascii.hexlify(unsigned_pretx).decode(
'utf-8')
# with segwit we already know the txid and can return both
if segwit:
#pretx_txid = hashlib.sha256(unsigned_pretx).digest() # this should be segwit txid
ptx = CTransaction.stream_deserialize(
io.BytesIO(unsigned_pretx)) # could be a non-segwit tx anyways
txid_ba = bytearray(ptx.GetTxid())
txid_ba.reverse()
pretx_txid = bytes(
txid_ba) # gonna leave the malleability problem to upstream
logger.getChild('p2shdebug').debug('pretx_txid %s' % pretx_txid)
print('pretx txid:', binascii.hexlify(pretx_txid))
if unsigned_pretx:
# we set a long lock on this, don't want other TXs to spend from it
UTXO_P2SH_ENCODING_LOCKS[make_outkey_vin(unsigned_pretx, 0)] = True
# only generate the data TX if we have the pretx txId
if pretx_txid:
source_input = None
if script.is_p2sh(source):
source_input = select_any_coin_from_source(source)
if not source_input:
raise exceptions.TransactionError(
'Unable to select source input for p2sh source address'
)
unsigned_datatx = serializer.serialise_p2sh_datatx(
pretx_txid,
source=source_address,
source_input=source_input,
destination_outputs=destination_outputs,
data_output=data_output,
pubkey=dust_return_pubkey,
multisig_pubkeys=p2sh_source_multisig_pubkeys,
multisig_pubkeys_required=p2sh_source_multisig_pubkeys_required
)
unsigned_datatx_hex = binascii.hexlify(unsigned_datatx).decode(
'utf-8')
# let the rest of the code work it's magic on the data tx
unsigned_tx_hex = unsigned_datatx_hex
else:
# we're just gonna return the pretx, it doesn't require any of the further checks
logger.warn('old_style_api = %s' % old_style_api)
return return_result([unsigned_pretx_hex],
old_style_api=old_style_api)
else:
# Serialise inputs and outputs.
unsigned_tx = serializer.serialise(
encoding,
inputs,
destination_outputs,
data_output,
change_output,
dust_return_pubkey=dust_return_pubkey)
unsigned_tx_hex = binascii.hexlify(unsigned_tx).decode('utf-8')
'''Sanity Check'''
# Desired transaction info.
(desired_source, desired_destination_outputs, desired_data) = tx_info
desired_source = script.make_canonical(desired_source)
desired_destination = script.make_canonical(
desired_destination_outputs[0]
[0]) if desired_destination_outputs else ''
# NOTE: Include change in destinations for BTC transactions.
# if change_output and not desired_data and desired_destination != config.UNSPENDABLE:
# if desired_destination == '':
# desired_destination = desired_source
# else:
# desired_destination += '-{}'.format(desired_source)
# NOTE
if desired_data == None:
desired_data = b''
# Parsed transaction info.
try:
if pretx_txid and unsigned_pretx:
backend.cache_pretx(pretx_txid, unsigned_pretx)
parsed_source, parsed_destination, x, y, parsed_data, extra = blocks._get_tx_info(
unsigned_tx_hex, p2sh_is_segwit=script.is_bech32(desired_source))
if encoding == 'p2sh':
# make_canonical can't determine the address, so we blindly change the desired to the parsed
desired_source = parsed_source
if pretx_txid and unsigned_pretx:
backend.clear_pretx(pretx_txid)
except exceptions.BTCOnlyError:
# Skip BTC‐only transactions.
if extended_tx_info:
return {
'btc_in': btc_in,
'btc_out': destination_btc_out + data_btc_out,
'btc_change': change_quantity,
'btc_fee': final_fee,
'tx_hex': unsigned_tx_hex,
}
logger.getChild('p2shdebug').debug('BTC-ONLY')
return return_result([unsigned_pretx_hex, unsigned_tx_hex],
old_style_api=old_style_api)
desired_source = script.make_canonical(desired_source)
# Check desired info against parsed info.
desired = (desired_source, desired_destination, desired_data)
parsed = (parsed_source, parsed_destination, parsed_data)
if desired != parsed:
# Unlock (revert) UTXO locks
if UTXO_LOCKS is not None and inputs:
for input in inputs:
UTXO_LOCKS[source].pop(make_outkey(input), None)
raise exceptions.TransactionError(
'Constructed transaction does not parse correctly: {} ≠ {}'.format(
desired, parsed))
if extended_tx_info:
return {
'btc_in': btc_in,
'btc_out': destination_btc_out + data_btc_out,
'btc_change': change_quantity,
'btc_fee': final_fee,
'tx_hex': unsigned_tx_hex,
}
return return_result([unsigned_pretx_hex, unsigned_tx_hex],
old_style_api=old_style_api)
def msg_deser(cls, f, protover=PROTO_VERSION):
c = cls()
c.tx = CTransaction.stream_deserialize(f)
return c
def msg_deser(cls, f, protover=PROTO_VERSION):
c = cls()
c.tx = CTransaction.stream_deserialize(f)
return c
