def send_multi_payment(payment_privkey, list_of_addresses,
payment_per_address):
payment_address = get_address_from_privkey(payment_privkey)
if dontuseAddress(payment_address):
log.debug("Payment address %s not ready" % payment_address)
return None
inputs = [{'address': payment_address}]
payment_in_satoshis = btc_to_satoshis(float(payment_per_address))
outputs = []
for address in list_of_addresses:
outputs.append({'address': address, 'value': int(payment_in_satoshis)})
unsigned_tx = create_unsigned_tx(inputs=inputs,
outputs=outputs,
api_key=BLOCKCYPHER_TOKEN)
# iterate through unsigned_tx['tx']['inputs'] to find each address in order
# need to include duplicates as many times as they may appear
privkey_list = []
pubkey_list = []
for input in unsigned_tx['tx']['inputs']:
privkey_list.append(payment_privkey)
pubkey_list.append(get_pubkey_from_privkey(payment_privkey))
tx_signatures = make_tx_signatures(txs_to_sign=unsigned_tx['tosign'],
privkey_list=privkey_list,
pubkey_list=pubkey_list)
resp = broadcast_signed_transaction(unsigned_tx=unsigned_tx,
signatures=tx_signatures,
pubkeys=pubkey_list)
if 'tx' in resp:
return resp['tx']['hash']
else:
return None
def send_multi_payment(payment_privkey, list_of_addresses, payment_per_address):
payment_address = get_address_from_privkey(payment_privkey)
if dontuseAddress(payment_address):
log.debug("Payment address %s not ready" % payment_address)
return None
inputs = [{'address': payment_address}]
payment_in_satoshis = btc_to_satoshis(float(payment_per_address))
outputs = []
for address in list_of_addresses:
outputs.append({'address': address, 'value': int(payment_in_satoshis)})
unsigned_tx = create_unsigned_tx(inputs=inputs, outputs=outputs,
api_key=BLOCKCYPHER_TOKEN)
# iterate through unsigned_tx['tx']['inputs'] to find each address in order
# need to include duplicates as many times as they may appear
privkey_list = []
pubkey_list = []
for input in unsigned_tx['tx']['inputs']:
privkey_list.append(payment_privkey)
pubkey_list.append(get_pubkey_from_privkey(payment_privkey))
tx_signatures = make_tx_signatures(txs_to_sign=unsigned_tx['tosign'],
privkey_list=privkey_list,
pubkey_list=pubkey_list)
resp = broadcast_signed_transaction(unsigned_tx=unsigned_tx,
signatures=tx_signatures,
pubkeys=pubkey_list,
api_key=BLOCKCYPHER_TOKEN)
if 'tx' in resp:
return resp['tx']['hash']
else:
return None
def subsidized_update(fqu, profile, owner_privkey, payment_address,
payment_privkey=None):
"""
Update a previously registered fqu, using a different payment address
@fqu: fully qualified name e.g., muneeb.id
@profile: new profile json, hash(profile) goes to blockchain
@owner_privkey: privkey of owner address, to sign update
@payment_address: the address which is paying for the cost
Returns True/False and stores tx_hash in queue
"""
if alreadyinQueue(update_queue, fqu):
log.debug("Already in update queue: %s" % fqu)
return False
if not nameRegistered(fqu):
log.debug("Not yet registered %s" % fqu)
return False
profile_hash = get_hash(profile)
blockchain_record = get_blockchain_record(fqu)
owner_address = blockchain_record['address']
check_address = get_address_from_privkey(owner_privkey)
if check_address != owner_address:
log.debug("Given privkey/address doesn't own this name.")
return False
if dontuseAddress(payment_address):
log.debug("Payment address not ready: %s" % payment_address)
return False
elif underfundedAddress(payment_address):
log.debug("Payment address under funded: %s" % payment_address)
return False
owner_public_key = get_pubkey_from_privkey(owner_privkey)
if payment_privkey is None:
payment_privkey = wallet.get_privkey_from_address(payment_address)
log.debug("Updating (%s, %s)" % (fqu, profile_hash))
log.debug("<owner, payment> (%s, %s)" % (owner_address, payment_address))
resp = {}
try:
# do_update( fqu, zonefile_hash, owner_privkey, payment_privkey, utxo_client, tx_broadcaster
resp = do_update(fqu, profile_hash,
owner_privkey, payment_privkey,
utxo_client, tx_broadcaster)
except Exception as e:
log.debug(e)
if 'transaction_hash' in resp:
add_to_queue(update_queue, fqu, profile=profile,
profile_hash=profile_hash, owner_address=owner_address,
tx_hash=resp['transaction_hash'])
else:
log.debug("Error updating: %s" % fqu)
log.debug(resp)
return False
return True
def subsidized_transfer(fqu, transfer_address, owner_privkey, payment_address,
payment_privkey=None):
"""
Transfer a previously registered fqu, using a different payment address
@fqu: fully qualified name e.g., muneeb.id
@transfer_address: new owner address
@owner_privkey: privkey of current owner address, to sign tx
@payment_address: the address which is paying for the cost
Returns True/False and stores tx_hash in queue
"""
if alreadyinQueue(transfer_queue, fqu):
log.debug("Already in transfer queue: %s" % fqu)
return False
if not nameRegistered(fqu):
log.debug("Not yet registered %s" % fqu)
return False
if ownerName(fqu, transfer_address):
log.debug("Already transferred %s" % fqu)
return True
if recipientNotReady(transfer_address):
log.debug("Address %s owns too many names already." % transfer_address)
return False
blockchain_record = get_blockchain_record(fqu)
owner_address = blockchain_record['address']
check_address = get_address_from_privkey(owner_privkey)
if check_address != owner_address:
log.debug("Given privkey/address doesn't own this name.")
return False
if dontuseAddress(payment_address):
log.debug("Payment address not ready: %s" % payment_address)
return False
elif underfundedAddress(payment_address):
log.debug("Payment address under funded: %s" % payment_address)
return False
owner_public_key = get_pubkey_from_privkey(owner_privkey)
if payment_privkey is None:
payment_privkey = wallet.get_privkey_from_address(payment_address)
log.debug("Transferring (%s, %s)" % (fqu, transfer_address))
log.debug("<owner, payment> (%s, %s)" % (owner_address, payment_address))
resp = {}
try:
# do_transfer( fqu, transfer_address, keep_data, owner_privkey, payment_privkey, utxo_client, tx_broadcaster
resp = do_transfer(fqu, transfer_address, True,
owner_privkey, payment_privkey,
utxo_client, tx_broadcaster)
except Exception as e:
log.debug(e)
if 'transaction_hash' in resp:
add_to_queue(transfer_queue, fqu, owner_address=owner_address,
transfer_address=transfer_address,
tx_hash=resp['transaction_hash'])
else:
log.debug("Error transferring: %s" % fqu)
log.debug(resp)
return False
return True
def subsidized_update(fqu, profile, owner_privkey, payment_address,
payment_privkey=None):
"""
Update a previously registered fqu, using a different payment address
@fqu: fully qualified name e.g., muneeb.id
@profile: new profile json, hash(profile) goes to blockchain
@owner_privkey: privkey of owner address, to sign update
@payment_address: the address which is paying for the cost
Returns True/False and stores tx_hash in queue
"""
# hack to ensure local, until we update client
from blockstack_client import client as bs_client
# start session using blockstack_client
bs_client.session(server_host=BLOCKSTACKD_IP, server_port=BLOCKSTACKD_PORT,
set_global=True)
if alreadyinQueue(update_queue, fqu):
log.debug("Already in update queue: %s" % fqu)
return False
if not nameRegistered(fqu):
log.debug("Not yet registered %s" % fqu)
return False
profile_hash = get_hash(profile)
blockchain_record = get_blockchain_record(fqu)
owner_address = blockchain_record['address']
check_address = get_address_from_privkey(owner_privkey)
if check_address != owner_address:
log.debug("Given privkey/address doens't own this name.")
return False
if dontuseAddress(payment_address):
log.debug("Payment address not ready: %s" % payment_address)
return False
elif underfundedAddress(payment_address):
log.debug("Payment address under funded: %s" % payment_address)
return False
owner_public_key = get_pubkey_from_privkey(owner_privkey)
if payment_privkey is None:
payment_privkey = wallet.get_privkey_from_address(payment_address)
log.debug("Updating (%s, %s)" % (fqu, profile_hash))
log.debug("<owner, payment> (%s, %s)" % (owner_address, payment_address))
resp = {}
try:
resp = bs_client.update_subsidized(fqu, profile_hash,
public_key=owner_public_key,
subsidy_key=payment_privkey)
except Exception as e:
log.debug(e)
if 'subsidized_tx' in resp:
unsigned_tx = resp['subsidized_tx']
else:
log.debug("Error updating: %s" % fqu)
log.debug(resp)
return False
broadcast_resp = send_subsidized(owner_privkey, unsigned_tx)
if 'tx_hash' in broadcast_resp:
add_to_queue(update_queue, fqu, profile=profile,
profile_hash=profile_hash, owner_address=owner_address,
tx_hash=broadcast_resp['tx_hash'])
else:
log.debug("Error updating: %s" % fqu)
log.debug(broadcast_resp)
return False
return True
def subsidized_transfer(fqu, transfer_address, owner_privkey, payment_address,
payment_privkey=None):
"""
Transfer a previously registered fqu, using a different payment address
@fqu: fully qualified name e.g., muneeb.id
@transfer_address: new owner address
@owner_privkey: privkey of current owner address, to sign tx
@payment_address: the address which is paying for the cost
Returns True/False and stores tx_hash in queue
"""
# hack to ensure local, until we update client
from blockstack_client import client as bs_client
# start session using blockstack_client
bs_client.session(server_host=BLOCKSTACKD_IP, server_port=BLOCKSTACKD_PORT,
set_global=True)
if alreadyinQueue(transfer_queue, fqu):
log.debug("Already in transfer queue: %s" % fqu)
return False
if not nameRegistered(fqu):
log.debug("Not yet registered %s" % fqu)
return False
if ownerName(fqu, transfer_address):
log.debug("Already transferred %s" % fqu)
return True
if recipientNotReady(transfer_address):
log.debug("Address %s owns too many names already." % transfer_address)
return False
blockchain_record = get_blockchain_record(fqu)
owner_address = blockchain_record['address']
check_address = get_address_from_privkey(owner_privkey)
if check_address != owner_address:
log.debug("Given privkey/address doens't own this name.")
return False
if dontuseAddress(payment_address):
log.debug("Payment address not ready: %s" % payment_address)
return False
elif underfundedAddress(payment_address):
log.debug("Payment address under funded: %s" % payment_address)
return False
owner_public_key = get_pubkey_from_privkey(owner_privkey)
if payment_privkey is None:
payment_privkey = wallet.get_privkey_from_address(payment_address)
log.debug("Transferring (%s, %s)" % (fqu, transfer_address))
log.debug("<owner, payment> (%s, %s)" % (owner_address, payment_address))
resp = {}
try:
# format for transfer RPC call is:
# (name, address, keep_data, public_key, subsidy_key)
resp = bs_client.transfer_subsidized(fqu, transfer_address, True,
public_key=owner_public_key,
subsidy_key=payment_privkey)
except Exception as e:
log.debug(e)
if 'subsidized_tx' in resp:
unsigned_tx = resp['subsidized_tx']
else:
log.debug("Error transferring: %s" % fqu)
log.debug(pprint(resp))
return False
broadcast_resp = send_subsidized(owner_privkey, unsigned_tx)
if 'tx_hash' in broadcast_resp:
add_to_queue(transfer_queue, fqu, owner_address=owner_address,
transfer_address=transfer_address,
tx_hash=broadcast_resp['tx_hash'])
else:
log.debug("Error transferring: %s" % fqu)
log.debug(broadcast_resp)
return False
return True
