forked from LBRYCommunity/lbry-sdk
393 lines
16 KiB
Python
393 lines
16 KiB
Python
# pylint: disable=invalid-name
|
|
import logging
|
|
from decimal import Decimal
|
|
from binascii import hexlify, unhexlify
|
|
from datetime import datetime, date
|
|
from json import JSONEncoder
|
|
from typing import Iterator, Generic, Callable, Awaitable
|
|
|
|
from google.protobuf.message import DecodeError
|
|
|
|
from lbry.schema.claim import Claim
|
|
from lbry.wallet.wallet import Wallet, Account
|
|
from lbry.blockchain.transaction import Transaction, Output
|
|
from lbry.crypto.bip32 import PubKey
|
|
from lbry.blockchain.dewies import dewies_to_lbc
|
|
from lbry.stream.managed_stream import ManagedStream
|
|
from lbry.db.database import Result, ResultType
|
|
from lbry.constants import DEFAULT_PAGE_SIZE
|
|
|
|
|
|
log = logging.getLogger(__name__)
|
|
|
|
|
|
output_doc = {
|
|
'txid': "hash of transaction in hex",
|
|
'nout': "position in the transaction",
|
|
'height': "block where transaction was recorded",
|
|
'amount': "value of the txo as a decimal",
|
|
'address': "address of who can spend the txo",
|
|
'confirmations': "number of confirmed blocks",
|
|
'is_change': "payment to change address, only available when it can be determined",
|
|
'is_received': "true if txo was sent from external account to this account",
|
|
'is_spent': "true if txo is spent",
|
|
'is_mine': "payment to one of your accounts, only available when it can be determined",
|
|
'type': "one of 'claim', 'support' or 'purchase'",
|
|
'name': "when type is 'claim' or 'support', this is the claim name",
|
|
'claim_id': "when type is 'claim', 'support' or 'purchase', this is the claim id",
|
|
'claim_op': "when type is 'claim', this determines if it is 'create' or 'update'",
|
|
'value': "when type is 'claim' or 'support' with payload, this is the decoded protobuf payload",
|
|
'value_type': "determines the type of the 'value' field: 'channel', 'stream', etc",
|
|
'protobuf': "hex encoded raw protobuf version of 'value' field",
|
|
'permanent_url': "when type is 'claim' or 'support', this is the long permanent claim URL",
|
|
'claim': "for purchase outputs only, metadata of purchased claim",
|
|
'reposted_claim': "for repost claims only, metadata of claim being reposted",
|
|
'signing_channel': "for signed claims only, metadata of signing channel",
|
|
'is_channel_signature_valid': "for signed claims only, whether signature is valid",
|
|
'purchase_receipt': "metadata for the purchase transaction associated with this claim"
|
|
}
|
|
|
|
|
|
transaction_doc = {
|
|
'txid': "hash of transaction in hex",
|
|
'height': "block where transaction was recorded",
|
|
'inputs': ['spent outputs...'],
|
|
'outputs': [output_doc],
|
|
'total_input': "sum of inputs as a decimal",
|
|
'total_output': "sum of outputs, sans fee, as a decimal",
|
|
'total_fee': "fee amount",
|
|
'hex': "entire transaction encoded in hex",
|
|
}
|
|
|
|
|
|
account_doc = {
|
|
'id': 'account_id',
|
|
'is_default': 'this account is used by default',
|
|
'ledger': 'name of crypto currency and network',
|
|
'name': 'optional account name',
|
|
'seed': 'human friendly words from which account can be recreated',
|
|
'encrypted': 'if account is encrypted',
|
|
'private_key': 'extended private key',
|
|
'public_key': 'extended public key',
|
|
'address_generator': 'settings for generating addresses',
|
|
'modified_on': 'date of last modification to account settings'
|
|
}
|
|
|
|
|
|
wallet_doc = {
|
|
'id': 'wallet_id',
|
|
'name': 'optional wallet name',
|
|
}
|
|
|
|
|
|
managedstream_doc = {
|
|
'streaming_url': '(str) url to stream the file using range requests',
|
|
'completed': '(bool) true if download is completed',
|
|
'file_name': '(str) name of file',
|
|
'download_directory': '(str) download directory',
|
|
'points_paid': '(float) credit paid to download file',
|
|
'stopped': '(bool) true if download is stopped',
|
|
'stream_hash': '(str) stream hash of file',
|
|
'stream_name': '(str) stream name',
|
|
'suggested_file_name': '(str) suggested file name',
|
|
'sd_hash': '(str) sd hash of file',
|
|
'download_path': '(str) download path of file',
|
|
'mime_type': '(str) mime type of file',
|
|
'key': '(str) key attached to file',
|
|
'total_bytes_lower_bound': '(int) lower bound file size in bytes',
|
|
'total_bytes': '(int) file upper bound size in bytes',
|
|
'written_bytes': '(int) written size in bytes',
|
|
'blobs_completed': '(int) number of fully downloaded blobs',
|
|
'blobs_in_stream': '(int) total blobs on stream',
|
|
'blobs_remaining': '(int) total blobs remaining to download',
|
|
'status': '(str) downloader status',
|
|
'claim_id': '(str) None if claim is not found else the claim id',
|
|
'txid': '(str) None if claim is not found else the transaction id',
|
|
'nout': '(int) None if claim is not found else the transaction output index',
|
|
'outpoint': '(str) None if claim is not found else the tx and output',
|
|
'metadata': '(dict) None if claim is not found else the claim metadata',
|
|
'channel_claim_id': '(str) None if claim is not found or not signed',
|
|
'channel_name': '(str) None if claim is not found or not signed',
|
|
'claim_name': '(str) None if claim is not found else the claim name'
|
|
}
|
|
|
|
|
|
address_doc = {
|
|
"address": "(str)"
|
|
}
|
|
|
|
|
|
def encode_pagination_doc(items):
|
|
return {
|
|
"page": "Page number of the current items.",
|
|
"page_size": "Number of items to show on a page.",
|
|
"total_pages": "Total number of pages.",
|
|
"total_items": "Total number of items.",
|
|
"items": [items],
|
|
}
|
|
|
|
|
|
class Paginated(Generic[ResultType]):
|
|
|
|
__slots__ = 'result', 'page', 'page_size'
|
|
|
|
def __init__(self, result: Result, page: int, page_size: int):
|
|
self.result = result
|
|
self.page = page
|
|
self.page_size = page_size
|
|
|
|
@classmethod
|
|
def from_list(cls, items: list, page: int = None, page_size: int = None, include_total=False):
|
|
page = max(1, page or 1)
|
|
page_size = max(1, page_size or DEFAULT_PAGE_SIZE)
|
|
total_items = len(items)
|
|
offset = page_size * (page - 1)
|
|
subitems = []
|
|
if offset <= total_items:
|
|
subitems = items[offset:offset + page_size]
|
|
return cls(Result(subitems, total_items if include_total else None), page, page_size)
|
|
|
|
@classmethod
|
|
async def from_getter(
|
|
cls, get_records: Callable[..., Awaitable[Result]],
|
|
page: int = None, page_size: int = None, **constraints
|
|
):
|
|
page = max(1, page or 1)
|
|
page_size = max(1, page_size or DEFAULT_PAGE_SIZE)
|
|
constraints.update({
|
|
"offset": page_size * (page - 1),
|
|
"limit": page_size
|
|
})
|
|
return cls(await get_records(**constraints), page, page_size)
|
|
|
|
def __getitem__(self, item: int) -> ResultType:
|
|
return self.result[item]
|
|
|
|
def __iter__(self) -> Iterator[ResultType]:
|
|
return iter(self.result)
|
|
|
|
def __len__(self):
|
|
return len(self.result)
|
|
|
|
def __repr__(self):
|
|
return repr(self.to_dict())
|
|
|
|
def to_dict(self):
|
|
d = {"items": self.result.rows, "page": self.page, "page_size": self.page_size}
|
|
if self.result.total is not None:
|
|
count = self.result.total
|
|
d["total_pages"] = int((count + (self.page_size - 1)) / self.page_size)
|
|
d["total_items"] = count
|
|
return d
|
|
|
|
|
|
class JSONResponseEncoder(JSONEncoder):
|
|
|
|
def __init__(self, *args, service, include_protobuf=False, **kwargs):
|
|
super().__init__(*args, **kwargs)
|
|
self.service = service
|
|
self.include_protobuf = include_protobuf
|
|
|
|
def default(self, obj): # pylint: disable=method-hidden,arguments-differ,too-many-return-statements
|
|
if isinstance(obj, Paginated):
|
|
return obj.to_dict()
|
|
if isinstance(obj, Account):
|
|
return self.encode_account(obj)
|
|
if isinstance(obj, Wallet):
|
|
return self.encode_wallet(obj)
|
|
if isinstance(obj, ManagedStream):
|
|
return self.encode_file(obj)
|
|
if isinstance(obj, Transaction):
|
|
return self.encode_transaction(obj)
|
|
if isinstance(obj, Output):
|
|
return self.encode_output(obj)
|
|
if isinstance(obj, Claim):
|
|
return self.encode_claim(obj)
|
|
if isinstance(obj, PubKey):
|
|
return obj.extended_key_string()
|
|
if isinstance(obj, date):
|
|
return obj.isoformat()
|
|
if isinstance(obj, datetime):
|
|
return obj.strftime("%Y%m%dT%H:%M:%S")
|
|
if isinstance(obj, Decimal):
|
|
return float(obj)
|
|
if isinstance(obj, bytes):
|
|
return obj.decode()
|
|
return super().default(obj)
|
|
|
|
def encode_transaction(self, tx):
|
|
return {
|
|
'txid': tx.id,
|
|
'height': tx.height,
|
|
'inputs': [self.encode_input(txo) for txo in tx.inputs],
|
|
'outputs': [self.encode_output(txo) for txo in tx.outputs],
|
|
'total_input': dewies_to_lbc(tx.input_sum),
|
|
'total_output': dewies_to_lbc(tx.input_sum - tx.fee),
|
|
'total_fee': dewies_to_lbc(tx.fee),
|
|
'hex': hexlify(tx.raw).decode(),
|
|
}
|
|
|
|
def encode_output(self, txo, check_signature=True):
|
|
if not txo:
|
|
return
|
|
tx_height = txo.tx_ref.height
|
|
best_height = 0#self.ledger.headers.height
|
|
output = {
|
|
'txid': txo.tx_ref.id,
|
|
'nout': txo.position,
|
|
'height': tx_height,
|
|
'amount': dewies_to_lbc(txo.amount),
|
|
'address': txo.get_address(self.service.ledger) if txo.has_address else None,
|
|
'confirmations': (best_height+1) - tx_height if tx_height > 0 else tx_height,
|
|
'timestamp': 0 #self.ledger.headers.estimated_timestamp(tx_height)
|
|
}
|
|
if txo.is_spent is not None:
|
|
output['is_spent'] = txo.is_spent
|
|
if txo.is_my_output is not None:
|
|
output['is_my_output'] = txo.is_my_output
|
|
if txo.is_my_input is not None:
|
|
output['is_my_input'] = txo.is_my_input
|
|
if txo.sent_supports is not None:
|
|
output['sent_supports'] = dewies_to_lbc(txo.sent_supports)
|
|
if txo.sent_tips is not None:
|
|
output['sent_tips'] = dewies_to_lbc(txo.sent_tips)
|
|
if txo.received_tips is not None:
|
|
output['received_tips'] = dewies_to_lbc(txo.received_tips)
|
|
if txo.is_internal_transfer is not None:
|
|
output['is_internal_transfer'] = txo.is_internal_transfer
|
|
|
|
if txo.script.is_claim_name:
|
|
output['type'] = 'claim'
|
|
output['claim_op'] = 'create'
|
|
elif txo.script.is_update_claim:
|
|
output['type'] = 'claim'
|
|
output['claim_op'] = 'update'
|
|
elif txo.script.is_support_claim:
|
|
output['type'] = 'support'
|
|
elif txo.script.is_return_data:
|
|
output['type'] = 'data'
|
|
elif txo.purchase is not None:
|
|
output['type'] = 'purchase'
|
|
output['claim_id'] = txo.purchased_claim_id
|
|
if txo.purchased_claim is not None:
|
|
output['claim'] = self.encode_output(txo.purchased_claim)
|
|
else:
|
|
output['type'] = 'payment'
|
|
|
|
if txo.script.is_claim_involved:
|
|
output.update({
|
|
'name': txo.claim_name,
|
|
'normalized_name': txo.normalized_name,
|
|
'claim_id': txo.claim_id,
|
|
'permanent_url': txo.permanent_url,
|
|
'meta': self.encode_claim_meta(txo.meta.copy())
|
|
})
|
|
if 'short_url' in output['meta']:
|
|
output['short_url'] = output['meta'].pop('short_url')
|
|
if 'canonical_url' in output['meta']:
|
|
output['canonical_url'] = output['meta'].pop('canonical_url')
|
|
if txo.claims is not None:
|
|
output['claims'] = [self.encode_output(o) for o in txo.claims]
|
|
if txo.reposted_claim is not None:
|
|
output['reposted_claim'] = self.encode_output(txo.reposted_claim)
|
|
if txo.script.is_claim_name or txo.script.is_update_claim:
|
|
try:
|
|
output['value'] = txo.claim
|
|
output['value_type'] = txo.claim.claim_type
|
|
if self.include_protobuf:
|
|
output['protobuf'] = hexlify(txo.claim.to_bytes())
|
|
if txo.purchase_receipt is not None:
|
|
output['purchase_receipt'] = self.encode_output(txo.purchase_receipt)
|
|
if txo.claim.is_channel:
|
|
output['has_signing_key'] = txo.has_private_key
|
|
if check_signature and txo.claim.is_signed:
|
|
if txo.channel is not None:
|
|
output['signing_channel'] = self.encode_output(txo.channel)
|
|
output['is_channel_signature_valid'] = txo.is_signed_by(txo.channel, self.service.ledger)
|
|
else:
|
|
output['signing_channel'] = {'channel_id': txo.claim.signing_channel_id}
|
|
output['is_channel_signature_valid'] = False
|
|
except DecodeError:
|
|
pass
|
|
return output
|
|
|
|
def encode_claim_meta(self, meta):
|
|
for key, value in meta.items():
|
|
if key.endswith('_amount'):
|
|
if isinstance(value, int):
|
|
meta[key] = dewies_to_lbc(value)
|
|
if 0 < meta.get('creation_height', 0) <= 0: #self.ledger.headers.height:
|
|
meta['creation_timestamp'] = self.service.ledger.headers.estimated_timestamp(meta['creation_height'])
|
|
return meta
|
|
|
|
def encode_input(self, txi):
|
|
return self.encode_output(txi.txo_ref.txo, False) if txi.txo_ref.txo is not None else {
|
|
'txid': txi.txo_ref.tx_ref.id,
|
|
'nout': txi.txo_ref.position
|
|
}
|
|
|
|
@staticmethod
|
|
def encode_account(account):
|
|
result = account.to_dict()
|
|
result['id'] = account.id
|
|
result.pop('certificates', None)
|
|
#result['is_default'] = self.ledger.accounts[0] == account
|
|
return result
|
|
|
|
@staticmethod
|
|
def encode_wallet(wallet):
|
|
return {
|
|
'id': wallet.id,
|
|
'name': wallet.name
|
|
}
|
|
|
|
def encode_file(self, managed_stream):
|
|
output_exists = managed_stream.output_file_exists
|
|
tx_height = managed_stream.stream_claim_info.height
|
|
best_height = 0 #self.ledger.headers.height
|
|
return {
|
|
'streaming_url': managed_stream.stream_url,
|
|
'completed': managed_stream.completed,
|
|
'file_name': managed_stream.file_name if output_exists else None,
|
|
'download_directory': managed_stream.download_directory if output_exists else None,
|
|
'download_path': managed_stream.full_path if output_exists else None,
|
|
'points_paid': 0.0,
|
|
'stopped': not managed_stream.running,
|
|
'stream_hash': managed_stream.stream_hash,
|
|
'stream_name': managed_stream.descriptor.stream_name,
|
|
'suggested_file_name': managed_stream.descriptor.suggested_file_name,
|
|
'sd_hash': managed_stream.descriptor.sd_hash,
|
|
'mime_type': managed_stream.mime_type,
|
|
'key': managed_stream.descriptor.key,
|
|
'total_bytes_lower_bound': managed_stream.descriptor.lower_bound_decrypted_length(),
|
|
'total_bytes': managed_stream.descriptor.upper_bound_decrypted_length(),
|
|
'written_bytes': managed_stream.written_bytes,
|
|
'blobs_completed': managed_stream.blobs_completed,
|
|
'blobs_in_stream': managed_stream.blobs_in_stream,
|
|
'blobs_remaining': managed_stream.blobs_remaining,
|
|
'status': managed_stream.status,
|
|
'claim_id': managed_stream.claim_id,
|
|
'txid': managed_stream.txid,
|
|
'nout': managed_stream.nout,
|
|
'outpoint': managed_stream.outpoint,
|
|
'metadata': managed_stream.metadata,
|
|
'protobuf': managed_stream.metadata_protobuf,
|
|
'channel_claim_id': managed_stream.channel_claim_id,
|
|
'channel_name': managed_stream.channel_name,
|
|
'claim_name': managed_stream.claim_name,
|
|
'content_fee': managed_stream.content_fee,
|
|
'purchase_receipt': self.encode_output(managed_stream.purchase_receipt),
|
|
'added_on': managed_stream.added_on,
|
|
'height': tx_height,
|
|
'confirmations': (best_height + 1) - tx_height if tx_height > 0 else tx_height,
|
|
'timestamp': 0, #self.ledger.headers.estimated_timestamp(tx_height),
|
|
'is_fully_reflected': managed_stream.is_fully_reflected
|
|
}
|
|
|
|
def encode_claim(self, claim):
|
|
encoded = getattr(claim, claim.claim_type).to_dict()
|
|
if 'public_key' in encoded:
|
|
encoded['public_key_id'] = self.service.ledger.public_key_to_address(
|
|
unhexlify(encoded['public_key'])
|
|
)
|
|
return encoded
|