Mirroristas/planetmint
2
0
Fork 0
mirror of https://github.com/planetmint/planetmint.git synced 2025-03-30 15:08:31 +00:00
Code Issues Packages Projects Releases Wiki Activity

Remove create and transfer code snippets from transaction.py

Browse Source 
Signed-off-by: Sangat Das <sangatdas5@gmail.com>
This commit is contained in:
Sangat Das 2022-03-21 19:52:10 +00:00
parent c3284fe060
commit 0fee3607ee
26 changed files with 251 additions and 390 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.path
from planetmint.transactions.common.transaction import Transaction, Input, TransactionLink
from planetmint.transactions.common.input import Input
from planetmint.transactions.common.transaction_link import TransactionLink
from planetmint import lib
from planetmint.transactions.types.assets.create import Create
from planetmint.transactions.types.assets.transfer import Transfer
from planetmint.web import server
@ -133,7 +136,7 @@ def main():
privkey = 'CfdqtD7sS7FgkMoGPXw55MVGGFwQLAoHYTcBhZDtF99Z'
pubkey = '4K9sWUMFwTgaDGPfdynrbxWqWS6sWmKbZoTjxLtVUibD'
asset = {'msg': 'Hello Planetmint!'}
tx = Transaction.create([pubkey], [([pubkey], 1)], asset=asset, metadata={'sequence': 0})
tx = Create.generate([pubkey], [([pubkey], 1)], asset=asset, metadata={'sequence': 0})
tx = tx.sign([privkey])
ctx['tx'] = pretty_json(tx.to_dict())
ctx['public_keys'] = tx.outputs[0].public_keys[0]
@ -147,7 +150,7 @@ def main():
input_ = Input(fulfillment=tx.outputs[cid].fulfillment,
fulfills=TransactionLink(txid=tx.id, output=cid),
owners_before=tx.outputs[cid].public_keys)
tx_transfer = Transaction.transfer([input_], [([pubkey_transfer], 1)], asset_id=tx.id, metadata={'sequence': 1})
tx_transfer = Transfer.generate([input_], [([pubkey_transfer], 1)], asset_id=tx.id, metadata={'sequence': 1})
tx_transfer = tx_transfer.sign([privkey])
ctx['tx_transfer'] = pretty_json(tx_transfer.to_dict())
ctx['public_keys_transfer'] = tx_transfer.outputs[0].public_keys[0]
@ -160,7 +163,7 @@ def main():
input_ = Input(fulfillment=tx_transfer.outputs[cid].fulfillment,
fulfills=TransactionLink(txid=tx_transfer.id, output=cid),
owners_before=tx_transfer.outputs[cid].public_keys)
tx_transfer_last = Transaction.transfer([input_], [([pubkey_transfer_last], 1)],
tx_transfer_last = Transfer.generate([input_], [([pubkey_transfer_last], 1)],
asset_id=tx.id, metadata={'sequence': 2})
tx_transfer_last = tx_transfer_last.sign([privkey_transfer])
ctx['tx_transfer_last'] = pretty_json(tx_transfer_last.to_dict())

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

@ -167,137 +167,6 @@ class Transaction(object):
def _hash(self):
self._id = hash_data(self.serialized)
@classmethod
def validate_create(cls, tx_signers, recipients, asset, metadata):
if not isinstance(tx_signers, list):
raise TypeError('`tx_signers` must be a list instance')
if not isinstance(recipients, list):
raise TypeError('`recipients` must be a list instance')
if len(tx_signers) == 0:
raise ValueError('`tx_signers` list cannot be empty')
if len(recipients) == 0:
raise ValueError('`recipients` list cannot be empty')
if not (asset is None or isinstance(asset, dict)):
raise TypeError('`asset` must be a dict or None')
if not (metadata is None or isinstance(metadata, dict)):
raise TypeError('`metadata` must be a dict or None')
inputs = []
outputs = []
# generate_outputs
for recipient in recipients:
if not isinstance(recipient, tuple) or len(recipient) != 2:
raise ValueError(('Each `recipient` in the list must be a'
' tuple of `([<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):
try:
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)
# Code is Apache-2.0 and docs are CC-BY-4.0
from planetmint.transactions.common.transaction import Transaction
from planetmint.models import Transaction
from planetmint.transactions.common.input import Input
from planetmint.transactions.common.output import Output
@ -13,7 +13,7 @@ class Create(Transaction):
ALLOWED_OPERATIONS = (OPERATION,)
@classmethod
def validate(self, tx_signers, recipients, asset, metadata):
def validate_create(self, tx_signers, recipients, asset, metadata):
if not isinstance(tx_signers, list):
raise TypeError('`tx_signers` must be a list instance')
if not isinstance(recipients, list):
@ -73,5 +73,5 @@ class Create(Transaction):
:class:`~planetmint.common.transaction.Transaction`
"""
(inputs, outputs) = cls.validate(tx_signers, recipients, asset, metadata)
(inputs, outputs) = cls.validate_create(tx_signers, recipients, asset, metadata)
return cls(cls.OPERATION, {'data': asset}, inputs, outputs, metadata)

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

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

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

@ -143,7 +143,7 @@ class Election(Transaction):
uuid = uuid4()
election_data['seed'] = str(uuid)
(inputs, outputs) = cls.validate_create(initiator, voters, election_data, metadata)
(inputs, outputs) = Create.validate_create(initiator, voters, election_data, metadata)
election = cls(cls.OPERATION, {'data': election_data}, inputs, outputs, metadata)
cls.validate_schema(election.to_dict())
return election

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

@ -10,7 +10,7 @@ from planetmint.transactions.common.schema import (
_validate_schema, TX_SCHEMA_COMMON, TX_SCHEMA_TRANSFER, TX_SCHEMA_VOTE)
class Vote(Transaction):
class Vote(Transfer):
OPERATION = 'VOTE'
# NOTE: This class inherits TRANSFER txn type. The `TRANSFER` property is

21
tests/assets/test_digital_assets.py
View File

@ -5,12 +5,11 @@
import pytest
import random
from planetmint.transactions.types.assets.create import Create
from planetmint.transactions.types.assets.transfer import Transfer
def test_asset_transfer(b, signed_create_tx, user_pk, user_sk):
from planetmint.models import Transaction
tx_transfer = Transaction.transfer(signed_create_tx.to_inputs(), [([user_pk], 1)],
tx_transfer = Transfer.generate(signed_create_tx.to_inputs(), [([user_pk], 1)],
signed_create_tx.id)
tx_transfer_signed = tx_transfer.sign([user_sk])
@ -22,9 +21,8 @@ def test_asset_transfer(b, signed_create_tx, user_pk, user_sk):
def test_validate_transfer_asset_id_mismatch(b, signed_create_tx, user_pk, user_sk):
from planetmint.transactions.common.exceptions import AssetIdMismatch
from planetmint.models import Transaction
tx_transfer = Transaction.transfer(signed_create_tx.to_inputs(), [([user_pk], 1)],
tx_transfer = Transfer.generate(signed_create_tx.to_inputs(), [([user_pk], 1)],
signed_create_tx.id)
tx_transfer.asset['id'] = 'a' * 64
tx_transfer_signed = tx_transfer.sign([user_sk])
@ -37,14 +35,14 @@ def test_validate_transfer_asset_id_mismatch(b, signed_create_tx, user_pk, user_
def test_get_asset_id_create_transaction(alice, user_pk):
from planetmint.models import Transaction
tx_create = Transaction.create([alice.public_key], [([user_pk], 1)])
tx_create = Create.generate([alice.public_key], [([user_pk], 1)])
assert Transaction.get_asset_id(tx_create) == tx_create.id
def test_get_asset_id_transfer_transaction(b, signed_create_tx, user_pk):
from planetmint.models import Transaction
tx_transfer = Transaction.transfer(signed_create_tx.to_inputs(), [([user_pk], 1)],
tx_transfer = Transfer.generate(signed_create_tx.to_inputs(), [([user_pk], 1)],
signed_create_tx.id)
asset_id = Transaction.get_asset_id(tx_transfer)
assert asset_id == tx_transfer.asset['id']
@ -54,10 +52,10 @@ def test_asset_id_mismatch(alice, user_pk):
from planetmint.models import Transaction
from planetmint.transactions.common.exceptions import AssetIdMismatch
tx1 = Transaction.create([alice.public_key], [([user_pk], 1)],
tx1 = Create.generate([alice.public_key], [([user_pk], 1)],
metadata={'msg': random.random()})
tx1.sign([alice.private_key])
tx2 = Transaction.create([alice.public_key], [([user_pk], 1)],
tx2 = Create.generate([alice.public_key], [([user_pk], 1)],
metadata={'msg': random.random()})
tx2.sign([alice.private_key])
@ -66,8 +64,7 @@ def test_asset_id_mismatch(alice, user_pk):
def test_create_valid_divisible_asset(b, user_pk, user_sk):
from planetmint.models import Transaction
tx = Transaction.create([user_pk], [([user_pk], 2)])
tx = Create.generate([user_pk], [([user_pk], 2)])
tx_signed = tx.sign([user_sk])
assert tx_signed.validate(b) == tx_signed

105
tests/assets/test_divisible_assets.py
View File

@ -3,9 +3,12 @@
# SPDX-License-Identifier: (Apache-2.0 AND CC-BY-4.0)
# Code is Apache-2.0 and docs are CC-BY-4.0
import pytest
import random
from planetmint.transactions.types.assets.create import Create
from planetmint.transactions.types.assets.transfer import Transfer
from planetmint.transactions.common.exceptions import DoubleSpend
@ -15,9 +18,9 @@ from planetmint.transactions.common.exceptions import DoubleSpend
# Single output
# Single owners_after
def test_single_in_single_own_single_out_single_own_create(alice, user_pk, b):
from planetmint.models import Transaction
tx = Transaction.create([alice.public_key], [([user_pk], 100)], asset={'name': random.random()})
tx = Create.generate([alice.public_key], [([user_pk], 100)], asset={'name': random.random()})
tx_signed = tx.sign([alice.private_key])
assert tx_signed.validate(b) == tx_signed
@ -32,9 +35,9 @@ def test_single_in_single_own_single_out_single_own_create(alice, user_pk, b):
# Multiple outputs
# Single owners_after per output
def test_single_in_single_own_multiple_out_single_own_create(alice, user_pk, b):
from planetmint.models import Transaction
tx = Transaction.create([alice.public_key], [([user_pk], 50), ([user_pk], 50)],
tx = Create.generate([alice.public_key], [([user_pk], 50), ([user_pk], 50)],
asset={'name': random.random()})
tx_signed = tx.sign([alice.private_key])
@ -51,9 +54,8 @@ def test_single_in_single_own_multiple_out_single_own_create(alice, user_pk, b):
# Single output
# Multiple owners_after
def test_single_in_single_own_single_out_multiple_own_create(alice, user_pk, b):
from planetmint.models import Transaction
tx = Transaction.create([alice.public_key], [([user_pk, user_pk], 100)], asset={'name': random.random()})
tx = Create.generate([alice.public_key], [([user_pk, user_pk], 100)], asset={'name': random.random()})
tx_signed = tx.sign([alice.private_key])
assert tx_signed.validate(b) == tx_signed
@ -74,9 +76,8 @@ def test_single_in_single_own_single_out_multiple_own_create(alice, user_pk, b):
# Mix: one output with a single owners_after, one output with multiple
# owners_after
def test_single_in_single_own_multiple_out_mix_own_create(alice, user_pk, b):
from planetmint.models import Transaction
tx = Transaction.create([alice.public_key], [([user_pk], 50), ([user_pk, user_pk], 50)],
tx = Create.generate([alice.public_key], [([user_pk], 50), ([user_pk, user_pk], 50)],
asset={'name': random.random()})
tx_signed = tx.sign([alice.private_key])
@ -98,10 +99,10 @@ def test_single_in_single_own_multiple_out_mix_own_create(alice, user_pk, b):
# Output combinations already tested above
def test_single_in_multiple_own_single_out_single_own_create(alice, b, user_pk,
user_sk):
from planetmint.models import Transaction
from planetmint.transactions.common.utils import _fulfillment_to_details
tx = Transaction.create([alice.public_key, user_pk], [([user_pk], 100)], asset={'name': random.random()})
tx = Create.generate([alice.public_key, user_pk], [([user_pk], 100)], asset={'name': random.random()})
tx_signed = tx.sign([alice.private_key, user_sk])
assert tx_signed.validate(b) == tx_signed
assert len(tx_signed.outputs) == 1
@ -120,14 +121,13 @@ def test_single_in_multiple_own_single_out_single_own_create(alice, b, user_pk,
# Single owners_after
def test_single_in_single_own_single_out_single_own_transfer(alice, b, user_pk,
user_sk):
from planetmint.models import Transaction
# CREATE divisible asset
tx_create = Transaction.create([alice.public_key], [([user_pk], 100)], asset={'name': random.random()})
tx_create = Create.generate([alice.public_key], [([user_pk], 100)], asset={'name': random.random()})
tx_create_signed = tx_create.sign([alice.private_key])
# TRANSFER
tx_transfer = Transaction.transfer(tx_create.to_inputs(), [([alice.public_key], 100)],
tx_transfer = Transfer.generate(tx_create.to_inputs(), [([alice.public_key], 100)],
asset_id=tx_create.id)
tx_transfer_signed = tx_transfer.sign([user_sk])
@ -146,14 +146,13 @@ def test_single_in_single_own_single_out_single_own_transfer(alice, b, user_pk,
# Single owners_after
def test_single_in_single_own_multiple_out_single_own_transfer(alice, b, user_pk,
user_sk):
from planetmint.models import Transaction
# CREATE divisible asset
tx_create = Transaction.create([alice.public_key], [([user_pk], 100)], asset={'name': random.random()})
tx_create = Create.generate([alice.public_key], [([user_pk], 100)], asset={'name': random.random()})
tx_create_signed = tx_create.sign([alice.private_key])
# TRANSFER
tx_transfer = Transaction.transfer(tx_create.to_inputs(),
tx_transfer = Transfer.generate(tx_create.to_inputs(),
[([alice.public_key], 50), ([alice.public_key], 50)],
asset_id=tx_create.id)
tx_transfer_signed = tx_transfer.sign([user_sk])
@ -174,14 +173,13 @@ def test_single_in_single_own_multiple_out_single_own_transfer(alice, b, user_pk
# Multiple owners_after
def test_single_in_single_own_single_out_multiple_own_transfer(alice, b, user_pk,
user_sk):
from planetmint.models import Transaction
# CREATE divisible asset
tx_create = Transaction.create([alice.public_key], [([user_pk], 100)], asset={'name': random.random()})
tx_create = Create.generate([alice.public_key], [([user_pk], 100)], asset={'name': random.random()})
tx_create_signed = tx_create.sign([alice.private_key])
# TRANSFER
tx_transfer = Transaction.transfer(tx_create.to_inputs(),
tx_transfer = Transfer.generate(tx_create.to_inputs(),
[([alice.public_key, alice.public_key], 100)],
asset_id=tx_create.id)
tx_transfer_signed = tx_transfer.sign([user_sk])
@ -211,14 +209,13 @@ def test_single_in_single_own_single_out_multiple_own_transfer(alice, b, user_pk
# owners_after
def test_single_in_single_own_multiple_out_mix_own_transfer(alice, b, user_pk,
user_sk):
from planetmint.models import Transaction
# CREATE divisible asset
tx_create = Transaction.create([alice.public_key], [([user_pk], 100)], asset={'name': random.random()})
tx_create = Create.generate([alice.public_key], [([user_pk], 100)], asset={'name': random.random()})
tx_create_signed = tx_create.sign([alice.private_key])
# TRANSFER
tx_transfer = Transaction.transfer(tx_create.to_inputs(),
tx_transfer = Transfer.generate(tx_create.to_inputs(),
[([alice.public_key], 50), ([alice.public_key, alice.public_key], 50)],
asset_id=tx_create.id)
tx_transfer_signed = tx_transfer.sign([user_sk])
@ -248,16 +245,16 @@ def test_single_in_single_own_multiple_out_mix_own_transfer(alice, b, user_pk,
# Single owners_after
def test_single_in_multiple_own_single_out_single_own_transfer(alice, b, user_pk,
user_sk):
from planetmint.models import Transaction
from planetmint.transactions.common.utils import _fulfillment_to_details
# CREATE divisible asset
tx_create = Transaction.create([alice.public_key], [([alice.public_key, user_pk], 100)],
tx_create = Create.generate([alice.public_key], [([alice.public_key, user_pk], 100)],
asset={'name': random.random()})
tx_create_signed = tx_create.sign([alice.private_key])
# TRANSFER
tx_transfer = Transaction.transfer(tx_create.to_inputs(), [([alice.public_key], 100)],
tx_transfer = Transfer.generate(tx_create.to_inputs(), [([alice.public_key], 100)],
asset_id=tx_create.id)
tx_transfer_signed = tx_transfer.sign([alice.private_key, user_sk])
@ -284,15 +281,14 @@ def test_single_in_multiple_own_single_out_single_own_transfer(alice, b, user_pk
# Single owners_after
def test_multiple_in_single_own_single_out_single_own_transfer(alice, b, user_pk,
user_sk):
from planetmint.models import Transaction
# CREATE divisible asset
tx_create = Transaction.create([alice.public_key], [([user_pk], 50), ([user_pk], 50)],
tx_create = Create.generate([alice.public_key], [([user_pk], 50), ([user_pk], 50)],
asset={'name': random.random()})
tx_create_signed = tx_create.sign([alice.private_key])
# TRANSFER
tx_transfer = Transaction.transfer(tx_create.to_inputs(), [([alice.public_key], 100)],
tx_transfer = Transfer.generate(tx_create.to_inputs(), [([alice.public_key], 100)],
asset_id=tx_create.id)
tx_transfer_signed = tx_transfer.sign([user_sk])
@ -315,17 +311,17 @@ def test_multiple_in_single_own_single_out_single_own_transfer(alice, b, user_pk
# Single owners_after
def test_multiple_in_multiple_own_single_out_single_own_transfer(alice, b, user_pk,
user_sk):
from planetmint.models import Transaction
from planetmint.transactions.common.utils import _fulfillment_to_details
# CREATE divisible asset
tx_create = Transaction.create([alice.public_key], [([user_pk, alice.public_key], 50),
tx_create = Create.generate([alice.public_key], [([user_pk, alice.public_key], 50),
([user_pk, alice.public_key], 50)],
asset={'name': random.random()})
tx_create_signed = tx_create.sign([alice.private_key])
# TRANSFER
tx_transfer = Transaction.transfer(tx_create.to_inputs(), [([alice.public_key], 100)],
tx_transfer = Transfer.generate(tx_create.to_inputs(), [([alice.public_key], 100)],
asset_id=tx_create.id)
tx_transfer_signed = tx_transfer.sign([alice.private_key, user_sk])
@ -356,16 +352,16 @@ def test_multiple_in_multiple_own_single_out_single_own_transfer(alice, b, user_
# Single owners_after
def test_muiltiple_in_mix_own_multiple_out_single_own_transfer(alice, b, user_pk,
user_sk):
from planetmint.models import Transaction
from planetmint.transactions.common.utils import _fulfillment_to_details
# CREATE divisible asset
tx_create = Transaction.create([alice.public_key], [([user_pk], 50), ([user_pk, alice.public_key], 50)],
tx_create = Create.generate([alice.public_key], [([user_pk], 50), ([user_pk, alice.public_key], 50)],
asset={'name': random.random()})
tx_create_signed = tx_create.sign([alice.private_key])
# TRANSFER
tx_transfer = Transaction.transfer(tx_create.to_inputs(), [([alice.public_key], 100)],
tx_transfer = Transfer.generate(tx_create.to_inputs(), [([alice.public_key], 100)],
asset_id=tx_create.id)
tx_transfer_signed = tx_transfer.sign([alice.private_key, user_sk])
@ -396,16 +392,16 @@ def test_muiltiple_in_mix_own_multiple_out_single_own_transfer(alice, b, user_pk
# owners_after
def test_muiltiple_in_mix_own_multiple_out_mix_own_transfer(alice, b, user_pk,
user_sk):
from planetmint.models import Transaction
from planetmint.transactions.common.utils import _fulfillment_to_details
# CREATE divisible asset
tx_create = Transaction.create([alice.public_key], [([user_pk], 50), ([user_pk, alice.public_key], 50)],
tx_create = Create.generate([alice.public_key], [([user_pk], 50), ([user_pk, alice.public_key], 50)],
asset={'name': random.random()})
tx_create_signed = tx_create.sign([alice.private_key])
# TRANSFER
tx_transfer = Transaction.transfer(tx_create.to_inputs(),
tx_transfer = Transfer.generate(tx_create.to_inputs(),
[([alice.public_key], 50), ([alice.public_key, user_pk], 50)],
asset_id=tx_create.id)
tx_transfer_signed = tx_transfer.sign([alice.private_key, user_sk])
@ -441,12 +437,11 @@ def test_muiltiple_in_mix_own_multiple_out_mix_own_transfer(alice, b, user_pk,
# Single output
# Single owners_after
def test_multiple_in_different_transactions(alice, b, user_pk, user_sk):
from planetmint.models import Transaction
# CREATE divisible asset
# `b` creates a divisible asset and assigns 50 shares to `b` and
# 50 shares to `user_pk`
tx_create = Transaction.create([alice.public_key], [([user_pk], 50), ([alice.public_key], 50)],
tx_create = Create.generate([alice.public_key], [([user_pk], 50), ([alice.public_key], 50)],
asset={'name': random.random()})
tx_create_signed = tx_create.sign([alice.private_key])
@ -454,7 +449,7 @@ def test_multiple_in_different_transactions(alice, b, user_pk, user_sk):
# `b` transfers its 50 shares to `user_pk`
# after this transaction `user_pk` will have a total of 100 shares
# split across two different transactions
tx_transfer1 = Transaction.transfer(tx_create.to_inputs([1]),
tx_transfer1 = Transfer.generate(tx_create.to_inputs([1]),
[([user_pk], 50)],
asset_id=tx_create.id)
tx_transfer1_signed = tx_transfer1.sign([alice.private_key])
@ -462,7 +457,7 @@ def test_multiple_in_different_transactions(alice, b, user_pk, user_sk):
# TRANSFER
# `user_pk` combines two different transaction with 50 shares each and
# transfers a total of 100 shares back to `b`
tx_transfer2 = Transaction.transfer(tx_create.to_inputs([0]) +
tx_transfer2 = Transfer.generate(tx_create.to_inputs([0]) +
tx_transfer1.to_inputs([0]),
[([alice.private_key], 100)],
asset_id=tx_create.id)
@ -485,18 +480,18 @@ def test_multiple_in_different_transactions(alice, b, user_pk, user_sk):
# inputs needs to match the amount being sent in the outputs.
# In other words `amount_in_inputs - amount_in_outputs == 0`
def test_amount_error_transfer(alice, b, user_pk, user_sk):
from planetmint.models import Transaction
from planetmint.transactions.common.exceptions import AmountError
# CREATE divisible asset
tx_create = Transaction.create([alice.public_key], [([user_pk], 100)], asset={'name': random.random()})
tx_create = Create.generate([alice.public_key], [([user_pk], 100)], asset={'name': random.random()})
tx_create_signed = tx_create.sign([alice.private_key])
b.store_bulk_transactions([tx_create_signed])
# TRANSFER
# output amount less than input amount
tx_transfer = Transaction.transfer(tx_create.to_inputs(), [([alice.public_key], 50)],
tx_transfer = Transfer.generate(tx_create.to_inputs(), [([alice.public_key], 50)],
asset_id=tx_create.id)
tx_transfer_signed = tx_transfer.sign([user_sk])
@ -505,7 +500,7 @@ def test_amount_error_transfer(alice, b, user_pk, user_sk):
# TRANSFER
# output amount greater than input amount
tx_transfer = Transaction.transfer(tx_create.to_inputs(), [([alice.public_key], 101)],
tx_transfer = Transfer.generate(tx_create.to_inputs(), [([alice.public_key], 101)],
asset_id=tx_create.id)
tx_transfer_signed = tx_transfer.sign([user_sk])
@ -521,15 +516,13 @@ def test_threshold_same_public_key(alice, b, user_pk, user_sk):
# Creating threshold conditions with the same key does not make sense but
# that does not mean that the code shouldn't work.
from planetmint.models import Transaction
# CREATE divisible asset
tx_create = Transaction.create([alice.public_key], [([user_pk, user_pk], 100)],
tx_create = Create.generate([alice.public_key], [([user_pk, user_pk], 100)],
asset={'name': random.random()})
tx_create_signed = tx_create.sign([alice.private_key])
# TRANSFER
tx_transfer = Transaction.transfer(tx_create.to_inputs(), [([alice.public_key], 100)],
tx_transfer = Transfer.generate(tx_create.to_inputs(), [([alice.public_key], 100)],
asset_id=tx_create.id)
tx_transfer_signed = tx_transfer.sign([user_sk, user_sk])
@ -543,16 +536,16 @@ def test_threshold_same_public_key(alice, b, user_pk, user_sk):
def test_sum_amount(alice, b, user_pk, user_sk):
from planetmint.models import Transaction
# CREATE divisible asset with 3 outputs with amount 1
tx_create = Transaction.create([alice.public_key], [([user_pk], 1), ([user_pk], 1), ([user_pk], 1)],
tx_create = Create.generate([alice.public_key], [([user_pk], 1), ([user_pk], 1), ([user_pk], 1)],
asset={'name': random.random()})
tx_create_signed = tx_create.sign([alice.private_key])
# create a transfer transaction with one output and check if the amount
# is 3
tx_transfer = Transaction.transfer(tx_create.to_inputs(), [([alice.public_key], 3)],
tx_transfer = Transfer.generate(tx_create.to_inputs(), [([alice.public_key], 3)],
asset_id=tx_create.id)
tx_transfer_signed = tx_transfer.sign([user_sk])
@ -568,15 +561,15 @@ def test_sum_amount(alice, b, user_pk, user_sk):
def test_divide(alice, b, user_pk, user_sk):
from planetmint.models import Transaction
# CREATE divisible asset with 1 output with amount 3
tx_create = Transaction.create([alice.public_key], [([user_pk], 3)], asset={'name': random.random()})
tx_create = Create.generate([alice.public_key], [([user_pk], 3)], asset={'name': random.random()})
tx_create_signed = tx_create.sign([alice.private_key])
# create a transfer transaction with 3 outputs and check if the amount
# of each output is 1
tx_transfer = Transaction.transfer(tx_create.to_inputs(),
tx_transfer = Transfer.generate(tx_create.to_inputs(),
[([alice.public_key], 1), ([alice.public_key], 1), ([alice.public_key], 1)],
asset_id=tx_create.id)
tx_transfer_signed = tx_transfer.sign([user_sk])

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
from copy import deepcopy
from planetmint.transactions.types.assets.create import Create
from planetmint.transactions.types.assets.transfer import Transfer
import pytest
import pymongo
@ -215,16 +217,15 @@ def test_get_owned_ids(signed_create_tx, user_pk):
def test_get_spending_transactions(user_pk, user_sk):
from planetmint.backend import connect, query
from planetmint.models import Transaction
conn = connect()
out = [([user_pk], 1)]
tx1 = Transaction.create([user_pk], out * 3)
tx1 = Create.generate([user_pk], out * 3)
tx1.sign([user_sk])
inputs = tx1.to_inputs()
tx2 = Transaction.transfer([inputs[0]], out, tx1.id).sign([user_sk])
tx3 = Transaction.transfer([inputs[1]], out, tx1.id).sign([user_sk])
tx4 = Transaction.transfer([inputs[2]], out, tx1.id).sign([user_sk])
tx2 = Transfer.generate([inputs[0]], out, tx1.id).sign([user_sk])
tx3 = Transfer.generate([inputs[1]], out, tx1.id).sign([user_sk])
tx4 = Transfer.generate([inputs[2]], out, tx1.id).sign([user_sk])
txns = [deepcopy(tx.to_dict()) for tx in [tx1, tx2, tx3, tx4]]
conn.db.transactions.insert_many(txns)
@ -237,7 +238,6 @@ def test_get_spending_transactions(user_pk, user_sk):
def test_get_spending_transactions_multiple_inputs():
from planetmint.backend import connect, query
from planetmint.models import Transaction
from planetmint.transactions.common.crypto import generate_key_pair
conn = connect()
(alice_sk, alice_pk) = generate_key_pair()
@ -245,20 +245,20 @@ def test_get_spending_transactions_multiple_inputs():
(carol_sk, carol_pk) = generate_key_pair()
out = [([alice_pk], 9)]
tx1 = Transaction.create([alice_pk], out).sign([alice_sk])
tx1 = Create.generate([alice_pk], out).sign([alice_sk])
inputs1 = tx1.to_inputs()
tx2 = Transaction.transfer([inputs1[0]],
tx2 = Transfer.generate([inputs1[0]],
[([alice_pk], 6), ([bob_pk], 3)],
tx1.id).sign([alice_sk])
inputs2 = tx2.to_inputs()
tx3 = Transaction.transfer([inputs2[0]],
tx3 = Transfer.generate([inputs2[0]],
[([bob_pk], 3), ([carol_pk], 3)],
tx1.id).sign([alice_sk])
inputs3 = tx3.to_inputs()
tx4 = Transaction.transfer([inputs2[1], inputs3[0]],
tx4 = Transfer.generate([inputs2[1], inputs3[0]],
[([carol_pk], 6)],
tx1.id).sign([bob_sk])

6
tests/commands/test_commands.py
View File

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

7
tests/common/test_memoize.py
View File

@ -7,6 +7,7 @@ import pytest
from copy import deepcopy
from planetmint.models import Transaction
from planetmint.transactions.types.assets.create import Create
from planetmint.transactions.common.crypto import generate_key_pair
from planetmint.transactions.common.memoize import to_dict, from_dict
@ -23,7 +24,7 @@ def test_memoize_to_dict(b):
assert to_dict.cache_info().hits == 0
assert to_dict.cache_info().misses == 0
tx = Transaction.create([alice.public_key],
tx = Create.generate([alice.public_key],
[([alice.public_key], 1)],
asset=asset,)\
.sign([alice.private_key])
@ -49,7 +50,7 @@ def test_memoize_from_dict(b):
assert from_dict.cache_info().hits == 0
assert from_dict.cache_info().misses == 0
tx = Transaction.create([alice.public_key],
tx = Create.generate([alice.public_key],
[([alice.public_key], 1)],
asset=asset,)\
.sign([alice.private_key])
@ -76,7 +77,7 @@ def test_memoize_input_valid(b):
assert Transaction._input_valid.cache_info().hits == 0
assert Transaction._input_valid.cache_info().misses == 0
tx = Transaction.create([alice.public_key],
tx = Create.generate([alice.public_key],
[([alice.public_key], 1)],
asset=asset,)\
.sign([alice.private_key])

54
tests/common/test_transaction.py
View File

@ -11,6 +11,8 @@ from copy import deepcopy
from base58 import b58encode, b58decode
from cryptoconditions import Ed25519Sha256
from planetmint.transactions.types.assets.create import Create
from planetmint.transactions.types.assets.transfer import Transfer
from pytest import mark, raises
try:
from hashlib import sha3_256
@ -690,7 +692,7 @@ def test_create_create_transaction_single_io(user_output, user_pub, data):
'version': Transaction.VERSION,
}
tx = Transaction.create([user_pub], [([user_pub], 1)], metadata=data,
tx = Create.generate([user_pub], [([user_pub], 1)], metadata=data,
asset=data)
tx_dict = tx.to_dict()
tx_dict['inputs'][0]['fulfillment'] = None
@ -705,7 +707,7 @@ def test_validate_single_io_create_transaction(user_pub, user_priv, data,
asset_definition):
from planetmint.transactions.common.transaction import Transaction
tx = Transaction.create([user_pub], [([user_pub], 1)], metadata=data)
tx = Create.generate([user_pub], [([user_pub], 1)], metadata=data)
tx = tx.sign([user_priv])
assert tx.inputs_valid() is True
@ -727,7 +729,7 @@ def test_create_create_transaction_multiple_io(user_output, user2_output, user_p
'operation': 'CREATE',
'version': Transaction.VERSION
}
tx = Transaction.create([user_pub, user2_pub],
tx = Create.generate([user_pub, user2_pub],
[([user_pub], 1), ([user2_pub], 1)],
metadata={'message': 'hello'}).to_dict()
tx.pop('id')
@ -742,7 +744,7 @@ def test_validate_multiple_io_create_transaction(user_pub, user_priv,
from planetmint.transactions.common.transaction import Transaction
from .utils import validate_transaction_model
tx = Transaction.create([user_pub, user2_pub],
tx = Create.generate([user_pub, user2_pub],
[([user_pub], 1), ([user2_pub], 1)],
metadata={'message': 'hello'})
tx = tx.sign([user_priv, user2_priv])
@ -774,7 +776,7 @@ def test_create_create_transaction_threshold(user_pub, user2_pub, user3_pub,
'operation': 'CREATE',
'version': Transaction.VERSION
}
tx = Transaction.create([user_pub], [([user_pub, user2_pub], 1)],
tx = Create.generate([user_pub], [([user_pub, user2_pub], 1)],
metadata=data, asset=data)
tx_dict = tx.to_dict()
tx_dict.pop('id')
@ -788,7 +790,7 @@ def test_validate_threshold_create_transaction(user_pub, user_priv, user2_pub,
from planetmint.transactions.common.transaction import Transaction
from .utils import validate_transaction_model
tx = Transaction.create([user_pub], [([user_pub, user2_pub], 1)],
tx = Create.generate([user_pub], [([user_pub, user2_pub], 1)],
metadata=data)
tx = tx.sign([user_priv])
assert tx.inputs_valid() is True
@ -800,22 +802,22 @@ def test_create_create_transaction_with_invalid_parameters(user_pub):
from planetmint.transactions.common.transaction import Transaction
with raises(TypeError):
Transaction.create('not a list')
Create.generate('not a list')
with raises(TypeError):
Transaction.create([], 'not a list')
Create.generate([], 'not a list')
with raises(ValueError):
Transaction.create([], [user_pub])
Create.generate([], [user_pub])
with raises(ValueError):
Transaction.create([user_pub], [])
Create.generate([user_pub], [])
with raises(ValueError):
Transaction.create([user_pub], [user_pub])
Create.generate([user_pub], [user_pub])
with raises(ValueError):
Transaction.create([user_pub], [([user_pub],)])
Create.generate([user_pub], [([user_pub],)])
with raises(TypeError):
Transaction.create([user_pub], [([user_pub], 1)],
Create.generate([user_pub], [([user_pub], 1)],
metadata='not a dict or none')
with raises(TypeError):
Transaction.create([user_pub],
Create.generate([user_pub],
[([user_pub], 1)],
asset='not a dict or none')
@ -858,7 +860,7 @@ def test_create_transfer_transaction_single_io(tx, user_pub, user2_pub,
'version': Transaction.VERSION
}
inputs = tx.to_inputs([0])
transfer_tx = Transaction.transfer(inputs, [([user2_pub], 1)],
transfer_tx = Transfer.generate(inputs, [([user2_pub], 1)],
asset_id=tx.id)
transfer_tx = transfer_tx.sign([user_priv])
transfer_tx = transfer_tx.to_dict()
@ -889,7 +891,7 @@ def test_create_transfer_transaction_multiple_io(user_pub, user_priv,
asset_definition):
from planetmint.transactions.common.transaction import Transaction
tx = Transaction.create([user_pub], [([user_pub], 1), ([user2_pub], 1)],
tx = Create.generate([user_pub], [([user_pub], 1), ([user2_pub], 1)],
metadata={'message': 'hello'})
tx = tx.sign([user_priv])
@ -921,7 +923,7 @@ def test_create_transfer_transaction_multiple_io(user_pub, user_priv,
'version': Transaction.VERSION
}
transfer_tx = Transaction.transfer(tx.to_inputs(),
transfer_tx = Transfer.generate(tx.to_inputs(),
[([user2_pub], 1), ([user2_pub], 1)],
asset_id=tx.id)
transfer_tx = transfer_tx.sign([user_priv, user2_priv])
@ -944,22 +946,22 @@ def test_create_transfer_with_invalid_parameters(tx, user_pub):
from planetmint.transactions.common.transaction import Transaction
with raises(TypeError):
Transaction.transfer({}, [], tx.id)
Transfer.generate({}, [], tx.id)
with raises(ValueError):
Transaction.transfer([], [], tx.id)
Transfer.generate([], [], tx.id)
with raises(TypeError):
Transaction.transfer(['fulfillment'], {}, tx.id)
Transfer.generate(['fulfillment'], {}, tx.id)
with raises(ValueError):
Transaction.transfer(['fulfillment'], [], tx.id)
Transfer.generate(['fulfillment'], [], tx.id)
with raises(ValueError):
Transaction.transfer(['fulfillment'], [user_pub], tx.id)
Transfer.generate(['fulfillment'], [user_pub], tx.id)
with raises(ValueError):
Transaction.transfer(['fulfillment'], [([user_pub],)], tx.id)
Transfer.generate(['fulfillment'], [([user_pub],)], tx.id)
with raises(TypeError):
Transaction.transfer(['fulfillment'], [([user_pub], 1)],
Transfer.generate(['fulfillment'], [([user_pub], 1)],
tx.id, metadata='not a dict or none')
with raises(TypeError):
Transaction.transfer(['fulfillment'], [([user_pub], 1)],
Transfer.generate(['fulfillment'], [([user_pub], 1)],
['not a string'])
@ -1020,7 +1022,7 @@ def test_output_from_dict_invalid_amount(user_output):
def test_unspent_outputs_property(merlin, alice, bob, carol):
from planetmint.transactions.common.transaction import Transaction
tx = Transaction.create(
tx = Create.generate(
[merlin.public_key],
[([alice.public_key], 1),
([bob.public_key], 2),

16
tests/conftest.py
View File

@ -285,9 +285,9 @@ def mock_get_validators(network_validators):
@pytest.fixture
def create_tx(alice, user_pk):
from planetmint.models import Transaction
from planetmint.transactions.types.assets.create import Create
name = f'I am created by the create_tx fixture. My random identifier is {random.random()}.'
return Transaction.create([alice.public_key], [([user_pk], 1)], asset={'name': name})
return Create.generate([alice.public_key], [([user_pk], 1)], asset={'name': name})
@pytest.fixture
@ -304,17 +304,17 @@ def posted_create_tx(b, signed_create_tx):
@pytest.fixture
def signed_transfer_tx(signed_create_tx, user_pk, user_sk):
from planetmint.models import Transaction
from planetmint.transactions.types.assets.transfer import Transfer
inputs = signed_create_tx.to_inputs()
tx = Transaction.transfer(inputs, [([user_pk], 1)], asset_id=signed_create_tx.id)
tx = Transfer.generate(inputs, [([user_pk], 1)], asset_id=signed_create_tx.id)
return tx.sign([user_sk])
@pytest.fixture
def double_spend_tx(signed_create_tx, carol_pubkey, user_sk):
from planetmint.models import Transaction
from planetmint.transactions.types.assets.transfer import Transfer
inputs = signed_create_tx.to_inputs()
tx = Transaction.transfer(
tx = Transfer.generate(
inputs, [([carol_pubkey], 1)], asset_id=signed_create_tx.id)
return tx.sign([user_sk])
@ -326,11 +326,11 @@ def _get_height(b):
@pytest.fixture
def inputs(user_pk, b, alice):
from planetmint.models import Transaction
from planetmint.transactions.types.assets.create import Create
# create blocks with transactions for `USER` to spend
for height in range(1, 4):
transactions = [
Transaction.create(
Create.generate(
[alice.public_key],
[([user_pk], 1)],
metadata={'msg': random.random()},

64
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
from unittest.mock import patch
from planetmint.transactions.types.assets.create import Create
from planetmint.transactions.types.assets.transfer import Transfer
import pytest
from base58 import b58decode
@ -18,15 +20,15 @@ class TestBigchainApi(object):
from planetmint.transactions.common.exceptions import DoubleSpend
from planetmint.exceptions import CriticalDoubleSpend
tx = Transaction.create([alice.public_key], [([alice.public_key], 1)])
tx = Create.generate([alice.public_key], [([alice.public_key], 1)])
tx = tx.sign([alice.private_key])
b.store_bulk_transactions([tx])
transfer_tx = Transaction.transfer(tx.to_inputs(), [([alice.public_key], 1)],
transfer_tx = Transfer.generate(tx.to_inputs(), [([alice.public_key], 1)],
asset_id=tx.id)
transfer_tx = transfer_tx.sign([alice.private_key])
transfer_tx2 = Transaction.transfer(tx.to_inputs(), [([alice.public_key], 2)],
transfer_tx2 = Transfer.generate(tx.to_inputs(), [([alice.public_key], 2)],
asset_id=tx.id)
transfer_tx2 = transfer_tx2.sign([alice.private_key])
@ -47,7 +49,7 @@ class TestBigchainApi(object):
from planetmint.models import Transaction
from planetmint.backend.exceptions import OperationError
tx = Transaction.create([alice.public_key], [([alice.public_key], 1)])
tx = Create.generate([alice.public_key], [([alice.public_key], 1)])
tx = tx.sign([alice.private_key])
b.store_bulk_transactions([tx])
@ -64,11 +66,11 @@ class TestBigchainApi(object):
asset3 = {'msg': 'Planetmint 3'}
# create the transactions
tx1 = Transaction.create([alice.public_key], [([alice.public_key], 1)],
tx1 = Create.generate([alice.public_key], [([alice.public_key], 1)],
asset=asset1).sign([alice.private_key])
tx2 = Transaction.create([alice.public_key], [([alice.public_key], 1)],
tx2 = Create.generate([alice.public_key], [([alice.public_key], 1)],
asset=asset2).sign([alice.private_key])
tx3 = Transaction.create([alice.public_key], [([alice.public_key], 1)],
tx3 = Create.generate([alice.public_key], [([alice.public_key], 1)],
asset=asset3).sign([alice.private_key])
# write the transactions to the DB
@ -89,7 +91,7 @@ class TestBigchainApi(object):
input = Input(Ed25519Sha256(public_key=b58decode(user_pk)),
[user_pk],
TransactionLink('somethingsomething', 0))
tx = Transaction.transfer([input], [([user_pk], 1)],
tx = Transfer.generate([input], [([user_pk], 1)],
asset_id='mock_asset_link')
with pytest.raises(InputDoesNotExist):
tx.validate(b)
@ -99,7 +101,7 @@ class TestBigchainApi(object):
asset1 = {'msg': 'Planetmint 1'}
tx = Transaction.create([alice.public_key], [([alice.public_key], 1)],
tx = Create.generate([alice.public_key], [([alice.public_key], 1)],
asset=asset1).sign([alice.private_key])
b.store_bulk_transactions([tx])
@ -133,7 +135,7 @@ class TestTransactionValidation(object):
input_tx = b.fastquery.get_outputs_by_public_key(user_pk).pop()
input_transaction = b.get_transaction(input_tx.txid)
sk, pk = generate_key_pair()
tx = Transaction.create([pk], [([user_pk], 1)])
tx = Create.generate([pk], [([user_pk], 1)])
tx.operation = 'TRANSFER'
tx.asset = {'id': input_transaction.id}
tx.inputs[0].fulfills = input_tx
@ -164,7 +166,7 @@ class TestMultipleInputs(object):
tx_link = b.fastquery.get_outputs_by_public_key(user_pk).pop()
input_tx = b.get_transaction(tx_link.txid)
inputs = input_tx.to_inputs()
tx = Transaction.transfer(inputs, [([user2_pk], 1)],
tx = Transfer.generate(inputs, [([user2_pk], 1)],
asset_id=input_tx.id)
tx = tx.sign([user_sk])
@ -185,7 +187,7 @@ class TestMultipleInputs(object):
tx_link = b.fastquery.get_outputs_by_public_key(user_pk).pop()
input_tx = b.get_transaction(tx_link.txid)
tx = Transaction.transfer(input_tx.to_inputs(),
tx = Transfer.generate(input_tx.to_inputs(),
[([user2_pk, user3_pk], 1)],
asset_id=input_tx.id)
tx = tx.sign([user_sk])
@ -205,7 +207,7 @@ class TestMultipleInputs(object):
user2_sk, user2_pk = crypto.generate_key_pair()
user3_sk, user3_pk = crypto.generate_key_pair()
tx = Transaction.create([alice.public_key], [([user_pk, user2_pk], 1)])
tx = Create.generate([alice.public_key], [([user_pk, user2_pk], 1)])
tx = tx.sign([alice.private_key])
b.store_bulk_transactions([tx])
@ -213,7 +215,7 @@ class TestMultipleInputs(object):
input_tx = b.get_transaction(owned_input.txid)
inputs = input_tx.to_inputs()
transfer_tx = Transaction.transfer(inputs, [([user3_pk], 1)],
transfer_tx = Transfer.generate(inputs, [([user3_pk], 1)],
asset_id=input_tx.id)
transfer_tx = transfer_tx.sign([user_sk, user2_sk])
@ -234,7 +236,7 @@ class TestMultipleInputs(object):
user3_sk, user3_pk = crypto.generate_key_pair()
user4_sk, user4_pk = crypto.generate_key_pair()
tx = Transaction.create([alice.public_key], [([user_pk, user2_pk], 1)])
tx = Create.generate([alice.public_key], [([user_pk, user2_pk], 1)])
tx = tx.sign([alice.private_key])
b.store_bulk_transactions([tx])
@ -242,7 +244,7 @@ class TestMultipleInputs(object):
tx_link = b.fastquery.get_outputs_by_public_key(user_pk).pop()
tx_input = b.get_transaction(tx_link.txid)
tx = Transaction.transfer(tx_input.to_inputs(),
tx = Transfer.generate(tx_input.to_inputs(),
[([user3_pk, user4_pk], 1)],
asset_id=tx_input.id)
tx = tx.sign([user_sk, user2_sk])
@ -258,7 +260,7 @@ class TestMultipleInputs(object):
user2_sk, user2_pk = crypto.generate_key_pair()
tx = Transaction.create([alice.public_key], [([user_pk], 1)])
tx = Create.generate([alice.public_key], [([user_pk], 1)])
tx = tx.sign([alice.private_key])
b.store_bulk_transactions([tx])
@ -267,7 +269,7 @@ class TestMultipleInputs(object):
assert owned_inputs_user1 == [TransactionLink(tx.id, 0)]
assert owned_inputs_user2 == []
tx_transfer = Transaction.transfer(tx.to_inputs(), [([user2_pk], 1)],
tx_transfer = Transfer.generate(tx.to_inputs(), [([user2_pk], 1)],
asset_id=tx.id)
tx_transfer = tx_transfer.sign([user_sk])
b.store_bulk_transactions([tx_transfer])
@ -287,7 +289,7 @@ class TestMultipleInputs(object):
user2_sk, user2_pk = crypto.generate_key_pair()
# create divisible asset
tx_create = Transaction.create([alice.public_key], [([user_pk], 1), ([user_pk], 1)])
tx_create = Create.generate([alice.public_key], [([user_pk], 1), ([user_pk], 1)])
tx_create_signed = tx_create.sign([alice.private_key])
b.store_bulk_transactions([tx_create_signed])
@ -301,7 +303,7 @@ class TestMultipleInputs(object):
assert owned_inputs_user2 == []
# transfer divisible asset divided in two outputs
tx_transfer = Transaction.transfer(tx_create.to_inputs(),
tx_transfer = Transfer.generate(tx_create.to_inputs(),
[([user2_pk], 1), ([user2_pk], 1)],
asset_id=tx_create.id)
tx_transfer_signed = tx_transfer.sign([user_sk])
@ -321,7 +323,7 @@ class TestMultipleInputs(object):
user2_sk, user2_pk = crypto.generate_key_pair()
user3_sk, user3_pk = crypto.generate_key_pair()
tx = Transaction.create([alice.public_key], [([user_pk, user2_pk], 1)])
tx = Create.generate([alice.public_key], [([user_pk, user2_pk], 1)])
tx = tx.sign([alice.private_key])
b.store_bulk_transactions([tx])
@ -333,7 +335,7 @@ class TestMultipleInputs(object):
assert owned_inputs_user1 == owned_inputs_user2
assert owned_inputs_user1 == expected_owned_inputs_user1
tx = Transaction.transfer(tx.to_inputs(), [([user3_pk], 1)],
tx = Transfer.generate(tx.to_inputs(), [([user3_pk], 1)],
asset_id=tx.id)
tx = tx.sign([user_sk, user2_sk])
b.store_bulk_transactions([tx])
@ -351,7 +353,7 @@ class TestMultipleInputs(object):
user2_sk, user2_pk = crypto.generate_key_pair()
tx = Transaction.create([alice.public_key], [([user_pk], 1)])
tx = Create.generate([alice.public_key], [([user_pk], 1)])
tx = tx.sign([alice.private_key])
b.store_bulk_transactions([tx])
@ -363,7 +365,7 @@ class TestMultipleInputs(object):
assert spent_inputs_user1 is None
# create a transaction and send it
tx = Transaction.transfer(tx.to_inputs(), [([user2_pk], 1)],
tx = Transfer.generate(tx.to_inputs(), [([user2_pk], 1)],
asset_id=tx.id)
tx = tx.sign([user_sk])
b.store_bulk_transactions([tx])
@ -379,7 +381,7 @@ class TestMultipleInputs(object):
user2_sk, user2_pk = crypto.generate_key_pair()
# create a divisible asset with 3 outputs
tx_create = Transaction.create([alice.public_key],
tx_create = Create.generate([alice.public_key],
[([user_pk], 1),
([user_pk], 1),
([user_pk], 1)])
@ -393,7 +395,7 @@ class TestMultipleInputs(object):
assert b.get_spent(input_tx.txid, input_tx.output) is None
# transfer the first 2 inputs
tx_transfer = Transaction.transfer(tx_create.to_inputs()[:2],
tx_transfer = Transfer.generate(tx_create.to_inputs()[:2],
[([user2_pk], 1), ([user2_pk], 1)],
asset_id=tx_create.id)
tx_transfer_signed = tx_transfer.sign([user_sk])
@ -418,7 +420,7 @@ class TestMultipleInputs(object):
transactions = []
for i in range(3):
payload = {'somedata': i}
tx = Transaction.create([alice.public_key], [([user_pk, user2_pk], 1)],
tx = Create.generate([alice.public_key], [([user_pk, user2_pk], 1)],
payload)
tx = tx.sign([alice.private_key])
transactions.append(tx)
@ -431,7 +433,7 @@ class TestMultipleInputs(object):
assert b.get_spent(input_tx.txid, input_tx.output) is None
# create a transaction
tx = Transaction.transfer(transactions[0].to_inputs(),
tx = Transfer.generate(transactions[0].to_inputs(),
[([user3_pk], 1)],
asset_id=transactions[0].id)
tx = tx.sign([user_sk, user2_sk])
@ -500,7 +502,7 @@ def test_cant_spend_same_input_twice_in_tx(b, alice):
from planetmint.transactions.common.exceptions import DoubleSpend
# create a divisible asset
tx_create = Transaction.create([alice.public_key], [([alice.public_key], 100)])
tx_create = Create.generate([alice.public_key], [([alice.public_key], 100)])
tx_create_signed = tx_create.sign([alice.private_key])
assert b.validate_transaction(tx_create_signed) == tx_create_signed
@ -508,7 +510,7 @@ def test_cant_spend_same_input_twice_in_tx(b, alice):
# Create a transfer transaction with duplicated fulfillments
dup_inputs = tx_create.to_inputs() + tx_create.to_inputs()
tx_transfer = Transaction.transfer(dup_inputs, [([alice.public_key], 200)],
tx_transfer = Transfer.generate(dup_inputs, [([alice.public_key], 200)],
asset_id=tx_create.id)
tx_transfer_signed = tx_transfer.sign([alice.private_key])
with pytest.raises(DoubleSpend):
@ -524,7 +526,7 @@ def test_transaction_unicode(b, alice):
beer_python = {'beer': '\N{BEER MUG}'}
beer_json = '{"beer":"\N{BEER MUG}"}'
tx = (Transaction.create([alice.public_key], [([alice.public_key], 100)], beer_python)
tx = (Create.generate([alice.public_key], [([alice.public_key], 100)], beer_python)
).sign([alice.private_key])
tx_1 = copy.deepcopy(tx)

18
tests/tendermint/test_core.py
View File

@ -4,6 +4,8 @@
# Code is Apache-2.0 and docs are CC-BY-4.0
import json
from planetmint.transactions.types.assets.create import Create
from planetmint.transactions.types.assets.transfer import Transfer
import pytest
import random
@ -208,7 +210,7 @@ def test_check_tx__signed_create_is_ok(b):
alice = generate_key_pair()
bob = generate_key_pair()
tx = Transaction.create([alice.public_key],
tx = Create.generate([alice.public_key],
[([bob.public_key], 1)])\
.sign([alice.private_key])
@ -225,7 +227,7 @@ def test_check_tx__unsigned_create_is_error(b):
alice = generate_key_pair()
bob = generate_key_pair()
tx = Transaction.create([alice.public_key],
tx = Create.generate([alice.public_key],
[([bob.public_key], 1)])
app = App(b)
@ -243,7 +245,7 @@ def test_deliver_tx__valid_create_updates_db_and_emits_event(b, init_chain_reque
bob = generate_key_pair()
events = mp.Queue()
tx = Transaction.create([alice.public_key],
tx = Create.generate([alice.public_key],
[([bob.public_key], 1)])\
.sign([alice.private_key])
@ -279,7 +281,7 @@ def test_deliver_tx__double_spend_fails(b, init_chain_request):
alice = generate_key_pair()
bob = generate_key_pair()
tx = Transaction.create([alice.public_key],
tx = Create.generate([alice.public_key],
[([bob.public_key], 1)])\
.sign([alice.private_key])
@ -319,7 +321,7 @@ def test_deliver_transfer_tx__double_spend_fails(b, init_chain_request):
'msg': 'live long and prosper'
}
tx = Transaction.create([alice.public_key],
tx = Create.generate([alice.public_key],
[([alice.public_key], 1)],
asset=asset)\
.sign([alice.private_key])
@ -327,7 +329,7 @@ def test_deliver_transfer_tx__double_spend_fails(b, init_chain_request):
result = app.deliver_tx(encode_tx_to_bytes(tx))
assert result.code == OkCode
tx_transfer = Transaction.transfer(tx.to_inputs(),
tx_transfer = Transfer.generate(tx.to_inputs(),
[([bob.public_key], 1)],
asset_id=tx.id)\
.sign([alice.private_key])
@ -335,7 +337,7 @@ def test_deliver_transfer_tx__double_spend_fails(b, init_chain_request):
result = app.deliver_tx(encode_tx_to_bytes(tx_transfer))
assert result.code == OkCode
double_spend = Transaction.transfer(tx.to_inputs(),
double_spend = Transfer.generate(tx.to_inputs(),
[([carly.public_key], 1)],
asset_id=tx.id)\
.sign([alice.private_key])
@ -384,7 +386,7 @@ def test_store_pre_commit_state_in_end_block(b, alice, init_chain_request):
from planetmint.backend import query
from planetmint.models import Transaction
tx = Transaction.create([alice.public_key],
tx = Create.generate([alice.public_key],
[([alice.public_key], 1)],
asset={'msg': 'live long and prosper'})\
.sign([alice.private_key])

21
tests/tendermint/test_fastquery.py
View File

@ -6,7 +6,8 @@
import pytest
from planetmint.transactions.common.transaction import TransactionLink
from planetmint.models import Transaction
from planetmint.transactions.types.assets.create import Create
from planetmint.transactions.types.assets.transfer import Transfer
pytestmark = pytest.mark.bdb
@ -14,9 +15,9 @@ pytestmark = pytest.mark.bdb
@pytest.fixture
def txns(b, user_pk, user_sk, user2_pk, user2_sk):
txs = [Transaction.create([user_pk], [([user2_pk], 1)]).sign([user_sk]),
Transaction.create([user2_pk], [([user_pk], 1)]).sign([user2_sk]),
Transaction.create([user_pk], [([user_pk], 1), ([user2_pk], 1)])
txs = [Create.generate([user_pk], [([user2_pk], 1)]).sign([user_sk]),
Create.generate([user2_pk], [([user_pk], 1)]).sign([user2_sk]),
Create.generate([user_pk], [([user_pk], 1), ([user2_pk], 1)])
.sign([user_sk])]
b.store_bulk_transactions(txs)
return txs
@ -35,12 +36,12 @@ def test_get_outputs_by_public_key(b, user_pk, user2_pk, txns):
def test_filter_spent_outputs(b, user_pk, user_sk):
out = [([user_pk], 1)]
tx1 = Transaction.create([user_pk], out * 2)
tx1 = Create.generate([user_pk], out * 2)
tx1.sign([user_sk])
inputs = tx1.to_inputs()
tx2 = Transaction.transfer([inputs[0]], out, tx1.id)
tx2 = Transfer.generate([inputs[0]], out, tx1.id)
tx2.sign([user_sk])
# tx2 produces a new unspent. inputs[1] remains unspent.
@ -57,12 +58,12 @@ def test_filter_spent_outputs(b, user_pk, user_sk):
def test_filter_unspent_outputs(b, user_pk, user_sk):
out = [([user_pk], 1)]
tx1 = Transaction.create([user_pk], out * 2)
tx1 = Create.generate([user_pk], out * 2)
tx1.sign([user_sk])
inputs = tx1.to_inputs()
tx2 = Transaction.transfer([inputs[0]], out, tx1.id)
tx2 = Transfer.generate([inputs[0]], out, tx1.id)
tx2.sign([user_sk])
# tx2 produces a new unspent. input[1] remains unspent.
@ -80,13 +81,13 @@ def test_outputs_query_key_order(b, user_pk, user_sk, user2_pk, user2_sk):
from planetmint import backend
from planetmint.backend import connect
tx1 = Transaction.create([user_pk],
tx1 = Create.generate([user_pk],
[([user_pk], 3), ([user_pk], 2), ([user_pk], 1)])\
.sign([user_sk])
b.store_bulk_transactions([tx1])
inputs = tx1.to_inputs()
tx2 = Transaction.transfer([inputs[1]], [([user2_pk], 2)], tx1.id).sign([user_sk])
tx2 = Transfer.generate([inputs[1]], [([user2_pk], 2)], tx1.id).sign([user_sk])
assert tx2.validate(b)
tx2_dict = tx2.to_dict()

6
tests/tendermint/test_integration.py
View File

@ -4,6 +4,7 @@
# Code is Apache-2.0 and docs are CC-BY-4.0
import codecs
from planetmint.transactions.types.assets.create import Create
from tendermint.abci import types_pb2 as types
import json
@ -23,7 +24,6 @@ def test_app(b, eventqueue_fixture, init_chain_request):
from planetmint import App
from planetmint.tendermint_utils import calculate_hash
from planetmint.transactions.common.crypto import generate_key_pair
from planetmint.models import Transaction
app = App(b, eventqueue_fixture)
p = ProtocolHandler(app)
@ -49,7 +49,7 @@ def test_app(b, eventqueue_fixture, init_chain_request):
alice = generate_key_pair()
bob = generate_key_pair()
tx = Transaction.create([alice.public_key],
tx = Create.generate([alice.public_key],
[([bob.public_key], 1)])\
.sign([alice.private_key])
etxn = json.dumps(tx.to_dict()).encode('utf8')
@ -118,7 +118,7 @@ def test_post_transaction_responses(tendermint_ws_url, b):
alice = generate_key_pair()
bob = generate_key_pair()
tx = Transaction.create([alice.public_key],
tx = Create.generate([alice.public_key],
[([alice.public_key], 1)],
asset=None)\
.sign([alice.private_key])

40
tests/tendermint/test_lib.py
View File

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

18
tests/test_core.py
View File

@ -4,6 +4,8 @@
# Code is Apache-2.0 and docs are CC-BY-4.0
import json
from planetmint.transactions.types.assets.create import Create
from planetmint.transactions.types.assets.transfer import Transfer
import pytest
import random
@ -208,7 +210,7 @@ def test_check_tx__signed_create_is_ok(b):
alice = generate_key_pair()
bob = generate_key_pair()
tx = Transaction.create([alice.public_key],
tx = Create.generate([alice.public_key],
[([bob.public_key], 1)])\
.sign([alice.private_key])
@ -225,7 +227,7 @@ def test_check_tx__unsigned_create_is_error(b):
alice = generate_key_pair()
bob = generate_key_pair()
tx = Transaction.create([alice.public_key],
tx = Create.generate([alice.public_key],
[([bob.public_key], 1)])
app = App(b)
@ -243,7 +245,7 @@ def test_deliver_tx__valid_create_updates_db_and_emits_event(b, init_chain_reque
bob = generate_key_pair()
events = mp.Queue()
tx = Transaction.create([alice.public_key],
tx = Create.generate([alice.public_key],
[([bob.public_key], 1)])\
.sign([alice.private_key])
@ -279,7 +281,7 @@ def test_deliver_tx__double_spend_fails(b, eventqueue_fixture, init_chain_reques
alice = generate_key_pair()
bob = generate_key_pair()
tx = Transaction.create([alice.public_key],
tx = Create.generate([alice.public_key],
[([bob.public_key], 1)])\
.sign([alice.private_key])
@ -319,7 +321,7 @@ def test_deliver_transfer_tx__double_spend_fails(b, init_chain_request):
'msg': 'live long and prosper'
}
tx = Transaction.create([alice.public_key],
tx = Create.generate([alice.public_key],
[([alice.public_key], 1)],
asset=asset)\
.sign([alice.private_key])
@ -327,7 +329,7 @@ def test_deliver_transfer_tx__double_spend_fails(b, init_chain_request):
result = app.deliver_tx(encode_tx_to_bytes(tx))
assert result.code == OkCode
tx_transfer = Transaction.transfer(tx.to_inputs(),
tx_transfer = Transfer.generate(tx.to_inputs(),
[([bob.public_key], 1)],
asset_id=tx.id)\
.sign([alice.private_key])
@ -335,7 +337,7 @@ def test_deliver_transfer_tx__double_spend_fails(b, init_chain_request):
result = app.deliver_tx(encode_tx_to_bytes(tx_transfer))
assert result.code == OkCode
double_spend = Transaction.transfer(tx.to_inputs(),
double_spend = Transfer.generate(tx.to_inputs(),
[([carly.public_key], 1)],
asset_id=tx.id)\
.sign([alice.private_key])
@ -384,7 +386,7 @@ def test_store_pre_commit_state_in_end_block(b, alice, init_chain_request):
from planetmint.backend import query
from planetmint.models import Transaction
tx = Transaction.create([alice.public_key],
tx = Create.generate([alice.public_key],
[([alice.public_key], 1)],
asset={'msg': 'live long and prosper'})\
.sign([alice.private_key])

10
tests/test_parallel_validation.py
View File

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

9
tests/test_txlist.py
View File

@ -12,18 +12,19 @@ import pytest
@pytest.fixture
def txlist(b, user_pk, user2_pk, user_sk, user2_sk):
from planetmint.models import Transaction
from planetmint.transactions.types.assets.create import Create
from planetmint.transactions.types.assets.transfer import Transfer
# Create two CREATE transactions
create1 = Transaction.create([user_pk], [([user2_pk], 6)]) \
create1 = Create.generate([user_pk], [([user2_pk], 6)]) \
.sign([user_sk])
create2 = Transaction.create([user2_pk],
create2 = Create.generate([user2_pk],
[([user2_pk], 5), ([user_pk], 5)]) \
.sign([user2_sk])
# Create a TRANSFER transactions
transfer1 = Transaction.transfer(create1.to_inputs(),
transfer1 = Transfer.generate(create1.to_inputs(),
[([user_pk], 8)],
create1.id).sign([user2_sk])

7
tests/web/test_assets.py
View File

@ -4,6 +4,7 @@
# Code is Apache-2.0 and docs are CC-BY-4.0
import pytest
from planetmint.transactions.types.assets.create import Create
ASSETS_ENDPOINT = '/api/v1/assets/'
@ -31,7 +32,7 @@ def test_get_assets_tendermint(client, b, alice):
# create asset
asset = {'msg': 'abc'}
tx = Transaction.create([alice.public_key], [([alice.public_key], 1)],
tx = Create.generate([alice.public_key], [([alice.public_key], 1)],
asset=asset).sign([alice.private_key])
b.store_bulk_transactions([tx])
@ -53,9 +54,9 @@ def test_get_assets_limit_tendermint(client, b, alice):
# create two assets
asset1 = {'msg': 'abc 1'}
asset2 = {'msg': 'abc 2'}
tx1 = Transaction.create([alice.public_key], [([alice.public_key], 1)],
tx1 = Create.generate([alice.public_key], [([alice.public_key], 1)],
asset=asset1).sign([alice.private_key])
tx2 = Transaction.create([alice.public_key], [([alice.public_key], 1)],
tx2 = Create.generate([alice.public_key], [([alice.public_key], 1)],
asset=asset2).sign([alice.private_key])
b.store_bulk_transactions([tx1])

6
tests/web/test_block_tendermint.py
View File

@ -5,7 +5,7 @@
import pytest
from planetmint.models import Transaction
from planetmint.transactions.types.assets.create import Create
from planetmint.lib import Block
BLOCKS_ENDPOINT = '/api/v1/blocks/'
@ -15,7 +15,7 @@ BLOCKS_ENDPOINT = '/api/v1/blocks/'
@pytest.mark.usefixtures('inputs')
def test_get_block_endpoint(b, client, alice):
import copy
tx = Transaction.create([alice.public_key], [([alice.public_key], 1)], asset={'cycle': 'hero'})
tx = Create.generate([alice.public_key], [([alice.public_key], 1)], asset={'cycle': 'hero'})
tx = tx.sign([alice.private_key])
# with store_bulk_transactions we use `insert_many` where PyMongo
@ -48,7 +48,7 @@ def test_get_block_returns_404_if_not_found(client):
@pytest.mark.bdb
def test_get_block_containing_transaction(b, client, alice):
tx = Transaction.create([alice.public_key], [([alice.public_key], 1)], asset={'cycle': 'hero'})
tx = Create.generate([alice.public_key], [([alice.public_key], 1)], asset={'cycle': 'hero'})
tx = tx.sign([alice.private_key])
b.store_bulk_transactions([tx])

9
tests/web/test_metadata.py
View File

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

38
tests/web/test_transactions.py
View File

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

10
tests/web/test_websocket_server.py
View File

@ -8,6 +8,8 @@ import json
import queue
import threading
from unittest.mock import patch
from planetmint.transactions.types.assets.create import Create
from planetmint.transactions.types.assets.transfer import Transfer
import pytest
@ -27,10 +29,10 @@ def test_eventify_block_works_with_any_transaction():
alice = generate_key_pair()
tx = Transaction.create([alice.public_key],
tx = Create.generate([alice.public_key],
[([alice.public_key], 1)])\
.sign([alice.private_key])
tx_transfer = Transaction.transfer(tx.to_inputs(),
tx_transfer = Transfer.generate(tx.to_inputs(),
[([alice.public_key], 1)],
asset_id=tx.id)\
.sign([alice.private_key])
@ -142,7 +144,7 @@ async def test_websocket_block_event(b, test_client, loop):
from planetmint.transactions.common import crypto
user_priv, user_pub = crypto.generate_key_pair()
tx = Transaction.create([user_pub], [([user_pub], 1)])
tx = Create.generate([user_pub], [([user_pub], 1)])
tx = tx.sign([user_priv])
event_source = asyncio.Queue(loop=loop)
@ -203,7 +205,7 @@ def test_integration_from_webapi_to_websocket(monkeypatch, client, loop):
# Create a keypair and generate a new asset
user_priv, user_pub = crypto.generate_key_pair()
asset = {'random': random.random()}
tx = Transaction.create([user_pub], [([user_pub], 1)], asset=asset)
tx = Create.generate([user_pub], [([user_pub], 1)], asset=asset)
tx = tx.sign([user_priv])
# Post the transaction to the Planetmint Web API
client.post('/api/v1/transactions/', data=json.dumps(tx.to_dict()))