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)