def test_validate_fulfillments_of_transfer_tx_with_invalid_params(transfer_tx,
cond_uri,
utx,
user2_pub,
user_priv):
from bigchaindb_common.transaction import Condition
from cryptoconditions import Ed25519Fulfillment
invalid_cond = Condition(Ed25519Fulfillment.from_uri('cf:0:'), ['invalid'])
assert transfer_tx.fulfillments_valid([invalid_cond]) is False
invalid_cond = utx.conditions[0]
invalid_cond.owners_after = 'invalid'
assert transfer_tx.fulfillments_valid([invalid_cond]) is True
with raises(TypeError):
assert transfer_tx.fulfillments_valid(None) is False
with raises(AttributeError):
transfer_tx.fulfillments_valid('not a list')
with raises(ValueError):
transfer_tx.fulfillments_valid([])
with raises(TypeError):
transfer_tx.operation = "Operation that doesn't exist"
transfer_tx.fulfillments_valid([utx.conditions[0]])
with raises(ValueError):
tx = utx.sign([user_priv])
tx.conditions = []
tx.fulfillments_valid()
def test_multiple_fulfillment_validation_of_transfer_tx(user_ffill, user_cond,
user_priv, user2_pub,
user2_priv, user3_pub,
user3_priv):
from copy import deepcopy
from bigchaindb_common.transaction import (Transaction, TransactionLink,
Fulfillment, Condition, Asset)
from cryptoconditions import Ed25519Fulfillment
tx = Transaction(Transaction.CREATE, Asset(),
[user_ffill, deepcopy(user_ffill)],
[user_cond, deepcopy(user_cond)])
tx.sign([user_priv])
fulfillments = [Fulfillment(cond.fulfillment, cond.owners_after,
TransactionLink(tx.id, index))
for index, cond in enumerate(tx.conditions)]
conditions = [Condition(Ed25519Fulfillment(public_key=user3_pub),
[user3_pub]),
Condition(Ed25519Fulfillment(public_key=user3_pub),
[user3_pub])]
transfer_tx = Transaction('TRANSFER', tx.asset, fulfillments, conditions)
transfer_tx = transfer_tx.sign([user_priv])
assert transfer_tx.fulfillments_valid(tx.conditions) is True
def test_condition_deserialization(user_Ed25519, user_pub):
from bigchaindb_common.transaction import Condition
expected = Condition(user_Ed25519, [user_pub], 1)
cond = {
'condition': {
'uri': user_Ed25519.condition_uri,
'details': user_Ed25519.to_dict()
},
'owners_after': [user_pub],
'amount': 1,
}
cond = Condition.from_dict(cond)
assert cond == expected
def test_generate_conditions_single_owner_with_condition(user_pub):
from bigchaindb_common.transaction import Condition
from cryptoconditions import Ed25519Fulfillment
expected = Ed25519Fulfillment(public_key=user_pub)
cond = Condition.generate([expected])
assert cond.fulfillment.to_dict() == expected.to_dict()
def test_condition_hashlock_serialization():
from bigchaindb_common.transaction import Condition
from cryptoconditions import PreimageSha256Fulfillment
secret = b'wow much secret'
hashlock = PreimageSha256Fulfillment(preimage=secret).condition_uri
expected = {
'condition': {
'uri': hashlock,
},
'owners_after': None,
'amount': 1,
}
cond = Condition(hashlock, amount=1)
assert cond.to_dict() == expected
def test_create_create_transaction_hashlock(user_pub, data, data_id):
from cryptoconditions import PreimageSha256Fulfillment
from bigchaindb_common.transaction import Transaction, Condition, Asset
secret = b'much secret, wow'
hashlock = PreimageSha256Fulfillment(preimage=secret).condition_uri
cond = Condition(hashlock)
expected = {
'transaction': {
'conditions': [cond.to_dict(0)],
'metadata': {
'data': data,
},
'asset': {
'id': data_id,
'divisible': False,
'updatable': False,
'refillable': False,
'data': data,
},
'fulfillments': [
{
'owners_before': [
user_pub,
],
'fid': 0,
'fulfillment': None,
'input': None
},
],
'operation': 'CREATE',
},
'version': 1
}
asset = Asset(data, data_id)
tx = Transaction.create([user_pub], [], data, asset, secret).to_dict()
tx.pop('id')
tx['transaction']['metadata'].pop('id')
tx['transaction'].pop('timestamp')
tx['transaction']['fulfillments'][0]['fulfillment'] = None
assert tx == expected
def test_generate_conditions_invalid_parameters(user_pub, user2_pub,
user3_pub):
from bigchaindb_common.transaction import Condition
with raises(ValueError):
Condition.generate([])
with raises(TypeError):
Condition.generate('not a list')
with raises(ValueError):
Condition.generate([[user_pub, [user2_pub, [user3_pub]]]])
with raises(ValueError):
Condition.generate([[user_pub]])
def test_generate_conditions_flat_ownage(user_pub, user2_pub, user3_pub):
from bigchaindb_common.transaction import Condition
from cryptoconditions import Ed25519Fulfillment, ThresholdSha256Fulfillment
expected_simple1 = Ed25519Fulfillment(public_key=user_pub)
expected_simple2 = Ed25519Fulfillment(public_key=user2_pub)
expected_simple3 = Ed25519Fulfillment(public_key=user3_pub)
expected = ThresholdSha256Fulfillment(threshold=3)
expected.add_subfulfillment(expected_simple1)
expected.add_subfulfillment(expected_simple2)
expected.add_subfulfillment(expected_simple3)
cond = Condition.generate([user_pub, user2_pub, expected_simple3])
assert cond.fulfillment.to_dict() == expected.to_dict()
def test_generate_conditions_split_half_single_owner(user_pub, user2_pub,
user3_pub):
from bigchaindb_common.transaction import Condition
from cryptoconditions import Ed25519Fulfillment, ThresholdSha256Fulfillment
expected_simple1 = Ed25519Fulfillment(public_key=user_pub)
expected_simple2 = Ed25519Fulfillment(public_key=user2_pub)
expected_simple3 = Ed25519Fulfillment(public_key=user3_pub)
expected = ThresholdSha256Fulfillment(threshold=2)
expected_threshold = ThresholdSha256Fulfillment(threshold=2)
expected_threshold.add_subfulfillment(expected_simple2)
expected_threshold.add_subfulfillment(expected_simple3)
expected.add_subfulfillment(expected_threshold)
expected.add_subfulfillment(expected_simple1)
cond = Condition.generate([[expected_simple2, user3_pub], user_pub])
assert cond.fulfillment.to_dict() == expected.to_dict()
def test_generate_conditions_split_half_recursive_custom_threshold(user_pub,
user2_pub,
user3_pub):
from bigchaindb_common.transaction import Condition
from cryptoconditions import Ed25519Fulfillment, ThresholdSha256Fulfillment
expected_simple1 = Ed25519Fulfillment(public_key=user_pub)
expected_simple2 = Ed25519Fulfillment(public_key=user2_pub)
expected_simple3 = Ed25519Fulfillment(public_key=user3_pub)
expected = ThresholdSha256Fulfillment(threshold=1)
expected.add_subfulfillment(expected_simple1)
expected_threshold = ThresholdSha256Fulfillment(threshold=1)
expected_threshold.add_subfulfillment(expected_simple2)
expected_threshold.add_subfulfillment(expected_simple3)
expected.add_subfulfillment(expected_threshold)
cond = Condition.generate(([user_pub, ([user2_pub, expected_simple3], 1)],
1))
assert cond.fulfillment.to_dict() == expected.to_dict()
def test_generate_threshold_condition_with_hashlock(user_pub, user2_pub,
user3_pub):
from bigchaindb_common.transaction import Condition
from cryptoconditions import (PreimageSha256Fulfillment,
Ed25519Fulfillment,
ThresholdSha256Fulfillment)
secret = b'much secret, wow'
hashlock = PreimageSha256Fulfillment(preimage=secret)
expected_simple1 = Ed25519Fulfillment(public_key=user_pub)
expected_simple3 = Ed25519Fulfillment(public_key=user3_pub)
expected = ThresholdSha256Fulfillment(threshold=2)
expected_sub = ThresholdSha256Fulfillment(threshold=2)
expected_sub.add_subfulfillment(expected_simple1)
expected_sub.add_subfulfillment(hashlock)
expected.add_subfulfillment(expected_simple3)
cond = Condition.generate([[user_pub, hashlock], expected_simple3])
assert cond.fulfillment.to_dict() == expected.to_dict()
def user_user2_threshold_cond(user_user2_threshold, user_pub, user2_pub):
from bigchaindb_common.transaction import Condition
return Condition(user_user2_threshold, [user_pub, user2_pub])
def user2_cond(user2_Ed25519, user2_pub):
from bigchaindb_common.transaction import Condition
return Condition(user2_Ed25519, [user2_pub])
def test_invalid_condition_initialization(cond_uri, user_pub):
from bigchaindb_common.transaction import Condition
with raises(TypeError):
Condition(cond_uri, user_pub)