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)