def process_btc_maintenances():
open_maintenances = transactions.get_open_btc_maintenance()
for m in open_maintenances:
sender_public = m[0]
sender_private = m[1]
receiver_public = m[2]
fee = m[3]
amount = m[4] #IN SATOSHIS
last_sent = m[7]
randomid = m[6]
time_diff = time.time() - float(last_sent)
if time_diff > 1000:
current_balance = coinprism.check_btc_balance(receiver_public)
if amount > current_balance + 0.00001: #send funds
db.dbexecute(
"update btc_maintenance set last_sent=" +
str(int(time.time())) + " where randomid='" +
str(randomid) + "';", False)
print "MAINTAINING BTC BALANCE OF " + str(
amount) + " FOR " + str(receiver_public)
#clear pre-existing btc queued transactions for this receiving address to prevent double-sends
transactions.clear_btc_tx_on_address(receiver_public)
#queue a new tx
identifier = str(int(time.time(
))) + "queue btc transfer to maintain " + str(receiver_public)
transactions.queue_btc_tx(sender_public, sender_private,
receiver_public,
float(amount) / 100000000,
identifier)
def add_btc_maintenance(sender_public, sender_private, receiver_public, fee,
amount, randomid):
dbstring = "insert into btc_maintenance values ('" + str(
sender_public) + "', '" + str(sender_private) + "', '" + str(
receiver_public) + "', " + str(default_fee) + ", " + str(
amount) + ", True, '" + str(randomid) + "', 0);"
db.dbexecute(dbstring, False)
def send_plain_btc():
txs = db.unsent_btc_transfers()
for tx in txs:
sender_public = tx[0]
sender_private = tx[1]
receiver_public = tx[2]
fee = tx[3] #satoshi
amount = tx[4] #satoshi
randomid = tx[7]
btc_value = amount * 0.00000001
try:
txhash = transactions.send_btc(sender_public, sender_private,
receiver_public, btc_value)
print "TXHASH"
print txhash
except:
print "ERROR MAKING TX"
txhash = 'fail'
if len(txhash) > 10:
dbstring = "update btc_tx_queue set txhash='" + str(
txhash) + "', success=True where randomid='" + str(
randomid) + "';"
db.dbexecute(dbstring, False)
db.add_to_last_transactions(txhash)
def save_txs_in_block(height):
txs = download_block_local_node(height)['tx']
txdata = []
inputs = []
outputs = []
queued_input_checks = []
for tx in txs:
r = download_tx_local_node(tx)
txdata.append(r)
for inp in r['vin']:
g= get_input_address(inp)
if g[1]>-1:
input_address =g[0]
amt =g[1]
db.add_input_tx(input_address, r['txid'], amt, height)
queued_input_checks.append([inp['txid'], inp['vout'], r['txid']])
for outp in r['vout']:
if 'scriptPubKey' in outp:
if 'addresses' in outp['scriptPubKey']:
if len(outp['scriptPubKey']['addresses'])>0:
output_address = outp['scriptPubKey']['addresses'][0]
amt = outp['value']*100000000
db.add_output_tx(output_address, r['txid'], amt, height)
db.add_tx_output(r['txid'], outp['n'], False, '', height, -1, amt)
for a in queued_input_checks:
db.spent_tx_output(a[0], a[1], a[2], height)
dbstring="update meta set lastblockdone='"+str(height)+"';"
db.dbexecute(dbstring, False)
def transfer_colors():
txs = db.unsent_transfer_txs()
for tx in txs:
sender_public = tx[0]
sender_private = tx[1]
receiver_public = tx[2]
fee = tx[3]
asset_address = tx[4]
if len(str(asset_address)) < 10:
asset_address = coinprism.get_asset_id(sender_public)
color_amount = tx[5]
metadata = tx[8]
randomid = tx[9]
if len(str(asset_address)) > 10:
txhash = coinprism.transfer_asset(sender_public, receiver_public,
color_amount, metadata, fee,
sender_private, asset_address)
try:
if len(txhash) > 10:
dbstring = "update color_transfer_tx_queue set txhash='" + str(
txhash) + "', success=True where randomid='" + str(
randomid) + "';"
db.dbexecute(dbstring, False)
db.add_to_last_transactions(txhash)
except:
print "No tx"
else:
print "DONT HAVE ASSET ADDRESS FOR RANDOMID=" + str(randomid)
def queue_transfer_tx(sender_public, sender_private, recipient_public, amount,
metadata, asset_address, identifier):
dbstring = "insert into color_transfer_tx_queue values ('" + str(
sender_public) + "', '" + str(sender_private) + "', '" + str(
recipient_public) + "', " + str(default_fee) + ", '" + str(
asset_address) + "', " + str(amount) + ", False, '','" + str(
metadata) + "', '" + str(identifier) + "');"
db.dbexecute(dbstring, False)
def txs_pertaining_to_address(address):
inputted = db.dbexecute("select * from inputs where public_address='"+str(address)+"';", True)
outputted = db.dbexecute("select * from outputs where public_address='"+str(address)+"';", True)
txs = []
for tx in inputted:
txs.append(tx[1])
for tx in outputted:
txs.append(tx[1])
return txs
def connect_addresses(from_address, to_address, weight):
dbstring = "select * from address_address_correlation where from_address='"+str(from_address)+"' and to_address='"+str(to_address)+"';"
result = db.dbexecute(dbstring, True)
if len(result) > 0:
current_weight = result[0][2]
new_weight = float(current_weight) + weight
dbstring = "update address_address_correlation set weight = '"+str(new_weight)+"' where from_address='"+str(from_address)+"' and to_address='"+str(to_address)+"';"
else:
dbstring = "insert into address_address_correlation values ('"+str(from_address)+"', '"+str(to_address)+"', '"+str(weight)+"');"
db.dbexecute(dbstring, False)
def link_addresses(address_list, block_height):
known_ids = []
if len(address_list)>0:
for addr in address_list: #CHECK HOW MANY ARE KNOWN, if more than 1 do nothing
found_id = db.dbexecute("select person_id from addresses where public_address='"+str(addr)+"';",True)
print found_id
if len(found_id)>0:
known_ids.append(found_id[0][0])
else:
dbstring = "insert into addresses (public_address) values ('"+str(addr)+"');"
print dbstring
db.dbexecute(dbstring,False)
if len(known_ids)>1:
j=0 #do nothing
elif len(known_ids)==1:
#make all addresses in list under this person id
the_id = known_ids[0]
for x in address_list:
dbstring="update addresses set person_id = '"+str(the_id)+"' where public_address='"+str(x)+"';"
print dbstring
db.dbexecute(dbstring, False)
else:
#give them all a new person id
the_id = generate_new_id()
dbstring = "insert into people (person_id, firstblock) values ('"+str(the_id)+"', "+str(block_height)+");"
db.dbexecute(dbstring,False)
for x in address_list:
dbstring="update addresses set person_id = '"+str(the_id)+"' where public_address='"+str(x)+"';"
print dbstring
db.dbexecute(dbstring, False)
def queue_issuing_tx(source_address, recipient_address, source_private,
metadata, amount, name, identifier):
if metadata[0:2] == "u=":
metadata = "u=" + util.shorten_url(metadata[2:len(metadata)])
if metadata[0:9] == "u=http://":
metadata = metadata[0:6] + "s" + metadata[6:len(metadata)]
dbstring = "insert into color_issue_tx_queue values ('" + str(
source_address) + "', '" + str(source_private) + "', '" + str(
recipient_address) + "', " + str(default_fee) + ", '', " + str(
amount) + ", False, '', '" + str(metadata) + "', '" + str(
identifier) + "', '" + str(name) + "');"
db.dbexecute(dbstring, False)
def queue_btc_tx(sender_public, sender_private, recipient_public, amount,
identifier):
print sender_public
print sender_private
print recipient_public
print amount
amount = float(amount) * 100000000
dbstring = "insert into btc_tx_queue values ('" + str(
sender_public) + "', '" + str(sender_private) + "', '" + str(
recipient_public) + "', " + str(default_fee) + ", " + str(
amount) + ", False,'', '" + str(identifier) + "');"
db.dbexecute(dbstring, False)
def save(self):
exists = False
dbstring = "select * from addresses where public_address='"+str(self.public_address)+"';"
result = db.dbexecute(dbstring, True)
if len(result) > 0:
exists=True
if exists:
k=0 #update something
else:
dbstring = "insert into addresses values ('"+str(self.public_address)+"');"
db.dbexecute(dbstring, False)
def assign_new_id_to_mined(tx, height):
if not 'prev_out' in tx['inputs'][0]:
receiving_address = tx['out'][0]['addr']
#check if address already exists
dbstring = "select * from addresses where public_address='"+str(receiving_address)+"';"
found = db.dbexecute(dbstring,True)
if len(found)==0: #create new address in DB since this one hasnt been seen before
the_id = generate_new_id()
dbstring = "insert into people (person_id, firstblock) values ('"+str(the_id)+"', "+str(height)+");"
print dbstring
db.dbexecute(dbstring,False)
dbstring = "insert into addresses (public_address, person_id) values ('"+str(receiving_address)+"', '"+str(the_id)+"');"
print dbstring
db.dbexecute(dbstring,False)
def block_opreturns_to_db(blockn):
data=bitsource.opreturns_in_block_blockchain(blockn)
for x in data:
txhash=str(x[0])
message=parse(str(x[1]))
#message=str(x[1])
if len(message)>40:
message=message[0:40]
print message
k=add_message_to_db(message, str(blockn), txhash)
print k
db.dbexecute("UPDATE META SET lastblockdone='" + str(blockn)+"';",False)
def init():
dbstring = "create table assets (name varchar(300), source_address varchar(400), asset_address varchar(400), metadata varchar(30));"
db.dbexecute(dbstring, False)
dbstring = "create table color_transfer_tx_queue (sender_public varchar(300), sender_private varchar(300), receiver_public varchar(300), fee bigint, asset_address varchar(300), color_amount bigint, success bool, txhash varchar(300), metadata varchar(30), randomid varchar(300));"
db.dbexecute(dbstring, False)
dbstring = "create table color_issue_tx_queue (sender_public varchar(300), sender_private varchar(300), receiver_public varchar(300), fee bigint, asset_address varchar(300), color_amount bigint, success bool, txhash varchar(300), metadata varchar(100), randomid varchar(300), name varchar(300));"
db.dbexecute(dbstring, False)
dbstring = "create table btc_tx_queue (sender_public varchar(300), sender_private varchar(300), receiver_public varchar(300), fee bigint, amount bigint, success bool, txhash varchar(300), randomid varchar(300));"
db.dbexecute(dbstring, False)
dbstring = "create table btc_maintenance (sender_public varchar(300), sender_private varchar(300), receiver_public varchar(300), fee bigint, amount bigint, continue bool, randomid varchar(300), last_sent bigint);"
db.dbexecute(dbstring, False)
def tx_query(tx=None): dbstring="SELECT * FROM messages WHERE txhash='"+tx+"';" results=db.dbexecute(dbstring,True) results=json.dumps(results) response=make_response(str(results), 200) response.headers['Access-Control-Allow-Origin']= '*' return response
def block_query(block=None): dbstring="SELECT * FROM messages where block='"+block+"';" results=db.dbexecute(dbstring,True) results=json.dumps(results) response=make_response(str(results), 200) response.headers['Access-Control-Allow-Origin']= '*' return response
def save_next_blocks(nblocks):
last_block = 340000#get_last_block()#connect("getblockcount", [])
last_block_in_db = db.dbexecute("select * from meta;", True)[0][0]
if last_block - last_block_in_db < nblocks:
nblocks = last_block - last_block_in_db
next = last_block_in_db + nblocks
for i in range(last_block_in_db+1, next+1):
save_txs_in_block(i)
def process_children(parent_txhash, parent_index, parent_amount):
results = db.dbexecute("select * from tx_outputs where txhash='"+str(parent_txhash)+"' and index='"+str(parent_index)+"';", True)
children = []
for x in results:
child = {}
child['parent_txhash'] = parent_txhash
child['parent_index'] = parent_index
children.append([x[3], x[1], x[6]])
def last_block_updated():
lastblock = db.dbexecute("select * from meta;",True)
d = {}
d['last_block'] = str(lastblock[0][0])
response=make_response(str(lastblock[0][0]), 200)
response.headers['Content-Type'] = 'application/json'
response.headers['Access-Control-Allow-Origin']= '*'
return response
def messages_query(lastn=None): dbstring="SELECT * FROM messages ORDER BY block DESC;" results=db.dbexecute(dbstring,True) lastn=int(lastn) results=results[0:lastn] results=json.dumps(results) response=make_response(str(results), 200) response.headers['Access-Control-Allow-Origin']= '*' return response
def downstream_txs_on_address(public_address):
dbstring = "select * from inputs where public_address='"+str(public_address)+"';"
results = db.dbexecute(dbstring, True)
txs = []
if len(results)>0:
for x in results:
txs.append(x[1])
#txs = list(set(txs)) #removes duplicates from db saving errors
return txs
def addresses_backwards_local(public_address):
txs = upstream_txs_on_address(public_address)
addresses = []
for tx in txs:
dbstring = "select * from inputs where txhash='"+str(tx)+"';"
r = db.dbexecute(dbstring, True)
if len(r)>0:
for x in r:
addresses.append(x[0])
return addresses
def transfer_txs_without_asset_address():
dbstring = "select * from color_transfer_tx_queue where success=false and asset_address='' or asset_address='-1';"
a = db.dbexecute(dbstring, True)
for tx in a:
sender = tx[0]
print tx
asset_address = tx[4]
randomid = tx[9]
if len(asset_address) < 10:
new_asset_address = coinprism.get_asset_id(sender)
if new_asset_address == -1:
k = 0
elif len(new_asset_address) < 10:
k = 0
else:
dbstring = "update color_transfer_tx_queue set asset_address='" + str(
new_asset_address) + "' where randomid='" + str(
randomid) + "'';"
db.dbexecute(dbstring, False)
def moreblocks(number):
lastblock=db.dbexecute("SELECT * FROM META;",True)
lastblock=lastblock[0][0]
currentblock=int(requests.get("https://blockchain.info/q/getblockcount").content)
endtarget=lastblock+number
if endtarget>currentblock:
endtarget=currentblock
for i in range(lastblock+1, endtarget+1):
block_opreturns_to_db(i)
print "processed block "+str(i)+" for opreturns"
def message_queue():
text=str(request.form['text'])
r=addresses.generate_secure_pair()
public=r['public_address']
private=r['private_key']
#CALCULATE COST NOW
cost=0.002*(int(len(text)/37)+1)
#DO SOMETHING WITH TEXT IN DB
dbstring="insert into text_queue (text, public_address, private_key, amount_expected, success) values ('"+str(text)+"','"+public+"','"+private+"','"+str(int(cost*100000000))+"', 'False');"
db.dbexecute(dbstring,False)
results={}
results['public_address']=public
results['cost']=cost
results=json.dumps(results)
response=make_response(str(results), 200)
response.headers['Access-Control-Allow-Origin']= '*'
#response.headers['Access-Control-Allow-Origin']= 'http://www.chainscribe.com'
return response
def status():
jsonresponse={}
try:
jsonresponse['bitcoind_last_block']=bitcoind.connect("getblockcount", [])
except:
jsonresponse['bitcoind_last_block'] = "BITCOIND DOWN"
jsonresponse['lastblock_processed'] = str(db.dbexecute("select * from meta;", True)[0][0])
jsonresponse['last_header_height'] = str(db.last_header())
jsonresponse=json.dumps(jsonresponse)
response=make_response(str(jsonresponse), 200)
response.headers['Content-Type'] = 'application/json'
response.headers['Access-Control-Allow-Origin']= '*'
return response
def get_address_vector(public_address):
dbstring = "select * from address_address_correlation where from_address='"+str(public_address)+"' order by weight desc;"
result = db.dbexecute(dbstring, True)
vector = []
m=0
if len(result)>0:
for x in result:
vector.append([x[1], x[2]])
m=m+math.pow(x[2],2)
# m=math.pow(m, 0.5)
# if m>0:
# for i in range(len(vector)):
# vector[i][1] = vector[i][1] / m
return vector
def issue_colors():
txs = db.unsent_issue_txs()
for tx in txs:
sender_public = tx[0]
sender_private = tx[1]
receiver_public = tx[2]
fees = tx[3]
asset_address = tx[4]
color_amount = tx[5]
metadata = tx[8]
randomid = tx[9]
name = tx[10]
r = coinprism.issue_asset(sender_public, receiver_public, color_amount,
metadata, fees, sender_private)
if len(r) > 10:
txhash = r
dbstring = "update color_issue_tx_queue set txhash='" + str(
r) + "', success=True where randomid = '" + str(
randomid) + "';"
db.dbexecute(dbstring, False)
db.add_to_last_transactions(txhash)
db.add_asset(name, sender_public, '', metadata)
def get_open_btc_maintenance():
dbstring = "select * from btc_maintenance where continue=True;"
return db.dbexecute(dbstring, True)
def address_blacklisted(public_address):
r = db.dbexecute("select count(*) from blacklisted_addresses where public_address='""+str(public_address)+';",True)
if r[0][0] > 0:
return True
else:
return False
import bitcoind
import db
while True:
last_block_meta = db.dbexecute("select * from meta;", True)
last_block_meta = last_block_meta[0][0]
last_block_node = bitcoind.connect("getblockcount", [])
if last_block_meta < last_block_node-100:
bitcoind.save_next_blocks(100)
process.write_headers(1000)
def load(self):
dbstring = "select * from addresses where public_address='"+str(self.public_address)+"';"
result = db.dbexecute(dbstring, True)
if len(result) > 0:
self.public_address=result[0][0]
def init():
dbstring = "create table users (username varchar(100), activity varchar(1000), last_heard_at bigint);"
db.dbexecute(dbstring, False)
dbstring = "create table transactions (sender varchar(100), receiver varchar(100), amount float, timestamp bigint, message varchar(1000));"
db.dbexecute(dbstring, False)
def sum_inputs_txhash(txhash):
results = db.dbexecute("select sum(amount) from tx_outputs where spent_at_txhash='"+str(txhash)+"';", True)
return results[0][0]
def get_address_info_local(public_address):
dbstring = "select txhash from outputs where public_address='"+str(public_address)+"';"
result = db.dbexecute(dbstring, True)
def kill_btc_maintenance(receiver_public, sender_public, sender_private):
dbstring = "update btc_maintenance set continue=False where receiver_public='" + str(
receiver_public) + "' and sender_public='" + str(
sender_public) + "' and sender_private ='" + str(
sender_private) + "';"
db.dbexecute(dbstring, False)
def clear_btc_tx_on_address(recipient_public):
dbstring = "update btc_tx_queue set success=True where receiver_public='" + str(
recipient_public) + "' and success=False;"
db.dbexecute(dbstring, False)
def reset():
dbstring = "drop table assets;drop table color_transfer_tx_queue;drop table color_issue_tx_queue;drop table btc_tx_queue;drop table btc_maintenance"
db.dbexecute(dbstring, False)
init()
def add_message_to_db(message, block, txhash):
dbstring = "INSERT INTO MESSAGES (message, block, txhash) VALUES ('"+str(message)+"','"+str(block)+"','"+str(txhash)+"');"
print dbstring
response=db.dbexecute(dbstring, False)
return response
def delete_address_correlations_on_address(public_address):
db.dbexecute("delete from address_address_correlation * where from_address='"+str(public_address)+"';",False)
