def check_address(address):
if is_address(address) is False:
while is_address(address) is False:
address = raw_input("Invalid bitcoin address, please enter another address: ")
if is_address(address):
return address
def parse_URI(uri):
import bitcoin
from bitcoin import COIN
if ':' not in uri:
assert bitcoin.is_address(uri)
return {'address': uri}
u = urlparse.urlparse(uri)
assert u.scheme == 'verge'
address = u.path
# python for android fails to parse query
if address.find('?') > 0:
address, query = u.path.split('?')
pq = urlparse.parse_qs(query)
else:
pq = urlparse.parse_qs(u.query)
for k, v in pq.items():
if len(v) != 1:
raise Exception('Duplicate Key', k)
out = {k: v[0] for k, v in pq.items()}
if address:
assert bitcoin.is_address(address)
out['address'] = address
if 'amount' in out:
am = out['amount']
m = re.match('([0-9\.]+)X([0-9])', am)
if m:
k = int(m.group(2)) - 8
amount = Decimal(m.group(1)) * pow(Decimal(10), k)
else:
amount = Decimal(am) * COIN
out['amount'] = int(amount)
if 'message' in out:
out['message'] = out['message'].decode('utf8')
out['memo'] = out['message']
if 'time' in out:
out['time'] = int(out['time'])
if 'exp' in out:
out['exp'] = int(out['exp'])
if 'sig' in out:
out['sig'] = bitcoin.base_decode(out['sig'], None,
base=58).encode('hex')
return out
def parse_URI(uri):
import bitcoin
from bitcoin import COIN
if ':' not in uri:
assert bitcoin.is_address(uri)
return {'address': uri}
u = urlparse.urlparse(uri)
assert u.scheme == 'bitcoin'
address = u.path
# python for android fails to parse query
if address.find('?') > 0:
address, query = u.path.split('?')
pq = urlparse.parse_qs(query)
else:
pq = urlparse.parse_qs(u.query)
for k, v in pq.items():
if len(v)!=1:
raise Exception('Duplicate Key', k)
out = {k: v[0] for k, v in pq.items()}
if address:
assert bitcoin.is_address(address)
out['address'] = address
if 'amount' in out:
am = out['amount']
m = re.match('([0-9\.]+)X([0-9])', am)
if m:
k = int(m.group(2)) - 8
amount = Decimal(m.group(1)) * pow( Decimal(10) , k)
else:
amount = Decimal(am) * COIN
out['amount'] = int(amount)
if 'message' in out:
out['message'] = out['message'].decode('utf8')
out['memo'] = out['message']
if 'time' in out:
out['time'] = int(out['time'])
if 'exp' in out:
out['exp'] = int(out['exp'])
if 'sig' in out:
out['sig'] = bitcoin.base_decode(out['sig'], None, base=58).encode('hex')
return out
def parse_URI(uri, active_chain=None):
import urlparse
import bitcoin
from decimal import Decimal
import chainparams
if active_chain is None:
active_chain = chainparams.get_active_chain()
if ':' not in uri:
assert bitcoin.is_address(uri, active_chain)
return uri, None, None, None, None
uri_scheme = active_chain.coin_name.lower()
u = urlparse.urlparse(uri)
assert u.scheme == uri_scheme
address = u.path
valid_address = bitcoin.is_address(address, active_chain)
pq = urlparse.parse_qs(u.query)
for k, v in pq.items():
if len(v) != 1:
raise Exception('Duplicate Key', k)
amount = label = message = request_url = ''
if 'amount' in pq:
am = pq['amount'][0]
m = re.match('([0-9\.]+)X([0-9])', am)
if m:
k = int(m.group(2)) - 8
amount = Decimal(m.group(1)) * pow(Decimal(10), k)
else:
amount = Decimal(am) * 100000000
if 'message' in pq:
message = pq['message'][0]
if 'label' in pq:
label = pq['label'][0]
if 'r' in pq:
request_url = pq['r'][0]
if request_url != '':
return address, amount, label, message, request_url
assert valid_address
return address, amount, label, message, request_url
def parse_URI(uri, active_chain=None):
import urlparse
import bitcoin
from decimal import Decimal
import chainparams
if active_chain is None:
active_chain = chainparams.get_active_chain()
if ':' not in uri:
assert bitcoin.is_address(uri, active_chain)
return uri, None, None, None, None
uri_scheme = active_chain.coin_name.lower()
u = urlparse.urlparse(uri)
assert u.scheme == uri_scheme
address = u.path
valid_address = bitcoin.is_address(address, active_chain)
pq = urlparse.parse_qs(u.query)
for k, v in pq.items():
if len(v)!=1:
raise Exception('Duplicate Key', k)
amount = label = message = request_url = ''
if 'amount' in pq:
am = pq['amount'][0]
m = re.match('([0-9\.]+)X([0-9])', am)
if m:
k = int(m.group(2)) - 8
amount = Decimal(m.group(1)) * pow( Decimal(10) , k)
else:
amount = Decimal(am) * 100000000
if 'message' in pq:
message = pq['message'][0]
if 'label' in pq:
label = pq['label'][0]
if 'r' in pq:
request_url = pq['r'][0]
if request_url != '':
return address, amount, label, message, request_url
assert valid_address
return address, amount, label, message, request_url
def resolve(self, k):
if bitcoin.is_address(k):
return {
'address': k,
'type': 'address'
}
if k in self.keys():
_type, addr = self[k]
if _type == 'address':
return {
'address': addr,
'type': 'contact'
}
out = self.resolve_openalias(k)
if out:
address, name = out
try:
validated = self.validate_dnssec(k)
except:
validated = False
traceback.print_exc(file=sys.stderr)
return {
'address': address,
'name': name,
'type': 'openalias',
'validated': validated
}
raise Exception("Invalid BataCoin address or alias", k)
def resolve(self, k):
if bitcoin.is_address(k):
return {'address': k, 'type': 'address'}
if k in self.keys():
_type, addr = self[k]
if _type == 'address':
return {'address': addr, 'type': 'contact'}
out = self.resolve_openalias(k)
if out:
address, name = out
try:
validated = self.validate_dnssec(k)
except:
validated = False
traceback.print_exc(file=sys.stderr)
return {
'address': address,
'name': name,
'type': 'openalias',
'validated': validated
}
raise Exception("Invalid BataCoin address or alias", k)
def parse_URI(uri):
import bitcoin
from decimal import Decimal
if ":" not in uri:
assert bitcoin.is_address(uri)
return uri, None, None, None, None
u = urlparse.urlparse(uri)
assert u.scheme == "creditbit"
address = u.path
# python for android fails to parse query
if address.find("?") > 0:
address, query = u.path.split("?")
pq = urlparse.parse_qs(query)
else:
pq = urlparse.parse_qs(u.query)
for k, v in pq.items():
if len(v) != 1:
raise Exception("Duplicate Key", k)
amount = label = message = request_url = ""
if "amount" in pq:
am = pq["amount"][0]
m = re.match("([0-9\.]+)X([0-9])", am)
if m:
k = int(m.group(2)) - 8
amount = Decimal(m.group(1)) * pow(Decimal(10), k)
else:
amount = Decimal(am) * 1000000
if "message" in pq:
message = pq["message"][0].decode("utf8")
if "label" in pq:
label = pq["label"][0]
if "r" in pq:
request_url = pq["r"][0]
if request_url != "":
return address, amount, label, message, request_url
assert bitcoin.is_address(address)
return address, amount, label, message, request_url
def __init__(self, config):
StoreDict.__init__(self, config, 'contacts')
# backward compatibility
for k, v in self.items():
_type, n = v
if _type == 'address' and bitcoin.is_address(n):
self.pop(k)
self[n] = ('address', k)
def parse_URI(uri):
import bitcoin
from decimal import Decimal
if ':' not in uri:
assert bitcoin.is_address(uri)
return uri, None, None, None, None
u = urlparse.urlparse(uri)
assert u.scheme == 'bitcoin'
address = u.path
# python for android fails to parse query
if address.find('?') > 0:
address, query = u.path.split('?')
pq = urlparse.parse_qs(query)
else:
pq = urlparse.parse_qs(u.query)
for k, v in pq.items():
if len(v) != 1:
raise Exception('Duplicate Key', k)
amount = label = message = request_url = ''
if 'amount' in pq:
am = pq['amount'][0]
m = re.match('([0-9\.]+)X([0-9])', am)
if m:
k = int(m.group(2)) - 8
amount = Decimal(m.group(1)) * pow(Decimal(10), k)
else:
amount = Decimal(am) * 100000000
if 'message' in pq:
message = pq['message'][0].decode('utf8')
if 'label' in pq:
label = pq['label'][0]
if 'r' in pq:
request_url = pq['r'][0]
if request_url != '':
return address, amount, label, message, request_url
assert bitcoin.is_address(address)
return address, amount, label, message, request_url
def parse_URI(uri):
import bitcoin
from decimal import Decimal
if ':' not in uri:
assert bitcoin.is_address(uri)
return uri, None, None, None, None
u = urlparse.urlparse(uri)
assert u.scheme == 'VERGE'
address = u.path
# python for android fails to parse query
if address.find('?') > 0:
address, query = u.path.split('?')
pq = urlparse.parse_qs(query)
else:
pq = urlparse.parse_qs(u.query)
for k, v in pq.items():
if len(v)!=1:
raise Exception('Duplicate Key', k)
amount = label = message = request_url = ''
if 'amount' in pq:
am = pq['amount'][0]
m = re.match('([0-9\.]+)X([0-9])', am)
if m:
k = int(m.group(2)) - 8
amount = Decimal(m.group(1)) * pow( Decimal(10) , k)
else:
amount = Decimal(am) * 1000000
if 'message' in pq:
message = pq['message'][0].decode('utf8')
if 'label' in pq:
label = pq['label'][0]
if 'r' in pq:
request_url = pq['r'][0]
if request_url != '':
return address, amount, label, message, request_url
assert bitcoin.is_address(address)
return address, amount, label, message, request_url
def __init__(self, config):
StoreDict.__init__(self, config, 'contacts')
# backward compatibility
for k, v in self.items():
_type, n = v
if _type == 'address' and bitcoin.is_address(n):
self.pop(k)
self[n] = ('address', k)
def getprivatekeys(self, address):
"""Get private keys of addresses. You may pass a single wallet address, or a list of wallet addresses."""
if is_address(address):
return self.wallet.get_private_key(address, self._password)
domain = json_loads(address)
return [
self.wallet.get_private_key(address, self._password)
for address in domain
]
def __init__(self, storage):
self.storage = storage
d = self.storage.get('contacts', {})
self.update(d)
# backward compatibility
for k, v in self.items():
_type, n = v
if _type == 'address' and bitcoin.is_address(n):
self.pop(k)
self[n] = ('address', k)
def parse_URI(uri):
import bitcoin
from bitcoin import COIN
if ':' not in uri:
assert bitcoin.is_address(uri)
return uri, None, None, None, None
u = urlparse.urlparse(uri)
assert u.scheme == 'bitcoin'
address = u.path
# python for android fails to parse query
if address.find('?') > 0:
address, query = u.path.split('?')
pq = urlparse.parse_qs(query)
else:
pq = urlparse.parse_qs(u.query)
for k, v in pq.items():
if len(v) != 1:
raise Exception('Duplicate Key', k)
if k not in ['amount', 'label', 'message', 'r', 's']:
raise BaseException('Unknown key', k)
out = {k: v[0] for k, v in pq.items()}
if address:
assert bitcoin.is_address(address)
out['address'] = address
if 'amount' in out:
am = out['amount']
m = re.match('([0-9\.]+)X([0-9])', am)
if m:
k = int(m.group(2)) - 8
amount = Decimal(m.group(1)) * pow(Decimal(10), k)
else:
amount = Decimal(am) * COIN
out['amount'] = amount
if 'message' in out:
out['message'] = out['message'].decode('utf8')
return out
def parse_URI(uri):
import bitcoin
from bitcoin import COIN
if ':' not in uri:
assert bitcoin.is_address(uri)
return uri, None, None, None, None
u = urlparse.urlparse(uri)
assert u.scheme == 'bitcoin'
address = u.path
# python for android fails to parse query
if address.find('?') > 0:
address, query = u.path.split('?')
pq = urlparse.parse_qs(query)
else:
pq = urlparse.parse_qs(u.query)
for k, v in pq.items():
if len(v)!=1:
raise Exception('Duplicate Key', k)
if k not in ['amount', 'label', 'message', 'r', 's']:
raise BaseException('Unknown key', k)
out = {k: v[0] for k, v in pq.items()}
if address:
assert bitcoin.is_address(address)
out['address'] = address
if 'amount' in out:
am = out['amount']
m = re.match('([0-9\.]+)X([0-9])', am)
if m:
k = int(m.group(2)) - 8
amount = Decimal(m.group(1)) * pow( Decimal(10) , k)
else:
amount = Decimal(am) * COIN
out['amount'] = amount
if 'message' in out:
out['message'] = out['message'].decode('utf8')
return out
def resolve(self, k):
if bitcoin.is_address(k):
return {'address':k, 'type':'address'}
if k in self.keys():
_type, addr = self[k]
if _type == 'address':
return {'address':addr, 'type':'contact'}
out = run_hook('resolve_address', k)
if out:
return out
raise Exception("Invalid Bitcoin address or alias", k)
def _read_csv(self, csvpath):
import csv
outputs = []
with open(csvpath, 'rb') as csvfile:
csvReader = csv.reader(csvfile, delimiter=',')
for row in csvReader:
address, amount = row
assert bitcoin.is_address(address)
amount = Decimal(amount)
outputs.append((address, amount))
return outputs
def _validate(self, data):
for k, v in data.items():
if k == 'contacts':
return self._validate(v)
if not bitcoin.is_address(k):
data.pop(k)
else:
_type, _ = v
if _type != 'address':
data.pop(k)
return data
def _read_csv(self, csvpath):
import csv
outputs = []
with open(csvpath, 'rb') as csvfile:
csvReader = csv.reader(csvfile, delimiter=',')
for row in csvReader:
address, amount = row
assert bitcoin.is_address(address)
amount = Decimal(amount)
outputs.append((address, amount))
return outputs
def __init__(self, storage):
self.storage = storage
d = self.storage.get('contacts', {})
try:
self.update(d)
except:
return
# backward compatibility
for k, v in self.items():
_type, n = v
if _type == 'address' and bitcoin.is_address(n):
self.pop(k)
self[n] = ('address', k)
def resolve(self, k, nocheck=False):
if bitcoin.is_address(k):
return {'address': k, 'type': 'address'}
if k in self.keys():
_type, addr = self[k]
if _type == 'address':
return {'address': addr, 'type': 'contact'}
out = run_hook('resolve_address', k)
if out:
if not nocheck and out.get('validated') is False:
raise Exception("cannot validate alias")
return out
raise Exception("invalid coin address", k)
def create_URI(addr, amount, message):
import bitcoin
if not bitcoin.is_address(addr):
return ""
query = []
if amount:
query.append('amount=%s'%format_satoshis_plain(amount))
if message:
if type(message) == unicode:
message = message.encode('utf8')
query.append('message=%s'%urllib.quote(message))
p = urlparse.ParseResult(scheme='VERGE', netloc='', path=addr, params='', query='&'.join(query), fragment='')
return urlparse.urlunparse(p)
def resolve(self, k, nocheck=False):
if bitcoin.is_address(k):
return {'address':k, 'type':'address'}
if k in self.keys():
_type, addr = self[k]
if _type == 'address':
return {'address':addr, 'type':'contact'}
out = run_hook('resolve_address', k)
if out:
if not nocheck and out.get('validated') is False:
raise Exception("cannot validate alias")
return out
raise Exception("invalid coin address", k)
def create_URI(addr, amount, message):
import bitcoin
if not bitcoin.is_address(addr):
return ""
query = []
if amount:
query.append('amount=%s'%format_satoshis_plain(amount))
if message:
if type(message) == unicode:
message = message.encode('utf8')
query.append('message=%s'%urllib.quote(message))
p = urlparse.ParseResult(scheme='bitcoin', netloc='', path=addr, params='', query='&'.join(query), fragment='')
return urlparse.urlunparse(p)
def parse_URI(uri):
import urlparse
import bitcoin
from decimal import Decimal
if ':' not in uri:
assert bitcoin.is_address(uri)
return uri, None, None, None, None
u = urlparse.urlparse(uri)
assert u.scheme == 'litecoin'
address = u.path
assert bitcoin.is_address(address)
pq = urlparse.parse_qs(u.query)
for k, v in pq.items():
if len(v)!=1:
raise Exception('Duplicate Key', k)
amount = label = message = request_url = ''
if 'amount' in pq:
am = pq['amount'][0]
m = re.match('([0-9\.]+)X([0-9])', am)
if m:
k = int(m.group(2)) - 8
amount = Decimal(m.group(1)) * pow( Decimal(10) , k)
else:
amount = Decimal(am) * 100000000
if 'message' in pq:
message = pq['message'][0]
if 'label' in pq:
label = pq['label'][0]
if 'r' in pq:
request_url = pq['r'][0]
return address, amount, label, message, request_url
def parse_URI(uri):
import urlparse
import bitcoin
from decimal import Decimal
if ':' not in uri:
assert bitcoin.is_address(uri)
return uri, None, None, None, None
u = urlparse.urlparse(uri)
assert u.scheme == 'bitcoin'
address = u.path
assert bitcoin.is_address(address)
pq = urlparse.parse_qs(u.query)
for k, v in pq.items():
if len(v) != 1:
raise Exception('Duplicate Key', k)
amount = label = message = request_url = ''
if 'amount' in pq:
am = pq['amount'][0]
m = re.match('([0-9\.]+)X([0-9])', am)
if m:
k = int(m.group(2)) - 8
amount = Decimal(m.group(1)) * pow(Decimal(10), k)
else:
amount = Decimal(am)
if 'message' in pq:
message = pq['message'][0]
if 'label' in pq:
label = pq['label'][0]
if 'r' in pq:
request_url = pq['r'][0]
return address, amount, label, message, request_url
def create_URI(addr, amount, message):
import bitcoin
if not bitcoin.is_address(addr):
return ""
query = []
if amount:
query.append("amount=%s" % format_satoshis_plain(amount))
if message:
if type(message) == unicode:
message = message.encode("utf8")
query.append("message=%s" % urllib.quote(message))
p = urlparse.ParseResult(scheme="bitcoin", netloc="", path=addr, params="", query="&".join(query), fragment="")
return urlparse.urlunparse(p)
def check_valid(self):
"""Evaluate whether this proposal is valid."""
if not self.proposal_name:
raise ValueError(_('A proposal name is required.'))
elif len(self.proposal_name) > 20:
raise ValueError(
_('Proposal names have a limit of 20 characters.'))
if not is_safe(self.proposal_name):
raise ValueError(_('Unsafe characters in proposal name.'))
if not self.proposal_url:
raise ValueError(_('A proposal URL is required.'))
elif len(self.proposal_url) > 64:
raise ValueError(_('Proposal URLs have a limit of 64 characters.'))
if not is_safe(self.proposal_url):
raise ValueError(_('Unsafe characters in proposal URL.'))
if self.end_block < self.start_block:
raise ValueError(_('End block must be after start block.'))
if not bitcoin.is_address(self.address):
raise ValueError(_('Invalid address:') + ' %s' % self.address)
addrtype, h160 = bitcoin.bc_address_to_hash_160(self.address)
if addrtype != bitcoin.PUBKEY_ADDR:
raise ValueError(
_('Only P2PKH addresses are currently supported.'))
if self.payment_amount < bitcoin.COIN:
raise ValueError(_('Payments must be at least 1 DSR.'))
# Calculate max budget.
subsidy = 5 * bitcoin.COIN
if bitcoin.TESTNET:
for i in range(46200, self.start_block + 1,
SUBSIDY_HALVING_INTERVAL):
subsidy -= subsidy / 14
else:
for i in range(SUBSIDY_HALVING_INTERVAL, self.start_block + 1,
SUBSIDY_HALVING_INTERVAL):
subsidy -= subsidy / 14
# 10%
total_budget = ((subsidy / 100) * 10) * BUDGET_PAYMENTS_CYCLE_BLOCKS
if self.payment_amount > total_budget:
raise ValueError(
_('Payment is more than max') +
' (%s).' % util.format_satoshis_plain(total_budget))
def resolve(self, k):
if bitcoin.is_address(k):
return {'address': k, 'type': 'address'}
if k in self.keys():
_type, addr = self[k]
if _type == 'address':
return {'address': addr, 'type': 'contact'}
out = self.resolve_openalias(k)
if out:
address, name, validated = out
return {
'address': address,
'name': name,
'type': 'openalias',
'validated': validated
}
raise Exception("Invalid Viacoin address or alias", k)
def _process_outputs(outputs, timestamp):
total_out = 0
outs = []
for out in sorted(outputs, key=lambda x: x[0]):
address, amount = out
if amount != _cut_to_8(amount):
raise InvalidAmounts(
"Output amounts limited to 8 decimal places: %s" % amount)
if amount <= 0:
raise InvalidAmounts("Output can't be zero or negative")
total_out += amount
outs.append("%s,%s" % (address, amount))
if not is_address(address) or not address.startswith("1"):
raise InvalidAddress("Invalid address: %s" % address)
if type(timestamp) == datetime.datetime:
timestamp = timestamp.isoformat()
return total_out, ";".join(outs + [timestamp])
def resolve(self, k):
if bitcoin.is_address(k):
return {
'address': k,
'type': 'address'
}
if k in self.keys():
_type, addr = self[k]
if _type == 'address':
return {
'address': addr,
'type': 'contact'
}
out = self.resolve_openalias(k)
if out:
address, name, validated = out
return {
'address': address,
'name': name,
'type': 'openalias',
'validated': validated
}
raise Exception("Invalid Bitcoin address or alias", k)
def is_address_list(text):
parts = text.split()
return bool(parts) and all(bitcoin.is_address(x) for x in parts)
def is_address_list(text):
parts = text.split()
return bool(parts) and all(bitcoin.is_address(x) for x in parts)
def parse_URI(uri, on_pr=None):
import bitcoin
from bitcoin import COIN
if ":" not in uri:
assert bitcoin.is_address(uri)
return {"address": uri}
u = urlparse.urlparse(uri)
assert u.scheme == "bitcoin"
address = u.path
# python for android fails to parse query
if address.find("?") > 0:
address, query = u.path.split("?")
pq = urlparse.parse_qs(query)
else:
pq = urlparse.parse_qs(u.query)
for k, v in pq.items():
if len(v) != 1:
raise Exception("Duplicate Key", k)
out = {k: v[0] for k, v in pq.items()}
if address:
assert bitcoin.is_address(address)
out["address"] = address
if "amount" in out:
am = out["amount"]
m = re.match("([0-9\.]+)X([0-9])", am)
if m:
k = int(m.group(2)) - 8
amount = Decimal(m.group(1)) * pow(Decimal(10), k)
else:
amount = Decimal(am) * COIN
out["amount"] = int(amount)
if "message" in out:
out["message"] = out["message"].decode("utf8")
out["memo"] = out["message"]
if "time" in out:
out["time"] = int(out["time"])
if "exp" in out:
out["exp"] = int(out["exp"])
if "sig" in out:
out["sig"] = bitcoin.base_decode(out["sig"], None, base=58).encode("hex")
r = out.get("r")
sig = out.get("sig")
name = out.get("name")
if r or (name and sig):
def get_payment_request_thread():
import paymentrequest as pr
if name and sig:
s = pr.serialize_request(out).SerializeToString()
request = pr.PaymentRequest(s)
else:
request = pr.get_payment_request(r)
on_pr(request)
t = threading.Thread(target=get_payment_request_thread)
t.setDaemon(True)
t.start()
return out
def parse_URI(uri, on_pr=None):
import bitcoin
from bitcoin import COIN
if ':' not in uri:
if not bitcoin.is_address(uri):
raise BaseException("Not a bitcoin address")
return {'address': uri}
u = urlparse.urlparse(uri)
if u.scheme != 'bitcoin':
raise BaseException("Not a bitcoin URI")
address = u.path
# python for android fails to parse query
if address.find('?') > 0:
address, query = u.path.split('?')
pq = urlparse.parse_qs(query)
else:
pq = urlparse.parse_qs(u.query)
for k, v in pq.items():
if len(v)!=1:
raise Exception('Duplicate Key', k)
out = {k: v[0] for k, v in pq.items()}
if address:
if not bitcoin.is_address(address):
raise BaseException("Invalid bitcoin address:" + address)
out['address'] = address
if 'amount' in out:
am = out['amount']
m = re.match('([0-9\.]+)X([0-9])', am)
if m:
k = int(m.group(2)) - 8
amount = Decimal(m.group(1)) * pow( Decimal(10) , k)
else:
amount = Decimal(am) * COIN
out['amount'] = int(amount)
if 'message' in out:
out['message'] = out['message'].decode('utf8')
out['memo'] = out['message']
if 'time' in out:
out['time'] = int(out['time'])
if 'exp' in out:
out['exp'] = int(out['exp'])
if 'sig' in out:
out['sig'] = bitcoin.base_decode(out['sig'], None, base=58).encode('hex')
r = out.get('r')
sig = out.get('sig')
name = out.get('name')
if on_pr and (r or (name and sig)):
def get_payment_request_thread():
import paymentrequest as pr
if name and sig:
s = pr.serialize_request(out).SerializeToString()
request = pr.PaymentRequest(s)
else:
request = pr.get_payment_request(r)
on_pr(request)
t = threading.Thread(target=get_payment_request_thread)
t.setDaemon(True)
t.start()
return out
def parse_URI(uri, on_pr=None):
import bitcoin
from bitcoin import COIN
if ':' not in uri:
if not bitcoin.is_address(uri):
raise BaseException("Not a bitcoin address")
return {'address': uri}
u = urlparse.urlparse(uri)
if u.scheme != 'bitcoin':
raise BaseException("Not a bitcoin URI")
address = u.path
# python for android fails to parse query
if address.find('?') > 0:
address, query = u.path.split('?')
pq = urlparse.parse_qs(query)
else:
pq = urlparse.parse_qs(u.query)
for k, v in pq.items():
if len(v)!=1:
raise Exception('Duplicate Key', k)
out = {k: v[0] for k, v in pq.items()}
if address:
if not bitcoin.is_address(address):
raise BaseException("Invalid bitcoin address:" + address)
out['address'] = address
if 'amount' in out:
am = out['amount']
m = re.match('([0-9\.]+)X([0-9])', am)
if m:
k = int(m.group(2)) - 8
amount = Decimal(m.group(1)) * pow( Decimal(10) , k)
else:
amount = Decimal(am) * COIN
out['amount'] = int(amount)
if 'message' in out:
out['message'] = out['message'].decode('utf8')
out['memo'] = out['message']
if 'time' in out:
out['time'] = int(out['time'])
if 'exp' in out:
out['exp'] = int(out['exp'])
if 'sig' in out:
out['sig'] = bitcoin.base_decode(out['sig'], None, base=58).encode('hex')
r = out.get('r')
sig = out.get('sig')
name = out.get('name')
if on_pr and (r or (name and sig)):
def get_payment_request_thread():
import paymentrequest as pr
if name and sig:
s = pr.serialize_request(out).SerializeToString()
request = pr.PaymentRequest(s)
else:
request = pr.get_payment_request(r)
on_pr(request)
t = threading.Thread(target=get_payment_request_thread)
t.setDaemon(True)
t.start()
return out
def validateaddress(self, address):
"""Check that an address is valid. """
return is_address(address)
def validateaddress(self, address):
"""Check that an address is valid. """
return is_address(address)
def getprivatekeys(self, address):
"""Get private keys of addresses. You may pass a single wallet address, or a list of wallet addresses."""
if is_address(address):
return self.wallet.get_private_key(address, self._password)
domain = json_loads(address)
return [self.wallet.get_private_key(address, self._password) for address in domain]
