def test_output_from_dict_invalid_amount(user_output):
from bigchaindb.common.transaction import Output
from bigchaindb.common.exceptions import AmountError
out = user_output.to_dict()
out['amount'] = 'a'
with raises(AmountError):
Output.from_dict(out)
def create_asset(vw_sk, vw_pk, vehicle_id, data, metadata):
# Create asset VW -> [VW, TEL]
# Custom crypto condition multisig 1-2
threshold_fulfillment = ThresholdSha256Fulfillment(threshold=1)
vw_fulfillment = Ed25519Fulfillment(public_key=vw_pk)
tel_fulfillment = Ed25519Fulfillment(public_key=vehicle_id)
threshold_fulfillment.add_subfulfillment(vw_fulfillment)
threshold_fulfillment.add_subfulfillment(tel_fulfillment)
output = {
'amount': 1,
'condition': {
'details': threshold_fulfillment.to_dict(),
'uri': threshold_fulfillment.condition.serialize_uri()
},
'public_keys': [vw_pk, vehicle_id]
}
# Create the transaction
tx_create = Transaction.create([vw_pk], [([vw_pk, vehicle_id], 1)],
asset=data,
metadata=metadata)
# Override the condition we our custom build one
tx_create.outputs[0] = Output.from_dict(output)
# Sign the transaction
tx_create_signed = tx_create.sign([vw_sk])
return tx_create_signed
def create(owner_before, outputs, metadata, asset_data):
"""
Generate a CREATE transaction.
The CREATE transaction creates a new asset.
"""
input_ = Input.generate([owner_before])
outputs = [Output.from_dict(c) for c in listify(outputs)]
tx = Transaction(Transaction.CREATE, {'data': asset_data}, [input_],
outputs, metadata)
tx = Transaction._to_str(tx.to_dict())
click.echo(tx)
def transfer(inputs, outputs, asset, metadata):
"""
Generate a TRANSFER transaction.
The TRANSFER transaction transfers ownership of a given asset.
"""
inputs = [Input.from_dict(i) for i in listify(inputs)]
outputs = [Output.from_dict(i) for i in listify(outputs)]
tx = Transaction(Transaction.TRANSFER,
asset=asset,
inputs=inputs,
outputs=outputs,
metadata=metadata)
click.echo(Transaction._to_str(tx.to_dict()))
def test_output_hashlock_deserialization():
from bigchaindb.common.transaction import Output
from cryptoconditions import PreimageSha256
secret = b'wow much secret'
hashlock = PreimageSha256(preimage=secret).condition_uri
expected = Output(hashlock, amount=1)
cond = {
'condition': {
'uri': hashlock
},
'public_keys': None,
'amount': '1',
}
cond = Output.from_dict(cond)
assert cond == expected
def test_output_deserialization(user_Ed25519, user_pub):
from bigchaindb.common.transaction import Output
expected = Output(user_Ed25519, [user_pub], 1)
cond = {
'condition': {
'uri': user_Ed25519.condition_uri,
'details': {
'type': 'ed25519-sha-256',
'public_key': b58encode(user_Ed25519.public_key).decode(),
},
},
'public_keys': [user_pub],
'amount': '1',
}
cond = Output.from_dict(cond)
assert cond == expected
