lbry-sdk/lbry/wallet/wallet.py

# pylint: disable=arguments-differ
import os
import json
import zlib
import asyncio
import logging
from datetime import datetime
from typing import Awaitable, Callable, List, Tuple, Optional, Iterable, Union
from hashlib import sha256
from operator import attrgetter
from decimal import Decimal


from lbry.db import Database, SPENDABLE_TYPE_CODES, Result
from lbry.blockchain.ledger import Ledger
from lbry.constants import COIN, NULL_HASH32
from lbry.blockchain.transaction import Transaction, Input, Output
from lbry.blockchain.dewies import dewies_to_lbc
from lbry.crypto.crypt import better_aes_encrypt, better_aes_decrypt
from lbry.crypto.bip32 import PubKey, PrivateKey
from lbry.schema.claim import Claim
from lbry.schema.purchase import Purchase
from lbry.error import InsufficientFundsError, KeyFeeAboveMaxAllowedError
from lbry.stream.managed_stream import ManagedStream

from .account import Account, SingleKey, HierarchicalDeterministic
from .coinselection import CoinSelector, OutputEffectiveAmountEstimator
from .storage import WalletStorage
from .preferences import TimestampedPreferences


log = logging.getLogger(__name__)

ENCRYPT_ON_DISK = 'encrypt-on-disk'


class Wallet:
    """ The primary role of Wallet is to encapsulate a collection
        of accounts (seed/private keys) and the spending rules / settings
        for the coins attached to those accounts. Wallets are represented
        by physical files on the filesystem.
    """

    def __init__(self, ledger: Ledger, db: Database, name: str, storage: WalletStorage, preferences: dict):
        self.ledger = ledger
        self.db = db
        self.name = name
        self.storage = storage
        self.preferences = TimestampedPreferences(preferences or {})
        self.encryption_password: Optional[str] = None
        self.id = self.get_id()

        self.utxo_lock = asyncio.Lock()

        self.accounts = AccountListManager(self)
        self.claims = ClaimListManager(self)
        self.streams = StreamListManager(self)
        self.channels = ChannelListManager(self)
        self.collections = CollectionListManager(self)
        self.purchases = PurchaseListManager(self)
        self.supports = SupportListManager(self)

    def get_id(self):
        return os.path.basename(self.storage.path) if self.storage.path else self.name

    @classmethod
    async def create(
            cls, ledger: Ledger, db: Database, path: str, name: str,
            create_account=False, language='en', single_key=False):
        wallet = cls(ledger, db, name, WalletStorage(path), {})
        if create_account:
            await wallet.accounts.generate(language=language, address_generator={
                'name': SingleKey.name if single_key else HierarchicalDeterministic.name
            })
        await wallet.save()
        return wallet

    @classmethod
    async def from_path(cls, ledger: Ledger, db: Database, path: str):
        return await cls.from_storage(ledger, db, WalletStorage(path))

    @classmethod
    async def from_storage(cls, ledger: Ledger, db: Database, storage: WalletStorage) -> 'Wallet':
        json_dict = await storage.read()
        if 'ledger' in json_dict and json_dict['ledger'] != ledger.get_id():
            raise ValueError(
                f"Using ledger {ledger.get_id()} but wallet is {json_dict['ledger']}."
            )
        wallet = cls(
            ledger, db,
            name=json_dict.get('name', 'Wallet'),
            storage=storage,
            preferences=json_dict.get('preferences', {}),
        )
        for account_dict in json_dict.get('accounts', []):
            await wallet.accounts.add_from_dict(account_dict)
        return wallet

    def to_dict(self, encrypt_password: str = None):
        return {
            'version': WalletStorage.VERSION,
            'ledger': self.ledger.get_id(),
            'name': self.name,
            'preferences': self.preferences.data,
            'accounts': [a.to_dict(encrypt_password) for a in self.accounts]
        }

    async def save(self):
        if self.preferences.get(ENCRYPT_ON_DISK, False):
            if self.encryption_password is not None:
                return await self.storage.write(self.to_dict(encrypt_password=self.encryption_password))
            elif not self.is_locked:
                log.warning(
                    "Disk encryption requested but no password available for encryption. "
                    "Saving wallet in an unencrypted state."
                )
        return await self.storage.write(self.to_dict())

    @property
    def hash(self) -> bytes:
        h = sha256()
        if self.preferences.get(ENCRYPT_ON_DISK, False):
            assert self.encryption_password is not None, \
                "Encryption is enabled but no password is available, cannot generate hash."
            h.update(self.encryption_password.encode())
        h.update(self.preferences.hash)
        for account in sorted(self.accounts, key=attrgetter('id')):
            h.update(account.hash)
        return h.digest()

    def pack(self, password):
        assert not self.is_locked, "Cannot pack a wallet with locked/encrypted accounts."
        new_data = json.dumps(self.to_dict())
        new_data_compressed = zlib.compress(new_data.encode())
        return better_aes_encrypt(password, new_data_compressed)

    @classmethod
    def unpack(cls, password, encrypted):
        decrypted = better_aes_decrypt(password, encrypted)
        decompressed = zlib.decompress(decrypted)
        return json.loads(decompressed)

    async def merge(self, password: str, data: str) -> List[Account]:
        assert not self.is_locked, "Cannot sync apply on a locked wallet."
        added_accounts = []
        decrypted_data = self.unpack(password, data)
        self.preferences.merge(decrypted_data.get('preferences', {}))
        for account_dict in decrypted_data['accounts']:
            _, _, pubkey = await Account.keys_from_dict(self.ledger, account_dict)
            account_id = pubkey.address
            local_match = None
            for local_account in self.accounts:
                if account_id == local_account.id:
                    local_match = local_account
                    break
            if local_match is not None:
                local_match.merge(account_dict)
            else:
                added_accounts.append(
                    self.accounts.add_from_dict(account_dict)
                )
        return added_accounts

    @property
    def is_locked(self) -> bool:
        for account in self.accounts:
            if account.encrypted:
                return True
        return False

    def unlock(self, password):
        for account in self.accounts:
            if account.encrypted:
                if not account.decrypt(password):
                    return False
        self.encryption_password = password
        return True

    def lock(self):
        assert self.encryption_password is not None, "Cannot lock an unencrypted wallet, encrypt first."
        for account in self.accounts:
            if not account.encrypted:
                account.encrypt(self.encryption_password)
        return True

    @property
    def is_encrypted(self) -> bool:
        return self.is_locked or self.preferences.get(ENCRYPT_ON_DISK, False)

    async def decrypt(self):
        assert not self.is_locked, "Cannot decrypt a locked wallet, unlock first."
        self.preferences[ENCRYPT_ON_DISK] = False
        await self.save()
        return True

    async def encrypt(self, password):
        assert not self.is_locked, "Cannot re-encrypt a locked wallet, unlock first."
        assert password, "Cannot encrypt with blank password."
        self.encryption_password = password
        self.preferences[ENCRYPT_ON_DISK] = True
        await self.save()
        return True

    @property
    def has_accounts(self):
        return len(self.accounts) > 0

    async def _get_account_and_address_info_for_address(self, address):
        match = await self.db.get_address(accounts=self.accounts, address=address)
        if match:
            for account in self.accounts:
                if match['account'] == account.public_key.address:
                    return account, match

    async def get_private_key_for_address(self, address) -> Optional[PrivateKey]:
        match = await self._get_account_and_address_info_for_address(address)
        if match:
            account, address_info = match
            return account.get_private_key(address_info['chain'], address_info['pubkey'].n)
        return None

    async def get_public_key_for_address(self, address) -> Optional[PubKey]:
        match = await self._get_account_and_address_info_for_address(address)
        if match:
            _, address_info = match
            return address_info['pubkey']
        return None

    async def get_account_for_address(self, address):
        match = await self._get_account_and_address_info_for_address(address)
        if match:
            return match[0]

    async def save_max_gap(self):
        gap_changed = False
        for account in self.accounts:
            if await account.save_max_gap():
                gap_changed = True
        if gap_changed:
            await self.save()

    async def get_effective_amount_estimators(self, funding_accounts: Iterable[Account]):
        estimators = []
        utxos = await self.db.get_utxos(
            accounts=funding_accounts,
            txo_type__in=SPENDABLE_TYPE_CODES
        )
        for utxo in utxos:
            estimators.append(OutputEffectiveAmountEstimator(self.ledger, utxo))
        return estimators

    async def get_spendable_utxos(self, amount: int, funding_accounts: Iterable[Account]):
        async with self.utxo_lock:
            txos = await self.get_effective_amount_estimators(funding_accounts)
            fee = Output.pay_pubkey_hash(COIN, NULL_HASH32).get_fee(self.ledger)
            selector = CoinSelector(amount, fee)
            spendables = selector.select(txos, self.ledger.coin_selection_strategy)
            if spendables:
                await self.db.reserve_outputs(s.txo for s in spendables)
            return spendables

    async def list_transactions(self, **constraints):
        return txs_to_dict(await self.db.get_transactions(
            include_is_my_output=True, include_is_spent=True,
            **constraints
        ), self.ledger)

    async def create_transaction(
            self, inputs: Iterable[Input], outputs: Iterable[Output],
            funding_accounts: Iterable[Account], change_account: Account):
        """ Find optimal set of inputs when only outputs are provided; add change
            outputs if only inputs are provided or if inputs are greater than outputs. """

        tx = Transaction() \
            .add_inputs(inputs) \
            .add_outputs(outputs)

        # value of the outputs plus associated fees
        cost = (
            tx.get_base_fee(self.ledger) +
            tx.get_total_output_sum(self.ledger)
        )
        # value of the inputs less the cost to spend those inputs
        payment = tx.get_effective_input_sum(self.ledger)

        try:

            for _ in range(5):

                if payment < cost:
                    deficit = cost - payment
                    spendables = await self.get_spendable_utxos(deficit, funding_accounts)
                    if not spendables:
                        raise InsufficientFundsError()
                    payment += sum(s.effective_amount for s in spendables)
                    tx.add_inputs(s.txi for s in spendables)

                cost_of_change = (
                    tx.get_base_fee(self.ledger) +
                    Output.pay_pubkey_hash(COIN, NULL_HASH32).get_fee(self.ledger)
                )
                if payment > cost:
                    change = payment - cost
                    if change > cost_of_change:
                        change_address = await change_account.change.get_or_create_usable_address()
                        change_hash160 = change_account.ledger.address_to_hash160(change_address)
                        change_amount = change - cost_of_change
                        change_output = Output.pay_pubkey_hash(change_amount, change_hash160)
                        change_output.is_internal_transfer = True
                        tx.add_outputs([Output.pay_pubkey_hash(change_amount, change_hash160)])

                if tx._outputs:
                    break
                # this condition and the outer range(5) loop cover an edge case
                # whereby a single input is just enough to cover the fee and
                # has some change left over, but the change left over is less
                # than the cost_of_change: thus the input is completely
                # consumed and no output is added, which is an invalid tx.
                # to be able to spend this input we must increase the cost
                # of the TX and run through the balance algorithm a second time
                # adding an extra input and change output, making tx valid.
                # we do this 5 times in case the other UTXOs added are also
                # less than the fee, after 5 attempts we give up and go home
                cost += cost_of_change + 1

        except Exception as e:
            await self.db.release_tx(tx)
            raise e

        return tx

    async def sign(self, tx):
        for i, txi in enumerate(tx._inputs):
            assert txi.script is not None
            assert txi.txo_ref.txo is not None
            txo_script = txi.txo_ref.txo.script
            if txo_script.is_pay_pubkey_hash:
                address = self.ledger.hash160_to_address(txo_script.values['pubkey_hash'])
                private_key = await self.get_private_key_for_address(address)
                assert private_key is not None, 'Cannot find private key for signing output.'
                serialized = tx._serialize_for_signature(i)
                txi.script.values['signature'] = \
                    private_key.sign(serialized) + bytes((tx.signature_hash_type(1),))
                txi.script.values['pubkey'] = private_key.public_key.pubkey_bytes
                txi.script.generate()
            else:
                raise NotImplementedError("Don't know how to spend this output.")
        tx._reset()

    async def pay(self, amount: int, address: bytes, funding_accounts: List[Account], change_account: Account):
        output = Output.pay_pubkey_hash(amount, self.ledger.address_to_hash160(address))
        return await self.create_transaction([], [output], funding_accounts, change_account)

    async def fund(self, from_account, to_account, amount=None, everything=False,
                   outputs=1, broadcast=False, **constraints):
        assert self.ledger == to_account.ledger, 'Can only transfer between accounts of the same ledger.'
        if everything:
            utxos = await self.db.get_utxos(**constraints)
            await self.db.reserve_outputs(utxos)
            tx = await self.create_transaction(
                inputs=[Input.spend(txo) for txo in utxos],
                outputs=[],
                funding_accounts=[from_account],
                change_account=to_account
            )
        elif amount > 0:
            to_address = await to_account.change.get_or_create_usable_address()
            to_hash160 = to_account.ledger.address_to_hash160(to_address)
            tx = await self.create_transaction(
                inputs=[],
                outputs=[
                    Output.pay_pubkey_hash(amount//outputs, to_hash160)
                    for _ in range(outputs)
                ],
                funding_accounts=[from_account],
                change_account=from_account
            )
        else:
            raise ValueError('An amount is required.')

        return tx

    async def _report_state(self):
        try:
            for account in self.accounts:
                balance = dewies_to_lbc(await account.get_balance(include_claims=True))
                _, channel_count = await account.get_channels(limit=1)
                claim_count = await account.get_claim_count()
                if isinstance(account.receiving, SingleKey):
                    log.info("Loaded single key account %s with %s LBC. "
                             "%d channels, %d certificates and %d claims",
                             account.id, balance, channel_count, len(account.channel_keys), claim_count)
                else:
                    total_receiving = len(await account.receiving.get_addresses())
                    total_change = len(await account.change.get_addresses())
                    log.info("Loaded account %s with %s LBC, %d receiving addresses (gap: %d), "
                             "%d change addresses (gap: %d), %d channels, %d certificates and %d claims. ",
                             account.id, balance, total_receiving, account.receiving.gap, total_change,
                             account.change.gap, channel_count, len(account.channel_keys), claim_count)
        except Exception as err:
            if isinstance(err, asyncio.CancelledError):  # TODO: remove when updated to 3.8
                raise
            log.exception(
                'Failed to display wallet state, please file issue '
                'for this bug along with the traceback you see below:')

    async def verify_duplicate(self, name: str, allow_duplicate: bool):
        if not allow_duplicate:
            claims = await self.claims.list(claim_name=name)
            if len(claims) > 0:
                raise Exception(
                    f"You already have a claim published under the name '{name}'. "
                    f"Use --allow-duplicate-name flag to override."
                )


class AccountListManager:
    __slots__ = 'wallet', '_accounts'

    def __init__(self, wallet: Wallet):
        self.wallet = wallet
        self._accounts: List[Account] = []

    def __len__(self):
        return self._accounts.__len__()

    def __iter__(self):
        return self._accounts.__iter__()

    def __getitem__(self, account_id: str) -> Account:
        for account in self:
            if account.id == account_id:
                return account
        raise ValueError(f"Couldn't find account: {account_id}.")

    @property
    def default(self) -> Optional[Account]:
        for account in self:
            return account

    async def generate(self, name: str = None, language: str = 'en', address_generator: dict = None) -> Account:
        account = await Account.generate(
            self.wallet.ledger, self.wallet.db, name, language, address_generator
        )
        self._accounts.append(account)
        return account

    async def add_from_dict(self, account_dict: dict) -> Account:
        account = await Account.from_dict(self.wallet.ledger, self.wallet.db, account_dict)
        self._accounts.append(account)
        return account

    async def remove(self, account_id: str) -> Account:
        account = self[account_id]
        self._accounts.remove(account)
        await self.wallet.save()
        return account

    def get_or_none(self, account_id: str) -> Optional[Account]:
        if account_id is not None:
            return self[account_id]

    def get_or_default(self, account_id: str) -> Optional[Account]:
        if account_id is None:
            return self.default
        return self[account_id]

    def get_or_all(self, account_ids: Union[List[str], str]) -> List[Account]:
        if account_ids and isinstance(account_ids, str):
            account_ids = [account_ids]
        return [self[account_id] for account_id in account_ids] if account_ids else self._accounts

    async def get_account_details(self, **kwargs):
        accounts = []
        for i, account in enumerate(self._accounts):
            details = await account.get_details(**kwargs)
            details['is_default'] = i == 0
            accounts.append(details)
        return accounts


class BaseListManager:
    __slots__ = 'wallet',

    def __init__(self, wallet: Wallet):
        self.wallet = wallet

    async def create(self, *args, **kwargs) -> Transaction:
        raise NotImplementedError

    async def delete(self, **constraints) -> Transaction:
        raise NotImplementedError

    async def list(self, **constraints) -> Tuple[List[Output], Optional[int]]:
        raise NotImplementedError

    async def get(self, **constraints) -> Output:
        raise NotImplementedError

    async def get_or_none(self, **constraints) -> Optional[Output]:
        raise NotImplementedError


class ClaimListManager(BaseListManager):
    name = 'claim'
    __slots__ = ()

    async def _create(
            self, name: str, claim: Claim, amount: int, holding_address: str,
            funding_accounts: List[Account], change_account: Account,
            signing_channel: Output = None) -> Transaction:
        txo = Output.pay_claim_name_pubkey_hash(
            amount, name, claim, self.wallet.ledger.address_to_hash160(holding_address)
        )
        if signing_channel is not None:
            txo.sign(signing_channel, b'placeholder txid:nout')
        tx = await self.wallet.create_transaction(
            [], [txo], funding_accounts, change_account
        )
        return tx

    async def create(
            self, name: str, claim: Claim, amount: int, holding_address: str,
            funding_accounts: List[Account], change_account: Account,
            signing_channel: Output = None) -> Transaction:
        tx = await self._create(
            name, claim, amount, holding_address,
            funding_accounts, change_account,
            signing_channel
        )
        txo = tx.outputs[0]
        if signing_channel is not None:
            txo.sign(signing_channel)
        await self.wallet.sign(tx)
        return tx

    async def update(
            self, previous_claim: Output, claim: Claim, amount: int, holding_address: str,
            funding_accounts: List[Account], change_account: Account,
            signing_channel: Output = None) -> Transaction:
        updated_claim = Output.pay_update_claim_pubkey_hash(
            amount, previous_claim.claim_name, previous_claim.claim_id,
            claim, self.wallet.ledger.address_to_hash160(holding_address)
        )
        if signing_channel is not None:
            updated_claim.sign(signing_channel, b'placeholder txid:nout')
        else:
            updated_claim.clear_signature()
        return await self.wallet.create_transaction(
            [Input.spend(previous_claim)], [updated_claim], funding_accounts, change_account, sign=False
        )

    async def delete(self, claim_id=None, txid=None, nout=None):
        claim = await self.get(claim_id=claim_id, txid=txid, nout=nout)
        return await self.wallet.create_transaction(
            [Input.spend(claim)], [], self.wallet._accounts, self.wallet._accounts[0]
        )

    async def list(self, **constraints) -> Result[Output]:
        return await self.wallet.db.get_claims(wallet=self.wallet, **constraints)

    async def get(self, claim_id=None, claim_name=None, txid=None, nout=None) -> Output:
        if txid is not None and nout is not None:
            key, value, constraints = 'txid:nout', f'{txid}:{nout}', {'tx_hash': '', 'position': nout}
        elif claim_id is not None:
            key, value, constraints = 'id', claim_id, {'claim_id': claim_id}
        elif claim_name is not None:
            key, value, constraints = 'name', claim_name, {'claim_name': claim_name}
        else:
            raise ValueError(f"Couldn't find {self.name} because an {self.name}_id or name was not provided.")
        claims = await self.list(**constraints)
        if len(claims) == 1:
            return claims[0]
        elif len(claims) > 1:
            raise ValueError(
                f"Multiple {self.name}s found with {key} '{value}', "
                f"pass a {self.name}_id to narrow it down."
            )
        raise ValueError(f"Couldn't find {self.name} with {key} '{value}'.")

    async def get_or_none(self, claim_id=None, claim_name=None, txid=None, nout=None) -> Optional[Output]:
        if any((claim_id, claim_name, all((txid, nout)))):
            return await self.get(claim_id, claim_name, txid, nout)


class ChannelListManager(ClaimListManager):
    name = 'channel'
    __slots__ = ()

    async def create(
            self, name: str, amount: int, holding_account: Account,
            funding_accounts: List[Account], save_key=True, **kwargs) -> Transaction:

        holding_address = await holding_account.receiving.get_or_create_usable_address()

        claim = Claim()
        claim.channel.update(**kwargs)
        txo = Output.pay_claim_name_pubkey_hash(
            amount, name, claim, self.wallet.ledger.address_to_hash160(holding_address)
        )

        await txo.generate_channel_private_key()

        tx = await self.wallet.create_transaction(
            [], [txo], funding_accounts, funding_accounts[0]
        )

        await self.wallet.sign(tx)

        if save_key:
            holding_account.add_channel_private_key(txo.private_key)
            await self.wallet.save()

        return tx

    async def update(
            self, old: Output, amount: int, new_signing_key: bool, replace: bool,
            holding_account: Account, funding_accounts: List[Account],
            save_key=True, **kwargs) -> Transaction:

        moving_accounts = False
        holding_address = old.get_address(self.wallet.ledger)
        if holding_account:
            old_account = await self.wallet.get_account_for_address(holding_address)
            if holding_account.id != old_account.id:
                holding_address = await holding_account.receiving.get_or_create_usable_address()
                moving_accounts = True
        elif new_signing_key:
            holding_account = await self.wallet.get_account_for_address(holding_address)

        if replace:
            claim = Claim()
            claim.channel.public_key_bytes = old.claim.channel.public_key_bytes
        else:
            claim = Claim.from_bytes(old.claim.to_bytes())
        claim.channel.update(**kwargs)

        txo = Output.pay_update_claim_pubkey_hash(
            amount, old.claim_name, old.claim_id, claim,
            self.wallet.ledger.address_to_hash160(holding_address)
        )

        if new_signing_key:
            await txo.generate_channel_private_key()
        else:
            txo.private_key = old.private_key

        tx = await self.wallet.create_transaction(
            [Input.spend(old)], [txo], funding_accounts, funding_accounts[0]
        )

        await self.wallet.sign(tx)

        if any((new_signing_key, moving_accounts)) and save_key:
            holding_account.add_channel_private_key(txo.private_key)
            await self.wallet.save()

        return tx

    async def list(self, **constraints) -> Result[Output]:
        return await self.wallet.db.get_channels(wallet=self.wallet, **constraints)

    async def get_for_signing(self, channel_id=None, channel_name=None) -> Output:
        channel = await self.get(claim_id=channel_id, claim_name=channel_name)
        if not channel.has_private_key:
            raise Exception(
                f"Couldn't find private key for channel '{channel.claim_name}', "
                f"can't use channel for signing. "
            )
        return channel

    async def get_for_signing_or_none(self, channel_id=None, channel_name=None) -> Optional[Output]:
        if channel_id or channel_name:
            return await self.get_for_signing(channel_id, channel_name)


class StreamListManager(ClaimListManager):
    __slots__ = ()

    async def create(
            self, name: str, amount: int, file_path: str,
            create_file_stream: Callable[[str], Awaitable[ManagedStream]],
            holding_address: str, funding_accounts: List[Account],
            signing_channel: Optional[Output] = None,
            preview=False, **kwargs) -> Tuple[Transaction, ManagedStream]:

        claim = Claim()
        claim.stream.update(file_path=file_path, sd_hash='0' * 96, **kwargs)

        # before creating file stream, create TX to ensure we have enough LBC
        tx = await self._create(
            name, claim, amount, holding_address,
            funding_accounts, funding_accounts[0],
            signing_channel
        )
        txo = tx.outputs[0]

        file_stream = None
        try:

            # we have enough LBC to create TX, now try create the file stream
            if not preview:
                file_stream = await create_file_stream(file_path)
                claim.stream.source.sd_hash = file_stream.sd_hash
                txo.script.generate()

            # creating TX and file stream was successful, now sign all the things
            if signing_channel is not None:
                txo.sign(signing_channel)
            await self.wallet.sign(tx)

        except Exception as e:
            # creating file stream or something else went wrong, release txos
            await self.wallet.db.release_tx(tx)
            raise e

        return tx, file_stream

    async def list(self, **constraints) -> Result[Output]:
        return await self.wallet.db.get_streams(wallet=self.wallet, **constraints)


class CollectionListManager(ClaimListManager):
    __slots__ = ()

    async def create(
            self, name: str, amount: int, holding_address: str, funding_accounts: List[Account],
            channel: Optional[Output] = None, **kwargs) -> Transaction:
        claim = Claim()
        claim.collection.update(**kwargs)
        return await super().create(
            name, claim, amount, holding_address, funding_accounts, funding_accounts[0], channel
        )

    async def list(self, **constraints) -> Result[Output]:
        return await self.wallet.db.get_collections(wallet=self.wallet, **constraints)


class SupportListManager(BaseListManager):
    __slots__ = ()

    async def create(self, name: str, claim_id: str, amount: int, holding_address: str,
                     funding_accounts: List[Account], change_account: Account) -> Transaction:
        support_output = Output.pay_support_pubkey_hash(
            amount, name, claim_id, self.wallet.ledger.address_to_hash160(holding_address)
        )
        return await self.wallet.create_transaction(
            [], [support_output], funding_accounts, change_account
        )

    async def list(self, **constraints) -> Result[Output]:
        return await self.wallet.db.get_supports(**constraints)

    async def get(self, **constraints) -> Output:
        raise NotImplementedError

    async def get_or_none(self, **constraints) -> Optional[Output]:
        raise NotImplementedError


class PurchaseListManager(BaseListManager):
    __slots__ = ()

    async def create(self, name: str, claim_id: str, amount: int, holding_address: str,
                     funding_accounts: List[Account], change_account: Account) -> Transaction:
        support_output = Output.pay_support_pubkey_hash(
            amount, name, claim_id, self.wallet.ledger.address_to_hash160(holding_address)
        )
        return await self.wallet.create_transaction(
            [], [support_output], funding_accounts, change_account
        )

    def purchase(self, claim_id: str, amount: int, merchant_address: bytes,
                 funding_accounts: List['Account'], change_account: 'Account'):
        payment = Output.pay_pubkey_hash(amount, self.wallet.ledger.address_to_hash160(merchant_address))
        data = Output.add_purchase_data(Purchase(claim_id))
        return self.wallet.create_transaction(
            [], [payment, data], funding_accounts, change_account
        )

    async def create_purchase_transaction(
            self, accounts: List[Account], txo: Output, exchange: 'ExchangeRateManager',
            override_max_key_fee=False):
        fee = txo.claim.stream.fee
        fee_amount = exchange.to_dewies(fee.currency, fee.amount)
        if not override_max_key_fee and self.wallet.ledger.conf.max_key_fee:
            max_fee = self.wallet.ledger.conf.max_key_fee
            max_fee_amount = exchange.to_dewies(max_fee['currency'], Decimal(max_fee['amount']))
            if max_fee_amount and fee_amount > max_fee_amount:
                error_fee = f"{dewies_to_lbc(fee_amount)} LBC"
                if fee.currency != 'LBC':
                    error_fee += f" ({fee.amount} {fee.currency})"
                error_max_fee = f"{dewies_to_lbc(max_fee_amount)} LBC"
                if max_fee['currency'] != 'LBC':
                    error_max_fee += f" ({max_fee['amount']} {max_fee['currency']})"
                raise KeyFeeAboveMaxAllowedError(
                    f"Purchase price of {error_fee} exceeds maximum "
                    f"configured price of {error_max_fee}."
                )
        fee_address = fee.address or txo.get_address(self.wallet.ledger)
        return await self.purchase(
            txo.claim_id, fee_amount, fee_address, accounts, accounts[0]
        )

    async def list(self, **constraints) -> Result[Output]:
        return await self.wallet.db.get_purchases(**constraints)

    async def get(self, **constraints) -> Output:
        raise NotImplementedError

    async def get_or_none(self, **constraints) -> Optional[Output]:
        raise NotImplementedError


def txs_to_dict(txs, ledger):
    history = []
    for tx in txs:  # pylint: disable=too-many-nested-blocks
        ts = ledger.headers.estimated_timestamp(tx.height)
        item = {
            'txid': tx.id,
            'timestamp': ts,
            'date': datetime.fromtimestamp(ts).isoformat(' ')[:-3] if tx.height > 0 else None,
            'confirmations': (ledger.headers.height + 1) - tx.height if tx.height > 0 else 0,
            'claim_info': [],
            'update_info': [],
            'support_info': [],
            'abandon_info': [],
            'purchase_info': []
        }
        is_my_inputs = all([txi.is_my_input for txi in tx.inputs])
        if is_my_inputs:
            # fees only matter if we are the ones paying them
            item['value'] = dewies_to_lbc(tx.net_account_balance + tx.fee)
            item['fee'] = dewies_to_lbc(-tx.fee)
        else:
            # someone else paid the fees
            item['value'] = dewies_to_lbc(tx.net_account_balance)
            item['fee'] = '0.0'
        for txo in tx.my_claim_outputs:
            item['claim_info'].append({
                'address': txo.get_address(ledger),
                'balance_delta': dewies_to_lbc(-txo.amount),
                'amount': dewies_to_lbc(txo.amount),
                'claim_id': txo.claim_id,
                'claim_name': txo.claim_name,
                'nout': txo.position,
                'is_spent': txo.is_spent,
            })
        for txo in tx.my_update_outputs:
            if is_my_inputs:  # updating my own claim
                previous = None
                for txi in tx.inputs:
                    if txi.txo_ref.txo is not None:
                        other_txo = txi.txo_ref.txo
                        if (other_txo.is_claim or other_txo.script.is_support_claim) \
                                and other_txo.claim_id == txo.claim_id:
                            previous = other_txo
                            break
                if previous is not None:
                    item['update_info'].append({
                        'address': txo.get_address(ledger),
                        'balance_delta': dewies_to_lbc(previous.amount - txo.amount),
                        'amount': dewies_to_lbc(txo.amount),
                        'claim_id': txo.claim_id,
                        'claim_name': txo.claim_name,
                        'nout': txo.position,
                        'is_spent': txo.is_spent,
                    })
            else:  # someone sent us their claim
                item['update_info'].append({
                    'address': txo.get_address(ledger),
                    'balance_delta': dewies_to_lbc(0),
                    'amount': dewies_to_lbc(txo.amount),
                    'claim_id': txo.claim_id,
                    'claim_name': txo.claim_name,
                    'nout': txo.position,
                    'is_spent': txo.is_spent,
                })
        for txo in tx.my_support_outputs:
            item['support_info'].append({
                'address': txo.get_address(ledger),
                'balance_delta': dewies_to_lbc(txo.amount if not is_my_inputs else -txo.amount),
                'amount': dewies_to_lbc(txo.amount),
                'claim_id': txo.claim_id,
                'claim_name': txo.claim_name,
                'is_tip': not is_my_inputs,
                'nout': txo.position,
                'is_spent': txo.is_spent,
            })
        if is_my_inputs:
            for txo in tx.other_support_outputs:
                item['support_info'].append({
                    'address': txo.get_address(ledger),
                    'balance_delta': dewies_to_lbc(-txo.amount),
                    'amount': dewies_to_lbc(txo.amount),
                    'claim_id': txo.claim_id,
                    'claim_name': txo.claim_name,
                    'is_tip': is_my_inputs,
                    'nout': txo.position,
                    'is_spent': txo.is_spent,
                })
        for txo in tx.my_abandon_outputs:
            item['abandon_info'].append({
                'address': txo.get_address(ledger),
                'balance_delta': dewies_to_lbc(txo.amount),
                'amount': dewies_to_lbc(txo.amount),
                'claim_id': txo.claim_id,
                'claim_name': txo.claim_name,
                'nout': txo.position
            })
        for txo in tx.any_purchase_outputs:
            item['purchase_info'].append({
                'address': txo.get_address(ledger),
                'balance_delta': dewies_to_lbc(txo.amount if not is_my_inputs else -txo.amount),
                'amount': dewies_to_lbc(txo.amount),
                'claim_id': txo.purchased_claim_id,
                'nout': txo.position,
                'is_spent': txo.is_spent,
            })
        history.append(item)
    return history