bitcoinwatcher 1.0.1__py3-none-any.whl → 1.2.0__py3-none-any.whl

bitcoin/address_listener/address_listener.py

@@ -1,35 +1,13 @@
-import dataclasses
 import os
 from abc import ABC, abstractmethod
-from enum import Enum
 
 from bitcoinlib.transactions import Transaction
 from ordipool.ordipool.mempoolio import Mempool
 
+from bitcoin.models.address_tx_data import AddressTxData
 from bitcoin.tx_listener.abstract_tx_listener import AbstractTxListener
 from bitcoin.utils.constants import default_host
-
-
-class AddressTxType(Enum):
-    INPUT = "input"
-    OUTPUT = "output"
-
-
-@dataclasses.dataclass
-class AddressTxData:
-    tx_id: str
-    address: str
-    type: AddressTxType
-    # figure out the way to get amount in vin
-    _amount: int = 0
-
-    def get_amount(self):
-        return self._amount
-
-    def amount_in_btc(self):
-        if self.type == AddressTxType.INPUT:
-            return "Amount is not supported for input type, yet"
-        return self._amount / 100000000
+from bitcoin.utils.tx_address_data_extractor import DefaultTxAddressDataExtractor, MempoolTxAddressDataExtractor
 
 
 class AbstractAddressListener(AbstractTxListener, ABC):
@@ -37,6 +15,8 @@ class AbstractAddressListener(AbstractTxListener, ABC):
     host = os.environ.get("RPC_HOST", default_host)
     base_url = f"http://{host}:3006/api"
     mempool = Mempool(base_url=base_url)
+    default_tx_extractor = DefaultTxAddressDataExtractor()
+    mempool_tx_extractor = MempoolTxAddressDataExtractor(mempool)
 
     def __init__(self, addresses_to_listen: {str}):
         self.addresses_to_listen = addresses_to_listen
@@ -55,27 +35,17 @@ class AbstractAddressListener(AbstractTxListener, ABC):
         # get all address in the inputs and outputs along with the amount
         if tx.coinbase:
             return
-        outputs = tx.outputs
-        tx_id = tx.txid
-        tx = self.mempool.get_transaction(tx_id)
-        address_tx_data = []
-        # getting inputs data separately from mempool
-        # as current library doesn't provide rich data like previous outputs and its value
-        for input in tx.vins:
-            address = input.prev_out.address
-            amount = input.prev_out.value
-            address_tx_data.append(AddressTxData(address=address,
-                                                 type=AddressTxType.INPUT,
-                                                 _amount=amount,
-                                                 tx_id=tx_id))
-        for output in outputs:
-            amount = output.value
-            address_tx_data.append(AddressTxData(address=output.address,
-                                                 _amount=amount,
-                                                 type=AddressTxType.OUTPUT,
-                                                 tx_id=tx_id))
-
+        address_tx_data = self.default_tx_extractor.extract(tx)
         # filter the address we are interested in
         addresses_for_events = self.filter_address_tx_data(address_tx_data)
+        if len(addresses_for_events) == 0:
+            return
+        # get the address tx data from mempool for full details if any address matches
+        try:
+            address_tx_data = self.mempool_tx_extractor.extract(tx)
+        except Exception as e:
+            print(f"Error in getting mempool tx data, taking defaults: {e}")
+            address_tx_data = address_tx_data
+
         for address in addresses_for_events:
             self.consume(subscribed_address=address, address_tx_data=address_tx_data)

bitcoin/address_listener/simple_address_listener.py

@@ -1,4 +1,5 @@
-from bitcoin.address_listener.address_listener import AbstractAddressListener, AddressTxData, AddressTxType
+from bitcoin.address_listener.address_listener import AbstractAddressListener, AddressTxData
+from bitcoin.models.address_tx_data import AddressTxType
 from bitcoin.tx_listener.zmq_listener import ZMQTXListener
 
 
@@ -11,6 +12,7 @@ class SimpleAddressListener(AbstractAddressListener):
                                 address_tx_data))
         total_amount_in_input = sum(map(lambda x: x.amount_in_btc(), all_input))
         # scale ito 4 decimal places
+        print("Transaction status: ", address_tx_data[0].tx_status)
         total_amount_in_output = round(total_amount_in_output, self.DECIMAL_SCALE)
         print(f"Address {subscribed_address} received {total_amount_in_output} BTC in tx {address_tx_data[0].tx_id}")
         print(f"Address {subscribed_address} spent {total_amount_in_input} BTC in tx {address_tx_data[0].tx_id}")

bitcoin/models/address_tx_data.py

@@ -0,0 +1,36 @@
+import dataclasses
+from enum import Enum
+
+
+class AddressTxType(Enum):
+    INPUT = "input"
+    OUTPUT = "output"
+
+
+class AddressTxSource(Enum):
+    MEMPOOL = "mempool"
+    DEFAULT = "default"
+
+
+class TransactionStatus(Enum):
+    UNCONFIRMED = "unconfirmed"
+    CONFIRMED = "confirmed"
+
+
+@dataclasses.dataclass
+class AddressTxData:
+    tx_id: str
+    address: str
+    type: AddressTxType
+    # figure out the way to get amount in vin
+    _amount: int = 0
+    tx_status: str = "unconfirmed"
+    is_reveal_tx: bool = False
+
+    def get_amount(self):
+        return self._amount
+
+    def amount_in_btc(self):
+        if self.type == AddressTxType.INPUT:
+            return "Amount is not supported for input type, yet"
+        return self._amount / 100000000