diff --git a/docs/root/generate_http_server_api_documentation.py b/docs/root/generate_http_server_api_documentation.py index 4b84d57..1bf66ae 100644 --- a/docs/root/generate_http_server_api_documentation.py +++ b/docs/root/generate_http_server_api_documentation.py @@ -9,8 +9,11 @@ import json import os import os.path -from planetmint.transactions.common.transaction import Transaction, Input, TransactionLink +from planetmint.transactions.common.input import Input +from planetmint.transactions.common.transaction_link import TransactionLink from planetmint import lib +from planetmint.transactions.types.assets.create import Create +from planetmint.transactions.types.assets.transfer import Transfer from planetmint.web import server @@ -133,7 +136,7 @@ def main(): privkey = 'CfdqtD7sS7FgkMoGPXw55MVGGFwQLAoHYTcBhZDtF99Z' pubkey = '4K9sWUMFwTgaDGPfdynrbxWqWS6sWmKbZoTjxLtVUibD' asset = {'msg': 'Hello Planetmint!'} - tx = Transaction.create([pubkey], [([pubkey], 1)], asset=asset, metadata={'sequence': 0}) + tx = Create.generate([pubkey], [([pubkey], 1)], asset=asset, metadata={'sequence': 0}) tx = tx.sign([privkey]) ctx['tx'] = pretty_json(tx.to_dict()) ctx['public_keys'] = tx.outputs[0].public_keys[0] @@ -147,7 +150,7 @@ def main(): input_ = Input(fulfillment=tx.outputs[cid].fulfillment, fulfills=TransactionLink(txid=tx.id, output=cid), owners_before=tx.outputs[cid].public_keys) - tx_transfer = Transaction.transfer([input_], [([pubkey_transfer], 1)], asset_id=tx.id, metadata={'sequence': 1}) + tx_transfer = Transfer.generate([input_], [([pubkey_transfer], 1)], asset_id=tx.id, metadata={'sequence': 1}) tx_transfer = tx_transfer.sign([privkey]) ctx['tx_transfer'] = pretty_json(tx_transfer.to_dict()) ctx['public_keys_transfer'] = tx_transfer.outputs[0].public_keys[0] @@ -160,7 +163,7 @@ def main(): input_ = Input(fulfillment=tx_transfer.outputs[cid].fulfillment, fulfills=TransactionLink(txid=tx_transfer.id, output=cid), owners_before=tx_transfer.outputs[cid].public_keys) - tx_transfer_last = Transaction.transfer([input_], [([pubkey_transfer_last], 1)], + tx_transfer_last = Transfer.generate([input_], [([pubkey_transfer_last], 1)], asset_id=tx.id, metadata={'sequence': 2}) tx_transfer_last = tx_transfer_last.sign([privkey_transfer]) ctx['tx_transfer_last'] = pretty_json(tx_transfer_last.to_dict()) diff --git a/planetmint/transactions/common/transaction.py b/planetmint/transactions/common/transaction.py index e89aa6b..c21e99f 100644 --- a/planetmint/transactions/common/transaction.py +++ b/planetmint/transactions/common/transaction.py @@ -167,137 +167,6 @@ class Transaction(object): def _hash(self): self._id = hash_data(self.serialized) - @classmethod - def validate_create(cls, tx_signers, recipients, asset, metadata): - if not isinstance(tx_signers, list): - raise TypeError('`tx_signers` must be a list instance') - if not isinstance(recipients, list): - raise TypeError('`recipients` must be a list instance') - if len(tx_signers) == 0: - raise ValueError('`tx_signers` list cannot be empty') - if len(recipients) == 0: - raise ValueError('`recipients` list cannot be empty') - if not (asset is None or isinstance(asset, dict)): - raise TypeError('`asset` must be a dict or None') - if not (metadata is None or isinstance(metadata, dict)): - raise TypeError('`metadata` must be a dict or None') - - inputs = [] - outputs = [] - - # generate_outputs - for recipient in recipients: - if not isinstance(recipient, tuple) or len(recipient) != 2: - raise ValueError(('Each `recipient` in the list must be a' - ' tuple of `([],' - ' )`')) - pub_keys, amount = recipient - outputs.append(Output.generate(pub_keys, amount)) - - # generate inputs - inputs.append(Input.generate(tx_signers)) - - return (inputs, outputs) - - @classmethod - def create(cls, tx_signers, recipients, metadata=None, asset=None): - """A simple way to generate a `CREATE` transaction. - - Note: - This method currently supports the following Cryptoconditions - use cases: - - Ed25519 - - ThresholdSha256 - - Additionally, it provides support for the following Planetmint - use cases: - - Multiple inputs and outputs. - - Args: - tx_signers (:obj:`list` of :obj:`str`): A list of keys that - represent the signers of the CREATE Transaction. - recipients (:obj:`list` of :obj:`tuple`): A list of - ([keys],amount) that represent the recipients of this - Transaction. - metadata (dict): The metadata to be stored along with the - Transaction. - asset (dict): The metadata associated with the asset that will - be created in this Transaction. - - Returns: - :class:`~planetmint.transactions.common.transaction.Transaction` - """ - - (inputs, outputs) = cls.validate_create(tx_signers, recipients, asset, metadata) - return cls(cls.CREATE, {'data': asset}, inputs, outputs, metadata) - - @classmethod - def validate_transfer(cls, inputs, recipients, asset_id, metadata): - if not isinstance(inputs, list): - raise TypeError('`inputs` must be a list instance') - if len(inputs) == 0: - raise ValueError('`inputs` must contain at least one item') - if not isinstance(recipients, list): - raise TypeError('`recipients` must be a list instance') - if len(recipients) == 0: - raise ValueError('`recipients` list cannot be empty') - - outputs = [] - for recipient in recipients: - if not isinstance(recipient, tuple) or len(recipient) != 2: - raise ValueError(('Each `recipient` in the list must be a' - ' tuple of `([],' - ' )`')) - pub_keys, amount = recipient - outputs.append(Output.generate(pub_keys, amount)) - - if not isinstance(asset_id, str): - raise TypeError('`asset_id` must be a string') - - return (deepcopy(inputs), outputs) - - @classmethod - def transfer(cls, inputs, recipients, asset_id, metadata=None): - """A simple way to generate a `TRANSFER` transaction. - - Note: - Different cases for threshold conditions: - - Combining multiple `inputs` with an arbitrary number of - `recipients` can yield interesting cases for the creation of - threshold conditions we'd like to support. The following - notation is proposed: - - 1. The index of a `recipient` corresponds to the index of - an input: - e.g. `transfer([input1], [a])`, means `input1` would now be - owned by user `a`. - - 2. `recipients` can (almost) get arbitrary deeply nested, - creating various complex threshold conditions: - e.g. `transfer([inp1, inp2], [[a, [b, c]], d])`, means - `a`'s signature would have a 50% weight on `inp1` - compared to `b` and `c` that share 25% of the leftover - weight respectively. `inp2` is owned completely by `d`. - - Args: - inputs (:obj:`list` of :class:`~planetmint.transactions.common.transaction. - Input`): Converted `Output`s, intended to - be used as inputs in the transfer to generate. - recipients (:obj:`list` of :obj:`tuple`): A list of - ([keys],amount) that represent the recipients of this - Transaction. - asset_id (str): The asset ID of the asset to be transferred in - this Transaction. - metadata (dict): Python dictionary to be stored along with the - Transaction. - - Returns: - :class:`~planetmint.transactions.common.transaction.Transaction` - """ - (inputs, outputs) = cls.validate_transfer(inputs, recipients, asset_id, metadata) - return cls(cls.TRANSFER, {'id': asset_id}, inputs, outputs, metadata) - def __eq__(self, other): try: other = other.to_dict() diff --git a/planetmint/transactions/types/assets/create.py b/planetmint/transactions/types/assets/create.py index d8a1222..3a38783 100644 --- a/planetmint/transactions/types/assets/create.py +++ b/planetmint/transactions/types/assets/create.py @@ -3,7 +3,7 @@ # SPDX-License-Identifier: (Apache-2.0 AND CC-BY-4.0) # Code is Apache-2.0 and docs are CC-BY-4.0 -from planetmint.transactions.common.transaction import Transaction +from planetmint.models import Transaction from planetmint.transactions.common.input import Input from planetmint.transactions.common.output import Output @@ -13,7 +13,7 @@ class Create(Transaction): ALLOWED_OPERATIONS = (OPERATION,) @classmethod - def validate(self, tx_signers, recipients, asset, metadata): + def validate_create(self, tx_signers, recipients, asset, metadata): if not isinstance(tx_signers, list): raise TypeError('`tx_signers` must be a list instance') if not isinstance(recipients, list): @@ -73,5 +73,5 @@ class Create(Transaction): :class:`~planetmint.common.transaction.Transaction` """ - (inputs, outputs) = cls.validate(tx_signers, recipients, asset, metadata) + (inputs, outputs) = cls.validate_create(tx_signers, recipients, asset, metadata) return cls(cls.OPERATION, {'data': asset}, inputs, outputs, metadata) diff --git a/planetmint/transactions/types/assets/transfer.py b/planetmint/transactions/types/assets/transfer.py index 9fb709b..a658bc0 100644 --- a/planetmint/transactions/types/assets/transfer.py +++ b/planetmint/transactions/types/assets/transfer.py @@ -3,7 +3,7 @@ # SPDX-License-Identifier: (Apache-2.0 AND CC-BY-4.0) # Code is Apache-2.0 and docs are CC-BY-4.0 -from planetmint.transactions.common.transaction import Transaction +from planetmint.models import Transaction from planetmint.transactions.common.output import Output from copy import deepcopy @@ -13,7 +13,7 @@ class Transfer(Transaction): ALLOWED_OPERATIONS = (OPERATION,) @classmethod - def validate(cls, inputs, recipients, asset_id, metadata): + def validate_transfer(cls, inputs, recipients, asset_id, metadata): if not isinstance(inputs, list): raise TypeError('`inputs` must be a list instance') if len(inputs) == 0: diff --git a/planetmint/transactions/types/elections/election.py b/planetmint/transactions/types/elections/election.py index d74fcbd..984d179 100644 --- a/planetmint/transactions/types/elections/election.py +++ b/planetmint/transactions/types/elections/election.py @@ -143,7 +143,7 @@ class Election(Transaction): uuid = uuid4() election_data['seed'] = str(uuid) - (inputs, outputs) = cls.validate_create(initiator, voters, election_data, metadata) + (inputs, outputs) = Create.validate_create(initiator, voters, election_data, metadata) election = cls(cls.OPERATION, {'data': election_data}, inputs, outputs, metadata) cls.validate_schema(election.to_dict()) return election diff --git a/planetmint/transactions/types/elections/vote.py b/planetmint/transactions/types/elections/vote.py index a4b25f3..c102a8c 100644 --- a/planetmint/transactions/types/elections/vote.py +++ b/planetmint/transactions/types/elections/vote.py @@ -5,12 +5,11 @@ from planetmint.transactions.types.assets.create import Create from planetmint.transactions.types.assets.transfer import Transfer -from planetmint.transactions.common.transaction import Transaction from planetmint.transactions.common.schema import ( _validate_schema, TX_SCHEMA_COMMON, TX_SCHEMA_TRANSFER, TX_SCHEMA_VOTE) -class Vote(Transaction): +class Vote(Transfer): OPERATION = 'VOTE' # NOTE: This class inherits TRANSFER txn type. The `TRANSFER` property is diff --git a/tests/assets/test_digital_assets.py b/tests/assets/test_digital_assets.py index b23b05d..3a5b88b 100644 --- a/tests/assets/test_digital_assets.py +++ b/tests/assets/test_digital_assets.py @@ -5,12 +5,11 @@ import pytest import random - +from planetmint.transactions.types.assets.create import Create +from planetmint.transactions.types.assets.transfer import Transfer def test_asset_transfer(b, signed_create_tx, user_pk, user_sk): - from planetmint.models import Transaction - - tx_transfer = Transaction.transfer(signed_create_tx.to_inputs(), [([user_pk], 1)], + tx_transfer = Transfer.generate(signed_create_tx.to_inputs(), [([user_pk], 1)], signed_create_tx.id) tx_transfer_signed = tx_transfer.sign([user_sk]) @@ -22,9 +21,8 @@ def test_asset_transfer(b, signed_create_tx, user_pk, user_sk): def test_validate_transfer_asset_id_mismatch(b, signed_create_tx, user_pk, user_sk): from planetmint.transactions.common.exceptions import AssetIdMismatch - from planetmint.models import Transaction - tx_transfer = Transaction.transfer(signed_create_tx.to_inputs(), [([user_pk], 1)], + tx_transfer = Transfer.generate(signed_create_tx.to_inputs(), [([user_pk], 1)], signed_create_tx.id) tx_transfer.asset['id'] = 'a' * 64 tx_transfer_signed = tx_transfer.sign([user_sk]) @@ -37,14 +35,14 @@ def test_validate_transfer_asset_id_mismatch(b, signed_create_tx, user_pk, user_ def test_get_asset_id_create_transaction(alice, user_pk): from planetmint.models import Transaction - tx_create = Transaction.create([alice.public_key], [([user_pk], 1)]) + tx_create = Create.generate([alice.public_key], [([user_pk], 1)]) assert Transaction.get_asset_id(tx_create) == tx_create.id def test_get_asset_id_transfer_transaction(b, signed_create_tx, user_pk): from planetmint.models import Transaction - tx_transfer = Transaction.transfer(signed_create_tx.to_inputs(), [([user_pk], 1)], + tx_transfer = Transfer.generate(signed_create_tx.to_inputs(), [([user_pk], 1)], signed_create_tx.id) asset_id = Transaction.get_asset_id(tx_transfer) assert asset_id == tx_transfer.asset['id'] @@ -54,10 +52,10 @@ def test_asset_id_mismatch(alice, user_pk): from planetmint.models import Transaction from planetmint.transactions.common.exceptions import AssetIdMismatch - tx1 = Transaction.create([alice.public_key], [([user_pk], 1)], + tx1 = Create.generate([alice.public_key], [([user_pk], 1)], metadata={'msg': random.random()}) tx1.sign([alice.private_key]) - tx2 = Transaction.create([alice.public_key], [([user_pk], 1)], + tx2 = Create.generate([alice.public_key], [([user_pk], 1)], metadata={'msg': random.random()}) tx2.sign([alice.private_key]) @@ -66,8 +64,7 @@ def test_asset_id_mismatch(alice, user_pk): def test_create_valid_divisible_asset(b, user_pk, user_sk): - from planetmint.models import Transaction - tx = Transaction.create([user_pk], [([user_pk], 2)]) + tx = Create.generate([user_pk], [([user_pk], 2)]) tx_signed = tx.sign([user_sk]) assert tx_signed.validate(b) == tx_signed diff --git a/tests/assets/test_divisible_assets.py b/tests/assets/test_divisible_assets.py index 570be4b..4381c06 100644 --- a/tests/assets/test_divisible_assets.py +++ b/tests/assets/test_divisible_assets.py @@ -3,9 +3,12 @@ # SPDX-License-Identifier: (Apache-2.0 AND CC-BY-4.0) # Code is Apache-2.0 and docs are CC-BY-4.0 + import pytest import random +from planetmint.transactions.types.assets.create import Create +from planetmint.transactions.types.assets.transfer import Transfer from planetmint.transactions.common.exceptions import DoubleSpend @@ -15,9 +18,8 @@ from planetmint.transactions.common.exceptions import DoubleSpend # Single output # Single owners_after def test_single_in_single_own_single_out_single_own_create(alice, user_pk, b): - from planetmint.models import Transaction - tx = Transaction.create([alice.public_key], [([user_pk], 100)], asset={'name': random.random()}) + tx = Create.generate([alice.public_key], [([user_pk], 100)], asset={'name': random.random()}) tx_signed = tx.sign([alice.private_key]) assert tx_signed.validate(b) == tx_signed @@ -32,9 +34,8 @@ def test_single_in_single_own_single_out_single_own_create(alice, user_pk, b): # Multiple outputs # Single owners_after per output def test_single_in_single_own_multiple_out_single_own_create(alice, user_pk, b): - from planetmint.models import Transaction - tx = Transaction.create([alice.public_key], [([user_pk], 50), ([user_pk], 50)], + tx = Create.generate([alice.public_key], [([user_pk], 50), ([user_pk], 50)], asset={'name': random.random()}) tx_signed = tx.sign([alice.private_key]) @@ -51,9 +52,8 @@ def test_single_in_single_own_multiple_out_single_own_create(alice, user_pk, b): # Single output # Multiple owners_after def test_single_in_single_own_single_out_multiple_own_create(alice, user_pk, b): - from planetmint.models import Transaction - tx = Transaction.create([alice.public_key], [([user_pk, user_pk], 100)], asset={'name': random.random()}) + tx = Create.generate([alice.public_key], [([user_pk, user_pk], 100)], asset={'name': random.random()}) tx_signed = tx.sign([alice.private_key]) assert tx_signed.validate(b) == tx_signed @@ -74,9 +74,8 @@ def test_single_in_single_own_single_out_multiple_own_create(alice, user_pk, b): # Mix: one output with a single owners_after, one output with multiple # owners_after def test_single_in_single_own_multiple_out_mix_own_create(alice, user_pk, b): - from planetmint.models import Transaction - tx = Transaction.create([alice.public_key], [([user_pk], 50), ([user_pk, user_pk], 50)], + tx = Create.generate([alice.public_key], [([user_pk], 50), ([user_pk, user_pk], 50)], asset={'name': random.random()}) tx_signed = tx.sign([alice.private_key]) @@ -98,10 +97,9 @@ def test_single_in_single_own_multiple_out_mix_own_create(alice, user_pk, b): # Output combinations already tested above def test_single_in_multiple_own_single_out_single_own_create(alice, b, user_pk, user_sk): - from planetmint.models import Transaction from planetmint.transactions.common.utils import _fulfillment_to_details - tx = Transaction.create([alice.public_key, user_pk], [([user_pk], 100)], asset={'name': random.random()}) + tx = Create.generate([alice.public_key, user_pk], [([user_pk], 100)], asset={'name': random.random()}) tx_signed = tx.sign([alice.private_key, user_sk]) assert tx_signed.validate(b) == tx_signed assert len(tx_signed.outputs) == 1 @@ -120,14 +118,13 @@ def test_single_in_multiple_own_single_out_single_own_create(alice, b, user_pk, # Single owners_after def test_single_in_single_own_single_out_single_own_transfer(alice, b, user_pk, user_sk): - from planetmint.models import Transaction # CREATE divisible asset - tx_create = Transaction.create([alice.public_key], [([user_pk], 100)], asset={'name': random.random()}) + tx_create = Create.generate([alice.public_key], [([user_pk], 100)], asset={'name': random.random()}) tx_create_signed = tx_create.sign([alice.private_key]) # TRANSFER - tx_transfer = Transaction.transfer(tx_create.to_inputs(), [([alice.public_key], 100)], + tx_transfer = Transfer.generate(tx_create.to_inputs(), [([alice.public_key], 100)], asset_id=tx_create.id) tx_transfer_signed = tx_transfer.sign([user_sk]) @@ -146,14 +143,13 @@ def test_single_in_single_own_single_out_single_own_transfer(alice, b, user_pk, # Single owners_after def test_single_in_single_own_multiple_out_single_own_transfer(alice, b, user_pk, user_sk): - from planetmint.models import Transaction # CREATE divisible asset - tx_create = Transaction.create([alice.public_key], [([user_pk], 100)], asset={'name': random.random()}) + tx_create = Create.generate([alice.public_key], [([user_pk], 100)], asset={'name': random.random()}) tx_create_signed = tx_create.sign([alice.private_key]) # TRANSFER - tx_transfer = Transaction.transfer(tx_create.to_inputs(), + tx_transfer = Transfer.generate(tx_create.to_inputs(), [([alice.public_key], 50), ([alice.public_key], 50)], asset_id=tx_create.id) tx_transfer_signed = tx_transfer.sign([user_sk]) @@ -174,14 +170,13 @@ def test_single_in_single_own_multiple_out_single_own_transfer(alice, b, user_pk # Multiple owners_after def test_single_in_single_own_single_out_multiple_own_transfer(alice, b, user_pk, user_sk): - from planetmint.models import Transaction # CREATE divisible asset - tx_create = Transaction.create([alice.public_key], [([user_pk], 100)], asset={'name': random.random()}) + tx_create = Create.generate([alice.public_key], [([user_pk], 100)], asset={'name': random.random()}) tx_create_signed = tx_create.sign([alice.private_key]) # TRANSFER - tx_transfer = Transaction.transfer(tx_create.to_inputs(), + tx_transfer = Transfer.generate(tx_create.to_inputs(), [([alice.public_key, alice.public_key], 100)], asset_id=tx_create.id) tx_transfer_signed = tx_transfer.sign([user_sk]) @@ -211,14 +206,13 @@ def test_single_in_single_own_single_out_multiple_own_transfer(alice, b, user_pk # owners_after def test_single_in_single_own_multiple_out_mix_own_transfer(alice, b, user_pk, user_sk): - from planetmint.models import Transaction # CREATE divisible asset - tx_create = Transaction.create([alice.public_key], [([user_pk], 100)], asset={'name': random.random()}) + tx_create = Create.generate([alice.public_key], [([user_pk], 100)], asset={'name': random.random()}) tx_create_signed = tx_create.sign([alice.private_key]) # TRANSFER - tx_transfer = Transaction.transfer(tx_create.to_inputs(), + tx_transfer = Transfer.generate(tx_create.to_inputs(), [([alice.public_key], 50), ([alice.public_key, alice.public_key], 50)], asset_id=tx_create.id) tx_transfer_signed = tx_transfer.sign([user_sk]) @@ -248,16 +242,15 @@ def test_single_in_single_own_multiple_out_mix_own_transfer(alice, b, user_pk, # Single owners_after def test_single_in_multiple_own_single_out_single_own_transfer(alice, b, user_pk, user_sk): - from planetmint.models import Transaction from planetmint.transactions.common.utils import _fulfillment_to_details # CREATE divisible asset - tx_create = Transaction.create([alice.public_key], [([alice.public_key, user_pk], 100)], + tx_create = Create.generate([alice.public_key], [([alice.public_key, user_pk], 100)], asset={'name': random.random()}) tx_create_signed = tx_create.sign([alice.private_key]) # TRANSFER - tx_transfer = Transaction.transfer(tx_create.to_inputs(), [([alice.public_key], 100)], + tx_transfer = Transfer.generate(tx_create.to_inputs(), [([alice.public_key], 100)], asset_id=tx_create.id) tx_transfer_signed = tx_transfer.sign([alice.private_key, user_sk]) @@ -284,15 +277,13 @@ def test_single_in_multiple_own_single_out_single_own_transfer(alice, b, user_pk # Single owners_after def test_multiple_in_single_own_single_out_single_own_transfer(alice, b, user_pk, user_sk): - from planetmint.models import Transaction - # CREATE divisible asset - tx_create = Transaction.create([alice.public_key], [([user_pk], 50), ([user_pk], 50)], + tx_create = Create.generate([alice.public_key], [([user_pk], 50), ([user_pk], 50)], asset={'name': random.random()}) tx_create_signed = tx_create.sign([alice.private_key]) # TRANSFER - tx_transfer = Transaction.transfer(tx_create.to_inputs(), [([alice.public_key], 100)], + tx_transfer = Transfer.generate(tx_create.to_inputs(), [([alice.public_key], 100)], asset_id=tx_create.id) tx_transfer_signed = tx_transfer.sign([user_sk]) @@ -314,18 +305,17 @@ def test_multiple_in_single_own_single_out_single_own_transfer(alice, b, user_pk # Single output # Single owners_after def test_multiple_in_multiple_own_single_out_single_own_transfer(alice, b, user_pk, - user_sk): - from planetmint.models import Transaction + user_sk): from planetmint.transactions.common.utils import _fulfillment_to_details # CREATE divisible asset - tx_create = Transaction.create([alice.public_key], [([user_pk, alice.public_key], 50), - ([user_pk, alice.public_key], 50)], - asset={'name': random.random()}) + tx_create = Create.generate([alice.public_key], [([user_pk, alice.public_key], 50), + ([user_pk, alice.public_key], 50)], + asset={'name': random.random()}) tx_create_signed = tx_create.sign([alice.private_key]) # TRANSFER - tx_transfer = Transaction.transfer(tx_create.to_inputs(), [([alice.public_key], 100)], + tx_transfer = Transfer.generate(tx_create.to_inputs(), [([alice.public_key], 100)], asset_id=tx_create.id) tx_transfer_signed = tx_transfer.sign([alice.private_key, user_sk]) @@ -356,16 +346,15 @@ def test_multiple_in_multiple_own_single_out_single_own_transfer(alice, b, user_ # Single owners_after def test_muiltiple_in_mix_own_multiple_out_single_own_transfer(alice, b, user_pk, user_sk): - from planetmint.models import Transaction from planetmint.transactions.common.utils import _fulfillment_to_details # CREATE divisible asset - tx_create = Transaction.create([alice.public_key], [([user_pk], 50), ([user_pk, alice.public_key], 50)], + tx_create = Create.generate([alice.public_key], [([user_pk], 50), ([user_pk, alice.public_key], 50)], asset={'name': random.random()}) tx_create_signed = tx_create.sign([alice.private_key]) # TRANSFER - tx_transfer = Transaction.transfer(tx_create.to_inputs(), [([alice.public_key], 100)], + tx_transfer = Transfer.generate(tx_create.to_inputs(), [([alice.public_key], 100)], asset_id=tx_create.id) tx_transfer_signed = tx_transfer.sign([alice.private_key, user_sk]) @@ -396,16 +385,15 @@ def test_muiltiple_in_mix_own_multiple_out_single_own_transfer(alice, b, user_pk # owners_after def test_muiltiple_in_mix_own_multiple_out_mix_own_transfer(alice, b, user_pk, user_sk): - from planetmint.models import Transaction from planetmint.transactions.common.utils import _fulfillment_to_details # CREATE divisible asset - tx_create = Transaction.create([alice.public_key], [([user_pk], 50), ([user_pk, alice.public_key], 50)], + tx_create = Create.generate([alice.public_key], [([user_pk], 50), ([user_pk, alice.public_key], 50)], asset={'name': random.random()}) tx_create_signed = tx_create.sign([alice.private_key]) # TRANSFER - tx_transfer = Transaction.transfer(tx_create.to_inputs(), + tx_transfer = Transfer.generate(tx_create.to_inputs(), [([alice.public_key], 50), ([alice.public_key, user_pk], 50)], asset_id=tx_create.id) tx_transfer_signed = tx_transfer.sign([alice.private_key, user_sk]) @@ -441,12 +429,11 @@ def test_muiltiple_in_mix_own_multiple_out_mix_own_transfer(alice, b, user_pk, # Single output # Single owners_after def test_multiple_in_different_transactions(alice, b, user_pk, user_sk): - from planetmint.models import Transaction # CREATE divisible asset # `b` creates a divisible asset and assigns 50 shares to `b` and # 50 shares to `user_pk` - tx_create = Transaction.create([alice.public_key], [([user_pk], 50), ([alice.public_key], 50)], + tx_create = Create.generate([alice.public_key], [([user_pk], 50), ([alice.public_key], 50)], asset={'name': random.random()}) tx_create_signed = tx_create.sign([alice.private_key]) @@ -454,7 +441,7 @@ def test_multiple_in_different_transactions(alice, b, user_pk, user_sk): # `b` transfers its 50 shares to `user_pk` # after this transaction `user_pk` will have a total of 100 shares # split across two different transactions - tx_transfer1 = Transaction.transfer(tx_create.to_inputs([1]), + tx_transfer1 = Transfer.generate(tx_create.to_inputs([1]), [([user_pk], 50)], asset_id=tx_create.id) tx_transfer1_signed = tx_transfer1.sign([alice.private_key]) @@ -462,7 +449,7 @@ def test_multiple_in_different_transactions(alice, b, user_pk, user_sk): # TRANSFER # `user_pk` combines two different transaction with 50 shares each and # transfers a total of 100 shares back to `b` - tx_transfer2 = Transaction.transfer(tx_create.to_inputs([0]) + + tx_transfer2 = Transfer.generate(tx_create.to_inputs([0]) + tx_transfer1.to_inputs([0]), [([alice.private_key], 100)], asset_id=tx_create.id) @@ -485,18 +472,17 @@ def test_multiple_in_different_transactions(alice, b, user_pk, user_sk): # inputs needs to match the amount being sent in the outputs. # In other words `amount_in_inputs - amount_in_outputs == 0` def test_amount_error_transfer(alice, b, user_pk, user_sk): - from planetmint.models import Transaction from planetmint.transactions.common.exceptions import AmountError # CREATE divisible asset - tx_create = Transaction.create([alice.public_key], [([user_pk], 100)], asset={'name': random.random()}) + tx_create = Create.generate([alice.public_key], [([user_pk], 100)], asset={'name': random.random()}) tx_create_signed = tx_create.sign([alice.private_key]) b.store_bulk_transactions([tx_create_signed]) # TRANSFER # output amount less than input amount - tx_transfer = Transaction.transfer(tx_create.to_inputs(), [([alice.public_key], 50)], + tx_transfer = Transfer.generate(tx_create.to_inputs(), [([alice.public_key], 50)], asset_id=tx_create.id) tx_transfer_signed = tx_transfer.sign([user_sk]) @@ -505,7 +491,7 @@ def test_amount_error_transfer(alice, b, user_pk, user_sk): # TRANSFER # output amount greater than input amount - tx_transfer = Transaction.transfer(tx_create.to_inputs(), [([alice.public_key], 101)], + tx_transfer = Transfer.generate(tx_create.to_inputs(), [([alice.public_key], 101)], asset_id=tx_create.id) tx_transfer_signed = tx_transfer.sign([user_sk]) @@ -521,15 +507,13 @@ def test_threshold_same_public_key(alice, b, user_pk, user_sk): # Creating threshold conditions with the same key does not make sense but # that does not mean that the code shouldn't work. - from planetmint.models import Transaction - # CREATE divisible asset - tx_create = Transaction.create([alice.public_key], [([user_pk, user_pk], 100)], + tx_create = Create.generate([alice.public_key], [([user_pk, user_pk], 100)], asset={'name': random.random()}) tx_create_signed = tx_create.sign([alice.private_key]) # TRANSFER - tx_transfer = Transaction.transfer(tx_create.to_inputs(), [([alice.public_key], 100)], + tx_transfer = Transfer.generate(tx_create.to_inputs(), [([alice.public_key], 100)], asset_id=tx_create.id) tx_transfer_signed = tx_transfer.sign([user_sk, user_sk]) @@ -543,16 +527,15 @@ def test_threshold_same_public_key(alice, b, user_pk, user_sk): def test_sum_amount(alice, b, user_pk, user_sk): - from planetmint.models import Transaction # CREATE divisible asset with 3 outputs with amount 1 - tx_create = Transaction.create([alice.public_key], [([user_pk], 1), ([user_pk], 1), ([user_pk], 1)], + tx_create = Create.generate([alice.public_key], [([user_pk], 1), ([user_pk], 1), ([user_pk], 1)], asset={'name': random.random()}) tx_create_signed = tx_create.sign([alice.private_key]) # create a transfer transaction with one output and check if the amount # is 3 - tx_transfer = Transaction.transfer(tx_create.to_inputs(), [([alice.public_key], 3)], + tx_transfer = Transfer.generate(tx_create.to_inputs(), [([alice.public_key], 3)], asset_id=tx_create.id) tx_transfer_signed = tx_transfer.sign([user_sk]) @@ -568,15 +551,14 @@ def test_sum_amount(alice, b, user_pk, user_sk): def test_divide(alice, b, user_pk, user_sk): - from planetmint.models import Transaction # CREATE divisible asset with 1 output with amount 3 - tx_create = Transaction.create([alice.public_key], [([user_pk], 3)], asset={'name': random.random()}) + tx_create = Create.generate([alice.public_key], [([user_pk], 3)], asset={'name': random.random()}) tx_create_signed = tx_create.sign([alice.private_key]) # create a transfer transaction with 3 outputs and check if the amount # of each output is 1 - tx_transfer = Transaction.transfer(tx_create.to_inputs(), + tx_transfer = Transfer.generate(tx_create.to_inputs(), [([alice.public_key], 1), ([alice.public_key], 1), ([alice.public_key], 1)], asset_id=tx_create.id) tx_transfer_signed = tx_transfer.sign([user_sk]) diff --git a/tests/backend/localmongodb/test_queries.py b/tests/backend/localmongodb/test_queries.py index 0557527..80abb5d 100644 --- a/tests/backend/localmongodb/test_queries.py +++ b/tests/backend/localmongodb/test_queries.py @@ -4,6 +4,8 @@ # Code is Apache-2.0 and docs are CC-BY-4.0 from copy import deepcopy +from planetmint.transactions.types.assets.create import Create +from planetmint.transactions.types.assets.transfer import Transfer import pytest import pymongo @@ -215,16 +217,15 @@ def test_get_owned_ids(signed_create_tx, user_pk): def test_get_spending_transactions(user_pk, user_sk): from planetmint.backend import connect, query - from planetmint.models import Transaction conn = connect() out = [([user_pk], 1)] - tx1 = Transaction.create([user_pk], out * 3) + tx1 = Create.generate([user_pk], out * 3) tx1.sign([user_sk]) inputs = tx1.to_inputs() - tx2 = Transaction.transfer([inputs[0]], out, tx1.id).sign([user_sk]) - tx3 = Transaction.transfer([inputs[1]], out, tx1.id).sign([user_sk]) - tx4 = Transaction.transfer([inputs[2]], out, tx1.id).sign([user_sk]) + tx2 = Transfer.generate([inputs[0]], out, tx1.id).sign([user_sk]) + tx3 = Transfer.generate([inputs[1]], out, tx1.id).sign([user_sk]) + tx4 = Transfer.generate([inputs[2]], out, tx1.id).sign([user_sk]) txns = [deepcopy(tx.to_dict()) for tx in [tx1, tx2, tx3, tx4]] conn.db.transactions.insert_many(txns) @@ -237,7 +238,6 @@ def test_get_spending_transactions(user_pk, user_sk): def test_get_spending_transactions_multiple_inputs(): from planetmint.backend import connect, query - from planetmint.models import Transaction from planetmint.transactions.common.crypto import generate_key_pair conn = connect() (alice_sk, alice_pk) = generate_key_pair() @@ -245,20 +245,20 @@ def test_get_spending_transactions_multiple_inputs(): (carol_sk, carol_pk) = generate_key_pair() out = [([alice_pk], 9)] - tx1 = Transaction.create([alice_pk], out).sign([alice_sk]) + tx1 = Create.generate([alice_pk], out).sign([alice_sk]) inputs1 = tx1.to_inputs() - tx2 = Transaction.transfer([inputs1[0]], + tx2 = Transfer.generate([inputs1[0]], [([alice_pk], 6), ([bob_pk], 3)], tx1.id).sign([alice_sk]) inputs2 = tx2.to_inputs() - tx3 = Transaction.transfer([inputs2[0]], + tx3 = Transfer.generate([inputs2[0]], [([bob_pk], 3), ([carol_pk], 3)], tx1.id).sign([alice_sk]) inputs3 = tx3.to_inputs() - tx4 = Transaction.transfer([inputs2[1], inputs3[0]], + tx4 = Transfer.generate([inputs2[1], inputs3[0]], [([carol_pk], 6)], tx1.id).sign([bob_sk]) diff --git a/tests/commands/test_commands.py b/tests/commands/test_commands.py index 1e9384f..df4c1b8 100644 --- a/tests/commands/test_commands.py +++ b/tests/commands/test_commands.py @@ -259,16 +259,16 @@ def test_recover_db_on_start(mock_run_recover, @pytest.mark.bdb def test_run_recover(b, alice, bob): from planetmint.commands.planetmint import run_recover - from planetmint.models import Transaction + from planetmint.transactions.types.assets.create import Create from planetmint.lib import Block from planetmint.backend import query - tx1 = Transaction.create([alice.public_key], + tx1 = Create.generate([alice.public_key], [([alice.public_key], 1)], asset={'cycle': 'hero'}, metadata={'name': 'hohenheim'}) \ .sign([alice.private_key]) - tx2 = Transaction.create([bob.public_key], + tx2 = Create.generate([bob.public_key], [([bob.public_key], 1)], asset={'cycle': 'hero'}, metadata={'name': 'hohenheim'}) \ diff --git a/tests/common/test_memoize.py b/tests/common/test_memoize.py index 8665080..dd047cb 100644 --- a/tests/common/test_memoize.py +++ b/tests/common/test_memoize.py @@ -7,6 +7,7 @@ import pytest from copy import deepcopy from planetmint.models import Transaction +from planetmint.transactions.types.assets.create import Create from planetmint.transactions.common.crypto import generate_key_pair from planetmint.transactions.common.memoize import to_dict, from_dict @@ -23,7 +24,7 @@ def test_memoize_to_dict(b): assert to_dict.cache_info().hits == 0 assert to_dict.cache_info().misses == 0 - tx = Transaction.create([alice.public_key], + tx = Create.generate([alice.public_key], [([alice.public_key], 1)], asset=asset,)\ .sign([alice.private_key]) @@ -49,7 +50,7 @@ def test_memoize_from_dict(b): assert from_dict.cache_info().hits == 0 assert from_dict.cache_info().misses == 0 - tx = Transaction.create([alice.public_key], + tx = Create.generate([alice.public_key], [([alice.public_key], 1)], asset=asset,)\ .sign([alice.private_key]) @@ -76,7 +77,7 @@ def test_memoize_input_valid(b): assert Transaction._input_valid.cache_info().hits == 0 assert Transaction._input_valid.cache_info().misses == 0 - tx = Transaction.create([alice.public_key], + tx = Create.generate([alice.public_key], [([alice.public_key], 1)], asset=asset,)\ .sign([alice.private_key]) diff --git a/tests/common/test_transaction.py b/tests/common/test_transaction.py index 84ddb2b..691e475 100644 --- a/tests/common/test_transaction.py +++ b/tests/common/test_transaction.py @@ -11,6 +11,8 @@ from copy import deepcopy from base58 import b58encode, b58decode from cryptoconditions import Ed25519Sha256 +from planetmint.transactions.types.assets.create import Create +from planetmint.transactions.types.assets.transfer import Transfer from pytest import mark, raises try: from hashlib import sha3_256 @@ -690,7 +692,7 @@ def test_create_create_transaction_single_io(user_output, user_pub, data): 'version': Transaction.VERSION, } - tx = Transaction.create([user_pub], [([user_pub], 1)], metadata=data, + tx = Create.generate([user_pub], [([user_pub], 1)], metadata=data, asset=data) tx_dict = tx.to_dict() tx_dict['inputs'][0]['fulfillment'] = None @@ -703,9 +705,8 @@ def test_create_create_transaction_single_io(user_output, user_pub, data): def test_validate_single_io_create_transaction(user_pub, user_priv, data, asset_definition): - from planetmint.transactions.common.transaction import Transaction - tx = Transaction.create([user_pub], [([user_pub], 1)], metadata=data) + tx = Create.generate([user_pub], [([user_pub], 1)], metadata=data) tx = tx.sign([user_priv]) assert tx.inputs_valid() is True @@ -727,7 +728,7 @@ def test_create_create_transaction_multiple_io(user_output, user2_output, user_p 'operation': 'CREATE', 'version': Transaction.VERSION } - tx = Transaction.create([user_pub, user2_pub], + tx = Create.generate([user_pub, user2_pub], [([user_pub], 1), ([user2_pub], 1)], metadata={'message': 'hello'}).to_dict() tx.pop('id') @@ -739,10 +740,9 @@ def test_create_create_transaction_multiple_io(user_output, user2_output, user_p def test_validate_multiple_io_create_transaction(user_pub, user_priv, user2_pub, user2_priv, asset_definition): - from planetmint.transactions.common.transaction import Transaction from .utils import validate_transaction_model - tx = Transaction.create([user_pub, user2_pub], + tx = Create.generate([user_pub, user2_pub], [([user_pub], 1), ([user2_pub], 1)], metadata={'message': 'hello'}) tx = tx.sign([user_priv, user2_priv]) @@ -774,7 +774,7 @@ def test_create_create_transaction_threshold(user_pub, user2_pub, user3_pub, 'operation': 'CREATE', 'version': Transaction.VERSION } - tx = Transaction.create([user_pub], [([user_pub, user2_pub], 1)], + tx = Create.generate([user_pub], [([user_pub, user2_pub], 1)], metadata=data, asset=data) tx_dict = tx.to_dict() tx_dict.pop('id') @@ -785,10 +785,9 @@ def test_create_create_transaction_threshold(user_pub, user2_pub, user3_pub, def test_validate_threshold_create_transaction(user_pub, user_priv, user2_pub, data, asset_definition): - from planetmint.transactions.common.transaction import Transaction from .utils import validate_transaction_model - tx = Transaction.create([user_pub], [([user_pub, user2_pub], 1)], + tx = Create.generate([user_pub], [([user_pub, user2_pub], 1)], metadata=data) tx = tx.sign([user_priv]) assert tx.inputs_valid() is True @@ -797,25 +796,23 @@ def test_validate_threshold_create_transaction(user_pub, user_priv, user2_pub, def test_create_create_transaction_with_invalid_parameters(user_pub): - from planetmint.transactions.common.transaction import Transaction - with raises(TypeError): - Transaction.create('not a list') + Create.generate('not a list') with raises(TypeError): - Transaction.create([], 'not a list') + Create.generate([], 'not a list') with raises(ValueError): - Transaction.create([], [user_pub]) + Create.generate([], [user_pub]) with raises(ValueError): - Transaction.create([user_pub], []) + Create.generate([user_pub], []) with raises(ValueError): - Transaction.create([user_pub], [user_pub]) + Create.generate([user_pub], [user_pub]) with raises(ValueError): - Transaction.create([user_pub], [([user_pub],)]) + Create.generate([user_pub], [([user_pub],)]) with raises(TypeError): - Transaction.create([user_pub], [([user_pub], 1)], + Create.generate([user_pub], [([user_pub], 1)], metadata='not a dict or none') with raises(TypeError): - Transaction.create([user_pub], + Create.generate([user_pub], [([user_pub], 1)], asset='not a dict or none') @@ -858,7 +855,7 @@ def test_create_transfer_transaction_single_io(tx, user_pub, user2_pub, 'version': Transaction.VERSION } inputs = tx.to_inputs([0]) - transfer_tx = Transaction.transfer(inputs, [([user2_pub], 1)], + transfer_tx = Transfer.generate(inputs, [([user2_pub], 1)], asset_id=tx.id) transfer_tx = transfer_tx.sign([user_priv]) transfer_tx = transfer_tx.to_dict() @@ -889,7 +886,7 @@ def test_create_transfer_transaction_multiple_io(user_pub, user_priv, asset_definition): from planetmint.transactions.common.transaction import Transaction - tx = Transaction.create([user_pub], [([user_pub], 1), ([user2_pub], 1)], + tx = Create.generate([user_pub], [([user_pub], 1), ([user2_pub], 1)], metadata={'message': 'hello'}) tx = tx.sign([user_priv]) @@ -921,7 +918,7 @@ def test_create_transfer_transaction_multiple_io(user_pub, user_priv, 'version': Transaction.VERSION } - transfer_tx = Transaction.transfer(tx.to_inputs(), + transfer_tx = Transfer.generate(tx.to_inputs(), [([user2_pub], 1), ([user2_pub], 1)], asset_id=tx.id) transfer_tx = transfer_tx.sign([user_priv, user2_priv]) @@ -941,25 +938,23 @@ def test_create_transfer_transaction_multiple_io(user_pub, user_priv, def test_create_transfer_with_invalid_parameters(tx, user_pub): - from planetmint.transactions.common.transaction import Transaction - with raises(TypeError): - Transaction.transfer({}, [], tx.id) + Transfer.generate({}, [], tx.id) with raises(ValueError): - Transaction.transfer([], [], tx.id) + Transfer.generate([], [], tx.id) with raises(TypeError): - Transaction.transfer(['fulfillment'], {}, tx.id) + Transfer.generate(['fulfillment'], {}, tx.id) with raises(ValueError): - Transaction.transfer(['fulfillment'], [], tx.id) + Transfer.generate(['fulfillment'], [], tx.id) with raises(ValueError): - Transaction.transfer(['fulfillment'], [user_pub], tx.id) + Transfer.generate(['fulfillment'], [user_pub], tx.id) with raises(ValueError): - Transaction.transfer(['fulfillment'], [([user_pub],)], tx.id) + Transfer.generate(['fulfillment'], [([user_pub],)], tx.id) with raises(TypeError): - Transaction.transfer(['fulfillment'], [([user_pub], 1)], + Transfer.generate(['fulfillment'], [([user_pub], 1)], tx.id, metadata='not a dict or none') with raises(TypeError): - Transaction.transfer(['fulfillment'], [([user_pub], 1)], + Transfer.generate(['fulfillment'], [([user_pub], 1)], ['not a string']) @@ -1019,8 +1014,7 @@ def test_output_from_dict_invalid_amount(user_output): def test_unspent_outputs_property(merlin, alice, bob, carol): - from planetmint.transactions.common.transaction import Transaction - tx = Transaction.create( + tx = Create.generate( [merlin.public_key], [([alice.public_key], 1), ([bob.public_key], 2), diff --git a/tests/conftest.py b/tests/conftest.py index f553538..8216072 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -285,9 +285,9 @@ def mock_get_validators(network_validators): @pytest.fixture def create_tx(alice, user_pk): - from planetmint.models import Transaction + from planetmint.transactions.types.assets.create import Create name = f'I am created by the create_tx fixture. My random identifier is {random.random()}.' - return Transaction.create([alice.public_key], [([user_pk], 1)], asset={'name': name}) + return Create.generate([alice.public_key], [([user_pk], 1)], asset={'name': name}) @pytest.fixture @@ -304,17 +304,17 @@ def posted_create_tx(b, signed_create_tx): @pytest.fixture def signed_transfer_tx(signed_create_tx, user_pk, user_sk): - from planetmint.models import Transaction + from planetmint.transactions.types.assets.transfer import Transfer inputs = signed_create_tx.to_inputs() - tx = Transaction.transfer(inputs, [([user_pk], 1)], asset_id=signed_create_tx.id) + tx = Transfer.generate(inputs, [([user_pk], 1)], asset_id=signed_create_tx.id) return tx.sign([user_sk]) @pytest.fixture def double_spend_tx(signed_create_tx, carol_pubkey, user_sk): - from planetmint.models import Transaction + from planetmint.transactions.types.assets.transfer import Transfer inputs = signed_create_tx.to_inputs() - tx = Transaction.transfer( + tx = Transfer.generate( inputs, [([carol_pubkey], 1)], asset_id=signed_create_tx.id) return tx.sign([user_sk]) @@ -326,11 +326,11 @@ def _get_height(b): @pytest.fixture def inputs(user_pk, b, alice): - from planetmint.models import Transaction + from planetmint.transactions.types.assets.create import Create # create blocks with transactions for `USER` to spend for height in range(1, 4): transactions = [ - Transaction.create( + Create.generate( [alice.public_key], [([user_pk], 1)], metadata={'msg': random.random()}, diff --git a/tests/db/test_bigchain_api.py b/tests/db/test_planetmint_api.py similarity index 85% rename from tests/db/test_bigchain_api.py rename to tests/db/test_planetmint_api.py index 9724cb6..cb95598 100644 --- a/tests/db/test_bigchain_api.py +++ b/tests/db/test_planetmint_api.py @@ -4,6 +4,8 @@ # Code is Apache-2.0 and docs are CC-BY-4.0 from unittest.mock import patch +from planetmint.transactions.types.assets.create import Create +from planetmint.transactions.types.assets.transfer import Transfer import pytest from base58 import b58decode @@ -14,19 +16,18 @@ pytestmark = pytest.mark.bdb class TestBigchainApi(object): def test_get_spent_with_double_spend_detected(self, b, alice): - from planetmint.models import Transaction from planetmint.transactions.common.exceptions import DoubleSpend from planetmint.exceptions import CriticalDoubleSpend - tx = Transaction.create([alice.public_key], [([alice.public_key], 1)]) + tx = Create.generate([alice.public_key], [([alice.public_key], 1)]) tx = tx.sign([alice.private_key]) b.store_bulk_transactions([tx]) - transfer_tx = Transaction.transfer(tx.to_inputs(), [([alice.public_key], 1)], + transfer_tx = Transfer.generate(tx.to_inputs(), [([alice.public_key], 1)], asset_id=tx.id) transfer_tx = transfer_tx.sign([alice.private_key]) - transfer_tx2 = Transaction.transfer(tx.to_inputs(), [([alice.public_key], 2)], + transfer_tx2 = Transfer.generate(tx.to_inputs(), [([alice.public_key], 2)], asset_id=tx.id) transfer_tx2 = transfer_tx2.sign([alice.private_key]) @@ -44,10 +45,9 @@ class TestBigchainApi(object): b.get_spent(tx.id, 0) def test_double_inclusion(self, b, alice): - from planetmint.models import Transaction from planetmint.backend.exceptions import OperationError - tx = Transaction.create([alice.public_key], [([alice.public_key], 1)]) + tx = Create.generate([alice.public_key], [([alice.public_key], 1)]) tx = tx.sign([alice.private_key]) b.store_bulk_transactions([tx]) @@ -56,7 +56,6 @@ class TestBigchainApi(object): b.store_bulk_transactions([tx]) def test_text_search(self, b, alice): - from planetmint.models import Transaction # define the assets asset1 = {'msg': 'Planetmint 1'} @@ -64,11 +63,11 @@ class TestBigchainApi(object): asset3 = {'msg': 'Planetmint 3'} # create the transactions - tx1 = Transaction.create([alice.public_key], [([alice.public_key], 1)], + tx1 = Create.generate([alice.public_key], [([alice.public_key], 1)], asset=asset1).sign([alice.private_key]) - tx2 = Transaction.create([alice.public_key], [([alice.public_key], 1)], + tx2 = Create.generate([alice.public_key], [([alice.public_key], 1)], asset=asset2).sign([alice.private_key]) - tx3 = Transaction.create([alice.public_key], [([alice.public_key], 1)], + tx3 = Create.generate([alice.public_key], [([alice.public_key], 1)], asset=asset3).sign([alice.private_key]) # write the transactions to the DB @@ -83,23 +82,21 @@ class TestBigchainApi(object): from cryptoconditions import Ed25519Sha256 from planetmint.transactions.common.exceptions import InputDoesNotExist from planetmint.transactions.common.transaction import Input, TransactionLink - from planetmint.models import Transaction # Create an input for a non existing transaction input = Input(Ed25519Sha256(public_key=b58decode(user_pk)), [user_pk], TransactionLink('somethingsomething', 0)) - tx = Transaction.transfer([input], [([user_pk], 1)], + tx = Transfer.generate([input], [([user_pk], 1)], asset_id='mock_asset_link') with pytest.raises(InputDoesNotExist): tx.validate(b) def test_write_transaction(self, b, user_sk, user_pk, alice, create_tx): - from planetmint.models import Transaction asset1 = {'msg': 'Planetmint 1'} - tx = Transaction.create([alice.public_key], [([alice.public_key], 1)], + tx = Create.generate([alice.public_key], [([alice.public_key], 1)], asset=asset1).sign([alice.private_key]) b.store_bulk_transactions([tx]) @@ -128,12 +125,11 @@ class TestTransactionValidation(object): def test_non_create_valid_input_wrong_owner(self, b, user_pk): from planetmint.transactions.common.crypto import generate_key_pair from planetmint.transactions.common.exceptions import InvalidSignature - from planetmint.models import Transaction input_tx = b.fastquery.get_outputs_by_public_key(user_pk).pop() input_transaction = b.get_transaction(input_tx.txid) sk, pk = generate_key_pair() - tx = Transaction.create([pk], [([user_pk], 1)]) + tx = Create.generate([pk], [([user_pk], 1)]) tx.operation = 'TRANSFER' tx.asset = {'id': input_transaction.id} tx.inputs[0].fulfills = input_tx @@ -157,14 +153,13 @@ class TestMultipleInputs(object): def test_transfer_single_owner_single_input(self, b, inputs, user_pk, user_sk): from planetmint.transactions.common import crypto - from planetmint.models import Transaction user2_sk, user2_pk = crypto.generate_key_pair() tx_link = b.fastquery.get_outputs_by_public_key(user_pk).pop() input_tx = b.get_transaction(tx_link.txid) inputs = input_tx.to_inputs() - tx = Transaction.transfer(inputs, [([user2_pk], 1)], + tx = Transfer.generate(inputs, [([user2_pk], 1)], asset_id=input_tx.id) tx = tx.sign([user_sk]) @@ -178,14 +173,13 @@ class TestMultipleInputs(object): user_pk, inputs): from planetmint.transactions.common import crypto - from planetmint.models import Transaction user2_sk, user2_pk = crypto.generate_key_pair() user3_sk, user3_pk = crypto.generate_key_pair() tx_link = b.fastquery.get_outputs_by_public_key(user_pk).pop() input_tx = b.get_transaction(tx_link.txid) - tx = Transaction.transfer(input_tx.to_inputs(), + tx = Transfer.generate(input_tx.to_inputs(), [([user2_pk, user3_pk], 1)], asset_id=input_tx.id) tx = tx.sign([user_sk]) @@ -200,12 +194,11 @@ class TestMultipleInputs(object): user_pk, alice): from planetmint.transactions.common import crypto - from planetmint.models import Transaction user2_sk, user2_pk = crypto.generate_key_pair() user3_sk, user3_pk = crypto.generate_key_pair() - tx = Transaction.create([alice.public_key], [([user_pk, user2_pk], 1)]) + tx = Create.generate([alice.public_key], [([user_pk, user2_pk], 1)]) tx = tx.sign([alice.private_key]) b.store_bulk_transactions([tx]) @@ -213,7 +206,7 @@ class TestMultipleInputs(object): input_tx = b.get_transaction(owned_input.txid) inputs = input_tx.to_inputs() - transfer_tx = Transaction.transfer(inputs, [([user3_pk], 1)], + transfer_tx = Transfer.generate(inputs, [([user3_pk], 1)], asset_id=input_tx.id) transfer_tx = transfer_tx.sign([user_sk, user2_sk]) @@ -228,13 +221,12 @@ class TestMultipleInputs(object): user_pk, alice): from planetmint.transactions.common import crypto - from planetmint.models import Transaction user2_sk, user2_pk = crypto.generate_key_pair() user3_sk, user3_pk = crypto.generate_key_pair() user4_sk, user4_pk = crypto.generate_key_pair() - tx = Transaction.create([alice.public_key], [([user_pk, user2_pk], 1)]) + tx = Create.generate([alice.public_key], [([user_pk, user2_pk], 1)]) tx = tx.sign([alice.private_key]) b.store_bulk_transactions([tx]) @@ -242,7 +234,7 @@ class TestMultipleInputs(object): tx_link = b.fastquery.get_outputs_by_public_key(user_pk).pop() tx_input = b.get_transaction(tx_link.txid) - tx = Transaction.transfer(tx_input.to_inputs(), + tx = Transfer.generate(tx_input.to_inputs(), [([user3_pk, user4_pk], 1)], asset_id=tx_input.id) tx = tx.sign([user_sk, user2_sk]) @@ -254,11 +246,10 @@ class TestMultipleInputs(object): def test_get_owned_ids_single_tx_single_output(self, b, user_sk, user_pk, alice): from planetmint.transactions.common import crypto from planetmint.transactions.common.transaction import TransactionLink - from planetmint.models import Transaction user2_sk, user2_pk = crypto.generate_key_pair() - tx = Transaction.create([alice.public_key], [([user_pk], 1)]) + tx = Create.generate([alice.public_key], [([user_pk], 1)]) tx = tx.sign([alice.private_key]) b.store_bulk_transactions([tx]) @@ -267,7 +258,7 @@ class TestMultipleInputs(object): assert owned_inputs_user1 == [TransactionLink(tx.id, 0)] assert owned_inputs_user2 == [] - tx_transfer = Transaction.transfer(tx.to_inputs(), [([user2_pk], 1)], + tx_transfer = Transfer.generate(tx.to_inputs(), [([user2_pk], 1)], asset_id=tx.id) tx_transfer = tx_transfer.sign([user_sk]) b.store_bulk_transactions([tx_transfer]) @@ -282,12 +273,11 @@ class TestMultipleInputs(object): user_pk, alice): from planetmint.transactions.common import crypto from planetmint.transactions.common.transaction import TransactionLink - from planetmint.models import Transaction user2_sk, user2_pk = crypto.generate_key_pair() # create divisible asset - tx_create = Transaction.create([alice.public_key], [([user_pk], 1), ([user_pk], 1)]) + tx_create = Create.generate([alice.public_key], [([user_pk], 1), ([user_pk], 1)]) tx_create_signed = tx_create.sign([alice.private_key]) b.store_bulk_transactions([tx_create_signed]) @@ -301,7 +291,7 @@ class TestMultipleInputs(object): assert owned_inputs_user2 == [] # transfer divisible asset divided in two outputs - tx_transfer = Transaction.transfer(tx_create.to_inputs(), + tx_transfer = Transfer.generate(tx_create.to_inputs(), [([user2_pk], 1), ([user2_pk], 1)], asset_id=tx_create.id) tx_transfer_signed = tx_transfer.sign([user_sk]) @@ -316,12 +306,11 @@ class TestMultipleInputs(object): def test_get_owned_ids_multiple_owners(self, b, user_sk, user_pk, alice): from planetmint.transactions.common import crypto from planetmint.transactions.common.transaction import TransactionLink - from planetmint.models import Transaction user2_sk, user2_pk = crypto.generate_key_pair() user3_sk, user3_pk = crypto.generate_key_pair() - tx = Transaction.create([alice.public_key], [([user_pk, user2_pk], 1)]) + tx = Create.generate([alice.public_key], [([user_pk, user2_pk], 1)]) tx = tx.sign([alice.private_key]) b.store_bulk_transactions([tx]) @@ -333,7 +322,7 @@ class TestMultipleInputs(object): assert owned_inputs_user1 == owned_inputs_user2 assert owned_inputs_user1 == expected_owned_inputs_user1 - tx = Transaction.transfer(tx.to_inputs(), [([user3_pk], 1)], + tx = Transfer.generate(tx.to_inputs(), [([user3_pk], 1)], asset_id=tx.id) tx = tx.sign([user_sk, user2_sk]) b.store_bulk_transactions([tx]) @@ -347,11 +336,10 @@ class TestMultipleInputs(object): def test_get_spent_single_tx_single_output(self, b, user_sk, user_pk, alice): from planetmint.transactions.common import crypto - from planetmint.models import Transaction user2_sk, user2_pk = crypto.generate_key_pair() - tx = Transaction.create([alice.public_key], [([user_pk], 1)]) + tx = Create.generate([alice.public_key], [([user_pk], 1)]) tx = tx.sign([alice.private_key]) b.store_bulk_transactions([tx]) @@ -363,7 +351,7 @@ class TestMultipleInputs(object): assert spent_inputs_user1 is None # create a transaction and send it - tx = Transaction.transfer(tx.to_inputs(), [([user2_pk], 1)], + tx = Transfer.generate(tx.to_inputs(), [([user2_pk], 1)], asset_id=tx.id) tx = tx.sign([user_sk]) b.store_bulk_transactions([tx]) @@ -373,13 +361,12 @@ class TestMultipleInputs(object): def test_get_spent_single_tx_multiple_outputs(self, b, user_sk, user_pk, alice): from planetmint.transactions.common import crypto - from planetmint.models import Transaction # create a new users user2_sk, user2_pk = crypto.generate_key_pair() # create a divisible asset with 3 outputs - tx_create = Transaction.create([alice.public_key], + tx_create = Create.generate([alice.public_key], [([user_pk], 1), ([user_pk], 1), ([user_pk], 1)]) @@ -393,7 +380,7 @@ class TestMultipleInputs(object): assert b.get_spent(input_tx.txid, input_tx.output) is None # transfer the first 2 inputs - tx_transfer = Transaction.transfer(tx_create.to_inputs()[:2], + tx_transfer = Transfer.generate(tx_create.to_inputs()[:2], [([user2_pk], 1), ([user2_pk], 1)], asset_id=tx_create.id) tx_transfer_signed = tx_transfer.sign([user_sk]) @@ -410,7 +397,6 @@ class TestMultipleInputs(object): def test_get_spent_multiple_owners(self, b, user_sk, user_pk, alice): from planetmint.transactions.common import crypto - from planetmint.models import Transaction user2_sk, user2_pk = crypto.generate_key_pair() user3_sk, user3_pk = crypto.generate_key_pair() @@ -418,7 +404,7 @@ class TestMultipleInputs(object): transactions = [] for i in range(3): payload = {'somedata': i} - tx = Transaction.create([alice.public_key], [([user_pk, user2_pk], 1)], + tx = Create.generate([alice.public_key], [([user_pk, user2_pk], 1)], payload) tx = tx.sign([alice.private_key]) transactions.append(tx) @@ -431,7 +417,7 @@ class TestMultipleInputs(object): assert b.get_spent(input_tx.txid, input_tx.output) is None # create a transaction - tx = Transaction.transfer(transactions[0].to_inputs(), + tx = Transfer.generate(transactions[0].to_inputs(), [([user3_pk], 1)], asset_id=transactions[0].id) tx = tx.sign([user_sk, user2_sk]) @@ -496,11 +482,10 @@ def test_cant_spend_same_input_twice_in_tx(b, alice): """Recreate duplicated fulfillments bug https://github.com/planetmint/planetmint/issues/1099 """ - from planetmint.models import Transaction from planetmint.transactions.common.exceptions import DoubleSpend # create a divisible asset - tx_create = Transaction.create([alice.public_key], [([alice.public_key], 100)]) + tx_create = Create.generate([alice.public_key], [([alice.public_key], 100)]) tx_create_signed = tx_create.sign([alice.private_key]) assert b.validate_transaction(tx_create_signed) == tx_create_signed @@ -508,7 +493,7 @@ def test_cant_spend_same_input_twice_in_tx(b, alice): # Create a transfer transaction with duplicated fulfillments dup_inputs = tx_create.to_inputs() + tx_create.to_inputs() - tx_transfer = Transaction.transfer(dup_inputs, [([alice.public_key], 200)], + tx_transfer = Transfer.generate(dup_inputs, [([alice.public_key], 200)], asset_id=tx_create.id) tx_transfer_signed = tx_transfer.sign([alice.private_key]) with pytest.raises(DoubleSpend): @@ -518,13 +503,12 @@ def test_cant_spend_same_input_twice_in_tx(b, alice): def test_transaction_unicode(b, alice): import copy from planetmint.transactions.common.utils import serialize - from planetmint.models import Transaction # http://www.fileformat.info/info/unicode/char/1f37a/index.htm beer_python = {'beer': '\N{BEER MUG}'} beer_json = '{"beer":"\N{BEER MUG}"}' - tx = (Transaction.create([alice.public_key], [([alice.public_key], 100)], beer_python) + tx = (Create.generate([alice.public_key], [([alice.public_key], 100)], beer_python) ).sign([alice.private_key]) tx_1 = copy.deepcopy(tx) diff --git a/tests/tendermint/test_core.py b/tests/tendermint/test_core.py index 581fbe9..6f4ae8f 100644 --- a/tests/tendermint/test_core.py +++ b/tests/tendermint/test_core.py @@ -4,6 +4,8 @@ # Code is Apache-2.0 and docs are CC-BY-4.0 import json +from planetmint.transactions.types.assets.create import Create +from planetmint.transactions.types.assets.transfer import Transfer import pytest import random @@ -202,13 +204,12 @@ def test_info(b): def test_check_tx__signed_create_is_ok(b): from planetmint import App - from planetmint.models import Transaction from planetmint.transactions.common.crypto import generate_key_pair alice = generate_key_pair() bob = generate_key_pair() - tx = Transaction.create([alice.public_key], + tx = Create.generate([alice.public_key], [([bob.public_key], 1)])\ .sign([alice.private_key]) @@ -219,13 +220,12 @@ def test_check_tx__signed_create_is_ok(b): def test_check_tx__unsigned_create_is_error(b): from planetmint import App - from planetmint.models import Transaction from planetmint.transactions.common.crypto import generate_key_pair alice = generate_key_pair() bob = generate_key_pair() - tx = Transaction.create([alice.public_key], + tx = Create.generate([alice.public_key], [([bob.public_key], 1)]) app = App(b) @@ -236,14 +236,13 @@ def test_check_tx__unsigned_create_is_error(b): def test_deliver_tx__valid_create_updates_db_and_emits_event(b, init_chain_request): import multiprocessing as mp from planetmint import App - from planetmint.models import Transaction from planetmint.transactions.common.crypto import generate_key_pair alice = generate_key_pair() bob = generate_key_pair() events = mp.Queue() - tx = Transaction.create([alice.public_key], + tx = Create.generate([alice.public_key], [([bob.public_key], 1)])\ .sign([alice.private_key]) @@ -273,13 +272,12 @@ def test_deliver_tx__valid_create_updates_db_and_emits_event(b, init_chain_reque def test_deliver_tx__double_spend_fails(b, init_chain_request): from planetmint import App - from planetmint.models import Transaction from planetmint.transactions.common.crypto import generate_key_pair alice = generate_key_pair() bob = generate_key_pair() - tx = Transaction.create([alice.public_key], + tx = Create.generate([alice.public_key], [([bob.public_key], 1)])\ .sign([alice.private_key]) @@ -302,7 +300,6 @@ def test_deliver_tx__double_spend_fails(b, init_chain_request): def test_deliver_transfer_tx__double_spend_fails(b, init_chain_request): from planetmint import App - from planetmint.models import Transaction from planetmint.transactions.common.crypto import generate_key_pair app = App(b) @@ -319,7 +316,7 @@ def test_deliver_transfer_tx__double_spend_fails(b, init_chain_request): 'msg': 'live long and prosper' } - tx = Transaction.create([alice.public_key], + tx = Create.generate([alice.public_key], [([alice.public_key], 1)], asset=asset)\ .sign([alice.private_key]) @@ -327,7 +324,7 @@ def test_deliver_transfer_tx__double_spend_fails(b, init_chain_request): result = app.deliver_tx(encode_tx_to_bytes(tx)) assert result.code == OkCode - tx_transfer = Transaction.transfer(tx.to_inputs(), + tx_transfer = Transfer.generate(tx.to_inputs(), [([bob.public_key], 1)], asset_id=tx.id)\ .sign([alice.private_key]) @@ -335,7 +332,7 @@ def test_deliver_transfer_tx__double_spend_fails(b, init_chain_request): result = app.deliver_tx(encode_tx_to_bytes(tx_transfer)) assert result.code == OkCode - double_spend = Transaction.transfer(tx.to_inputs(), + double_spend = Transfer.generate(tx.to_inputs(), [([carly.public_key], 1)], asset_id=tx.id)\ .sign([alice.private_key]) @@ -382,9 +379,8 @@ def test_end_block_return_validator_updates(b, init_chain_request): def test_store_pre_commit_state_in_end_block(b, alice, init_chain_request): from planetmint import App from planetmint.backend import query - from planetmint.models import Transaction - tx = Transaction.create([alice.public_key], + tx = Create.generate([alice.public_key], [([alice.public_key], 1)], asset={'msg': 'live long and prosper'})\ .sign([alice.private_key]) diff --git a/tests/tendermint/test_fastquery.py b/tests/tendermint/test_fastquery.py index 61f8ac9..d79d511 100644 --- a/tests/tendermint/test_fastquery.py +++ b/tests/tendermint/test_fastquery.py @@ -6,7 +6,8 @@ import pytest from planetmint.transactions.common.transaction import TransactionLink -from planetmint.models import Transaction +from planetmint.transactions.types.assets.create import Create +from planetmint.transactions.types.assets.transfer import Transfer pytestmark = pytest.mark.bdb @@ -14,9 +15,9 @@ pytestmark = pytest.mark.bdb @pytest.fixture def txns(b, user_pk, user_sk, user2_pk, user2_sk): - txs = [Transaction.create([user_pk], [([user2_pk], 1)]).sign([user_sk]), - Transaction.create([user2_pk], [([user_pk], 1)]).sign([user2_sk]), - Transaction.create([user_pk], [([user_pk], 1), ([user2_pk], 1)]) + txs = [Create.generate([user_pk], [([user2_pk], 1)]).sign([user_sk]), + Create.generate([user2_pk], [([user_pk], 1)]).sign([user2_sk]), + Create.generate([user_pk], [([user_pk], 1), ([user2_pk], 1)]) .sign([user_sk])] b.store_bulk_transactions(txs) return txs @@ -35,12 +36,12 @@ def test_get_outputs_by_public_key(b, user_pk, user2_pk, txns): def test_filter_spent_outputs(b, user_pk, user_sk): out = [([user_pk], 1)] - tx1 = Transaction.create([user_pk], out * 2) + tx1 = Create.generate([user_pk], out * 2) tx1.sign([user_sk]) inputs = tx1.to_inputs() - tx2 = Transaction.transfer([inputs[0]], out, tx1.id) + tx2 = Transfer.generate([inputs[0]], out, tx1.id) tx2.sign([user_sk]) # tx2 produces a new unspent. inputs[1] remains unspent. @@ -57,12 +58,12 @@ def test_filter_spent_outputs(b, user_pk, user_sk): def test_filter_unspent_outputs(b, user_pk, user_sk): out = [([user_pk], 1)] - tx1 = Transaction.create([user_pk], out * 2) + tx1 = Create.generate([user_pk], out * 2) tx1.sign([user_sk]) inputs = tx1.to_inputs() - tx2 = Transaction.transfer([inputs[0]], out, tx1.id) + tx2 = Transfer.generate([inputs[0]], out, tx1.id) tx2.sign([user_sk]) # tx2 produces a new unspent. input[1] remains unspent. @@ -80,13 +81,13 @@ def test_outputs_query_key_order(b, user_pk, user_sk, user2_pk, user2_sk): from planetmint import backend from planetmint.backend import connect - tx1 = Transaction.create([user_pk], + tx1 = Create.generate([user_pk], [([user_pk], 3), ([user_pk], 2), ([user_pk], 1)])\ .sign([user_sk]) b.store_bulk_transactions([tx1]) inputs = tx1.to_inputs() - tx2 = Transaction.transfer([inputs[1]], [([user2_pk], 2)], tx1.id).sign([user_sk]) + tx2 = Transfer.generate([inputs[1]], [([user2_pk], 2)], tx1.id).sign([user_sk]) assert tx2.validate(b) tx2_dict = tx2.to_dict() diff --git a/tests/tendermint/test_integration.py b/tests/tendermint/test_integration.py index 45b4db1..69c818d 100644 --- a/tests/tendermint/test_integration.py +++ b/tests/tendermint/test_integration.py @@ -4,6 +4,8 @@ # Code is Apache-2.0 and docs are CC-BY-4.0 import codecs +from planetmint.transactions.types.assets.create import Create +from planetmint.transactions.types.assets.transfer import Transfer from tendermint.abci import types_pb2 as types import json @@ -23,7 +25,6 @@ def test_app(b, eventqueue_fixture, init_chain_request): from planetmint import App from planetmint.tendermint_utils import calculate_hash from planetmint.transactions.common.crypto import generate_key_pair - from planetmint.models import Transaction app = App(b, eventqueue_fixture) p = ProtocolHandler(app) @@ -49,7 +50,7 @@ def test_app(b, eventqueue_fixture, init_chain_request): alice = generate_key_pair() bob = generate_key_pair() - tx = Transaction.create([alice.public_key], + tx = Create.generate([alice.public_key], [([bob.public_key], 1)])\ .sign([alice.private_key]) etxn = json.dumps(tx.to_dict()).encode('utf8') @@ -114,11 +115,10 @@ def test_app(b, eventqueue_fixture, init_chain_request): @pytest.mark.abci def test_post_transaction_responses(tendermint_ws_url, b): from planetmint.transactions.common.crypto import generate_key_pair - from planetmint.models import Transaction alice = generate_key_pair() bob = generate_key_pair() - tx = Transaction.create([alice.public_key], + tx = Create.generate([alice.public_key], [([alice.public_key], 1)], asset=None)\ .sign([alice.private_key]) @@ -126,7 +126,7 @@ def test_post_transaction_responses(tendermint_ws_url, b): code, message = b.write_transaction(tx, BROADCAST_TX_COMMIT) assert code == 202 - tx_transfer = Transaction.transfer(tx.to_inputs(), + tx_transfer = Transfer.generate(tx.to_inputs(), [([bob.public_key], 1)], asset_id=tx.id)\ .sign([alice.private_key]) @@ -135,7 +135,7 @@ def test_post_transaction_responses(tendermint_ws_url, b): assert code == 202 carly = generate_key_pair() - double_spend = Transaction.transfer( + double_spend = Transfer.generate( tx.to_inputs(), [([carly.public_key], 1)], asset_id=tx.id, diff --git a/tests/tendermint/test_lib.py b/tests/tendermint/test_lib.py index 55fd2be..211ece9 100644 --- a/tests/tendermint/test_lib.py +++ b/tests/tendermint/test_lib.py @@ -5,6 +5,8 @@ import os from unittest.mock import patch +from planetmint.transactions.types.assets.create import Create +from planetmint.transactions.types.assets.transfer import Transfer try: @@ -25,7 +27,6 @@ from planetmint.lib import Block @pytest.mark.bdb def test_asset_is_separated_from_transaciton(b): import copy - from planetmint.models import Transaction from planetmint.transactions.common.crypto import generate_key_pair alice = generate_key_pair() @@ -40,7 +41,7 @@ def test_asset_is_separated_from_transaciton(b): 'tell a lie', 'hurt you']} - tx = Transaction.create([alice.public_key], + tx = Create.generate([alice.public_key], [([bob.public_key], 1)], metadata=None, asset=asset)\ @@ -81,11 +82,10 @@ def test_get_empty_block(_0, _1, b): def test_validation_error(b): - from planetmint.models import Transaction from planetmint.transactions.common.crypto import generate_key_pair alice = generate_key_pair() - tx = Transaction.create([alice.public_key], + tx = Create.generate([alice.public_key], [([alice.public_key], 1)], asset=None)\ .sign([alice.private_key]).to_dict() @@ -96,12 +96,11 @@ def test_validation_error(b): @patch('requests.post') def test_write_and_post_transaction(mock_post, b): - from planetmint.models import Transaction from planetmint.transactions.common.crypto import generate_key_pair from planetmint.tendermint_utils import encode_transaction alice = generate_key_pair() - tx = Transaction.create([alice.public_key], + tx = Create.generate([alice.public_key], [([alice.public_key], 1)], asset=None)\ .sign([alice.private_key]).to_dict() @@ -123,10 +122,9 @@ def test_write_and_post_transaction(mock_post, b): BROADCAST_TX_COMMIT ]) def test_post_transaction_valid_modes(mock_post, b, mode): - from planetmint.models import Transaction from planetmint.transactions.common.crypto import generate_key_pair alice = generate_key_pair() - tx = Transaction.create([alice.public_key], + tx = Create.generate([alice.public_key], [([alice.public_key], 1)], asset=None) \ .sign([alice.private_key]).to_dict() @@ -138,11 +136,10 @@ def test_post_transaction_valid_modes(mock_post, b, mode): def test_post_transaction_invalid_mode(b): - from planetmint.models import Transaction from planetmint.transactions.common.crypto import generate_key_pair from planetmint.transactions.common.exceptions import ValidationError alice = generate_key_pair() - tx = Transaction.create([alice.public_key], + tx = Create.generate([alice.public_key], [([alice.public_key], 1)], asset=None) \ .sign([alice.private_key]).to_dict() @@ -354,28 +351,27 @@ def test_get_utxoset_merkle_root(b, utxoset): @pytest.mark.bdb def test_get_spent_transaction_critical_double_spend(b, alice, bob, carol): - from planetmint.models import Transaction from planetmint.exceptions import CriticalDoubleSpend from planetmint.transactions.common.exceptions import DoubleSpend asset = {'test': 'asset'} - tx = Transaction.create([alice.public_key], + tx = Create.generate([alice.public_key], [([alice.public_key], 1)], asset=asset)\ .sign([alice.private_key]) - tx_transfer = Transaction.transfer(tx.to_inputs(), + tx_transfer = Transfer.generate(tx.to_inputs(), [([bob.public_key], 1)], asset_id=tx.id)\ .sign([alice.private_key]) - double_spend = Transaction.transfer(tx.to_inputs(), + double_spend = Transfer.generate(tx.to_inputs(), [([carol.public_key], 1)], asset_id=tx.id)\ .sign([alice.private_key]) - same_input_double_spend = Transaction.transfer(tx.to_inputs() + tx.to_inputs(), + same_input_double_spend = Transfer.generate(tx.to_inputs() + tx.to_inputs(), [([bob.public_key], 1)], asset_id=tx.id)\ .sign([alice.private_key]) @@ -404,15 +400,14 @@ def test_get_spent_transaction_critical_double_spend(b, alice, bob, carol): def test_validation_with_transaction_buffer(b): from planetmint.transactions.common.crypto import generate_key_pair - from planetmint.models import Transaction priv_key, pub_key = generate_key_pair() - create_tx = Transaction.create([pub_key], [([pub_key], 10)]).sign([priv_key]) - transfer_tx = Transaction.transfer(create_tx.to_inputs(), + create_tx = Create.generate([pub_key], [([pub_key], 10)]).sign([priv_key]) + transfer_tx = Transfer.generate(create_tx.to_inputs(), [([pub_key], 10)], asset_id=create_tx.id).sign([priv_key]) - double_spend = Transaction.transfer(create_tx.to_inputs(), + double_spend = Transfer.generate(create_tx.to_inputs(), [([pub_key], 10)], asset_id=create_tx.id).sign([priv_key]) @@ -459,21 +454,20 @@ def test_migrate_abci_chain_generates_new_chains(b, chain, block_height, @pytest.mark.bdb def test_get_spent_key_order(b, user_pk, user_sk, user2_pk, user2_sk): from planetmint import backend - from planetmint.models import Transaction from planetmint.transactions.common.crypto import generate_key_pair from planetmint.transactions.common.exceptions import DoubleSpend alice = generate_key_pair() bob = generate_key_pair() - tx1 = Transaction.create([user_pk], + tx1 = Create.generate([user_pk], [([alice.public_key], 3), ([user_pk], 2)], asset=None)\ .sign([user_sk]) b.store_bulk_transactions([tx1]) inputs = tx1.to_inputs() - tx2 = Transaction.transfer([inputs[1]], [([user2_pk], 2)], tx1.id).sign([user_sk]) + tx2 = Transfer.generate([inputs[1]], [([user2_pk], 2)], tx1.id).sign([user_sk]) assert tx2.validate(b) tx2_dict = tx2.to_dict() @@ -483,7 +477,7 @@ def test_get_spent_key_order(b, user_pk, user_sk, user2_pk, user2_sk): backend.query.store_transactions(b.connection, [tx2_dict]) - tx3 = Transaction.transfer([inputs[1]], [([bob.public_key], 2)], tx1.id).sign([user_sk]) + tx3 = Transfer.generate([inputs[1]], [([bob.public_key], 2)], tx1.id).sign([user_sk]) with pytest.raises(DoubleSpend): tx3.validate(b) diff --git a/tests/test_core.py b/tests/test_core.py index 140cd22..ae02b44 100644 --- a/tests/test_core.py +++ b/tests/test_core.py @@ -4,6 +4,8 @@ # Code is Apache-2.0 and docs are CC-BY-4.0 import json +from planetmint.transactions.types.assets.create import Create +from planetmint.transactions.types.assets.transfer import Transfer import pytest import random @@ -202,13 +204,12 @@ def test_info(b): def test_check_tx__signed_create_is_ok(b): from planetmint import App - from planetmint.models import Transaction from planetmint.transactions.common.crypto import generate_key_pair alice = generate_key_pair() bob = generate_key_pair() - tx = Transaction.create([alice.public_key], + tx = Create.generate([alice.public_key], [([bob.public_key], 1)])\ .sign([alice.private_key]) @@ -219,13 +220,12 @@ def test_check_tx__signed_create_is_ok(b): def test_check_tx__unsigned_create_is_error(b): from planetmint import App - from planetmint.models import Transaction from planetmint.transactions.common.crypto import generate_key_pair alice = generate_key_pair() bob = generate_key_pair() - tx = Transaction.create([alice.public_key], + tx = Create.generate([alice.public_key], [([bob.public_key], 1)]) app = App(b) @@ -236,14 +236,13 @@ def test_check_tx__unsigned_create_is_error(b): def test_deliver_tx__valid_create_updates_db_and_emits_event(b, init_chain_request): import multiprocessing as mp from planetmint import App - from planetmint.models import Transaction from planetmint.transactions.common.crypto import generate_key_pair alice = generate_key_pair() bob = generate_key_pair() events = mp.Queue() - tx = Transaction.create([alice.public_key], + tx = Create.generate([alice.public_key], [([bob.public_key], 1)])\ .sign([alice.private_key]) @@ -273,13 +272,12 @@ def test_deliver_tx__valid_create_updates_db_and_emits_event(b, init_chain_reque def test_deliver_tx__double_spend_fails(b, eventqueue_fixture, init_chain_request): from planetmint import App - from planetmint.models import Transaction from planetmint.transactions.common.crypto import generate_key_pair alice = generate_key_pair() bob = generate_key_pair() - tx = Transaction.create([alice.public_key], + tx = Create.generate([alice.public_key], [([bob.public_key], 1)])\ .sign([alice.private_key]) @@ -302,7 +300,6 @@ def test_deliver_tx__double_spend_fails(b, eventqueue_fixture, init_chain_reques def test_deliver_transfer_tx__double_spend_fails(b, init_chain_request): from planetmint import App - from planetmint.models import Transaction from planetmint.transactions.common.crypto import generate_key_pair app = App(b) @@ -319,7 +316,7 @@ def test_deliver_transfer_tx__double_spend_fails(b, init_chain_request): 'msg': 'live long and prosper' } - tx = Transaction.create([alice.public_key], + tx = Create.generate([alice.public_key], [([alice.public_key], 1)], asset=asset)\ .sign([alice.private_key]) @@ -327,7 +324,7 @@ def test_deliver_transfer_tx__double_spend_fails(b, init_chain_request): result = app.deliver_tx(encode_tx_to_bytes(tx)) assert result.code == OkCode - tx_transfer = Transaction.transfer(tx.to_inputs(), + tx_transfer = Transfer.generate(tx.to_inputs(), [([bob.public_key], 1)], asset_id=tx.id)\ .sign([alice.private_key]) @@ -335,7 +332,7 @@ def test_deliver_transfer_tx__double_spend_fails(b, init_chain_request): result = app.deliver_tx(encode_tx_to_bytes(tx_transfer)) assert result.code == OkCode - double_spend = Transaction.transfer(tx.to_inputs(), + double_spend = Transfer.generate(tx.to_inputs(), [([carly.public_key], 1)], asset_id=tx.id)\ .sign([alice.private_key]) @@ -382,9 +379,8 @@ def test_end_block_return_validator_updates(b, init_chain_request): def test_store_pre_commit_state_in_end_block(b, alice, init_chain_request): from planetmint import App from planetmint.backend import query - from planetmint.models import Transaction - tx = Transaction.create([alice.public_key], + tx = Create.generate([alice.public_key], [([alice.public_key], 1)], asset={'msg': 'live long and prosper'})\ .sign([alice.private_key]) diff --git a/tests/test_parallel_validation.py b/tests/test_parallel_validation.py index df2a39d..29e8864 100644 --- a/tests/test_parallel_validation.py +++ b/tests/test_parallel_validation.py @@ -6,8 +6,8 @@ import pytest from planetmint.transactions.common.crypto import generate_key_pair -from planetmint.models import Transaction - +from planetmint.transactions.types.assets.create import Create +from planetmint.transactions.types.assets.transfer import Transfer pytestmark = pytest.mark.tendermint @@ -16,8 +16,8 @@ def generate_create_and_transfer(keypair=None): if not keypair: keypair = generate_key_pair() priv_key, pub_key = keypair - create_tx = Transaction.create([pub_key], [([pub_key], 10)]).sign([priv_key]) - transfer_tx = Transaction.transfer( + create_tx = Create.generate([pub_key], [([pub_key], 10)]).sign([priv_key]) + transfer_tx = Transfer.generate( create_tx.to_inputs(), [([pub_key], 10)], asset_id=create_tx.id).sign([priv_key]) @@ -30,7 +30,7 @@ def test_validation_worker_process_multiple_transactions(b): keypair = generate_key_pair() create_tx, transfer_tx = generate_create_and_transfer(keypair) - double_spend = Transaction.transfer( + double_spend = Transfer.generate( create_tx.to_inputs(), [([keypair.public_key], 10)], asset_id=create_tx.id).sign([keypair.private_key]) diff --git a/tests/test_txlist.py b/tests/test_txlist.py index 50cf55c..8475be2 100644 --- a/tests/test_txlist.py +++ b/tests/test_txlist.py @@ -12,18 +12,19 @@ import pytest @pytest.fixture def txlist(b, user_pk, user2_pk, user_sk, user2_sk): - from planetmint.models import Transaction + from planetmint.transactions.types.assets.create import Create + from planetmint.transactions.types.assets.transfer import Transfer # Create two CREATE transactions - create1 = Transaction.create([user_pk], [([user2_pk], 6)]) \ + create1 = Create.generate([user_pk], [([user2_pk], 6)]) \ .sign([user_sk]) - create2 = Transaction.create([user2_pk], + create2 = Create.generate([user2_pk], [([user2_pk], 5), ([user_pk], 5)]) \ .sign([user2_sk]) # Create a TRANSFER transactions - transfer1 = Transaction.transfer(create1.to_inputs(), + transfer1 = Transfer.generate(create1.to_inputs(), [([user_pk], 8)], create1.id).sign([user2_sk]) diff --git a/tests/utils.py b/tests/utils.py index 4829d4e..ceffff0 100644 --- a/tests/utils.py +++ b/tests/utils.py @@ -13,6 +13,7 @@ from planetmint.backend.localmongodb.connection import LocalMongoDBConnection from planetmint.backend.schema import TABLES from planetmint.transactions.common import crypto from planetmint.transactions.common.transaction_mode_types import BROADCAST_TX_COMMIT +from planetmint.transactions.types.assets.create import Create from planetmint.transactions.types.elections.election import Election, Vote from planetmint.tendermint_utils import key_to_base64 @@ -30,10 +31,9 @@ def flush_localmongo_db(connection, dbname): def generate_block(planet): from planetmint.transactions.common.crypto import generate_key_pair - from planetmint.models import Transaction alice = generate_key_pair() - tx = Transaction.create([alice.public_key], + tx = Create.generate([alice.public_key], [([alice.public_key], 1)], asset=None)\ .sign([alice.private_key]) diff --git a/tests/web/test_assets.py b/tests/web/test_assets.py index 9c632ef..b88c2ef 100644 --- a/tests/web/test_assets.py +++ b/tests/web/test_assets.py @@ -4,6 +4,7 @@ # Code is Apache-2.0 and docs are CC-BY-4.0 import pytest +from planetmint.transactions.types.assets.create import Create ASSETS_ENDPOINT = '/api/v1/assets/' @@ -22,7 +23,6 @@ def test_get_assets_with_missing_text_search(client): @pytest.mark.bdb def test_get_assets_tendermint(client, b, alice): - from planetmint.models import Transaction # test returns empty list when no assets are found res = client.get(ASSETS_ENDPOINT + '?search=abc') @@ -31,7 +31,7 @@ def test_get_assets_tendermint(client, b, alice): # create asset asset = {'msg': 'abc'} - tx = Transaction.create([alice.public_key], [([alice.public_key], 1)], + tx = Create.generate([alice.public_key], [([alice.public_key], 1)], asset=asset).sign([alice.private_key]) b.store_bulk_transactions([tx]) @@ -48,14 +48,13 @@ def test_get_assets_tendermint(client, b, alice): @pytest.mark.bdb def test_get_assets_limit_tendermint(client, b, alice): - from planetmint.models import Transaction # create two assets asset1 = {'msg': 'abc 1'} asset2 = {'msg': 'abc 2'} - tx1 = Transaction.create([alice.public_key], [([alice.public_key], 1)], + tx1 = Create.generate([alice.public_key], [([alice.public_key], 1)], asset=asset1).sign([alice.private_key]) - tx2 = Transaction.create([alice.public_key], [([alice.public_key], 1)], + tx2 = Create.generate([alice.public_key], [([alice.public_key], 1)], asset=asset2).sign([alice.private_key]) b.store_bulk_transactions([tx1]) diff --git a/tests/web/test_block_tendermint.py b/tests/web/test_block_tendermint.py index 2accbce..7fb034d 100644 --- a/tests/web/test_block_tendermint.py +++ b/tests/web/test_block_tendermint.py @@ -5,7 +5,7 @@ import pytest -from planetmint.models import Transaction +from planetmint.transactions.types.assets.create import Create from planetmint.lib import Block BLOCKS_ENDPOINT = '/api/v1/blocks/' @@ -15,7 +15,7 @@ BLOCKS_ENDPOINT = '/api/v1/blocks/' @pytest.mark.usefixtures('inputs') def test_get_block_endpoint(b, client, alice): import copy - tx = Transaction.create([alice.public_key], [([alice.public_key], 1)], asset={'cycle': 'hero'}) + tx = Create.generate([alice.public_key], [([alice.public_key], 1)], asset={'cycle': 'hero'}) tx = tx.sign([alice.private_key]) # with store_bulk_transactions we use `insert_many` where PyMongo @@ -48,7 +48,7 @@ def test_get_block_returns_404_if_not_found(client): @pytest.mark.bdb def test_get_block_containing_transaction(b, client, alice): - tx = Transaction.create([alice.public_key], [([alice.public_key], 1)], asset={'cycle': 'hero'}) + tx = Create.generate([alice.public_key], [([alice.public_key], 1)], asset={'cycle': 'hero'}) tx = tx.sign([alice.private_key]) b.store_bulk_transactions([tx]) diff --git a/tests/web/test_metadata.py b/tests/web/test_metadata.py index d9301f3..9e2acf2 100644 --- a/tests/web/test_metadata.py +++ b/tests/web/test_metadata.py @@ -4,6 +4,7 @@ # Code is Apache-2.0 and docs are CC-BY-4.0 import pytest +from planetmint.transactions.types.assets.create import Create METADATA_ENDPOINT = '/api/v1/metadata/' @@ -22,7 +23,6 @@ def test_get_metadata_with_missing_text_search(client): @pytest.mark.bdb def test_get_metadata_tendermint(client, b, alice): - from planetmint.models import Transaction # test returns empty list when no assets are found res = client.get(METADATA_ENDPOINT + '?search=abc') @@ -32,7 +32,7 @@ def test_get_metadata_tendermint(client, b, alice): # create asset asset = {'msg': 'abc'} metadata = {'key': 'my_meta'} - tx = Transaction.create([alice.public_key], [([alice.public_key], 1)], metadata=metadata, + tx = Create.generate([alice.public_key], [([alice.public_key], 1)], metadata=metadata, asset=asset).sign([alice.private_key]) b.store_bulk_transactions([tx]) @@ -49,18 +49,17 @@ def test_get_metadata_tendermint(client, b, alice): @pytest.mark.bdb def test_get_metadata_limit_tendermint(client, b, alice): - from planetmint.models import Transaction # create two assets asset1 = {'msg': 'abc 1'} meta1 = {'key': 'meta 1'} - tx1 = Transaction.create([alice.public_key], [([alice.public_key], 1)], metadata=meta1, + tx1 = Create.generate([alice.public_key], [([alice.public_key], 1)], metadata=meta1, asset=asset1).sign([alice.private_key]) b.store_bulk_transactions([tx1]) asset2 = {'msg': 'abc 2'} meta2 = {'key': 'meta 2'} - tx2 = Transaction.create([alice.public_key], [([alice.public_key], 1)], metadata=meta2, + tx2 = Create.generate([alice.public_key], [([alice.public_key], 1)], metadata=meta2, asset=asset2).sign([alice.private_key]) b.store_bulk_transactions([tx2]) diff --git a/tests/web/test_outputs.py b/tests/web/test_outputs.py index 112526a..16783b8 100644 --- a/tests/web/test_outputs.py +++ b/tests/web/test_outputs.py @@ -3,7 +3,10 @@ # SPDX-License-Identifier: (Apache-2.0 AND CC-BY-4.0) # Code is Apache-2.0 and docs are CC-BY-4.0 + import pytest +from planetmint.transactions.types.assets.create import Create +from planetmint.transactions.types.assets.transfer import Transfer from unittest.mock import MagicMock, patch @@ -83,7 +86,6 @@ def test_get_outputs_endpoint_with_invalid_spent(client, user_pk): @pytest.mark.abci def test_get_divisble_transactions_returns_500(b, client): - from planetmint.models import Transaction from planetmint.transactions.common import crypto import json @@ -96,7 +98,7 @@ def test_get_divisble_transactions_returns_500(b, client): bob_priv, bob_pub = crypto.generate_key_pair() carly_priv, carly_pub = crypto.generate_key_pair() - create_tx = Transaction.create([alice_pub], [([alice_pub], 4)]) + create_tx = Create.generate([alice_pub], [([alice_pub], 4)]) create_tx.sign([alice_priv]) res = client.post(TX_ENDPOINT, data=json.dumps(create_tx.to_dict())) @@ -104,7 +106,7 @@ def test_get_divisble_transactions_returns_500(b, client): mine([create_tx]) - transfer_tx = Transaction.transfer(create_tx.to_inputs(), + transfer_tx = Transfer.generate(create_tx.to_inputs(), [([alice_pub], 3), ([bob_pub], 1)], asset_id=create_tx.id) transfer_tx.sign([alice_priv]) @@ -114,7 +116,7 @@ def test_get_divisble_transactions_returns_500(b, client): mine([transfer_tx]) - transfer_tx_carly = Transaction.transfer([transfer_tx.to_inputs()[1]], + transfer_tx_carly = Transfer.generate([transfer_tx.to_inputs()[1]], [([carly_pub], 1)], asset_id=create_tx.id) transfer_tx_carly.sign([bob_priv]) diff --git a/tests/web/test_transactions.py b/tests/web/test_transactions.py index 11846e4..b613c50 100644 --- a/tests/web/test_transactions.py +++ b/tests/web/test_transactions.py @@ -15,6 +15,8 @@ except ImportError: from sha3 import sha3_256 from planetmint.transactions.common import crypto +from planetmint.transactions.types.assets.create import Create +from planetmint.transactions.types.assets.transfer import Transfer from planetmint.transactions.common.transaction_mode_types import ( BROADCAST_TX_COMMIT, BROADCAST_TX_ASYNC, BROADCAST_TX_SYNC) @@ -38,10 +40,9 @@ def test_get_transaction_returns_404_if_not_found(client): @pytest.mark.abci def test_post_create_transaction_endpoint(b, client): - from planetmint.models import Transaction user_priv, user_pub = crypto.generate_key_pair() - tx = Transaction.create([user_pub], [([user_pub], 1)]) + tx = Create.generate([user_pub], [([user_pub], 1)]) tx = tx.sign([user_priv]) res = client.post(TX_ENDPOINT, data=json.dumps(tx.to_dict())) @@ -67,7 +68,6 @@ def test_post_create_transaction_endpoint(b, client): @pytest.mark.language def test_post_create_transaction_with_language(b, client, nested, language, expected_status_code): - from planetmint.models import Transaction from planetmint.backend.localmongodb.connection import LocalMongoDBConnection if isinstance(b.connection, LocalMongoDBConnection): @@ -79,7 +79,7 @@ def test_post_create_transaction_with_language(b, client, nested, language, else: asset = lang_obj - tx = Transaction.create([user_pub], [([user_pub], 1)], + tx = Create.generate([user_pub], [([user_pub], 1)], asset=asset) tx = tx.sign([user_priv]) res = client.post(TX_ENDPOINT, data=json.dumps(tx.to_dict())) @@ -105,16 +105,15 @@ def test_post_create_transaction_with_language(b, client, nested, language, ]) def test_post_create_transaction_with_invalid_key(b, client, field, value, err_key, expected_status_code): - from planetmint.models import Transaction from planetmint.backend.localmongodb.connection import LocalMongoDBConnection user_priv, user_pub = crypto.generate_key_pair() if isinstance(b.connection, LocalMongoDBConnection): if field == 'asset': - tx = Transaction.create([user_pub], [([user_pub], 1)], + tx = Create.generate([user_pub], [([user_pub], 1)], asset=value) elif field == 'metadata': - tx = Transaction.create([user_pub], [([user_pub], 1)], + tx = Create.generate([user_pub], [([user_pub], 1)], metadata=value) tx = tx.sign([user_priv]) res = client.post(TX_ENDPOINT, data=json.dumps(tx.to_dict())) @@ -133,10 +132,9 @@ def test_post_create_transaction_with_invalid_key(b, client, field, value, @patch('planetmint.web.views.base.logger') def test_post_create_transaction_with_invalid_id(mock_logger, b, client): from planetmint.transactions.common.exceptions import InvalidHash - from planetmint.models import Transaction user_priv, user_pub = crypto.generate_key_pair() - tx = Transaction.create([user_pub], [([user_pub], 1)]) + tx = Create.generate([user_pub], [([user_pub], 1)]) tx = tx.sign([user_priv]).to_dict() tx['id'] = 'abcd' * 16 @@ -170,10 +168,9 @@ def test_post_create_transaction_with_invalid_signature(mock_logger, b, client): from planetmint.transactions.common.exceptions import InvalidSignature - from planetmint.models import Transaction user_priv, user_pub = crypto.generate_key_pair() - tx = Transaction.create([user_pub], [([user_pub], 1)]).to_dict() + tx = Create.generate([user_pub], [([user_pub], 1)]).to_dict() tx['inputs'][0]['fulfillment'] = 64 * '0' tx['id'] = sha3_256( json.dumps( @@ -217,9 +214,8 @@ def test_post_create_transaction_with_invalid_structure(client): @pytest.mark.abci @patch('planetmint.web.views.base.logger') def test_post_create_transaction_with_invalid_schema(mock_logger, client): - from planetmint.models import Transaction user_priv, user_pub = crypto.generate_key_pair() - tx = Transaction.create([user_pub], [([user_pub], 1)]).to_dict() + tx = Create.generate([user_pub], [([user_pub], 1)]).to_dict() del tx['version'] ed25519 = Ed25519Sha256(public_key=base58.b58decode(user_pub)) message = json.dumps( @@ -307,9 +303,8 @@ def test_post_invalid_transaction(mock_logger, client, exc, msg, monkeypatch,): @pytest.mark.abci def test_post_transfer_transaction_endpoint(client, user_pk, user_sk, posted_create_tx): - from planetmint.models import Transaction - transfer_tx = Transaction.transfer(posted_create_tx.to_inputs(), + transfer_tx = Transfer.generate(posted_create_tx.to_inputs(), [([user_pk], 1)], asset_id=posted_create_tx.id) transfer_tx = transfer_tx.sign([user_sk]) @@ -324,10 +319,9 @@ def test_post_transfer_transaction_endpoint(client, user_pk, user_sk, posted_cre @pytest.mark.abci def test_post_invalid_transfer_transaction_returns_400(client, user_pk, posted_create_tx): - from planetmint.models import Transaction from planetmint.transactions.common.exceptions import InvalidSignature - transfer_tx = Transaction.transfer(posted_create_tx.to_inputs(), + transfer_tx = Transfer.generate(posted_create_tx.to_inputs(), [([user_pk], 1)], asset_id=posted_create_tx.id) transfer_tx._hash() @@ -342,18 +336,17 @@ def test_post_invalid_transfer_transaction_returns_400(client, user_pk, posted_c @pytest.mark.abci def test_post_wrong_asset_division_transfer_returns_400(b, client, user_pk): - from planetmint.models import Transaction from planetmint.transactions.common.exceptions import AmountError priv_key, pub_key = crypto.generate_key_pair() - create_tx = Transaction.create([pub_key], + create_tx = Create.generate([pub_key], [([pub_key], 10)], asset={'test': 'asset'}).sign([priv_key]) res = client.post(TX_ENDPOINT + '?mode=commit', data=json.dumps(create_tx.to_dict())) assert res.status_code == 202 - transfer_tx = Transaction.transfer(create_tx.to_inputs(), + transfer_tx = Transfer.generate(create_tx.to_inputs(), [([pub_key], 20)], # 20 > 10 asset_id=create_tx.id).sign([priv_key]) res = client.post(TX_ENDPOINT + '?mode=commit', data=json.dumps(transfer_tx.to_dict())) @@ -423,7 +416,6 @@ def test_transactions_get_list_bad(client): ('?mode=commit', BROADCAST_TX_COMMIT), ]) def test_post_transaction_valid_modes(mock_post, client, mode): - from planetmint.models import Transaction from planetmint.transactions.common.crypto import generate_key_pair def _mock_post(*args, **kwargs): @@ -432,7 +424,7 @@ def test_post_transaction_valid_modes(mock_post, client, mode): mock_post.side_effect = _mock_post alice = generate_key_pair() - tx = Transaction.create([alice.public_key], + tx = Create.generate([alice.public_key], [([alice.public_key], 1)], asset=None) \ .sign([alice.private_key]) @@ -444,10 +436,9 @@ def test_post_transaction_valid_modes(mock_post, client, mode): @pytest.mark.abci def test_post_transaction_invalid_mode(client): - from planetmint.models import Transaction from planetmint.transactions.common.crypto import generate_key_pair alice = generate_key_pair() - tx = Transaction.create([alice.public_key], + tx = Create.generate([alice.public_key], [([alice.public_key], 1)], asset=None) \ .sign([alice.private_key]) diff --git a/tests/web/test_websocket_server.py b/tests/web/test_websocket_server.py index 05b45fc..d7d9d85 100644 --- a/tests/web/test_websocket_server.py +++ b/tests/web/test_websocket_server.py @@ -8,6 +8,8 @@ import json import queue import threading from unittest.mock import patch +from planetmint.transactions.types.assets.create import Create +from planetmint.transactions.types.assets.transfer import Transfer import pytest @@ -23,14 +25,13 @@ class MockWebSocket: def test_eventify_block_works_with_any_transaction(): from planetmint.web.websocket_server import eventify_block from planetmint.transactions.common.crypto import generate_key_pair - from planetmint.lib import Transaction alice = generate_key_pair() - tx = Transaction.create([alice.public_key], + tx = Create.generate([alice.public_key], [([alice.public_key], 1)])\ .sign([alice.private_key]) - tx_transfer = Transaction.transfer(tx.to_inputs(), + tx_transfer = Transfer.generate(tx.to_inputs(), [([alice.public_key], 1)], asset_id=tx.id)\ .sign([alice.private_key]) @@ -138,11 +139,10 @@ async def test_websocket_string_event(test_client, loop): async def test_websocket_block_event(b, test_client, loop): from planetmint import events from planetmint.web.websocket_server import init_app, POISON_PILL, EVENTS_ENDPOINT - from planetmint.models import Transaction from planetmint.transactions.common import crypto user_priv, user_pub = crypto.generate_key_pair() - tx = Transaction.create([user_pub], [([user_pub], 1)]) + tx = Create.generate([user_pub], [([user_pub], 1)]) tx = tx.sign([user_priv]) event_source = asyncio.Queue(loop=loop) @@ -184,7 +184,6 @@ def test_integration_from_webapi_to_websocket(monkeypatch, client, loop): # TODO processes does not exist anymore, when reactivating this test it # will fail because of this from planetmint import processes - from planetmint.models import Transaction # Start Planetmint processes.start() @@ -203,7 +202,7 @@ def test_integration_from_webapi_to_websocket(monkeypatch, client, loop): # Create a keypair and generate a new asset user_priv, user_pub = crypto.generate_key_pair() asset = {'random': random.random()} - tx = Transaction.create([user_pub], [([user_pub], 1)], asset=asset) + tx = Create.generate([user_pub], [([user_pub], 1)], asset=asset) tx = tx.sign([user_priv]) # Post the transaction to the Planetmint Web API client.post('/api/v1/transactions/', data=json.dumps(tx.to_dict()))