forked from LBRYCommunity/lbry-sdk
182 lines
7.4 KiB
Python
182 lines
7.4 KiB
Python
import json
|
|
import logging
|
|
from functools import partial
|
|
from hashlib import sha256
|
|
from string import hexdigits
|
|
|
|
import ecdsa
|
|
from lbry.wallet.constants import CLAIM_TYPES, TXO_TYPES
|
|
|
|
from lbry.wallet.client.baseaccount import BaseAccount, HierarchicalDeterministic
|
|
|
|
|
|
log = logging.getLogger(__name__)
|
|
|
|
|
|
def validate_claim_id(claim_id):
|
|
if not len(claim_id) == 40:
|
|
raise Exception("Incorrect claimid length: %i" % len(claim_id))
|
|
if isinstance(claim_id, bytes):
|
|
claim_id = claim_id.decode('utf-8')
|
|
if set(claim_id).difference(hexdigits):
|
|
raise Exception("Claim id is not hex encoded")
|
|
|
|
|
|
class Account(BaseAccount):
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
super().__init__(*args, **kwargs)
|
|
self.channel_keys = {}
|
|
|
|
@property
|
|
def hash(self) -> bytes:
|
|
h = sha256(json.dumps(self.to_dict(include_channel_keys=False)).encode())
|
|
for cert in sorted(self.channel_keys.keys()):
|
|
h.update(cert.encode())
|
|
return h.digest()
|
|
|
|
def merge(self, d: dict):
|
|
super().merge(d)
|
|
self.channel_keys.update(d.get('certificates', {}))
|
|
|
|
def add_channel_private_key(self, private_key):
|
|
public_key_bytes = private_key.get_verifying_key().to_der()
|
|
channel_pubkey_hash = self.ledger.public_key_to_address(public_key_bytes)
|
|
self.channel_keys[channel_pubkey_hash] = private_key.to_pem().decode()
|
|
|
|
def get_channel_private_key(self, public_key_bytes):
|
|
channel_pubkey_hash = self.ledger.public_key_to_address(public_key_bytes)
|
|
private_key_pem = self.channel_keys.get(channel_pubkey_hash)
|
|
if private_key_pem:
|
|
return ecdsa.SigningKey.from_pem(private_key_pem, hashfunc=sha256)
|
|
|
|
async def maybe_migrate_certificates(self):
|
|
if not self.channel_keys:
|
|
return
|
|
channel_keys = {}
|
|
for private_key_pem in self.channel_keys.values():
|
|
if not isinstance(private_key_pem, str):
|
|
continue
|
|
if "-----BEGIN EC PRIVATE KEY-----" not in private_key_pem:
|
|
continue
|
|
private_key = ecdsa.SigningKey.from_pem(private_key_pem, hashfunc=sha256)
|
|
public_key_der = private_key.get_verifying_key().to_der()
|
|
channel_keys[self.ledger.public_key_to_address(public_key_der)] = private_key_pem
|
|
if self.channel_keys != channel_keys:
|
|
self.channel_keys = channel_keys
|
|
self.wallet.save()
|
|
|
|
async def save_max_gap(self):
|
|
if issubclass(self.address_generator, HierarchicalDeterministic):
|
|
gap = await self.get_max_gap()
|
|
gap_changed = False
|
|
new_receiving_gap = max(20, gap['max_receiving_gap'] + 1)
|
|
if self.receiving.gap != new_receiving_gap:
|
|
self.receiving.gap = new_receiving_gap
|
|
gap_changed = True
|
|
new_change_gap = max(6, gap['max_change_gap'] + 1)
|
|
if self.change.gap != new_change_gap:
|
|
self.change.gap = new_change_gap
|
|
gap_changed = True
|
|
if gap_changed:
|
|
self.wallet.save()
|
|
|
|
def get_balance(self, confirmations=0, include_claims=False, **constraints):
|
|
if not include_claims:
|
|
constraints.update({'txo_type__in': (0, TXO_TYPES['purchase'])})
|
|
return super().get_balance(confirmations, **constraints)
|
|
|
|
async def get_detailed_balance(self, confirmations=0, reserved_subtotals=False):
|
|
tips_balance, supports_balance, claims_balance = 0, 0, 0
|
|
get_total_balance = partial(self.get_balance, confirmations=confirmations, include_claims=True)
|
|
total = await get_total_balance()
|
|
if reserved_subtotals:
|
|
claims_balance = await get_total_balance(txo_type__in=CLAIM_TYPES)
|
|
for amount, spent, from_me, to_me, height in await self.get_support_summary():
|
|
if confirmations > 0 and not 0 < height <= self.ledger.headers.height - (confirmations - 1):
|
|
continue
|
|
if not spent and to_me:
|
|
if from_me:
|
|
supports_balance += amount
|
|
else:
|
|
tips_balance += amount
|
|
reserved = claims_balance + supports_balance + tips_balance
|
|
else:
|
|
reserved = await self.get_balance(
|
|
confirmations=confirmations, include_claims=True, txo_type__gt=0
|
|
)
|
|
return {
|
|
'total': total,
|
|
'available': total - reserved,
|
|
'reserved': reserved,
|
|
'reserved_subtotals': {
|
|
'claims': claims_balance,
|
|
'supports': supports_balance,
|
|
'tips': tips_balance
|
|
} if reserved_subtotals else None
|
|
}
|
|
|
|
@classmethod
|
|
def get_private_key_from_seed(cls, ledger, seed: str, password: str):
|
|
return super().get_private_key_from_seed(
|
|
ledger, seed, password or 'lbryum'
|
|
)
|
|
|
|
@classmethod
|
|
def from_dict(cls, ledger, wallet, d: dict) -> 'Account':
|
|
account = super().from_dict(ledger, wallet, d)
|
|
account.channel_keys = d.get('certificates', {})
|
|
return account
|
|
|
|
def to_dict(self, encrypt_password: str = None, include_channel_keys: bool = True):
|
|
d = super().to_dict(encrypt_password)
|
|
if include_channel_keys:
|
|
d['certificates'] = self.channel_keys
|
|
return d
|
|
|
|
async def get_details(self, **kwargs):
|
|
details = await super().get_details(**kwargs)
|
|
details['certificates'] = len(self.channel_keys)
|
|
return details
|
|
|
|
def get_transaction_history(self, **constraints):
|
|
return self.ledger.get_transaction_history(wallet=self.wallet, accounts=[self], **constraints)
|
|
|
|
def get_transaction_history_count(self, **constraints):
|
|
return self.ledger.get_transaction_history_count(wallet=self.wallet, accounts=[self], **constraints)
|
|
|
|
def get_claims(self, **constraints):
|
|
return self.ledger.get_claims(wallet=self.wallet, accounts=[self], **constraints)
|
|
|
|
def get_claim_count(self, **constraints):
|
|
return self.ledger.get_claim_count(wallet=self.wallet, accounts=[self], **constraints)
|
|
|
|
def get_streams(self, **constraints):
|
|
return self.ledger.get_streams(wallet=self.wallet, accounts=[self], **constraints)
|
|
|
|
def get_stream_count(self, **constraints):
|
|
return self.ledger.get_stream_count(wallet=self.wallet, accounts=[self], **constraints)
|
|
|
|
def get_channels(self, **constraints):
|
|
return self.ledger.get_channels(wallet=self.wallet, accounts=[self], **constraints)
|
|
|
|
def get_channel_count(self, **constraints):
|
|
return self.ledger.get_channel_count(wallet=self.wallet, accounts=[self], **constraints)
|
|
|
|
def get_collections(self, **constraints):
|
|
return self.ledger.get_collections(wallet=self.wallet, accounts=[self], **constraints)
|
|
|
|
def get_collection_count(self, **constraints):
|
|
return self.ledger.get_collection_count(wallet=self.wallet, accounts=[self], **constraints)
|
|
|
|
def get_supports(self, **constraints):
|
|
return self.ledger.get_supports(wallet=self.wallet, accounts=[self], **constraints)
|
|
|
|
def get_support_count(self, **constraints):
|
|
return self.ledger.get_support_count(wallet=self.wallet, accounts=[self], **constraints)
|
|
|
|
def get_support_summary(self):
|
|
return self.ledger.db.get_supports_summary(account_id=self.id)
|
|
|
|
async def release_all_outputs(self):
|
|
await self.ledger.db.release_all_outputs(self)
|