renamed group_txs and used data models in fastquery

Signed-off-by: Lorenz Herzberger <lorenzherzberger@gmail.com>

planetmint/backend/models/dbtransaction.py

@@ -4,9 +4,9 @@
 # Code is Apache-2.0 and docs are CC-BY-4.0
 
 from __future__ import annotations
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 
-from planetmint.backend.models import Asset, MetaData, Input, Script
+from planetmint.backend.models import Asset, MetaData, Input, Script, Output
 
 
 @dataclass
@@ -15,8 +15,9 @@ class DbTransaction:
     operation: str = ""
     version: str = ""
     metadata: MetaData = None
-    assets: list[Asset] = None
-    inputs: list[Input] = None
+    assets: list[Asset] = field(default_factory=list)
+    inputs: list[Input] = field(default_factory=list)
+    outputs: list[Output] = field(default_factory=list)
     script: Script = None
 
     @staticmethod

planetmint/backend/models/fulfills.py

@@ -10,3 +10,9 @@ from dataclasses import dataclass
 class Fulfills:
     transaction_id: str = ""
     output_index: int = 0
+
+    def to_dict(self) -> dict:
+        return {
+            "transaction_id": self.transaction_id,
+            "output_index": self.output_index
+        }

planetmint/backend/query.py

@@ -71,8 +71,8 @@ def store_transaction(connection, transaction):
 
 
 @singledispatch
-def get_transaction_space_by_id(connection, transaction_id):
-    """Get the transaction space by transaction id."""
+def get_transaction_by_id(connection, transaction_id):
+    """Get the transaction by transaction id."""
 
     raise NotImplementedError
 
@@ -464,7 +464,7 @@ def store_transaction_inputs(connection, inputs: list[Input]):
 
 
 @singledispatch
-def _group_transaction_by_ids(txids: list, connection):
+def get_complete_transactions_by_ids(txids: list, connection):
     """Returns the transactions object (JSON TYPE), from list of ids."""
     raise NotImplementedError
 

planetmint/backend/tarantool/query.py

@@ -31,12 +31,14 @@ register_query = module_dispatch_registrar(query)
 
 
 @register_query(TarantoolDBConnection)
-def _group_transaction_by_ids(connection, txids: list) -> list[DbTransaction]:
+def get_complete_transactions_by_ids(connection, txids: list) -> list[DbTransaction]:
     _transactions = []
     for txid in txids:
-        tx = get_transaction_space_by_id(connection, txid)
+        tx = get_transaction_by_id(connection, txid)
         if tx is None:
             continue
+        outputs = get_outputs_by_tx_id(connection, txid)
+        tx.outputs = outputs
         _transactions.append(tx)
     return _transactions
 
@@ -93,7 +95,7 @@ def store_transaction(connection, transaction):
 
 
 @register_query(TarantoolDBConnection)
-def get_transaction_space_by_id(connection, transaction_id):
+def get_transaction_by_id(connection, transaction_id):
     txs = connection.run(connection.space(TARANT_TABLE_TRANSACTION).select(transaction_id, index=TARANT_ID_SEARCH))
     if len(txs) == 0:
         return None
@@ -102,12 +104,12 @@ def get_transaction_space_by_id(connection, transaction_id):
 
 @register_query(TarantoolDBConnection)
 def get_transaction_single(connection, transaction_id) -> DbTransaction:
-    return _group_transaction_by_ids(txids=[transaction_id], connection=connection)[0]
+    return get_complete_transactions_by_ids(txids=[transaction_id], connection=connection)[0]
 
 
 @register_query(TarantoolDBConnection)
 def get_transactions(connection, transactions_ids: list) -> list[DbTransaction]:
-    return _group_transaction_by_ids(txids=transactions_ids, connection=connection)
+    return get_complete_transactions_by_ids(txids=transactions_ids, connection=connection)
 
 
 @register_query(TarantoolDBConnection)
@@ -136,7 +138,7 @@ def get_spent(connection, fullfil_transaction_id: str, fullfil_output_index: str
             [fullfil_transaction_id, fullfil_output_index], index=TARANT_INDEX_SPENDING_BY_ID_AND_OUTPUT_INDEX
         )
     )
-    return _group_transaction_by_ids(txids=[inp[0] for inp in _inputs], connection=connection)
+    return get_complete_transactions_by_ids(txids=[inp[0] for inp in _inputs], connection=connection)
 
 
 @register_query(TarantoolDBConnection)
@@ -206,11 +208,11 @@ def text_search(conn, search, table=TARANT_TABLE_ASSETS, limit=0):
 
 @register_query(TarantoolDBConnection)
 def get_owned_ids(connection, owner: str):
-    _keys = connection.run(connection.space(TARANT_TABLE_KEYS).select(owner, index="keys_search"))
-    if _keys is None or len(_keys) == 0:
+    outputs = connection.run(connection.space(TARANT_TABLE_OUTPUT).select(owner, index="public_keys"))
+    if len(outputs) == 0:
         return []
-    _transactionids = list(set([key[1] for key in _keys]))
-    return _group_transaction_by_ids(txids=_transactionids, connection=connection)
+    txids = [output[5] for output in outputs]
+    return get_complete_transactions_by_ids(connection, txids)
 
 
 @register_query(TarantoolDBConnection)
@@ -409,7 +411,7 @@ def get_asset_tokens_for_public_key(
     _transactions = connection.run(connection.space(TARANT_TABLE_ASSETS).select([asset_id], index="assetid_search"))
     # _transactions = _transactions
     # _keys = _keys.data
-    return _group_transaction_by_ids(connection=connection, txids=[_tx[1] for _tx in _transactions])
+    return get_complete_transactions_by_ids(connection=connection, txids=[_tx[1] for _tx in _transactions])
 
 
 @register_query(TarantoolDBConnection)

planetmint/fastquery.py

@@ -16,12 +16,13 @@ class FastQuery:
 
     def get_outputs_by_public_key(self, public_key):
         """Get outputs for a public key"""
-        txs = list(query.get_owned_ids(self.connection, public_key))
+        txs = query.get_owned_ids(self.connection, public_key)
+        print(txs)
         return [
-            TransactionLink(tx["transactions"].id, index)
+            TransactionLink(tx.id, index)
             for tx in txs
-            for index, output in enumerate(tx["outputs"])
-            if condition_details_has_owner(output["condition"]["details"], public_key)
+            for index, output in enumerate(tx.outputs)
+            if condition_details_has_owner(output.condition.details, public_key)
         ]
 
     def filter_spent_outputs(self, outputs):
@@ -31,8 +32,8 @@ class FastQuery:
             outputs: list of TransactionLink
         """
         links = [o.to_dict() for o in outputs]
-        txs = list(query.get_spending_transactions(self.connection, links))
-        spends = {TransactionLink.from_dict(input_["fulfills"]) for tx in txs for input_ in tx["inputs"]}
+        txs = query.get_spending_transactions(self.connection, links)
+        spends = {TransactionLink.from_dict(input.fulfills.to_dict()) for tx in txs for input in tx.inputs}
         return [ff for ff in outputs if ff not in spends]
 
     def filter_unspent_outputs(self, outputs):
@@ -42,6 +43,6 @@ class FastQuery:
             outputs: list of TransactionLink
         """
         links = [o.to_dict() for o in outputs]
-        txs = list(query.get_spending_transactions(self.connection, links))
-        spends = {TransactionLink.from_dict(input_["fulfills"]) for tx in txs for input_ in tx["inputs"]}
+        txs = query.get_spending_transactions(self.connection, links)
+        spends = {TransactionLink.from_dict(input.fulfills.to_dict()) for tx in txs for input in tx.inputs}
         return [ff for ff in outputs if ff in spends]

planetmint/lib.py

@@ -225,7 +225,7 @@ class Planetmint(object):
             return backend.query.delete_unspent_outputs(self.connection, *unspent_outputs)
 
     def is_committed(self, transaction_id):
-        transaction = backend.query.get_transaction_space_by_id(self.connection, transaction_id)
+        transaction = backend.query.get_transaction_by_id(self.connection, transaction_id)
         return bool(transaction)
 
     def get_transaction(self, transaction_id):

planetmint/utils.py

@@ -120,8 +120,8 @@ def condition_details_has_owner(condition_details, owner):
         bool: True if the public key is found in the condition details, False otherwise
 
     """
-    if "subconditions" in condition_details:
-        result = condition_details_has_owner(condition_details["subconditions"], owner)
+    if condition_details.sub_conditions is not None:
+        result = condition_details_has_owner(condition_details.sub_conditions, owner)
         if result:
             return True
 
@@ -131,7 +131,7 @@ def condition_details_has_owner(condition_details, owner):
             if result:
                 return True
     else:
-        if "public_key" in condition_details and owner == condition_details["public_key"]:
+        if condition_details.public_key is not None and owner == condition_details.public_key:
             return True
     return False