def checkaddresses():
dbstring="SELECT * FROM ADDRESSES WHERE amount_withdrawn=0;"
addresslist=databases.dbexecute(dbstring,True)
print addresslist
for address in addresslist:
unspents=addresses.unspent(address[0])
value=0
for x in unspents:
value=value+x['value']
print "currently available in "+str(address[0])+" : "+str(value/100000000)
if value>=address[2] and address[3]<address[2]:
#makenewcoins
fromaddr=address[0]
colornumber=address[6]
colorname=address[5]
destination=address[7]
fee_each=0.00004
private_key=address[1]
ticker=address[9]
description=address[8]
txdata=transactions.make_new_coin(fromaddr, colornumber, colorname, destination, fee_each, private_key, description)
txhash=txdata[0]
txhash=txhash+":0" #issuance always first output
#mark as completed
databases.edit_address(fromaddr, value, value, colornumber)
#add entry to colors db
# #referencehex=bitsource.tx_lookup(specific_inputs)
# color_address=bitsource.script_to_coloraddress()
#databases.add_color(color_address, fromaddr, colornumber, colorname)
databases.dbexecute("insert into colors (source_address, color_name) values ('"+fromaddr+"','"+colorname+"');",False)
def schedule_transfer():
jsoninput=json.loads(request.data)
fromaddr=str(jsoninput['from_public_address'])
dest=str(jsoninput['to_public_address'])
fee_each=float(jsoninput['fee_each'])
fee_each=str(int(fee_each*100000000))
privatekey=str(jsoninput['from_private_key'])
sourceaddress=str(jsoninput['issuing_address'])
coloramt=str(jsoninput['transfer_amount'])
r=str(random.random())
random_id=str(hashlib.sha256(r).hexdigest())
callback_url=None
if 'callback_url' in jsoninput:
callback_url=jsoninput['callback_url']
dbstring="insert into tx_queue (first_tried_at_block, success, from_public, from_private, destination, fee_each, source_address, transfer_amount, callback_url, randomid) values ('-1','False"+"','"+fromaddr+"','"+privatekey+"','"+dest+"','"+fee_each+"','"+sourceaddress+"','"+coloramt+"','"+callback_url+"','"+str(random_id)+"');"
else:
dbstring="insert into tx_queue (first_tried_at_block, success, from_public, from_private, destination, fee_each, source_address, transfer_amount, randomid) values ('-1','False"+"','"+fromaddr+"','"+privatekey+"','"+dest+"','"+fee_each+"','"+sourceaddress+"','"+coloramt+"','"+str(random_id)+"');"
databases.dbexecute(dbstring,False)
jsonresponse={}
jsonresponse['result']="Queued"
jsonresponse['id']=random_id
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 checkaddresses():
dbstring="SELECT * FROM ADDRESSES WHERE amount_withdrawn=0;"
addresslist=databases.dbexecute(dbstring,True)
print addresslist
for address in addresslist:
unspents=addresses.unspent(address[0])
value=0
for x in unspents:
value=value+x['value']
print "currently available in "+str(address[0])+" : "+str(value/100000000)
if value>=address[2] and address[3]<address[2]:
#makenewcoins
fromaddr=address[0]
colornumber=address[6]
colorname=address[5]
destination=address[7]
fee_each=0.00005
private_key=address[1]
ticker=address[9]
description=address[8]
txdata=transactions.make_new_coin(fromaddr, colornumber, colorname, destination, fee_each, private_key, description)
txhash=txdata[0]
txhash=txhash+":0" #issuance always first output
#mark as completed
if len(txhash)>10:
databases.edit_address(fromaddr, value, value, colornumber)
their_email=address[9]
email_commands.email_creation(str(their_email), str(colorname), str(colornumber), str(description), str(txhash))
databases.dbexecute("insert into colors (source_address, color_name) values ('"+fromaddr+"','"+colorname+"');",False)
def check_for_misspents(
block_height_start, block_height_end
): # BLOCKHEIGHT INPUT MEANS CHECK FOR OUTPUTS SINCE THIS BLOCK HEIGHT
txs = databases.dbexecute(
"select * from outputs where blockmade>="
+ str(block_height_start)
+ " and blockmade<="
+ str(block_height_end)
+ ";",
True,
)
for tx in txs:
txhash_index = tx[7]
txhash_index = txhash_index.split(":")
txhash = txhash_index[0]
index = int(txhash_index[1])
spent = bitsource.check_if_output_misspent(txhash, index)
if spent:
print "output is spent: " + str(txhash_index)
index = str(index)
# MARK AS SPENT IN OUTPUTS DB, MARK spent_at_transactionhash = "DESTROYED"
dbstring = (
"UPDATE outputs SET spent=true, spent_at_txhash='destroyed' where txhash_index='"
+ str(txhash)
+ ":"
+ str(index)
+ "';"
)
databases.dbexecute(dbstring, False)
print "MISSPENT TX DISCOVERED: " + str(txhash) + ":" + str(index)
def find_transfer_inputs(fromaddr, coloraddress, coloramt, btc):
if coloraddress is None:
coloraddress = "none"
available_inputs = databases.dbexecute(
"SELECT * FROM OUTPUTS WHERE spent='False' and destination_address='" +
fromaddr + "' and color_address='" + coloraddress + "';", True)
forbidden_inputs = databases.dbexecute(
"SELECT * FROM OUTPUTS WHERE spent='False' and destination_address='" +
fromaddr + "' and not color_address='" + str(coloraddress) +
"' and not color_address='';", True)
other_inputs = addresses.get_unspent(fromaddr)
totalfound = 0
btc = int(btc * 100000000)
totalavailable = 0
btcfound = 0
btcavailable = 0
answer = []
totalinputamt = 0
for x in available_inputs:
totalavailable = totalavailable + x[1]
for x in other_inputs:
btcavailable = btcavailable + x['value']
if totalavailable >= coloramt and btcavailable >= btc:
n = 0
while totalfound < coloramt and n < len(available_inputs):
r = {}
r['output'] = available_inputs[n][7]
r['value'] = available_inputs[n][0]
btcfound = btcfound + r['value']
totalinputamt = totalinputamt + r['value']
totalfound = totalfound + available_inputs[n][1]
answer.append(r)
n = n + 1
n = 0
while btcfound < btc and n < len(other_inputs):
r = {}
if n < len(other_inputs):
r = other_inputs[n]
found = False
for x in answer:
if x['output'] == r['output']:
found = True
if other_inputs[n]['value'] > dust and not found:
btcfound = btcfound + other_inputs[n]['value']
answer.append(r)
n = n + 1
for x in forbidden_inputs:
outp = x[7]
for y in answer:
if y['output'] == outp:
answer.remove(y)
totalfound = totalfound - y['value']
return answer, totalfound
def blocks_outputs(blockend):
lastblockprocessed=databases.dbexecute("SELECT * FROM META;",True)
currentblock=bitsource.get_current_block()
if blockend>currentblock:
blockend=currentblock
for i in range(lastblockprocessed[0][0]+1,blockend+1):
add_output_db(i)
print "processed block "+str(i)
databases.dbexecute("UPDATE META SET lastblockdone='"+str(i)+"';",False)
def blocks_outputs(blockend):
lastblockprocessed=databases.dbexecute("SELECT * FROM META;",True)
currentblock=node.connect('getblockcount',[])
if blockend>currentblock:
blockend=currentblock
for i in range(lastblockprocessed[0][0]+1,blockend+1):
add_output_db(i)
print "processed block "+str(i)
databases.dbexecute("UPDATE META SET lastblockdone='"+str(i)+"';",False)
def test_prepare():
url="https://coins.assembly.com/v1/colors/prepare"
payload='{"issued_amount": 100, "description": "another test", "coin_name": "baltimore", "email": "afasd"}'
headers = {'content-type': 'application/json'}
response=requests.post(url, data=payload, headers=headers)
print response.content
should_be='{"name": "baltimore", "issuing_private_key": "5JsA268SaN3VrjnPM3m46JxE7mqibfYTD6Gacbhci17FYSuTUUc", "issuing_public_address": "1HRUD9KXmu7etUQPfYW7rnRrFfAzPq2sUj", "minting_fee": "0.00043606"}'
jsonresponse=json.loads(response.content)
db.dbexecute("delete from addresses * where coin_name='baltimore';", False)
assert jsonresponse['name']=="baltimore" and float(jsonresponse['minting_fee'])>0
def test_prepare():
url = "https://coins.assembly.com/v1/colors/prepare"
payload = '{"issued_amount": 100, "description": "another test", "coin_name": "baltimore", "email": "afasd"}'
headers = {'content-type': 'application/json'}
response = requests.post(url, data=payload, headers=headers)
print response.content
should_be = '{"name": "baltimore", "issuing_private_key": "5JsA268SaN3VrjnPM3m46JxE7mqibfYTD6Gacbhci17FYSuTUUc", "issuing_public_address": "1HRUD9KXmu7etUQPfYW7rnRrFfAzPq2sUj", "minting_fee": "0.00043606"}'
jsonresponse = json.loads(response.content)
db.dbexecute("delete from addresses * where coin_name='baltimore';", False)
assert jsonresponse['name'] == "baltimore" and float(
jsonresponse['minting_fee']) > 0
def checkaddresses():
dbstring = "SELECT * FROM ADDRESSES WHERE amount_withdrawn=0;"
addresslist = databases.dbexecute(dbstring, True)
print addresslist
for address in addresslist:
unspents = addresses.get_unspent(address[0])
value = 0
for x in unspents:
value = value + x["value"]
print "currently available in " + str(address[0]) + " : " + str(value / 100000000)
if value >= address[2] and address[3] < address[2]:
# makenewcoins
fromaddr = address[0]
colornumber = address[6]
colorname = address[5]
destination = address[7]
fee_each = 0.00005
private_key = address[1]
ticker = address[9]
description = address[8]
try:
txdata = transactions.make_new_coin(
fromaddr, colornumber, colorname, destination, fee_each, private_key, description
)
except:
print "ERROR CREATING NEW COIN"
print str(fromaddr) + " / " + str(colornumber) + " / " + str(colorname) + " / " + str(
destination
) + " / " + str(fee_each) + " / " + str(private_key) + " / " + str(description)
try:
txhash = txdata["transaction_hash"]
except:
txhash = "Error"
print "ERROR reading txdata"
print txdata
txhash = txhash + ":0" # issuance always first output
# mark as completed
if txhash == "None:0":
k = 1 # do nothing
else:
databases.edit_address(fromaddr, value, value, colornumber)
their_email = address[9]
email_commands.email_creation(
str(their_email), str(colorname), str(colornumber), str(description), str(txhash)
)
databases.dbexecute(
"insert into colors (source_address, color_name) values ('" + fromaddr + "','" + colorname + "');",
False,
)
def find_transfer_inputs(fromaddr, coloraddress, coloramt, btc):
if coloraddress is None:
coloraddress="none"
available_inputs=databases.dbexecute("SELECT * FROM OUTPUTS WHERE spent='False' and destination_address='"+fromaddr+"' and color_address='"+coloraddress+"';",True)
forbidden_inputs = databases.dbexecute("SELECT * FROM OUTPUTS WHERE spent='False' and destination_address='"+fromaddr+"' and not color_address='"+str(coloraddress)+"';",True)
other_inputs=addresses.get_unspent(fromaddr)
totalfound=0
btc=int(btc*100000000)
totalavailable=0
btcfound=0
btcavailable=0
answer=[]
totalinputamt=0
for x in available_inputs:
totalavailable=totalavailable+x[1]
for x in other_inputs:
btcavailable=btcavailable+x['value']
if totalavailable>=coloramt and btcavailable>=btc:
n=0
while totalfound<coloramt and n<len(available_inputs):
r={}
r['output']=available_inputs[n][7]
r['value']=available_inputs[n][0]
btcfound=btcfound+r['value']
totalinputamt=totalinputamt+r['value']
totalfound=totalfound+available_inputs[n][1]
answer.append(r)
n=n+1
n=0
while btcfound<btc and n<len(other_inputs):
r={}
if n<len(other_inputs):
r=other_inputs[n]
found=False
for x in answer:
if x['output']==r['output']:
found=True
if other_inputs[n]['value']>dust and not found:
btcfound=btcfound+other_inputs[n]['value']
answer.append(r)
n=n+1
for x in forbidden_inputs:
outp = x[7]
for y in answer:
if y['output'] == outp:
answer.remove(y)
totalfound=totalfound - y['value']
return answer, totalfound
def tx_queue_batches():
current_block=bitsource.get_current_block()
distinct_senders=databases.dbexecute("select distinct from_public from tx_queue where success='False';",True)
for sender in distinct_senders:
sender=sender[0]
colors=databases.dbexecute("select distinct source_address from tx_queue where from_public='"+sender+"';", True)
for color in colors:
color_needed=0
txs=databases.dbexecute("select * from tx_queue where from_public='"+sender+"' and success='False' and source_address='"+color[0]+"';",True)
coloramt_array=[]
dest_array=[]
fromaddr=sender
btc_needed=0
rowlist=[]
for tx in txs:
color_needed=color_needed+tx[5]
btc_needed=btc_needed+(int(tx[3])+int(transactions.dust*100000000)) #INTEGER, IN SATOSHIs
dest_array.append(tx[2])
coloramt_array.append(tx[5])
fee_each=float(tx[3])*0.00000001
privatekey=tx[1]
othermeta="multitransfer"
rowlist.append(tx[10])
sourceaddress=color[0]
coloraddress=databases.first_coloraddress_from_sourceaddress(sourceaddress)
btc_needed=float(btc_needed)/100000000
inputs=transactions.find_transfer_inputs(fromaddr, coloraddress, color_needed, btc_needed)
inputcolortamt=inputs[1]
inputs=inputs[0]
try:
result=transactions.transfer_tx_multiple(fromaddr, dest_array, fee_each, privatekey, sourceaddress, coloramt_array, othermeta)
result=result[0]
except:
print "ERROR processing queued TX from "+str(fromaddr)
result=None
if result is None:
print "No response heard from Bitcoin Network"
else:
print "HEARD TX RESULT: "+str(result)
for id in rowlist:
dbstring2="update tx_queue set txhash='"+str(result) +"', success='True' where randomid='"+str(id)+"';"
print dbstring2
databases.dbexecute(dbstring2,False)
def find_transfer_inputs(fromaddr, coloraddress, coloramt, btc):
available_inputs=databases.dbexecute("SELECT * FROM OUTPUTS WHERE spent='False' and destination_address='"+fromaddr+"' and color_address='"+coloraddress+"';",True)
totalfound=0
btc=int(btc*100000000)
totalavailable=0
btcfound=0
btcavailable=0
answer=[]
totalinputamt=0
for x in available_inputs:
totalavailable=totalavailable+x[1]
btcavailable=btcavailable+x[0]
if totalavailable>=coloramt and btcavailable>=btc:
n=0
while totalfound<coloramt and n<len(available_inputs):
r={}
r['output']=available_inputs[n][7]
r['value']=available_inputs[n][0]
btcfound=btcfound+r['value']
totalinputamt=totalinputamt+r['value']
answer.append(r)
n=n+1
while btcfound<btc and n<len(available_inputs):
r={}
if n<len(available_inputs):
r['output']=available_inputs[n][7]
r['value']=available_inputs[n][0]
answer.append(r)
n=n+1
return answer, totalinputamt
def issuenewcoinsserverside(): #TO ONE RECIPIENT ADDRESS
jsoninput=json.loads(request.data)
private_key=str(jsoninput['private_key'])
public_address=str(jsoninput['public_address'])
more_coins=int(jsoninput['more_coins'])
recipient=str(jsoninput['recipient'])
fee_each=str(jsoninput['fee_each'])
name=str(jsoninput['name'])
othermeta=str(name)
specific_inputs = addresses.get_unspent(public_address)
#REMOVE COLORED OUTPUTS FROM THIS
for x in specific_inputs:
txhash_index = x['output']
found = databases.dbexecute("select * from outputs where spent='False' and txhash_index='"+str(txhash_index)+"' and destination_address='"+str(public_address)+"';",True)
nfound = len(found)
if nfound>0:
specific_inputs.remove(x)
print specific_inputs
response=transactions.create_issuing_tx(public_address, recipient, fee_each, private_key, more_coins, specific_inputs, othermeta)
jsonresponse={}
jsonresponse['transaction_hash']=response
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 find_transfer_inputs(fromaddr, coloraddress, coloramt, btc):
available_inputs = databases.dbexecute(
"SELECT * FROM OUTPUTS WHERE spent='False' and destination_address='" +
fromaddr + "' and color_address='" + coloraddress + "';", True)
totalfound = 0
btc = int(btc * 100000000)
totalavailable = 0
btcfound = 0
btcavailable = 0
answer = []
totalinputamt = 0
for x in available_inputs:
totalavailable = totalavailable + x[1]
btcavailable = btcavailable + x[0]
if totalavailable >= coloramt and btcavailable >= btc:
n = 0
while totalfound < coloramt and n < len(available_inputs):
r = {}
r['output'] = available_inputs[n][7]
r['value'] = available_inputs[n][0]
btcfound = btcfound + r['value']
totalinputamt = totalinputamt + r['value']
answer.append(r)
n = n + 1
while btcfound < btc and n < len(available_inputs):
r = {}
if n < len(available_inputs):
r['output'] = available_inputs[n][7]
r['value'] = available_inputs[n][0]
answer.append(r)
n = n + 1
return answer, totalinputamt
def color_txs_in_block(txs_n=None):
if txs_n == None:
txs_n = 10
dbstring = "SELECT * FROM outputs ORDER BY blockmade DESC limit " + str(
txs_n) + ";"
print dbstring
results = databases.dbexecute(dbstring, True)
response = {}
response['outputs'] = []
for x in results:
jsonresponse = {}
jsonresponse['btc'] = x[0]
jsonresponse['color_amount'] = x[1]
jsonresponse['color_address'] = x[2]
jsonresponse['spent'] = x[3]
jsonresponse['spent_at_txhash'] = x[4]
jsonresponse['destination_address'] = x[5]
jsonresponse['txhash'] = x[6]
jsonresponse['txhash_index'] = x[7]
jsonresponse['blockmade'] = x[8]
jsonresponse['previous_input'] = x[9]
jsonresponse['blockspent'] = x[10]
response['outputs'].append(jsonresponse)
results = json.dumps(response)
response = make_response(str(results), 200)
response.headers['Content-Type'] = 'application/json'
response.headers['Access-Control-Allow-Origin'] = '*'
return response
def colorbalances(public_address=None):
answer=databases.color_balance(public_address, None)
jsonresponse={}
jsonresponse['public_address']=public_address
jsonresponse['assets']=[]
issuer=""
colorname=""
for x in answer:
r={}
colordata=databases.dbexecute("select * from colors where color_address='"+str(x)+"';", True)
if len(colordata)>0:
colorname=colordata[0][3]
issuer=colordata[0][1]
if colorname=="color_name":
colorname=""
r['issuing_address']=str(issuer)
r['color_name']=colorname
r['color_address']=x
r['quantity']=answer[x]
jsonresponse['assets'].append(r)
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 colorholders(color_address=None):
answer=databases.color_holders(color_address)
if len(answer)==0:
color_address=databases.first_coloraddress_from_sourceaddress(color_address)
if not color_address is None:
answer=databases.color_holders(color_address)
else:
answer=""
colordata=databases.dbexecute("select * from colors where color_address='"+color_address+"';",True)
source_address="not found"
color_name="not found"
if len(colordata)>0:
source_address=colordata[0][1]
color_name=colordata[0][3]
if color_name=="color_name":
color_name=""
jsonresponse={}
jsonresponse['owners']=[]
jsonresponse['color_address']=color_address
jsonresponse['issuing_address']=source_address
jsonresponse['color_name']=color_name
for x in answer:
r={}
r['public_address']=x
r['quantity']=answer[x]
jsonresponse['owners'].append(r)
answer=json.dumps(jsonresponse)
response=make_response(str(answer), 200)
response.headers['Content-Type'] = 'application/json'
response.headers['Access-Control-Allow-Origin']= '*'
return response
def issuenewcoinsserverside(): #TO ONE RECIPIENT ADDRESS
jsoninput = json.loads(request.data)
private_key = str(jsoninput['private_key'])
public_address = str(jsoninput['public_address'])
more_coins = int(jsoninput['more_coins'])
recipient = str(jsoninput['recipient'])
fee_each = str(jsoninput['fee_each'])
name = str(jsoninput['name'])
othermeta = str(name)
specific_inputs = addresses.get_unspent(public_address)
#REMOVE COLORED OUTPUTS FROM THIS
for x in specific_inputs:
txhash_index = x['output']
found = databases.dbexecute(
"select * from outputs where spent='False' and txhash_index='" +
str(txhash_index) + "' and destination_address='" +
str(public_address) + "';", True)
nfound = len(found)
if nfound > 0:
specific_inputs.remove(x)
print specific_inputs
response = transactions.create_issuing_tx(public_address, recipient,
fee_each, private_key,
more_coins, specific_inputs,
othermeta)
jsonresponse = {}
jsonresponse['transaction_hash'] = response
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 color_txs_in_block(txs_n=None):
if txs_n==None:
txs_n=10
dbstring="SELECT * FROM outputs ORDER BY blockmade DESC limit "+str(txs_n)+";"
print dbstring
results=databases.dbexecute(dbstring,True)
response={}
response['outputs']=[]
for x in results:
jsonresponse={}
jsonresponse['btc']=x[0]
jsonresponse['color_amount']=x[1]
jsonresponse['color_address']=x[2]
jsonresponse['spent']=x[3]
jsonresponse['spent_at_txhash']=x[4]
jsonresponse['destination_address']=x[5]
jsonresponse['txhash']=x[6]
jsonresponse['txhash_index']=x[7]
jsonresponse['blockmade']=x[8]
jsonresponse['previous_input']=x[9]
jsonresponse['blockspent']=x[10]
response['outputs'].append(jsonresponse)
results=json.dumps(response)
response=make_response(str(results), 200)
response.headers['Content-Type'] = 'application/json'
response.headers['Access-Control-Allow-Origin']= '*'
return response
def colorbalances(public_address=None):
answer = databases.color_balance(public_address, None)
jsonresponse = {}
jsonresponse['public_address'] = public_address
jsonresponse['assets'] = []
issuer = ""
colorname = ""
for x in answer:
r = {}
colordata = databases.dbexecute(
"select * from colors where color_address='" + str(x) + "';", True)
if len(colordata) > 0:
colorname = colordata[0][3]
issuer = colordata[0][1]
if colorname == "color_name":
colorname = ""
r['issuing_address'] = str(issuer)
r['color_name'] = colorname
r['color_address'] = x
r['quantity'] = answer[x]
jsonresponse['assets'].append(r)
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 showcreatedassets():
created_assets = databases.dbexecute("select distinct coin_name, issued_amount, public_address from addresses where amount_received>=amount_expected;", True)
jsonresponse={}
jsonresponse['colors_created']=[]
for x in created_assets:
a={}
a['coin_name'] = x[0]
a['issued_amount'] = x[1]
a['public_address']=x[2]
a['color_address'] = databases.dbexecute("select color_address from colors where source_address='"+str(x[2])+"';", True)
jsonresponse['colors_created'].append(a)
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 read_color_names():
unnamed_colors=databases.dbexecute("select * from colors where color_name='color_name';",True)
totallength=len(unnamed_colors)
n=0
for unnamed_color in unnamed_colors:
#lookup metadata on blockchain
address=unnamed_color[1] #the source_address
result=addresses.read_opreturns_sent_by_address(address)
name="color_name"
print "color: "+str(n)+" / "+str(totallength)
n=n+1
try:
name=json.loads(result)
name=name['name']
databases.dbexecute("update colors set color_name='"+name+"' where source_address='"+address+"';", False)
except:
print "no name found for source: "+str(address)
def more_blocks(moreblocks):
currentblock=int(bitsource.get_current_block())
lastblockprocessed=databases.dbexecute("SELECT * FROM META;",True)
nextblock=lastblockprocessed[0][0]+moreblocks
print "starting block " +str(currentblock)
print "nextblock "+str(nextblock)
if nextblock>currentblock:
nextblock=currentblock
if lastblockprocessed[0][0]<currentblock:
for i in range(lastblockprocessed[0][0]+1, nextblock+1):
if i<=currentblock:
output_db(i)
print "processed block "+str(i)
databases.dbexecute("UPDATE META SET lastblockdone='"+str(i)+"';",False)
def get_current_block():
try:
response=requests.get("https://blockchain.info/q/getblockcount?api_code="+str(blockchain_api_code))
result=int(str(response.content))
except:
result= databases.dbexecute("select lastblockdone from meta;", True)[0][0]
print "I am using the DB for the last block, blockchain is not responding"
print result
return result
def test_meta_lastblockdone():
blockchain_blockcount=requests.get("https://blockchain.info/q/getblockcount").content
lastblockdone=db.dbexecute("SELECT * FROM meta;",True)
try:
lastblockdone=lastblockdone[0][0]
except:
lastblockdone=-1
print "Color DB is not up to date, stuck at "+str(lastblockdone)+" out of "+str(blockchain_blockcount)
assert int(lastblockdone)==int(blockchain_blockcount)
def more_blocks(moreblocks):
currentblock=node.connect('getblockcount',[])
lastblockprocessed=databases.dbexecute("SELECT * FROM META;",True)
nextblock=lastblockprocessed[0][0]+moreblocks
if nextblock>currentblock:
nextblock=currentblock
for i in range(lastblockprocessed[0][0]+1, nextblock+1):
try:
output_db(i)
print "processed block "+str(i)
databases.dbexecute("UPDATE META SET lastblockdone='"+str(i)+"';",False)
except:
print "error updating db"
elif nextblock<=currentblock:
for i in range(lastblockprocessed[0][0]+1, nextblock+1):
#try:
output_db(i)
print "processed block "+str(i)
databases.dbexecute("UPDATE META SET lastblockdone='"+str(i)+"';",False)
def verify_colors():
unknowns=databases.dbexecute("select * from outputs where spent='false' and color_address='unknown';",True)
for unknown in unknowns:
previous_inputs=unknown[9]
previous_inputs=previous_inputs.split("_")
previous_inputs=previous_inputs[0:len(previous_inputs)-1]
coloraddress=''
for previous_input in previous_inputs:
data=databases.dbexecute("select color_address from outputs where txhash_index='"+previous_input+"';", True)
try:
data=data[0][0]
except:
data='unknown'
coloraddress=data
dbstring="update outputs set color_address='"+coloraddress+"' where txhash_index='"+unknown[7]+"';"
print dbstring
databases.dbexecute(dbstring,False)
def test_meta_lastblockdone():
blockchain_blockcount = requests.get(
"https://blockchain.info/q/getblockcount").content
lastblockdone = db.dbexecute("SELECT * FROM meta;", True)
try:
lastblockdone = lastblockdone[0][0]
except:
lastblockdone = -1
print "Color DB is not up to date, stuck at " + str(
lastblockdone) + " out of " + str(blockchain_blockcount)
assert int(lastblockdone) == int(blockchain_blockcount)
def getcoloraddressfromsource(source_address=None):
coloraddress = "not found"
if not source_address == None:
coloraddress = databases.dbexecute("select color_address from colors where source_address='"+str(source_address)+"'", True)
jsonresponse['color_address']=coloraddress
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 showcreatedassets():
created_assets = databases.dbexecute(
"select distinct coin_name, issued_amount, public_address from addresses where amount_received>=amount_expected;",
True)
jsonresponse = {}
jsonresponse['colors_created'] = []
for x in created_assets:
a = {}
a['coin_name'] = x[0]
a['issued_amount'] = x[1]
a['public_address'] = x[2]
a['color_address'] = databases.dbexecute(
"select color_address from colors where source_address='" +
str(x[2]) + "';", True)
jsonresponse['colors_created'].append(a)
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_current_block():
try:
response = requests.get(
"https://blockchain.info/q/getblockcount?api_code=" +
str(blockchain_api_code))
result = int(str(response.content))
except:
result = databases.dbexecute("select lastblockdone from meta;",
True)[0][0]
print "I am using the DB for the last block, blockchain is not responding"
print result
return result
def color_txs_in_block():
dbstring = "SELECT * FROM outputs ORDER BY blockmade DESC;"
results = databases.dbexecute(dbstring, True)
maxreturnlength = 100
if len(results) > maxreturnlength:
results = results[0:maxreturnlength]
results = json.dumps(results)
response = make_response(str(results), 200)
response.headers['Access-Control-Allow-Origin'] = '*'
return response
def sendbtc():
jsoninput=json.loads(request.data)
public_address=str(jsoninput['public_address'])
destination=str(jsoninput['destination'])
private_key=str(jsoninput['private_key'])
amount=str(int(jsoninput['amount']*100000000))
r=str(random.random())
random_id=str(hashlib.sha256(r).hexdigest())
fee=str(5000)
dbstring="insert into tx_queue (first_tried_at_block, success, from_public, from_private, destination, fee_each, source_address, transfer_amount, randomid) values ('-1', 'False', '"+public_address+"','"+str(private_key)+"','"+destination+"','"+fee+"', '', '"+str(amount)+"','"+str(random_id)+"');"
print dbstring
databases.dbexecute(dbstring,False)
jsonresponse={}
jsonresponse['result']="Queued"
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 color_txs_in_block():
dbstring="SELECT * FROM outputs ORDER BY blockmade DESC;"
results= databases.dbexecute(dbstring,True)
maxreturnlength=100
if len(results)>maxreturnlength:
results=results[0:maxreturnlength]
results=json.dumps(results)
response=make_response(str(results), 200)
response.headers['Access-Control-Allow-Origin']= '*'
return response
def searchbyname(the_name=None):
the_name = the_name.replace ("_", " ")
coloraddress= None
result=databases.dbexecute("select color_address from colors where color_name='"+the_name+"';",True)
if len(result)>0:
coloraddress=result[0][0]
jsonresponse={}
jsonresponse['color_address']=coloraddress
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 getcoloraddressfromsource(source_address=None):
coloraddress = "not found"
if not source_address == None:
coloraddress = databases.dbexecute(
"select color_address from colors where source_address='" +
str(source_address) + "'", True)
jsonresponse['color_address'] = coloraddress
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 searchbyname(the_name=None):
the_name = the_name.replace("_", " ")
coloraddress = None
result = databases.dbexecute(
"select color_address from colors where color_name='" + the_name +
"';", True)
if len(result) > 0:
coloraddress = result[0][0]
jsonresponse = {}
jsonresponse['color_address'] = coloraddress
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 tx_queue():
dbstring = "select * from tx_queue where success='False';"
txs = databases.dbexecute(dbstring, True)
print txs
for tx in txs:
fromaddr = tx[0]
destination = tx[2]
fee = float(tx[3]) * 0.00000001
privatekey = tx[1]
source_address = tx[4]
coloramt = tx[5]
randomid = tx[10]
othermeta = "transfer"
try:
result = transactions.transfer_tx(
fromaddr, destination, fee, privatekey, source_address, coloramt, othermeta
)
except:
print "ERROR processing queued TX from " + str(fromaddr)
result = None
result = result[0]
if result is None:
print "No response heard from Bitcoin Network"
firsttriedatblock = tx[6]
if firsttriedatblock == -1:
dbstring = (
"update tx_queue set first_tried_at_block='"
+ str(current_block)
+ "' where randomid='"
+ randomid
+ "';"
)
databases.dbexecute(dbstring, False)
elif current_block - firsttriedatblock > 500:
dbstring = "delete from tx_queue * where randomid='" + randomid + "';"
databases.dbexecute(dbstring, False)
elif len(str(result)) > 10:
print "HEARD TX RESULT: " + str(result)
dbstring2 = (
"update tx_queue set txhash='" + str(result) + "', success='True' where randomid='" + randomid + "';"
)
databases.dbexecute(dbstring2, False)
print dbstring2
response = {}
response["transaction_hash"] = result
response = json.dumps(response)
postresponse = requests.post(tx[9], data=response)
print "SENDING POST TO " + str(tx[9]) + " WITH DATA= " + str(response)
print "RESPONSE HEARD TYPE " + str(postresponse.status_code)
print "RESPONSE CONTENTS: " + str(postresponse.content)
def sendbtc():
jsoninput = json.loads(request.data)
public_address = str(jsoninput['public_address'])
destination = str(jsoninput['destination'])
private_key = str(jsoninput['private_key'])
amount = str(int(jsoninput['amount'] * 100000000))
r = str(random.random())
random_id = str(hashlib.sha256(r).hexdigest())
fee = str(5000)
dbstring = "insert into tx_queue (first_tried_at_block, success, from_public, from_private, destination, fee_each, source_address, transfer_amount, randomid) values ('-1', 'False', '" + public_address + "','" + str(
private_key) + "','" + destination + "','" + fee + "', '', '" + str(
amount) + "','" + str(random_id) + "');"
print dbstring
databases.dbexecute(dbstring, False)
jsonresponse = {}
jsonresponse['result'] = "Queued"
jsonresponse['id'] = random_id
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 schedule_transfer():
jsoninput = json.loads(request.data)
fromaddr = str(jsoninput['from_public_address'])
dest = str(jsoninput['to_public_address'])
fee_each = float(jsoninput['fee_each'])
fee_each = str(int(fee_each * 100000000))
privatekey = str(jsoninput['from_private_key'])
sourceaddress = str(jsoninput['issuing_address'])
coloramt = str(jsoninput['transfer_amount'])
if 'type' in jsoninput:
atype = str(jsoninput['type'])
else:
atype = ''
r = str(random.random())
random_id = str(hashlib.sha256(r).hexdigest())
callback_url = None
if 'callback_url' in jsoninput:
callback_url = jsoninput['callback_url']
dbstring = "insert into tx_queue (first_tried_at_block, success, from_public, from_private, destination, fee_each, source_address, transfer_amount, callback_url, randomid, type) values ('-1','False" + "','" + fromaddr + "','" + privatekey + "','" + dest + "','" + fee_each + "','" + sourceaddress + "','" + coloramt + "','" + callback_url + "','" + str(
random_id) + "','" + str(atype) + "');"
else:
dbstring = "insert into tx_queue (first_tried_at_block, success, from_public, from_private, destination, fee_each, source_address, transfer_amount, randomid, type) values ('-1','False" + "','" + fromaddr + "','" + privatekey + "','" + dest + "','" + fee_each + "','" + sourceaddress + "','" + coloramt + "','" + str(
random_id) + "','" + str(atype) + "');"
databases.dbexecute(dbstring, False)
jsonresponse = {}
jsonresponse['result'] = "Queued"
jsonresponse['id'] = random_id
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 checkaddresses(): #FOR PAYMENT DUE #WORKS
#check all addresses that are still pending
#for each that is ready, go through makenewcoins process
#mark as completed
#send profits elsewhere
#read all addresses
dbstring="SELECT * FROM ADDRESSES WHERE amount_withdrawn=0;"
addresslist=databases.dbexecute(dbstring,True)
print addresslist
for address in addresslist:
unspents=addresses.unspent(address[0])
value=0
for x in unspents:
value=value+x['value']
print "currently available in "+str(address[0])+" : "+str(value/100000000)
if value>=address[2] and address[3]<address[2]:
#makenewcoins
fromaddr=address[0]
colornumber=address[6]
colorname=address[5]
destination=address[7]
fee_each=0.00004
private_key=address[1]
ticker=address[9]
description=address[8]
txdata=transactions.make_new_coin(fromaddr, colornumber, colorname, destination, fee_each, private_key, ticker, description)
txhash=txdata[0]
txhash=txhash+":0" #issuance always first output
specific_inputs=txdata[1]['output'] #THIS IS CRUCIAL IN FINDING COLOR ADDRESS
#mark as completed
databases.edit_address(fromaddr, value, value, colornumber)
#add entry to colors db
#referencehex=bitsource.tx_lookup(specific_inputs)
color_address=bitsource.script_to_coloraddress()
databases.add_color(color_address, fromaddr, colornumber, colorname)
def colorholders(color_address=None):
answer = databases.color_holders(color_address)
if len(answer) == 0:
color_address = databases.first_coloraddress_from_sourceaddress(
color_address)
if not color_address is None:
answer = databases.color_holders(color_address)
else:
answer = ""
colordata = databases.dbexecute(
"select * from colors where color_address='" + color_address + "';",
True)
source_address = "not found"
color_name = "not found"
if len(colordata) > 0:
source_address = colordata[0][1]
color_name = colordata[0][3]
if color_name == "color_name":
color_name = ""
jsonresponse = {}
jsonresponse['owners'] = []
jsonresponse['color_address'] = color_address
jsonresponse['issuing_address'] = source_address
jsonresponse['color_name'] = color_name
for x in answer:
r = {}
r['public_address'] = x['public_address']
r['quantity'] = x['quantity']
jsonresponse['owners'].append(r)
answer = json.dumps(jsonresponse)
response = make_response(str(answer), 200)
response.headers['Content-Type'] = 'application/json'
response.headers['Access-Control-Allow-Origin'] = '*'
return response
def colortxs(tx_hash=None):
dbstring="SELECT * FROM outputs WHERE txhash='"+str(tx_hash)+"';"
result=databases.dbexecute(dbstring,True)
response={}
response['outputs']=[]
for x in result:
jsonresponse={}
jsonresponse['btc']=x[0]
jsonresponse['color_amount']=x[1]
jsonresponse['color_address']=x[2]
jsonresponse['spent']=x[3]
jsonresponse['spent_at_txhash']=x[4]
jsonresponse['destination_address']=x[5]
jsonresponse['txhash']=x[6]
jsonresponse['txhash_index']=x[7]
jsonresponse['blockmade']=x[8]
jsonresponse['previous_input']=x[9]
jsonresponse['blockspent']=x[10]
response['outputs'].append(jsonresponse)
results=json.dumps(response)
response=make_response(str(results), 200)
response.headers['Content-Type'] = 'application/json'
response.headers['Access-Control-Allow-Origin']= '*'
return response
def colortxs(tx_hash=None):
dbstring = "SELECT * FROM outputs WHERE txhash='" + str(tx_hash) + "';"
result = databases.dbexecute(dbstring, True)
response = {}
response['outputs'] = []
for x in result:
jsonresponse = {}
jsonresponse['btc'] = x[0]
jsonresponse['color_amount'] = x[1]
jsonresponse['color_address'] = x[2]
jsonresponse['spent'] = x[3]
jsonresponse['spent_at_txhash'] = x[4]
jsonresponse['destination_address'] = x[5]
jsonresponse['txhash'] = x[6]
jsonresponse['txhash_index'] = x[7]
jsonresponse['blockmade'] = x[8]
jsonresponse['previous_input'] = x[9]
jsonresponse['blockspent'] = x[10]
response['outputs'].append(jsonresponse)
results = json.dumps(response)
response = make_response(str(results), 200)
response.headers['Content-Type'] = 'application/json'
response.headers['Access-Control-Allow-Origin'] = '*'
return response
def output_db(blockn):
#ADD OUTPUTS TO DB assuming correctness
txdata=oa_in_block(blockn)
for tx in txdata:
#ISSUED
for txissued in tx[1]['issued']:
coloraddress = txissued['color_address']
btc= str(txissued['btc'])
coloramt = str(txissued['quantity'])
spent=str(False)
spentat=""
destination=str(txissued['destination_address'])
txhash_index=str(txissued['txhash_index'])
txhash = txhash_index[0:len(txhash_index)-2]
blockmade=str(blockn)
prev_input=txissued['previous_inputs']
databases.add_output(btc, coloramt, coloraddress, spent, spentat, destination, txhash, txhash_index, blockmade, prev_input)
#EDIT COLOR OVERVIEW DATA
oldamount=databases.read_color(coloraddress)
if len(oldamount)==0: #COLOR DOES NOT EXIST YET
source_address=prev_input[7:len(prev_input)]
databases.add_color(coloraddress, source_address, coloramt, "color_name")
else:
oldamount=oldamount[0][2]
databases.edit_color(coloraddress, int(oldamount)+int(coloramt))
#TRANSFERRED
for txtransfer in tx[1]['transferred']:
coloraddress="illegitimate"
btc=str(txtransfer['btc'])
coloramt=str(txtransfer['quantity'])
spent=str(False)
spentat=""
destination=txtransfer['destination_address']
txhash_index=txtransfer['txhash_index']
txhash=txhash_index[0:len(txhash_index)-2]
blockmade=str(blockn)
prev_input=txtransfer['previous_inputs']
databases.add_output(btc, coloramt, coloraddress, spent, spentat, destination, txhash, txhash_index, blockmade, prev_input)
recentlyaddedtxs=databases.dbexecute("SELECT txhash FROM OUTPUTS WHERE blockmade="+str(blockn)+";", True)
print "recently added txs "
print recentlyaddedtxs
print ""
for tx in recentlyaddedtxs:
txhash=tx[0]
totalin=0
inputs=databases.dbexecute("SELECT previous_input from outputs where txhash='"+txhash+"';",True)
inputs=inputs[0]
for inp in inputs:
if inp[0:7]=="source:": #WAS ISSUED, need not be checked
totalin=999999999999
else:
inp=inp.split("_")
inp=inp[0:len(inp)-1]
print "MY INPUTS IN TRANSFER "
print inp
print ""
for x in inp:
dbstring="SELECT color_amount from outputs where txhash_index='"+x+"';"
colinps=databases.dbexecute(dbstring,True)
for colinp in colinps:
totalin=totalin+colinp[0]
#THEN SUM TOTAL OUT
outps=databases.dbexecute("SELECT color_amount from outputs where blockmade="+str(blockn)+" and txhash='"+txhash+"'", True)
totalout=0
for outp in outps:
totalout=totalout+outp[0]
#IF TOTALIN>= TOTAL OUT, its OK, else, SPENT ALL OUTPUTS AND UNSPEND ALL INPUTS
print "IN: "+str(totalin)+" OUT: "+str(totalout)+" for tx: "+str(tx)
if totalout<=totalin:
#everything OK
print "legit tx: "+str(tx)
#SPEND INPUTS FINALLY
inputs=databases.dbexecute("SELECT previous_input from outputs where txhash='"+txhash+"';",True)
for inp in inputs:
for x in inp:
if not x[0:7]=="source:":
x=x.split("_")
x=x[0:len(x)-1]
print x
#GET COLOR OF PREVIOUS INPUTS
thecolor=databases.dbexecute("SELECT color_address from outputs where txhash_index='"+x[0]+"';",True)
if len(thecolor)>0:
thecolor=thecolor[0][0]
else:
thecolor="unknown"
#SET COLOR
databases.dbexecute("UPDATE outputs set color_address='"+thecolor+"' where txhash='"+txhash+"';",False)
for y in x:
databases.spend_output(str(y), txhash,blockn)
print "SPENDING: "+str(y)
else:
print "ILLEGITIMATE TX DETECTED: "+str(tx)
databases.dbexecute("delete from outputs * where color_address='illegitimate';",False)
def colormeta():
answer = databases.dbexecute("SELECT * FROM COLORS;", True)
answer = json.dumps(answer)
response = make_response(str(answer), 200)
response.headers['Access-Control-Allow-Origin'] = '*'
return response
def create_meta_table():
dbstring="create table meta (lastblockdone integer);"
databases.dbexecute(dbstring, False)
databases.dbexecute("insert into meta values (300000);",False)
def create_color_table(): dbstring="create table colors (color_address varchar(140), source_address varchar(140), total_issued bigint, color_name varchar(200));" databases.dbexecute(dbstring, False)
def test_unknown():
response = db.dbexecute(
"select * from outputs where color_address='unknown' and spent='false';",
True)
assert len(response) == 0
def test_colordb_connected():
a = db.dbexecute("SELECT * FROM meta;", True)
print "COLOR DB NOT RESPONDING"
assert len(a) > 0
def create_tx_queue_table(): dbstring="create table tx_queue (from_public varchar(140), from_private varchar(140), destination varchar(140), fee_each bigint, source_address varchar(140), transfer_amount bigint, first_tried_at_block integer, success bool, txhash varchar(200), callback_url varchar(200), randomid varchar(200));" databases.dbexecute(dbstring, False)
def output_db(blockn):
#ADD OUTPUTS TO DB assuming correctness
txdata=oa_in_block(blockn)
for tx in txdata:
try:
#ISSUED
for txissued in tx[1]['issued']:
coloraddress = txissued['color_address']
btc= str(txissued['btc'])
coloramt = str(txissued['quantity'])
spent=str(False)
spentat=""
destination=str(txissued['destination_address'])
txhash_index=str(txissued['txhash_index'])
txhash = txhash_index[0:len(txhash_index)-2]
blockmade=str(blockn)
prev_input=txissued['previous_inputs']
databases.add_output(btc, coloramt, coloraddress, spent, spentat, destination, txhash, txhash_index, blockmade, prev_input)
#EDIT COLOR OVERVIEW DATA
oldamount=databases.read_color(coloraddress)
if len(oldamount)==0:
source_address=prev_input[7:len(prev_input)]
databases.add_color(coloraddress, source_address, coloramt, "color_name")
else:
oldamount=oldamount[0][2]
databases.edit_color(coloraddress, int(oldamount)+int(coloramt))
#TRANSFERRED
for txtransfer in tx[1]['transferred']:
coloraddress=txtransfer['color_address']
btc=str(txtransfer['btc'])
coloramt=str(txtransfer['quantity'])
spent=str(False)
spentat=""
destination=txtransfer['destination_address']
txhash_index=txtransfer['txhash_index']
txhash=txhash_index[0:len(txhash_index)-2]
blockmade=str(blockn)
prev_input=txtransfer['previous_inputs']
databases.add_output(btc, coloramt, coloraddress, spent, spentat, destination, txhash, txhash_index, blockmade, prev_input)
except:
databases.dbexecute("insert into errors txhash values ('"+tx[0]+"');",False)
#after entire block is processed check that the sums match, SPEND SPENT OUTPUTS
recentlyaddedtxs=databases.dbexecute("SELECT txhash FROM OUTPUTS WHERE blockmade="+str(blockn)+";", True)
#FIND TX (not outputs but parent) and SUM TOTAL IN
for tx in recentlyaddedtxs:
txhash=tx[0]
#sum total in
totalin=0
inputs=databases.dbexecute("SELECT previous_input from outputs where txhash='"+txhash+"';",True)
for inpa in inputs:
for inp in inpa:
if inp[0:7]=="source:": #WAS ISSUED, need not be check
totalin=999999999999
else:
inp=inp.split("_")
inp=inp[0:len(inp)-1]
for x in inp:
dbstring="SELECT color_amount from outputs where txhash_index='"+x+"';"
#print dbstring
colinps=databases.dbexecute(dbstring,True)
for colinp in colinps:
totalin=totalin+colinp[0]
#THEN SUM TOTAL OUT
outps=databases.dbexecute("SELECT color_amount from outputs where blockmade="+str(blockn)+" and txhash='"+txhash+"'", True)
totalout=0
for outp in outps:
totalout=totalout+outp[0]
#IF TOTALIN>= TOTAL OUT, its OK, else, SPENT ALL OUTPUTS AND UNSPEND ALL INPUTS
if totalout<=totalin:
#everything OK
print "legit tx: "+str(tx)
#SPEND INPUTS FINALLY
inputs=databases.dbexecute("SELECT previous_input from outputs where txhash='"+txhash+"';",True)
for inp in inputs:
for x in inp:
if not x[0:7]=="source:":
x=x.split("_")
x=x[0:len(inputs)-1]
for y in x:
databases.spend_output(str(y), txhash,blockn)
else:
print "ILLEGITIMATE TX DETECTED: "+str(tx)
def create_outputs_table(): dbstring="create table outputs (btc bigint, color_amount bigint, color_address varchar(200), spent bool, spent_at_txhash varchar(200), destination_address varchar(140), txhash varchar(200), txhash_index varchar(200), blockmade integer, previous_input varchar(3000), blockspent integer);" databases.dbexecute(dbstring, False)
def add_output_db(blockn):
results=oa_in_block(blockn)
for tx in results:
try:
if 'issued' in tx[1]:
for outputs in tx[1]['issued']:
#ISSUED FIRST, no check necessary
btc=str(outputs['btc'])
coloramt=str(outputs['quantity'])
coloraddress=str(outputs['color_address']) #THIS WORKED!
spent="False"
spentat=""
destination=str(outputs['destination_address'])
txhash=str(tx[0][0:len(tx[0])-2])
txhash_index=str(outputs['txhash_index'])
blockmade=str(blockn)
prev_input=outputs['previous_inputs']
databases.add_output(btc,coloramt,coloraddress, spent, spentat, destination, txhash, txhash_index, blockmade, prev_input)
#ADD NEW ISSUED to COLORS META INFO
oldamount=databases.read_color(coloraddress)
if len(oldamount)==0:
source_address=outputs['previous_inputs'][outputs['previous_inputs'].index(':')+1:len(outputs['previous_inputs'])]
databases.add_color(coloraddress, source_address, coloramt, "color_name")
else:
oldamount=oldamount[0][2]
databases.edit_color(coloraddress, int(oldamount)+int(coloramt))
for inps in tx[1]['transferred']:
#TRANSFERS
btc=str(inps['btc'])
coloramt=str(inps['quantity'])
coloraddress=str(inps['color_address'])
spent="False"
spentat=""
destination=str(inps['destination_address'])
#print tx
txhash=str(tx[0][0:len(tx[0])-2])
txhash_index=str(inps['txhash_index'])
blockmade=str(blockn)
prev_inputs=inps['previous_inputs']
#print prev_inputs
# totalin=0
# inputlist=[]
# for x in prev_inputs: #for each previnput txhash_with_index
# print "CHECKING PREV INPUT: "+str(x)
# old=databases.read_output(x,False) #read that input
# print old
# if len(old)>0: #if it is found in the DB
# old=old[0] #get that element
# totalin=totalin+old[1] #add its color amount to the total inputted
# coloraddress=databases.dbexecute("SELECT color_address from outputs WHERE txhash_index='"+x+"';",True)[0][0] #get the color address of that input
# inputlist.append([x,old[1], coloraddress]) #append it to the total list
#
# print inputlist
#CHECK AMT ON PREVIOUS INPUT
#oldamt=databases.read_output(prev_input, True)
totalin=int(coloramt) #so it always passes
if totalin>=int(coloramt): #LEGITIMATE
#ADD NEW OUTPUT
print "color address"+str(coloraddress)
prev_input="FIX HERE"
#decide which inputs to spend
totalspent=0
inputcounter=0
cont=True
while int(coloramt)-totalspent>0 and cont:
if inputcounter<len(inputlist):
prev_input=inputlist[inputcounter][0]
totalspent=totalspent+inputlist[inputcounter][1]
databases.add_output(btc,coloramt,coloraddress,spent,spentat,destination,txhash,txhash_index, blockmade, prev_input)
inputcounter=inputcounter+1
elif inputcounter>=len(inputlist):
cont=False
#MARK OLD OUTPUT AS SPENT
#print str(prev_input)+" "+str(txhash)
databases.spend_output(prev_input, txhash, blockn)
else:
print "ILLEGITIMATE TX: "+str(tx[0])
print str(totalin)+" / "+str(coloramt)
previnplist=[]
for previnps in tx[1]['transferred']:
for x in previnps['previous_inputs']:
previnplist.append([x,previnps['txhash_index']])
for x in previnplist:
databases.spend_output(x[0], x[1], blockn)
else:
print "Invalid OA TX cannot be processed: " +str(tx)+" END "
except:
databases.dbexecute("insert into errors (txhash) values ('"+tx[0]+"')")
#CHECK BLOCK SPENT TXS FOR VERACITY AT END OF BLOCK
for tx in results:
for inps in tx[1]['transferred']:
prev_inputs=inps['previous_inputs']
totalin=0
inputlist=[]
for x in prev_inputs: #for each previnput txhash_with_index
print "CHECKING PREV INPUT: "+str(x)
old=databases.read_output(x,False) #read that input
print old
if len(old)>0: #if it is found in the DB
old=old[0] #get that element
totalin=totalin+old[1] #add its color amount to the total inputted
coloraddress=databases.dbexecute("SELECT color_address from outputs WHERE txhash_index='"+x+"';",True)[0][0] #get the color address of that input
inputlist.append([x,old[1], coloraddress]) #append it to the total list
print inputlist
coloramt=str(inps['quantity'])
if totalin>=int(coloramt):
#everything was OK
h=0
else:
txhash_index=str(outputs['txhash_index'])
print "ILLEGITIMATE TX DETECTED "+txhash_index
def create_addresses_table(): dbstring="create table addresses (public_address varchar(140), private_key varchar(200), amount_expected bigint, amount_received bigint, amount_withdrawn bigint, coin_name varchar(140), issued_amount bigint, destination_address varchar(140), description varchar(3000), email varchar(400));" databases.dbexecute(dbstring,False)
