def prepare_addresses(self, current_block_nr):
""" Runs the recognition algorithm for future blocks in order to build up a set of known addresses """
nr_of_async_blocks = 10
async_requester = Async_requester()
number_of_blocks = Settings.get_preparation_range("BTC")
start_block = current_block_nr + number_of_blocks
current_number = start_block
while current_number > current_block_nr:
print("Check " + str(nr_of_async_blocks) + " blocks from:" +
str(current_number))
if (current_number - current_block_nr) > nr_of_async_blocks:
async_requester.add_request_data("BTC", current_number,
nr_of_async_blocks)
else:
async_requester.add_request_data(
"BTC", current_number, current_number - current_block_nr)
new_blocks = async_requester.get_multiple_blocks()
current_number = current_number - nr_of_async_blocks
for new_transactions in new_blocks:
for transaction in new_transactions:
self.recognize(transaction)
print("Number of single addresses: " +
str(len(self.shapeshift_single_addresses)))
# Save all found adresses
for address in self.shapeshift_middle_addresses:
Database_manager.insert_shapeshift_address_btc(address, "middle")
for address in self.shapeshift_single_addresses:
Database_manager.insert_shapeshift_address_btc(address, "single")
def __init__(self):
self.shapeshift_main_addresses = Settings.get_main_addresses()
self.shapeshift_middle_addresses = Database_manager.get_all_shapeshift_middle_addresses_btc(
"middle")
self.shapeshift_single_addresses = Database_manager.get_all_shapeshift_middle_addresses_btc(
"single")
self.shapeshift_stop_addresses = Settings.get_trading_platform_addresses(
)
self.shapeshift_stop_hashes = Settings.get_hashes_to_block()
def recognize_and_categorize(self, exchange_transaction):
""" Recognizes if the given transaction is related to Shapeshift and classifies it """
for tx_output in exchange_transaction["outputs"]:
if tx_output["address"] in self.shapeshift_main_addresses \
or tx_output["address"] in self.shapeshift_middle_addresses \
or tx_output["address"] in self.shapeshift_single_addresses:
#Check if input from trading platform. If yes, ignore tx
ignore = False
for tx_input in exchange_transaction["inputs"]:
if tx_input["address"] in self.shapeshift_stop_addresses:
ignore = True
break
if ignore:
pass
elif tx_output["address"][0] != "3" or tx_output[
"address"] in self.shapeshift_main_addresses:
if not (exchange_transaction["hash"]
in self.shapeshift_stop_hashes):
# Delete Shapeshift Address from Outputs (and leave only User Address(es))
exchange_transaction["outputs"].remove(tx_output)
exchange_transaction["is_exchange_deposit"] = False
exchange_transaction["is_exchange_withdrawl"] = True
for tx_input in exchange_transaction["inputs"]:
if not(tx_input["address"] in self.shapeshift_main_addresses) \
and not(tx_input["address"] in self.shapeshift_middle_addresses):
# Check if input address was already used and move from single to middle class.
if tx_input[
"address"] in self.shapeshift_single_addresses:
self.shapeshift_single_addresses.remove(
tx_input["address"])
self.shapeshift_middle_addresses.add(
tx_input["address"])
else:
self.shapeshift_single_addresses.add(
tx_input["address"])
Database_manager.insert_relation(
tx_input["address"],
tx_output["address"],
exchange_transaction["hash"])
else:
# Leave only Shapeshift Address in Outputs
exchange_transaction["outputs"] = [tx_output]
exchange_transaction["is_exchange_deposit"] = True
exchange_transaction["is_exchange_withdrawl"] = False
# Delete single addresses after analysing transaction, because no more needed
for tx_output_delete in exchange_transaction["outputs"]:
if tx_output_delete[
"address"] in self.shapeshift_single_addresses:
self.shapeshift_single_addresses.remove(
tx_output_delete["address"])
return exchange_transaction
return exchange_transaction
def main(address_to_prove):
""" Track from where an address originated. Goes back the path taken by the address recognition """
address_to_search = str(address_to_prove)
print("start with " + address_to_search)
Database_manager.initialize_db()
rels = Database_manager.get_relations(address_to_search)
while rels:
curr_addr = rels[0][2]
print("From: INPUT:" + str(rels[0][1]) + ", OUTPUT " +
str(rels[0][2]) + ", HASH: " + str(rels[0][3]))
rels = Database_manager.get_relations(curr_addr)
def main():
""" Runs the recognition process from the given block number """
start_time = time.time()
Database_manager.initialize_db()
Database_manager.create_table_shapeshift_addresses_btc()
address_tracker = Address_tracker_btc()
address_tracker.prepare_addresses(511557)
print("Duration: " + str(time.time() - start_time))
print("finish")
def recognize(self, exchange_transaction):
""" Recognizes if the given transaction is related to Shapeshift and saves new addresses """
for tx_output in exchange_transaction["outputs"]:
if tx_output["address"] in self.shapeshift_main_addresses \
or tx_output["address"] in self.shapeshift_middle_addresses \
or tx_output["address"] in self.shapeshift_single_addresses:
#Check if input from trading platform. If yes, ignore tx
ignore = False
for tx_input in exchange_transaction["inputs"]:
if tx_input["address"] in self.shapeshift_stop_addresses:
ignore = True
break
if ignore:
pass
elif tx_output["address"][0] != "3" or tx_output[
"address"] in self.shapeshift_main_addresses:
if not (exchange_transaction["hash"]
in self.shapeshift_stop_hashes):
for tx_input in exchange_transaction["inputs"]:
if not(tx_input["address"] in self.shapeshift_main_addresses)\
and not(tx_input["address"] in self.shapeshift_middle_addresses):
# Check if input address was already used and move from single to middle class
if tx_input[
"address"] in self.shapeshift_single_addresses:
print("Adding new MIDDLE Address: " +
str(tx_input["address"]))
self.shapeshift_single_addresses.remove(
tx_input["address"])
self.shapeshift_middle_addresses.add(
tx_input["address"])
else:
print("Adding new SINGLE Address: " +
str(tx_input["address"]))
self.shapeshift_single_addresses.add(
tx_input["address"])
Database_manager.insert_relation(
tx_input["address"],
tx_output["address"],
exchange_transaction["hash"])
for tx_output_delete in exchange_transaction["outputs"]:
if tx_output_delete[
"address"] in self.shapeshift_single_addresses:
self.shapeshift_single_addresses.remove(
tx_output_delete["address"])
return
def __init__(self, parent=None):
super(Ui_MainWindow, self).__init__(parent)
self.ab = dm.Database_manage()
self.ab.init('HCI_Database', 'QSQLITE')
self.f = fr.Face_Thread()
self.r = rm.Rec_Thread()
self.num_iter = 0
self.setupUi(self)
self.setFixedSize(320, 380)
def save_all_addresses(self):
""" Saves all identified addresses to the DB """
Database_manager.create_table_shapeshift_addresses_btc_end()
for address in self.shapeshift_middle_addresses:
Database_manager.insert_shapeshift_address_btc_end(
address, "middle")
for address in self.shapeshift_single_addresses:
Database_manager.insert_shapeshift_address_btc_end(
address, "single")
def main():
""" Main method which runs the tool from the given block numbers """
start = time.time()
print ("starting time: " + str(start))
# Create MySQL Database and connect
Database_manager.initialize_db()
# Create MySQL Tables
Database_manager.create_table_exchanges()
Database_manager.create_table_shapeshift_addresses_btc()
# Delete all data from DB
Database_manager.delete_all_data()
# Find Exchanges
print ("Searching for Exchanges...")
currencies_list = ["BTC", "ETH"]
# February data
current_block_number_dict = {"BTC": 511557, "ETH": 5180422}
exchange_finder = Exchange_finder(currencies_list, current_block_number_dict=current_block_number_dict)
exchange_finder.find_exchanges()
print("Duration: " + str(time.time() - start))
def main():
# Create MySQL Database and connect
Database_manager.initialize_db()
# Create MySQL Tables
Database_manager.create_table_shapeshift()
Database_manager.create_table_cmc()
Database_manager.create_table_exchanges()
previous_exchanges = []
# Dalete all data from DB
Database_manager.delete_all_data()
# Update Coinmarketcap data
last_time_updated_cmc = update_cmc(None)
# Update Shapeshift
last_time_updated_ss = update_ssf(None)
while True:
result = Shapeshift.get_last_transactions(previous_exchanges)
if result:
new_exchanges = result["new_exchanges"]
# After every loop: Wait the half of the duration of retrieved 50 Txs
duration_to_wait = result["duration"].total_seconds()/2
if new_exchanges:
print ("Starting loop: " + str(datetime.datetime.now()))
start_time = time.time()
# Update Coinmarketcap data
last_time_updated_cmc = update_cmc(last_time_updated_cmc)
# Update Shapeshift
last_time_updated_ss = update_ssf(last_time_updated_ss)
previous_exchanges = new_exchanges
print ("Search for Ethereum Txs...")
left_transactions_eth = Ether.get_ethereum_transaction(new_exchanges)
if left_transactions_eth:
Ether.get_ethereum_transaction_infura(left_transactions_eth)
print ("Search for Litecoin Txs...")
left_transactions_ltc = Litecoin.get_litecoin_transaction(new_exchanges)
if left_transactions_ltc:
time.sleep(50)
Litecoin.get_litecoin_transaction(left_transactions_ltc)
print ("Search for Bitcoin Txs...")
left_transactions_btc = Bitcoin.get_bitcoin_transaction(new_exchanges)
if left_transactions_btc:
#time.sleep(30)
Bitcoin.get_bitcoin_transaction(left_transactions_btc)
print ("Finished loop: " + str(datetime.datetime.now()))
elapsed_time = time.time() - start_time
if elapsed_time < duration_to_wait:
print ("Done! Wait " + str(duration_to_wait - elapsed_time) + " seconds")
time.sleep(duration_to_wait - elapsed_time)
else:
print ("No Transactions. Wait " + str(duration_to_wait) + " seconds")
time.sleep(duration_to_wait)
else:
print ("Retrieving Transactions from Shapeshift didn't work")
time.sleep(180)
import numpy
from sklearn.svm.classes import SVC
import Features_manager
import Database_manager
from sklearn.metrics.classification import precision_recall_fscore_support, accuracy_score
import csv
#initializate database_manager
database_manager = Database_manager.make_database_manager()
#initializate feature_manager
feature_manager = Features_manager.make_feature_manager()
tweets_training = numpy.array(database_manager.return_tweets_training())
labels_training = numpy.array(feature_manager.get_label(tweets_training))
tweets_test = numpy.array(database_manager.return_tweets_test())
#labels_test=numpy.array(feature_manager.get_label(tweets_test))
#feature_type=feature_manager.get_availablefeaturetypes()
feature_type = [
"ngrams", "chargrams", "deprel", "Sidorovbigramsform",
"Sidorovbigramsdeprel"
]
print("train: ", len(tweets_training))
print("test: ", len(tweets_test))
X, X_test, feature_name, feature_index = feature_manager.create_feature_space(
tweets_training, feature_type, tweets_test)
def save_found_exchanges(self):
""" Saves all transaction pairs found to the DB with one command """
if self.current_exchanges_found:
Database_manager.insert_multiple_exchanges(
self.current_exchanges_found)
self.current_exchanges_found = []
