def blockstack_name_renew(name,
privatekey,
register_addr=None,
subsidy_key=None,
user_public_key=None,
safety_checks=False):
test_proxy = make_proxy()
blockstack_client.set_default_proxy(test_proxy)
name_cost_info = test_proxy.get_name_cost(name)
if register_addr is None:
register_addr = pybitcoin.BitcoinPrivateKey(
privatekey).public_key().address()
else:
assert register_addr == pybitcoin.BitcoinPrivateKey(
privatekey).public_key().address()
resp = blockstack_client.do_renewal(name,
privatekey,
privatekey,
name_cost_info['satoshis'],
test_proxy,
test_proxy,
config_path=test_proxy.config_path,
proxy=test_proxy,
safety_checks=safety_checks)
api_call_history.append(APICallRecord("renew", name, resp))
return resp
def namespace_preorder(namespace_id, privatekey, reveal_addr=None, proxy=None):
"""
namespace preorder
Generate a register change address private key, if not given
"""
if proxy is None:
proxy = get_default_proxy()
reveal_privkey_wif = None
if reveal_addr is None:
privkey = pybitcoin.BitcoinPrivateKey()
pubkey = privkey.public_key()
reveal_addr = pubkey.address()
reveal_privkey_wif = privkey.to_wif()
print reveal_privkey_wif
print reveal_addr
# make sure the reveal address is *not* the address of this private key
privkey = pybitcoin.BitcoinPrivateKey(privatekey)
if reveal_addr == privkey.public_key().address():
return {"error": "Reveal address derived from private key"}
result = proxy.namespace_preorder(namespace_id, reveal_addr, privatekey)
if 'error' in result:
return result
if reveal_privkey_wif is not None:
result['reveal_privatekey'] = reveal_privkey_wif
return result
def preorder(name, privatekey, register_addr=None, proxy=None, tx_only=False):
"""
preorder.
Generate a private key to derive a change address for the register,
if one is not given already.
"""
register_privkey_wif = None
if register_addr is None:
privkey = pybitcoin.BitcoinPrivateKey()
pubkey = privkey.public_key()
register_addr = pubkey.address()
register_privkey_wif = privkey.to_wif()
print register_privkey_wif
print register_addr
# make sure the reveal address is *not* the address of this private key
privkey = pybitcoin.BitcoinPrivateKey(privatekey)
if register_addr == privkey.public_key().address():
return {"error": "Register address derived from private key"}
resp = {}
if proxy is None:
proxy = get_default_proxy()
try:
if tx_only:
# get unsigned preorder
resp = proxy.preorder_tx(name, privatekey, register_addr)
else:
# send preorder
resp = proxy.preorder(name, privatekey, register_addr)
except Exception as e:
resp['error'] = str(e)
if 'error' in resp:
return resp
# give the client back the key to the addr we used
if register_privkey_wif is not None:
resp['register_privatekey'] = register_privkey_wif
return resp
def __init__(self, pk_wif, value_str):
pk = pybitcoin.BitcoinPrivateKey(pk_wif)
self._pk = pk
self.privkey = pk_wif
self.pubkey_hex = pk.public_key().to_hex()
self.addr = pk.public_key().address()
self.value = int(value_str)
def __init__(self, pk_wif, value_str):
pk = pybitcoin.BitcoinPrivateKey(pk_wif)
self._pk = pk
self.privkey = pk_wif
self.pubkey_hex = pk.public_key().to_hex(
) # coordinate (uncompressed) EC public key
self.ec_pubkey_hex = keylib.ECPrivateKey(pk_wif).public_key().to_hex(
) # parameterized (compressed) EC public key
self.addr = pk.public_key().address()
self.value = int(value_str)
def get_wallet(self, rpc_token=None):
""" Keeps payment privkey in memory (instead of disk)
for the time that server is alive
"""
data = {}
valid_rpc_token = get_rpc_token()
if str(valid_rpc_token) != str(rpc_token):
data['error'] = "Incorrect RPC token"
return json.dumps(data)
data['payment_address'] = self.payment_address
data['owner_address'] = self.owner_address
data['data_pubkey'] = pybitcoin.BitcoinPrivateKey( self.get_data_privkey() ).public_key().to_hex()
data['payment_privkey'] = self.get_payment_privkey()
data['owner_privkey'] = self.get_owner_privkey()
data['data_privkey'] = self.get_data_privkey()
return json.dumps(data)
"""
Unit tests.
"""
import pybitcoin
import json
# hack around absolute paths
current_dir = os.path.abspath(os.path.join(os.path.dirname(__file__),
".."))
sys.path.insert(0, current_dir)
from storage import serialize_mutable_data, parse_mutable_data
from user import make_mutable_data_info
pk = pybitcoin.BitcoinPrivateKey()
data_privkey = pk.to_hex()
data_pubkey = pk.public_key().to_hex()
test_data = [
["my_first_datum", "hello world", 1, "unused", None],
["/my/second/datum", "hello world 2", 2, "unused", None],
[
"user_profile", '{"name":{"formatted":"judecn"},"v":"2"}', 3,
"unused", None
],
["empty_string", "", 4, "unused", None],
]
def hash_data(d):
return pybitcoin.hash.hex_hash160(d)
def __init__(self,
tx_path=None,
tx_list=None,
tx_grouping=1,
start_block=0,
start_time=0x11111111,
difficulty=1.0,
initial_utxos={},
**kw):
"""
Create a mock bitcoind connection, either from a
list of serialized transactions on-file, or a given Python
list of serialized transactions.
Transactions will be bundled into blocks in groups of size tx_grouping.
"""
self.block_hashes = {} # map block ID to block hash
self.blocks = {
} # map block hash to block info (including transaction IDs)
self.txs = {} # map tx hash to a list of transactions
self.next_block_txs = [] # next block's transactions
self.difficulty = difficulty
self.time = start_time
self.start_block = start_block
self.end_block = start_block
self.block_hashes[start_block - 1] = '00' * 32
self.blocks['00' * 32] = {}
tx_recs = []
if tx_path is not None:
with open(tx_path, "r") as f:
tmp = f.readlines()
tx_recs = [l.strip() for l in tmp]
elif tx_list is not None:
tx_recs = tx_list
# prepend utxos
if len(initial_utxos) > 0:
initial_outputs = []
for (privkey, value) in initial_utxos.items():
addr = pybitcoin.BitcoinPrivateKey(
privkey).public_key().address()
out = {
'value': value,
'script_hex': pybitcoin.make_pay_to_address_script(addr)
}
initial_outputs.append(out)
tx = {
'inputs': [],
'outputs': initial_outputs,
'locktime': 0,
'version': 0xff
}
tx_hex = tx_serialize(tx['inputs'], tx['outputs'], tx['locktime'],
tx['version'])
tx_recs = [tx_hex] + tx_recs
i = 0
while True:
txs = []
count = 0
while i < len(tx_recs) and count < tx_grouping:
txs.append(tx_recs[i])
i += 1
if len(txs) > 0:
for tx in txs:
self.sendrawtransaction(tx)
self.flush_transactions()
if i >= len(tx_recs):
break
keyring = []
unfunded = []
keyring_path = "%s.keyring" % namespace_id
if os.path.exists(keyring_path):
print "import from '%s'" % keyring_path
try:
tmp = []
with open(keyring_path, "r") as f:
tmp = f.readlines()
keyring = []
tmp2 = [k.strip() for k in tmp]
for pk in tmp2:
addr = pybitcoin.BitcoinPrivateKey(pk).public_key().address()
balance = get_balance(chaincom_id, chaincom_secret, addr)
print "%s (%s) balance: %s" % (pk, addr, balance)
total_balance += balance
if balance > 54000:
keyring.append(pk)
else:
unfunded.append(addr)
except Exception, e:
log.exception(e)
pass
if len(keyring) == 0:
pk = pybitcoin.BitcoinPrivateKey(privkey_str)
chaincom_client = pybitcoin.ChainComClient(chaincom_id, chaincom_secret)
# get our namespace's names
try:
with open(sys.argv[1], "r") as f:
names_json = f.read()
except Exception, e:
traceback.print_exc()
print >> sys.stderr, "Failed to read '%s'" % sys.argv[1]
sys.exit(1)
privkey_str = sys.argv[3]
namespace_id = sys.argv[2]
privkey = pybitcoin.BitcoinPrivateKey(privkey_str)
importer_address = privkey.public_key().address()
try:
names = json.loads(names_json)
except Exception, e:
traceback.print_exc()
print >> sys.stderr, "Invalid JSON file '%s'" % sys.argv[1]
sys.exit(1)
# record name status
logfile_path = namespace_id + ".sent"
failed_path = namespace_id + ".failed"
confirmed_path = namespace_id + ".confirmed"
sent_names_json = []
def __init__(self, save_file=None, tx_path=None, tx_list=None, tx_grouping=1, \
start_block=0, start_time=0x11111111, difficulty=1.0, initial_utxos={}, \
spv_headers_path=None, **kw ):
"""
Create a mock bitcoind connection, either from a
list of serialized transactions on-file, or a given Python
list of serialized transactions.
If possible, restore from a saved file. This trumps all other options.
Transactions will be bundled into blocks in groups of size tx_grouping.
"""
assert save_file is not None
self.block_hashes = {} # map block ID to block hash
self.blocks = {} # map block hash to block info (including transaction IDs)
self.txs = {} # map tx hash to a list of transactions
self.txid_to_blockhash = {} # map tx hash to block hash
self.next_block_txs_path = None # next block's transactions
self.difficulty = difficulty
self.time = start_time
self.start_block = start_block
self.end_block = start_block
self.spv_headers_path = spv_headers_path
# for compatibility with blockstack_client (should refer to nothing)
self.opts = {
'bitcoind_server': "localhost",
'bitcoind_port': 31113
}
self.block_hashes[ start_block - 1 ] = '00' * 32
self.blocks[ '00' * 32 ] = {}
self.save_file = save_file
if save_file is not None:
self.next_block_txs_path = save_file + ".next"
if save_file is not None and os.path.exists( save_file ):
self.restore( save_file )
else:
# the initial utxos might be a serialized CSV (i.e. loaded directly from the config file).
# if so, then parse it
if type(initial_utxos) in [str, unicode]:
tmp = {}
parts = initial_utxos.split(",")
for utxo in parts:
privkey, value = utxo.split(':')
tmp[ privkey ] = int(value)
initial_utxos = tmp
tx_recs = []
if tx_path is not None:
with open( tx_path, "r" ) as f:
tmp = f.readlines()
tx_recs = [l.strip() for l in tmp]
elif tx_list is not None:
tx_recs = tx_list
# prepend utxos
if len(initial_utxos) > 0:
initial_outputs = []
for (privkey, value) in initial_utxos.items():
addr = pybitcoin.BitcoinPrivateKey( privkey ).public_key().address()
out = {
'value': value,
'script_hex': pybitcoin.make_pay_to_address_script( addr )
}
initial_outputs.append( out )
tx = {
'inputs': [],
'outputs': initial_outputs,
'locktime': 0,
'version': 0xff
}
tx_hex = tx_serialize( tx['inputs'], tx['outputs'], tx['locktime'], tx['version'] )
tx_recs = [tx_hex] + tx_recs
# feed all txs
i = 0
while True:
txs = []
count = 0
while i < len(tx_recs) and count < tx_grouping:
txs.append( tx_recs[i] )
i += 1
if len(txs) > 0:
for tx in txs:
self.sendrawtransaction( tx )
self.flush_transactions()
if i >= len(tx_recs):
break
def address(sk):
return pybitcoin.BitcoinPrivateKey(sk).public_key().address()
