def broadcast_next_transaction(internal_id):
"""
Broadcast a transaction, but only if it is one of the valid next
transactions.
"""
transaction_store_filename = TRANSACTION_STORE_FILENAME
initial_tx = load(transaction_store_filename=transaction_store_filename)
recentdata = get_current_confirmed_transaction(initial_tx)
internal_id = str(internal_id)
internal_ids = [str(blah.internal_id) for blah in recentdata["next"]]
if internal_id not in internal_ids:
logger.error(
f"Error: internal_id {internal_id} is an invalid next step")
sys.exit(1)
internal_map = dict([(str(blah.internal_id), blah)
for blah in recentdata["next"]])
requested_tx = internal_map[str(internal_id)]
bitcoin_transaction = requested_tx.bitcoin_transaction
connection = get_bitcoin_rpc_connection()
result = connection.sendrawtransaction(bitcoin_transaction)
if type(result) == bytes:
result = b2lx(result)
logger.info("Broadcasted, txid: {}".format(result))
return result
def to_dict(self):
data = {
"counter": self.id,
"name": self.name,
"txid": b2lx(self.txid),
"outputs": dict([(idx, some_output.to_dict()) for (idx, some_output) in enumerate(self.output_utxos)]),
}
return data
def to_dict(self):
"""
Convert the current planned transaction to a formatted dictionary.
"""
data = {
"counter": self.id,
"internal_id": str(self.internal_id),
"name": self.name,
"txid": b2lx(self.bitcoin_transaction.GetTxid()),
"inputs": dict([(idx, some_input.to_dict()) for (idx, some_input) in enumerate(self.inputs)]),
"outputs": dict([(idx, some_output.to_dict()) for (idx, some_output) in enumerate(self.output_utxos)]),
"bitcoin_transaction": b2x(self.bitcoin_transaction.serialize()),
}
if hasattr(self, "ctv_bitcoin_transaction"):
logger.info("Transaction name: {}".format(self.name))
data["ctv_bitcoin_transaction"] = b2x(self.ctv_bitcoin_transaction.serialize())
data["ctv_bitcoin_transaction_txid"] = b2lx(self.ctv_bitcoin_transaction.GetTxid())
return data
def check_blockchain_has_transaction(txid, connection=None):
"""
Check whether a given transaction id (txid) is present in the bitcoin
blockchain with at least one confirmation.
"""
if connection == None:
connection = get_bitcoin_rpc_connection()
if type(txid) == bytes:
txid = b2lx(txid)
try:
rawtransaction = connection._call("getrawtransaction", txid, True)
if "confirmations" in rawtransaction.keys(
) and rawtransaction["confirmations"] > 0:
return True
else:
return False
except bitcoin.rpc.InvalidAddressOrKeyError:
return False
def render_planned_transaction(planned_transaction, depth=0):
"""
Render a planned transaction into text for use in the get_info command.
"""
prefix = "\t" * depth
output_text = prefix + "Transaction:\n"
output_text += prefix + "\tname: {}\n".format(planned_transaction.name)
output_text += prefix + "\tinternal id: {}\n".format(
planned_transaction.internal_id)
output_text += prefix + "\ttxid: {}\n".format(
b2lx(planned_transaction.txid))
output_text += prefix + "\tnum inputs: {}\n".format(
len(planned_transaction.inputs))
output_text += prefix + "\tnum outputs: {}\n".format(
len(planned_transaction.output_utxos))
output_text += "\n"
output_text += prefix + "\tOutputs:\n"
for output in planned_transaction.output_utxos:
output_text += render_planned_output(output, depth=depth + 2)
return output_text
def sign_planned_transaction(planned_transaction, parameters=None):
"""
Sign a planned transaction by parameterizing each of the witnesses based on
the script templates from their predecesor coins.
"""
for planned_input in planned_transaction.inputs:
logger.info("parent transaction name: {}".format(
planned_input.utxo.transaction.name))
# Sanity test: all parent transactions should already be finalized
assert planned_input.utxo.transaction.is_finalized == True
planned_utxo = planned_input.utxo
witness_template_selection = planned_input.witness_template_selection
# sanity check
if witness_template_selection not in planned_utxo.script_template.witness_templates.keys(
):
raise VaultException(
"UTXO {} is missing witness template \"{}\"".format(
planned_utxo.internal_id, witness_template_selection))
witness_template = planned_utxo.script_template.witness_templates[
witness_template_selection]
# Would use transaction.bitcoin_transaction.get_txid() but for the
# very first utxo, the txid is going to be mocked for testing
# purposes. So it's better to just use the txid property...
txid = planned_utxo.transaction.txid
vout = planned_utxo.vout
relative_timelock = planned_input.relative_timelock
if relative_timelock != None:
# Note that it's not enough to just have the relative timelock
# in the script; you also have to set it on the CTxIn object.
planned_input.bitcoin_input = CTxIn(COutPoint(txid, vout),
nSequence=relative_timelock)
else:
planned_input.bitcoin_input = CTxIn(COutPoint(txid, vout))
# TODO: is_finalized is misnamed here.. since the signature isn't
# there yet.
planned_input.is_finalized = True
# Can't sign the input yet because the other inputs aren't finalized.
# sanity check
finalized = planned_transaction.check_inputs_outputs_are_finalized()
assert finalized == True
bitcoin_inputs = [
planned_input.bitcoin_input
for planned_input in planned_transaction.inputs
]
bitcoin_outputs = [
planned_output.bitcoin_output
for planned_output in planned_transaction.output_utxos
]
witnesses = []
planned_transaction.bitcoin_inputs = bitcoin_inputs
planned_transaction.bitcoin_outputs = bitcoin_outputs
# Must be a mutable transaction because the witnesses are added later.
planned_transaction.bitcoin_transaction = CMutableTransaction(
bitcoin_inputs, bitcoin_outputs, nLockTime=0, nVersion=2, witness=None)
# python-bitcoin-utils had a bug where the witnesses weren't
# initialized blank.
#planned_transaction.bitcoin_transaction.witnesses = []
if len(
bitcoin_inputs
) == 0 and planned_transaction.name != "initial transaction (from user)":
raise VaultException("Can't have a transaction with zero inputs")
# Now that the inputs are finalized, it should be possible to sign each
# input on this transaction and add to the list of witnesses.
witnesses = []
for planned_input in planned_transaction.inputs:
# sign!
# Make a signature. Use some code defined in the PlannedInput model.
witness = parameterize_witness_template_by_signing(
planned_input, parameters)
witnesses.append(witness)
# Now take the list of CScript objects and do the needful.
ctxinwitnesses = [
CTxInWitness(CScriptWitness(list(witness))) for witness in witnesses
]
witness = CTxWitness(ctxinwitnesses)
planned_transaction.bitcoin_transaction.wit = witness
planned_transaction.is_finalized = True
if planned_transaction.name == "initial transaction (from user)":
# serialization function fails, so just skip
return
serialized_transaction = planned_transaction.serialize()
logger.info("tx len: {}".format(len(serialized_transaction)))
logger.info("txid: {}".format(
b2lx(planned_transaction.bitcoin_transaction.GetTxid())))
logger.info("Serialized transaction: {}".format(
b2x(serialized_transaction)))