Mirroristas/planetmint
2
0
Fork 0
mirror of https://github.com/planetmint/planetmint.git synced 2025-06-06 14:16:38 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #61 from roninx991/main

Browse Source 
Removing create and transfer transactions from transaction.py file
This commit is contained in:
Arpit Shukla 2022-03-23 16:07:58 +01:00 committed by GitHub
commit f9f1a64773
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
28 changed files with 254 additions and 447 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
docs/root/generate_http_server_api_documentation.py
View File

@ -9,8 +9,11 @@ import json
import os import os
import os.path 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 import lib
from planetmint.transactions.types.assets.create import Create
from planetmint.transactions.types.assets.transfer import Transfer
from planetmint.web import server from planetmint.web import server
@ -133,7 +136,7 @@ def main():
privkey = 'CfdqtD7sS7FgkMoGPXw55MVGGFwQLAoHYTcBhZDtF99Z' privkey = 'CfdqtD7sS7FgkMoGPXw55MVGGFwQLAoHYTcBhZDtF99Z'
pubkey = '4K9sWUMFwTgaDGPfdynrbxWqWS6sWmKbZoTjxLtVUibD' pubkey = '4K9sWUMFwTgaDGPfdynrbxWqWS6sWmKbZoTjxLtVUibD'
asset = {'msg': 'Hello Planetmint!'} 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]) tx = tx.sign([privkey])
ctx['tx'] = pretty_json(tx.to_dict()) ctx['tx'] = pretty_json(tx.to_dict())
ctx['public_keys'] = tx.outputs[0].public_keys[0] ctx['public_keys'] = tx.outputs[0].public_keys[0]
@ -147,7 +150,7 @@ def main():
input_ = Input(fulfillment=tx.outputs[cid].fulfillment, input_ = Input(fulfillment=tx.outputs[cid].fulfillment,
fulfills=TransactionLink(txid=tx.id, output=cid), fulfills=TransactionLink(txid=tx.id, output=cid),
owners_before=tx.outputs[cid].public_keys) 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]) tx_transfer = tx_transfer.sign([privkey])
ctx['tx_transfer'] = pretty_json(tx_transfer.to_dict()) ctx['tx_transfer'] = pretty_json(tx_transfer.to_dict())
ctx['public_keys_transfer'] = tx_transfer.outputs[0].public_keys[0] 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, input_ = Input(fulfillment=tx_transfer.outputs[cid].fulfillment,
fulfills=TransactionLink(txid=tx_transfer.id, output=cid), fulfills=TransactionLink(txid=tx_transfer.id, output=cid),
owners_before=tx_transfer.outputs[cid].public_keys) 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}) asset_id=tx.id, metadata={'sequence': 2})
tx_transfer_last = tx_transfer_last.sign([privkey_transfer]) tx_transfer_last = tx_transfer_last.sign([privkey_transfer])
ctx['tx_transfer_last'] = pretty_json(tx_transfer_last.to_dict()) ctx['tx_transfer_last'] = pretty_json(tx_transfer_last.to_dict())

131
planetmint/transactions/common/transaction.py
View File

@ -167,137 +167,6 @@ class Transaction(object):
def _hash(self): def _hash(self):
self._id = hash_data(self.serialized) 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 `([<list of public keys>],'
' <amount>)`'))
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 `([<list of public keys>],'
' <amount>)`'))
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): def __eq__(self, other):
try: try:
other = other.to_dict() other = other.to_dict()

6
planetmint/transactions/types/assets/create.py
View File

@ -3,7 +3,7 @@
# SPDX-License-Identifier: (Apache-2.0 AND CC-BY-4.0) # SPDX-License-Identifier: (Apache-2.0 AND CC-BY-4.0)
# Code is Apache-2.0 and docs are 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.input import Input
from planetmint.transactions.common.output import Output from planetmint.transactions.common.output import Output
@ -13,7 +13,7 @@ class Create(Transaction):
ALLOWED_OPERATIONS = (OPERATION,) ALLOWED_OPERATIONS = (OPERATION,)
@classmethod @classmethod
def validate(self, tx_signers, recipients, asset, metadata): def validate_create(self, tx_signers, recipients, asset, metadata):
if not isinstance(tx_signers, list): if not isinstance(tx_signers, list):
raise TypeError('`tx_signers` must be a list instance') raise TypeError('`tx_signers` must be a list instance')
if not isinstance(recipients, list): if not isinstance(recipients, list):
@ -73,5 +73,5 @@ class Create(Transaction):
:class:`~planetmint.common.transaction.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) return cls(cls.OPERATION, {'data': asset}, inputs, outputs, metadata)

4
planetmint/transactions/types/assets/transfer.py
View File

@ -3,7 +3,7 @@
# SPDX-License-Identifier: (Apache-2.0 AND CC-BY-4.0) # SPDX-License-Identifier: (Apache-2.0 AND CC-BY-4.0)
# Code is Apache-2.0 and docs are 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 planetmint.transactions.common.output import Output
from copy import deepcopy from copy import deepcopy
@ -13,7 +13,7 @@ class Transfer(Transaction):
ALLOWED_OPERATIONS = (OPERATION,) ALLOWED_OPERATIONS = (OPERATION,)
@classmethod @classmethod
def validate(cls, inputs, recipients, asset_id, metadata): def validate_transfer(cls, inputs, recipients, asset_id, metadata):
if not isinstance(inputs, list): if not isinstance(inputs, list):
raise TypeError('`inputs` must be a list instance') raise TypeError('`inputs` must be a list instance')
if len(inputs) == 0: if len(inputs) == 0:

2
planetmint/transactions/types/elections/election.py
View File

@ -143,7 +143,7 @@ class Election(Transaction):
uuid = uuid4() uuid = uuid4()
election_data['seed'] = str(uuid) 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) election = cls(cls.OPERATION, {'data': election_data}, inputs, outputs, metadata)
cls.validate_schema(election.to_dict()) cls.validate_schema(election.to_dict())
return election return election

3
planetmint/transactions/types/elections/vote.py
View File

@ -5,12 +5,11 @@
from planetmint.transactions.types.assets.create import Create from planetmint.transactions.types.assets.create import Create
from planetmint.transactions.types.assets.transfer import Transfer from planetmint.transactions.types.assets.transfer import Transfer
from planetmint.transactions.common.transaction import Transaction
from planetmint.transactions.common.schema import ( from planetmint.transactions.common.schema import (
_validate_schema, TX_SCHEMA_COMMON, TX_SCHEMA_TRANSFER, TX_SCHEMA_VOTE) _validate_schema, TX_SCHEMA_COMMON, TX_SCHEMA_TRANSFER, TX_SCHEMA_VOTE)
class Vote(Transaction): class Vote(Transfer):
OPERATION = 'VOTE' OPERATION = 'VOTE'
# NOTE: This class inherits TRANSFER txn type. The `TRANSFER` property is # NOTE: This class inherits TRANSFER txn type. The `TRANSFER` property is

21
tests/assets/test_digital_assets.py
View File

@ -5,12 +5,11 @@
import pytest import pytest
import random 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): def test_asset_transfer(b, signed_create_tx, user_pk, user_sk):
from planetmint.models import Transaction tx_transfer = Transfer.generate(signed_create_tx.to_inputs(), [([user_pk], 1)],
tx_transfer = Transaction.transfer(signed_create_tx.to_inputs(), [([user_pk], 1)],
signed_create_tx.id) signed_create_tx.id)
tx_transfer_signed = tx_transfer.sign([user_sk]) 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): def test_validate_transfer_asset_id_mismatch(b, signed_create_tx, user_pk, user_sk):
from planetmint.transactions.common.exceptions import AssetIdMismatch 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) signed_create_tx.id)
tx_transfer.asset['id'] = 'a' * 64 tx_transfer.asset['id'] = 'a' * 64
tx_transfer_signed = tx_transfer.sign([user_sk]) 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): def test_get_asset_id_create_transaction(alice, user_pk):
from planetmint.models import Transaction 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 assert Transaction.get_asset_id(tx_create) == tx_create.id
def test_get_asset_id_transfer_transaction(b, signed_create_tx, user_pk): def test_get_asset_id_transfer_transaction(b, signed_create_tx, user_pk):
from planetmint.models import Transaction 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) signed_create_tx.id)
asset_id = Transaction.get_asset_id(tx_transfer) asset_id = Transaction.get_asset_id(tx_transfer)
assert asset_id == tx_transfer.asset['id'] 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.models import Transaction
from planetmint.transactions.common.exceptions import AssetIdMismatch 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()}) metadata={'msg': random.random()})
tx1.sign([alice.private_key]) 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()}) metadata={'msg': random.random()})
tx2.sign([alice.private_key]) 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): 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]) tx_signed = tx.sign([user_sk])
assert tx_signed.validate(b) == tx_signed assert tx_signed.validate(b) == tx_signed

100
tests/assets/test_divisible_assets.py
View File

@ -3,9 +3,12 @@
# SPDX-License-Identifier: (Apache-2.0 AND CC-BY-4.0) # SPDX-License-Identifier: (Apache-2.0 AND CC-BY-4.0)
# Code is Apache-2.0 and docs are CC-BY-4.0 # Code is Apache-2.0 and docs are CC-BY-4.0
import pytest import pytest
import random 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 from planetmint.transactions.common.exceptions import DoubleSpend
@ -15,9 +18,8 @@ from planetmint.transactions.common.exceptions import DoubleSpend
# Single output # Single output
# Single owners_after # Single owners_after
def test_single_in_single_own_single_out_single_own_create(alice, user_pk, b): 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]) tx_signed = tx.sign([alice.private_key])
assert tx_signed.validate(b) == tx_signed 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 # Multiple outputs
# Single owners_after per output # Single owners_after per output
def test_single_in_single_own_multiple_out_single_own_create(alice, user_pk, b): 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()}) asset={'name': random.random()})
tx_signed = tx.sign([alice.private_key]) 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 # Single output
# Multiple owners_after # Multiple owners_after
def test_single_in_single_own_single_out_multiple_own_create(alice, user_pk, b): 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]) tx_signed = tx.sign([alice.private_key])
assert tx_signed.validate(b) == tx_signed 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 # Mix: one output with a single owners_after, one output with multiple
# owners_after # owners_after
def test_single_in_single_own_multiple_out_mix_own_create(alice, user_pk, b): 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()}) asset={'name': random.random()})
tx_signed = tx.sign([alice.private_key]) 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 # Output combinations already tested above
def test_single_in_multiple_own_single_out_single_own_create(alice, b, user_pk, def test_single_in_multiple_own_single_out_single_own_create(alice, b, user_pk,
user_sk): user_sk):
from planetmint.models import Transaction
from planetmint.transactions.common.utils import _fulfillment_to_details 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]) tx_signed = tx.sign([alice.private_key, user_sk])
assert tx_signed.validate(b) == tx_signed assert tx_signed.validate(b) == tx_signed
assert len(tx_signed.outputs) == 1 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 # Single owners_after
def test_single_in_single_own_single_out_single_own_transfer(alice, b, user_pk, def test_single_in_single_own_single_out_single_own_transfer(alice, b, user_pk,
user_sk): user_sk):
from planetmint.models import Transaction
# CREATE divisible asset # 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]) tx_create_signed = tx_create.sign([alice.private_key])
# TRANSFER # 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) asset_id=tx_create.id)
tx_transfer_signed = tx_transfer.sign([user_sk]) 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 # Single owners_after
def test_single_in_single_own_multiple_out_single_own_transfer(alice, b, user_pk, def test_single_in_single_own_multiple_out_single_own_transfer(alice, b, user_pk,
user_sk): user_sk):
from planetmint.models import Transaction
# CREATE divisible asset # 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]) tx_create_signed = tx_create.sign([alice.private_key])
# TRANSFER # 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)], [([alice.public_key], 50), ([alice.public_key], 50)],
asset_id=tx_create.id) asset_id=tx_create.id)
tx_transfer_signed = tx_transfer.sign([user_sk]) 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 # Multiple owners_after
def test_single_in_single_own_single_out_multiple_own_transfer(alice, b, user_pk, def test_single_in_single_own_single_out_multiple_own_transfer(alice, b, user_pk,
user_sk): user_sk):
from planetmint.models import Transaction
# CREATE divisible asset # 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]) tx_create_signed = tx_create.sign([alice.private_key])
# TRANSFER # TRANSFER
tx_transfer = Transaction.transfer(tx_create.to_inputs(), tx_transfer = Transfer.generate(tx_create.to_inputs(),
[([alice.public_key, alice.public_key], 100)], [([alice.public_key, alice.public_key], 100)],
asset_id=tx_create.id) asset_id=tx_create.id)
tx_transfer_signed = tx_transfer.sign([user_sk]) 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 # owners_after
def test_single_in_single_own_multiple_out_mix_own_transfer(alice, b, user_pk, def test_single_in_single_own_multiple_out_mix_own_transfer(alice, b, user_pk,
user_sk): user_sk):
from planetmint.models import Transaction
# CREATE divisible asset # 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]) tx_create_signed = tx_create.sign([alice.private_key])
# TRANSFER # 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)], [([alice.public_key], 50), ([alice.public_key, alice.public_key], 50)],
asset_id=tx_create.id) asset_id=tx_create.id)
tx_transfer_signed = tx_transfer.sign([user_sk]) 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 # Single owners_after
def test_single_in_multiple_own_single_out_single_own_transfer(alice, b, user_pk, def test_single_in_multiple_own_single_out_single_own_transfer(alice, b, user_pk,
user_sk): user_sk):
from planetmint.models import Transaction
from planetmint.transactions.common.utils import _fulfillment_to_details from planetmint.transactions.common.utils import _fulfillment_to_details
# CREATE divisible asset # 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()}) asset={'name': random.random()})
tx_create_signed = tx_create.sign([alice.private_key]) tx_create_signed = tx_create.sign([alice.private_key])
# TRANSFER # 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) asset_id=tx_create.id)
tx_transfer_signed = tx_transfer.sign([alice.private_key, user_sk]) 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 # Single owners_after
def test_multiple_in_single_own_single_out_single_own_transfer(alice, b, user_pk, def test_multiple_in_single_own_single_out_single_own_transfer(alice, b, user_pk,
user_sk): user_sk):
from planetmint.models import Transaction
# CREATE divisible asset # 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()}) asset={'name': random.random()})
tx_create_signed = tx_create.sign([alice.private_key]) tx_create_signed = tx_create.sign([alice.private_key])
# TRANSFER # 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) asset_id=tx_create.id)
tx_transfer_signed = tx_transfer.sign([user_sk]) 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 output
# Single owners_after # Single owners_after
def test_multiple_in_multiple_own_single_out_single_own_transfer(alice, b, user_pk, def test_multiple_in_multiple_own_single_out_single_own_transfer(alice, b, user_pk,
user_sk): user_sk):
from planetmint.models import Transaction
from planetmint.transactions.common.utils import _fulfillment_to_details from planetmint.transactions.common.utils import _fulfillment_to_details
# CREATE divisible asset # CREATE divisible asset
tx_create = Transaction.create([alice.public_key], [([user_pk, alice.public_key], 50), tx_create = Create.generate([alice.public_key], [([user_pk, alice.public_key], 50),
([user_pk, alice.public_key], 50)], ([user_pk, alice.public_key], 50)],
asset={'name': random.random()}) asset={'name': random.random()})
tx_create_signed = tx_create.sign([alice.private_key]) tx_create_signed = tx_create.sign([alice.private_key])
# TRANSFER # 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) asset_id=tx_create.id)
tx_transfer_signed = tx_transfer.sign([alice.private_key, user_sk]) 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 # Single owners_after
def test_muiltiple_in_mix_own_multiple_out_single_own_transfer(alice, b, user_pk, def test_muiltiple_in_mix_own_multiple_out_single_own_transfer(alice, b, user_pk,
user_sk): user_sk):
from planetmint.models import Transaction
from planetmint.transactions.common.utils import _fulfillment_to_details from planetmint.transactions.common.utils import _fulfillment_to_details
# CREATE divisible asset # 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()}) asset={'name': random.random()})
tx_create_signed = tx_create.sign([alice.private_key]) tx_create_signed = tx_create.sign([alice.private_key])
# TRANSFER # 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) asset_id=tx_create.id)
tx_transfer_signed = tx_transfer.sign([alice.private_key, user_sk]) 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 # owners_after
def test_muiltiple_in_mix_own_multiple_out_mix_own_transfer(alice, b, user_pk, def test_muiltiple_in_mix_own_multiple_out_mix_own_transfer(alice, b, user_pk,
user_sk): user_sk):
from planetmint.models import Transaction
from planetmint.transactions.common.utils import _fulfillment_to_details from planetmint.transactions.common.utils import _fulfillment_to_details
# CREATE divisible asset # 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()}) asset={'name': random.random()})
tx_create_signed = tx_create.sign([alice.private_key]) tx_create_signed = tx_create.sign([alice.private_key])
# TRANSFER # 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)], [([alice.public_key], 50), ([alice.public_key, user_pk], 50)],
asset_id=tx_create.id) asset_id=tx_create.id)
tx_transfer_signed = tx_transfer.sign([alice.private_key, user_sk]) 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 output
# Single owners_after # Single owners_after
def test_multiple_in_different_transactions(alice, b, user_pk, user_sk): def test_multiple_in_different_transactions(alice, b, user_pk, user_sk):
from planetmint.models import Transaction
# CREATE divisible asset # CREATE divisible asset
# `b` creates a divisible asset and assigns 50 shares to `b` and # `b` creates a divisible asset and assigns 50 shares to `b` and
# 50 shares to `user_pk` # 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()}) asset={'name': random.random()})
tx_create_signed = tx_create.sign([alice.private_key]) 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` # `b` transfers its 50 shares to `user_pk`
# after this transaction `user_pk` will have a total of 100 shares # after this transaction `user_pk` will have a total of 100 shares
# split across two different transactions # 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)], [([user_pk], 50)],
asset_id=tx_create.id) asset_id=tx_create.id)
tx_transfer1_signed = tx_transfer1.sign([alice.private_key]) 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 # TRANSFER
# `user_pk` combines two different transaction with 50 shares each and # `user_pk` combines two different transaction with 50 shares each and
# transfers a total of 100 shares back to `b` # 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]), tx_transfer1.to_inputs([0]),
[([alice.private_key], 100)], [([alice.private_key], 100)],
asset_id=tx_create.id) 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. # inputs needs to match the amount being sent in the outputs.
# In other words `amount_in_inputs - amount_in_outputs == 0` # In other words `amount_in_inputs - amount_in_outputs == 0`
def test_amount_error_transfer(alice, b, user_pk, user_sk): def test_amount_error_transfer(alice, b, user_pk, user_sk):
from planetmint.models import Transaction
from planetmint.transactions.common.exceptions import AmountError from planetmint.transactions.common.exceptions import AmountError
# CREATE divisible asset # 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]) tx_create_signed = tx_create.sign([alice.private_key])
b.store_bulk_transactions([tx_create_signed]) b.store_bulk_transactions([tx_create_signed])
# TRANSFER # TRANSFER
# output amount less than input amount # 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) asset_id=tx_create.id)
tx_transfer_signed = tx_transfer.sign([user_sk]) tx_transfer_signed = tx_transfer.sign([user_sk])
@ -505,7 +491,7 @@ def test_amount_error_transfer(alice, b, user_pk, user_sk):
# TRANSFER # TRANSFER
# output amount greater than input amount # 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) asset_id=tx_create.id)
tx_transfer_signed = tx_transfer.sign([user_sk]) 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 # Creating threshold conditions with the same key does not make sense but
# that does not mean that the code shouldn't work. # that does not mean that the code shouldn't work.
from planetmint.models import Transaction
# CREATE divisible asset # 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()}) asset={'name': random.random()})
tx_create_signed = tx_create.sign([alice.private_key]) tx_create_signed = tx_create.sign([alice.private_key])
# TRANSFER # 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) asset_id=tx_create.id)
tx_transfer_signed = tx_transfer.sign([user_sk, user_sk]) 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): def test_sum_amount(alice, b, user_pk, user_sk):
from planetmint.models import Transaction
# CREATE divisible asset with 3 outputs with amount 1 # 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()}) asset={'name': random.random()})
tx_create_signed = tx_create.sign([alice.private_key]) tx_create_signed = tx_create.sign([alice.private_key])
# create a transfer transaction with one output and check if the amount # create a transfer transaction with one output and check if the amount
# is 3 # 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) asset_id=tx_create.id)
tx_transfer_signed = tx_transfer.sign([user_sk]) 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): def test_divide(alice, b, user_pk, user_sk):
from planetmint.models import Transaction
# CREATE divisible asset with 1 output with amount 3 # 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]) tx_create_signed = tx_create.sign([alice.private_key])
# create a transfer transaction with 3 outputs and check if the amount # create a transfer transaction with 3 outputs and check if the amount
# of each output is 1 # 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)], [([alice.public_key], 1), ([alice.public_key], 1), ([alice.public_key], 1)],
asset_id=tx_create.id) asset_id=tx_create.id)
tx_transfer_signed = tx_transfer.sign([user_sk]) tx_transfer_signed = tx_transfer.sign([user_sk])

20
tests/backend/localmongodb/test_queries.py
View File

@ -4,6 +4,8 @@
# Code is Apache-2.0 and docs are CC-BY-4.0 # Code is Apache-2.0 and docs are CC-BY-4.0
from copy import deepcopy from copy import deepcopy
from planetmint.transactions.types.assets.create import Create
from planetmint.transactions.types.assets.transfer import Transfer
import pytest import pytest
import pymongo 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): def test_get_spending_transactions(user_pk, user_sk):
from planetmint.backend import connect, query from planetmint.backend import connect, query
from planetmint.models import Transaction
conn = connect() conn = connect()
out = [([user_pk], 1)] out = [([user_pk], 1)]
tx1 = Transaction.create([user_pk], out * 3) tx1 = Create.generate([user_pk], out * 3)
tx1.sign([user_sk]) tx1.sign([user_sk])
inputs = tx1.to_inputs() inputs = tx1.to_inputs()
tx2 = Transaction.transfer([inputs[0]], out, tx1.id).sign([user_sk]) tx2 = Transfer.generate([inputs[0]], out, tx1.id).sign([user_sk])
tx3 = Transaction.transfer([inputs[1]], out, tx1.id).sign([user_sk]) tx3 = Transfer.generate([inputs[1]], out, tx1.id).sign([user_sk])
tx4 = Transaction.transfer([inputs[2]], 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]] txns = [deepcopy(tx.to_dict()) for tx in [tx1, tx2, tx3, tx4]]
conn.db.transactions.insert_many(txns) 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(): def test_get_spending_transactions_multiple_inputs():
from planetmint.backend import connect, query from planetmint.backend import connect, query
from planetmint.models import Transaction
from planetmint.transactions.common.crypto import generate_key_pair from planetmint.transactions.common.crypto import generate_key_pair
conn = connect() conn = connect()
(alice_sk, alice_pk) = generate_key_pair() (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() (carol_sk, carol_pk) = generate_key_pair()
out = [([alice_pk], 9)] 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() inputs1 = tx1.to_inputs()
tx2 = Transaction.transfer([inputs1[0]], tx2 = Transfer.generate([inputs1[0]],
[([alice_pk], 6), ([bob_pk], 3)], [([alice_pk], 6), ([bob_pk], 3)],
tx1.id).sign([alice_sk]) tx1.id).sign([alice_sk])
inputs2 = tx2.to_inputs() inputs2 = tx2.to_inputs()
tx3 = Transaction.transfer([inputs2[0]], tx3 = Transfer.generate([inputs2[0]],
[([bob_pk], 3), ([carol_pk], 3)], [([bob_pk], 3), ([carol_pk], 3)],
tx1.id).sign([alice_sk]) tx1.id).sign([alice_sk])
inputs3 = tx3.to_inputs() inputs3 = tx3.to_inputs()
tx4 = Transaction.transfer([inputs2[1], inputs3[0]], tx4 = Transfer.generate([inputs2[1], inputs3[0]],
[([carol_pk], 6)], [([carol_pk], 6)],
tx1.id).sign([bob_sk]) tx1.id).sign([bob_sk])

6
tests/commands/test_commands.py
View File

@ -259,16 +259,16 @@ def test_recover_db_on_start(mock_run_recover,
@pytest.mark.bdb @pytest.mark.bdb
def test_run_recover(b, alice, bob): def test_run_recover(b, alice, bob):
from planetmint.commands.planetmint import run_recover 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.lib import Block
from planetmint.backend import query from planetmint.backend import query
tx1 = Transaction.create([alice.public_key], tx1 = Create.generate([alice.public_key],
[([alice.public_key], 1)], [([alice.public_key], 1)],
asset={'cycle': 'hero'}, asset={'cycle': 'hero'},
metadata={'name': 'hohenheim'}) \ metadata={'name': 'hohenheim'}) \
.sign([alice.private_key]) .sign([alice.private_key])
tx2 = Transaction.create([bob.public_key], tx2 = Create.generate([bob.public_key],
[([bob.public_key], 1)], [([bob.public_key], 1)],
asset={'cycle': 'hero'}, asset={'cycle': 'hero'},
metadata={'name': 'hohenheim'}) \ metadata={'name': 'hohenheim'}) \

7
tests/common/test_memoize.py
View File

@ -7,6 +7,7 @@ import pytest
from copy import deepcopy from copy import deepcopy
from planetmint.models import Transaction 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.crypto import generate_key_pair
from planetmint.transactions.common.memoize import to_dict, from_dict 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().hits == 0
assert to_dict.cache_info().misses == 0 assert to_dict.cache_info().misses == 0
tx = Transaction.create([alice.public_key], tx = Create.generate([alice.public_key],
[([alice.public_key], 1)], [([alice.public_key], 1)],
asset=asset,)\ asset=asset,)\
.sign([alice.private_key]) .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().hits == 0
assert from_dict.cache_info().misses == 0 assert from_dict.cache_info().misses == 0
tx = Transaction.create([alice.public_key], tx = Create.generate([alice.public_key],
[([alice.public_key], 1)], [([alice.public_key], 1)],
asset=asset,)\ asset=asset,)\
.sign([alice.private_key]) .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().hits == 0
assert Transaction._input_valid.cache_info().misses == 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)], [([alice.public_key], 1)],
asset=asset,)\ asset=asset,)\
.sign([alice.private_key]) .sign([alice.private_key])

62
tests/common/test_transaction.py
View File

@ -11,6 +11,8 @@ from copy import deepcopy
from base58 import b58encode, b58decode from base58 import b58encode, b58decode
from cryptoconditions import Ed25519Sha256 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 from pytest import mark, raises
try: try:
from hashlib import sha3_256 from hashlib import sha3_256
@ -690,7 +692,7 @@ def test_create_create_transaction_single_io(user_output, user_pub, data):
'version': Transaction.VERSION, '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) asset=data)
tx_dict = tx.to_dict() tx_dict = tx.to_dict()
tx_dict['inputs'][0]['fulfillment'] = None 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, def test_validate_single_io_create_transaction(user_pub, user_priv, data,
asset_definition): 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]) tx = tx.sign([user_priv])
assert tx.inputs_valid() is True 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', 'operation': 'CREATE',
'version': Transaction.VERSION 'version': Transaction.VERSION
} }
tx = Transaction.create([user_pub, user2_pub], tx = Create.generate([user_pub, user2_pub],
[([user_pub], 1), ([user2_pub], 1)], [([user_pub], 1), ([user2_pub], 1)],
metadata={'message': 'hello'}).to_dict() metadata={'message': 'hello'}).to_dict()
tx.pop('id') 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, def test_validate_multiple_io_create_transaction(user_pub, user_priv,
user2_pub, user2_priv, user2_pub, user2_priv,
asset_definition): asset_definition):
from planetmint.transactions.common.transaction import Transaction
from .utils import validate_transaction_model 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)], [([user_pub], 1), ([user2_pub], 1)],
metadata={'message': 'hello'}) metadata={'message': 'hello'})
tx = tx.sign([user_priv, user2_priv]) 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', 'operation': 'CREATE',
'version': Transaction.VERSION '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) metadata=data, asset=data)
tx_dict = tx.to_dict() tx_dict = tx.to_dict()
tx_dict.pop('id') 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, def test_validate_threshold_create_transaction(user_pub, user_priv, user2_pub,
data, asset_definition): data, asset_definition):
from planetmint.transactions.common.transaction import Transaction
from .utils import validate_transaction_model 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) metadata=data)
tx = tx.sign([user_priv]) tx = tx.sign([user_priv])
assert tx.inputs_valid() is True 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): def test_create_create_transaction_with_invalid_parameters(user_pub):
from planetmint.transactions.common.transaction import Transaction
with raises(TypeError): with raises(TypeError):
Transaction.create('not a list') Create.generate('not a list')
with raises(TypeError): with raises(TypeError):
Transaction.create([], 'not a list') Create.generate([], 'not a list')
with raises(ValueError): with raises(ValueError):
Transaction.create([], [user_pub]) Create.generate([], [user_pub])
with raises(ValueError): with raises(ValueError):
Transaction.create([user_pub], []) Create.generate([user_pub], [])
with raises(ValueError): with raises(ValueError):
Transaction.create([user_pub], [user_pub]) Create.generate([user_pub], [user_pub])
with raises(ValueError): with raises(ValueError):
Transaction.create([user_pub], [([user_pub],)]) Create.generate([user_pub], [([user_pub],)])
with raises(TypeError): with raises(TypeError):
Transaction.create([user_pub], [([user_pub], 1)], Create.generate([user_pub], [([user_pub], 1)],
metadata='not a dict or none') metadata='not a dict or none')
with raises(TypeError): with raises(TypeError):
Transaction.create([user_pub], Create.generate([user_pub],
[([user_pub], 1)], [([user_pub], 1)],
asset='not a dict or none') 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 'version': Transaction.VERSION
} }
inputs = tx.to_inputs([0]) 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) asset_id=tx.id)
transfer_tx = transfer_tx.sign([user_priv]) transfer_tx = transfer_tx.sign([user_priv])
transfer_tx = transfer_tx.to_dict() transfer_tx = transfer_tx.to_dict()
@ -889,7 +886,7 @@ def test_create_transfer_transaction_multiple_io(user_pub, user_priv,
asset_definition): asset_definition):
from planetmint.transactions.common.transaction import Transaction 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'}) metadata={'message': 'hello'})
tx = tx.sign([user_priv]) tx = tx.sign([user_priv])
@ -921,7 +918,7 @@ def test_create_transfer_transaction_multiple_io(user_pub, user_priv,
'version': Transaction.VERSION 'version': Transaction.VERSION
} }
transfer_tx = Transaction.transfer(tx.to_inputs(), transfer_tx = Transfer.generate(tx.to_inputs(),
[([user2_pub], 1), ([user2_pub], 1)], [([user2_pub], 1), ([user2_pub], 1)],
asset_id=tx.id) asset_id=tx.id)
transfer_tx = transfer_tx.sign([user_priv, user2_priv]) 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): def test_create_transfer_with_invalid_parameters(tx, user_pub):
from planetmint.transactions.common.transaction import Transaction
with raises(TypeError): with raises(TypeError):
Transaction.transfer({}, [], tx.id) Transfer.generate({}, [], tx.id)
with raises(ValueError): with raises(ValueError):
Transaction.transfer([], [], tx.id) Transfer.generate([], [], tx.id)
with raises(TypeError): with raises(TypeError):
Transaction.transfer(['fulfillment'], {}, tx.id) Transfer.generate(['fulfillment'], {}, tx.id)
with raises(ValueError): with raises(ValueError):
Transaction.transfer(['fulfillment'], [], tx.id) Transfer.generate(['fulfillment'], [], tx.id)
with raises(ValueError): with raises(ValueError):
Transaction.transfer(['fulfillment'], [user_pub], tx.id) Transfer.generate(['fulfillment'], [user_pub], tx.id)
with raises(ValueError): with raises(ValueError):
Transaction.transfer(['fulfillment'], [([user_pub],)], tx.id) Transfer.generate(['fulfillment'], [([user_pub],)], tx.id)
with raises(TypeError): with raises(TypeError):
Transaction.transfer(['fulfillment'], [([user_pub], 1)], Transfer.generate(['fulfillment'], [([user_pub], 1)],
tx.id, metadata='not a dict or none') tx.id, metadata='not a dict or none')
with raises(TypeError): with raises(TypeError):
Transaction.transfer(['fulfillment'], [([user_pub], 1)], Transfer.generate(['fulfillment'], [([user_pub], 1)],
['not a string']) ['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): def test_unspent_outputs_property(merlin, alice, bob, carol):
from planetmint.transactions.common.transaction import Transaction tx = Create.generate(
tx = Transaction.create(
[merlin.public_key], [merlin.public_key],
[([alice.public_key], 1), [([alice.public_key], 1),
([bob.public_key], 2), ([bob.public_key], 2),

16
tests/conftest.py
View File

@ -285,9 +285,9 @@ def mock_get_validators(network_validators):
@pytest.fixture @pytest.fixture
def create_tx(alice, user_pk): 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()}.' 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 @pytest.fixture
@ -304,17 +304,17 @@ def posted_create_tx(b, signed_create_tx):
@pytest.fixture @pytest.fixture
def signed_transfer_tx(signed_create_tx, user_pk, user_sk): 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() 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]) return tx.sign([user_sk])
@pytest.fixture @pytest.fixture
def double_spend_tx(signed_create_tx, carol_pubkey, user_sk): 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() inputs = signed_create_tx.to_inputs()
tx = Transaction.transfer( tx = Transfer.generate(
inputs, [([carol_pubkey], 1)], asset_id=signed_create_tx.id) inputs, [([carol_pubkey], 1)], asset_id=signed_create_tx.id)
return tx.sign([user_sk]) return tx.sign([user_sk])
@ -326,11 +326,11 @@ def _get_height(b):
@pytest.fixture @pytest.fixture
def inputs(user_pk, b, alice): 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 # create blocks with transactions for `USER` to spend
for height in range(1, 4): for height in range(1, 4):
transactions = [ transactions = [
Transaction.create( Create.generate(
[alice.public_key], [alice.public_key],
[([user_pk], 1)], [([user_pk], 1)],
metadata={'msg': random.random()}, metadata={'msg': random.random()},

82
tests/db/test_bigchain_api.py → tests/db/test_planetmint_api.py
View File

@ -4,6 +4,8 @@
# Code is Apache-2.0 and docs are CC-BY-4.0 # Code is Apache-2.0 and docs are CC-BY-4.0
from unittest.mock import patch from unittest.mock import patch
from planetmint.transactions.types.assets.create import Create
from planetmint.transactions.types.assets.transfer import Transfer
import pytest import pytest
from base58 import b58decode from base58 import b58decode
@ -14,19 +16,18 @@ pytestmark = pytest.mark.bdb
class TestBigchainApi(object): class TestBigchainApi(object):
def test_get_spent_with_double_spend_detected(self, b, alice): 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.transactions.common.exceptions import DoubleSpend
from planetmint.exceptions import CriticalDoubleSpend 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]) tx = tx.sign([alice.private_key])
b.store_bulk_transactions([tx]) 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) asset_id=tx.id)
transfer_tx = transfer_tx.sign([alice.private_key]) 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) asset_id=tx.id)
transfer_tx2 = transfer_tx2.sign([alice.private_key]) transfer_tx2 = transfer_tx2.sign([alice.private_key])
@ -44,10 +45,9 @@ class TestBigchainApi(object):
b.get_spent(tx.id, 0) b.get_spent(tx.id, 0)
def test_double_inclusion(self, b, alice): def test_double_inclusion(self, b, alice):
from planetmint.models import Transaction
from planetmint.backend.exceptions import OperationError 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]) tx = tx.sign([alice.private_key])
b.store_bulk_transactions([tx]) b.store_bulk_transactions([tx])
@ -56,7 +56,6 @@ class TestBigchainApi(object):
b.store_bulk_transactions([tx]) b.store_bulk_transactions([tx])
def test_text_search(self, b, alice): def test_text_search(self, b, alice):
from planetmint.models import Transaction
# define the assets # define the assets
asset1 = {'msg': 'Planetmint 1'} asset1 = {'msg': 'Planetmint 1'}
@ -64,11 +63,11 @@ class TestBigchainApi(object):
asset3 = {'msg': 'Planetmint 3'} asset3 = {'msg': 'Planetmint 3'}
# create the transactions # 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]) 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]) 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]) asset=asset3).sign([alice.private_key])
# write the transactions to the DB # write the transactions to the DB
@ -83,23 +82,21 @@ class TestBigchainApi(object):
from cryptoconditions import Ed25519Sha256 from cryptoconditions import Ed25519Sha256
from planetmint.transactions.common.exceptions import InputDoesNotExist from planetmint.transactions.common.exceptions import InputDoesNotExist
from planetmint.transactions.common.transaction import Input, TransactionLink from planetmint.transactions.common.transaction import Input, TransactionLink
from planetmint.models import Transaction
# Create an input for a non existing transaction # Create an input for a non existing transaction
input = Input(Ed25519Sha256(public_key=b58decode(user_pk)), input = Input(Ed25519Sha256(public_key=b58decode(user_pk)),
[user_pk], [user_pk],
TransactionLink('somethingsomething', 0)) TransactionLink('somethingsomething', 0))
tx = Transaction.transfer([input], [([user_pk], 1)], tx = Transfer.generate([input], [([user_pk], 1)],
asset_id='mock_asset_link') asset_id='mock_asset_link')
with pytest.raises(InputDoesNotExist): with pytest.raises(InputDoesNotExist):
tx.validate(b) tx.validate(b)
def test_write_transaction(self, b, user_sk, user_pk, alice, create_tx): def test_write_transaction(self, b, user_sk, user_pk, alice, create_tx):
from planetmint.models import Transaction
asset1 = {'msg': 'Planetmint 1'} 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]) asset=asset1).sign([alice.private_key])
b.store_bulk_transactions([tx]) b.store_bulk_transactions([tx])
@ -128,12 +125,11 @@ class TestTransactionValidation(object):
def test_non_create_valid_input_wrong_owner(self, b, user_pk): 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.crypto import generate_key_pair
from planetmint.transactions.common.exceptions import InvalidSignature 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_tx = b.fastquery.get_outputs_by_public_key(user_pk).pop()
input_transaction = b.get_transaction(input_tx.txid) input_transaction = b.get_transaction(input_tx.txid)
sk, pk = generate_key_pair() sk, pk = generate_key_pair()
tx = Transaction.create([pk], [([user_pk], 1)]) tx = Create.generate([pk], [([user_pk], 1)])
tx.operation = 'TRANSFER' tx.operation = 'TRANSFER'
tx.asset = {'id': input_transaction.id} tx.asset = {'id': input_transaction.id}
tx.inputs[0].fulfills = input_tx 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, def test_transfer_single_owner_single_input(self, b, inputs, user_pk,
user_sk): user_sk):
from planetmint.transactions.common import crypto from planetmint.transactions.common import crypto
from planetmint.models import Transaction
user2_sk, user2_pk = crypto.generate_key_pair() user2_sk, user2_pk = crypto.generate_key_pair()
tx_link = b.fastquery.get_outputs_by_public_key(user_pk).pop() tx_link = b.fastquery.get_outputs_by_public_key(user_pk).pop()
input_tx = b.get_transaction(tx_link.txid) input_tx = b.get_transaction(tx_link.txid)
inputs = input_tx.to_inputs() inputs = input_tx.to_inputs()
tx = Transaction.transfer(inputs, [([user2_pk], 1)], tx = Transfer.generate(inputs, [([user2_pk], 1)],
asset_id=input_tx.id) asset_id=input_tx.id)
tx = tx.sign([user_sk]) tx = tx.sign([user_sk])
@ -178,14 +173,13 @@ class TestMultipleInputs(object):
user_pk, user_pk,
inputs): inputs):
from planetmint.transactions.common import crypto from planetmint.transactions.common import crypto
from planetmint.models import Transaction
user2_sk, user2_pk = crypto.generate_key_pair() user2_sk, user2_pk = crypto.generate_key_pair()
user3_sk, user3_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() tx_link = b.fastquery.get_outputs_by_public_key(user_pk).pop()
input_tx = b.get_transaction(tx_link.txid) 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)], [([user2_pk, user3_pk], 1)],
asset_id=input_tx.id) asset_id=input_tx.id)
tx = tx.sign([user_sk]) tx = tx.sign([user_sk])
@ -200,12 +194,11 @@ class TestMultipleInputs(object):
user_pk, user_pk,
alice): alice):
from planetmint.transactions.common import crypto from planetmint.transactions.common import crypto
from planetmint.models import Transaction
user2_sk, user2_pk = crypto.generate_key_pair() user2_sk, user2_pk = crypto.generate_key_pair()
user3_sk, user3_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]) tx = tx.sign([alice.private_key])
b.store_bulk_transactions([tx]) b.store_bulk_transactions([tx])
@ -213,7 +206,7 @@ class TestMultipleInputs(object):
input_tx = b.get_transaction(owned_input.txid) input_tx = b.get_transaction(owned_input.txid)
inputs = input_tx.to_inputs() 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) asset_id=input_tx.id)
transfer_tx = transfer_tx.sign([user_sk, user2_sk]) transfer_tx = transfer_tx.sign([user_sk, user2_sk])
@ -228,13 +221,12 @@ class TestMultipleInputs(object):
user_pk, user_pk,
alice): alice):
from planetmint.transactions.common import crypto from planetmint.transactions.common import crypto
from planetmint.models import Transaction
user2_sk, user2_pk = crypto.generate_key_pair() user2_sk, user2_pk = crypto.generate_key_pair()
user3_sk, user3_pk = crypto.generate_key_pair() user3_sk, user3_pk = crypto.generate_key_pair()
user4_sk, user4_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]) tx = tx.sign([alice.private_key])
b.store_bulk_transactions([tx]) 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_link = b.fastquery.get_outputs_by_public_key(user_pk).pop()
tx_input = b.get_transaction(tx_link.txid) 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)], [([user3_pk, user4_pk], 1)],
asset_id=tx_input.id) asset_id=tx_input.id)
tx = tx.sign([user_sk, user2_sk]) 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): 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 import crypto
from planetmint.transactions.common.transaction import TransactionLink from planetmint.transactions.common.transaction import TransactionLink
from planetmint.models import Transaction
user2_sk, user2_pk = crypto.generate_key_pair() 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]) tx = tx.sign([alice.private_key])
b.store_bulk_transactions([tx]) b.store_bulk_transactions([tx])
@ -267,7 +258,7 @@ class TestMultipleInputs(object):
assert owned_inputs_user1 == [TransactionLink(tx.id, 0)] assert owned_inputs_user1 == [TransactionLink(tx.id, 0)]
assert owned_inputs_user2 == [] 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) asset_id=tx.id)
tx_transfer = tx_transfer.sign([user_sk]) tx_transfer = tx_transfer.sign([user_sk])
b.store_bulk_transactions([tx_transfer]) b.store_bulk_transactions([tx_transfer])
@ -282,12 +273,11 @@ class TestMultipleInputs(object):
user_pk, alice): user_pk, alice):
from planetmint.transactions.common import crypto from planetmint.transactions.common import crypto
from planetmint.transactions.common.transaction import TransactionLink from planetmint.transactions.common.transaction import TransactionLink
from planetmint.models import Transaction
user2_sk, user2_pk = crypto.generate_key_pair() user2_sk, user2_pk = crypto.generate_key_pair()
# create divisible asset # 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]) tx_create_signed = tx_create.sign([alice.private_key])
b.store_bulk_transactions([tx_create_signed]) b.store_bulk_transactions([tx_create_signed])
@ -301,7 +291,7 @@ class TestMultipleInputs(object):
assert owned_inputs_user2 == [] assert owned_inputs_user2 == []
# transfer divisible asset divided in two outputs # 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)], [([user2_pk], 1), ([user2_pk], 1)],
asset_id=tx_create.id) asset_id=tx_create.id)
tx_transfer_signed = tx_transfer.sign([user_sk]) 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): def test_get_owned_ids_multiple_owners(self, b, user_sk, user_pk, alice):
from planetmint.transactions.common import crypto from planetmint.transactions.common import crypto
from planetmint.transactions.common.transaction import TransactionLink from planetmint.transactions.common.transaction import TransactionLink
from planetmint.models import Transaction
user2_sk, user2_pk = crypto.generate_key_pair() user2_sk, user2_pk = crypto.generate_key_pair()
user3_sk, user3_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]) tx = tx.sign([alice.private_key])
b.store_bulk_transactions([tx]) b.store_bulk_transactions([tx])
@ -333,7 +322,7 @@ class TestMultipleInputs(object):
assert owned_inputs_user1 == owned_inputs_user2 assert owned_inputs_user1 == owned_inputs_user2
assert owned_inputs_user1 == expected_owned_inputs_user1 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) asset_id=tx.id)
tx = tx.sign([user_sk, user2_sk]) tx = tx.sign([user_sk, user2_sk])
b.store_bulk_transactions([tx]) 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): def test_get_spent_single_tx_single_output(self, b, user_sk, user_pk, alice):
from planetmint.transactions.common import crypto from planetmint.transactions.common import crypto
from planetmint.models import Transaction
user2_sk, user2_pk = crypto.generate_key_pair() 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]) tx = tx.sign([alice.private_key])
b.store_bulk_transactions([tx]) b.store_bulk_transactions([tx])
@ -363,7 +351,7 @@ class TestMultipleInputs(object):
assert spent_inputs_user1 is None assert spent_inputs_user1 is None
# create a transaction and send it # 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) asset_id=tx.id)
tx = tx.sign([user_sk]) tx = tx.sign([user_sk])
b.store_bulk_transactions([tx]) 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): def test_get_spent_single_tx_multiple_outputs(self, b, user_sk, user_pk, alice):
from planetmint.transactions.common import crypto from planetmint.transactions.common import crypto
from planetmint.models import Transaction
# create a new users # create a new users
user2_sk, user2_pk = crypto.generate_key_pair() user2_sk, user2_pk = crypto.generate_key_pair()
# create a divisible asset with 3 outputs # 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), ([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 assert b.get_spent(input_tx.txid, input_tx.output) is None
# transfer the first 2 inputs # 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)], [([user2_pk], 1), ([user2_pk], 1)],
asset_id=tx_create.id) asset_id=tx_create.id)
tx_transfer_signed = tx_transfer.sign([user_sk]) 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): def test_get_spent_multiple_owners(self, b, user_sk, user_pk, alice):
from planetmint.transactions.common import crypto from planetmint.transactions.common import crypto
from planetmint.models import Transaction
user2_sk, user2_pk = crypto.generate_key_pair() user2_sk, user2_pk = crypto.generate_key_pair()
user3_sk, user3_pk = crypto.generate_key_pair() user3_sk, user3_pk = crypto.generate_key_pair()
@ -418,7 +404,7 @@ class TestMultipleInputs(object):
transactions = [] transactions = []
for i in range(3): for i in range(3):
payload = {'somedata': i} 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) payload)
tx = tx.sign([alice.private_key]) tx = tx.sign([alice.private_key])
transactions.append(tx) transactions.append(tx)
@ -431,7 +417,7 @@ class TestMultipleInputs(object):
assert b.get_spent(input_tx.txid, input_tx.output) is None assert b.get_spent(input_tx.txid, input_tx.output) is None
# create a transaction # create a transaction
tx = Transaction.transfer(transactions[0].to_inputs(), tx = Transfer.generate(transactions[0].to_inputs(),
[([user3_pk], 1)], [([user3_pk], 1)],
asset_id=transactions[0].id) asset_id=transactions[0].id)
tx = tx.sign([user_sk, user2_sk]) 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 """Recreate duplicated fulfillments bug
https://github.com/planetmint/planetmint/issues/1099 https://github.com/planetmint/planetmint/issues/1099
""" """
from planetmint.models import Transaction
from planetmint.transactions.common.exceptions import DoubleSpend from planetmint.transactions.common.exceptions import DoubleSpend
# create a divisible asset # 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]) tx_create_signed = tx_create.sign([alice.private_key])
assert b.validate_transaction(tx_create_signed) == tx_create_signed 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 # Create a transfer transaction with duplicated fulfillments
dup_inputs = tx_create.to_inputs() + tx_create.to_inputs() 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) asset_id=tx_create.id)
tx_transfer_signed = tx_transfer.sign([alice.private_key]) tx_transfer_signed = tx_transfer.sign([alice.private_key])
with pytest.raises(DoubleSpend): 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): def test_transaction_unicode(b, alice):
import copy import copy
from planetmint.transactions.common.utils import serialize from planetmint.transactions.common.utils import serialize
from planetmint.models import Transaction
# http://www.fileformat.info/info/unicode/char/1f37a/index.htm # http://www.fileformat.info/info/unicode/char/1f37a/index.htm
beer_python = {'beer': '\N{BEER MUG}'} beer_python = {'beer': '\N{BEER MUG}'}
beer_json = '{"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]) ).sign([alice.private_key])
tx_1 = copy.deepcopy(tx) tx_1 = copy.deepcopy(tx)

24
tests/tendermint/test_core.py
View File

@ -4,6 +4,8 @@
# Code is Apache-2.0 and docs are CC-BY-4.0 # Code is Apache-2.0 and docs are CC-BY-4.0
import json import json
from planetmint.transactions.types.assets.create import Create
from planetmint.transactions.types.assets.transfer import Transfer
import pytest import pytest
import random import random
@ -202,13 +204,12 @@ def test_info(b):
def test_check_tx__signed_create_is_ok(b): def test_check_tx__signed_create_is_ok(b):
from planetmint import App from planetmint import App
from planetmint.models import Transaction
from planetmint.transactions.common.crypto import generate_key_pair from planetmint.transactions.common.crypto import generate_key_pair
alice = generate_key_pair() alice = generate_key_pair()
bob = generate_key_pair() bob = generate_key_pair()
tx = Transaction.create([alice.public_key], tx = Create.generate([alice.public_key],
[([bob.public_key], 1)])\ [([bob.public_key], 1)])\
.sign([alice.private_key]) .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): def test_check_tx__unsigned_create_is_error(b):
from planetmint import App from planetmint import App
from planetmint.models import Transaction
from planetmint.transactions.common.crypto import generate_key_pair from planetmint.transactions.common.crypto import generate_key_pair
alice = generate_key_pair() alice = generate_key_pair()
bob = generate_key_pair() bob = generate_key_pair()
tx = Transaction.create([alice.public_key], tx = Create.generate([alice.public_key],
[([bob.public_key], 1)]) [([bob.public_key], 1)])
app = App(b) 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): def test_deliver_tx__valid_create_updates_db_and_emits_event(b, init_chain_request):
import multiprocessing as mp import multiprocessing as mp
from planetmint import App from planetmint import App
from planetmint.models import Transaction
from planetmint.transactions.common.crypto import generate_key_pair from planetmint.transactions.common.crypto import generate_key_pair
alice = generate_key_pair() alice = generate_key_pair()
bob = generate_key_pair() bob = generate_key_pair()
events = mp.Queue() events = mp.Queue()
tx = Transaction.create([alice.public_key], tx = Create.generate([alice.public_key],
[([bob.public_key], 1)])\ [([bob.public_key], 1)])\
.sign([alice.private_key]) .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): def test_deliver_tx__double_spend_fails(b, init_chain_request):
from planetmint import App from planetmint import App
from planetmint.models import Transaction
from planetmint.transactions.common.crypto import generate_key_pair from planetmint.transactions.common.crypto import generate_key_pair
alice = generate_key_pair() alice = generate_key_pair()
bob = generate_key_pair() bob = generate_key_pair()
tx = Transaction.create([alice.public_key], tx = Create.generate([alice.public_key],
[([bob.public_key], 1)])\ [([bob.public_key], 1)])\
.sign([alice.private_key]) .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): def test_deliver_transfer_tx__double_spend_fails(b, init_chain_request):
from planetmint import App from planetmint import App
from planetmint.models import Transaction
from planetmint.transactions.common.crypto import generate_key_pair from planetmint.transactions.common.crypto import generate_key_pair
app = App(b) app = App(b)
@ -319,7 +316,7 @@ def test_deliver_transfer_tx__double_spend_fails(b, init_chain_request):
'msg': 'live long and prosper' 'msg': 'live long and prosper'
} }
tx = Transaction.create([alice.public_key], tx = Create.generate([alice.public_key],
[([alice.public_key], 1)], [([alice.public_key], 1)],
asset=asset)\ asset=asset)\
.sign([alice.private_key]) .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)) result = app.deliver_tx(encode_tx_to_bytes(tx))
assert result.code == OkCode assert result.code == OkCode
tx_transfer = Transaction.transfer(tx.to_inputs(), tx_transfer = Transfer.generate(tx.to_inputs(),
[([bob.public_key], 1)], [([bob.public_key], 1)],
asset_id=tx.id)\ asset_id=tx.id)\
.sign([alice.private_key]) .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)) result = app.deliver_tx(encode_tx_to_bytes(tx_transfer))
assert result.code == OkCode assert result.code == OkCode
double_spend = Transaction.transfer(tx.to_inputs(), double_spend = Transfer.generate(tx.to_inputs(),
[([carly.public_key], 1)], [([carly.public_key], 1)],
asset_id=tx.id)\ asset_id=tx.id)\
.sign([alice.private_key]) .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): def test_store_pre_commit_state_in_end_block(b, alice, init_chain_request):
from planetmint import App from planetmint import App
from planetmint.backend import query 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)], [([alice.public_key], 1)],
asset={'msg': 'live long and prosper'})\ asset={'msg': 'live long and prosper'})\
.sign([alice.private_key]) .sign([alice.private_key])

21
tests/tendermint/test_fastquery.py
View File

@ -6,7 +6,8 @@
import pytest import pytest
from planetmint.transactions.common.transaction import TransactionLink 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 pytestmark = pytest.mark.bdb
@ -14,9 +15,9 @@ pytestmark = pytest.mark.bdb
@pytest.fixture @pytest.fixture
def txns(b, user_pk, user_sk, user2_pk, user2_sk): def txns(b, user_pk, user_sk, user2_pk, user2_sk):
txs = [Transaction.create([user_pk], [([user2_pk], 1)]).sign([user_sk]), txs = [Create.generate([user_pk], [([user2_pk], 1)]).sign([user_sk]),
Transaction.create([user2_pk], [([user_pk], 1)]).sign([user2_sk]), Create.generate([user2_pk], [([user_pk], 1)]).sign([user2_sk]),
Transaction.create([user_pk], [([user_pk], 1), ([user2_pk], 1)]) Create.generate([user_pk], [([user_pk], 1), ([user2_pk], 1)])
.sign([user_sk])] .sign([user_sk])]
b.store_bulk_transactions(txs) b.store_bulk_transactions(txs)
return 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): def test_filter_spent_outputs(b, user_pk, user_sk):
out = [([user_pk], 1)] out = [([user_pk], 1)]
tx1 = Transaction.create([user_pk], out * 2) tx1 = Create.generate([user_pk], out * 2)
tx1.sign([user_sk]) tx1.sign([user_sk])
inputs = tx1.to_inputs() 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.sign([user_sk])
# tx2 produces a new unspent. inputs[1] remains unspent. # 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): def test_filter_unspent_outputs(b, user_pk, user_sk):
out = [([user_pk], 1)] out = [([user_pk], 1)]
tx1 = Transaction.create([user_pk], out * 2) tx1 = Create.generate([user_pk], out * 2)
tx1.sign([user_sk]) tx1.sign([user_sk])
inputs = tx1.to_inputs() 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.sign([user_sk])
# tx2 produces a new unspent. input[1] remains unspent. # 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 import backend
from planetmint.backend import connect from planetmint.backend import connect
tx1 = Transaction.create([user_pk], tx1 = Create.generate([user_pk],
[([user_pk], 3), ([user_pk], 2), ([user_pk], 1)])\ [([user_pk], 3), ([user_pk], 2), ([user_pk], 1)])\
.sign([user_sk]) .sign([user_sk])
b.store_bulk_transactions([tx1]) b.store_bulk_transactions([tx1])
inputs = tx1.to_inputs() 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) assert tx2.validate(b)
tx2_dict = tx2.to_dict() tx2_dict = tx2.to_dict()

12
tests/tendermint/test_integration.py
View File

@ -4,6 +4,8 @@
# Code is Apache-2.0 and docs are CC-BY-4.0 # Code is Apache-2.0 and docs are CC-BY-4.0
import codecs 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 from tendermint.abci import types_pb2 as types
import json import json
@ -23,7 +25,6 @@ def test_app(b, eventqueue_fixture, init_chain_request):
from planetmint import App from planetmint import App
from planetmint.tendermint_utils import calculate_hash from planetmint.tendermint_utils import calculate_hash
from planetmint.transactions.common.crypto import generate_key_pair from planetmint.transactions.common.crypto import generate_key_pair
from planetmint.models import Transaction
app = App(b, eventqueue_fixture) app = App(b, eventqueue_fixture)
p = ProtocolHandler(app) p = ProtocolHandler(app)
@ -49,7 +50,7 @@ def test_app(b, eventqueue_fixture, init_chain_request):
alice = generate_key_pair() alice = generate_key_pair()
bob = generate_key_pair() bob = generate_key_pair()
tx = Transaction.create([alice.public_key], tx = Create.generate([alice.public_key],
[([bob.public_key], 1)])\ [([bob.public_key], 1)])\
.sign([alice.private_key]) .sign([alice.private_key])
etxn = json.dumps(tx.to_dict()).encode('utf8') etxn = json.dumps(tx.to_dict()).encode('utf8')
@ -114,11 +115,10 @@ def test_app(b, eventqueue_fixture, init_chain_request):
@pytest.mark.abci @pytest.mark.abci
def test_post_transaction_responses(tendermint_ws_url, b): def test_post_transaction_responses(tendermint_ws_url, b):
from planetmint.transactions.common.crypto import generate_key_pair from planetmint.transactions.common.crypto import generate_key_pair
from planetmint.models import Transaction
alice = generate_key_pair() alice = generate_key_pair()
bob = generate_key_pair() bob = generate_key_pair()
tx = Transaction.create([alice.public_key], tx = Create.generate([alice.public_key],
[([alice.public_key], 1)], [([alice.public_key], 1)],
asset=None)\ asset=None)\
.sign([alice.private_key]) .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) code, message = b.write_transaction(tx, BROADCAST_TX_COMMIT)
assert code == 202 assert code == 202
tx_transfer = Transaction.transfer(tx.to_inputs(), tx_transfer = Transfer.generate(tx.to_inputs(),
[([bob.public_key], 1)], [([bob.public_key], 1)],
asset_id=tx.id)\ asset_id=tx.id)\
.sign([alice.private_key]) .sign([alice.private_key])
@ -135,7 +135,7 @@ def test_post_transaction_responses(tendermint_ws_url, b):
assert code == 202 assert code == 202
carly = generate_key_pair() carly = generate_key_pair()
double_spend = Transaction.transfer( double_spend = Transfer.generate(
tx.to_inputs(), tx.to_inputs(),
[([carly.public_key], 1)], [([carly.public_key], 1)],
asset_id=tx.id, asset_id=tx.id,

40
tests/tendermint/test_lib.py
View File

@ -5,6 +5,8 @@
import os import os
from unittest.mock import patch from unittest.mock import patch
from planetmint.transactions.types.assets.create import Create
from planetmint.transactions.types.assets.transfer import Transfer
try: try:
@ -25,7 +27,6 @@ from planetmint.lib import Block
@pytest.mark.bdb @pytest.mark.bdb
def test_asset_is_separated_from_transaciton(b): def test_asset_is_separated_from_transaciton(b):
import copy import copy
from planetmint.models import Transaction
from planetmint.transactions.common.crypto import generate_key_pair from planetmint.transactions.common.crypto import generate_key_pair
alice = generate_key_pair() alice = generate_key_pair()
@ -40,7 +41,7 @@ def test_asset_is_separated_from_transaciton(b):
'tell a lie', 'tell a lie',
'hurt you']} 'hurt you']}
tx = Transaction.create([alice.public_key], tx = Create.generate([alice.public_key],
[([bob.public_key], 1)], [([bob.public_key], 1)],
metadata=None, metadata=None,
asset=asset)\ asset=asset)\
@ -81,11 +82,10 @@ def test_get_empty_block(_0, _1, b):
def test_validation_error(b): def test_validation_error(b):
from planetmint.models import Transaction
from planetmint.transactions.common.crypto import generate_key_pair from planetmint.transactions.common.crypto import generate_key_pair
alice = generate_key_pair() alice = generate_key_pair()
tx = Transaction.create([alice.public_key], tx = Create.generate([alice.public_key],
[([alice.public_key], 1)], [([alice.public_key], 1)],
asset=None)\ asset=None)\
.sign([alice.private_key]).to_dict() .sign([alice.private_key]).to_dict()
@ -96,12 +96,11 @@ def test_validation_error(b):
@patch('requests.post') @patch('requests.post')
def test_write_and_post_transaction(mock_post, b): 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.transactions.common.crypto import generate_key_pair
from planetmint.tendermint_utils import encode_transaction from planetmint.tendermint_utils import encode_transaction
alice = generate_key_pair() alice = generate_key_pair()
tx = Transaction.create([alice.public_key], tx = Create.generate([alice.public_key],
[([alice.public_key], 1)], [([alice.public_key], 1)],
asset=None)\ asset=None)\
.sign([alice.private_key]).to_dict() .sign([alice.private_key]).to_dict()
@ -123,10 +122,9 @@ def test_write_and_post_transaction(mock_post, b):
BROADCAST_TX_COMMIT BROADCAST_TX_COMMIT
]) ])
def test_post_transaction_valid_modes(mock_post, b, mode): def test_post_transaction_valid_modes(mock_post, b, mode):
from planetmint.models import Transaction
from planetmint.transactions.common.crypto import generate_key_pair from planetmint.transactions.common.crypto import generate_key_pair
alice = generate_key_pair() alice = generate_key_pair()
tx = Transaction.create([alice.public_key], tx = Create.generate([alice.public_key],
[([alice.public_key], 1)], [([alice.public_key], 1)],
asset=None) \ asset=None) \
.sign([alice.private_key]).to_dict() .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): 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.crypto import generate_key_pair
from planetmint.transactions.common.exceptions import ValidationError from planetmint.transactions.common.exceptions import ValidationError
alice = generate_key_pair() alice = generate_key_pair()
tx = Transaction.create([alice.public_key], tx = Create.generate([alice.public_key],
[([alice.public_key], 1)], [([alice.public_key], 1)],
asset=None) \ asset=None) \
.sign([alice.private_key]).to_dict() .sign([alice.private_key]).to_dict()
@ -354,28 +351,27 @@ def test_get_utxoset_merkle_root(b, utxoset):
@pytest.mark.bdb @pytest.mark.bdb
def test_get_spent_transaction_critical_double_spend(b, alice, bob, carol): def test_get_spent_transaction_critical_double_spend(b, alice, bob, carol):
from planetmint.models import Transaction
from planetmint.exceptions import CriticalDoubleSpend from planetmint.exceptions import CriticalDoubleSpend
from planetmint.transactions.common.exceptions import DoubleSpend from planetmint.transactions.common.exceptions import DoubleSpend
asset = {'test': 'asset'} asset = {'test': 'asset'}
tx = Transaction.create([alice.public_key], tx = Create.generate([alice.public_key],
[([alice.public_key], 1)], [([alice.public_key], 1)],
asset=asset)\ asset=asset)\
.sign([alice.private_key]) .sign([alice.private_key])
tx_transfer = Transaction.transfer(tx.to_inputs(), tx_transfer = Transfer.generate(tx.to_inputs(),
[([bob.public_key], 1)], [([bob.public_key], 1)],
asset_id=tx.id)\ asset_id=tx.id)\
.sign([alice.private_key]) .sign([alice.private_key])
double_spend = Transaction.transfer(tx.to_inputs(), double_spend = Transfer.generate(tx.to_inputs(),
[([carol.public_key], 1)], [([carol.public_key], 1)],
asset_id=tx.id)\ asset_id=tx.id)\
.sign([alice.private_key]) .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)], [([bob.public_key], 1)],
asset_id=tx.id)\ asset_id=tx.id)\
.sign([alice.private_key]) .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): def test_validation_with_transaction_buffer(b):
from planetmint.transactions.common.crypto import generate_key_pair from planetmint.transactions.common.crypto import generate_key_pair
from planetmint.models import Transaction
priv_key, pub_key = generate_key_pair() priv_key, pub_key = generate_key_pair()
create_tx = Transaction.create([pub_key], [([pub_key], 10)]).sign([priv_key]) create_tx = Create.generate([pub_key], [([pub_key], 10)]).sign([priv_key])
transfer_tx = Transaction.transfer(create_tx.to_inputs(), transfer_tx = Transfer.generate(create_tx.to_inputs(),
[([pub_key], 10)], [([pub_key], 10)],
asset_id=create_tx.id).sign([priv_key]) 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)], [([pub_key], 10)],
asset_id=create_tx.id).sign([priv_key]) 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 @pytest.mark.bdb
def test_get_spent_key_order(b, user_pk, user_sk, user2_pk, user2_sk): def test_get_spent_key_order(b, user_pk, user_sk, user2_pk, user2_sk):
from planetmint import backend from planetmint import backend
from planetmint.models import Transaction
from planetmint.transactions.common.crypto import generate_key_pair from planetmint.transactions.common.crypto import generate_key_pair
from planetmint.transactions.common.exceptions import DoubleSpend from planetmint.transactions.common.exceptions import DoubleSpend
alice = generate_key_pair() alice = generate_key_pair()
bob = generate_key_pair() bob = generate_key_pair()
tx1 = Transaction.create([user_pk], tx1 = Create.generate([user_pk],
[([alice.public_key], 3), ([user_pk], 2)], [([alice.public_key], 3), ([user_pk], 2)],
asset=None)\ asset=None)\
.sign([user_sk]) .sign([user_sk])
b.store_bulk_transactions([tx1]) b.store_bulk_transactions([tx1])
inputs = tx1.to_inputs() 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) assert tx2.validate(b)
tx2_dict = tx2.to_dict() 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]) 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): with pytest.raises(DoubleSpend):
tx3.validate(b) tx3.validate(b)

24
tests/test_core.py
View File

@ -4,6 +4,8 @@
# Code is Apache-2.0 and docs are CC-BY-4.0 # Code is Apache-2.0 and docs are CC-BY-4.0
import json import json
from planetmint.transactions.types.assets.create import Create
from planetmint.transactions.types.assets.transfer import Transfer
import pytest import pytest
import random import random
@ -202,13 +204,12 @@ def test_info(b):
def test_check_tx__signed_create_is_ok(b): def test_check_tx__signed_create_is_ok(b):
from planetmint import App from planetmint import App
from planetmint.models import Transaction
from planetmint.transactions.common.crypto import generate_key_pair from planetmint.transactions.common.crypto import generate_key_pair
alice = generate_key_pair() alice = generate_key_pair()
bob = generate_key_pair() bob = generate_key_pair()
tx = Transaction.create([alice.public_key], tx = Create.generate([alice.public_key],
[([bob.public_key], 1)])\ [([bob.public_key], 1)])\
.sign([alice.private_key]) .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): def test_check_tx__unsigned_create_is_error(b):
from planetmint import App from planetmint import App
from planetmint.models import Transaction
from planetmint.transactions.common.crypto import generate_key_pair from planetmint.transactions.common.crypto import generate_key_pair
alice = generate_key_pair() alice = generate_key_pair()
bob = generate_key_pair() bob = generate_key_pair()
tx = Transaction.create([alice.public_key], tx = Create.generate([alice.public_key],
[([bob.public_key], 1)]) [([bob.public_key], 1)])
app = App(b) 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): def test_deliver_tx__valid_create_updates_db_and_emits_event(b, init_chain_request):
import multiprocessing as mp import multiprocessing as mp
from planetmint import App from planetmint import App
from planetmint.models import Transaction
from planetmint.transactions.common.crypto import generate_key_pair from planetmint.transactions.common.crypto import generate_key_pair
alice = generate_key_pair() alice = generate_key_pair()
bob = generate_key_pair() bob = generate_key_pair()
events = mp.Queue() events = mp.Queue()
tx = Transaction.create([alice.public_key], tx = Create.generate([alice.public_key],
[([bob.public_key], 1)])\ [([bob.public_key], 1)])\
.sign([alice.private_key]) .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): def test_deliver_tx__double_spend_fails(b, eventqueue_fixture, init_chain_request):
from planetmint import App from planetmint import App
from planetmint.models import Transaction
from planetmint.transactions.common.crypto import generate_key_pair from planetmint.transactions.common.crypto import generate_key_pair
alice = generate_key_pair() alice = generate_key_pair()
bob = generate_key_pair() bob = generate_key_pair()
tx = Transaction.create([alice.public_key], tx = Create.generate([alice.public_key],
[([bob.public_key], 1)])\ [([bob.public_key], 1)])\
.sign([alice.private_key]) .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): def test_deliver_transfer_tx__double_spend_fails(b, init_chain_request):
from planetmint import App from planetmint import App
from planetmint.models import Transaction
from planetmint.transactions.common.crypto import generate_key_pair from planetmint.transactions.common.crypto import generate_key_pair
app = App(b) app = App(b)
@ -319,7 +316,7 @@ def test_deliver_transfer_tx__double_spend_fails(b, init_chain_request):
'msg': 'live long and prosper' 'msg': 'live long and prosper'
} }
tx = Transaction.create([alice.public_key], tx = Create.generate([alice.public_key],
[([alice.public_key], 1)], [([alice.public_key], 1)],
asset=asset)\ asset=asset)\
.sign([alice.private_key]) .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)) result = app.deliver_tx(encode_tx_to_bytes(tx))
assert result.code == OkCode assert result.code == OkCode
tx_transfer = Transaction.transfer(tx.to_inputs(), tx_transfer = Transfer.generate(tx.to_inputs(),
[([bob.public_key], 1)], [([bob.public_key], 1)],
asset_id=tx.id)\ asset_id=tx.id)\
.sign([alice.private_key]) .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)) result = app.deliver_tx(encode_tx_to_bytes(tx_transfer))
assert result.code == OkCode assert result.code == OkCode
double_spend = Transaction.transfer(tx.to_inputs(), double_spend = Transfer.generate(tx.to_inputs(),
[([carly.public_key], 1)], [([carly.public_key], 1)],
asset_id=tx.id)\ asset_id=tx.id)\
.sign([alice.private_key]) .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): def test_store_pre_commit_state_in_end_block(b, alice, init_chain_request):
from planetmint import App from planetmint import App
from planetmint.backend import query 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)], [([alice.public_key], 1)],
asset={'msg': 'live long and prosper'})\ asset={'msg': 'live long and prosper'})\
.sign([alice.private_key]) .sign([alice.private_key])

10
tests/test_parallel_validation.py
View File

@ -6,8 +6,8 @@
import pytest import pytest
from planetmint.transactions.common.crypto import generate_key_pair 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 pytestmark = pytest.mark.tendermint
@ -16,8 +16,8 @@ def generate_create_and_transfer(keypair=None):
if not keypair: if not keypair:
keypair = generate_key_pair() keypair = generate_key_pair()
priv_key, pub_key = keypair priv_key, pub_key = keypair
create_tx = Transaction.create([pub_key], [([pub_key], 10)]).sign([priv_key]) create_tx = Create.generate([pub_key], [([pub_key], 10)]).sign([priv_key])
transfer_tx = Transaction.transfer( transfer_tx = Transfer.generate(
create_tx.to_inputs(), create_tx.to_inputs(),
[([pub_key], 10)], [([pub_key], 10)],
asset_id=create_tx.id).sign([priv_key]) asset_id=create_tx.id).sign([priv_key])
@ -30,7 +30,7 @@ def test_validation_worker_process_multiple_transactions(b):
keypair = generate_key_pair() keypair = generate_key_pair()
create_tx, transfer_tx = generate_create_and_transfer(keypair) create_tx, transfer_tx = generate_create_and_transfer(keypair)
double_spend = Transaction.transfer( double_spend = Transfer.generate(
create_tx.to_inputs(), create_tx.to_inputs(),
[([keypair.public_key], 10)], [([keypair.public_key], 10)],
asset_id=create_tx.id).sign([keypair.private_key]) asset_id=create_tx.id).sign([keypair.private_key])

9
tests/test_txlist.py
View File

@ -12,18 +12,19 @@ import pytest
@pytest.fixture @pytest.fixture
def txlist(b, user_pk, user2_pk, user_sk, user2_sk): 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 # Create two CREATE transactions
create1 = Transaction.create([user_pk], [([user2_pk], 6)]) \ create1 = Create.generate([user_pk], [([user2_pk], 6)]) \
.sign([user_sk]) .sign([user_sk])
create2 = Transaction.create([user2_pk], create2 = Create.generate([user2_pk],
[([user2_pk], 5), ([user_pk], 5)]) \ [([user2_pk], 5), ([user_pk], 5)]) \
.sign([user2_sk]) .sign([user2_sk])
# Create a TRANSFER transactions # Create a TRANSFER transactions
transfer1 = Transaction.transfer(create1.to_inputs(), transfer1 = Transfer.generate(create1.to_inputs(),
[([user_pk], 8)], [([user_pk], 8)],
create1.id).sign([user2_sk]) create1.id).sign([user2_sk])

4
tests/utils.py
View File

@ -13,6 +13,7 @@ from planetmint.backend.localmongodb.connection import LocalMongoDBConnection
from planetmint.backend.schema import TABLES from planetmint.backend.schema import TABLES
from planetmint.transactions.common import crypto from planetmint.transactions.common import crypto
from planetmint.transactions.common.transaction_mode_types import BROADCAST_TX_COMMIT 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.transactions.types.elections.election import Election, Vote
from planetmint.tendermint_utils import key_to_base64 from planetmint.tendermint_utils import key_to_base64
@ -30,10 +31,9 @@ def flush_localmongo_db(connection, dbname):
def generate_block(planet): def generate_block(planet):
from planetmint.transactions.common.crypto import generate_key_pair from planetmint.transactions.common.crypto import generate_key_pair
from planetmint.models import Transaction
alice = generate_key_pair() alice = generate_key_pair()
tx = Transaction.create([alice.public_key], tx = Create.generate([alice.public_key],
[([alice.public_key], 1)], [([alice.public_key], 1)],
asset=None)\ asset=None)\
.sign([alice.private_key]) .sign([alice.private_key])

9
tests/web/test_assets.py
View File

@ -4,6 +4,7 @@
# Code is Apache-2.0 and docs are CC-BY-4.0 # Code is Apache-2.0 and docs are CC-BY-4.0
import pytest import pytest
from planetmint.transactions.types.assets.create import Create
ASSETS_ENDPOINT = '/api/v1/assets/' ASSETS_ENDPOINT = '/api/v1/assets/'
@ -22,7 +23,6 @@ def test_get_assets_with_missing_text_search(client):
@pytest.mark.bdb @pytest.mark.bdb
def test_get_assets_tendermint(client, b, alice): def test_get_assets_tendermint(client, b, alice):
from planetmint.models import Transaction
# test returns empty list when no assets are found # test returns empty list when no assets are found
res = client.get(ASSETS_ENDPOINT + '?search=abc') res = client.get(ASSETS_ENDPOINT + '?search=abc')
@ -31,7 +31,7 @@ def test_get_assets_tendermint(client, b, alice):
# create asset # create asset
asset = {'msg': 'abc'} 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]) asset=asset).sign([alice.private_key])
b.store_bulk_transactions([tx]) b.store_bulk_transactions([tx])
@ -48,14 +48,13 @@ def test_get_assets_tendermint(client, b, alice):
@pytest.mark.bdb @pytest.mark.bdb
def test_get_assets_limit_tendermint(client, b, alice): def test_get_assets_limit_tendermint(client, b, alice):
from planetmint.models import Transaction
# create two assets # create two assets
asset1 = {'msg': 'abc 1'} asset1 = {'msg': 'abc 1'}
asset2 = {'msg': 'abc 2'} 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]) 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]) asset=asset2).sign([alice.private_key])
b.store_bulk_transactions([tx1]) b.store_bulk_transactions([tx1])

6
tests/web/test_block_tendermint.py
View File

@ -5,7 +5,7 @@
import pytest import pytest
from planetmint.models import Transaction from planetmint.transactions.types.assets.create import Create
from planetmint.lib import Block from planetmint.lib import Block
BLOCKS_ENDPOINT = '/api/v1/blocks/' BLOCKS_ENDPOINT = '/api/v1/blocks/'
@ -15,7 +15,7 @@ BLOCKS_ENDPOINT = '/api/v1/blocks/'
@pytest.mark.usefixtures('inputs') @pytest.mark.usefixtures('inputs')
def test_get_block_endpoint(b, client, alice): def test_get_block_endpoint(b, client, alice):
import copy 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]) tx = tx.sign([alice.private_key])
# with store_bulk_transactions we use `insert_many` where PyMongo # 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 @pytest.mark.bdb
def test_get_block_containing_transaction(b, client, alice): 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]) tx = tx.sign([alice.private_key])
b.store_bulk_transactions([tx]) b.store_bulk_transactions([tx])

9
tests/web/test_metadata.py
View File

@ -4,6 +4,7 @@
# Code is Apache-2.0 and docs are CC-BY-4.0 # Code is Apache-2.0 and docs are CC-BY-4.0
import pytest import pytest
from planetmint.transactions.types.assets.create import Create
METADATA_ENDPOINT = '/api/v1/metadata/' METADATA_ENDPOINT = '/api/v1/metadata/'
@ -22,7 +23,6 @@ def test_get_metadata_with_missing_text_search(client):
@pytest.mark.bdb @pytest.mark.bdb
def test_get_metadata_tendermint(client, b, alice): def test_get_metadata_tendermint(client, b, alice):
from planetmint.models import Transaction
# test returns empty list when no assets are found # test returns empty list when no assets are found
res = client.get(METADATA_ENDPOINT + '?search=abc') res = client.get(METADATA_ENDPOINT + '?search=abc')
@ -32,7 +32,7 @@ def test_get_metadata_tendermint(client, b, alice):
# create asset # create asset
asset = {'msg': 'abc'} asset = {'msg': 'abc'}
metadata = {'key': 'my_meta'} 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]) asset=asset).sign([alice.private_key])
b.store_bulk_transactions([tx]) b.store_bulk_transactions([tx])
@ -49,18 +49,17 @@ def test_get_metadata_tendermint(client, b, alice):
@pytest.mark.bdb @pytest.mark.bdb
def test_get_metadata_limit_tendermint(client, b, alice): def test_get_metadata_limit_tendermint(client, b, alice):
from planetmint.models import Transaction
# create two assets # create two assets
asset1 = {'msg': 'abc 1'} asset1 = {'msg': 'abc 1'}
meta1 = {'key': 'meta 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]) asset=asset1).sign([alice.private_key])
b.store_bulk_transactions([tx1]) b.store_bulk_transactions([tx1])
asset2 = {'msg': 'abc 2'} asset2 = {'msg': 'abc 2'}
meta2 = {'key': 'meta 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]) asset=asset2).sign([alice.private_key])
b.store_bulk_transactions([tx2]) b.store_bulk_transactions([tx2])

10
tests/web/test_outputs.py
View File

@ -3,7 +3,10 @@
# SPDX-License-Identifier: (Apache-2.0 AND CC-BY-4.0) # SPDX-License-Identifier: (Apache-2.0 AND CC-BY-4.0)
# Code is Apache-2.0 and docs are CC-BY-4.0 # Code is Apache-2.0 and docs are CC-BY-4.0
import pytest import pytest
from planetmint.transactions.types.assets.create import Create
from planetmint.transactions.types.assets.transfer import Transfer
from unittest.mock import MagicMock, patch from unittest.mock import MagicMock, patch
@ -83,7 +86,6 @@ def test_get_outputs_endpoint_with_invalid_spent(client, user_pk):
@pytest.mark.abci @pytest.mark.abci
def test_get_divisble_transactions_returns_500(b, client): def test_get_divisble_transactions_returns_500(b, client):
from planetmint.models import Transaction
from planetmint.transactions.common import crypto from planetmint.transactions.common import crypto
import json import json
@ -96,7 +98,7 @@ def test_get_divisble_transactions_returns_500(b, client):
bob_priv, bob_pub = crypto.generate_key_pair() bob_priv, bob_pub = crypto.generate_key_pair()
carly_priv, carly_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]) create_tx.sign([alice_priv])
res = client.post(TX_ENDPOINT, data=json.dumps(create_tx.to_dict())) 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]) 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)], [([alice_pub], 3), ([bob_pub], 1)],
asset_id=create_tx.id) asset_id=create_tx.id)
transfer_tx.sign([alice_priv]) transfer_tx.sign([alice_priv])
@ -114,7 +116,7 @@ def test_get_divisble_transactions_returns_500(b, client):
mine([transfer_tx]) 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)], [([carly_pub], 1)],
asset_id=create_tx.id) asset_id=create_tx.id)
transfer_tx_carly.sign([bob_priv]) transfer_tx_carly.sign([bob_priv])

39
tests/web/test_transactions.py
View File

@ -15,6 +15,8 @@ except ImportError:
from sha3 import sha3_256 from sha3 import sha3_256
from planetmint.transactions.common import crypto 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 ( from planetmint.transactions.common.transaction_mode_types import (
BROADCAST_TX_COMMIT, BROADCAST_TX_ASYNC, BROADCAST_TX_SYNC) 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 @pytest.mark.abci
def test_post_create_transaction_endpoint(b, client): def test_post_create_transaction_endpoint(b, client):
from planetmint.models import Transaction
user_priv, user_pub = crypto.generate_key_pair() 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]) tx = tx.sign([user_priv])
res = client.post(TX_ENDPOINT, data=json.dumps(tx.to_dict())) 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 @pytest.mark.language
def test_post_create_transaction_with_language(b, client, nested, language, def test_post_create_transaction_with_language(b, client, nested, language,
expected_status_code): expected_status_code):
from planetmint.models import Transaction
from planetmint.backend.localmongodb.connection import LocalMongoDBConnection from planetmint.backend.localmongodb.connection import LocalMongoDBConnection
if isinstance(b.connection, LocalMongoDBConnection): if isinstance(b.connection, LocalMongoDBConnection):
@ -79,7 +79,7 @@ def test_post_create_transaction_with_language(b, client, nested, language,
else: else:
asset = lang_obj asset = lang_obj
tx = Transaction.create([user_pub], [([user_pub], 1)], tx = Create.generate([user_pub], [([user_pub], 1)],
asset=asset) asset=asset)
tx = tx.sign([user_priv]) tx = tx.sign([user_priv])
res = client.post(TX_ENDPOINT, data=json.dumps(tx.to_dict())) 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, def test_post_create_transaction_with_invalid_key(b, client, field, value,
err_key, expected_status_code): err_key, expected_status_code):
from planetmint.models import Transaction
from planetmint.backend.localmongodb.connection import LocalMongoDBConnection from planetmint.backend.localmongodb.connection import LocalMongoDBConnection
user_priv, user_pub = crypto.generate_key_pair() user_priv, user_pub = crypto.generate_key_pair()
if isinstance(b.connection, LocalMongoDBConnection): if isinstance(b.connection, LocalMongoDBConnection):
if field == 'asset': if field == 'asset':
tx = Transaction.create([user_pub], [([user_pub], 1)], tx = Create.generate([user_pub], [([user_pub], 1)],
asset=value) asset=value)
elif field == 'metadata': elif field == 'metadata':
tx = Transaction.create([user_pub], [([user_pub], 1)], tx = Create.generate([user_pub], [([user_pub], 1)],
metadata=value) metadata=value)
tx = tx.sign([user_priv]) tx = tx.sign([user_priv])
res = client.post(TX_ENDPOINT, data=json.dumps(tx.to_dict())) 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') @patch('planetmint.web.views.base.logger')
def test_post_create_transaction_with_invalid_id(mock_logger, b, client): def test_post_create_transaction_with_invalid_id(mock_logger, b, client):
from planetmint.transactions.common.exceptions import InvalidHash from planetmint.transactions.common.exceptions import InvalidHash
from planetmint.models import Transaction
user_priv, user_pub = crypto.generate_key_pair() 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 = tx.sign([user_priv]).to_dict()
tx['id'] = 'abcd' * 16 tx['id'] = 'abcd' * 16
@ -170,10 +168,9 @@ def test_post_create_transaction_with_invalid_signature(mock_logger,
b, b,
client): client):
from planetmint.transactions.common.exceptions import InvalidSignature from planetmint.transactions.common.exceptions import InvalidSignature
from planetmint.models import Transaction
user_priv, user_pub = crypto.generate_key_pair() 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['inputs'][0]['fulfillment'] = 64 * '0'
tx['id'] = sha3_256( tx['id'] = sha3_256(
json.dumps( json.dumps(
@ -217,9 +214,8 @@ def test_post_create_transaction_with_invalid_structure(client):
@pytest.mark.abci @pytest.mark.abci
@patch('planetmint.web.views.base.logger') @patch('planetmint.web.views.base.logger')
def test_post_create_transaction_with_invalid_schema(mock_logger, client): def test_post_create_transaction_with_invalid_schema(mock_logger, client):
from planetmint.models import Transaction
user_priv, user_pub = crypto.generate_key_pair() 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'] del tx['version']
ed25519 = Ed25519Sha256(public_key=base58.b58decode(user_pub)) ed25519 = Ed25519Sha256(public_key=base58.b58decode(user_pub))
message = json.dumps( message = json.dumps(
@ -307,9 +303,8 @@ def test_post_invalid_transaction(mock_logger, client, exc, msg, monkeypatch,):
@pytest.mark.abci @pytest.mark.abci
def test_post_transfer_transaction_endpoint(client, user_pk, user_sk, posted_create_tx): 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)], [([user_pk], 1)],
asset_id=posted_create_tx.id) asset_id=posted_create_tx.id)
transfer_tx = transfer_tx.sign([user_sk]) 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 @pytest.mark.abci
def test_post_invalid_transfer_transaction_returns_400(client, user_pk, posted_create_tx): 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 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)], [([user_pk], 1)],
asset_id=posted_create_tx.id) asset_id=posted_create_tx.id)
transfer_tx._hash() transfer_tx._hash()
@ -342,18 +336,17 @@ def test_post_invalid_transfer_transaction_returns_400(client, user_pk, posted_c
@pytest.mark.abci @pytest.mark.abci
def test_post_wrong_asset_division_transfer_returns_400(b, client, user_pk): 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 from planetmint.transactions.common.exceptions import AmountError
priv_key, pub_key = crypto.generate_key_pair() priv_key, pub_key = crypto.generate_key_pair()
create_tx = Transaction.create([pub_key], create_tx = Create.generate([pub_key],
[([pub_key], 10)], [([pub_key], 10)],
asset={'test': 'asset'}).sign([priv_key]) asset={'test': 'asset'}).sign([priv_key])
res = client.post(TX_ENDPOINT + '?mode=commit', data=json.dumps(create_tx.to_dict())) res = client.post(TX_ENDPOINT + '?mode=commit', data=json.dumps(create_tx.to_dict()))
assert res.status_code == 202 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 [([pub_key], 20)], # 20 > 10
asset_id=create_tx.id).sign([priv_key]) asset_id=create_tx.id).sign([priv_key])
res = client.post(TX_ENDPOINT + '?mode=commit', data=json.dumps(transfer_tx.to_dict())) 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), ('?mode=commit', BROADCAST_TX_COMMIT),
]) ])
def test_post_transaction_valid_modes(mock_post, client, mode): def test_post_transaction_valid_modes(mock_post, client, mode):
from planetmint.models import Transaction
from planetmint.transactions.common.crypto import generate_key_pair from planetmint.transactions.common.crypto import generate_key_pair
def _mock_post(*args, **kwargs): 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 mock_post.side_effect = _mock_post
alice = generate_key_pair() alice = generate_key_pair()
tx = Transaction.create([alice.public_key], tx = Create.generate([alice.public_key],
[([alice.public_key], 1)], [([alice.public_key], 1)],
asset=None) \ asset=None) \
.sign([alice.private_key]) .sign([alice.private_key])
@ -444,10 +436,9 @@ def test_post_transaction_valid_modes(mock_post, client, mode):
@pytest.mark.abci @pytest.mark.abci
def test_post_transaction_invalid_mode(client): def test_post_transaction_invalid_mode(client):
from planetmint.models import Transaction
from planetmint.transactions.common.crypto import generate_key_pair from planetmint.transactions.common.crypto import generate_key_pair
alice = generate_key_pair() alice = generate_key_pair()
tx = Transaction.create([alice.public_key], tx = Create.generate([alice.public_key],
[([alice.public_key], 1)], [([alice.public_key], 1)],
asset=None) \ asset=None) \
.sign([alice.private_key]) .sign([alice.private_key])

13
tests/web/test_websocket_server.py
View File

@ -8,6 +8,8 @@ import json
import queue import queue
import threading import threading
from unittest.mock import patch from unittest.mock import patch
from planetmint.transactions.types.assets.create import Create
from planetmint.transactions.types.assets.transfer import Transfer
import pytest import pytest
@ -23,14 +25,13 @@ class MockWebSocket:
def test_eventify_block_works_with_any_transaction(): def test_eventify_block_works_with_any_transaction():
from planetmint.web.websocket_server import eventify_block from planetmint.web.websocket_server import eventify_block
from planetmint.transactions.common.crypto import generate_key_pair from planetmint.transactions.common.crypto import generate_key_pair
from planetmint.lib import Transaction
alice = generate_key_pair() alice = generate_key_pair()
tx = Transaction.create([alice.public_key], tx = Create.generate([alice.public_key],
[([alice.public_key], 1)])\ [([alice.public_key], 1)])\
.sign([alice.private_key]) .sign([alice.private_key])
tx_transfer = Transaction.transfer(tx.to_inputs(), tx_transfer = Transfer.generate(tx.to_inputs(),
[([alice.public_key], 1)], [([alice.public_key], 1)],
asset_id=tx.id)\ asset_id=tx.id)\
.sign([alice.private_key]) .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): async def test_websocket_block_event(b, test_client, loop):
from planetmint import events from planetmint import events
from planetmint.web.websocket_server import init_app, POISON_PILL, EVENTS_ENDPOINT from planetmint.web.websocket_server import init_app, POISON_PILL, EVENTS_ENDPOINT
from planetmint.models import Transaction
from planetmint.transactions.common import crypto from planetmint.transactions.common import crypto
user_priv, user_pub = crypto.generate_key_pair() 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]) tx = tx.sign([user_priv])
event_source = asyncio.Queue(loop=loop) 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 # TODO processes does not exist anymore, when reactivating this test it
# will fail because of this # will fail because of this
from planetmint import processes from planetmint import processes
from planetmint.models import Transaction
# Start Planetmint # Start Planetmint
processes.start() processes.start()
@ -203,7 +202,7 @@ def test_integration_from_webapi_to_websocket(monkeypatch, client, loop):
# Create a keypair and generate a new asset # Create a keypair and generate a new asset
user_priv, user_pub = crypto.generate_key_pair() user_priv, user_pub = crypto.generate_key_pair()
asset = {'random': random.random()} 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]) tx = tx.sign([user_priv])
# Post the transaction to the Planetmint Web API # Post the transaction to the Planetmint Web API
client.post('/api/v1/transactions/', data=json.dumps(tx.to_dict())) client.post('/api/v1/transactions/', data=json.dumps(tx.to_dict()))