def transaction__is_final__locktime_less_block_height_less_threshold_returns_true(
):
height = 100
time = 100
instance = bc.Transaction()
instance.set_locktime(50)
assert instance.is_final(height, time)
def transaction__double_spends__include_unconfirmed_false_with_unconfirmed__returns_empty(
):
instance = bc.Transaction()
input = bc.Input()
input.previous_output().validation.spent = True
instance.set_inputs([input])
assert not instance.double_spends(False)
def transaction__is_coinbase__with_coinbase_input__returns_true():
input = bc.Input()
input.set_previous_output(
bc.OutputPoint.from_tuple(bc.null_hash, bc.max_input_sequence))
instance = bc.Transaction()
instance.set_inputs([input])
assert instance.is_coinbase()
def transaction__inputs_setter_1__roundtrip__success():
input = bc.Input.from_data(bytes.fromhex(TX0))
instance = bc.Transaction()
assert [input] != instance.inputs()
instance.set_inputs([input])
assert [input] == instance.inputs()
def transaction__is_double_spend__include_unconfirmed_true_with_unconfirmed__returns_true(
):
instance = bc.Transaction()
input = bc.Input()
input.previous_output().validation.spent = True
instance.set_inputs([input])
assert instance.is_double_spend(True)
def transaction__is_final__locktime_less_block_time_greater_threshold__returns_true(
):
height = bc.locktime_threshold + 100
time = 100
instance = bc.Transaction()
instance.set_locktime(bc.locktime_threshold + 50)
assert instance.is_final(height, time)
def transaction__operator_boolean_equals__differs__returns_false():
raw_tx = bytes.fromhex(TX4)
alpha = bc.Transaction.from_data(raw_tx)
assert alpha is not None
beta = bc.Transaction()
assert beta is not None
assert alpha != beta
def transaction__outputs_setter_1__roundtrip__success():
output = bc.Output.from_data(bytes.fromhex(TX0_LAST_OUTPUT))
instance = bc.Transaction()
assert [output] != instance.outputs()
instance.set_outputs([output])
assert [output] == instance.outputs()
def transaction__missing_previous_outputs__inputs_with_cache_value__returns_empty(
):
instance = bc.Transaction()
input = bc.Input()
input.previous_output().validation.cache.set_value(123)
instance.set_inputs([input])
assert not instance.missing_previous_outputs()
def transaction__missing_previous_outputs__inputs_without_cache_value__returns_single_index(
):
instance = bc.Transaction()
input = bc.Input()
instance.set_inputs([input])
result = instance.missing_previous_outputs()
assert len(result) == 1
assert result[-1] == 0
def transaction__total_input_value__cache__returns_cache_value_sum():
instance = bc.Transaction()
input0 = bc.Input()
input1 = bc.Input()
input0.previous_output().validation.cache.set_value(123)
input1.previous_output().validation.cache.set_value(123)
instance.set_inputs([input0, input1])
assert instance.total_input_value() == 444
def transaction__immature_inputs__immature_inputs__returns_input_indexes():
instance = bc.Transaction()
input = bc.Input()
input.previous_output().validation.height = 20
instance.set_inputs([input])
result = instance.immature_inputs(50)
assert len(result) == 1
assert result[-1] == 0
def transaction__double_spends__include_unconfirmed_true_with_unconfirmed__returns_expected(
):
instance = bc.Transaction()
input = bc.Input()
input.previous_output().validation.spent = True
instance.set_inputs([input])
result = instance.double_spends(True)
assert len(result) == 1
assert result[-1] == 0
def transaction__is_overspent__output_exceeds_input__returns_true():
instance = bc.Transaction()
output0 = bc.Output()
output0.set_value(1200)
output1 = bc.Output()
output1.set_value(34)
instance.set_outputs([output0, output1])
assert instance.is_overspent()
def transaction__total_output_value__non_empty_outputs__returns_sum():
instance = bc.Transaction()
output0 = bc.Output()
output0.set_value(1200)
output1 = bc.Output()
output1.set_value(34)
instance.set_outputs([output0, output1])
assert instance.total_output_value() == 1234
def transaction__is_final__locktime_input_not_final__returns_false():
height = 100
time = 100
instance = bc.Transaction()
instance.set_locktime(101)
input = bc.Input()
input.sequence = 1
instance.set_inputs([input])
assert not instance.is_final(height, time)
def transaction__is_oversized_coinbase__script_size_below_min__returns_true():
prevout = bc.OutputPoint()
prevout.base.set_index(bc.Point.null_index)
prevout.base.set_hash(bc.null_hash)
input = bc.Input()
input.set_previous_output(prevout)
instance = bc.Transaction()
instance.set_inputs([input])
assert instance.is_coinbase()
assert input.script().serialized_size(False) < bc.min_coinbase_size
assert instance.is_oversized_coinbase()
def transaction__fees__nonempty__returns_outputs_minus_inputs():
instance = bc.Transaction()
input0 = bc.Input()
input1 = bc.Input()
input0.previous_output().validation.cache.set_value(123)
input1.previous_output().validation.cache.set_value(321)
instance.set_inputs([input0, input1])
output0 = bc.Output()
output0.set_value(44)
instance.set_outputs([output0])
assert instance.fees() == 400
def transaction__is_null_non_coinbase__null_input_prevout__returns_true():
prevout = bc.OutputPoint()
prevout.base.set_index(bc.Point.null_index)
prevout.base.set_hash(bc.null_hash)
input0 = bc.Input()
input1 = bc.Input()
input1.set_previous_output(prevout)
instance = bc.Transaction()
instance.set_inputs([input0, input1])
assert not instance.is_coinbase()
assert prevout.is_null()
assert instance.is_null_non_coinbase()
def transaction__is_oversized_coinbase__script_size_above_max__returns_true():
prevout = bc.OutputPoint()
prevout.base.set_index(bc.Point.null_index)
prevout.base.set_hash(bc.null_hash)
input_script = bc.Script.from_data(
bytes.fromhex("00" * (bc.max_coinbase_size + 10)), False)
assert input_script is not None
input = bc.Input()
input.set_previous_output(prevout)
input.set_script(input_script)
instance = bc.Transaction()
instance.set_inputs([input])
assert instance.is_coinbase()
assert input.script().serialized_size(False) > bc.max_coinbase_size
assert instance.is_oversized_coinbase()
async def _build_transaction(self, out, dests, change_pocket=None):
tx = bc.Transaction()
tx.set_version(1)
tx.set_locktime(0)
inputs = [self._create_input(point) for point in out.points]
tx.set_inputs(inputs)
outputs = [self._create_outputs(addr, value) for addr, value in dests]
if out.change:
outputs += [self._create_change_output(change_pocket, out.change)]
random.shuffle(outputs)
outputs = flatten(outputs)
tx.set_outputs(outputs)
return tx
def new_tx(test, sequence=0):
tx = bc.Transaction()
input_script = [bc.Script()]
if not parse(input_script, test[0]):
return tx
output_script = [bc.Script()]
if not parse(output_script, test[1]):
return tx
input = bc.Input()
input.set_sequence(sequence)
input.set_script(input_script[0])
input.previous_output().validation.cache.set_script(output_script[0])
tx.set_inputs([input])
return tx
def transaction__is_double_spend__empty_inputs__returns_false():
instance = bc.Transaction()
assert not instance.is_double_spend(False)
assert not instance.is_double_spend(True)
def transaction__double_spends__empty_inputs__returns_empty():
instance = bc.Transaction()
assert not instance.double_spends(False)
assert not instance.double_spends(True)
def transaction__is_double_spend__unspent_inputs__returns_false():
instance = bc.Transaction()
input = bc.Input()
instance.set_inputs([input])
assert not instance.is_double_spend(False)
assert not instance.is_double_spend(True)
def transaction__double_spends__unspent_inputs__returns_empty():
instance = bc.Transaction()
instance.set_inputs([bc.Input()])
assert not instance.double_spends(False)
assert not instance.double_spends(True)
def transaction__immature_inputs__mature_inputs__returns_empty():
input = bc.Input()
input.previous_output().base.set_index(123)
instance = bc.Transaction()
instance.set_inputs([input])
assert not instance.immature_inputs(453)
def transaction__immature_inputs__empty_inputs__returns_empty():
instance = bc.Transaction()
assert not instance.immature_inputs(453)
def transaction__is_immature__immature_inputs__returns_true():
instance = bc.Transaction()
input = bc.Input()
input.previous_output().validation.height = 20
instance.set_inputs([input])
assert instance.is_immature(50)
def transaction__is_immature__empty_inputs__returns_false():
instance = bc.Transaction()
assert not instance.is_immature(453)
