#!/usr/bin/env python3
##########################################
# 2023/Jan/28 by citb0in #
# https://github.com/citb0in #
# #
# This project is licensed under the #
# terms of the GPLv3 license. #
##########################################
import requests
import re
####################
# Some global vars #
####################
# Uncomment following line(s) for manually seting the difficulty/netrate to a value of your choice
#diff = 210453655497.094
#netrate = 1510000000000000000
# Number of chars to print as horizontal line separator, on a widescreen you could try 200
sep = 150
###########################
# Definitions (functions) #
###########################
def get_diff_and_netrate(diff_from_api=False,netrate_from_api=False):
"""Function for getting the current Bitcoin difficulty and network hashrate from API"""
global diff
global netrate
if 'diff' not in globals() or 'netrate' not in globals():
response = requests.get("https://mempool.space/api/v1/mining/hashrate/3d")
print("Execution de la requête API pour recevoir les informations du réseau Bitcoin...\n")
if response.status_code != 200:
raise Exception("Èchec, impossible de recevoir les données depuis API")
if 'diff' not in globals():
diff = response.json()["currentDifficulty"]
diff_from_api = True
if 'netrate' not in globals():
netrate = response.json()["currentHashrate"]
netrate_from_api = True
return diff, netrate, diff_from_api, netrate_from_api
def get_probability_single_hash():
"""Function to calculate the probability of a single hash solving a block"""
# the target represents the number of valid hashes
# ratio of all hashes over valid hashes => 2**256 / (0xffff*2**208 / D)
ratio = diff * 2**48 / 0xffff
prob = 1/ratio
return ratio, prob
def get_proportion_of_netrate(hashrate):
"""Function to set the hashrate of the solominer in relation to the total network rate"""
proportion = hashrate_raw / netrate * 100
if "e-" in str(proportion):
precision = 1
netrate_prec = int(str(proportion).split("e-")[1]) + precision
else:
netrate_prec = re.search(r"[1-9]", str(proportion)).start()
return proportion, netrate_prec
def format_input(hashrate_raw):
"""Function for formatting the input hashrate"""
hashrate_match = re.match(r'^\s*([0-9]+(?:\.[0-9]+)?)\s*([KMGTPEZY]?)\s*(H)?\s*(\/)?\s*(s|sec)?\s*$', hashrate_raw, flags=re.IGNORECASE)
if hashrate_match:
hashrate_nounit = float(hashrate_match.group(1))
hashrate_unit = hashrate_match.group(2).upper()
conversions = {'K': 1e3, 'M': 1e6, 'G': 1e9, 'T': 1e12, 'P': 1e15, 'E': 1e18, 'Z': 1e21, 'Y': 1e24}
if hashrate_unit in conversions:
hashrate_raw = hashrate_nounit*conversions[hashrate_unit]
else:
hashrate_raw = hashrate_nounit
else:
return None
return hashrate_nounit, hashrate_unit, hashrate_raw
def scale_unit(value):
"""Function for scaling to highest possible unit"""
units = ['', 'K', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y']
value = str(value)
prefix = ''
if ' ' in value:
value, prefix = value.split()
exponent = 0
while float(value) >= 1000:
value = str(float(value) / 1000)
exponent += 1
return f"{float(value):.2f} {units[exponent]}{prefix}"
def calculate_probability(hashrate):
"""Function for calculating the probability per block avg. time of 10min for use as a base"""
expected_blockhit_time = diff * 2**48 / 0xffff / hashrate_raw / 3600
expected_blockhit_rel_net = netrate / hashrate_raw * 600
prob_per_10min = hashrate_raw / (diff * 2**48 / 0xffff) * 600
prob_per_block = prob_per_10min
if "e-" in str(prob_per_10min):
# Number of desired additional decimal places
# beginning from first occurring decimal place not equal to zero
precision = 2
prob_prec = int(str(prob_per_10min).split("e-")[1]) + precision
else:
prob_prec = 3
# Define some additional time units
prob_per_hour = prob_per_block * 6
prob_per_day = prob_per_hour * 24
prob_per_week = prob_per_day * 7
prob_per_month = prob_per_day * 30
prob_per_halfyear = prob_per_day * 182.5
prob_per_year = prob_per_day * 365
return expected_blockhit_time, expected_blockhit_rel_net, prob_per_block, prob_per_hour, prob_per_day, prob_per_week, prob_per_month, prob_per_halfyear, prob_per_year, prob_prec, netrate_prec
def probability_phrase(probability):
if probability <= 0.00001:
return "plus de chances d'être frappé par un éclair"
elif probability <= 0.0001:
return "plus de chances de gagner au Lotto"
elif probability <= 0.45:
return "les chances sont contre vous en théorie"
elif probability <= 0.55:
return "aussi probable que de tirer à pile ou face et d'obtenir face."
elif probability <= 0.00001:
return "plus probable que de trouver une aiguille dans une botte de foin."
elif probability <= 0.001:
return "aussi probable que de faire un trou en un au golf."
elif probability <= 0.000001:
return "probabilité similaire à celle de trouver un grain de sable spécifique sur une plage"
elif probability <= 0.001:
return "aussi probable que d'obtenir un score parfait à un jeu de fléchettes."
elif probability <= 0.5:
return "improbable"
else:
return "plus probable que non"
def describe_probability(prob):
if prob >1:
return "une garantie, une chose sûre à 100% - vous pouvez parier votre dernier dollar là-dessus. Ça va arriver bientôt ! YEAH ! !!"
if prob >= 0.99 and prob <= 1:
return "pratiquement certain, presque une garantie - c'est similaire à la probabilité que le soleil se lève demain."
elif prob >= 0.98 and prob < 0.99:
return "extrêmement probable, presque une certitude - c'est similaire à la probabilité qu'une équipe de football gagne un match lorsqu'elle mène de 14 points à 2 minutes de la fin."
elif prob >= 0.95 and prob < 0.98:
return "très probable, hautement probable - c'est similaire à la probabilité qu'un lanceur de baseball lance un strike avec un compte de 3-2."
elif prob >= 0.9 and prob < 0.95:
return "C'est un peu comme la probabilité qu'un golfeur fasse un putt d'un mètre cinquante."
elif prob >= 0.8 and prob < 0.9:
return "plus probable que non - c'est similaire à la probabilité qu'une équipe de basket-ball réussisse un lancer franc."
elif prob >= 0.7 and prob < 0.8:
return "C'est un peu comme la probabilité qu'une équipe de football marque un touchdown dans une zone rouge."
elif prob >= 0.6 and prob < 0.7:
return "C'est un peu comme la probabilité qu'une prévision météorologique annonce de la pluie et qu'il pleuve réellement."
elif prob >= 0.5 and prob < 0.6:
return "C'est un peu comme la probabilité de tirer à pile ou face et d'obtenir pile du premier coup."
elif prob >= 0.4 and prob < 0.5:
return "assez probable - elle est similaire à la probabilité de tirer une carte rouge d'un jeu de cartes à jouer standard"
elif prob >= 0.3 and prob < 0.4:
return "moins probable que non - c'est similaire à la probabilité qu'une équipe de baseball remporte un match alors qu'elle est menée par quatre points dans le bas de la neuvième manche."
elif prob >= 0.2 and prob < 0.3:
return "improbable, tout à fait improbable - c'est un peu comme la probabilité de deviner la bonne combinaison d'une serrure à trois chiffres du premier coup."
elif prob >= 0.1 and prob < 0.2:
return "très improbable, hautement improbable - c'est comme la probabilité d'obtenir un nombre spécifique en lançant un dé juste."
elif prob >= 0.01 and prob < 0.1:
return "Extrêmement improbable - c'est comme tirer à pile ou face et obtenir pile 10 fois de suite."
elif prob >= 0.001 and prob < 0.01:
return "pratiquement impossible - c'est comme lancer une pièce de monnaie et obtenir pile 100 fois de suite."
elif prob >= 0.0001 and prob < 0.001:
return "pratiquement impossible - il est plus probable d'être frappé par la foudre deux fois au même endroit ou de recevoir une quinte royale au poker dès la première main."
elif prob >= 0.00005 and prob < 0.0001:
return "pratiquement impossible - il est plus probable d'être frappé par la foudre dans une vie."
elif prob >= 0.00001 and prob < 0.00005:
return "pratiquement impossible - c'est comme si un individu donné était frappé par la foudre plusieurs fois dans sa vie."
elif prob >= 0.000001 and prob < 0.00001:
return "pratiquement impossible - c'est comme la probabilité de gagner un prix dans une loterie avec 1 chance sur 10 millions."
elif prob >= 0.0000005 and prob < 0.000001:
return "pratiquement impossible - c'est comme la probabilité d'obtenir une combinaison spécifique de cinq numéros sur une machine à sous."
elif prob >= 0.00000005 and prob < 0.0000005:
return "pratiquement impossible - il est plus probable de gagner le jackpot de la loterie Powerball ou Mega Millions."
elif prob < 0.00000005:
return "infiniment petit - c'est similaire à la probabilité de trouver un atome spécifique parmi tous les atomes de l'univers."
else:
return "discutable ? !"
#######################################
# Program flow / variable assignments #
#######################################
# User input hash rate
hashrate_input = input("Entrer le hashrate/sec de votre équipement solo : ")
# Call the functions and fill the variables
diff, netrate, diff_from_api, netrate_from_api = get_diff_and_netrate()
diff_formatted, netrate_formatted = scale_unit(diff), scale_unit(netrate)+"H/s"
hashrate_nounit, hashrate_unit, hashrate_raw = format_input(hashrate_input)
proportion, netrate_prec = get_proportion_of_netrate(hashrate_raw)
expected_blockhit_time, expected_blockhit_rel_net, prob_per_block, prob_per_hour, prob_per_day, prob_per_week, prob_per_month, prob_per_halfyear, prob_per_year, prob_prec, netrate_prec = calculate_probability(hashrate_raw)
single_ratio, single_prob = get_probability_single_hash()
##########
# Output #
##########
print(f"{'Choisir la difficulté manuellement:' if not diff_from_api else 'La difficulté actuelle de Bitcoin est :'} {diff:,.3f} ({diff_formatted})\n{'Hashrate total du réseau Bitcoin:' if not netrate_from_api else 'Le hashrate total de tout le réseau Bitcoin:'} {netrate:,.2f} ({netrate_formatted})\n")
print('\nLe ratio de tous les hash par rapport aux shares valides est de:\n1 hash sur {:,.0f}'.format(single_ratio),'donnera un block potentiellement valide.\nOu chaque hash a une chance de miner un block de {:,.30f} %'.format(single_prob))
print('=' * sep)
print(f'\nLe hashrate entré de {hashrate_nounit} {hashrate_unit}H/sec équivaut à: {hashrate_raw:,.2f} hash/sec\n Le ratio de votre hashrate par rapport au réseau BTC est de: {proportion:,.{netrate_prec}f} %\n')
print('=' * sep)
# Display probability as decimal value, percentage, "1 in x" format and as description / analogy text
print(f'Chances par 10 min: {prob_per_block:,.{prob_prec}f} ({prob_per_block*100:,.{prob_prec}f} %) ou 1 sur {1/prob_per_block:,.0f}')
print(f'\nLa chance de miner un block avec le hashrate donné dans un délai de 1 an est similaire à la probabilité de choisir une boule rouge gagnante dans un bocal contenant {str(describe_probability(prob_per_block))}')
print('=' * sep)
print(f'Chances par heures: {prob_per_hour:,.{prob_prec}f} ({prob_per_hour*100:,.2f} %) ou 1 sur {1/prob_per_hour:,.0f}')
print(f'\nLa chance de miner un block avec le hashrate donné dans un délai de 1 an est similaire à la probabilité de choisir une boule rouge gagnante dans un bocal contenant {int(round(1/prob_per_hour,0)):,} boules blanches. Ou alors, la probabilité que cela se produise est de {str(describe_probability(prob_per_hour))}')
print('=' * sep)
print(f'Chances par jours: {prob_per_day:,.{prob_prec}f} ({prob_per_day*100:,.2f} %) ou 1 sur {1/prob_per_day:,.0f}')
print(f'\nLa chance de miner un block avec le hashrate donné dans un délai de 1 an est similaire à la probabilité de choisir une boule rouge gagnante dans un bocal contenant {int(round(1/prob_per_day,0)):,} boules blanches. Ou alors, la probabilité que cela se produise est de {str(describe_probability(prob_per_day))}')
print('=' * sep)
print(f'Chances par semaines: {prob_per_week:,.{prob_prec}f} ({prob_per_week*100:,.2f} %) ou 1 sur {1/prob_per_week:,.0f}')
print(f'\nLa chance de miner un block avec le hashrate donné dans un délai de 1 an est similaire à la probabilité de choisir une boule rouge gagnante dans un bocal contenant {int(round(1/prob_per_week,0)):,} boules blanches. Ou alors, la probabilité que cela se produise est de {str(describe_probability(prob_per_week))}')
print('=' * sep)
print(f'Chances par mois: {prob_per_month:,.{prob_prec}f} ({prob_per_month*100:,.2f} %) ou 1 sur {1/prob_per_month:,.0f}')
print(f'\nLa chance de miner un block avec le hashrate donné dans un délai de 1 an est similaire à la probabilité de choisir une boule rouge gagnante dans un bocal contenant {int(round(1/prob_per_month,0)):,} boules blanches. Ou alors, la probabilité que cela se produise est de {str(describe_probability(prob_per_month))}')
print('=' * sep)
print(f'Chances par demi-années: {prob_per_halfyear:,.{prob_prec}f} ({prob_per_halfyear*100:,.2f} %) ou 1 sur {1/prob_per_halfyear:,.0f}')
print(f'\nLa chance de miner un block avec le hashrate donné dans un délai de 1 an est similaire à la probabilité de choisir une boule rouge gagnante dans un bocal contenant {int(round(1/prob_per_halfyear,0)):,} boules blanches. Ou alors, la probabilité que cela se produise est de {str(describe_probability(prob_per_halfyear))}')
print('=' * sep)
print(f'Chances par années: {prob_per_year:,.{prob_prec}f} ({prob_per_year*100:,.2f} %) ou 1 sur {1/prob_per_year:,.0f}')
print(f'\nLa chance de miner un block avec le hashrate donné dans un délai de 1 an est similaire à la probabilité de choisir une boule rouge gagnante dans un bocal contenant {int(round(1/prob_per_year,0)):,} boules blanches. Ou alors, la probabilité que cela se produise est de {str(describe_probability(prob_per_year))}')
print('=' * sep)
print(f'Temps attendu moyen pour miner un block :\n{expected_blockhit_time*3600:,.1f} sec = {expected_blockhit_time*60:,.1f} min = {expected_blockhit_time:,.1f} h = {expected_blockhit_time/24:,.1f} jours = {expected_blockhit_time/24/7:,.1f} semaines = {expected_blockhit_time/24/7/4.34:,.1f} mois = {expected_blockhit_time/24/7/4.34/12:,.1f} années\n')
print(f'Temps attendu moyen (en fonction de tout le réseau):\n{expected_blockhit_rel_net:,.1f} sec = {expected_blockhit_rel_net/60:,.1f} min = {expected_blockhit_rel_net/60/60:,.1f} h = {expected_blockhit_rel_net/60/60/24:,.1f} jours = {expected_blockhit_rel_net/60/60/24/7:,.1f} semaines = {expected_blockhit_rel_net/60/60/24/7/4.34:,.1f} mois = {expected_blockhit_rel_net/60/60/24/7/4.34/12:,.1f} années')
print('=' * sep)
