scan_electrums.py

scan_electrums.py

#!/usr/bin/env python3
import os
import ssl
import json
import time
import socket
import requests
import threading
from pprint import pprint

ignore_list = []
passed_electrums = {}
passed_electrums_ssl = {}
failed_electrums = {}
failed_electrums_ssl = {}

socket.setdefaulttimeout(10)
coins_repo_data = requests.get('https://raw.githubusercontent.com/KomodoPlatform/coins/update_electrums/coins').json()
coins_to_check = []
for i in coins_repo_data:
    coins_to_check.append(i["coin"])

def colorize(string, color):
    colors = {
            'red':'\033[31m',
            'green':'\033[32m'
    }
    if color not in colors:
            return str(string)
    else:
            return colors[color] + str(string) + '\033[0m'


def get_from_electrum(url, port, method, params=None):
    if params:
        params = [params] if type(params) is not list else params
    try:
        with socket.create_connection((url, port)) as sock:
            payload = {"id": 0, "method": method}
            if params:
                payload.update({"params": params})
            sock.send(json.dumps(payload).encode() + b'\n')
            time.sleep(3)
            resp = sock.recv(999999)[:-1].decode()
            return resp
    except Exception as e:
        return e


def get_from_electrum_ssl(url, port, method, params=None):
    if params:
        params = [params] if type(params) is not list else params
    context = ssl.SSLContext(verify_mode=ssl.CERT_NONE)
    try:
        with socket.create_connection((url, port)) as sock:
            with context.wrap_socket(sock, server_hostname=url) as ssock:
                payload = {"id": 0, "method": method}
                if params:
                    payload.update({"params": params})
                ssock.send(json.dumps(payload).encode() + b'\n')
                time.sleep(3)
                resp = ssock.recv(999999)[:-1].decode()
                return resp
    except Exception as e:
        return e


class electrum_thread(threading.Thread):
    def __init__(self, coin, ip, port, method, params=None, is_ssl=False):
        threading.Thread.__init__(self)
        self.coin = coin
        self.ip = ip
        self.port = port
        self.method = method
        self.params = params
        self.is_ssl = is_ssl
    def run(self):
        if self.is_ssl:
            thread_electrum_ssl(self.coin, self.ip, self.port, self.method, self.params)
        else:
            thread_electrum(self.coin, self.ip, self.port, self.method, self.params)


def thread_electrum(coin, ip, port, method, params):
    resp = get_from_electrum(ip, port, method, params)
    try:
        resp_json = json.loads(resp)['result']
        # print(resp_json)
        print(colorize(f"{coin} {ip}:{port} OK!", 'green'))
        if coin not in passed_electrums:
            passed_electrums.update({coin:[]})
        passed_electrums[coin].append(f"{ip}:{port}")

    except Exception as e:
        if coin not in failed_electrums:
            failed_electrums.update({coin:{}})
        failed_electrums[coin].update({f"{ip}:{port}": f"{resp}"})
        print(colorize(f"{coin} {ip}:{port} Failed! {e} | {resp}", 'red'))


def thread_electrum_ssl(coin, ip, port, method, params):
    resp = get_from_electrum_ssl(ip, port, method, params)
    try:
        resp_json = json.loads(resp)['result']
        # print(resp_json)
        print(colorize(f"{coin} {ip}:{port} OK!", 'green'))
        if coin not in passed_electrums_ssl:
            passed_electrums_ssl.update({coin:[]})
        passed_electrums_ssl[coin].append(f"{ip}:{port}")

    except Exception as e:
        if coin not in failed_electrums_ssl:
            failed_electrums_ssl.update({coin:{}})
        failed_electrums_ssl[coin].update({f"{ip}:{port}": f"{resp}"})
        print(colorize(f"{coin} {ip}:{port} Failed! {e} | {resp}", 'red'))


def scan_electrums():
    thread_list = []
    non_ssl_list = []
    endpoint = f"http://116.203.120.91:8762/api/info/electrums/"
    all_electrums = requests.get(f"{endpoint}").json()["results"]
    for coin in all_electrums:
        if coin in coins_to_check:
            electrums = all_electrums[coin]
            for electrum in electrums:
                non_ssl_list.append(coin)
                url, port = electrum.split(":")[:2]
                thread_list.append(electrum_thread(coin, url, port, "blockchain.block.headers", [1,2]))
        else:
            ignore_list.append(coin)
    for thread in thread_list:
        thread.start()
        time.sleep(0.1)
    return set(non_ssl_list)


def scan_electrums_ssl():
    thread_list = []
    ssl_list = []
    endpoint = f"http://116.203.120.91:8762/api/info/electrums_ssl/"
    all_electrums_ssl = requests.get(f"{endpoint}").json()["results"]
    for coin in all_electrums_ssl:
        if coin in coins_to_check:
            electrums = all_electrums_ssl[coin]
            for electrum in electrums:
                ssl_list.append(coin)
                url, port = electrum.split(":")
                thread_list.append(electrum_thread(coin, url, port, "blockchain.block.headers", [1,2], True))
        else:
            ignore_list.append(coin)
    for thread in thread_list:
        thread.start()
        time.sleep(0.1)
    return set(ssl_list)


if __name__ == '__main__':
    electrum_coins = scan_electrums()
    electrum_coins_ssl = scan_electrums_ssl()

    i = 0
    while True:
        electrums_set = set(list(passed_electrums.keys()) + list(failed_electrums.keys())) - set(ignore_list)
        electrums_ssl_set = set(list(passed_electrums_ssl.keys()) + list(failed_electrums_ssl.keys())) - set(ignore_list)
        electrums_pct = round(len(electrums_set) / len(electrum_coins) * 100, 2)
        electrums_ssl_pct = round(len(electrums_ssl_set) / len(electrum_coins_ssl) * 100, 2)
        print(f"Scan progress: {electrums_pct}% electrums,  {electrums_ssl_pct}% electrums_ssl, ")
        if electrums_set == electrum_coins:
            if electrums_ssl_set == electrum_coins_ssl:
                break
        if i > 60:
            print("Loop expired incomplete after 60 iterations.")
            break
        i += 1
        time.sleep(1)

    results = {
        "passed": passed_electrums,
        "passed_ssl": passed_electrums_ssl,
        "failed": failed_electrums,
        "failed_ssl": failed_electrums_ssl
    }
    with open("electrum_scan_report.json", "w+") as f:
        f.write(json.dumps(results, indent=4))

    pprint(failed_electrums)
    pprint(failed_electrums_ssl)