lbry-sdk/torba/baseledger.py

245 lines
9.1 KiB
Python
Raw Normal View History

2018-05-25 08:03:25 +02:00
import os
2018-06-11 15:33:32 +02:00
import six
2018-05-25 08:03:25 +02:00
import hashlib
from binascii import hexlify, unhexlify
2018-06-11 15:33:32 +02:00
from typing import Dict, Type
2018-05-25 08:03:25 +02:00
from operator import itemgetter
2018-06-11 15:33:32 +02:00
from twisted.internet import defer
2018-05-25 08:03:25 +02:00
2018-06-11 15:33:32 +02:00
from torba import baseaccount
from torba import basedatabase
from torba import baseheader
from torba import basenetwork
from torba import basetransaction
2018-05-25 08:03:25 +02:00
from torba.stream import StreamController, execute_serially
2018-06-11 15:33:32 +02:00
from torba.hash import hash160, double_sha256, Base58
2018-05-25 08:03:25 +02:00
2018-06-11 15:33:32 +02:00
class LedgerRegistry(type):
ledgers = {} # type: Dict[str, Type[BaseLedger]]
2018-05-25 08:03:25 +02:00
2018-06-11 15:33:32 +02:00
def __new__(mcs, name, bases, attrs):
cls = super(LedgerRegistry, mcs).__new__(mcs, name, bases, attrs) # type: Type[BaseLedger]
if not (name == 'BaseLedger' and not bases):
ledger_id = cls.get_id()
assert ledger_id not in mcs.ledgers,\
'Ledger with id "{}" already registered.'.format(ledger_id)
mcs.ledgers[ledger_id] = cls
return cls
2018-05-25 08:03:25 +02:00
2018-06-11 15:33:32 +02:00
@classmethod
def get_ledger_class(mcs, ledger_id): # type: (str) -> Type[BaseLedger]
return mcs.ledgers[ledger_id]
2018-05-25 08:03:25 +02:00
2018-06-11 15:33:32 +02:00
class BaseLedger(six.with_metaclass(LedgerRegistry)):
2018-05-25 08:03:25 +02:00
2018-06-11 15:33:32 +02:00
name = None
symbol = None
network_name = None
2018-05-25 08:03:25 +02:00
2018-06-11 15:33:32 +02:00
account_class = baseaccount.BaseAccount
database_class = basedatabase.BaseDatabase
headers_class = baseheader.BaseHeaders
network_class = basenetwork.BaseNetwork
transaction_class = basetransaction.BaseTransaction
2018-05-25 08:03:25 +02:00
2018-06-11 15:33:32 +02:00
secret_prefix = None
pubkey_address_prefix = None
script_address_prefix = None
extended_public_key_prefix = None
extended_private_key_prefix = None
2018-05-25 08:03:25 +02:00
2018-06-08 05:47:46 +02:00
default_fee_per_byte = 10
2018-05-25 08:03:25 +02:00
2018-06-11 15:33:32 +02:00
def __init__(self, config=None, db=None, network=None):
2018-05-25 08:03:25 +02:00
self.config = config or {}
2018-06-14 21:17:59 +02:00
self.db = db or self.database_class(
os.path.join(self.path, "blockchain.db")
) # type: basedatabase.BaseDatabase
2018-06-08 05:47:46 +02:00
self.network = network or self.network_class(self)
2018-05-25 08:03:25 +02:00
self.network.on_header.listen(self.process_header)
self.network.on_status.listen(self.process_status)
2018-06-11 15:33:32 +02:00
self.accounts = set()
2018-06-08 05:47:46 +02:00
self.headers = self.headers_class(self)
2018-06-11 15:33:32 +02:00
self.fee_per_byte = self.config.get('fee_per_byte', self.default_fee_per_byte)
2018-06-08 05:47:46 +02:00
self._on_transaction_controller = StreamController()
self.on_transaction = self._on_transaction_controller.stream
2018-06-11 15:33:32 +02:00
@classmethod
def get_id(cls):
return '{}_{}'.format(cls.symbol.lower(), cls.network_name.lower())
def hash160_to_address(self, h160):
raw_address = self.pubkey_address_prefix + h160
return Base58.encode(bytearray(raw_address + double_sha256(raw_address)[0:4]))
@staticmethod
def address_to_hash160(address):
bytes = Base58.decode(address)
prefix, pubkey_bytes, addr_checksum = bytes[0], bytes[1:21], bytes[21:]
return pubkey_bytes
def public_key_to_address(self, public_key):
return self.hash160_to_address(hash160(public_key))
@staticmethod
def private_key_to_wif(private_key):
return b'\x1c' + private_key + b'\x01'
2018-06-08 05:47:46 +02:00
@property
def path(self):
2018-06-12 16:02:04 +02:00
return os.path.join(self.config['wallet_path'], self.get_id())
2018-06-08 05:47:46 +02:00
def get_input_output_fee(self, io):
""" Fee based on size of the input / output. """
return self.fee_per_byte * io.size
def get_transaction_base_fee(self, tx):
""" Fee for the transaction header and all outputs; without inputs. """
return self.fee_per_byte * tx.base_size
2018-05-25 08:03:25 +02:00
2018-06-08 05:47:46 +02:00
@defer.inlineCallbacks
2018-06-12 16:02:04 +02:00
def add_transaction(self, address, transaction, height):
# type: (bytes, basetransaction.BaseTransaction, int) -> None
yield self.db.add_transaction(
2018-06-14 02:57:57 +02:00
address, self.address_to_hash160(address), transaction, height, False
2018-06-12 16:02:04 +02:00
)
2018-05-25 08:03:25 +02:00
self._on_transaction_controller.add(transaction)
2018-06-14 02:57:57 +02:00
@defer.inlineCallbacks
def add_account(self, account): # type: (baseaccount.BaseAccount) -> None
self.accounts.add(account)
if self.network.is_connected:
yield self.update_account(account)
2018-06-11 15:33:32 +02:00
@defer.inlineCallbacks
def get_private_key_for_address(self, address):
2018-06-12 16:02:04 +02:00
match = yield self.db.get_address(address)
2018-06-11 15:33:32 +02:00
if match:
for account in self.accounts:
if bytes(match['account']) == account.public_key.address:
defer.returnValue(account.get_private_key(match['chain'], match['position']))
2018-06-08 05:47:46 +02:00
def get_unspent_outputs(self, account):
return self.db.get_utxos(account, self.transaction_class.output_class)
2018-06-12 16:02:04 +02:00
@defer.inlineCallbacks
def get_local_status(self, address):
address_details = yield self.db.get_address(address)
hash = hashlib.sha256(address_details['history']).digest()
defer.returnValue(hexlify(hash))
@defer.inlineCallbacks
def get_local_history(self, address):
address_details = yield self.db.get_address(address)
history = address_details['history'] or b''
2018-06-14 02:57:57 +02:00
if six.PY2:
history = str(history)
2018-06-12 16:02:04 +02:00
parts = history.split(b':')[:-1]
defer.returnValue(list(zip(parts[0::2], map(int, parts[1::2]))))
2018-05-25 08:03:25 +02:00
@defer.inlineCallbacks
def start(self):
2018-06-08 05:47:46 +02:00
if not os.path.exists(self.path):
os.mkdir(self.path)
yield self.db.start()
2018-05-25 08:03:25 +02:00
first_connection = self.network.on_connected.first
self.network.start()
yield first_connection
self.headers.touch()
yield self.update_headers()
yield self.network.subscribe_headers()
yield self.update_accounts()
def stop(self):
return self.network.stop()
@execute_serially
@defer.inlineCallbacks
def update_headers(self):
while True:
height_sought = len(self.headers)
headers = yield self.network.get_headers(height_sought)
print("received {} headers starting at {} height".format(headers['count'], height_sought))
#log.info("received {} headers starting at {} height".format(headers['count'], height_sought))
if headers['count'] <= 0:
break
yield self.headers.connect(height_sought, unhexlify(headers['hex']))
@defer.inlineCallbacks
def process_header(self, response):
header = response[0]
if self.update_headers.is_running:
return
if header['height'] == len(self.headers):
# New header from network directly connects after the last local header.
yield self.headers.connect(len(self.headers), unhexlify(header['hex']))
elif header['height'] > len(self.headers):
# New header is several heights ahead of local, do download instead.
yield self.update_headers()
@execute_serially
def update_accounts(self):
return defer.DeferredList([
self.update_account(a) for a in self.accounts
])
@defer.inlineCallbacks
2018-06-12 16:02:04 +02:00
def update_account(self, account): # type: (baseaccount.BaseAccount) -> defer.Defferred
2018-05-25 08:03:25 +02:00
# Before subscribing, download history for any addresses that don't have any,
# this avoids situation where we're getting status updates to addresses we know
# need to update anyways. Continue to get history and create more addresses until
# all missing addresses are created and history for them is fully restored.
2018-06-12 16:02:04 +02:00
yield account.ensure_address_gap()
addresses = yield account.get_unused_addresses()
2018-05-25 08:03:25 +02:00
while addresses:
yield defer.DeferredList([
self.update_history(a) for a in addresses
])
2018-06-12 16:02:04 +02:00
addresses = yield account.ensure_address_gap()
2018-05-25 08:03:25 +02:00
# By this point all of the addresses should be restored and we
# can now subscribe all of them to receive updates.
2018-06-12 16:02:04 +02:00
all_addresses = yield account.get_addresses()
yield defer.DeferredList(
list(map(self.subscribe_history, all_addresses))
)
2018-06-08 05:47:46 +02:00
2018-05-25 08:03:25 +02:00
@defer.inlineCallbacks
2018-06-12 16:02:04 +02:00
def update_history(self, address):
remote_history = yield self.network.get_history(address)
local = yield self.get_local_history(address)
history_parts = []
for i, (hash, height) in enumerate(map(itemgetter('tx_hash', 'height'), remote_history)):
history_parts.append('{}:{}:'.format(hash.decode(), height))
if i < len(local) and local[i] == (hash, height):
continue
raw = yield self.network.get_transaction(hash)
transaction = self.transaction_class(unhexlify(raw))
yield self.add_transaction(address, transaction, height)
yield self.db.set_address_history(
address, ''.join(history_parts).encode()
)
2018-05-25 08:03:25 +02:00
@defer.inlineCallbacks
def subscribe_history(self, address):
2018-06-08 05:47:46 +02:00
remote_status = yield self.network.subscribe_address(address)
2018-06-12 16:02:04 +02:00
local_status = yield self.get_local_status(address)
2018-06-08 05:47:46 +02:00
if local_status != remote_status:
2018-06-12 16:02:04 +02:00
yield self.update_history(address)
2018-05-25 08:03:25 +02:00
2018-06-08 05:47:46 +02:00
@defer.inlineCallbacks
2018-05-25 08:03:25 +02:00
def process_status(self, response):
2018-06-08 05:47:46 +02:00
address, remote_status = response
2018-06-12 16:02:04 +02:00
local_status = yield self.get_local_status(address)
2018-06-08 05:47:46 +02:00
if local_status != remote_status:
2018-06-12 16:02:04 +02:00
yield self.update_history(address)
2018-05-25 08:03:25 +02:00
def broadcast(self, tx):
return self.network.broadcast(hexlify(tx.raw))