# 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, **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