def create_handler(request, order_total, btc_total):
"""
Create a new bitcoin address if the latest created one has received funds.
Otherwise use the latest address. The aim is to avoid 'address gap' issue.
invoice_id should be something unique for the transaction.
"""
invoice_id = str(request.cart.id)
recv = BtcInvoice.objects.latest()
address = recv.address
received = get_address(address).total_received
if received > 0:
callback_url = _create_callback_url(
request, invoice_id, settings.SECRET_KEY
)
recv = receive(settings.XPUB, callback_url, settings.API_KEY)
address = recv.address
invoice = BtcInvoice(
invoice_id=invoice_id,
price_in_usd=order_total,
price_in_btc=btc_total,
address=address
)
invoice.save()
else:
recv.price_in_usd = order_total
recv.price_in_btc = btc_total
recv.added_time = datetime.datetime.now(pytz.utc)
recv.save()
invoice_id = recv.invoice_id
return (address, invoice_id)
class Lock(object):
transaction = None
public_address = None
nonce = None
nonce_flag = False
def __init__(self):
f = open('lock.txt', 'r')
self.transaction = f.readline().rstrip()
self.public_address = f.readline().rstrip()
self.nonce = None
self.nonce_flag = False
if len(self.transaction) == 64:
self.updateLock(1)
def init_lock(self, address, trans):
""" Initialize of global parameters storing lock address and transaction
Can only be called once upon lock conception.
:param: Public address associated with lock
:param: Transaction associated with lock creation
:return: String stating result of initalization call
"""
if len(self.transaction) == 64:
return 'Propery has been Initialized previously'
try:
blockexplorer.get_tx(trans)
except blockchain.exceptions.APIException, TypeError:
return 'Invalid transaction'
try:
blockexplorer.get_address(address)
except blockchain.exceptions.APIException, TypeError:
return 'Invalid address'
def address():
form = AddressSearchForm(request.form)
if request.method == 'POST':
addr = request.form['addr'].strip()
try:
clean_addr = str(addr)
if len(clean_addr) == 34:
try:
address = be.get_address(clean_addr, api_code=app.api_code)
return render_template(
'_address.html',
address=address,
search_value=addr,
current_time=datetime.now().strftime('LLL'))
except APIException as e:
flash('API Error', 'warning')
return redirect(url_for('address'))
else:
message = 'The Bitcoin address is malformed. Please check your data and try again.'
flash(message, 'danger')
redirect(url_for('address'))
except (ValueError, TypeError) as err:
message = 'An error has occurred: ' + str(err)
flash(message, 'danger')
return redirect(url_for('address'))
else:
return render_template('_address.html',
form=form,
current_time=datetime.now().strftime('LLL'))
def Main():
print("***block data components***")
hashValue = '000000000000000016f9a2c3e0f4c1245ff24856a79c34806969f5084f410680'
blockDict = class_00.getBlockDict(hashValue)
class_00.printDictvalue(blockDict)
print("***transaction data components***")
transactionDict = class_00.getTransactionDict(blockDict['transactions'])
class_00.printDictvalue(transactionDict)
print("***transaction output data***")
outputDict = class_00.getOutputDict(transactionDict['outputs'])
class_00.printDictvalue(outputDict)
print("***address data components***")
address = blockexplorer.get_address('1HS9RLmKvJ7D1ZYgfPExJZQZA1DMU3DEVd')
addressDict = class_00.getAddressDict(address)
class_00.printDictvalue(addressDict)
print("***unspentoutputs data components***")
outs = blockexplorer.get_unspent_outputs(
'1HS9RLmKvJ7D1ZYgfPExJZQZA1DMU3DEVd')
unspentoutputDict = class_00.getUnspentoutputsDict(outs[0])
class_00.printDictvalue(unspentoutputDict)
def build(address, comment=""):
# Builds the object with given attributes
api_address = blockexplorer.get_address(address)
api_transactions = api_address.transactions
n_tx = api_address.n_tx
total_received = api_address.total_received / 100000000
total_sent = api_address.total_sent / 100000000
balance = api_address.final_balance / 100000000
if api_transactions:
last_tx_date = api_transactions[0].time
else:
last_tx_date = 0
#last_tx_date = datetime.utcfromtimestamp(api_transactions[-1].time).strftime('%Y-%m-%d %H:%M:%S')
data_created_date = 0
final_object = BitcoinAddress(address,
n_tx,
total_received,
total_sent,
balance,
last_tx_date,
data_created_date,
comment,
transactions=api_transactions)
return final_object
def bitcoin_data(address):
"""
Gather and format the Bitcoin data for a given address
Output schema as Tuple:
input address,
output address,
{
input value
output value
transaction hash
transaction time
transaction relay
}
"""
transaction_pairs = []
input_address = bce.get_address(address)
transactions = input_address.transactions
for event in transactions:
for i in event.inputs:
for o in event.outputs:
transaction_pairs.append(tuple([i.address,
o.address,
{
'input_value': i.value,
'output_value': o.value,
'hash': event.hash,
'time': timestamp_conv(event.time),
'relay': event.relayed_by
}
]))
return transaction_pairs
def extract_bitcoin_accounts(text):
'''
Extract posible bitcoin public keys
:param text: Text to search the bitcoin public keys
:return: List with bitcoin public keys, or None if there isn't
'''
# Regular expresion to detect bitcoin public keys. There aren't 0, I, O, and l
regex = r"[1-3][123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]{27,34}"
bclist = re.findall(regex, text)
bclist = list(set(bclist)) # Delete duplicates
possible = len(bclist)
ret = []
# Look for the word bitcoin also
if "BITCOIN" in text.upper() and len(bclist) > 0:
for address in bclist:
try:
salida = blockexplorer.get_address(address,
limit=1,
api_code=apic)
if len(salida.transactions) > 0:
ret.append(address)
except Exception as e:
logging.error(
"In function extract_bitcoins_accounts/blockexplorer API: {}"
.format(e))
pass
if len(ret) > 0:
return ret, possible
else:
return None, possible
else:
return None, possible
def results(query):
search_results = None
type = None
if len(query) > 63:
try:
search_results = be.get_block(query, api_code=app.api_code)
type = 'Block Info'
except APIException as e:
print('An API error has occurred ' + str(e))
elif len(query) > 33:
try:
search_results = be.get_address(query)
type = 'Address Info'
except APIException as e:
print('Error ' + str(e))
else:
type = 'Block Height Info'
try:
try:
n = int(query)
search_results = be.get_block_height(n, api_code=app.api_code)
except (ValueError, TypeError) as err:
search_results = str('Invalid query expression. ' + str(err))
flash(search_results, 'danger')
return redirect(url_for('index'))
except APIException as e:
print('Error ' + str(e))
return render_template('results.html',
query=query,
search_results=search_results,
type=type,
current_time=datetime.now().strftime('LLL'))
def main():
# get latest block (max height)
latest_block = be.get_latest_block()
print("Latest height: ",str(latest_block.height))
print("Latest hash: ",latest_block.hash)
# hash of the block where laszlo transaction resides
pizza_block_hash = "00000000152340ca42227603908689183edc47355204e7aca59383b0aaac1fd8"
# hash of the laszlo tx
pizza_tx_hash = "a1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d"
# get the block
pizza_block = be.get_block(pizza_block_hash)
print("The block height for the Laszlo tx ", pizza_block.height)
# get the tx
pizza_tx = be.get_tx(pizza_tx_hash)
print("That pizza cost ", satoshis_to_btc(pizza_tx.outputs.pop().value), " BTCs!")
# get Txs in Laszlo's address
laszlo_addr = "1XPTgDRhN8RFnzniWCddobD9iKZatrvH4"
print("Laszlo transaction list for address ", laszlo_addr)
laszlo_txs = be.get_address(laszlo_addr).transactions
for t in laszlo_txs:
for o in t.outputs:
print(satoshis_to_btc(o.value))
def update():
"""
Checks/updates pending receiving addresses and checks/updates pending transactions
"""
# Check all pending receivers
pending_receivers = db.session.query(Node).filter(Node.role=='receiving',
Node.status=='pending').all()
logger.info("pending receivers: "+str(len(pending_receivers)))
for node in pending_receivers:
# update the balance from bc.info
logger.info("checking "+str(node.address))
bc_address = blockchain.get_address(node.address, confirmations=2)
node.balance = float(float(bc_address.balance) / float(100000000)) # satoshis -> BTC
logger.info(str(node.address)+" has "+str(node.balance))
if node.balance >= node.pending_amt:
# get the origin of the receiver's balance
origins = []
node_bc_addr = blockexplorer.get_address(node.address)
for tx in node_bc_addr.transactions:
for inpt in tx.inputs:
logger.info("appending origin: "+str(inpt.address))
origins.append(inpt.address)
if len(origins) > 1:
logger.warn("change origin from db string to list!")
origin_addr = origins[0]
node.orign = origin_addr
# inputs have been received, so update its transaction and blunderbuss
# tag wallet with the origin of its inputs
tx = db.session.query(Tx).filter(Tx.parent==node.address).one()
tx.received_inputs = True
tx.origin = origin_addr
blunderbussed = controller.blunderbuss(parent=node.address,
amount=tx.amount,
origin=origin_addr)
if blunderbussed:
node.status='blunderbussed'
logger.info("blunderbussed")
db.session.commit()
# Check all pending txs whose received inputs = True
pending_txs = db.session.query(Tx).filter(Tx.received_inputs==True,
Tx.outputs_sent==False).all()
logger.info(str(len(pending_txs))+" pending transactions")
for tx in pending_txs:
sent = controller.focus_cloud(destination=tx.destination,
amount=tx.amount,
exclude_parents=[tx.parent,tx.origin])
if sent:
tx.outputs_sent = True
logger.info("tx sent")
db.session.commit()
def enviado(filename): #function to see sent volume
addr = loadfile(filename)
tt_sent = 0.
for address in addr:
addr_stats = blockexplorer.get_address(address)
tt_sent += addr_stats.total_sent * 10**(-8)
#print balance
return round(tt_sent, 8)
def check_for_update(self, last_tx_time_old, address):
api_address = blockexplorer.get_address(address)
api_transactions = api_address.transactions
last_tx_time = api_transactions[1].time
if last_tx_time_old < last_tx_time:
return True
else:
return False
def saldo(filename): # fuction to see balance of N addresses
addr = loadfile(filename)
balance = 0.
for address in addr:
addr_stats = blockexplorer.get_address(address)
balance += addr_stats.final_balance * 10**(-8)
#print balance
return round(balance, 8)
def __traverse(self, address):
try:
node = blockexplorer.get_address(str(address))
next = set([
output.address for transaction in node.transactions
for output in transaction.outputs
])
print('test')
return node.transactions, next
except blockchain.exceptions.APIException:
return None, set()
def get_address(address):
try:
addr = be.get_address(address, api_code=app.api_code)
tx = addr.transactions
except APIException as e:
print('Error ' + str(e))
return render_template('address.html',
addr=addr,
tx=tx,
current_time=datetime.now().strftime('LLL'))
def check_for_update(self):
api_address = blockexplorer.get_address(self.address)
api_transactions = api_address.transactions
if self.n_tx < api_address.n_tx:
self.total_received = api_address.total_received
self.total_sent = api_address.total_sent
self.balance = api_address.final_balance
self.n_tx = api_address.n_tx
self.last_tx_date = api_transactions[0].time
return True
else:
return False
def get_bitcoin_wallet():
address = blockexplorer.get_address(e1.get())
var.set(address.final_balance)
resultlabel.set("Current Balance:")
hashlabel.set("Transaction History:")
stringer = ''
transactions = address.transactions
for trans in transactions:
timestamp = trans.time
fixedtime = datetime.datetime.fromtimestamp(timestamp)
fixer = fixedtime.strftime('%Y-%m-%d %H:%M:%S')
stringer = stringer + "hash: " + trans.hash + "\ntime: " + fixer + "\nip relay: " + str(trans.relayed_by) + "\n"
hashlist.set(stringer)
def transactions(addr):
address = blockexplorer.get_address(addr)
transactionsAll = []
print("TRANSACTIONS of " + str(addr))
for trans in address.transactions:
#(input,output) = listInOut(trans.hash)
transactionsAll.append(trans)
return transactionsAll[::-1]
def blockexplorer(self):
block = blockexplorer.get_block(
'000000000000000016f9a2c3e0f4c1245ff24856a79c34806969f5084f410680')
tx = blockexplorer.get_tx(
'd4af240386cdacab4ca666d178afc88280b620ae308ae8d2585e9ab8fc664a94')
blocks = blockexplorer.get_block_height(2570)
address = blockexplorer.get_address(
'1HS9RLmKvJ7D1ZYgfPExJZQZA1DMU3DEVd')
xpub = None #blockexplorer.get_xpub('xpub6CmZamQcHw2TPtbGmJNEvRgfhLwitarvzFn3fBYEEkFTqztus7W7CNbf48Kxuj1bRRBmZPzQocB6qar9ay6buVkQk73ftKE1z4tt9cPHWRn')
addresses = None # blockexplorer.get_multi_address('1HS9RLmKvJ7D1ZYgfPExJZQZA1DMU3DEVd', 'xpub6CmZamQcHw2TPtbGmJNEvRgfhLwitarvzFn3fBYEEkFTqztus7W7CNbf48Kxuj1bRRBmZPzQocB6qar9ay6buVkQk73ftKE1z4tt9cPHWRn')
outs = blockexplorer.get_unspent_outputs(
'1HS9RLmKvJ7D1ZYgfPExJZQZA1DMU3DEVd')
latest_block = blockexplorer.get_latest_block()
txs = blockexplorer.get_unconfirmed_tx()
blocks_by_name = None #blockexplorer.get_blocks(pool_name = 'Discus Fish')
def get(self, address, request):
'''
@return
hash160 : str
address : str
n_tx : int
total_received : int
total_sent : int
final_balance : int
transactions : array of Transaction objects
'''
from blockchain import blockexplorer
address_data = blockexplorer.get_address(address)
content = {'data': address_data}
return Response(content)
def buildSankey(exploredAddresses, edge_factory, edges, address):
# print 'explored:', exploredAddresses
# print 'address:', address
address_string = address
address_object = blockexplorer.get_address(address_string)
transactions = address_object.transactions
unexploredAddresses = {}
for t in transactions:
inputs = t.inputs
outputs = t.outputs
createLeavingEdges(exploredAddresses, unexploredAddresses, edge_factory, edges, address_string, inputs, outputs)
createIncomingEdges(exploredAddresses, unexploredAddresses, edge_factory, edges,address_string,inputs,outputs)
exploredAddresses.add(address_string)
result = printSankeyInfo(edge_factory, edges)
return result, exploredAddresses
def getSankey(address):
unexploredAddresses = {}
exploredAddresses = set()
edges = []
edge_factory = EdgeFactory()
# address_string = popUnexploredAddress(unexploredAddresses)
address_string = address
address_object = blockexplorer.get_address(address_string)
transactions = address_object.transactions
for t in transactions:
inputs = t.inputs
outputs = t.outputs
createLeavingEdges(exploredAddresses, unexploredAddresses, edge_factory, edges, address_string, inputs, outputs)
createIncomingEdges(exploredAddresses, unexploredAddresses, edge_factory, edges, address_string, inputs, outputs)
exploredAddresses.add(address_string)
result = printSankeyInfo(edge_factory, edges)
return result, exploredAddresses
def get_utxo_set(address: str, testnet: bool = False) -> List[str]:
"""
Retrieves UTXO (unspent transaction outputs) for a given address
This is used to determine output amounts and fees.
UTXOs are pulled from online block explorers
Args:
address: bitcoin address in Base58Check encoding (standard address format)
testnet: Is the address on testnet or mainnet?
Returns:
List of Output Dict objects with txid, n, and amount keys
Example:
TODO
"""
if testnet:
util.BASE_URL = "https://testnet.blockchain.info/"
else:
util.BASE_URL = "https://blockchain.info/"
transactions = BlockExplorer.get_address(address).transactions
utxos = []
for tx in transactions:
for utxo in tx.outputs:
if not utxo.spent and utxo.address == address:
utxos.append({"txid": tx.hash, "n": utxo.n, "amount":utxo.value})
for utxo in utxos:
url = util.BASE_URL + "tx/" + utxo['txid'] + "?format=hex"
res = requests.get(url=url)
utxo['rawRefTx'] = res.content.decode()
return utxos
def extractTransactionLists(ownAddress):
TxReceivedList = []
TxSentList = []
transactionList = []
stepsize = 50
address = blockexplorer.get_address(ownAddress, limit=stepsize)
nTx = address.n_tx
for i in range(0, nTx, stepsize):
print(i)
address = blockexplorer.get_address(ownAddress,
limit=stepsize,
offset=i)
transactionList += address.transactions
print("No. Tx: " + str(address.n_tx))
print("len: " + str(len(transactionList)))
finalBalance = 0
totalSent = 0
totalReceived = 0
for tx in transactionList:
date = datetime.datetime.fromtimestamp(tx.time)
dateFormatted = date.strftime('%Y-%m-%d %H:%M:%S')
print(dateFormatted)
print(tx.hash)
print("inputs")
txVal = 0
for input in tx.inputs:
print(str(input.address) + " | value: " + str(input.value))
if str(input.address) == ownAddress:
txVal -= input.value
print("outputs")
for output in tx.outputs:
print(
str(output.address) + " | value: " + str(output.value) +
" | " + str(output.spent))
if str(output.address) == ownAddress:
txVal += output.value
if (txVal < 0):
totalSent -= txVal #negative
TxSentList.append(TxSent(date, txVal))
else:
totalReceived += txVal #positive
TxReceivedList.append(TxReceived(date, txVal))
print("txVal: " + str(txVal)
) # if negative: sent |txVal|, if positive: received |txVal|
finalBalance += txVal
print("#################################################")
if (address.total_received == totalReceived
and address.total_sent == totalSent
and address.final_balance == finalBalance):
print("OK!")
else:
print("ERROR!")
TxReceivedList.reverse()
TxSentList.reverse()
return TxReceivedList, TxSentList
#!/usr/bin/python3
# Author: James Campbell
# Date: November 22 2015
# What: Accesses the blockchain module and queries some data as example
import sys
from sys import exit
import datetime
from blockchain import blockexplorer
# example address test
address = blockexplorer.get_address('1SDude3hVWoAT2sFxy3JkH2VrcUXPM4PA')
if len(sys.argv) > 1: # you can pass a bitcoin address in from terminal
print(sys.argv[1])
address = blockexplorer.get_address(sys.argv[1])
print(address)
# final balance
print(address.final_balance) # add decimal after first
transactions = address.transactions
for trans in transactions:
print(trans.relayed_by) # print ip address of the relayed transaction
print(trans.hash) # hash of the transaction
print(trans.time) # time of the transaction
timestamp = trans.time
fixedtime = datetime.datetime.fromtimestamp(timestamp)
fixer = fixedtime.strftime('%Y-%m-%d %H:%M:%S')
print('Converted time:', fixedtime.strftime('%Y-%m-%d %H:%M:%S'))
# inventory only works for transactions up to 1 hour old
# inv = blockexplorere.get_inventory_data(trans.hash)
# print('Time: %s Initial IP: %s' % (fixer, inv.initial_ip))
exit()
### Importing modules for Blockchain Interaction, Referance: https://github.com/blockchain/api-v1-client-python
from blockchain import blockexplorer
from blockchain import statistics
### Gaining access to 1 google spreadsheet, in this case name = "BTC"
json_key = json.load(open('gspreadtest-2f9b2a153d04.json'))
scope = ['https://spreadsheets.google.com/feeds']
credentials = SignedJwtAssertionCredentials(json_key['client_email'], json_key['private_key'], scope)
gc = gspread.authorize(credentials)
btc = gc.open("BTC").sheet1
### Pulling data from Bitcoin Blockchain
address = blockexplorer.get_address('16RyYkFi7fkqFD9KP6NdYcSsZj77EHABaf')
### Putting data onto Google Spreadhseets
### btc.update_acell('A2', address.final_balance )
print address.total_received
for x in address.transactions:
pos = address.transactions.index(x)
btc.update_acell('A' + str(pos + 1), address.transactions[pos].outputs[0].value)
print x.outputs[0].value
# Coinbase # root_address = '17bWK1kGySckEV7jpNBHUmHuX1UoHeHoAs' # Circle # root_address = '1LZpJP5zKGAXnH4SnJF98cVn7sBHJroViG' # Multibit to Circle # root_address = '1DJv4wgJXCwK4m2BEmjg5P4meYKhKtcp9K' # Circle Afterwards root_address = '1PyZX9JTfs3vgnN2MRJTk9rH2f7aG7ukoR' unexploredAddresses[root_address] = 1 # Explore an address, create edges in/out of this address for i in range(4): address_string = popUnexploredAddress(unexploredAddresses) address_object = blockexplorer.get_address(address_string) transactions = address_object.transactions for t in transactions: inputs = t.inputs outputs = t.outputs createLeavingEdges(exploredAddresses, unexploredAddresses, edge_factory, edges, address_string, inputs, outputs) createIncomingEdges(exploredAddresses, unexploredAddresses, edge_factory, edges,address_string,inputs,outputs) exploredAddresses.add(address_string) # Create input string for Sankey diagram given edges and edge_factory node_list_result = ''
input_index = i
# Traverse blockchain to update lock ownership if credentials are outdated
if input_index == -1:
try:
utxo = blockexplorer.get_unspent_outputs(self.public_address)
tx_hashes = [str(i.tx_hash) for i in utxo]
if any(self.transaction in tx_hashes):
return 'Not Updated'
else:
self.updateLock(1)
except blockchain.exceptions.APIException:
response = 'go'
j = 0
while response == 'go':
old_address = blockexplorer.get_address(self.public_address)
outputs = old_address.transactions[0].outputs
scripts = [str(i.script) for i in outputs]
num_inputs = len(old_address.transactions[0].inputs)
output_index = self.ProcessTransaction(scripts, True,num_inputs)
if output_index is None:
output_index = 0
else:
output_index = int(output_index)
last_trans_output = old_address.transactions[0].outputs[output_index]
included_block = old_address.transactions[0].block_height
latest_block = blockexplorer.get_latest_block()
if (latest_block.height - included_block < 3):
if j == 0:
return 'Not Updated because of lack of confidence'
def wallet():
address = blockexplorer.get_address('xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx')
return render_template('wallet', address=address)
def user_crypto_balance(request):
user = MyUser.objects.get(username=request.user.username)
btc_user_info = blockexplorer.get_address(user.crypto_wallet)
btc_balance = btc_user_info.final_balance / 100000000
return btc_balance
def updateLock(self, num):
""" Checks and updates lock if ownernship has changed
:return: Result of checking and updating lock ownership
"""
try:
utxo = blockexplorer.get_unspent_outputs(self.public_address)
tx_hashes = [str(i.tx_hash) for i in utxo]
if any(self.transaction in tx_hashes):
return 'Not Updated'
else:
response = 'go'
j = 0
while response == 'go':
old_address = blockexplorer.get_address(self.public_address)
outputs = old_address.transactions[0].outputs
scripts = [str(i.script) for i in outputs]
num_inputs = len(old_address.transactions[0].inputs)
output_index = self.ProcessTransaction(scripts, True,num_inputs)
if output_index is None:
output_index = 0
else:
output_index = int(output_index)
last_trans_output = old_address.transactions[0].outputs[output_index]
included_block = old_address.transactions[0].block_height
latest_block = blockexplorer.get_latest_block()
if (latest_block.height - included_block < 3):
if j == 0:
return 'Not Updated because of lack of confidence'
if j > 0:
if trans == str(old_address.transaction[0].hash):
return 'Not enough confidence in provided transaction (updated to new address though)'
else:
return 'Not enough confidence but not in the provided transaction (updated to new address though)'
self.public_address = str(last_trans_output.address)
self.transaction = str(old_address.transactions[0].hash)
try:
utxo_2 = blockexplorer.get_unspent_outputs(self.public_address)
tx_hashes_2s = [str(i.tx_hash) for i in utxo_2]
if any(self.transaction in tx_hashes_2):
reponse = 'exit'
except blockchain.exceptions.APIException:
j = j + 1
f = open('lock.txt','w')
f.write(self.transaction)
f.write('\n')
f.write(self.public_address)
f.close()
return 'Updated but not with transaction provided'
except blockchain.exceptions.APIException:
response = 'go'
j = 0
while response == 'go':
old_address = blockexplorer.get_address(self.public_address)
outputs = old_address.transactions[0].outputs
scripts = [str(i.script) for i in outputs]
num_inputs = len(old_address.transactions[0].inputs)
output_index = self.ProcessTransaction(scripts, True,num_inputs)
if output_index is None:
output_index = 0
else:
output_index = int(output_index)
last_trans_output = old_address.transactions[0].outputs[output_index]
included_block = old_address.transactions[0].block_height
latest_block = blockexplorer.get_latest_block()
if (latest_block.height - included_block < 3):
if j == 0:
return 'Not Updated because of lack of confidence'
if j > 0:
if trans == str(old_address.transaction[0].hash):
return 'Not enough confidence in provided transaction (updated to new address though)'
else:
return 'Not enough confidence but not in the provided transaction (updated to new address though)'
self.public_address = str(last_trans_output.address)
self.transaction = str(old_address.transactions[0].hash)
try:
blockexplorer.get_unspent_outputs(self.public_address)
reponse = 'exit'
except blockchain.exceptions.APIException:
j = j + 1
f = open('lock.txt','w')
f.write(self.transaction)
f.write('\n')
f.write(self.public_address)
f.close()
return 'Updated but not with transaction provided'
def get_users():
whales_address = list()
for u in __class__.top_10:
whales_address.append(blockexplorer.get_address(u))
return whales_address
def balance(address): # fuction to see balance for 1 address
address_stats = blockexplorer.get_address(address)
balance = float(address_stats.final_balance) * 10**(-8)
return round(balance, 8)
# Coinbase
# root_address = '17bWK1kGySckEV7jpNBHUmHuX1UoHeHoAs'
# Circle
# root_address = '1LZpJP5zKGAXnH4SnJF98cVn7sBHJroViG'
# Multibit to Circle
# root_address = '1DJv4wgJXCwK4m2BEmjg5P4meYKhKtcp9K'
# Circle Afterwards
root_address = '1PyZX9JTfs3vgnN2MRJTk9rH2f7aG7ukoR'
unexploredAddresses[root_address] = 1
# Explore an address, create edges in/out of this address
for i in range(4):
address_string = popUnexploredAddress(unexploredAddresses)
address_object = blockexplorer.get_address(address_string)
transactions = address_object.transactions
for t in transactions:
inputs = t.inputs
outputs = t.outputs
createLeavingEdges(exploredAddresses, unexploredAddresses,
edge_factory, edges, address_string, inputs,
outputs)
createIncomingEdges(exploredAddresses, unexploredAddresses,
edge_factory, edges, address_string, inputs,
outputs)
exploredAddresses.add(address_string)
# Create input string for Sankey diagram given edges and edge_factory
def checkbalance():
val = blockexplorer.get_address(add)
realval = float(val.final_balance) / 100000000
return realval
def post(self, request):
'''Takes given address and validates.
If address is not in base - saves it create new Address object and saves all transactions.
Creates QRcode and returns template.
If address is in base - checks if all transactions are in base and returns template.
If some transactions are missing deletes object from base and creates new one with all transactions.
'''
form = AddressForm(request.POST)
if form.is_valid():
form_address = form.cleaned_data['address']
start_date = form.cleaned_data['start_date']
end_date = form.cleaned_data['end_date']
api_address = blockexplorer.get_address(form_address)
base_address = TransactionView.get_object(form_address)
img = pyqrcode.create(form_address)
img.png('bc_app/static/QRcode.png', scale=3)
if base_address:
if len(base_address.transactions.all()) == len(api_address.transactions):
transactions = TransactionView.transaction_search(base_address, start_date, end_date)
return render(request, template_name='base.html', context={'address': base_address,
'form': form,
'start_date': start_date,
'end_date': end_date,
'transactions': transactions})
else:
base_address.delete()
base_address = Address.objects.create(
address=api_address.address,
hash160=api_address.hash160,
final_balance=api_address.final_balance,
n_tx=api_address.n_tx,
total_received=api_address.total_received,
total_sent=api_address.total_sent
)
for transaction in api_address.transactions:
inputs_str = json.dumps(transaction.inputs, default=lambda o: o.__dict__)
inputs_data = json.loads(inputs_str)
outputs_str = json.dumps(transaction.outputs, default=lambda o: o.__dict__)
outputs_data = json.loads(outputs_str)
Transaction.objects.create(
block_height=transaction.block_height,
double_spend=transaction.double_spend,
hash=transaction.hash,
relayed_by=transaction.relayed_by,
size=transaction.size,
time=transaction.time,
tx_index=transaction.tx_index,
version=transaction.version,
inputs=inputs_data,
outputs=outputs_data,
address=base_address
)
transactions = TransactionView.transaction_search(base_address, start_date, end_date)
return render(request, template_name='base.html', context={'address': base_address,
'form': form,
'start_date': start_date,
'end_date': end_date,
'transactions': transactions})
return render(request, template_name='base.html', context={'form': form})
#!/usr/bin/python3
import time
import CryptographyFunctions
from blockchain import blockexplorer
# maybe try with websockets later on // https://www.blockchain.com/api/api_websocket
# my wallet actual address
botmasterAddress = '1GgH68gphSF1JHASKa7goET23sHwPqLJFD'
# a test address
botmasterAddress = '3Nzz16cQdmKDmPkNtsjpUP5uqCwg4i4wN7'
keyForSubliminalDecryption = ''
# get the list of Bot master trxs
EncodedTransactionsList = blockexplorer.get_address(
botmasterAddress).transactions
transactionsFromMaster = len(EncodedTransactionsList)
print("1st -- transactionsFromMaster -- : ", transactionsFromMaster)
DecodedTransactionsList = []
# this command returns the first transaction as shown in the website
# print("block is --> ", address.transactions[0])
# inputs is an array of people who contributed in this trx
# outputs is an array of people who received money from this trx
# print("block is --> ", address.transactions[0].inputs[0].address)
# print("block is --> ", EncodedTransactionsList[0].hash)
# for the thesis we may need to check only unconfirmed trxs of botmaster
# 1. try getting new transactions generated by the bot master
# 2. store them in a list
# 3. try decoding them (
# if success :
#!/usr/bin/python3
# Author: James Campbell
# Date: 2015-11-22
# Date Updated: 2019-06-19
# What: Accesses the blockchain module and queries some data as example
import sys
from sys import exit
import datetime
from blockchain import blockexplorer
# example address test
address = blockexplorer.get_address("1SDude3hVWoAT2sFxy3JkH2VrcUXPM4PA")
if len(sys.argv) > 1: # you can pass a bitcoin address in from terminal
print(sys.argv[1])
address = blockexplorer.get_address(sys.argv[1])
print(address)
# final balance
print(f"\nFinal balance of wallet: {address.final_balance}"
) # add decimal after first
transactions = address.transactions
print(
f"\nList of {len(transactions)} transactions: \n -----------------------------"
)
for trans in transactions:
print(f"Ip address of relayed transaction: {trans.relayed_by}"
) # print ip address of the relayed transaction
print(f"Hash of the transaction: {trans.hash}") # hash of the transaction
print(f"Time of the transaction: {trans.time}") # time of the transaction
timestamp = trans.time
fixedtime = datetime.datetime.fromtimestamp(timestamp)
fixer = fixedtime.strftime("%Y-%m-%d %H:%M:%S")
def get_wallet_amount(wallet):
return sat_to_btc(get_address(wallet).total_received)
