forked from LBRYCommunity/lbry-sdk
wip: initial import of twisted based wallet
This commit is contained in:
Lex Berezhny
Jack Robison
parent
79d1da5ff8
commit
ca8b2dd83e
29 changed files with 14642 additions and 305 deletions
|
|
@ -1,177 +0,0 @@
|
|||
import json
|
||||
import logging
|
||||
import socket
|
||||
|
||||
from twisted.internet import defer, error
|
||||
from twisted.protocols.basic import LineOnlyReceiver
|
||||
from errors import RemoteServiceException, ProtocolException, ServiceException
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
|
||||
|
||||
class StratumClientProtocol(LineOnlyReceiver):
|
||||
delimiter = '\n'
|
||||
|
||||
def __init__(self):
|
||||
self._connected = defer.Deferred()
|
||||
|
||||
def _get_id(self):
|
||||
self.request_id += 1
|
||||
return self.request_id
|
||||
|
||||
def _get_ip(self):
|
||||
return self.transport.getPeer().host
|
||||
|
||||
def get_session(self):
|
||||
return self.session
|
||||
|
||||
def connectionMade(self):
|
||||
try:
|
||||
self.transport.setTcpNoDelay(True)
|
||||
self.transport.setTcpKeepAlive(True)
|
||||
if hasattr(socket, "TCP_KEEPIDLE"):
|
||||
self.transport.socket.setsockopt(socket.SOL_TCP, socket.TCP_KEEPIDLE,
|
||||
120) # Seconds before sending keepalive probes
|
||||
else:
|
||||
log.debug("TCP_KEEPIDLE not available")
|
||||
if hasattr(socket, "TCP_KEEPINTVL"):
|
||||
self.transport.socket.setsockopt(socket.SOL_TCP, socket.TCP_KEEPINTVL,
|
||||
1) # Interval in seconds between keepalive probes
|
||||
else:
|
||||
log.debug("TCP_KEEPINTVL not available")
|
||||
if hasattr(socket, "TCP_KEEPCNT"):
|
||||
self.transport.socket.setsockopt(socket.SOL_TCP, socket.TCP_KEEPCNT,
|
||||
5) # Failed keepalive probles before declaring other end dead
|
||||
else:
|
||||
log.debug("TCP_KEEPCNT not available")
|
||||
|
||||
except Exception as err:
|
||||
# Supported only by the socket transport,
|
||||
# but there's really no better place in code to trigger this.
|
||||
log.warning("Error setting up socket: %s", err)
|
||||
|
||||
self.request_id = 0
|
||||
self.lookup_table = {}
|
||||
|
||||
self._connected.callback(True)
|
||||
|
||||
# Initiate connection session
|
||||
self.session = {}
|
||||
|
||||
log.debug("Connected %s" % self.transport.getPeer().host)
|
||||
|
||||
def transport_write(self, data):
|
||||
'''Overwrite this if transport needs some extra care about data written
|
||||
to the socket, like adding message format in websocket.'''
|
||||
try:
|
||||
self.transport.write(data)
|
||||
except AttributeError:
|
||||
# Transport is disconnected
|
||||
log.warning("transport is disconnected")
|
||||
|
||||
def writeJsonRequest(self, method, params, is_notification=False):
|
||||
request_id = None if is_notification else self._get_id()
|
||||
serialized = json.dumps({'id': request_id, 'method': method, 'params': params})
|
||||
self.transport_write("%s\n" % serialized)
|
||||
return request_id
|
||||
|
||||
def writeJsonResponse(self, data, message_id):
|
||||
serialized = json.dumps({'id': message_id, 'result': data, 'error': None})
|
||||
self.transport_write("%s\n" % serialized)
|
||||
|
||||
def writeJsonError(self, code, message, traceback, message_id):
|
||||
serialized = json.dumps(
|
||||
{'id': message_id, 'result': None, 'error': (code, message, traceback)}
|
||||
)
|
||||
self.transport_write("%s\n" % serialized)
|
||||
|
||||
def writeGeneralError(self, message, code=-1):
|
||||
log.error(message)
|
||||
return self.writeJsonError(code, message, None, None)
|
||||
|
||||
def process_response(self, data, message_id):
|
||||
self.writeJsonResponse(data.result, message_id)
|
||||
|
||||
def process_failure(self, failure, message_id):
|
||||
if not isinstance(failure.value, ServiceException):
|
||||
# All handled exceptions should inherit from ServiceException class.
|
||||
# Throwing other exception class means that it is unhandled error
|
||||
# and we should log it.
|
||||
log.exception(failure)
|
||||
code = getattr(failure.value, 'code', -1)
|
||||
if message_id != None:
|
||||
tb = failure.getBriefTraceback()
|
||||
self.writeJsonError(code, failure.getErrorMessage(), tb, message_id)
|
||||
|
||||
def dataReceived(self, data):
|
||||
'''Original code from Twisted, hacked for request_counter proxying.
|
||||
request_counter is hack for HTTP transport, didn't found cleaner solution how
|
||||
to indicate end of request processing in asynchronous manner.
|
||||
|
||||
TODO: This would deserve some unit test to be sure that future twisted versions
|
||||
will work nicely with this.'''
|
||||
|
||||
lines = (self._buffer + data).split(self.delimiter)
|
||||
self._buffer = lines.pop(-1)
|
||||
|
||||
for line in lines:
|
||||
if self.transport.disconnecting:
|
||||
return
|
||||
if len(line) > self.MAX_LENGTH:
|
||||
return self.lineLengthExceeded(line)
|
||||
else:
|
||||
try:
|
||||
self.lineReceived(line)
|
||||
except Exception as exc:
|
||||
# log.exception("Processing of message failed")
|
||||
log.warning("Failed message: %s from %s" % (str(exc), self._get_ip()))
|
||||
return error.ConnectionLost('Processing of message failed')
|
||||
|
||||
if len(self._buffer) > self.MAX_LENGTH:
|
||||
return self.lineLengthExceeded(self._buffer)
|
||||
|
||||
def lineReceived(self, line):
|
||||
try:
|
||||
message = json.loads(line)
|
||||
except (ValueError, TypeError):
|
||||
# self.writeGeneralError("Cannot decode message '%s'" % line)
|
||||
raise ProtocolException("Cannot decode message '%s'" % line.strip())
|
||||
msg_id = message.get('id', 0)
|
||||
msg_result = message.get('result')
|
||||
msg_error = message.get('error')
|
||||
if msg_id:
|
||||
# It's a RPC response
|
||||
# Perform lookup to the table of waiting requests.
|
||||
try:
|
||||
meta = self.lookup_table[msg_id]
|
||||
del self.lookup_table[msg_id]
|
||||
except KeyError:
|
||||
# When deferred object for given message ID isn't found, it's an error
|
||||
raise ProtocolException(
|
||||
"Lookup for deferred object for message ID '%s' failed." % msg_id)
|
||||
# If there's an error, handle it as errback
|
||||
# If both result and error are null, handle it as a success with blank result
|
||||
if msg_error != None:
|
||||
meta['defer'].errback(
|
||||
RemoteServiceException(msg_error[0], msg_error[1], msg_error[2])
|
||||
)
|
||||
else:
|
||||
meta['defer'].callback(msg_result)
|
||||
else:
|
||||
raise ProtocolException("Cannot handle message '%s'" % line)
|
||||
|
||||
def rpc(self, method, params, is_notification=False):
|
||||
'''
|
||||
This method performs remote RPC call.
|
||||
|
||||
If method should expect an response, it store
|
||||
request ID to lookup table and wait for corresponding
|
||||
response message.
|
||||
'''
|
||||
|
||||
request_id = self.writeJsonRequest(method, params, is_notification)
|
||||
if is_notification:
|
||||
return
|
||||
d = defer.Deferred()
|
||||
self.lookup_table[request_id] = {'defer': d, 'method': method, 'params': params}
|
||||
return d
|
||||
|
|
@ -1,18 +0,0 @@
|
|||
class TransportException(Exception):
|
||||
pass
|
||||
|
||||
|
||||
class ServiceException(Exception):
|
||||
code = -2
|
||||
|
||||
|
||||
class RemoteServiceException(Exception):
|
||||
pass
|
||||
|
||||
|
||||
class ProtocolException(Exception):
|
||||
pass
|
||||
|
||||
|
||||
class MethodNotFoundException(ServiceException):
|
||||
code = -3
|
||||
|
|
@ -1,110 +0,0 @@
|
|||
import logging
|
||||
from twisted.internet import defer
|
||||
from twisted.internet.protocol import ClientFactory
|
||||
from client import StratumClientProtocol
|
||||
from errors import TransportException
|
||||
|
||||
log = logging.getLogger()
|
||||
|
||||
|
||||
class StratumClient(ClientFactory):
|
||||
protocol = StratumClientProtocol
|
||||
|
||||
def __init__(self, connected_d=None):
|
||||
self.client = None
|
||||
self.connected_d = connected_d or defer.Deferred()
|
||||
|
||||
def buildProtocol(self, addr):
|
||||
client = self.protocol()
|
||||
client.factory = self
|
||||
self.client = client
|
||||
self.client._connected.addCallback(lambda _: self.connected_d.callback(self))
|
||||
return client
|
||||
|
||||
def _rpc(self, method, params, *args, **kwargs):
|
||||
if not self.client:
|
||||
raise TransportException("Not connected")
|
||||
|
||||
return self.client.rpc(method, params, *args, **kwargs)
|
||||
|
||||
def blockchain_claimtrie_getvaluesforuris(self, block_hash, *uris):
|
||||
return self._rpc('blockchain.claimtrie.getvaluesforuris',
|
||||
[block_hash] + list(uris))
|
||||
|
||||
def blockchain_claimtrie_getvaluesforuri(self, block_hash, uri):
|
||||
return self._rpc('blockchain.claimtrie.getvaluesforuri', [block_hash, uri])
|
||||
|
||||
def blockchain_claimtrie_getclaimssignedbynthtoname(self, name, n):
|
||||
return self._rpc('blockchain.claimtrie.getclaimssignedbynthtoname', [name, n])
|
||||
|
||||
def blockchain_claimtrie_getclaimssignedbyid(self, certificate_id):
|
||||
return self._rpc('blockchain.claimtrie.getclaimssignedbyid', [certificate_id])
|
||||
|
||||
def blockchain_claimtrie_getclaimssignedby(self, name):
|
||||
return self._rpc('blockchain.claimtrie.getclaimssignedby', [name])
|
||||
|
||||
def blockchain_claimtrie_getnthclaimforname(self, name, n):
|
||||
return self._rpc('blockchain.claimtrie.getnthclaimforname', [name, n])
|
||||
|
||||
def blockchain_claimtrie_getclaimsbyids(self, *claim_ids):
|
||||
return self._rpc('blockchain.claimtrie.getclaimsbyids', list(claim_ids))
|
||||
|
||||
def blockchain_claimtrie_getclaimbyid(self, claim_id):
|
||||
return self._rpc('blockchain.claimtrie.getclaimbyid', [claim_id])
|
||||
|
||||
def blockchain_claimtrie_get(self):
|
||||
return self._rpc('blockchain.claimtrie.get', [])
|
||||
|
||||
def blockchain_block_get_block(self, block_hash):
|
||||
return self._rpc('blockchain.block.get_block', [block_hash])
|
||||
|
||||
def blockchain_claimtrie_getclaimsforname(self, name):
|
||||
return self._rpc('blockchain.claimtrie.getclaimsforname', [name])
|
||||
|
||||
def blockchain_claimtrie_getclaimsintx(self, txid):
|
||||
return self._rpc('blockchain.claimtrie.getclaimsintx', [txid])
|
||||
|
||||
def blockchain_claimtrie_getvalue(self, name, block_hash=None):
|
||||
return self._rpc('blockchain.claimtrie.getvalue', [name, block_hash])
|
||||
|
||||
def blockchain_relayfee(self):
|
||||
return self._rpc('blockchain.relayfee', [])
|
||||
|
||||
def blockchain_estimatefee(self):
|
||||
return self._rpc('blockchain.estimatefee', [])
|
||||
|
||||
def blockchain_transaction_get(self, txid):
|
||||
return self._rpc('blockchain.transaction.get', [txid])
|
||||
|
||||
def blockchain_transaction_get_merkle(self, tx_hash, height, cache_only=False):
|
||||
return self._rpc('blockchain.transaction.get_merkle', [tx_hash, height, cache_only])
|
||||
|
||||
def blockchain_transaction_broadcast(self, raw_transaction):
|
||||
return self._rpc('blockchain.transaction.broadcast', [raw_transaction])
|
||||
|
||||
def blockchain_block_get_chunk(self, index, cache_only=False):
|
||||
return self._rpc('blockchain.block.get_chunk', [index, cache_only])
|
||||
|
||||
def blockchain_block_get_header(self, height, cache_only=False):
|
||||
return self._rpc('blockchain.block.get_header', [height, cache_only])
|
||||
|
||||
def blockchain_utxo_get_address(self, txid, pos):
|
||||
return self._rpc('blockchain.utxo.get_address', [txid, pos])
|
||||
|
||||
def blockchain_address_listunspent(self, address):
|
||||
return self._rpc('blockchain.address.listunspent', [address])
|
||||
|
||||
def blockchain_address_get_proof(self, address):
|
||||
return self._rpc('blockchain.address.get_proof', [address])
|
||||
|
||||
def blockchain_address_get_balance(self, address):
|
||||
return self._rpc('blockchain.address.get_balance', [address])
|
||||
|
||||
def blockchain_address_get_mempool(self, address):
|
||||
return self._rpc('blockchain.address.get_mempool', [address])
|
||||
|
||||
def blockchain_address_get_history(self, address):
|
||||
return self._rpc('blockchain.address.get_history', [address])
|
||||
|
||||
def blockchain_block_get_server_height(self):
|
||||
return self._rpc('blockchain.block.get_server_height', [])
|
||||
0
lbrynet/wallet/__init__.py
Normal file
0
lbrynet/wallet/__init__.py
Normal file
83
lbrynet/wallet/account.py
Normal file
83
lbrynet/wallet/account.py
Normal file
|
|
@ -0,0 +1,83 @@
|
|||
import logging
|
||||
|
||||
from lbryschema.address import public_key_to_address
|
||||
|
||||
from .lbrycrd import deserialize_xkey
|
||||
from .lbrycrd import CKD_pub
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
|
||||
|
||||
def get_key_chain_from_xpub(xpub):
|
||||
_, _, _, chain, key = deserialize_xkey(xpub)
|
||||
return key, chain
|
||||
|
||||
|
||||
def derive_key(parent_key, chain, sequence):
|
||||
return CKD_pub(parent_key, chain, sequence)[0]
|
||||
|
||||
|
||||
class AddressSequence:
|
||||
|
||||
def __init__(self, derived_keys, gap, age_checker, pub_key, chain_key):
|
||||
self.gap = gap
|
||||
self.is_old = age_checker
|
||||
self.pub_key = pub_key
|
||||
self.chain_key = chain_key
|
||||
self.derived_keys = derived_keys
|
||||
self.addresses = [
|
||||
public_key_to_address(key.decode('hex'))
|
||||
for key in derived_keys
|
||||
]
|
||||
|
||||
def generate_next_address(self):
|
||||
new_key, _ = derive_key(self.pub_key, self.chain_key, len(self.derived_keys))
|
||||
address = public_key_to_address(new_key)
|
||||
self.derived_keys.append(new_key.encode('hex'))
|
||||
self.addresses.append(address)
|
||||
return address
|
||||
|
||||
def has_gap(self):
|
||||
if len(self.addresses) < self.gap:
|
||||
return False
|
||||
for address in self.addresses[-self.gap:]:
|
||||
if self.is_old(address):
|
||||
return False
|
||||
return True
|
||||
|
||||
def ensure_enough_addresses(self):
|
||||
starting_length = len(self.addresses)
|
||||
while not self.has_gap():
|
||||
self.generate_next_address()
|
||||
return self.addresses[starting_length:]
|
||||
|
||||
|
||||
class Account:
|
||||
|
||||
def __init__(self, data, receiving_gap, change_gap, age_checker):
|
||||
self.xpub = data['xpub']
|
||||
master_key, master_chain = get_key_chain_from_xpub(data['xpub'])
|
||||
self.receiving = AddressSequence(
|
||||
data.get('receiving', []), receiving_gap, age_checker,
|
||||
*derive_key(master_key, master_chain, 0)
|
||||
)
|
||||
self.change = AddressSequence(
|
||||
data.get('change', []), change_gap, age_checker,
|
||||
*derive_key(master_key, master_chain, 1)
|
||||
)
|
||||
self.is_old = age_checker
|
||||
|
||||
def as_dict(self):
|
||||
return {
|
||||
'receiving': self.receiving.derived_keys,
|
||||
'change': self.change.derived_keys,
|
||||
'xpub': self.xpub
|
||||
}
|
||||
|
||||
def ensure_enough_addresses(self):
|
||||
return self.receiving.ensure_enough_addresses() + \
|
||||
self.change.ensure_enough_addresses()
|
||||
|
||||
@property
|
||||
def sequences(self):
|
||||
return self.receiving, self.change
|
||||
133
lbrynet/wallet/bcd_data_stream.py
Normal file
133
lbrynet/wallet/bcd_data_stream.py
Normal file
|
|
@ -0,0 +1,133 @@
|
|||
import struct
|
||||
|
||||
|
||||
class SerializationError(Exception):
|
||||
""" Thrown when there's a problem deserializing or serializing """
|
||||
|
||||
|
||||
class BCDataStream(object):
|
||||
def __init__(self):
|
||||
self.input = None
|
||||
self.read_cursor = 0
|
||||
|
||||
def clear(self):
|
||||
self.input = None
|
||||
self.read_cursor = 0
|
||||
|
||||
def write(self, bytes): # Initialize with string of bytes
|
||||
if self.input is None:
|
||||
self.input = bytes
|
||||
else:
|
||||
self.input += bytes
|
||||
|
||||
def read_string(self):
|
||||
# Strings are encoded depending on length:
|
||||
# 0 to 252 : 1-byte-length followed by bytes (if any)
|
||||
# 253 to 65,535 : byte'253' 2-byte-length followed by bytes
|
||||
# 65,536 to 4,294,967,295 : byte '254' 4-byte-length followed by bytes
|
||||
# ... and the Bitcoin client is coded to understand:
|
||||
# greater than 4,294,967,295 : byte '255' 8-byte-length followed by bytes of string
|
||||
# ... but I don't think it actually handles any strings that big.
|
||||
if self.input is None:
|
||||
raise SerializationError("call write(bytes) before trying to deserialize")
|
||||
|
||||
try:
|
||||
length = self.read_compact_size()
|
||||
except IndexError:
|
||||
raise SerializationError("attempt to read past end of buffer")
|
||||
|
||||
return self.read_bytes(length)
|
||||
|
||||
def write_string(self, string):
|
||||
# Length-encoded as with read-string
|
||||
self.write_compact_size(len(string))
|
||||
self.write(string)
|
||||
|
||||
def read_bytes(self, length):
|
||||
try:
|
||||
result = self.input[self.read_cursor:self.read_cursor + length]
|
||||
self.read_cursor += length
|
||||
return result
|
||||
except IndexError:
|
||||
raise SerializationError("attempt to read past end of buffer")
|
||||
|
||||
return ''
|
||||
|
||||
def read_boolean(self):
|
||||
return self.read_bytes(1)[0] != chr(0)
|
||||
|
||||
def read_int16(self):
|
||||
return self._read_num('<h')
|
||||
|
||||
def read_uint16(self):
|
||||
return self._read_num('<H')
|
||||
|
||||
def read_int32(self):
|
||||
return self._read_num('<i')
|
||||
|
||||
def read_uint32(self):
|
||||
return self._read_num('<I')
|
||||
|
||||
def read_int64(self):
|
||||
return self._read_num('<q')
|
||||
|
||||
def read_uint64(self):
|
||||
return self._read_num('<Q')
|
||||
|
||||
def write_boolean(self, val):
|
||||
return self.write(chr(1) if val else chr(0))
|
||||
|
||||
def write_int16(self, val):
|
||||
return self._write_num('<h', val)
|
||||
|
||||
def write_uint16(self, val):
|
||||
return self._write_num('<H', val)
|
||||
|
||||
def write_int32(self, val):
|
||||
return self._write_num('<i', val)
|
||||
|
||||
def write_uint32(self, val):
|
||||
return self._write_num('<I', val)
|
||||
|
||||
def write_int64(self, val):
|
||||
return self._write_num('<q', val)
|
||||
|
||||
def write_uint64(self, val):
|
||||
return self._write_num('<Q', val)
|
||||
|
||||
def read_compact_size(self):
|
||||
size = ord(self.input[self.read_cursor])
|
||||
self.read_cursor += 1
|
||||
if size == 253:
|
||||
size = self._read_num('<H')
|
||||
elif size == 254:
|
||||
size = self._read_num('<I')
|
||||
elif size == 255:
|
||||
size = self._read_num('<Q')
|
||||
return size
|
||||
|
||||
def write_compact_size(self, size):
|
||||
if size < 0:
|
||||
raise SerializationError("attempt to write size < 0")
|
||||
elif size < 253:
|
||||
self.write(chr(size))
|
||||
elif size < 2 ** 16:
|
||||
self.write('\xfd')
|
||||
self._write_num('<H', size)
|
||||
elif size < 2 ** 32:
|
||||
self.write('\xfe')
|
||||
self._write_num('<I', size)
|
||||
elif size < 2 ** 64:
|
||||
self.write('\xff')
|
||||
self._write_num('<Q', size)
|
||||
|
||||
def _read_num(self, format):
|
||||
(i,) = struct.unpack_from(format, self.input, self.read_cursor)
|
||||
self.read_cursor += struct.calcsize(format)
|
||||
return i
|
||||
|
||||
def _write_num(self, format, num):
|
||||
s = struct.pack(format, num)
|
||||
self.write(s)
|
||||
|
||||
|
||||
243
lbrynet/wallet/blockchain.py
Normal file
243
lbrynet/wallet/blockchain.py
Normal file
|
|
@ -0,0 +1,243 @@
|
|||
import os
|
||||
import logging
|
||||
|
||||
from twisted.internet import threads, defer
|
||||
|
||||
from lbryum.util import hex_to_int, int_to_hex, rev_hex
|
||||
from lbryum.hashing import hash_encode, Hash, PoWHash
|
||||
from .stream import StreamController
|
||||
from .constants import blockchain_params, HEADER_SIZE
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
|
||||
|
||||
class BlockchainHeaders:
|
||||
|
||||
def __init__(self, path, chain='lbrycrd_main'):
|
||||
self.path = path
|
||||
self.chain = chain
|
||||
self.max_target = blockchain_params[chain]['max_target']
|
||||
self.target_timespan = blockchain_params[chain]['target_timespan']
|
||||
self.genesis_bits = blockchain_params[chain]['genesis_bits']
|
||||
|
||||
self._on_change_controller = StreamController()
|
||||
self.on_changed = self._on_change_controller.stream
|
||||
|
||||
self._size = None
|
||||
self._write_lock = defer.DeferredLock()
|
||||
|
||||
if not os.path.exists(path):
|
||||
with open(path, 'wb'):
|
||||
pass
|
||||
|
||||
def sync_read_length(self):
|
||||
return os.path.getsize(self.path) / HEADER_SIZE
|
||||
|
||||
def __len__(self):
|
||||
if self._size is None:
|
||||
self._size = self.sync_read_length()
|
||||
return self._size
|
||||
|
||||
def sync_read_header(self, height):
|
||||
if 0 <= height < len(self):
|
||||
with open(self.path, 'rb') as f:
|
||||
f.seek(height * HEADER_SIZE)
|
||||
return f.read(HEADER_SIZE)
|
||||
|
||||
def __getitem__(self, height):
|
||||
assert not isinstance(height, slice),\
|
||||
"Slicing of header chain has not been implemented yet."
|
||||
header = self.sync_read_header(height)
|
||||
return self._deserialize(height, header)
|
||||
|
||||
@defer.inlineCallbacks
|
||||
def connect(self, start, headers):
|
||||
yield self._write_lock.acquire()
|
||||
try:
|
||||
yield threads.deferToThread(self._sync_connect, start, headers)
|
||||
finally:
|
||||
self._write_lock.release()
|
||||
|
||||
def _sync_connect(self, start, headers):
|
||||
previous_header = None
|
||||
for header in self._iterate_headers(start, headers):
|
||||
height = header['block_height']
|
||||
if previous_header is None and height > 0:
|
||||
previous_header = self[height-1]
|
||||
self._verify_header(height, header, previous_header)
|
||||
previous_header = header
|
||||
|
||||
with open(self.path, 'r+b') as f:
|
||||
f.seek(start * HEADER_SIZE)
|
||||
f.write(headers)
|
||||
f.truncate()
|
||||
|
||||
_old_size = self._size
|
||||
self._size = self.sync_read_length()
|
||||
change = self._size - _old_size
|
||||
log.info('saved {} header blocks'.format(change))
|
||||
self._on_change_controller.add(change)
|
||||
|
||||
def _iterate_headers(self, height, headers):
|
||||
assert len(headers) % HEADER_SIZE == 0
|
||||
for idx in range(len(headers) / HEADER_SIZE):
|
||||
start, end = idx * HEADER_SIZE, (idx + 1) * HEADER_SIZE
|
||||
header = headers[start:end]
|
||||
yield self._deserialize(height+idx, header)
|
||||
|
||||
def _verify_header(self, height, header, previous_header):
|
||||
previous_hash = self._hash_header(previous_header)
|
||||
assert previous_hash == header['prev_block_hash'], \
|
||||
"prev hash mismatch: {} vs {}".format(previous_hash, header['prev_block_hash'])
|
||||
|
||||
bits, target = self._calculate_lbry_next_work_required(height, previous_header, header)
|
||||
assert bits == header['bits'], \
|
||||
"bits mismatch: {} vs {} (hash: {})".format(
|
||||
bits, header['bits'], self._hash_header(header))
|
||||
|
||||
_pow_hash = self._pow_hash_header(header)
|
||||
assert int('0x' + _pow_hash, 16) <= target, \
|
||||
"insufficient proof of work: {} vs target {}".format(
|
||||
int('0x' + _pow_hash, 16), target)
|
||||
|
||||
@staticmethod
|
||||
def _serialize(header):
|
||||
return ''.join([
|
||||
int_to_hex(header['version'], 4),
|
||||
rev_hex(header['prev_block_hash']),
|
||||
rev_hex(header['merkle_root']),
|
||||
rev_hex(header['claim_trie_root']),
|
||||
int_to_hex(int(header['timestamp']), 4),
|
||||
int_to_hex(int(header['bits']), 4),
|
||||
int_to_hex(int(header['nonce']), 4)
|
||||
])
|
||||
|
||||
@staticmethod
|
||||
def _deserialize(height, header):
|
||||
return {
|
||||
'version': hex_to_int(header[0:4]),
|
||||
'prev_block_hash': hash_encode(header[4:36]),
|
||||
'merkle_root': hash_encode(header[36:68]),
|
||||
'claim_trie_root': hash_encode(header[68:100]),
|
||||
'timestamp': hex_to_int(header[100:104]),
|
||||
'bits': hex_to_int(header[104:108]),
|
||||
'nonce': hex_to_int(header[108:112]),
|
||||
'block_height': height
|
||||
}
|
||||
|
||||
def _hash_header(self, header):
|
||||
if header is None:
|
||||
return '0' * 64
|
||||
return hash_encode(Hash(self._serialize(header).decode('hex')))
|
||||
|
||||
def _pow_hash_header(self, header):
|
||||
if header is None:
|
||||
return '0' * 64
|
||||
return hash_encode(PoWHash(self._serialize(header).decode('hex')))
|
||||
|
||||
def _calculate_lbry_next_work_required(self, height, first, last):
|
||||
""" See: lbrycrd/src/lbry.cpp """
|
||||
|
||||
if height == 0:
|
||||
return self.genesis_bits, self.max_target
|
||||
|
||||
# bits to target
|
||||
if self.chain != 'lbrycrd_regtest':
|
||||
bits = last['bits']
|
||||
bitsN = (bits >> 24) & 0xff
|
||||
assert 0x03 <= bitsN <= 0x1f, \
|
||||
"First part of bits should be in [0x03, 0x1d], but it was {}".format(hex(bitsN))
|
||||
bitsBase = bits & 0xffffff
|
||||
assert 0x8000 <= bitsBase <= 0x7fffff, \
|
||||
"Second part of bits should be in [0x8000, 0x7fffff] but it was {}".format(bitsBase)
|
||||
|
||||
# new target
|
||||
retargetTimespan = self.target_timespan
|
||||
nActualTimespan = last['timestamp'] - first['timestamp']
|
||||
|
||||
nModulatedTimespan = retargetTimespan + (nActualTimespan - retargetTimespan) // 8
|
||||
|
||||
nMinTimespan = retargetTimespan - (retargetTimespan // 8)
|
||||
nMaxTimespan = retargetTimespan + (retargetTimespan // 2)
|
||||
|
||||
# Limit adjustment step
|
||||
if nModulatedTimespan < nMinTimespan:
|
||||
nModulatedTimespan = nMinTimespan
|
||||
elif nModulatedTimespan > nMaxTimespan:
|
||||
nModulatedTimespan = nMaxTimespan
|
||||
|
||||
# Retarget
|
||||
bnPowLimit = _ArithUint256(self.max_target)
|
||||
bnNew = _ArithUint256.SetCompact(last['bits'])
|
||||
bnNew *= nModulatedTimespan
|
||||
bnNew //= nModulatedTimespan
|
||||
if bnNew > bnPowLimit:
|
||||
bnNew = bnPowLimit
|
||||
|
||||
return bnNew.GetCompact(), bnNew._value
|
||||
|
||||
|
||||
class _ArithUint256:
|
||||
""" See: lbrycrd/src/arith_uint256.cpp """
|
||||
|
||||
def __init__(self, value):
|
||||
self._value = value
|
||||
|
||||
def __str__(self):
|
||||
return hex(self._value)
|
||||
|
||||
@staticmethod
|
||||
def fromCompact(nCompact):
|
||||
"""Convert a compact representation into its value"""
|
||||
nSize = nCompact >> 24
|
||||
# the lower 23 bits
|
||||
nWord = nCompact & 0x007fffff
|
||||
if nSize <= 3:
|
||||
return nWord >> 8 * (3 - nSize)
|
||||
else:
|
||||
return nWord << 8 * (nSize - 3)
|
||||
|
||||
@classmethod
|
||||
def SetCompact(cls, nCompact):
|
||||
return cls(cls.fromCompact(nCompact))
|
||||
|
||||
def bits(self):
|
||||
"""Returns the position of the highest bit set plus one."""
|
||||
bn = bin(self._value)[2:]
|
||||
for i, d in enumerate(bn):
|
||||
if d:
|
||||
return (len(bn) - i) + 1
|
||||
return 0
|
||||
|
||||
def GetLow64(self):
|
||||
return self._value & 0xffffffffffffffff
|
||||
|
||||
def GetCompact(self):
|
||||
"""Convert a value into its compact representation"""
|
||||
nSize = (self.bits() + 7) // 8
|
||||
nCompact = 0
|
||||
if nSize <= 3:
|
||||
nCompact = self.GetLow64() << 8 * (3 - nSize)
|
||||
else:
|
||||
bn = _ArithUint256(self._value >> 8 * (nSize - 3))
|
||||
nCompact = bn.GetLow64()
|
||||
# The 0x00800000 bit denotes the sign.
|
||||
# Thus, if it is already set, divide the mantissa by 256 and increase the exponent.
|
||||
if nCompact & 0x00800000:
|
||||
nCompact >>= 8
|
||||
nSize += 1
|
||||
assert (nCompact & ~0x007fffff) == 0
|
||||
assert nSize < 256
|
||||
nCompact |= nSize << 24
|
||||
return nCompact
|
||||
|
||||
def __mul__(self, x):
|
||||
# Take the mod because we are limited to an unsigned 256 bit number
|
||||
return _ArithUint256((self._value * x) % 2 ** 256)
|
||||
|
||||
def __ifloordiv__(self, x):
|
||||
self._value = (self._value // x)
|
||||
return self
|
||||
|
||||
def __gt__(self, x):
|
||||
return self._value > x
|
||||
313
lbrynet/wallet/coinchooser.py
Normal file
313
lbrynet/wallet/coinchooser.py
Normal file
|
|
@ -0,0 +1,313 @@
|
|||
import struct
|
||||
import logging
|
||||
from collections import defaultdict, namedtuple
|
||||
from math import floor, log10
|
||||
|
||||
from .hashing import sha256
|
||||
from .constants import COIN, TYPE_ADDRESS
|
||||
from .transaction import Transaction
|
||||
from .errors import NotEnoughFunds
|
||||
|
||||
log = logging.getLogger()
|
||||
|
||||
|
||||
class PRNG(object):
|
||||
"""
|
||||
A simple deterministic PRNG. Used to deterministically shuffle a
|
||||
set of coins - the same set of coins should produce the same output.
|
||||
Although choosing UTXOs "randomly" we want it to be deterministic,
|
||||
so if sending twice from the same UTXO set we choose the same UTXOs
|
||||
to spend. This prevents attacks on users by malicious or stale
|
||||
servers.
|
||||
"""
|
||||
|
||||
def __init__(self, seed):
|
||||
self.sha = sha256(seed)
|
||||
self.pool = bytearray()
|
||||
|
||||
def get_bytes(self, n):
|
||||
while len(self.pool) < n:
|
||||
self.pool.extend(self.sha)
|
||||
self.sha = sha256(self.sha)
|
||||
result, self.pool = self.pool[:n], self.pool[n:]
|
||||
return result
|
||||
|
||||
def random(self):
|
||||
# Returns random double in [0, 1)
|
||||
four = self.get_bytes(4)
|
||||
return struct.unpack("I", four)[0] / 4294967296.0
|
||||
|
||||
def randint(self, start, end):
|
||||
# Returns random integer in [start, end)
|
||||
return start + int(self.random() * (end - start))
|
||||
|
||||
def choice(self, seq):
|
||||
return seq[int(self.random() * len(seq))]
|
||||
|
||||
def shuffle(self, x):
|
||||
for i in reversed(xrange(1, len(x))):
|
||||
# pick an element in x[:i+1] with which to exchange x[i]
|
||||
j = int(self.random() * (i + 1))
|
||||
x[i], x[j] = x[j], x[i]
|
||||
|
||||
|
||||
Bucket = namedtuple('Bucket', ['desc', 'size', 'value', 'coins'])
|
||||
|
||||
|
||||
def strip_unneeded(bkts, sufficient_funds):
|
||||
'''Remove buckets that are unnecessary in achieving the spend amount'''
|
||||
bkts = sorted(bkts, key=lambda bkt: bkt.value)
|
||||
for i in range(len(bkts)):
|
||||
if not sufficient_funds(bkts[i + 1:]):
|
||||
return bkts[i:]
|
||||
# Shouldn't get here
|
||||
return bkts
|
||||
|
||||
|
||||
class CoinChooserBase:
|
||||
def keys(self, coins):
|
||||
raise NotImplementedError
|
||||
|
||||
def bucketize_coins(self, coins):
|
||||
keys = self.keys(coins)
|
||||
buckets = defaultdict(list)
|
||||
for key, coin in zip(keys, coins):
|
||||
buckets[key].append(coin)
|
||||
|
||||
def make_Bucket(desc, coins):
|
||||
size = sum(Transaction.estimated_input_size(coin)
|
||||
for coin in coins)
|
||||
value = sum(coin['value'] for coin in coins)
|
||||
return Bucket(desc, size, value, coins)
|
||||
|
||||
return map(make_Bucket, buckets.keys(), buckets.values())
|
||||
|
||||
def penalty_func(self, tx):
|
||||
def penalty(candidate):
|
||||
return 0
|
||||
|
||||
return penalty
|
||||
|
||||
def change_amounts(self, tx, count, fee_estimator, dust_threshold):
|
||||
# Break change up if bigger than max_change
|
||||
output_amounts = [o[2] for o in tx.outputs()]
|
||||
# Don't split change of less than 0.02 BTC
|
||||
max_change = max(max(output_amounts) * 1.25, 0.02 * COIN)
|
||||
|
||||
# Use N change outputs
|
||||
for n in range(1, count + 1):
|
||||
# How much is left if we add this many change outputs?
|
||||
change_amount = max(0, tx.get_fee() - fee_estimator(n))
|
||||
if change_amount // n <= max_change:
|
||||
break
|
||||
|
||||
# Get a handle on the precision of the output amounts; round our
|
||||
# change to look similar
|
||||
def trailing_zeroes(val):
|
||||
s = str(val)
|
||||
return len(s) - len(s.rstrip('0'))
|
||||
|
||||
zeroes = map(trailing_zeroes, output_amounts)
|
||||
min_zeroes = min(zeroes)
|
||||
max_zeroes = max(zeroes)
|
||||
zeroes = range(max(0, min_zeroes - 1), (max_zeroes + 1) + 1)
|
||||
|
||||
# Calculate change; randomize it a bit if using more than 1 output
|
||||
remaining = change_amount
|
||||
amounts = []
|
||||
while n > 1:
|
||||
average = remaining // n
|
||||
amount = self.p.randint(int(average * 0.7), int(average * 1.3))
|
||||
precision = min(self.p.choice(zeroes), int(floor(log10(amount))))
|
||||
amount = int(round(amount, -precision))
|
||||
amounts.append(amount)
|
||||
remaining -= amount
|
||||
n -= 1
|
||||
|
||||
# Last change output. Round down to maximum precision but lose
|
||||
# no more than 100 satoshis to fees (2dp)
|
||||
N = pow(10, min(2, zeroes[0]))
|
||||
amount = (remaining // N) * N
|
||||
amounts.append(amount)
|
||||
|
||||
assert sum(amounts) <= change_amount
|
||||
|
||||
return amounts
|
||||
|
||||
def change_outputs(self, tx, change_addrs, fee_estimator, dust_threshold):
|
||||
amounts = self.change_amounts(tx, len(change_addrs), fee_estimator,
|
||||
dust_threshold)
|
||||
assert min(amounts) >= 0
|
||||
assert len(change_addrs) >= len(amounts)
|
||||
# If change is above dust threshold after accounting for the
|
||||
# size of the change output, add it to the transaction.
|
||||
dust = sum(amount for amount in amounts if amount < dust_threshold)
|
||||
amounts = [amount for amount in amounts if amount >= dust_threshold]
|
||||
change = [(TYPE_ADDRESS, addr, amount)
|
||||
for addr, amount in zip(change_addrs, amounts)]
|
||||
log.debug('change: %s', change)
|
||||
if dust:
|
||||
log.debug('not keeping dust %s', dust)
|
||||
return change
|
||||
|
||||
def make_tx(self, coins, outputs, change_addrs, fee_estimator,
|
||||
dust_threshold, abandon_txid=None):
|
||||
'''Select unspent coins to spend to pay outputs. If the change is
|
||||
greater than dust_threshold (after adding the change output to
|
||||
the transaction) it is kept, otherwise none is sent and it is
|
||||
added to the transaction fee.'''
|
||||
|
||||
# Deterministic randomness from coins
|
||||
utxos = [c['prevout_hash'] + str(c['prevout_n']) for c in coins]
|
||||
self.p = PRNG(''.join(sorted(utxos)))
|
||||
|
||||
# Copy the ouputs so when adding change we don't modify "outputs"
|
||||
tx = Transaction.from_io([], outputs[:])
|
||||
# Size of the transaction with no inputs and no change
|
||||
base_size = tx.estimated_size()
|
||||
spent_amount = tx.output_value()
|
||||
|
||||
claim_coin = None
|
||||
if abandon_txid is not None:
|
||||
claim_coins = [coin for coin in coins if coin['is_claim']]
|
||||
assert len(claim_coins) >= 1
|
||||
claim_coin = claim_coins[0]
|
||||
spent_amount -= claim_coin['value']
|
||||
coins = [coin for coin in coins if not coin['is_claim']]
|
||||
|
||||
def sufficient_funds(buckets):
|
||||
'''Given a list of buckets, return True if it has enough
|
||||
value to pay for the transaction'''
|
||||
total_input = sum(bucket.value for bucket in buckets)
|
||||
total_size = sum(bucket.size for bucket in buckets) + base_size
|
||||
return total_input >= spent_amount + fee_estimator(total_size)
|
||||
|
||||
# Collect the coins into buckets, choose a subset of the buckets
|
||||
buckets = self.bucketize_coins(coins)
|
||||
buckets = self.choose_buckets(buckets, sufficient_funds,
|
||||
self.penalty_func(tx))
|
||||
|
||||
if claim_coin is not None:
|
||||
tx.add_inputs([claim_coin])
|
||||
tx.add_inputs([coin for b in buckets for coin in b.coins])
|
||||
tx_size = base_size + sum(bucket.size for bucket in buckets)
|
||||
|
||||
# This takes a count of change outputs and returns a tx fee;
|
||||
# each pay-to-bitcoin-address output serializes as 34 bytes
|
||||
def fee(count):
|
||||
return fee_estimator(tx_size + count * 34)
|
||||
|
||||
change = self.change_outputs(tx, change_addrs, fee, dust_threshold)
|
||||
tx.add_outputs(change)
|
||||
|
||||
log.debug("using %i inputs", len(tx.inputs()))
|
||||
log.info("using buckets: %s", [bucket.desc for bucket in buckets])
|
||||
|
||||
return tx
|
||||
|
||||
|
||||
class CoinChooserOldestFirst(CoinChooserBase):
|
||||
'''Maximize transaction priority. Select the oldest unspent
|
||||
transaction outputs in your wallet, that are sufficient to cover
|
||||
the spent amount. Then, remove any unneeded inputs, starting with
|
||||
the smallest in value.
|
||||
'''
|
||||
|
||||
def keys(self, coins):
|
||||
return [coin['prevout_hash'] + ':' + str(coin['prevout_n'])
|
||||
for coin in coins]
|
||||
|
||||
def choose_buckets(self, buckets, sufficient_funds, penalty_func):
|
||||
'''Spend the oldest buckets first.'''
|
||||
# Unconfirmed coins are young, not old
|
||||
def adj_height(height):
|
||||
return 99999999 if height == 0 else height
|
||||
|
||||
buckets.sort(key=lambda b: max(adj_height(coin['height'])
|
||||
for coin in b.coins))
|
||||
selected = []
|
||||
for bucket in buckets:
|
||||
selected.append(bucket)
|
||||
if sufficient_funds(selected):
|
||||
return strip_unneeded(selected, sufficient_funds)
|
||||
raise NotEnoughFunds()
|
||||
|
||||
|
||||
class CoinChooserRandom(CoinChooserBase):
|
||||
def keys(self, coins):
|
||||
return [coin['prevout_hash'] + ':' + str(coin['prevout_n'])
|
||||
for coin in coins]
|
||||
|
||||
def bucket_candidates(self, buckets, sufficient_funds):
|
||||
'''Returns a list of bucket sets.'''
|
||||
candidates = set()
|
||||
|
||||
# Add all singletons
|
||||
for n, bucket in enumerate(buckets):
|
||||
if sufficient_funds([bucket]):
|
||||
candidates.add((n,))
|
||||
|
||||
# And now some random ones
|
||||
attempts = min(100, (len(buckets) - 1) * 10 + 1)
|
||||
permutation = range(len(buckets))
|
||||
for i in range(attempts):
|
||||
# Get a random permutation of the buckets, and
|
||||
# incrementally combine buckets until sufficient
|
||||
self.p.shuffle(permutation)
|
||||
bkts = []
|
||||
for count, index in enumerate(permutation):
|
||||
bkts.append(buckets[index])
|
||||
if sufficient_funds(bkts):
|
||||
candidates.add(tuple(sorted(permutation[:count + 1])))
|
||||
break
|
||||
else:
|
||||
raise NotEnoughFunds()
|
||||
|
||||
candidates = [[buckets[n] for n in c] for c in candidates]
|
||||
return [strip_unneeded(c, sufficient_funds) for c in candidates]
|
||||
|
||||
def choose_buckets(self, buckets, sufficient_funds, penalty_func):
|
||||
candidates = self.bucket_candidates(buckets, sufficient_funds)
|
||||
penalties = [penalty_func(cand) for cand in candidates]
|
||||
winner = candidates[penalties.index(min(penalties))]
|
||||
log.debug("Bucket sets: %i", len(buckets))
|
||||
log.debug("Winning penalty: %s", min(penalties))
|
||||
return winner
|
||||
|
||||
|
||||
class CoinChooserPrivacy(CoinChooserRandom):
|
||||
'''Attempts to better preserve user privacy. First, if any coin is
|
||||
spent from a user address, all coins are. Compared to spending
|
||||
from other addresses to make up an amount, this reduces
|
||||
information leakage about sender holdings. It also helps to
|
||||
reduce blockchain UTXO bloat, and reduce future privacy loss that
|
||||
would come from reusing that address' remaining UTXOs. Second, it
|
||||
penalizes change that is quite different to the sent amount.
|
||||
Third, it penalizes change that is too big.'''
|
||||
|
||||
def keys(self, coins):
|
||||
return [coin['address'] for coin in coins]
|
||||
|
||||
def penalty_func(self, tx):
|
||||
min_change = min(o[2] for o in tx.outputs()) * 0.75
|
||||
max_change = max(o[2] for o in tx.outputs()) * 1.33
|
||||
spent_amount = sum(o[2] for o in tx.outputs())
|
||||
|
||||
def penalty(buckets):
|
||||
badness = len(buckets) - 1
|
||||
total_input = sum(bucket.value for bucket in buckets)
|
||||
change = float(total_input - spent_amount)
|
||||
# Penalize change not roughly in output range
|
||||
if change < min_change:
|
||||
badness += (min_change - change) / (min_change + 10000)
|
||||
elif change > max_change:
|
||||
badness += (change - max_change) / (max_change + 10000)
|
||||
# Penalize large change; 5 BTC excess ~= using 1 more input
|
||||
badness += change / (COIN * 5)
|
||||
return badness
|
||||
|
||||
return penalty
|
||||
|
||||
|
||||
COIN_CHOOSERS = {'Priority': CoinChooserOldestFirst,
|
||||
'Privacy': CoinChooserPrivacy}
|
||||
76
lbrynet/wallet/constants.py
Normal file
76
lbrynet/wallet/constants.py
Normal file
|
|
@ -0,0 +1,76 @@
|
|||
from lbrynet import __version__
|
||||
LBRYUM_VERSION = __version__
|
||||
PROTOCOL_VERSION = '0.10' # protocol version requested
|
||||
NEW_SEED_VERSION = 11 # lbryum versions >= 2.0
|
||||
OLD_SEED_VERSION = 4 # lbryum versions < 2.0
|
||||
|
||||
# The hash of the mnemonic seed must begin with this
|
||||
SEED_PREFIX = '01' # Electrum standard wallet
|
||||
SEED_PREFIX_2FA = '101' # extended seed for two-factor authentication
|
||||
|
||||
|
||||
RECOMMENDED_FEE = 50000
|
||||
COINBASE_MATURITY = 100
|
||||
COIN = 100000000
|
||||
|
||||
# supported types of transaction outputs
|
||||
TYPE_ADDRESS = 1
|
||||
TYPE_PUBKEY = 2
|
||||
TYPE_SCRIPT = 4
|
||||
TYPE_CLAIM = 8
|
||||
TYPE_SUPPORT = 16
|
||||
TYPE_UPDATE = 32
|
||||
|
||||
# claim related constants
|
||||
EXPIRATION_BLOCKS = 262974
|
||||
RECOMMENDED_CLAIMTRIE_HASH_CONFIRMS = 1
|
||||
|
||||
NO_SIGNATURE = 'ff'
|
||||
|
||||
NULL_HASH = '0000000000000000000000000000000000000000000000000000000000000000'
|
||||
HEADER_SIZE = 112
|
||||
BLOCKS_PER_CHUNK = 96
|
||||
CLAIM_ID_SIZE = 20
|
||||
|
||||
HEADERS_URL = "https://s3.amazonaws.com/lbry-blockchain-headers/blockchain_headers_latest"
|
||||
|
||||
DEFAULT_PORTS = {'t': '50001', 's': '50002', 'h': '8081', 'g': '8082'}
|
||||
NODES_RETRY_INTERVAL = 60
|
||||
SERVER_RETRY_INTERVAL = 10
|
||||
MAX_BATCH_QUERY_SIZE = 500
|
||||
proxy_modes = ['socks4', 'socks5', 'http']
|
||||
|
||||
# Main network and testnet3 definitions
|
||||
# these values follow the parameters in lbrycrd/src/chainparams.cpp
|
||||
blockchain_params = {
|
||||
'lbrycrd_main': {
|
||||
'pubkey_address': 0,
|
||||
'script_address': 5,
|
||||
'pubkey_address_prefix': 85,
|
||||
'script_address_prefix': 122,
|
||||
'genesis_hash': '9c89283ba0f3227f6c03b70216b9f665f0118d5e0fa729cedf4fb34d6a34f463',
|
||||
'max_target': 0x0000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF,
|
||||
'genesis_bits': 0x1f00ffff,
|
||||
'target_timespan': 150
|
||||
},
|
||||
'lbrycrd_testnet': {
|
||||
'pubkey_address': 0,
|
||||
'script_address': 5,
|
||||
'pubkey_address_prefix': 111,
|
||||
'script_address_prefix': 196,
|
||||
'genesis_hash': '9c89283ba0f3227f6c03b70216b9f665f0118d5e0fa729cedf4fb34d6a34f463',
|
||||
'max_target': 0x0000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF,
|
||||
'genesis_bits': 0x1f00ffff,
|
||||
'target_timespan': 150
|
||||
},
|
||||
'lbrycrd_regtest': {
|
||||
'pubkey_address': 0,
|
||||
'script_address': 5,
|
||||
'pubkey_address_prefix': 111,
|
||||
'script_address_prefix': 196,
|
||||
'genesis_hash': '6e3fcf1299d4ec5d79c3a4c91d624a4acf9e2e173d95a1a0504f677669687556',
|
||||
'max_target': 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF,
|
||||
'genesis_bits': 0x207fffff,
|
||||
'target_timespan': 1
|
||||
}
|
||||
}
|
||||
47
lbrynet/wallet/enumeration.py
Normal file
47
lbrynet/wallet/enumeration.py
Normal file
|
|
@ -0,0 +1,47 @@
|
|||
import exceptions
|
||||
import types
|
||||
|
||||
|
||||
class EnumException(exceptions.Exception):
|
||||
pass
|
||||
|
||||
|
||||
class Enumeration(object):
|
||||
"""
|
||||
enum-like type
|
||||
From the Python Cookbook, downloaded from http://code.activestate.com/recipes/67107/
|
||||
"""
|
||||
|
||||
def __init__(self, name, enumList):
|
||||
self.__doc__ = name
|
||||
lookup = {}
|
||||
reverseLookup = {}
|
||||
i = 0
|
||||
uniqueNames = []
|
||||
uniqueValues = []
|
||||
for x in enumList:
|
||||
if isinstance(x, types.TupleType):
|
||||
x, i = x
|
||||
if not isinstance(x, types.StringType):
|
||||
raise EnumException, "enum name is not a string: " + x
|
||||
if not isinstance(i, types.IntType):
|
||||
raise EnumException, "enum value is not an integer: " + i
|
||||
if x in uniqueNames:
|
||||
raise EnumException, "enum name is not unique: " + x
|
||||
if i in uniqueValues:
|
||||
raise EnumException, "enum value is not unique for " + x
|
||||
uniqueNames.append(x)
|
||||
uniqueValues.append(i)
|
||||
lookup[x] = i
|
||||
reverseLookup[i] = x
|
||||
i = i + 1
|
||||
self.lookup = lookup
|
||||
self.reverseLookup = reverseLookup
|
||||
|
||||
def __getattr__(self, attr):
|
||||
if attr not in self.lookup:
|
||||
raise AttributeError(attr)
|
||||
return self.lookup[attr]
|
||||
|
||||
def whatis(self, value):
|
||||
return self.reverseLookup[value]
|
||||
43
lbrynet/wallet/errors.py
Normal file
43
lbrynet/wallet/errors.py
Normal file
|
|
@ -0,0 +1,43 @@
|
|||
class TransportException(Exception):
|
||||
pass
|
||||
|
||||
|
||||
class ServiceException(Exception):
|
||||
code = -2
|
||||
|
||||
|
||||
class RemoteServiceException(Exception):
|
||||
pass
|
||||
|
||||
|
||||
class ProtocolException(Exception):
|
||||
pass
|
||||
|
||||
|
||||
class MethodNotFoundException(ServiceException):
|
||||
code = -3
|
||||
|
||||
|
||||
class NotEnoughFunds(Exception):
|
||||
pass
|
||||
|
||||
|
||||
class InvalidPassword(Exception):
|
||||
def __str__(self):
|
||||
return "Incorrect password"
|
||||
|
||||
|
||||
class Timeout(Exception):
|
||||
pass
|
||||
|
||||
|
||||
class InvalidProofError(Exception):
|
||||
pass
|
||||
|
||||
|
||||
class ChainValidationError(Exception):
|
||||
pass
|
||||
|
||||
|
||||
class InvalidClaimId(Exception):
|
||||
pass
|
||||
50
lbrynet/wallet/hashing.py
Normal file
50
lbrynet/wallet/hashing.py
Normal file
|
|
@ -0,0 +1,50 @@
|
|||
import hashlib
|
||||
import hmac
|
||||
|
||||
|
||||
def sha256(x):
|
||||
return hashlib.sha256(x).digest()
|
||||
|
||||
|
||||
def sha512(x):
|
||||
return hashlib.sha512(x).digest()
|
||||
|
||||
|
||||
def ripemd160(x):
|
||||
h = hashlib.new('ripemd160')
|
||||
h.update(x)
|
||||
return h.digest()
|
||||
|
||||
|
||||
def Hash(x):
|
||||
if type(x) is unicode:
|
||||
x = x.encode('utf-8')
|
||||
return sha256(sha256(x))
|
||||
|
||||
|
||||
def PoWHash(x):
|
||||
if type(x) is unicode:
|
||||
x = x.encode('utf-8')
|
||||
r = sha512(Hash(x))
|
||||
r1 = ripemd160(r[:len(r) / 2])
|
||||
r2 = ripemd160(r[len(r) / 2:])
|
||||
r3 = Hash(r1 + r2)
|
||||
return r3
|
||||
|
||||
|
||||
def hash_encode(x):
|
||||
return x[::-1].encode('hex')
|
||||
|
||||
|
||||
def hash_decode(x):
|
||||
return x.decode('hex')[::-1]
|
||||
|
||||
|
||||
def hmac_sha_512(x, y):
|
||||
return hmac.new(x, y, hashlib.sha512).digest()
|
||||
|
||||
|
||||
def hash_160(public_key):
|
||||
md = hashlib.new('ripemd160')
|
||||
md.update(sha256(public_key))
|
||||
return md.digest()
|
||||
633
lbrynet/wallet/lbrycrd.py
Normal file
633
lbrynet/wallet/lbrycrd.py
Normal file
|
|
@ -0,0 +1,633 @@
|
|||
import base64
|
||||
import hashlib
|
||||
import hmac
|
||||
import struct
|
||||
import logging
|
||||
import aes
|
||||
import ecdsa
|
||||
from ecdsa import numbertheory, util
|
||||
from ecdsa.curves import SECP256k1
|
||||
from ecdsa.ecdsa import curve_secp256k1, generator_secp256k1
|
||||
from ecdsa.ellipticcurve import Point
|
||||
from ecdsa.util import number_to_string, string_to_number
|
||||
|
||||
from lbryschema.address import public_key_to_address
|
||||
from lbryschema.schema import B58_CHARS
|
||||
from lbryschema.base import b58encode_with_checksum, b58decode_strip_checksum
|
||||
|
||||
from . import msqr
|
||||
from .util import rev_hex, var_int, int_to_hex
|
||||
from .hashing import Hash, sha256, hash_160
|
||||
from .errors import InvalidPassword, InvalidClaimId
|
||||
from .constants import CLAIM_ID_SIZE
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
|
||||
# AES encryption
|
||||
EncodeAES = lambda secret, s: base64.b64encode(aes.encryptData(secret, s))
|
||||
DecodeAES = lambda secret, e: aes.decryptData(secret, base64.b64decode(e))
|
||||
|
||||
|
||||
# get the claim id hash from txid bytes and int n
|
||||
def claim_id_hash(txid, n):
|
||||
return hash_160(txid + struct.pack('>I', n))
|
||||
|
||||
|
||||
# deocde a claim_id hex string
|
||||
def decode_claim_id_hex(claim_id_hex):
|
||||
claim_id = rev_hex(claim_id_hex).decode('hex')
|
||||
if len(claim_id) != CLAIM_ID_SIZE:
|
||||
raise InvalidClaimId()
|
||||
return claim_id
|
||||
|
||||
|
||||
# encode claim id bytes into hex string
|
||||
def encode_claim_id_hex(claim_id):
|
||||
return rev_hex(claim_id.encode('hex'))
|
||||
|
||||
|
||||
def strip_PKCS7_padding(s):
|
||||
"""return s stripped of PKCS7 padding"""
|
||||
if len(s) % 16 or not s:
|
||||
raise ValueError("String of len %d can't be PCKS7-padded" % len(s))
|
||||
numpads = ord(s[-1])
|
||||
if numpads > 16:
|
||||
raise ValueError("String ending with %r can't be PCKS7-padded" % s[-1])
|
||||
if s[-numpads:] != numpads * chr(numpads):
|
||||
raise ValueError("Invalid PKCS7 padding")
|
||||
return s[:-numpads]
|
||||
|
||||
|
||||
# backport padding fix to AES module
|
||||
aes.strip_PKCS7_padding = strip_PKCS7_padding
|
||||
|
||||
|
||||
def aes_encrypt_with_iv(key, iv, data):
|
||||
mode = aes.AESModeOfOperation.modeOfOperation["CBC"]
|
||||
key = map(ord, key)
|
||||
iv = map(ord, iv)
|
||||
data = aes.append_PKCS7_padding(data)
|
||||
keysize = len(key)
|
||||
assert keysize in aes.AES.keySize.values(), 'invalid key size: %s' % keysize
|
||||
moo = aes.AESModeOfOperation()
|
||||
(mode, length, ciph) = moo.encrypt(data, mode, key, keysize, iv)
|
||||
return ''.join(map(chr, ciph))
|
||||
|
||||
|
||||
def aes_decrypt_with_iv(key, iv, data):
|
||||
mode = aes.AESModeOfOperation.modeOfOperation["CBC"]
|
||||
key = map(ord, key)
|
||||
iv = map(ord, iv)
|
||||
keysize = len(key)
|
||||
assert keysize in aes.AES.keySize.values(), 'invalid key size: %s' % keysize
|
||||
data = map(ord, data)
|
||||
moo = aes.AESModeOfOperation()
|
||||
decr = moo.decrypt(data, None, mode, key, keysize, iv)
|
||||
decr = strip_PKCS7_padding(decr)
|
||||
return decr
|
||||
|
||||
|
||||
def pw_encode(s, password):
|
||||
if password:
|
||||
secret = Hash(password)
|
||||
return EncodeAES(secret, s.encode("utf8"))
|
||||
else:
|
||||
return s
|
||||
|
||||
|
||||
def pw_decode(s, password):
|
||||
if password is not None:
|
||||
secret = Hash(password)
|
||||
try:
|
||||
d = DecodeAES(secret, s).decode("utf8")
|
||||
except Exception:
|
||||
raise InvalidPassword()
|
||||
return d
|
||||
else:
|
||||
return s
|
||||
|
||||
|
||||
def op_push(i):
|
||||
if i < 0x4c:
|
||||
return int_to_hex(i)
|
||||
elif i < 0xff:
|
||||
return '4c' + int_to_hex(i)
|
||||
elif i < 0xffff:
|
||||
return '4d' + int_to_hex(i, 2)
|
||||
else:
|
||||
return '4e' + int_to_hex(i, 4)
|
||||
|
||||
|
||||
# pywallet openssl private key implementation
|
||||
|
||||
def i2o_ECPublicKey(pubkey, compressed=False):
|
||||
# public keys are 65 bytes long (520 bits)
|
||||
# 0x04 + 32-byte X-coordinate + 32-byte Y-coordinate
|
||||
# 0x00 = point at infinity, 0x02 and 0x03 = compressed, 0x04 = uncompressed
|
||||
# compressed keys: <sign> <x> where <sign> is 0x02 if y is even and 0x03 if y is odd
|
||||
if compressed:
|
||||
if pubkey.point.y() & 1:
|
||||
key = '03' + '%064x' % pubkey.point.x()
|
||||
else:
|
||||
key = '02' + '%064x' % pubkey.point.x()
|
||||
else:
|
||||
key = '04' + \
|
||||
'%064x' % pubkey.point.x() + \
|
||||
'%064x' % pubkey.point.y()
|
||||
|
||||
return key.decode('hex')
|
||||
|
||||
|
||||
# end pywallet openssl private key implementation
|
||||
# functions from pywallet
|
||||
|
||||
|
||||
def PrivKeyToSecret(privkey):
|
||||
return privkey[9:9 + 32]
|
||||
|
||||
|
||||
def SecretToASecret(secret, compressed=False, addrtype=0):
|
||||
vchIn = chr((addrtype + 128) & 255) + secret
|
||||
if compressed:
|
||||
vchIn += '\01'
|
||||
return b58encode_with_checksum(vchIn)
|
||||
|
||||
|
||||
def ASecretToSecret(key, addrtype=0):
|
||||
vch = b58decode_strip_checksum(key)
|
||||
if vch and vch[0] == chr((addrtype + 128) & 255):
|
||||
return vch[1:]
|
||||
elif is_minikey(key):
|
||||
return minikey_to_private_key(key)
|
||||
else:
|
||||
return False
|
||||
|
||||
|
||||
def regenerate_key(sec):
|
||||
b = ASecretToSecret(sec)
|
||||
if not b:
|
||||
return False
|
||||
b = b[0:32]
|
||||
return EC_KEY(b)
|
||||
|
||||
|
||||
def GetPubKey(pubkey, compressed=False):
|
||||
return i2o_ECPublicKey(pubkey, compressed)
|
||||
|
||||
|
||||
def GetSecret(pkey):
|
||||
return ('%064x' % pkey.secret).decode('hex')
|
||||
|
||||
|
||||
def is_compressed(sec):
|
||||
b = ASecretToSecret(sec)
|
||||
return len(b) == 33
|
||||
|
||||
|
||||
def public_key_from_private_key(sec):
|
||||
# rebuild public key from private key, compressed or uncompressed
|
||||
pkey = regenerate_key(sec)
|
||||
assert pkey
|
||||
compressed = is_compressed(sec)
|
||||
public_key = GetPubKey(pkey.pubkey, compressed)
|
||||
return public_key.encode('hex')
|
||||
|
||||
|
||||
def address_from_private_key(sec):
|
||||
public_key = public_key_from_private_key(sec)
|
||||
address = public_key_to_address(public_key.decode('hex'))
|
||||
return address
|
||||
|
||||
|
||||
def is_private_key(key):
|
||||
try:
|
||||
k = ASecretToSecret(key)
|
||||
return k is not False
|
||||
except:
|
||||
return False
|
||||
|
||||
# end pywallet functions
|
||||
|
||||
|
||||
def is_minikey(text):
|
||||
# Minikeys are typically 22 or 30 characters, but this routine
|
||||
# permits any length of 20 or more provided the minikey is valid.
|
||||
# A valid minikey must begin with an 'S', be in base58, and when
|
||||
# suffixed with '?' have its SHA256 hash begin with a zero byte.
|
||||
# They are widely used in Casascius physical bitoins.
|
||||
return (len(text) >= 20 and text[0] == 'S'
|
||||
and all(c in B58_CHARS for c in text)
|
||||
and ord(sha256(text + '?')[0]) == 0)
|
||||
|
||||
|
||||
def minikey_to_private_key(text):
|
||||
return sha256(text)
|
||||
|
||||
|
||||
def msg_magic(message):
|
||||
varint = var_int(len(message))
|
||||
encoded_varint = "".join([chr(int(varint[i:i + 2], 16)) for i in xrange(0, len(varint), 2)])
|
||||
return "\x18Bitcoin Signed Message:\n" + encoded_varint + message
|
||||
|
||||
|
||||
def verify_message(address, signature, message):
|
||||
try:
|
||||
EC_KEY.verify_message(address, signature, message)
|
||||
return True
|
||||
except Exception as e:
|
||||
return False
|
||||
|
||||
|
||||
def encrypt_message(message, pubkey):
|
||||
return EC_KEY.encrypt_message(message, pubkey.decode('hex'))
|
||||
|
||||
|
||||
def chunks(l, n):
|
||||
return [l[i:i + n] for i in xrange(0, len(l), n)]
|
||||
|
||||
|
||||
def ECC_YfromX(x, curved=curve_secp256k1, odd=True):
|
||||
_p = curved.p()
|
||||
_a = curved.a()
|
||||
_b = curved.b()
|
||||
for offset in range(128):
|
||||
Mx = x + offset
|
||||
My2 = pow(Mx, 3, _p) + _a * pow(Mx, 2, _p) + _b % _p
|
||||
My = pow(My2, (_p + 1) / 4, _p)
|
||||
|
||||
if curved.contains_point(Mx, My):
|
||||
if odd == bool(My & 1):
|
||||
return [My, offset]
|
||||
return [_p - My, offset]
|
||||
raise Exception('ECC_YfromX: No Y found')
|
||||
|
||||
|
||||
def negative_point(P):
|
||||
return Point(P.curve(), P.x(), -P.y(), P.order())
|
||||
|
||||
|
||||
def point_to_ser(P, comp=True):
|
||||
if comp:
|
||||
return (('%02x' % (2 + (P.y() & 1))) + ('%064x' % P.x())).decode('hex')
|
||||
return ('04' + ('%064x' % P.x()) + ('%064x' % P.y())).decode('hex')
|
||||
|
||||
|
||||
def ser_to_point(Aser):
|
||||
curve = curve_secp256k1
|
||||
generator = generator_secp256k1
|
||||
_r = generator.order()
|
||||
assert Aser[0] in ['\x02', '\x03', '\x04']
|
||||
if Aser[0] == '\x04':
|
||||
return Point(curve, string_to_number(Aser[1:33]), string_to_number(Aser[33:]), _r)
|
||||
Mx = string_to_number(Aser[1:])
|
||||
return Point(curve, Mx, ECC_YfromX(Mx, curve, Aser[0] == '\x03')[0], _r)
|
||||
|
||||
|
||||
class MyVerifyingKey(ecdsa.VerifyingKey):
|
||||
@classmethod
|
||||
def from_signature(cls, sig, recid, h, curve):
|
||||
""" See http://www.secg.org/download/aid-780/sec1-v2.pdf, chapter 4.1.6 """
|
||||
curveFp = curve.curve
|
||||
G = curve.generator
|
||||
order = G.order()
|
||||
# extract r,s from signature
|
||||
r, s = util.sigdecode_string(sig, order)
|
||||
# 1.1
|
||||
x = r + (recid / 2) * order
|
||||
# 1.3
|
||||
alpha = (x * x * x + curveFp.a() * x + curveFp.b()) % curveFp.p()
|
||||
beta = msqr.modular_sqrt(alpha, curveFp.p())
|
||||
y = beta if (beta - recid) % 2 == 0 else curveFp.p() - beta
|
||||
# 1.4 the constructor checks that nR is at infinity
|
||||
R = Point(curveFp, x, y, order)
|
||||
# 1.5 compute e from message:
|
||||
e = string_to_number(h)
|
||||
minus_e = -e % order
|
||||
# 1.6 compute Q = r^-1 (sR - eG)
|
||||
inv_r = numbertheory.inverse_mod(r, order)
|
||||
Q = inv_r * (s * R + minus_e * G)
|
||||
return cls.from_public_point(Q, curve)
|
||||
|
||||
|
||||
class MySigningKey(ecdsa.SigningKey):
|
||||
"""Enforce low S values in signatures"""
|
||||
|
||||
def sign_number(self, number, entropy=None, k=None):
|
||||
curve = SECP256k1
|
||||
G = curve.generator
|
||||
order = G.order()
|
||||
r, s = ecdsa.SigningKey.sign_number(self, number, entropy, k)
|
||||
if s > order / 2:
|
||||
s = order - s
|
||||
return r, s
|
||||
|
||||
|
||||
class EC_KEY(object):
|
||||
def __init__(self, k):
|
||||
secret = string_to_number(k)
|
||||
self.pubkey = ecdsa.ecdsa.Public_key(generator_secp256k1, generator_secp256k1 * secret)
|
||||
self.privkey = ecdsa.ecdsa.Private_key(self.pubkey, secret)
|
||||
self.secret = secret
|
||||
|
||||
def get_public_key(self, compressed=True):
|
||||
return point_to_ser(self.pubkey.point, compressed).encode('hex')
|
||||
|
||||
def sign(self, msg_hash):
|
||||
private_key = MySigningKey.from_secret_exponent(self.secret, curve=SECP256k1)
|
||||
public_key = private_key.get_verifying_key()
|
||||
signature = private_key.sign_digest_deterministic(msg_hash, hashfunc=hashlib.sha256,
|
||||
sigencode=ecdsa.util.sigencode_string)
|
||||
assert public_key.verify_digest(signature, msg_hash, sigdecode=ecdsa.util.sigdecode_string)
|
||||
return signature
|
||||
|
||||
def sign_message(self, message, compressed, address):
|
||||
signature = self.sign(Hash(msg_magic(message)))
|
||||
for i in range(4):
|
||||
sig = chr(27 + i + (4 if compressed else 0)) + signature
|
||||
try:
|
||||
self.verify_message(address, sig, message)
|
||||
return sig
|
||||
except Exception:
|
||||
log.exception("error: cannot sign message")
|
||||
continue
|
||||
raise Exception("error: cannot sign message")
|
||||
|
||||
@classmethod
|
||||
def verify_message(cls, address, sig, message):
|
||||
if len(sig) != 65:
|
||||
raise Exception("Wrong encoding")
|
||||
nV = ord(sig[0])
|
||||
if nV < 27 or nV >= 35:
|
||||
raise Exception("Bad encoding")
|
||||
if nV >= 31:
|
||||
compressed = True
|
||||
nV -= 4
|
||||
else:
|
||||
compressed = False
|
||||
recid = nV - 27
|
||||
|
||||
h = Hash(msg_magic(message))
|
||||
public_key = MyVerifyingKey.from_signature(sig[1:], recid, h, curve=SECP256k1)
|
||||
# check public key
|
||||
public_key.verify_digest(sig[1:], h, sigdecode=ecdsa.util.sigdecode_string)
|
||||
pubkey = point_to_ser(public_key.pubkey.point, compressed)
|
||||
# check that we get the original signing address
|
||||
addr = public_key_to_address(pubkey)
|
||||
if address != addr:
|
||||
raise Exception("Bad signature")
|
||||
|
||||
# ECIES encryption/decryption methods; AES-128-CBC with PKCS7 is used as the cipher;
|
||||
# hmac-sha256 is used as the mac
|
||||
|
||||
@classmethod
|
||||
def encrypt_message(cls, message, pubkey):
|
||||
|
||||
pk = ser_to_point(pubkey)
|
||||
if not ecdsa.ecdsa.point_is_valid(generator_secp256k1, pk.x(), pk.y()):
|
||||
raise Exception('invalid pubkey')
|
||||
|
||||
ephemeral_exponent = number_to_string(ecdsa.util.randrange(pow(2, 256)),
|
||||
generator_secp256k1.order())
|
||||
ephemeral = EC_KEY(ephemeral_exponent)
|
||||
ecdh_key = point_to_ser(pk * ephemeral.privkey.secret_multiplier)
|
||||
key = hashlib.sha512(ecdh_key).digest()
|
||||
iv, key_e, key_m = key[0:16], key[16:32], key[32:]
|
||||
ciphertext = aes_encrypt_with_iv(key_e, iv, message)
|
||||
ephemeral_pubkey = ephemeral.get_public_key(compressed=True).decode('hex')
|
||||
encrypted = 'BIE1' + ephemeral_pubkey + ciphertext
|
||||
mac = hmac.new(key_m, encrypted, hashlib.sha256).digest()
|
||||
|
||||
return base64.b64encode(encrypted + mac)
|
||||
|
||||
def decrypt_message(self, encrypted):
|
||||
|
||||
encrypted = base64.b64decode(encrypted)
|
||||
|
||||
if len(encrypted) < 85:
|
||||
raise Exception('invalid ciphertext: length')
|
||||
|
||||
magic = encrypted[:4]
|
||||
ephemeral_pubkey = encrypted[4:37]
|
||||
ciphertext = encrypted[37:-32]
|
||||
mac = encrypted[-32:]
|
||||
|
||||
if magic != 'BIE1':
|
||||
raise Exception('invalid ciphertext: invalid magic bytes')
|
||||
|
||||
try:
|
||||
ephemeral_pubkey = ser_to_point(ephemeral_pubkey)
|
||||
except AssertionError, e:
|
||||
raise Exception('invalid ciphertext: invalid ephemeral pubkey')
|
||||
|
||||
if not ecdsa.ecdsa.point_is_valid(generator_secp256k1, ephemeral_pubkey.x(),
|
||||
ephemeral_pubkey.y()):
|
||||
raise Exception('invalid ciphertext: invalid ephemeral pubkey')
|
||||
|
||||
ecdh_key = point_to_ser(ephemeral_pubkey * self.privkey.secret_multiplier)
|
||||
key = hashlib.sha512(ecdh_key).digest()
|
||||
iv, key_e, key_m = key[0:16], key[16:32], key[32:]
|
||||
if mac != hmac.new(key_m, encrypted[:-32], hashlib.sha256).digest():
|
||||
raise Exception('invalid ciphertext: invalid mac')
|
||||
|
||||
return aes_decrypt_with_iv(key_e, iv, ciphertext)
|
||||
|
||||
|
||||
# BIP32
|
||||
|
||||
def random_seed(n):
|
||||
return "%032x" % ecdsa.util.randrange(pow(2, n))
|
||||
|
||||
|
||||
BIP32_PRIME = 0x80000000
|
||||
|
||||
|
||||
def get_pubkeys_from_secret(secret):
|
||||
# public key
|
||||
private_key = ecdsa.SigningKey.from_string(secret, curve=SECP256k1)
|
||||
public_key = private_key.get_verifying_key()
|
||||
K = public_key.to_string()
|
||||
K_compressed = GetPubKey(public_key.pubkey, True)
|
||||
return K, K_compressed
|
||||
|
||||
|
||||
# Child private key derivation function (from master private key)
|
||||
# k = master private key (32 bytes)
|
||||
# c = master chain code (extra entropy for key derivation) (32 bytes)
|
||||
# n = the index of the key we want to derive. (only 32 bits will be used)
|
||||
# If n is negative (i.e. the 32nd bit is set), the resulting private key's
|
||||
# corresponding public key can NOT be determined without the master private key.
|
||||
# However, if n is positive, the resulting private key's corresponding
|
||||
# public key can be determined without the master private key.
|
||||
def CKD_priv(k, c, n):
|
||||
is_prime = n & BIP32_PRIME
|
||||
return _CKD_priv(k, c, rev_hex(int_to_hex(n, 4)).decode('hex'), is_prime)
|
||||
|
||||
|
||||
def _CKD_priv(k, c, s, is_prime):
|
||||
order = generator_secp256k1.order()
|
||||
keypair = EC_KEY(k)
|
||||
cK = GetPubKey(keypair.pubkey, True)
|
||||
data = chr(0) + k + s if is_prime else cK + s
|
||||
I = hmac.new(c, data, hashlib.sha512).digest()
|
||||
k_n = number_to_string((string_to_number(I[0:32]) + string_to_number(k)) % order, order)
|
||||
c_n = I[32:]
|
||||
return k_n, c_n
|
||||
|
||||
|
||||
# Child public key derivation function (from public key only)
|
||||
# K = master public key
|
||||
# c = master chain code
|
||||
# n = index of key we want to derive
|
||||
# This function allows us to find the nth public key, as long as n is
|
||||
# non-negative. If n is negative, we need the master private key to find it.
|
||||
def CKD_pub(cK, c, n):
|
||||
if n & BIP32_PRIME:
|
||||
raise Exception("CKD pub error")
|
||||
return _CKD_pub(cK, c, rev_hex(int_to_hex(n, 4)).decode('hex'))
|
||||
|
||||
|
||||
# helper function, callable with arbitrary string
|
||||
def _CKD_pub(cK, c, s):
|
||||
order = generator_secp256k1.order()
|
||||
I = hmac.new(c, cK + s, hashlib.sha512).digest()
|
||||
curve = SECP256k1
|
||||
pubkey_point = string_to_number(I[0:32]) * curve.generator + ser_to_point(cK)
|
||||
public_key = ecdsa.VerifyingKey.from_public_point(pubkey_point, curve=SECP256k1)
|
||||
c_n = I[32:]
|
||||
cK_n = GetPubKey(public_key.pubkey, True)
|
||||
return cK_n, c_n
|
||||
|
||||
|
||||
BITCOIN_HEADER_PRIV = "0488ade4"
|
||||
BITCOIN_HEADER_PUB = "0488b21e"
|
||||
|
||||
TESTNET_HEADER_PRIV = "04358394"
|
||||
TESTNET_HEADER_PUB = "043587cf"
|
||||
|
||||
BITCOIN_HEADERS = (BITCOIN_HEADER_PUB, BITCOIN_HEADER_PRIV)
|
||||
TESTNET_HEADERS = (TESTNET_HEADER_PUB, TESTNET_HEADER_PRIV)
|
||||
|
||||
|
||||
def _get_headers(testnet):
|
||||
"""Returns the correct headers for either testnet or bitcoin, in the form
|
||||
of a 2-tuple, like (public, private)."""
|
||||
if testnet:
|
||||
return TESTNET_HEADERS
|
||||
else:
|
||||
return BITCOIN_HEADERS
|
||||
|
||||
|
||||
def deserialize_xkey(xkey):
|
||||
xkey = b58decode_strip_checksum(xkey)
|
||||
assert len(xkey) == 78
|
||||
|
||||
xkey_header = xkey[0:4].encode('hex')
|
||||
# Determine if the key is a bitcoin key or a testnet key.
|
||||
if xkey_header in TESTNET_HEADERS:
|
||||
head = TESTNET_HEADER_PRIV
|
||||
elif xkey_header in BITCOIN_HEADERS:
|
||||
head = BITCOIN_HEADER_PRIV
|
||||
else:
|
||||
raise Exception("Unknown xkey header: '%s'" % xkey_header)
|
||||
|
||||
depth = ord(xkey[4])
|
||||
fingerprint = xkey[5:9]
|
||||
child_number = xkey[9:13]
|
||||
c = xkey[13:13 + 32]
|
||||
if xkey[0:4].encode('hex') == head:
|
||||
K_or_k = xkey[13 + 33:]
|
||||
else:
|
||||
K_or_k = xkey[13 + 32:]
|
||||
return depth, fingerprint, child_number, c, K_or_k
|
||||
|
||||
|
||||
def get_xkey_name(xkey, testnet=False):
|
||||
depth, fingerprint, child_number, c, K = deserialize_xkey(xkey)
|
||||
n = int(child_number.encode('hex'), 16)
|
||||
if n & BIP32_PRIME:
|
||||
child_id = "%d'" % (n - BIP32_PRIME)
|
||||
else:
|
||||
child_id = "%d" % n
|
||||
if depth == 0:
|
||||
return ''
|
||||
elif depth == 1:
|
||||
return child_id
|
||||
else:
|
||||
raise BaseException("xpub depth error")
|
||||
|
||||
|
||||
def xpub_from_xprv(xprv, testnet=False):
|
||||
depth, fingerprint, child_number, c, k = deserialize_xkey(xprv)
|
||||
K, cK = get_pubkeys_from_secret(k)
|
||||
header_pub, _ = _get_headers(testnet)
|
||||
xpub = header_pub.decode('hex') + chr(depth) + fingerprint + child_number + c + cK
|
||||
return b58encode_with_checksum(xpub)
|
||||
|
||||
|
||||
def bip32_root(seed, testnet=False):
|
||||
header_pub, header_priv = _get_headers(testnet)
|
||||
I = hmac.new("Bitcoin seed", seed, hashlib.sha512).digest()
|
||||
master_k = I[0:32]
|
||||
master_c = I[32:]
|
||||
K, cK = get_pubkeys_from_secret(master_k)
|
||||
xprv = (header_priv + "00" + "00000000" + "00000000").decode("hex") + master_c + chr(
|
||||
0) + master_k
|
||||
xpub = (header_pub + "00" + "00000000" + "00000000").decode("hex") + master_c + cK
|
||||
return b58encode_with_checksum(xprv), b58encode_with_checksum(xpub)
|
||||
|
||||
|
||||
def xpub_from_pubkey(cK, testnet=False):
|
||||
header_pub, header_priv = _get_headers(testnet)
|
||||
assert cK[0] in ['\x02', '\x03']
|
||||
master_c = chr(0) * 32
|
||||
xpub = (header_pub + "00" + "00000000" + "00000000").decode("hex") + master_c + cK
|
||||
return b58encode_with_checksum(xpub)
|
||||
|
||||
|
||||
def bip32_private_derivation(xprv, branch, sequence, testnet=False):
|
||||
assert sequence.startswith(branch)
|
||||
if branch == sequence:
|
||||
return xprv, xpub_from_xprv(xprv, testnet)
|
||||
header_pub, header_priv = _get_headers(testnet)
|
||||
depth, fingerprint, child_number, c, k = deserialize_xkey(xprv)
|
||||
sequence = sequence[len(branch):]
|
||||
for n in sequence.split('/'):
|
||||
if n == '':
|
||||
continue
|
||||
i = int(n[:-1]) + BIP32_PRIME if n[-1] == "'" else int(n)
|
||||
parent_k = k
|
||||
k, c = CKD_priv(k, c, i)
|
||||
depth += 1
|
||||
|
||||
_, parent_cK = get_pubkeys_from_secret(parent_k)
|
||||
fingerprint = hash_160(parent_cK)[0:4]
|
||||
child_number = ("%08X" % i).decode('hex')
|
||||
K, cK = get_pubkeys_from_secret(k)
|
||||
xprv = header_priv.decode('hex') + chr(depth) + fingerprint + child_number + c + chr(0) + k
|
||||
xpub = header_pub.decode('hex') + chr(depth) + fingerprint + child_number + c + cK
|
||||
return b58encode_with_checksum(xprv), b58encode_with_checksum(xpub)
|
||||
|
||||
|
||||
def bip32_public_derivation(xpub, branch, sequence, testnet=False):
|
||||
header_pub, _ = _get_headers(testnet)
|
||||
depth, fingerprint, child_number, c, cK = deserialize_xkey(xpub)
|
||||
assert sequence.startswith(branch)
|
||||
sequence = sequence[len(branch):]
|
||||
for n in sequence.split('/'):
|
||||
if n == '':
|
||||
continue
|
||||
i = int(n)
|
||||
parent_cK = cK
|
||||
cK, c = CKD_pub(cK, c, i)
|
||||
depth += 1
|
||||
|
||||
fingerprint = hash_160(parent_cK)[0:4]
|
||||
child_number = ("%08X" % i).decode('hex')
|
||||
xpub = header_pub.decode('hex') + chr(depth) + fingerprint + child_number + c + cK
|
||||
return b58encode_with_checksum(xpub)
|
||||
|
||||
|
||||
def bip32_private_key(sequence, k, chain):
|
||||
for i in sequence:
|
||||
k, chain = CKD_priv(k, chain, i)
|
||||
return SecretToASecret(k, True)
|
||||
88
lbrynet/wallet/manager.py
Normal file
88
lbrynet/wallet/manager.py
Normal file
|
|
@ -0,0 +1,88 @@
|
|||
import os
|
||||
import logging
|
||||
|
||||
from twisted.internet import defer
|
||||
|
||||
import lbryschema
|
||||
|
||||
from .protocol import Network
|
||||
from .blockchain import BlockchainHeaders
|
||||
from .wallet import Wallet
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
|
||||
|
||||
def chunks(l, n):
|
||||
for i in range(0, len(l), n):
|
||||
yield l[i:i+n]
|
||||
|
||||
|
||||
class WalletManager:
|
||||
|
||||
def __init__(self, storage, config):
|
||||
self.storage = storage
|
||||
self.config = config
|
||||
lbryschema.BLOCKCHAIN_NAME = config['chain']
|
||||
self.headers = BlockchainHeaders(self.headers_path, config['chain'])
|
||||
self.wallet = Wallet(self.wallet_path)
|
||||
self.network = Network(config)
|
||||
self.network.on_header.listen(self.process_header)
|
||||
self.network.on_transaction.listen(self.process_transaction)
|
||||
self._downloading_headers = False
|
||||
|
||||
@property
|
||||
def headers_path(self):
|
||||
filename = 'blockchain_headers'
|
||||
if self.config['chain'] != 'lbrycrd_main':
|
||||
filename = '{}_headers'.format(self.config['chain'].split("_")[1])
|
||||
return os.path.join(self.config['wallet_path'], filename)
|
||||
|
||||
@property
|
||||
def wallet_path(self):
|
||||
return os.path.join(self.config['wallet_path'], 'wallets', 'default_wallet')
|
||||
|
||||
@defer.inlineCallbacks
|
||||
def start(self):
|
||||
self.wallet.load()
|
||||
self.network.start()
|
||||
yield self.network.on_connected.first
|
||||
yield self.download_headers()
|
||||
yield self.network.headers_subscribe()
|
||||
yield self.download_transactions()
|
||||
|
||||
def stop(self):
|
||||
return self.network.stop()
|
||||
|
||||
@defer.inlineCallbacks
|
||||
def download_headers(self):
|
||||
self._downloading_headers = True
|
||||
while True:
|
||||
sought_height = len(self.headers)
|
||||
headers = yield self.network.block_headers(sought_height)
|
||||
log.info("received {} headers starting at {} height".format(headers['count'], sought_height))
|
||||
if headers['count'] <= 0:
|
||||
break
|
||||
yield self.headers.connect(sought_height, headers['hex'].decode('hex'))
|
||||
self._downloading_headers = False
|
||||
|
||||
@defer.inlineCallbacks
|
||||
def process_header(self, header):
|
||||
if self._downloading_headers:
|
||||
return
|
||||
if header['block_height'] == len(self.headers):
|
||||
# New header from network directly connects after the last local header.
|
||||
yield self.headers.connect(len(self.headers), header['hex'].decode('hex'))
|
||||
elif header['block_height'] > len(self.headers):
|
||||
# New header is several heights ahead of local, do download instead.
|
||||
yield self.download_headers()
|
||||
|
||||
@defer.inlineCallbacks
|
||||
def download_transactions(self):
|
||||
for addresses in chunks(self.wallet.addresses, 500):
|
||||
self.network.rpc([
|
||||
('blockchain.address.subscribe', [address])
|
||||
for address in addresses
|
||||
])
|
||||
|
||||
def process_transaction(self, tx):
|
||||
pass
|
||||
157
lbrynet/wallet/mnemonic.py
Normal file
157
lbrynet/wallet/mnemonic.py
Normal file
|
|
@ -0,0 +1,157 @@
|
|||
import hashlib
|
||||
import hmac
|
||||
import math
|
||||
import os
|
||||
import pkgutil
|
||||
import string
|
||||
import unicodedata
|
||||
import logging
|
||||
import ecdsa
|
||||
import pbkdf2
|
||||
|
||||
from . import constants
|
||||
from .hashing import hmac_sha_512
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
|
||||
# http://www.asahi-net.or.jp/~ax2s-kmtn/ref/unicode/e_asia.html
|
||||
CJK_INTERVALS = [
|
||||
(0x4E00, 0x9FFF, 'CJK Unified Ideographs'),
|
||||
(0x3400, 0x4DBF, 'CJK Unified Ideographs Extension A'),
|
||||
(0x20000, 0x2A6DF, 'CJK Unified Ideographs Extension B'),
|
||||
(0x2A700, 0x2B73F, 'CJK Unified Ideographs Extension C'),
|
||||
(0x2B740, 0x2B81F, 'CJK Unified Ideographs Extension D'),
|
||||
(0xF900, 0xFAFF, 'CJK Compatibility Ideographs'),
|
||||
(0x2F800, 0x2FA1D, 'CJK Compatibility Ideographs Supplement'),
|
||||
(0x3190, 0x319F, 'Kanbun'),
|
||||
(0x2E80, 0x2EFF, 'CJK Radicals Supplement'),
|
||||
(0x2F00, 0x2FDF, 'CJK Radicals'),
|
||||
(0x31C0, 0x31EF, 'CJK Strokes'),
|
||||
(0x2FF0, 0x2FFF, 'Ideographic Description Characters'),
|
||||
(0xE0100, 0xE01EF, 'Variation Selectors Supplement'),
|
||||
(0x3100, 0x312F, 'Bopomofo'),
|
||||
(0x31A0, 0x31BF, 'Bopomofo Extended'),
|
||||
(0xFF00, 0xFFEF, 'Halfwidth and Fullwidth Forms'),
|
||||
(0x3040, 0x309F, 'Hiragana'),
|
||||
(0x30A0, 0x30FF, 'Katakana'),
|
||||
(0x31F0, 0x31FF, 'Katakana Phonetic Extensions'),
|
||||
(0x1B000, 0x1B0FF, 'Kana Supplement'),
|
||||
(0xAC00, 0xD7AF, 'Hangul Syllables'),
|
||||
(0x1100, 0x11FF, 'Hangul Jamo'),
|
||||
(0xA960, 0xA97F, 'Hangul Jamo Extended A'),
|
||||
(0xD7B0, 0xD7FF, 'Hangul Jamo Extended B'),
|
||||
(0x3130, 0x318F, 'Hangul Compatibility Jamo'),
|
||||
(0xA4D0, 0xA4FF, 'Lisu'),
|
||||
(0x16F00, 0x16F9F, 'Miao'),
|
||||
(0xA000, 0xA48F, 'Yi Syllables'),
|
||||
(0xA490, 0xA4CF, 'Yi Radicals'),
|
||||
]
|
||||
|
||||
|
||||
def is_CJK(c):
|
||||
n = ord(c)
|
||||
for imin, imax, name in CJK_INTERVALS:
|
||||
if imin <= n <= imax:
|
||||
return True
|
||||
return False
|
||||
|
||||
|
||||
def prepare_seed(seed):
|
||||
# normalize
|
||||
seed = unicodedata.normalize('NFKD', unicode(seed))
|
||||
# lower
|
||||
seed = seed.lower()
|
||||
# remove accents
|
||||
seed = u''.join([c for c in seed if not unicodedata.combining(c)])
|
||||
# normalize whitespaces
|
||||
seed = u' '.join(seed.split())
|
||||
# remove whitespaces between CJK
|
||||
seed = u''.join([seed[i] for i in range(len(seed)) if not (seed[i] in string.whitespace
|
||||
and is_CJK(seed[i - 1])
|
||||
and is_CJK(seed[i + 1]))])
|
||||
return seed
|
||||
|
||||
|
||||
filenames = {
|
||||
'en': 'english.txt',
|
||||
'es': 'spanish.txt',
|
||||
'ja': 'japanese.txt',
|
||||
'pt': 'portuguese.txt',
|
||||
'zh': 'chinese_simplified.txt'
|
||||
}
|
||||
|
||||
|
||||
class Mnemonic:
|
||||
# Seed derivation no longer follows BIP39
|
||||
# Mnemonic phrase uses a hash based checksum, instead of a wordlist-dependent checksum
|
||||
|
||||
def __init__(self, lang=None):
|
||||
lang = lang or "en"
|
||||
filename = filenames.get(lang[0:2], 'english.txt')
|
||||
s = pkgutil.get_data('lbrynet', os.path.join('wallet', 'wordlist', filename))
|
||||
s = unicodedata.normalize('NFKD', s.decode('utf8'))
|
||||
lines = s.split('\n')
|
||||
self.wordlist = []
|
||||
for line in lines:
|
||||
line = line.split('#')[0]
|
||||
line = line.strip(' \r')
|
||||
assert ' ' not in line
|
||||
if line:
|
||||
self.wordlist.append(line)
|
||||
log.info("wordlist has %d words", len(self.wordlist))
|
||||
|
||||
@classmethod
|
||||
def mnemonic_to_seed(cls, mnemonic, passphrase):
|
||||
PBKDF2_ROUNDS = 2048
|
||||
mnemonic = prepare_seed(mnemonic)
|
||||
return pbkdf2.PBKDF2(mnemonic, 'lbryum' + passphrase, iterations=PBKDF2_ROUNDS,
|
||||
macmodule=hmac, digestmodule=hashlib.sha512).read(64)
|
||||
|
||||
def mnemonic_encode(self, i):
|
||||
n = len(self.wordlist)
|
||||
words = []
|
||||
while i:
|
||||
x = i % n
|
||||
i = i / n
|
||||
words.append(self.wordlist[x])
|
||||
return ' '.join(words)
|
||||
|
||||
def mnemonic_decode(self, seed):
|
||||
n = len(self.wordlist)
|
||||
words = seed.split()
|
||||
i = 0
|
||||
while words:
|
||||
w = words.pop()
|
||||
k = self.wordlist.index(w)
|
||||
i = i * n + k
|
||||
return i
|
||||
|
||||
def check_seed(self, seed, custom_entropy):
|
||||
assert is_new_seed(seed)
|
||||
i = self.mnemonic_decode(seed)
|
||||
return i % custom_entropy == 0
|
||||
|
||||
def make_seed(self, num_bits=128, prefix=constants.SEED_PREFIX, custom_entropy=1):
|
||||
n = int(math.ceil(math.log(custom_entropy, 2)))
|
||||
# bits of entropy used by the prefix
|
||||
k = len(prefix) * 4
|
||||
# we add at least 16 bits
|
||||
n_added = max(16, k + num_bits - n)
|
||||
log.info("make_seed %s adding %d bits", prefix, n_added)
|
||||
my_entropy = ecdsa.util.randrange(pow(2, n_added))
|
||||
nonce = 0
|
||||
while True:
|
||||
nonce += 1
|
||||
i = custom_entropy * (my_entropy + nonce)
|
||||
seed = self.mnemonic_encode(i)
|
||||
assert i == self.mnemonic_decode(seed)
|
||||
if is_new_seed(seed, prefix):
|
||||
break
|
||||
log.info('%d words', len(seed.split()))
|
||||
return seed
|
||||
|
||||
|
||||
def is_new_seed(x, prefix=constants.SEED_PREFIX):
|
||||
x = prepare_seed(x)
|
||||
s = hmac_sha_512("Seed version", x.encode('utf8')).encode('hex')
|
||||
return s.startswith(prefix)
|
||||
96
lbrynet/wallet/msqr.py
Normal file
96
lbrynet/wallet/msqr.py
Normal file
|
|
@ -0,0 +1,96 @@
|
|||
# from http://eli.thegreenplace.net/2009/03/07/computing-modular-square-roots-in-python/
|
||||
|
||||
|
||||
def modular_sqrt(a, p):
|
||||
""" Find a quadratic residue (mod p) of 'a'. p
|
||||
must be an odd prime.
|
||||
|
||||
Solve the congruence of the form:
|
||||
x^2 = a (mod p)
|
||||
And returns x. Note that p - x is also a root.
|
||||
|
||||
0 is returned is no square root exists for
|
||||
these a and p.
|
||||
|
||||
The Tonelli-Shanks algorithm is used (except
|
||||
for some simple cases in which the solution
|
||||
is known from an identity). This algorithm
|
||||
runs in polynomial time (unless the
|
||||
generalized Riemann hypothesis is false).
|
||||
"""
|
||||
# Simple cases
|
||||
#
|
||||
if legendre_symbol(a, p) != 1:
|
||||
return 0
|
||||
elif a == 0:
|
||||
return 0
|
||||
elif p == 2:
|
||||
return p
|
||||
elif p % 4 == 3:
|
||||
return pow(a, (p + 1) / 4, p)
|
||||
|
||||
# Partition p-1 to s * 2^e for an odd s (i.e.
|
||||
# reduce all the powers of 2 from p-1)
|
||||
#
|
||||
s = p - 1
|
||||
e = 0
|
||||
while s % 2 == 0:
|
||||
s /= 2
|
||||
e += 1
|
||||
|
||||
# Find some 'n' with a legendre symbol n|p = -1.
|
||||
# Shouldn't take long.
|
||||
#
|
||||
n = 2
|
||||
while legendre_symbol(n, p) != -1:
|
||||
n += 1
|
||||
|
||||
# Here be dragons!
|
||||
# Read the paper "Square roots from 1; 24, 51,
|
||||
# 10 to Dan Shanks" by Ezra Brown for more
|
||||
# information
|
||||
#
|
||||
|
||||
# x is a guess of the square root that gets better
|
||||
# with each iteration.
|
||||
# b is the "fudge factor" - by how much we're off
|
||||
# with the guess. The invariant x^2 = ab (mod p)
|
||||
# is maintained throughout the loop.
|
||||
# g is used for successive powers of n to update
|
||||
# both a and b
|
||||
# r is the exponent - decreases with each update
|
||||
#
|
||||
x = pow(a, (s + 1) / 2, p)
|
||||
b = pow(a, s, p)
|
||||
g = pow(n, s, p)
|
||||
r = e
|
||||
|
||||
while True:
|
||||
t = b
|
||||
m = 0
|
||||
for m in xrange(r):
|
||||
if t == 1:
|
||||
break
|
||||
t = pow(t, 2, p)
|
||||
|
||||
if m == 0:
|
||||
return x
|
||||
|
||||
gs = pow(g, 2 ** (r - m - 1), p)
|
||||
g = (gs * gs) % p
|
||||
x = (x * gs) % p
|
||||
b = (b * g) % p
|
||||
r = m
|
||||
|
||||
|
||||
def legendre_symbol(a, p):
|
||||
""" Compute the Legendre symbol a|p using
|
||||
Euler's criterion. p is a prime, a is
|
||||
relatively prime to p (if p divides
|
||||
a, then a|p = 0)
|
||||
|
||||
Returns 1 if a has a square root modulo
|
||||
p, -1 otherwise.
|
||||
"""
|
||||
ls = pow(a, (p - 1) / 2, p)
|
||||
return -1 if ls == p - 1 else ls
|
||||
76
lbrynet/wallet/opcodes.py
Normal file
76
lbrynet/wallet/opcodes.py
Normal file
|
|
@ -0,0 +1,76 @@
|
|||
import struct
|
||||
from .enumeration import Enumeration
|
||||
|
||||
opcodes = Enumeration("Opcodes", [
|
||||
("OP_0", 0), ("OP_PUSHDATA1", 76), "OP_PUSHDATA2", "OP_PUSHDATA4", "OP_1NEGATE", "OP_RESERVED",
|
||||
"OP_1", "OP_2", "OP_3", "OP_4", "OP_5", "OP_6", "OP_7",
|
||||
"OP_8", "OP_9", "OP_10", "OP_11", "OP_12", "OP_13", "OP_14", "OP_15", "OP_16",
|
||||
"OP_NOP", "OP_VER", "OP_IF", "OP_NOTIF", "OP_VERIF", "OP_VERNOTIF", "OP_ELSE", "OP_ENDIF",
|
||||
"OP_VERIFY",
|
||||
"OP_RETURN", "OP_TOALTSTACK", "OP_FROMALTSTACK", "OP_2DROP", "OP_2DUP", "OP_3DUP", "OP_2OVER",
|
||||
"OP_2ROT", "OP_2SWAP",
|
||||
"OP_IFDUP", "OP_DEPTH", "OP_DROP", "OP_DUP", "OP_NIP", "OP_OVER", "OP_PICK", "OP_ROLL",
|
||||
"OP_ROT",
|
||||
"OP_SWAP", "OP_TUCK", "OP_CAT", "OP_SUBSTR", "OP_LEFT", "OP_RIGHT", "OP_SIZE", "OP_INVERT",
|
||||
"OP_AND",
|
||||
"OP_OR", "OP_XOR", "OP_EQUAL", "OP_EQUALVERIFY", "OP_RESERVED1", "OP_RESERVED2", "OP_1ADD",
|
||||
"OP_1SUB", "OP_2MUL",
|
||||
"OP_2DIV", "OP_NEGATE", "OP_ABS", "OP_NOT", "OP_0NOTEQUAL", "OP_ADD", "OP_SUB", "OP_MUL",
|
||||
"OP_DIV",
|
||||
"OP_MOD", "OP_LSHIFT", "OP_RSHIFT", "OP_BOOLAND", "OP_BOOLOR",
|
||||
"OP_NUMEQUAL", "OP_NUMEQUALVERIFY", "OP_NUMNOTEQUAL", "OP_LESSTHAN",
|
||||
"OP_GREATERTHAN", "OP_LESSTHANOREQUAL", "OP_GREATERTHANOREQUAL", "OP_MIN", "OP_MAX",
|
||||
"OP_WITHIN", "OP_RIPEMD160", "OP_SHA1", "OP_SHA256", "OP_HASH160",
|
||||
"OP_HASH256", "OP_CODESEPARATOR", "OP_CHECKSIG", "OP_CHECKSIGVERIFY", "OP_CHECKMULTISIG",
|
||||
"OP_CHECKMULTISIGVERIFY", "OP_NOP1", "OP_NOP2", "OP_NOP3", "OP_NOP4", "OP_NOP5",
|
||||
"OP_CLAIM_NAME",
|
||||
"OP_SUPPORT_CLAIM", "OP_UPDATE_CLAIM",
|
||||
("OP_SINGLEBYTE_END", 0xF0),
|
||||
("OP_DOUBLEBYTE_BEGIN", 0xF000),
|
||||
"OP_PUBKEY", "OP_PUBKEYHASH",
|
||||
("OP_INVALIDOPCODE", 0xFFFF),
|
||||
])
|
||||
|
||||
|
||||
def script_GetOp(bytes):
|
||||
i = 0
|
||||
while i < len(bytes):
|
||||
vch = None
|
||||
opcode = ord(bytes[i])
|
||||
i += 1
|
||||
if opcode >= opcodes.OP_SINGLEBYTE_END:
|
||||
opcode <<= 8
|
||||
opcode |= ord(bytes[i])
|
||||
i += 1
|
||||
|
||||
if opcode <= opcodes.OP_PUSHDATA4:
|
||||
nSize = opcode
|
||||
if opcode == opcodes.OP_PUSHDATA1:
|
||||
nSize = ord(bytes[i])
|
||||
i += 1
|
||||
elif opcode == opcodes.OP_PUSHDATA2:
|
||||
(nSize,) = struct.unpack_from('<H', bytes, i)
|
||||
i += 2
|
||||
elif opcode == opcodes.OP_PUSHDATA4:
|
||||
(nSize,) = struct.unpack_from('<I', bytes, i)
|
||||
i += 4
|
||||
vch = bytes[i:i + nSize]
|
||||
i += nSize
|
||||
|
||||
yield (opcode, vch, i)
|
||||
|
||||
|
||||
def script_GetOpName(opcode):
|
||||
return (opcodes.whatis(opcode)).replace("OP_", "")
|
||||
|
||||
|
||||
def match_decoded(decoded, to_match):
|
||||
if len(decoded) != len(to_match):
|
||||
return False
|
||||
for i, d in enumerate(decoded):
|
||||
if to_match[i] == opcodes.OP_PUSHDATA4 and opcodes.OP_PUSHDATA4 >= d[0] > 0:
|
||||
# Opcodes below OP_PUSHDATA4 all just push data onto stack, # and are equivalent.
|
||||
continue
|
||||
if to_match[i] != decoded[i][0]:
|
||||
return False
|
||||
return True
|
||||
282
lbrynet/wallet/protocol.py
Normal file
282
lbrynet/wallet/protocol.py
Normal file
|
|
@ -0,0 +1,282 @@
|
|||
import sys
|
||||
import time
|
||||
import json
|
||||
import socket
|
||||
import logging
|
||||
from itertools import cycle
|
||||
from twisted.internet import defer, reactor, protocol, threads
|
||||
from twisted.application.internet import ClientService, CancelledError
|
||||
from twisted.internet.endpoints import clientFromString
|
||||
from twisted.protocols.basic import LineOnlyReceiver
|
||||
from errors import RemoteServiceException, ProtocolException
|
||||
from errors import TransportException
|
||||
|
||||
from .stream import StreamController
|
||||
|
||||
log = logging.getLogger()
|
||||
|
||||
|
||||
class StratumClientProtocol(LineOnlyReceiver):
|
||||
delimiter = '\n'
|
||||
|
||||
def __init__(self):
|
||||
self.request_id = 0
|
||||
self.lookup_table = {}
|
||||
self.session = {}
|
||||
|
||||
self.on_disconnected_controller = StreamController()
|
||||
self.on_disconnected = self.on_disconnected_controller.stream
|
||||
|
||||
def _get_id(self):
|
||||
self.request_id += 1
|
||||
return self.request_id
|
||||
|
||||
@property
|
||||
def _ip(self):
|
||||
return self.transport.getPeer().host
|
||||
|
||||
def get_session(self):
|
||||
return self.session
|
||||
|
||||
def connectionMade(self):
|
||||
try:
|
||||
self.transport.setTcpNoDelay(True)
|
||||
self.transport.setTcpKeepAlive(True)
|
||||
self.transport.socket.setsockopt(
|
||||
socket.SOL_TCP, socket.TCP_KEEPIDLE, 120
|
||||
# Seconds before sending keepalive probes
|
||||
)
|
||||
self.transport.socket.setsockopt(
|
||||
socket.SOL_TCP, socket.TCP_KEEPINTVL, 1
|
||||
# Interval in seconds between keepalive probes
|
||||
)
|
||||
self.transport.socket.setsockopt(
|
||||
socket.SOL_TCP, socket.TCP_KEEPCNT, 5
|
||||
# Failed keepalive probles before declaring other end dead
|
||||
)
|
||||
except Exception as err:
|
||||
# Supported only by the socket transport,
|
||||
# but there's really no better place in code to trigger this.
|
||||
log.warning("Error setting up socket: %s", err)
|
||||
|
||||
def connectionLost(self, reason=None):
|
||||
self.on_disconnected_controller.add(True)
|
||||
|
||||
def lineReceived(self, line):
|
||||
try:
|
||||
message = json.loads(line)
|
||||
except (ValueError, TypeError):
|
||||
raise ProtocolException("Cannot decode message '%s'" % line.strip())
|
||||
msg_id = message.get('id', 0)
|
||||
msg_result = message.get('result')
|
||||
msg_error = message.get('error')
|
||||
msg_method = message.get('method')
|
||||
msg_params = message.get('params')
|
||||
if msg_id:
|
||||
# It's a RPC response
|
||||
# Perform lookup to the table of waiting requests.
|
||||
try:
|
||||
meta = self.lookup_table[msg_id]
|
||||
del self.lookup_table[msg_id]
|
||||
except KeyError:
|
||||
# When deferred object for given message ID isn't found, it's an error
|
||||
raise ProtocolException(
|
||||
"Lookup for deferred object for message ID '%s' failed." % msg_id)
|
||||
# If there's an error, handle it as errback
|
||||
# If both result and error are null, handle it as a success with blank result
|
||||
if msg_error != None:
|
||||
meta['defer'].errback(
|
||||
RemoteServiceException(msg_error[0], msg_error[1], msg_error[2])
|
||||
)
|
||||
else:
|
||||
meta['defer'].callback(msg_result)
|
||||
elif msg_method:
|
||||
if msg_method == 'blockchain.headers.subscribe':
|
||||
self.network._on_header_controller.add(msg_params[0])
|
||||
elif msg_method == 'blockchain.address.subscribe':
|
||||
self.network._on_address_controller.add(msg_params)
|
||||
else:
|
||||
log.warning("Cannot handle message '%s'" % line)
|
||||
|
||||
def write_request(self, method, params, is_notification=False):
|
||||
request_id = None if is_notification else self._get_id()
|
||||
serialized = json.dumps({'id': request_id, 'method': method, 'params': params})
|
||||
self.sendLine(serialized)
|
||||
return request_id
|
||||
|
||||
def rpc(self, method, params, is_notification=False):
|
||||
request_id = self.write_request(method, params, is_notification)
|
||||
if is_notification:
|
||||
return
|
||||
d = defer.Deferred()
|
||||
self.lookup_table[request_id] = {
|
||||
'method': method,
|
||||
'params': params,
|
||||
'defer': d,
|
||||
}
|
||||
return d
|
||||
|
||||
|
||||
class StratumClientFactory(protocol.ClientFactory):
|
||||
|
||||
protocol = StratumClientProtocol
|
||||
|
||||
def __init__(self, network):
|
||||
self.network = network
|
||||
self.client = None
|
||||
|
||||
def buildProtocol(self, addr):
|
||||
client = self.protocol()
|
||||
client.factory = self
|
||||
client.network = self.network
|
||||
self.client = client
|
||||
return client
|
||||
|
||||
|
||||
class Network:
|
||||
|
||||
def __init__(self, config):
|
||||
self.config = config
|
||||
self.client = None
|
||||
self.service = None
|
||||
self.running = False
|
||||
|
||||
self._on_connected_controller = StreamController()
|
||||
self.on_connected = self._on_connected_controller.stream
|
||||
|
||||
self._on_header_controller = StreamController()
|
||||
self.on_header = self._on_header_controller.stream
|
||||
|
||||
self._on_transaction_controller = StreamController()
|
||||
self.on_transaction = self._on_transaction_controller.stream
|
||||
|
||||
@defer.inlineCallbacks
|
||||
def start(self):
|
||||
for server in cycle(self.config.get('default_servers')):
|
||||
endpoint = clientFromString(reactor, 'tcp:{}:{}'.format(*server))
|
||||
self.service = ClientService(endpoint, StratumClientFactory(self))
|
||||
self.service.startService()
|
||||
try:
|
||||
self.client = yield self.service.whenConnected(failAfterFailures=2)
|
||||
self._on_connected_controller.add(True)
|
||||
yield self.client.on_disconnected.first
|
||||
except CancelledError:
|
||||
return
|
||||
except Exception as e:
|
||||
pass
|
||||
finally:
|
||||
self.client = None
|
||||
if not self.running:
|
||||
return
|
||||
|
||||
def stop(self):
|
||||
self.running = False
|
||||
if self.service is not None:
|
||||
self.service.stopService()
|
||||
if self.is_connected:
|
||||
return self.client.on_disconnected.first
|
||||
else:
|
||||
return defer.succeed(True)
|
||||
|
||||
@property
|
||||
def is_connected(self):
|
||||
return self.client is not None and self.client.connected
|
||||
|
||||
def rpc(self, method, params, *args, **kwargs):
|
||||
if self.is_connected:
|
||||
return self.client.rpc(method, params, *args, **kwargs)
|
||||
else:
|
||||
raise TransportException("Attempting to send rpc request when connection is not available.")
|
||||
|
||||
def claimtrie_getvaluesforuris(self, block_hash, *uris):
|
||||
return self.rpc(
|
||||
'blockchain.claimtrie.getvaluesforuris', [block_hash] + list(uris)
|
||||
)
|
||||
|
||||
def claimtrie_getvaluesforuri(self, block_hash, uri):
|
||||
return self.rpc('blockchain.claimtrie.getvaluesforuri', [block_hash, uri])
|
||||
|
||||
def claimtrie_getclaimssignedbynthtoname(self, name, n):
|
||||
return self.rpc('blockchain.claimtrie.getclaimssignedbynthtoname', [name, n])
|
||||
|
||||
def claimtrie_getclaimssignedbyid(self, certificate_id):
|
||||
return self.rpc('blockchain.claimtrie.getclaimssignedbyid', [certificate_id])
|
||||
|
||||
def claimtrie_getclaimssignedby(self, name):
|
||||
return self.rpc('blockchain.claimtrie.getclaimssignedby', [name])
|
||||
|
||||
def claimtrie_getnthclaimforname(self, name, n):
|
||||
return self.rpc('blockchain.claimtrie.getnthclaimforname', [name, n])
|
||||
|
||||
def claimtrie_getclaimsbyids(self, *claim_ids):
|
||||
return self.rpc('blockchain.claimtrie.getclaimsbyids', list(claim_ids))
|
||||
|
||||
def claimtrie_getclaimbyid(self, claim_id):
|
||||
return self.rpc('blockchain.claimtrie.getclaimbyid', [claim_id])
|
||||
|
||||
def claimtrie_get(self):
|
||||
return self.rpc('blockchain.claimtrie.get', [])
|
||||
|
||||
def block_get_block(self, block_hash):
|
||||
return self.rpc('blockchain.block.get_block', [block_hash])
|
||||
|
||||
def claimtrie_getclaimsforname(self, name):
|
||||
return self.rpc('blockchain.claimtrie.getclaimsforname', [name])
|
||||
|
||||
def claimtrie_getclaimsintx(self, txid):
|
||||
return self.rpc('blockchain.claimtrie.getclaimsintx', [txid])
|
||||
|
||||
def claimtrie_getvalue(self, name, block_hash=None):
|
||||
return self.rpc('blockchain.claimtrie.getvalue', [name, block_hash])
|
||||
|
||||
def relayfee(self):
|
||||
return self.rpc('blockchain.relayfee', [])
|
||||
|
||||
def estimatefee(self):
|
||||
return self.rpc('blockchain.estimatefee', [])
|
||||
|
||||
def transaction_get(self, txid):
|
||||
return self.rpc('blockchain.transaction.get', [txid])
|
||||
|
||||
def transaction_get_merkle(self, tx_hash, height, cache_only=False):
|
||||
return self.rpc('blockchain.transaction.get_merkle', [tx_hash, height, cache_only])
|
||||
|
||||
def transaction_broadcast(self, raw_transaction):
|
||||
return self.rpc('blockchain.transaction.broadcast', [raw_transaction])
|
||||
|
||||
def block_get_chunk(self, index, cache_only=False):
|
||||
return self.rpc('blockchain.block.get_chunk', [index, cache_only])
|
||||
|
||||
def block_get_header(self, height, cache_only=False):
|
||||
return self.rpc('blockchain.block.get_header', [height, cache_only])
|
||||
|
||||
def block_headers(self, height, count=10000):
|
||||
return self.rpc('blockchain.block.headers', [height, count])
|
||||
|
||||
def utxo_get_address(self, txid, pos):
|
||||
return self.rpc('blockchain.utxo.get_address', [txid, pos])
|
||||
|
||||
def address_listunspent(self, address):
|
||||
return self.rpc('blockchain.address.listunspent', [address])
|
||||
|
||||
def address_get_proof(self, address):
|
||||
return self.rpc('blockchain.address.get_proof', [address])
|
||||
|
||||
def address_get_balance(self, address):
|
||||
return self.rpc('blockchain.address.get_balance', [address])
|
||||
|
||||
def address_get_mempool(self, address):
|
||||
return self.rpc('blockchain.address.get_mempool', [address])
|
||||
|
||||
def address_get_history(self, address):
|
||||
return self.rpc('blockchain.address.get_history', [address])
|
||||
|
||||
def address_subscribe(self, addresses):
|
||||
if isinstance(addresses, str):
|
||||
return self.rpc('blockchain.address.subscribe', [addresses])
|
||||
else:
|
||||
msgs = map(lambda addr: ('blockchain.address.subscribe', [addr]), addresses)
|
||||
self.network.send(msgs, self.addr_subscription_response)
|
||||
|
||||
def headers_subscribe(self):
|
||||
return self.rpc('blockchain.headers.subscribe', [], True)
|
||||
31
lbrynet/wallet/store.py
Normal file
31
lbrynet/wallet/store.py
Normal file
|
|
@ -0,0 +1,31 @@
|
|||
import os
|
||||
import json
|
||||
|
||||
|
||||
class JSONStore(dict):
|
||||
|
||||
def __init__(self, config, name):
|
||||
self.config = config
|
||||
self.path = os.path.join(self.config.path, name)
|
||||
self.load()
|
||||
|
||||
def load(self):
|
||||
try:
|
||||
with open(self.path, 'r') as f:
|
||||
self.update(json.loads(f.read()))
|
||||
except:
|
||||
pass
|
||||
|
||||
def save(self):
|
||||
with open(self.path, 'w') as f:
|
||||
s = json.dumps(self, indent=4, sort_keys=True)
|
||||
r = f.write(s)
|
||||
|
||||
def __setitem__(self, key, value):
|
||||
dict.__setitem__(self, key, value)
|
||||
self.save()
|
||||
|
||||
def pop(self, key):
|
||||
if key in self.keys():
|
||||
dict.pop(self, key)
|
||||
self.save()
|
||||
127
lbrynet/wallet/stream.py
Normal file
127
lbrynet/wallet/stream.py
Normal file
|
|
@ -0,0 +1,127 @@
|
|||
from twisted.internet.defer import Deferred
|
||||
from twisted.python.failure import Failure
|
||||
|
||||
|
||||
class BroadcastSubscription:
|
||||
|
||||
def __init__(self, controller, on_data, on_error, on_done):
|
||||
self._controller = controller
|
||||
self._previous = self._next = None
|
||||
self._on_data = on_data
|
||||
self._on_error = on_error
|
||||
self._on_done = on_done
|
||||
self.is_paused = False
|
||||
self.is_canceled = False
|
||||
self.is_closed = False
|
||||
|
||||
def pause(self):
|
||||
self.is_paused = True
|
||||
|
||||
def resume(self):
|
||||
self.is_paused = False
|
||||
|
||||
def cancel(self):
|
||||
self._controller._cancel(self)
|
||||
self.is_canceled = True
|
||||
|
||||
@property
|
||||
def can_fire(self):
|
||||
return not any((self.is_paused, self.is_canceled, self.is_closed))
|
||||
|
||||
def _add(self, data):
|
||||
if self.can_fire and self._on_data is not None:
|
||||
self._on_data(data)
|
||||
|
||||
def _add_error(self, error, traceback):
|
||||
if self.can_fire and self._on_error is not None:
|
||||
self._on_error(error, traceback)
|
||||
|
||||
def _close(self):
|
||||
if self.can_fire and self._on_done is not None:
|
||||
self._on_done()
|
||||
self.is_closed = True
|
||||
|
||||
|
||||
class StreamController:
|
||||
|
||||
def __init__(self):
|
||||
self.stream = Stream(self)
|
||||
self._first_subscription = None
|
||||
self._last_subscription = None
|
||||
|
||||
@property
|
||||
def has_listener(self):
|
||||
return self._first_subscription is not None
|
||||
|
||||
@property
|
||||
def _iterate_subscriptions(self):
|
||||
next = self._first_subscription
|
||||
while next is not None:
|
||||
subscription = next
|
||||
next = next._next
|
||||
yield subscription
|
||||
|
||||
def add(self, event):
|
||||
for subscription in self._iterate_subscriptions:
|
||||
subscription._add(event)
|
||||
|
||||
def add_error(self, error, traceback):
|
||||
for subscription in self._iterate_subscriptions:
|
||||
subscription._add_error(error, traceback)
|
||||
|
||||
def close(self):
|
||||
for subscription in self._iterate_subscriptions:
|
||||
subscription._close()
|
||||
|
||||
def _cancel(self, subscription):
|
||||
previous = subscription._previous
|
||||
next = subscription._next
|
||||
if previous is None:
|
||||
self._first_subscription = next
|
||||
else:
|
||||
previous._next = next
|
||||
if next is None:
|
||||
self._last_subscription = previous
|
||||
else:
|
||||
next._previous = previous
|
||||
subscription._next = subscription._previous = subscription
|
||||
|
||||
def _listen(self, on_data, on_error, on_done):
|
||||
subscription = BroadcastSubscription(self, on_data, on_error, on_done)
|
||||
old_last = self._last_subscription
|
||||
self._last_subscription = subscription
|
||||
subscription._previous = old_last
|
||||
subscription._next = None
|
||||
if old_last is None:
|
||||
self._first_subscription = subscription
|
||||
else:
|
||||
old_last._next = subscription
|
||||
return subscription
|
||||
|
||||
|
||||
class Stream:
|
||||
|
||||
def __init__(self, controller):
|
||||
self._controller = controller
|
||||
|
||||
def listen(self, on_data, on_error=None, on_done=None):
|
||||
return self._controller._listen(on_data, on_error, on_done)
|
||||
|
||||
@property
|
||||
def first(self):
|
||||
deferred = Deferred()
|
||||
subscription = self.listen(
|
||||
lambda value: self._cancel_and_callback(subscription, deferred, value),
|
||||
lambda error, traceback: self._cancel_and_error(subscription, deferred, error, traceback)
|
||||
)
|
||||
return deferred
|
||||
|
||||
@staticmethod
|
||||
def _cancel_and_callback(subscription, deferred, value):
|
||||
subscription.cancel()
|
||||
deferred.callback(value)
|
||||
|
||||
@staticmethod
|
||||
def _cancel_and_error(subscription, deferred, error, traceback):
|
||||
subscription.cancel()
|
||||
deferred.errback(Failure(error, exc_tb=traceback))
|
||||
702
lbrynet/wallet/transaction.py
Normal file
702
lbrynet/wallet/transaction.py
Normal file
|
|
@ -0,0 +1,702 @@
|
|||
import sys
|
||||
import hashlib
|
||||
import logging
|
||||
import ecdsa
|
||||
from ecdsa.curves import SECP256k1
|
||||
|
||||
from lbryschema.address import hash_160_bytes_to_address, public_key_to_address
|
||||
from lbryschema.address import address_to_hash_160
|
||||
|
||||
from .constants import TYPE_SCRIPT, TYPE_PUBKEY, TYPE_UPDATE, TYPE_SUPPORT, TYPE_CLAIM
|
||||
from .constants import TYPE_ADDRESS, NO_SIGNATURE
|
||||
from .opcodes import opcodes, match_decoded, script_GetOp
|
||||
from .bcd_data_stream import BCDataStream
|
||||
from .hashing import Hash, hash_160, hash_encode
|
||||
from .lbrycrd import op_push
|
||||
from .lbrycrd import point_to_ser, MyVerifyingKey, MySigningKey
|
||||
from .lbrycrd import regenerate_key, public_key_from_private_key
|
||||
from .lbrycrd import encode_claim_id_hex, claim_id_hash
|
||||
from .util import profiler, var_int, int_to_hex, parse_sig, rev_hex
|
||||
|
||||
log = logging.getLogger()
|
||||
|
||||
|
||||
def parse_xpub(x_pubkey):
|
||||
if x_pubkey[0:2] in ['02', '03', '04']:
|
||||
pubkey = x_pubkey
|
||||
elif x_pubkey[0:2] == 'ff':
|
||||
from lbryum.bip32 import BIP32_Account
|
||||
xpub, s = BIP32_Account.parse_xpubkey(x_pubkey)
|
||||
pubkey = BIP32_Account.derive_pubkey_from_xpub(xpub, s[0], s[1])
|
||||
elif x_pubkey[0:2] == 'fd':
|
||||
addrtype = ord(x_pubkey[2:4].decode('hex'))
|
||||
hash160 = x_pubkey[4:].decode('hex')
|
||||
pubkey = None
|
||||
address = hash_160_bytes_to_address(hash160, addrtype)
|
||||
else:
|
||||
raise BaseException("Cannnot parse pubkey")
|
||||
if pubkey:
|
||||
address = public_key_to_address(pubkey.decode('hex'))
|
||||
return pubkey, address
|
||||
|
||||
|
||||
def parse_scriptSig(d, bytes):
|
||||
try:
|
||||
decoded = [x for x in script_GetOp(bytes)]
|
||||
except Exception:
|
||||
# coinbase transactions raise an exception
|
||||
log.error("cannot find address in input script: {}".format(bytes.encode('hex')))
|
||||
return
|
||||
|
||||
# payto_pubkey
|
||||
match = [opcodes.OP_PUSHDATA4]
|
||||
if match_decoded(decoded, match):
|
||||
sig = decoded[0][1].encode('hex')
|
||||
d['address'] = "(pubkey)"
|
||||
d['signatures'] = [sig]
|
||||
d['num_sig'] = 1
|
||||
d['x_pubkeys'] = ["(pubkey)"]
|
||||
d['pubkeys'] = ["(pubkey)"]
|
||||
return
|
||||
|
||||
# non-generated TxIn transactions push a signature
|
||||
# (seventy-something bytes) and then their public key
|
||||
# (65 bytes) onto the stack:
|
||||
match = [opcodes.OP_PUSHDATA4, opcodes.OP_PUSHDATA4]
|
||||
if match_decoded(decoded, match):
|
||||
sig = decoded[0][1].encode('hex')
|
||||
x_pubkey = decoded[1][1].encode('hex')
|
||||
try:
|
||||
signatures = parse_sig([sig])
|
||||
pubkey, address = parse_xpub(x_pubkey)
|
||||
except:
|
||||
import traceback
|
||||
traceback.print_exc(file=sys.stdout)
|
||||
log.error("cannot find address in input script: {}".format(bytes.encode('hex')))
|
||||
return
|
||||
d['signatures'] = signatures
|
||||
d['x_pubkeys'] = [x_pubkey]
|
||||
d['num_sig'] = 1
|
||||
d['pubkeys'] = [pubkey]
|
||||
d['address'] = address
|
||||
return
|
||||
|
||||
# p2sh transaction, m of n
|
||||
match = [opcodes.OP_0] + [opcodes.OP_PUSHDATA4] * (len(decoded) - 1)
|
||||
if not match_decoded(decoded, match):
|
||||
log.error("cannot find address in input script: {}".format(bytes.encode('hex')))
|
||||
return
|
||||
x_sig = [x[1].encode('hex') for x in decoded[1:-1]]
|
||||
dec2 = [x for x in script_GetOp(decoded[-1][1])]
|
||||
m = dec2[0][0] - opcodes.OP_1 + 1
|
||||
n = dec2[-2][0] - opcodes.OP_1 + 1
|
||||
op_m = opcodes.OP_1 + m - 1
|
||||
op_n = opcodes.OP_1 + n - 1
|
||||
match_multisig = [op_m] + [opcodes.OP_PUSHDATA4] * n + [op_n, opcodes.OP_CHECKMULTISIG]
|
||||
if not match_decoded(dec2, match_multisig):
|
||||
log.error("cannot find address in input script: {}".format(bytes.encode('hex')))
|
||||
return
|
||||
x_pubkeys = map(lambda x: x[1].encode('hex'), dec2[1:-2])
|
||||
pubkeys = [parse_xpub(x)[0] for x in x_pubkeys] # xpub, addr = parse_xpub()
|
||||
redeemScript = Transaction.multisig_script(pubkeys, m)
|
||||
# write result in d
|
||||
d['num_sig'] = m
|
||||
d['signatures'] = parse_sig(x_sig)
|
||||
d['x_pubkeys'] = x_pubkeys
|
||||
d['pubkeys'] = pubkeys
|
||||
d['redeemScript'] = redeemScript
|
||||
d['address'] = hash_160_bytes_to_address(hash_160(redeemScript.decode('hex')), 5)
|
||||
|
||||
|
||||
class NameClaim(object):
|
||||
def __init__(self, name, value):
|
||||
self.name = name
|
||||
self.value = value
|
||||
|
||||
|
||||
class ClaimUpdate(object):
|
||||
def __init__(self, name, claim_id, value):
|
||||
self.name = name
|
||||
self.claim_id = claim_id
|
||||
self.value = value
|
||||
|
||||
|
||||
class ClaimSupport(object):
|
||||
def __init__(self, name, claim_id):
|
||||
self.name = name
|
||||
self.claim_id = claim_id
|
||||
|
||||
|
||||
def decode_claim_script(decoded_script):
|
||||
if len(decoded_script) <= 6:
|
||||
return False
|
||||
op = 0
|
||||
claim_type = decoded_script[op][0]
|
||||
if claim_type == opcodes.OP_UPDATE_CLAIM:
|
||||
if len(decoded_script) <= 7:
|
||||
return False
|
||||
if claim_type not in [
|
||||
opcodes.OP_CLAIM_NAME,
|
||||
opcodes.OP_SUPPORT_CLAIM,
|
||||
opcodes.OP_UPDATE_CLAIM
|
||||
]:
|
||||
return False
|
||||
op += 1
|
||||
value = None
|
||||
claim_id = None
|
||||
claim = None
|
||||
if not 0 <= decoded_script[op][0] <= opcodes.OP_PUSHDATA4:
|
||||
return False
|
||||
name = decoded_script[op][1]
|
||||
op += 1
|
||||
if not 0 <= decoded_script[op][0] <= opcodes.OP_PUSHDATA4:
|
||||
return False
|
||||
if decoded_script[0][0] in [
|
||||
opcodes.OP_SUPPORT_CLAIM,
|
||||
opcodes.OP_UPDATE_CLAIM
|
||||
]:
|
||||
claim_id = decoded_script[op][1]
|
||||
if len(claim_id) != 20:
|
||||
return False
|
||||
else:
|
||||
value = decoded_script[op][1]
|
||||
op += 1
|
||||
if decoded_script[0][0] == opcodes.OP_UPDATE_CLAIM:
|
||||
value = decoded_script[op][1]
|
||||
op += 1
|
||||
if decoded_script[op][0] != opcodes.OP_2DROP:
|
||||
return False
|
||||
op += 1
|
||||
if decoded_script[op][0] != opcodes.OP_DROP and decoded_script[0][0] == opcodes.OP_CLAIM_NAME:
|
||||
return False
|
||||
elif decoded_script[op][0] != opcodes.OP_2DROP and decoded_script[0][0] == \
|
||||
opcodes.OP_UPDATE_CLAIM:
|
||||
return False
|
||||
op += 1
|
||||
if decoded_script[0][0] == opcodes.OP_CLAIM_NAME:
|
||||
if name is None or value is None:
|
||||
return False
|
||||
claim = NameClaim(name, value)
|
||||
elif decoded_script[0][0] == opcodes.OP_UPDATE_CLAIM:
|
||||
if name is None or value is None or claim_id is None:
|
||||
return False
|
||||
claim = ClaimUpdate(name, claim_id, value)
|
||||
elif decoded_script[0][0] == opcodes.OP_SUPPORT_CLAIM:
|
||||
if name is None or claim_id is None:
|
||||
return False
|
||||
claim = ClaimSupport(name, claim_id)
|
||||
return claim, decoded_script[op:]
|
||||
|
||||
|
||||
def get_address_from_output_script(script_bytes):
|
||||
output_type = 0
|
||||
decoded = [x for x in script_GetOp(script_bytes)]
|
||||
r = decode_claim_script(decoded)
|
||||
claim_args = None
|
||||
if r is not False:
|
||||
claim_info, decoded = r
|
||||
if isinstance(claim_info, NameClaim):
|
||||
claim_args = (claim_info.name, claim_info.value)
|
||||
output_type |= TYPE_CLAIM
|
||||
elif isinstance(claim_info, ClaimSupport):
|
||||
claim_args = (claim_info.name, claim_info.claim_id)
|
||||
output_type |= TYPE_SUPPORT
|
||||
elif isinstance(claim_info, ClaimUpdate):
|
||||
claim_args = (claim_info.name, claim_info.claim_id, claim_info.value)
|
||||
output_type |= TYPE_UPDATE
|
||||
|
||||
# The Genesis Block, self-payments, and pay-by-IP-address payments look like:
|
||||
# 65 BYTES:... CHECKSIG
|
||||
match_pubkey = [opcodes.OP_PUSHDATA4, opcodes.OP_CHECKSIG]
|
||||
|
||||
# Pay-by-Bitcoin-address TxOuts look like:
|
||||
# DUP HASH160 20 BYTES:... EQUALVERIFY CHECKSIG
|
||||
match_p2pkh = [opcodes.OP_DUP, opcodes.OP_HASH160, opcodes.OP_PUSHDATA4, opcodes.OP_EQUALVERIFY,
|
||||
opcodes.OP_CHECKSIG]
|
||||
|
||||
# p2sh
|
||||
match_p2sh = [opcodes.OP_HASH160, opcodes.OP_PUSHDATA4, opcodes.OP_EQUAL]
|
||||
|
||||
if match_decoded(decoded, match_pubkey):
|
||||
output_val = decoded[0][1].encode('hex')
|
||||
output_type |= TYPE_PUBKEY
|
||||
elif match_decoded(decoded, match_p2pkh):
|
||||
output_val = hash_160_bytes_to_address(decoded[2][1])
|
||||
output_type |= TYPE_ADDRESS
|
||||
elif match_decoded(decoded, match_p2sh):
|
||||
output_val = hash_160_bytes_to_address(decoded[1][1], 5)
|
||||
output_type |= TYPE_ADDRESS
|
||||
else:
|
||||
output_val = bytes
|
||||
output_type |= TYPE_SCRIPT
|
||||
|
||||
if output_type & (TYPE_CLAIM | TYPE_SUPPORT | TYPE_UPDATE):
|
||||
output_val = (claim_args, output_val)
|
||||
|
||||
return output_type, output_val
|
||||
|
||||
|
||||
def parse_input(vds):
|
||||
d = {}
|
||||
prevout_hash = hash_encode(vds.read_bytes(32))
|
||||
prevout_n = vds.read_uint32()
|
||||
scriptSig = vds.read_bytes(vds.read_compact_size())
|
||||
d['scriptSig'] = scriptSig.encode('hex')
|
||||
sequence = vds.read_uint32()
|
||||
if prevout_hash == '00' * 32:
|
||||
d['is_coinbase'] = True
|
||||
else:
|
||||
d['is_coinbase'] = False
|
||||
d['prevout_hash'] = prevout_hash
|
||||
d['prevout_n'] = prevout_n
|
||||
d['sequence'] = sequence
|
||||
d['pubkeys'] = []
|
||||
d['signatures'] = {}
|
||||
d['address'] = None
|
||||
if scriptSig:
|
||||
parse_scriptSig(d, scriptSig)
|
||||
return d
|
||||
|
||||
|
||||
def parse_output(vds, i):
|
||||
d = {}
|
||||
d['value'] = vds.read_int64()
|
||||
scriptPubKey = vds.read_bytes(vds.read_compact_size())
|
||||
d['type'], d['address'] = get_address_from_output_script(scriptPubKey)
|
||||
d['scriptPubKey'] = scriptPubKey.encode('hex')
|
||||
d['prevout_n'] = i
|
||||
return d
|
||||
|
||||
|
||||
def deserialize(raw):
|
||||
vds = BCDataStream()
|
||||
vds.write(raw.decode('hex'))
|
||||
d = {}
|
||||
start = vds.read_cursor
|
||||
d['version'] = vds.read_int32()
|
||||
n_vin = vds.read_compact_size()
|
||||
d['inputs'] = list(parse_input(vds) for i in xrange(n_vin))
|
||||
n_vout = vds.read_compact_size()
|
||||
d['outputs'] = list(parse_output(vds, i) for i in xrange(n_vout))
|
||||
d['lockTime'] = vds.read_uint32()
|
||||
return d
|
||||
|
||||
|
||||
def push_script(x):
|
||||
return op_push(len(x) / 2) + x
|
||||
|
||||
|
||||
class Transaction(object):
|
||||
def __str__(self):
|
||||
if self.raw is None:
|
||||
self.raw = self.serialize()
|
||||
return self.raw
|
||||
|
||||
def __init__(self, raw):
|
||||
if raw is None:
|
||||
self.raw = None
|
||||
elif type(raw) in [str, unicode]:
|
||||
self.raw = raw.strip() if raw else None
|
||||
elif type(raw) is dict:
|
||||
self.raw = raw['hex']
|
||||
else:
|
||||
raise BaseException("cannot initialize transaction", raw)
|
||||
self._inputs = None
|
||||
self._outputs = None
|
||||
|
||||
def update(self, raw):
|
||||
self.raw = raw
|
||||
self._inputs = None
|
||||
self.deserialize()
|
||||
|
||||
def inputs(self):
|
||||
if self._inputs is None:
|
||||
self.deserialize()
|
||||
return self._inputs
|
||||
|
||||
def outputs(self):
|
||||
if self._outputs is None:
|
||||
self.deserialize()
|
||||
return self._outputs
|
||||
|
||||
def update_signatures(self, raw):
|
||||
"""Add new signatures to a transaction"""
|
||||
d = deserialize(raw)
|
||||
for i, txin in enumerate(self.inputs()):
|
||||
sigs1 = txin.get('signatures')
|
||||
sigs2 = d['inputs'][i].get('signatures')
|
||||
for sig in sigs2:
|
||||
if sig in sigs1:
|
||||
continue
|
||||
for_sig = Hash(self.tx_for_sig(i).decode('hex'))
|
||||
# der to string
|
||||
order = ecdsa.ecdsa.generator_secp256k1.order()
|
||||
r, s = ecdsa.util.sigdecode_der(sig.decode('hex'), order)
|
||||
sig_string = ecdsa.util.sigencode_string(r, s, order)
|
||||
pubkeys = txin.get('pubkeys')
|
||||
compressed = True
|
||||
for recid in range(4):
|
||||
public_key = MyVerifyingKey.from_signature(sig_string, recid, for_sig,
|
||||
curve=SECP256k1)
|
||||
pubkey = point_to_ser(public_key.pubkey.point, compressed).encode('hex')
|
||||
if pubkey in pubkeys:
|
||||
public_key.verify_digest(sig_string, for_sig,
|
||||
sigdecode=ecdsa.util.sigdecode_string)
|
||||
j = pubkeys.index(pubkey)
|
||||
log.error("adding sig {} {} {} {}".format(i, j, pubkey, sig))
|
||||
self._inputs[i]['signatures'][j] = sig
|
||||
self._inputs[i]['x_pubkeys'][j] = pubkey
|
||||
break
|
||||
# redo raw
|
||||
self.raw = self.serialize()
|
||||
|
||||
def deserialize(self):
|
||||
if self.raw is None:
|
||||
self.raw = self.serialize()
|
||||
if self._inputs is not None:
|
||||
return
|
||||
d = deserialize(self.raw)
|
||||
self._inputs = d['inputs']
|
||||
self._outputs = [(x['type'], x['address'], x['value']) for x in d['outputs']]
|
||||
self.locktime = d['lockTime']
|
||||
return d
|
||||
|
||||
@classmethod
|
||||
def from_io(cls, inputs, outputs, locktime=0):
|
||||
self = cls(None)
|
||||
self._inputs = inputs
|
||||
self._outputs = outputs
|
||||
self.locktime = locktime
|
||||
return self
|
||||
|
||||
@classmethod
|
||||
def multisig_script(cls, public_keys, m):
|
||||
n = len(public_keys)
|
||||
assert n <= 15
|
||||
assert m <= n
|
||||
op_m = format(opcodes.OP_1 + m - 1, 'x')
|
||||
op_n = format(opcodes.OP_1 + n - 1, 'x')
|
||||
keylist = [op_push(len(k) / 2) + k for k in public_keys]
|
||||
return op_m + ''.join(keylist) + op_n + 'ae'
|
||||
|
||||
@classmethod
|
||||
def pay_script(cls, output_type, addr):
|
||||
script = ''
|
||||
if output_type & TYPE_CLAIM:
|
||||
claim, addr = addr
|
||||
claim_name, claim_value = claim
|
||||
script += 'b5' # op_claim_name
|
||||
script += push_script(claim_name.encode('hex'))
|
||||
script += push_script(claim_value.encode('hex'))
|
||||
script += '6d75' # op_2drop, op_drop
|
||||
elif output_type & TYPE_SUPPORT:
|
||||
claim, addr = addr
|
||||
claim_name, claim_id = claim
|
||||
script += 'b6'
|
||||
script += push_script(claim_name.encode('hex'))
|
||||
script += push_script(claim_id.encode('hex'))
|
||||
script += '6d75'
|
||||
elif output_type & TYPE_UPDATE:
|
||||
claim, addr = addr
|
||||
claim_name, claim_id, claim_value = claim
|
||||
script += 'b7'
|
||||
script += push_script(claim_name.encode('hex'))
|
||||
script += push_script(claim_id.encode('hex'))
|
||||
script += push_script(claim_value.encode('hex'))
|
||||
script += '6d6d'
|
||||
|
||||
if output_type & TYPE_SCRIPT:
|
||||
script += addr.encode('hex')
|
||||
elif output_type & TYPE_ADDRESS: # op_2drop, op_drop
|
||||
addrtype, hash_160 = address_to_hash_160(addr)
|
||||
if addrtype == 0:
|
||||
script += '76a9' # op_dup, op_hash_160
|
||||
script += push_script(hash_160.encode('hex'))
|
||||
script += '88ac' # op_equalverify, op_checksig
|
||||
elif addrtype == 5:
|
||||
script += 'a9' # op_hash_160
|
||||
script += push_script(hash_160.encode('hex'))
|
||||
script += '87' # op_equal
|
||||
else:
|
||||
raise Exception("Unknown address type: %s" % addrtype)
|
||||
else:
|
||||
raise Exception("Unknown output type: %s" % output_type)
|
||||
return script
|
||||
|
||||
@classmethod
|
||||
def input_script(cls, txin, i, for_sig):
|
||||
# for_sig:
|
||||
# -1 : do not sign, estimate length
|
||||
# i>=0 : serialized tx for signing input i
|
||||
# None : add all known signatures
|
||||
|
||||
p2sh = txin.get('redeemScript') is not None
|
||||
num_sig = txin['num_sig'] if p2sh else 1
|
||||
address = txin['address']
|
||||
|
||||
x_signatures = txin['signatures']
|
||||
signatures = filter(None, x_signatures)
|
||||
is_complete = len(signatures) == num_sig
|
||||
|
||||
if for_sig in [-1, None]:
|
||||
# if we have enough signatures, we use the actual pubkeys
|
||||
# use extended pubkeys (with bip32 derivation)
|
||||
if for_sig == -1:
|
||||
# we assume that signature will be 0x48 bytes long
|
||||
pubkeys = txin['pubkeys']
|
||||
sig_list = ["00" * 0x48] * num_sig
|
||||
elif is_complete:
|
||||
pubkeys = txin['pubkeys']
|
||||
sig_list = ((sig + '01') for sig in signatures)
|
||||
else:
|
||||
pubkeys = txin['x_pubkeys']
|
||||
sig_list = ((sig + '01') if sig else NO_SIGNATURE for sig in x_signatures)
|
||||
script = ''.join(push_script(x) for x in sig_list)
|
||||
if not p2sh:
|
||||
x_pubkey = pubkeys[0]
|
||||
if x_pubkey is None:
|
||||
addrtype, h160 = address_to_hash_160(txin['address'])
|
||||
x_pubkey = 'fd' + (chr(addrtype) + h160).encode('hex')
|
||||
script += push_script(x_pubkey)
|
||||
else:
|
||||
script = '00' + script # put op_0 in front of script
|
||||
redeem_script = cls.multisig_script(pubkeys, num_sig)
|
||||
script += push_script(redeem_script)
|
||||
|
||||
elif for_sig == i:
|
||||
script_type = TYPE_ADDRESS
|
||||
if 'is_claim' in txin and txin['is_claim']:
|
||||
script_type |= TYPE_CLAIM
|
||||
address = ((txin['claim_name'], txin['claim_value']), address)
|
||||
elif 'is_support' in txin and txin['is_support']:
|
||||
script_type |= TYPE_SUPPORT
|
||||
address = ((txin['claim_name'], txin['claim_id']), address)
|
||||
elif 'is_update' in txin and txin['is_update']:
|
||||
script_type |= TYPE_UPDATE
|
||||
address = ((txin['claim_name'], txin['claim_id'], txin['claim_value']), address)
|
||||
script = txin['redeemScript'] if p2sh else cls.pay_script(script_type, address)
|
||||
else:
|
||||
script = ''
|
||||
|
||||
return script
|
||||
|
||||
@classmethod
|
||||
def serialize_input(cls, txin, i, for_sig):
|
||||
# Prev hash and index
|
||||
s = txin['prevout_hash'].decode('hex')[::-1].encode('hex')
|
||||
s += int_to_hex(txin['prevout_n'], 4)
|
||||
# Script length, script, sequence
|
||||
script = cls.input_script(txin, i, for_sig)
|
||||
s += var_int(len(script) / 2)
|
||||
s += script
|
||||
s += "ffffffff"
|
||||
return s
|
||||
|
||||
def BIP_LI01_sort(self):
|
||||
# See https://github.com/kristovatlas/rfc/blob/master/bips/bip-li01.mediawiki
|
||||
self._inputs.sort(key=lambda i: (i['prevout_hash'], i['prevout_n']))
|
||||
self._outputs.sort(key=lambda o: (o[2], self.pay_script(o[0], o[1])))
|
||||
|
||||
def serialize(self, for_sig=None):
|
||||
inputs = self.inputs()
|
||||
outputs = self.outputs()
|
||||
s = int_to_hex(1, 4) # version
|
||||
s += var_int(len(inputs)) # number of inputs
|
||||
for i, txin in enumerate(inputs):
|
||||
s += self.serialize_input(txin, i, for_sig)
|
||||
s += var_int(len(outputs)) # number of outputs
|
||||
for output in outputs:
|
||||
output_type, addr, amount = output
|
||||
s += int_to_hex(amount, 8) # amount
|
||||
script = self.pay_script(output_type, addr)
|
||||
s += var_int(len(script) / 2) # script length
|
||||
s += script # script
|
||||
s += int_to_hex(0, 4) # lock time
|
||||
if for_sig is not None and for_sig != -1:
|
||||
s += int_to_hex(1, 4) # hash type
|
||||
return s
|
||||
|
||||
def tx_for_sig(self, i):
|
||||
return self.serialize(for_sig=i)
|
||||
|
||||
def hash(self):
|
||||
return Hash(self.raw.decode('hex'))[::-1].encode('hex')
|
||||
|
||||
def get_claim_id(self, nout):
|
||||
if nout < 0:
|
||||
raise IndexError
|
||||
if not self._outputs[nout][0] & TYPE_CLAIM:
|
||||
raise ValueError
|
||||
tx_hash = rev_hex(self.hash()).decode('hex')
|
||||
return encode_claim_id_hex(claim_id_hash(tx_hash, nout))
|
||||
|
||||
def add_inputs(self, inputs):
|
||||
self._inputs.extend(inputs)
|
||||
self.raw = None
|
||||
|
||||
def add_outputs(self, outputs):
|
||||
self._outputs.extend(outputs)
|
||||
self.raw = None
|
||||
|
||||
def input_value(self):
|
||||
return sum(x['value'] for x in self.inputs())
|
||||
|
||||
def output_value(self):
|
||||
return sum(val for tp, addr, val in self.outputs())
|
||||
|
||||
def get_fee(self):
|
||||
return self.input_value() - self.output_value()
|
||||
|
||||
def is_final(self):
|
||||
return not any([x.get('sequence') < 0xffffffff - 1 for x in self.inputs()])
|
||||
|
||||
@classmethod
|
||||
def fee_for_size(cls, relay_fee, fee_per_kb, size):
|
||||
'''Given a fee per kB in satoshis, and a tx size in bytes,
|
||||
returns the transaction fee.'''
|
||||
fee = int(fee_per_kb * size / 1000.)
|
||||
if fee < relay_fee:
|
||||
fee = relay_fee
|
||||
return fee
|
||||
|
||||
@profiler
|
||||
def estimated_size(self):
|
||||
'''Return an estimated tx size in bytes.'''
|
||||
return len(self.serialize(-1)) / 2 # ASCII hex string
|
||||
|
||||
@classmethod
|
||||
def estimated_input_size(cls, txin):
|
||||
'''Return an estimated of serialized input size in bytes.'''
|
||||
return len(cls.serialize_input(txin, -1, -1)) / 2
|
||||
|
||||
def estimated_fee(self, relay_fee, fee_per_kb):
|
||||
'''Return an estimated fee given a fee per kB in satoshis.'''
|
||||
return self.fee_for_size(relay_fee, fee_per_kb, self.estimated_size())
|
||||
|
||||
def signature_count(self):
|
||||
r = 0
|
||||
s = 0
|
||||
for txin in self.inputs():
|
||||
if txin.get('is_coinbase'):
|
||||
continue
|
||||
signatures = filter(None, txin.get('signatures', []))
|
||||
s += len(signatures)
|
||||
r += txin.get('num_sig', -1)
|
||||
return s, r
|
||||
|
||||
def is_complete(self):
|
||||
s, r = self.signature_count()
|
||||
return r == s
|
||||
|
||||
def inputs_without_script(self):
|
||||
out = set()
|
||||
for i, txin in enumerate(self.inputs()):
|
||||
if txin.get('scriptSig') == '':
|
||||
out.add(i)
|
||||
return out
|
||||
|
||||
def inputs_to_sign(self):
|
||||
out = set()
|
||||
for txin in self.inputs():
|
||||
num_sig = txin.get('num_sig')
|
||||
if num_sig is None:
|
||||
continue
|
||||
x_signatures = txin['signatures']
|
||||
signatures = filter(None, x_signatures)
|
||||
if len(signatures) == num_sig:
|
||||
# input is complete
|
||||
continue
|
||||
for k, x_pubkey in enumerate(txin['x_pubkeys']):
|
||||
if x_signatures[k] is not None:
|
||||
# this pubkey already signed
|
||||
continue
|
||||
out.add(x_pubkey)
|
||||
return out
|
||||
|
||||
def sign(self, keypairs):
|
||||
for i, txin in enumerate(self.inputs()):
|
||||
num = txin['num_sig']
|
||||
for x_pubkey in txin['x_pubkeys']:
|
||||
signatures = filter(None, txin['signatures'])
|
||||
if len(signatures) == num:
|
||||
# txin is complete
|
||||
break
|
||||
if x_pubkey in keypairs.keys():
|
||||
log.debug("adding signature for %s", x_pubkey)
|
||||
# add pubkey to txin
|
||||
txin = self._inputs[i]
|
||||
x_pubkeys = txin['x_pubkeys']
|
||||
ii = x_pubkeys.index(x_pubkey)
|
||||
sec = keypairs[x_pubkey]
|
||||
pubkey = public_key_from_private_key(sec)
|
||||
txin['x_pubkeys'][ii] = pubkey
|
||||
txin['pubkeys'][ii] = pubkey
|
||||
self._inputs[i] = txin
|
||||
# add signature
|
||||
for_sig = Hash(self.tx_for_sig(i).decode('hex'))
|
||||
pkey = regenerate_key(sec)
|
||||
secexp = pkey.secret
|
||||
private_key = MySigningKey.from_secret_exponent(secexp, curve=SECP256k1)
|
||||
public_key = private_key.get_verifying_key()
|
||||
sig = private_key.sign_digest_deterministic(for_sig, hashfunc=hashlib.sha256,
|
||||
sigencode=ecdsa.util.sigencode_der)
|
||||
assert public_key.verify_digest(sig, for_sig,
|
||||
sigdecode=ecdsa.util.sigdecode_der)
|
||||
txin['signatures'][ii] = sig.encode('hex')
|
||||
self._inputs[i] = txin
|
||||
log.debug("is_complete: %s", self.is_complete())
|
||||
self.raw = self.serialize()
|
||||
|
||||
def get_outputs(self):
|
||||
"""convert pubkeys to addresses"""
|
||||
o = []
|
||||
for type, x, v in self.outputs():
|
||||
if type & (TYPE_CLAIM | TYPE_UPDATE | TYPE_SUPPORT):
|
||||
x = x[1]
|
||||
if type & TYPE_ADDRESS:
|
||||
addr = x
|
||||
elif type & TYPE_PUBKEY:
|
||||
addr = public_key_to_address(x.decode('hex'))
|
||||
else:
|
||||
addr = 'SCRIPT ' + x.encode('hex')
|
||||
o.append((addr, v)) # consider using yield (addr, v)
|
||||
return o
|
||||
|
||||
def get_output_addresses(self):
|
||||
return [addr for addr, val in self.get_outputs()]
|
||||
|
||||
def has_address(self, addr):
|
||||
return (addr in self.get_output_addresses()) or (
|
||||
addr in (tx.get("address") for tx in self.inputs()))
|
||||
|
||||
def as_dict(self):
|
||||
if self.raw is None:
|
||||
self.raw = self.serialize()
|
||||
self.deserialize()
|
||||
out = {
|
||||
'hex': self.raw,
|
||||
'complete': self.is_complete()
|
||||
}
|
||||
return out
|
||||
|
||||
def requires_fee(self, wallet):
|
||||
# see https://en.bitcoin.it/wiki/Transaction_fees
|
||||
#
|
||||
# size must be smaller than 1 kbyte for free tx
|
||||
size = len(self.serialize(-1)) / 2
|
||||
if size >= 10000:
|
||||
return True
|
||||
# all outputs must be 0.01 BTC or larger for free tx
|
||||
for addr, value in self.get_outputs():
|
||||
if value < 1000000:
|
||||
return True
|
||||
# priority must be large enough for free tx
|
||||
threshold = 57600000
|
||||
weight = 0
|
||||
for txin in self.inputs():
|
||||
age = wallet.get_confirmations(txin["prevout_hash"])[0]
|
||||
weight += txin["value"] * age
|
||||
priority = weight / size
|
||||
log.error("{} {}".format(priority, threshold))
|
||||
|
||||
return priority < threshold
|
||||
117
lbrynet/wallet/util.py
Normal file
117
lbrynet/wallet/util.py
Normal file
|
|
@ -0,0 +1,117 @@
|
|||
import logging
|
||||
import os
|
||||
import re
|
||||
from decimal import Decimal
|
||||
import json
|
||||
from .constants import NO_SIGNATURE
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
|
||||
|
||||
def normalize_version(v):
|
||||
return [int(x) for x in re.sub(r'(\.0+)*$', '', v).split(".")]
|
||||
|
||||
|
||||
def json_decode(x):
|
||||
try:
|
||||
return json.loads(x, parse_float=Decimal)
|
||||
except:
|
||||
return x
|
||||
|
||||
|
||||
def user_dir():
|
||||
if "HOME" in os.environ:
|
||||
return os.path.join(os.environ["HOME"], ".lbryum")
|
||||
elif "APPDATA" in os.environ:
|
||||
return os.path.join(os.environ["APPDATA"], "LBRYum")
|
||||
elif "LOCALAPPDATA" in os.environ:
|
||||
return os.path.join(os.environ["LOCALAPPDATA"], "LBRYum")
|
||||
elif 'ANDROID_DATA' in os.environ:
|
||||
try:
|
||||
import jnius
|
||||
env = jnius.autoclass('android.os.Environment')
|
||||
_dir = env.getExternalStorageDirectory().getPath()
|
||||
return _dir + '/lbryum/'
|
||||
except ImportError:
|
||||
pass
|
||||
return "/sdcard/lbryum/"
|
||||
else:
|
||||
# raise Exception("No home directory found in environment variables.")
|
||||
return
|
||||
|
||||
|
||||
def format_satoshis(x, is_diff=False, num_zeros=0, decimal_point=8, whitespaces=False):
|
||||
from locale import localeconv
|
||||
if x is None:
|
||||
return 'unknown'
|
||||
x = int(x) # Some callers pass Decimal
|
||||
scale_factor = pow(10, decimal_point)
|
||||
integer_part = "{:n}".format(int(abs(x) / scale_factor))
|
||||
if x < 0:
|
||||
integer_part = '-' + integer_part
|
||||
elif is_diff:
|
||||
integer_part = '+' + integer_part
|
||||
dp = localeconv()['decimal_point']
|
||||
fract_part = ("{:0" + str(decimal_point) + "}").format(abs(x) % scale_factor)
|
||||
fract_part = fract_part.rstrip('0')
|
||||
if len(fract_part) < num_zeros:
|
||||
fract_part += "0" * (num_zeros - len(fract_part))
|
||||
result = integer_part + dp + fract_part
|
||||
if whitespaces:
|
||||
result += " " * (decimal_point - len(fract_part))
|
||||
result = " " * (15 - len(result)) + result
|
||||
return result.decode('utf8')
|
||||
|
||||
|
||||
def rev_hex(s):
|
||||
return s.decode('hex')[::-1].encode('hex')
|
||||
|
||||
|
||||
def int_to_hex(i, length=1):
|
||||
s = hex(i)[2:].rstrip('L')
|
||||
s = "0" * (2 * length - len(s)) + s
|
||||
return rev_hex(s)
|
||||
|
||||
|
||||
def hex_to_int(s):
|
||||
return int('0x' + s[::-1].encode('hex'), 16)
|
||||
|
||||
|
||||
def var_int(i):
|
||||
# https://en.bitcoin.it/wiki/Protocol_specification#Variable_length_integer
|
||||
if i < 0xfd:
|
||||
return int_to_hex(i)
|
||||
elif i <= 0xffff:
|
||||
return "fd" + int_to_hex(i, 2)
|
||||
elif i <= 0xffffffff:
|
||||
return "fe" + int_to_hex(i, 4)
|
||||
else:
|
||||
return "ff" + int_to_hex(i, 8)
|
||||
|
||||
|
||||
# This function comes from bitcointools, bct-LICENSE.txt.
|
||||
def long_hex(bytes):
|
||||
return bytes.encode('hex_codec')
|
||||
|
||||
|
||||
# This function comes from bitcointools, bct-LICENSE.txt.
|
||||
def short_hex(bytes):
|
||||
t = bytes.encode('hex_codec')
|
||||
if len(t) < 11:
|
||||
return t
|
||||
return t[0:4] + "..." + t[-4:]
|
||||
|
||||
|
||||
def parse_sig(x_sig):
|
||||
s = []
|
||||
for sig in x_sig:
|
||||
if sig[-2:] == '01':
|
||||
s.append(sig[:-2])
|
||||
else:
|
||||
assert sig == NO_SIGNATURE
|
||||
s.append(None)
|
||||
return s
|
||||
|
||||
|
||||
def is_extended_pubkey(x_pubkey):
|
||||
return x_pubkey[0:2] in ['fe', 'ff']
|
||||
1499
lbrynet/wallet/wallet.py
Normal file
1499
lbrynet/wallet/wallet.py
Normal file
File diff suppressed because it is too large
Load diff
2048
lbrynet/wallet/wordlist/chinese_simplified.txt
Normal file
2048
lbrynet/wallet/wordlist/chinese_simplified.txt
Normal file
File diff suppressed because it is too large
Load diff
2048
lbrynet/wallet/wordlist/english.txt
Normal file
2048
lbrynet/wallet/wordlist/english.txt
Normal file
File diff suppressed because it is too large
Load diff
2048
lbrynet/wallet/wordlist/japanese.txt
Normal file
2048
lbrynet/wallet/wordlist/japanese.txt
Normal file
File diff suppressed because it is too large
Load diff
1654
lbrynet/wallet/wordlist/portuguese.txt
Normal file
1654
lbrynet/wallet/wordlist/portuguese.txt
Normal file
File diff suppressed because it is too large
Load diff
2048
lbrynet/wallet/wordlist/spanish.txt
Normal file
2048
lbrynet/wallet/wordlist/spanish.txt
Normal file
File diff suppressed because it is too large
Load diff
Loading…
Reference in a new issue