You could try encode the input. input_string = "<provided if you can help>".encode('utf-8')
Since the ord function returns the unicode point for the given charater though if your outside the range for ASCII then it might not fit in a single byte. What you can do is try encode the string like UTF-8 before processing it. Keep in mind if you modify the encode decode function to accpet the unicode points you may need to transform the scheme. |
|
|
|
Is there a possibility that market makers (MMs) are manipulating the Bitcoin SV (BSV)/Bitcoin (BTC) pairs on the OKX exchange? It appears unusual that the BSV/BTC pair on OKX is experiencing movements that result in selling pressure. Could it be that MMs are extracting BTC from these transactions and then 'burning' it? My hypothesis is that this activity originates from within the exchange. The pattern seems to be: the market is artificially pumped, which excites MMs. These MMs then add BTC to their trading pairs. Subsequently, the manipulators withdraw the BTC from these market makers and deliberately decrease the price. Intriguingly, this BTC doesn't seem to re-enter the market. Instead, it might be destroyed or used for other purposes, such as spamming the network with low-value transactions, referred to as 'shitpegs.'  I think there is more to this than meets the eye. |
|
|
|
Miners must be loving it right now!
Yeah, the miners are getting huge rewards in the form of those high fees miners dont see transactions miners dont choose transactions miners are just given whatever cut of reward the POOL decides. dont point fingers at miners. realise who is making transaction decisions look at the devs that refuse to fix the exploits they create asic owners were not in poverty when the bitcoin price was $17k so dont even pretend miners deserve fee's now.. also the spot market will take care of miners when the reward halves so fees are not essential realise its all about dev politics thats causing the issues we see. it has absolutely nothing to do with asic economics whomever is telling you to look at miners is the guy that doesnt want you to scrutinise the core devs indecision and sponsored deals Relax.. Was a simple comment on the block fees atm. wow. |
|
|
|
|
Yay more fees just what everyone wants around the holiday season!
With the block count being ahead small transactions users going to feel the pain the most.
Miners must be loving it right now!
|
|
|
|
You can use https://www.breadcrumbs.app/ to track your transaction. Enter the address you send the coins to into the site and you can follow where the coins have gone. Without sharing some info on your transaction cannot advise further. |
|
|
|
Hey *magi... I mean DaCryptoRaccoon, is there a way to run this on smart phone? I would like to try it out. 😄
*= 😉
Probably in nethunter with termux but not advised.  usual warnings apply.  ... Will burn out not worth it ect ect all the usual stuff. I'm seeing on average with 2 cores on VM around 60k hashes p/s if you try it on a mobile device would be interested to know what your miner.log looks like. It's interesting to see how quickly you can run up to 5 of 6 leading zeros but after 6 the time to find a hash with more than 7 really takes some time. approximately 4 minutes and 24 seconds the difficulty increased from 9.96572131917006e-07 to 0.0017594876221516073, a significant jump showing the mining software's progression towards finding a valid block hash. The final hash (0000023858e72f1bf2f6fd953f87dfeb6a6b393915260baeda0e19bc79afbd49) Best hash found to date : 2023-12-21 12:42:47,904 [BEST HASH UPDATE] New best hash: 000000085bb2f248a7bf29e8908a8246dc557b4e158733958680959d88f332a8 with difficulty: 2023-12-22 03:25:04,440 [BEST HASH UPDATE] New best hash: 1db444db8f550c15191018e34220957301a2ab5fc4560eb48de0e630ddd4cf64 with difficulty: 2.0066082765125252e-09
2023-12-22 03:25:04,440 [BEST HASH UPDATE] New best hash: 1ab47481a55bd53da5b501458965d1e3b80d5329700adaf83b8a617e301ad413 with difficulty: 2.231973856636394e-09
2023-12-22 03:25:04,441 [BEST HASH UPDATE] New best hash: 0d3d42c600a94948ddf7cc4bb8b99c6374a55bc5cc67b2a1e545071c4b512a90 with difficulty: 4.5020993694025145e-09
2023-12-22 03:25:04,442 [BEST HASH UPDATE] New best hash: 02daed391238cf1fc9741de175cc1b61f52ff7029d96644e4c3c829799c5a294 with difficulty: 2.0875951121675577e-08
2023-12-22 03:25:04,442 [BEST HASH UPDATE] New best hash: 01d42658076f388fdab1bf8af59b8275ba7ea774ba0c800a8047d85de2691698 with difficulty: 3.259381866876962e-08
2023-12-22 03:25:04,443 [BEST HASH UPDATE] New best hash: 013f2182eb30ae674d4e2dd5d6c0090dc75f667219a34ab5fed0e92358a0d975 with difficulty: 4.781357391434335e-08
2023-12-22 03:25:04,444 [BEST HASH UPDATE] New best hash: 007c9877ff44e42d3b68f41f4b9ed2c77ca5b31a7e0305bc183b7ec80608d387 with difficulty: 1.224665348375222e-07
2023-12-22 03:25:04,456 [BEST HASH UPDATE] New best hash: 005eaf421eb8ee5161a054e9a4638e37aa09049e11a111513f1e14419f07d981 with difficulty: 1.6115385853269968e-07
2023-12-22 03:25:04,474 [BEST HASH UPDATE] New best hash: 00396b012b6ba612fa40a331b2d53ba9ee54d6dc4d321105818ed7b67f2402ff with difficulty: 2.657492881043723e-07
2023-12-22 03:25:04,476 [BEST HASH UPDATE] New best hash: 000f4fafa8a5c6a70b4e25e67e3889676e878f1732621eafac7faaca0a9a2800 with difficulty: 9.96572131917006e-07
2023-12-22 03:25:04,494 [BEST HASH UPDATE] New best hash: 0003f3efab5e22b7ddfa5144f9306b190e407d476ccbd859eba1369152ac5ffb with difficulty: 3.860174155988332e-06
2023-12-22 03:25:05,128 [BEST HASH UPDATE] New best hash: 0000b1943dc8aead148bc79c03e913dda76d220fd23eaf5f74670aae6b328d0d with difficulty: 2.1997243535196427e-05
2023-12-22 03:25:09,996 [BEST HASH UPDATE] New best hash: 00004ed4e0c0d0e1e4cdc35430053cf083e3929cb3e79fdaeb6299737136cf41 with difficulty: 4.9551858093943016e-05
2023-12-22 03:25:11,137 [BEST HASH UPDATE] New best hash: 000030e2bf06b31fcb5804e7bc12f68e48066355ae56e0be6f7449b9e67ec784 with difficulty: 7.99057355490974e-05
2023-12-22 03:25:11,943 [BEST HASH UPDATE] New best hash: 00001452c7a6c39b98bbddecd7f3f8443e54092b7c93cccc72a249c5d3079c22 with difficulty: 0.00019220494071557886
2023-12-22 03:25:15,270 [BEST HASH UPDATE] New best hash: 000005bc0510323d35deb11dc2a8f8521ddecf7772964629b2d9d132fbf20809 with difficulty: 0.0006811897324026841
2023-12-22 03:25:24,097 [BEST HASH UPDATE] New best hash: 000005a9293acda83a322c2c8406551ab19b29c998e0b34212415d853c85f1e7 with difficulty: 0.0006900544267129364
2023-12-22 03:29:26,714 [BEST HASH UPDATE] New best hash: 0000038fb6d0b10d8e0c53d1540878acd3cad213aa7313e306fe47a394456dc2 with difficulty: 0.00109683504510879
2023-12-22 03:29:28,344 [BEST HASH UPDATE] New best hash: 0000023858e72f1bf2f6fd953f87dfeb6a6b393915260baeda0e19bc79afbd49 with difficulty: 0.0017594876221516073
|
|
|
|
Sorry for the long term push on this but I have recently returned to the script and have some updated and have some questions maybe someone might be able to help with. New code posted below. 1. Added hashrate tracking and showing best hash found with a diff value and store it to miner.log and print on terminal. 2. I am intersted to know more about how a miner will submit a "share" at the moment I just set it to if difficulty >= 16: but I am sure this is probably not the correct method for this. Any help or advice on this would be great also I know not going to find a block with this just doing to to learn. I would be interested to know more about how the shares work and if there is a way to add in some calculations for total work done or total work done in relation to the target value. I added the miner.log file also after a short run. Thanks in advance. Updated Miner.py # Python Bitcoin Solo Miner
import requests
import socket
import threading
import json
import hashlib
import binascii
import logging
import random
import time
import traceback
import context as ctx
import psutil
from datetime import datetime
from signal import SIGINT, signal
from colorama import Back, Fore, Style
from tabulate import tabulate
from tqdm import tqdm
sock = None
best_difficulty = 0
best_hash = None
# Initialize difficulty outside the loop
difficulty = 0
# Initialize best share difficulty and hash
best_share_difficulty = float('inf')
best_share_hash = None
# Set the difficulty level
difficulty = 16
def show_loading_splash():
ascii_art = """
⠀⠀⠀⠀⠀⠀⠀⠀⣀⣤⣴⣶⣾⣿⣿⣿⣿⣷⣶⣦⣤⣀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⣠⣴⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣦⣄⠀⠀⠀⠀⠀
⠀⠀⠀⣠⣾⣿⣿⣿⣿⣿⣿⣿⣿⣿⡿⠿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣷⣄⠀⠀⠀
⠀⠀⣴⣿⣿⣿⣿⣿⣿⣿⠟⠿⠿⡿⠀⢰⣿⠁⢈⣿⣿⣿⣿⣿⣿⣿⣿⣦⠀⠀
⠀⣼⣿⣿⣿⣿⣿⣿⣿⣿⣤⣄⠀⠀⠀⠈⠉⠀⠸⠿⣿⣿⣿⣿⣿⣿⣿⣿⣧⠀
⢰⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡏⠀⠀⢠⣶⣶⣤⡀⠀⠈⢻⣿⣿⣿⣿⣿⣿⣿⡆
⣾⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠃⠀⠀⠼⣿⣿⡿⠃⠀⠀⢸⣿⣿⣿⣿⣿⣿⣿⣷
⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡟⠀⠀⢀⣀⣀⠀⠀⠀⠀⢴⣿⣿⣿⣿⣿⣿⣿⣿⣿
⢿⣿⣿⣿⣿⣿⣿⣿⢿⣿⠁⠀⠀⣼⣿⣿⣿⣦⠀⠀⠈⢻⣿⣿⣿⣿⣿⣿⣿⡿
⠸⣿⣿⣿⣿⣿⣿⣏⠀⠀⠀⠀⠀⠛⠛⠿⠟⠋⠀⠀⠀⣾⣿⣿⣿⣿⣿⣿⣿⠇
⠀⢻⣿⣿⣿⣿⣿⣿⣿⣿⠇⠀⣤⡄⠀⣀⣀⣀⣀⣠⣾⣿⣿⣿⣿⣿⣿⣿⡟⠀
⠀⠀⠻⣿⣿⣿⣿⣿⣿⣿⣄⣰⣿⠁⢀⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠟⠀⠀
⠀⠀⠀⠙⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡿⠋⠀⠀⠀
⠀⠀⠀⠀⠀⠙⠻⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠟⠋⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠉⠛⠻⠿⢿⣿⣿⣿⣿⡿⠿⠟⠛⠉⠀⠀⠀⠀⠀⠀⠀⠀
WE ARE ALL SATOSHI
B I T C O I N
"""
# ANSI escape code for orange text
orange_text = '\033[38;5;202m'
# ANSI escape code to reset color
reset_color = '\033[0m'
print(orange_text + ascii_art + reset_color)
# Call this function at the start of your script
show_loading_splash()
def timer():
return datetime.now().time()
## Mining Address **Change Me**
address = '123dAmdR7vV8FXRZ6hFzZCquyAzLuzEhAJ'
print(Back.BLUE, Fore.WHITE, 'SOLO ADDRESS:', Fore.GREEN, str(address), Style.RESET_ALL)
def handler(signal_received, frame):
ctx.fShutdown = True
print(Fore.MAGENTA, '[', timer(), ']', Fore.YELLOW, 'Force Close, Please Wait..')
# Define the logger with the desired format
logging.basicConfig(level=logging.INFO, filename="miner.log", format='%(asctime)s %(message)s')
logger = logging.getLogger("miner_logger")
# Update the logg function to use the logger
def logg(msg):
logger.info(msg)
## This code is used to get the current block height of the Bitcoin network.
## The request is made to the blockchain.info API and the response is parsed to get the height field.
## The height is then converted to an integer and returned.
def get_current_block_height():
r = requests.get('https://blockchain.info/latestblock')
return int(r.json()['height'])
## This code is used to check if the mining context (ctx) is in shutdown mode.
## If the ctx.fShutdown flag is set to True, the ctx.listfThreadRunning list is updated with the current thread's index (n) and set to False.
## The thread's exit flag is also set to True to signal the thread to exit.
def check_for_shutdown(t):
n = t.n
if ctx.fShutdown:
if n != -1:
ctx.listfThreadRunning[n] = False
t.exit = True
## This code is defining a custom thread class called ExitedThread which is a subclass of threading.Thread.
## The class has two attributes, exit and arg, and four methods,
## __init__, run, thread_handler and thread_handler2. The __init__ method is used to initialize the class and set the exit,
## arg and n attributes. The run method is used to call the thread_handler method with the arg and n attributes as parameters.
## The thread_handler method is used to check for shutdown and if the exit flag is set to True, the thread exits.
## The thread_handler2 method is used to be implemented by subclasses and is not implemented in this class.
## The check_self_shutdown and try_exit methods are used to check for shutdown and t
class ExitedThread(threading.Thread):
def __init__(self, arg, n):
super(ExitedThread, self).__init__()
self.exit = False
self.arg = arg
self.n = n
def run(self):
self.thread_handler(self.arg, self.n)
def thread_handler(self, arg, n):
while True:
check_for_shutdown(self)
if self.exit:
break
ctx.listfThreadRunning[n] = True
try:
self.thread_handler2(arg)
except Exception as e:
logg("ThreadHandler()")
print(Fore.MAGENTA, '[', timer(), ']', Fore.WHITE, 'ThreadHandler()')
logg(str(e))
print(Fore.GREEN, str(e))
ctx.listfThreadRunning[n] = False
time.sleep(2)
def thread_handler2(self, arg):
raise NotImplementedError("must implement this function")
def check_self_shutdown(self):
check_for_shutdown(self)
def try_exit(self):
self.exit = True
ctx.listfThreadRunning[self.n] = False
## This code is defining a function called bitcoin_miner which is used to start and restart the bitcoin miner.
## If the miner is restarted, it will log and print that it has been restarted and sleep for 5 seconds.
## It will then log and print that the miner has started. It then runs a loop which checks if the miner thread is still alive and if the subscribe thread is running.
## If either of these conditions are not true, the loop will break. Otherwise,
## it will set the miner thread to be running, call the mining method on the miner thread, and set the miner thread to be not running.
## If an exception occurs, it is logged and the traceback is printed, and the loop breaks.
# Initialize best difficulty outside the loop
best_difficulty = 0 # Add this line to initialize best_difficulty
def bitcoin_miner(t, restarted=False):
global best_share_difficulty, best_share_hash
start_time = time.time() # Start time for performance metrics
total_hashes = 0 # Initialize total_hashes
if restarted:
logg('\n[*] Bitcoin Miner restarted')
print(Fore.MAGENTA, '[', timer(), ']', Fore.YELLOW, 'Solo Miner Active')
print(Fore.MAGENTA, '[', timer(), ']', Fore.BLUE, '[*] Bitcoin Miner Restarted')
# Initialize share_difficulty outside the loop
share_difficulty = 0
# Initialize difficulty outside the loop
difficulty = 0
# Initialize best difficulty
best_difficulty = 0 # Add this line to initialize best_difficulty
## This code is used to create a target (difficulty) and extranonce2 value for a mining context (ctx).
## The target is created by taking the last 3 bits of the nbits field from the context and appending '00' to the end of it ctx.nbits[2:] times.
## The extranonce2 value is a random number between 0 and 2^32-1, which is converted to hex and padded with zeros to match the length of the ctx.extranonce2_size.
target = (ctx.nbits[2:] + '00' * (int(ctx.nbits[:2], 16) - 3)).zfill(64)
extranonce2 = hex(random.randint(0, 2**32 - 1))[2:].zfill(2 * ctx.extranonce2_size)
print(Fore.YELLOW, '[*] Target:', Fore.GREEN, '[', target, ']')
print(Fore.YELLOW, '[*] Extranonce2:', Fore.GREEN, '[', extranonce2, ']')
## This code is used to create a coinbase hash from the mining context (ctx) and the extranonce2 value generated in the previous code.
## The coinbase is created by combining the ctx.coinb1, ctx.extranonce1, extranonce2 and ctx.coinb2 fields.
## The coinbase hash is then generated by taking the SHA-256 hash of the coinbase t
coinbase = ctx.coinb1 + ctx.extranonce1 + extranonce2 + ctx.coinb2
coinbase_hash_bin = hashlib.sha256(hashlib.sha256(binascii.unhexlify(coinbase)).digest()).digest()
print(Fore.YELLOW, '[*] Coinbase Hash:', Fore.GREEN, '[', coinbase, ']')
## This code is used to generate a Merkle root from the mining context (ctx) and the coinbase hash generated in the previous code.
## The Merkle root is generated by looping through the ctx.merkle_branch list and combining the merkle_root and the current branch element in each iteration.
## The combined values are then hashed twice with SHA-256 to generate the new merkle_root.
merkle_root = coinbase_hash_bin
for h in ctx.merkle_branch:
merkle_root = hashlib.sha256(hashlib.sha256(merkle_root + binascii.unhexlify(h)).digest()).digest()
## This code is used to convert the binary Merkle root generated in the previous code to a hexadecimal string.
## The binary merkle_root is converted to a hexadecimal string using the binascii.hexlify() function,
## and then the result is decoded to a string using the decode() method.
merkle_root = binascii.hexlify(merkle_root).decode()
print(Fore.YELLOW, '[*] Merkle Root:', Fore.YELLOW, '[', merkle_root, ']')
## This code is used to format the Merkle root generated in the previous code. The string is split into two-character substrings,
## and the result is reversed using the [::-1] slice notation.
## The work_on variable is used to get the current block height,
## and the ctx.nHeightDiff dictionary is updated with the new block height and a value of 0.
merkle_root = ''.join([merkle_root[i] + merkle_root[i + 1] for i in range(0, len(merkle_root), 2)][::-1])
work_on = get_current_block_height()
ctx.nHeightDiff[work_on + 1] = 0
## This code is used to calculate the difficulty for the current block.
## The difficulty is calculated by taking the hex string "00000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
## and dividing it by the target value which is also in hex format. The result is the difficulty for the current block.
## Calculate the difficulty as you did in your original code
_diff = int("00000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 16)
# Print and log the difficulty value
print(Fore.YELLOW, '[*] Diff:', Fore.YELLOW, '[', int(_diff), ']')
logg('[*] Working to solve block at block height {}'.format(work_on + 1))
print(Fore.MAGENTA, '[', timer(), ']', Fore.YELLOW, '[*] Working to solve block at ', Fore.GREEN, 'height {}'.format(work_on + 1))
# Improved difficulty calculation
def calculate_difficulty(target, hash_hex):
hash_int = int(hash_hex, 16)
target_int = int(target, 16)
return target_int / max(hash_int, 1) # Avoid division by zero
# Enhanced metrics logging
def log_metrics(start_time, nonce, hashes_computed, best_difficulty, best_hash):
elapsed_time = time.time() - start_time
hash_rate = hashes_computed / max(elapsed_time, 1) # Avoid division by zero
print(f"Nonce: {nonce}, Hash Rate: {hash_rate:.2f} hashes/sec")
print(f"Hash Rate: {hash_rate:.2f} hashes/sec")
print(f"Best Difficulty: {best_difficulty:.2f}")
print(f"Best Hash: {best_hash}")
# Initialize a variable to keep track of the previous progress percentage
prev_progress_percentage = None
# Initialize total_hashes before entering the mining loop
total_hashes = 0
# Initialize hash_rate
hash_rate = 0.0
## Modify bitcoin_miner function to include improved difficulty analysis and metrics logging
## This code is a while loop which checks if the thread should be shut down and if so, it breaks out of the loop.
## It then checks if a new block has been detected and if so, it logs and prints that a new block has been detected,
## logs and prints the difficulty of the block, restarts the bitcoin miner, and continues the loop.
while True:
t.check_self_shutdown()
if t.exit:
break
if ctx.prevhash != ctx.updatedPrevHash:
logg('[*] NEW BLOCK {} DETECTED ON NETWORK'.format(ctx.prevhash))
print(Fore.YELLOW, '[', timer(), ']', Fore.MAGENTA, '[*] New block {} detected on', Fore.BLUE,
' network '.format(ctx.prevhash))
logg('[*] Best difficulty previous block {} was {}'.format(work_on + 1, ctx.nHeightDiff[work_on + 1]))
print(Fore.MAGENTA, '[', timer(), ']', Fore.GREEN, '[*] Best Diff Trying Block', Fore.YELLOW, ' {} ',
Fore.BLUE, 'was {}'.format(work_on + 1, ctx.nHeightDiff[work_on + 1]))
ctx.updatedPrevHash = ctx.prevhash
bitcoin_miner(t, restarted=True)
print(Back.YELLOW, Fore.MAGENTA, '[', timer(), ']', Fore.BLUE, 'NEW BLOCK DETECTED - RESTARTING MINER...',
Style.RESET_ALL)
continue
## This code is used to generate a blockheader from the mining context (ctx), the Merkle root,
## a random nonce, and the hash of the blockheader. The blockheader is created by combining the
## ctx.version, ctx.prevhash, merkle_root, ctx.ntime, ctx.nbits, nonce and,
## '000000800000000000000000000000000000000000000000000000000000000000000000000000000000000080020000'.
## The hash of the blockheader is then generated by taking the SHA-256 hash of the blockheader twice and getting the binary digest.
## The result is then converted to a hexadecimal string using the binascii.hexlify() function.
nonce = hex(random.randint(0, 2**32 - 1))[2:].zfill(8)
blockheader = ctx.version + ctx.prevhash + merkle_root + ctx.ntime + ctx.nbits + nonce + '000000800000000000000000000000000000000000000000000000000000000000000000000000000000000080020000'
hash = hashlib.sha256(hashlib.sha256(binascii.unhexlify(blockheader)).digest()).digest()
hash = binascii.hexlify(hash).decode()
ctx.total_hashes_computed += 1 # Increment total hash count
#print(Fore.YELLOW + '[*] Nonce: ' + Fore.GREEN + str(nonce), end="\r")
# Define the target difficulty as a hexadecimal string.
# The target difficulty represents the level of complexity required for a block to be considered valid.
# It consists of leading zeros followed by a sequence of 'F' characters.
# In hexadecimal format, it is represented as '0000000000000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'.
target_difficulty = '0000000000000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'
# Calculate the hash value of the current block as an integer.
# The 'hash' variable contains the hash value of the block in hexadecimal format.
# Converting it to an integer is useful for comparing it to the target difficulty.
this_hash = int(hash, 16)
# Check if the current hash meets or exceeds the target difficulty
if this_hash <= int(target_difficulty, 16):
logg(f'[*] New hash: {hash} for block {work_on + 1}')
print(Fore.MAGENTA, '[', timer(), ']', Fore.GREEN, f'[*] New hash: {hash} for block', Fore.YELLOW, work_on + 1)
print(Fore.MAGENTA, '[', timer(), ']', Fore.YELLOW, 'Hash:', hash.format(work_on + 1))
## This code is used to check if the difficulty of the current block is greater than the difficulty of the previous block.
## The difficulty of the current block is calculated by dividing the predetermined difficulty value _diff by the hash of the blockheader this_hash.
## If the current difficulty is greater than the previous difficulty stored in the ctx.nHeightDiff dictionary,
## the new difficulty is set as the value for the current block.
# Calculate the difficulty for the current block.
difficulty = _diff / this_hash
# Check if this is the best difficulty so far
if difficulty > best_difficulty:
best_difficulty = difficulty
best_hash = hash
logg(f'[BEST HASH UPDATE] New best hash: {best_hash} with difficulty: {best_difficulty}')
print(f'[BEST HASH UPDATE] New best hash: {best_hash} with difficulty: {best_difficulty}')
# Update the difficulty for the current block in the context
if ctx.nHeightDiff[work_on + 1] < difficulty:
ctx.nHeightDiff[work_on + 1] = difficulty
# Increment the total number of hashes computed
total_hashes += 1
# Calculate elapsed time
elapsed_time = time.time() - start_time
# Calculate hash rate
hash_rate = total_hashes / elapsed_time
# Display total hashes and hash rate on the same line with carriage return
print(f"\rTotal Hashes: {total_hashes} | Hash Rate: {hash_rate:.2f} H/s", end='')
## This code is used to check if the hash of the blockheader is less than the target value.
## If the hash is less than the target, it means the block has been successfully solved and the ctx.solved flag is set to True.
if hash < target:
logg('[*] Share found for block {}.'.format(work_on + 1))
print(Fore.MAGENTA, '[', timer(), ']', Fore.YELLOW, '[*] Share found for block {}.'.format(work_on + 1))
print(Fore.MAGENTA, '[', timer(), ']', Fore.YELLOW, 'Share:', hash.format(work_on + 1))
logg('[*] Block hash: {}'.format(hash))
print(Fore.YELLOW)
print(Fore.MAGENTA, '[', timer(), ']', Fore.YELLOW, '[*] Block hash: {}'.format(hash))
logg('[*] Blockheader: {}'.format(blockheader))
print(Fore.BLUE, '--------------~~( ', Fore.GREEN, 'BLOCK SOLVED CHECK WALLET!', Fore.ORANGE, ' )~~--------------')
print(Fore.YELLOW, '[*] Blockheader: {}'.format(blockheader))
# Print nonce value when a new share is found
logg('[*] Nonce Value: {}'.format(nonce))
print(Fore.YELLOW, '[*] Nonce Value: {}'.format(nonce))
payload = bytes('{"params": ["' + address + '", "' + ctx.job_id + '", "' + ctx.extranonce2 + '", "' + ctx.ntime + '", "' + nonce + '"], "id": 1, "method": "mining.submit"}\n', 'utf-8')
logg('[*] Payload: {}'.format(payload))
print(Fore.MAGENTA, '[', timer(), ']', Fore.BLUE, '[*] Payload:', Fore.GREEN, ' {}'.format(payload))
sock.sendall(payload)
ret = sock.recv(1024)
logg('[*] Pool response: {}'.format(ret))
print(Fore.MAGENTA, '[', timer(), ']', Fore.GREEN, '[*] Pool Response:', Fore.CYAN, ' {}'.format(ret))
print(payload)
return True
if difficulty >= 16:
# Construct JSON-RPC request for share submission
share_payload = {
"params": [address, ctx.job_id, ctx.extranonce2, ctx.ntime, nonce],
"id": 1,
"method": "mining.submit"
}
# Send the share payload to the pool's mining.submit endpoint
share_payload = json.dumps(share_payload) + '\n'
sock.sendall(share_payload.encode())
# Receive and handle the pool's response
response = sock.recv(1024).decode()
# Log and print the response for monitoring purposes
logg('[*] Pool response for share submission: {}'.format(response))
print(Fore.MAGENTA, '[', timer(), ']', Fore.GREEN, '[*] Pool Response for share submission:', Fore.CYAN, ' {}'.format(response))
# Calculate the difficulty for the current share
share_difficulty = _diff / this_hash
# Check if this share is better than the best share
if share_difficulty < best_share_difficulty:
best_share_difficulty = share_difficulty
best_share_hash = hash
logg(f'[BEST SHARE UPDATE] New best share hash: {best_share_hash} with difficulty: {best_share_difficulty}')
print(f'[BEST SHARE UPDATE] New best share hash: {best_share_hash} with difficulty: {best_share_difficulty}')
# Update the difficulty for the current block in the context
if ctx.nHeightDiff[work_on + 1] < share_difficulty:
ctx.nHeightDiff[work_on + 1] = share_difficulty
# Calculate elapsed time
elapsed_time = time.time() - start_time
# Calculate hash rate
hash_rate = total_hashes / elapsed_time
# Display total hashes, hash rate, and best share on the same line with carriage return
print(f"\rTotal Hashes: {total_hashes} | Hash Rate: {hash_rate:.2f} H/s | Best Share: {best_share_hash} (Difficulty: {best_share_difficulty:.2f})", end='')
## This code is used to set up a connection to the ckpool server and send a handle subscribe message.
## The response is parsed to get the ctx.sub_details, ctx.extranonce1 and ctx.extranonce2_size fields.
## Then an authorize message is sent with the address and password, and the response is read until the mining.notify message is received.
def block_listener(t) :
# init a connection to ckpool
sock = socket.socket(socket.AF_INET , socket.SOCK_STREAM)
sock.connect(('solo.ckpool.org' , 3333))
# send a handle subscribe message
sock.sendall(b'{"id": 1, "method": "mining.subscribe", "params": []}\n')
lines = sock.recv(1024).decode().split('\n')
response = json.loads(lines[0])
ctx.sub_details , ctx.extranonce1 , ctx.extranonce2_size = response['result']
# send and handle authorize message
sock.sendall(b'{"params": ["' + address.encode() + b'", "x"], "id": 2, "method": "mining.authorize"}\n')
response = b''
while response.count(b'\n') < 4 and not (b'mining.notify' in response) : response += sock.recv(1024)
print(response)
## This code is used to parse the response from the ckpool server and get the necessary fields for the mining context (ctx).
## The response is split into individual lines and only lines that contain the 'mining.notify' string are parsed.
## The parsed results are then stored in the,
## ctx.job_id, ctx.prevhash, ctx.coinb1, ctx.coinb2, ctx.merkle_branch, ctx.version, ctx.nbits, ctx.ntime and ctx.clean_jobs fields.
responses = [json.loads(res) for res in response.decode().split('\n') if
len(res.strip()) > 0 and 'mining.notify' in res]
ctx.job_id , ctx.prevhash , ctx.coinb1 , ctx.coinb2 , ctx.merkle_branch , ctx.version , ctx.nbits , ctx.ntime , ctx.clean_jobs = \
responses[0]['params']
## Do this one time, will be overwriten by mining loop when new block is detected
ctx.updatedPrevHash = ctx.prevhash
while True :
t.check_self_shutdown()
if t.exit :
break
## This code is used to check if the previous hash in the response from the ckpool server is different from the previous hash,
## in the mining context (ctx). If the hashes are different, the response is parsed to get the necessary fields
## for the mining context and the fields are updated with the new values.
response = b''
while response.count(b'\n') < 4 and not (b'mining.notify' in response) : response += sock.recv(1024)
responses = [json.loads(res) for res in response.decode().split('\n') if
len(res.strip()) > 0 and 'mining.notify' in res]
if responses[0]['params'][1] != ctx.prevhash :
## New block detected on network
## update context job data
# Update mining context with new work
ctx.job_id, ctx.prevhash, ctx.coinb1, ctx.coinb2, ctx.merkle_branch, ctx.version, ctx.nbits, ctx.ntime, ctx.clean_jobs = responses[0]['params']
# Call the splash screen function here
show_loading_splash()
# Log the new mining context
logger.info(f"New Work Received from Pool:\n"
f"Job ID: {ctx.job_id}\n"
f"Previous Block Hash: {ctx.prevhash}\n"
f"Coinbase 1: {ctx.coinb1}\n"
f"Coinbase 2: {ctx.coinb2}\n"
f"Merkle Branch: {ctx.merkle_branch}\n"
f"Version: {ctx.version}\n"
f"nBits: {ctx.nbits}\n"
f"nTime: {ctx.ntime}\n"
f"Clean Jobs: {ctx.clean_jobs}")
## This code is defining a custom thread class called CoinMinerThread which is a subclass of ExitedThread.
## The class has two methods, __init__ and thread_handler2. The __init__ method is used to initialize the class and set the n attribute to 0.
## The thread_handler2 method calls the thread_bitcoin_miner method with the arg parameter. The thread_bitcoin_miner method is used to check for shutdown,
## and then calls the bitcoin_miner function with the current thread object as the parameter. The result of the bitcoin_miner function is logged to the console.
class CoinMinerThread(ExitedThread) :
def __init__(self , arg = None) :
super(CoinMinerThread , self).__init__(arg , n = 0)
def thread_handler2(self , arg) :
self.thread_bitcoin_miner(arg)
def thread_bitcoin_miner(self , arg) :
ctx.listfThreadRunning[self.n] = True
check_for_shutdown(self)
try :
ret = bitcoin_miner(self)
logg(Fore.MAGENTA , "[" , timer() , "] [*] Miner returned %s\n\n" % "true" if ret else "false")
print(Fore.LIGHTCYAN_EX , "[*] Miner returned %s\n\n" % "true" if ret else "false")
except Exception as e :
logg("[*] Miner()")
print(Back.WHITE , Fore.MAGENTA , "[" , timer() , "]" , Fore.BLUE , "[*] Miner()")
logg(e)
traceback.print_exc()
ctx.listfThreadRunning[self.n] = False
pass
## This code is defining a new class called NewSubscribeThread which is a subclass of ExitedThread. It has two methods,
## __init__ and thread_handler2. The __init__ method sets up the thread with the specified argument and sets the number of threads to 1.
## The thread_handler2 method calls the thread_new_block method with the specified argument.
## The thread_new_block method sets the thread to be running, checks for shutdown, and then calls the block_listener function. If an exception occurs,
## it is logged and the traceback is printed. Finally, the thread is set to be not running.
class NewSubscribeThread(ExitedThread) :
def __init__(self , arg = None) :
super(NewSubscribeThread , self).__init__(arg , n = 1)
def thread_handler2(self , arg) :
self.thread_new_block(arg)
def thread_new_block(self , arg) :
ctx.listfThreadRunning[self.n] = True
check_for_shutdown(self)
try :
ret = block_listener(self)
except Exception as e :
logg("[*] Subscribe thread()")
print(Fore.MAGENTA , "[" , timer() , "]" , Fore.YELLOW , "[*] Subscribe thread()")
logg(e)
traceback.print_exc()
ctx.listfThreadRunning[self.n] = False
pass
## This code is defining a function called StartMining which creates a thread for subscribing and one for mining.
## It first creates a new thread called subscribe_t which uses the NewSubscribeThread class.
## It then starts the thread and logs that the subscribe thread has been started.
## It then sleeps for 4 seconds and creates a new thread called miner_t which uses the CoinMinerThread class.
## It then starts the thread and logs that the Bitcoin solo miner has been started.
def StartMining() :
subscribe_t = NewSubscribeThread(None)
subscribe_t.start()
logg("[*] Subscribe thread started.")
print(Fore.MAGENTA , "[" , timer() , "]" , Fore.GREEN , "[*] Subscribe thread started.")
time.sleep(1)
miner_t = CoinMinerThread(None)
miner_t.start()
logg("[*]£££ Bitcoin Solo Miner Started £££")
print(Fore.MAGENTA , "[" , timer() , '(', Fore.GREEN , 'SOLO MINER STARTED' , Fore.BLUE , ' )~~--------------')
print(Fore.BLUE , '--------------~~( ' , Fore.YELLOW , 'IN SATOSHI WE TRUST' , Fore.BLUE , ' )~~--------------')
print(Fore.BLUE , '--------------~~( ' , Fore.GREEN , 'DO NOT TRUST VERIFY' , Fore.BLUE , ' )~~--------------')
if __name__ == '__main__':
# Initialize performance metrics in context
ctx.total_hashes_computed = 0
ctx.mining_time_per_block = []
signal(SIGINT, handler)
StartMining()
Updated Context.py # context.py for CPU-based Bitcoin Mining
# Flag to indicate if the mining process should be shut down
fShutdown = False
# List to keep track of the running state of threads (e.g., mining, listening)
listfThreadRunning = [False] * 6
# Current height of the local blockchain copy
local_height = 0
# Dictionary to store the best difficulty achieved for each height
nHeightDiff = {}
# Hash of the previous block (to detect new blocks in the network)
updatedPrevHash = None
# Mining-related parameters (updated with each new block or job)
job_id = None
prevhash = None
coinb1 = None
coinb2 = None
merkle_branch = None
version = None
nbits = None
ntime = None
clean_jobs = None
sub_details = None
extranonce1 = None
extranonce2_size = None
# Performance Metrics for CPU Mining
total_hashes_computed = 0 # Total number of hashes computed
hash_rate = 0 # Hash rate (hashes per second)
mining_time_per_block = [] # Time taken to mine each block
resource_utilization = { # Resource utilization (CPU, memory)
'cpu_usage': 0,
'memory_usage': 0
}
# Network Statistics
network_difficulty = None # Current network difficulty
average_block_time = None # Average time for block discovery in the network
# Error Handling and Logging
error_count = 0 # Number of errors encountered
last_error_message = "" # Last error message for debugging
# Adaptive Mining Configuration
adaptive_difficulty = True # Flag to enable adaptive difficulty
reconnection_attempts = 0 # Number of attempts to reconnect to the pool
# Blockchain Data
last_block_hashes = [] # Store hashes of the last N blocks
# User Customization
user_preferences = {
'logging_level': 'info',
'ui_settings': {}
}
Miner.log 2023-12-21 10:17:35,805 [*] Subscribe thread started.
2023-12-21 10:17:36,807 [*]£££ Bitcoin Solo Miner Started £££
2023-12-21 10:17:37,376 [*] Working to solve block at block height 822222
2023-12-21 10:17:37,376 [BEST HASH UPDATE] New best hash: ccd3e0d1874c7495b166e2153fea0c019c647c12a6aee6cd4d5246f10c31cdf2 with difficulty: 2.9099901798400617e-10
2023-12-21 10:17:37,376 [BEST SHARE UPDATE] New best share hash: ccd3e0d1874c7495b166e2153fea0c019c647c12a6aee6cd4d5246f10c31cdf2 with difficulty: 0
2023-12-21 10:17:37,376 [BEST HASH UPDATE] New best hash: 53468a173e208a2422ea0e0dd63366117236b8caf4a00a4c3c38a3901df7f946 with difficulty: 7.157520861969146e-10
2023-12-21 10:17:37,376 [BEST HASH UPDATE] New best hash: 1ea56d0f3087b9a7997950cedbdc27523860181de956c64b24121f928c6d29a9 with difficulty: 1.94492804306208e-09
2023-12-21 10:17:37,377 [BEST HASH UPDATE] New best hash: 1a3341863ced131675314867621be86a7cbe9df660a5a2306747666b62a986be with difficulty: 2.2749674629798407e-09
2023-12-21 10:17:37,378 [BEST HASH UPDATE] New best hash: 186162795ac73905af2ea6e135696fdef6a7342544d5de81f5039fe678e75666 with difficulty: 2.4447762609415232e-09
2023-12-21 10:17:37,379 [BEST HASH UPDATE] New best hash: 1696c3988e897a3abd9f1253c4f4e2c84e3faeef755f51e0a17be2ab632dd73f with difficulty: 2.6386670698624605e-09
2023-12-21 10:17:37,379 [BEST HASH UPDATE] New best hash: 04499e0f5cd9f69620eb414b938e21b08266e897ebdb5259e23fa58c4909682b with difficulty: 1.3901737306484555e-08
2023-12-21 10:17:37,380 [BEST HASH UPDATE] New best hash: 004887f35ee30a2b1fe3454a2c9f0afc9773cbba5a2f008a43b928b2c0f3e3d4 with difficulty: 2.103759359413156e-07
2023-12-21 10:17:37,385 [BEST HASH UPDATE] New best hash: 0012173bb6966922e05a882c633db5f4e526e78ceef3f43e31f641c580bf9867 with difficulty: 8.43457840509098e-07
2023-12-21 10:17:37,786 [BEST HASH UPDATE] New best hash: 0000e6ea6543f305f5a2e7024bad21835b75adb070549ca29eb994a780e3643d with difficulty: 1.6916353290772178e-05
2023-12-21 10:17:40,082 [BEST HASH UPDATE] New best hash: 000023fd2a1af6e9327675eb9c580108f1e47ad3bd8827aede257d7f2f1f8985 with difficulty: 0.00010854033951395945
2023-12-21 10:17:47,226 [BEST HASH UPDATE] New best hash: 000003fd492be5222be82c58273d91a868bc9155dc84e3dba69e974aae0edad2 with difficulty: 0.0009791578170452227
2023-12-21 10:18:10,802 [BEST HASH UPDATE] New best hash: 000001ff682e93460a6a6c41ae9aa4b0ce5b05530ce2244a66556fef534a8127 with difficulty: 0.0019553898888381794
2023-12-21 10:20:34,773 [BEST HASH UPDATE] New best hash: 000000cc1d71b6278b94af1e5996c4724060c38f7166e0f0bfe49e1bdded5833 with difficulty: 0.004899198588521477
2023-12-21 10:23:00,681 [BEST HASH UPDATE] New best hash: 000000a7880b9c07990c3e495da47c779d4b0841432f82551c4f0db0ac7ad44f with difficulty: 0.005969029316057255
2023-12-21 10:23:02,474 [BEST HASH UPDATE] New best hash: 000000a47471f18dd68f8058aad44049d451661a10511f051f9e71773db8569f with difficulty: 0.006080695808325444
2023-12-21 10:25:07,961 New Work Received from Pool:
Job ID: 648516380008eef1
Previous Block Hash: 349904fddbc9beb9533181e7f1557f9c492edfcd0001f2300000000000000000
Coinbase 1: 01000000010000000000000000000000000000000000000000000000000000000000000000ffffffff3503cf8b0c000483128465044ea5612b0c
Coinbase 2: 0a636b706f6f6c112f736f6c6f2e636b706f6f6c2e6f72672fffffffff036484f52d000000001976a9140b77264c27eddef8af2a19ff48b9a7d2c49bdfb988acd31cf0000000000016001451ed61d2f6aa260cc72cdf743e4e436a82c010270000000000000000266a24aa21a9ed344146b7a2d62b4a5df5870ed5e40f976b9f66cbb334196f03d93499bc5a976200000000
Merkle Branch: ['29685f9dbc68e260ce3f2ecd3c5a475bf0f6dd03f0092640e0275abd597136f5', '994aad30200ec30f2c9a5cad9674bebb1e3e1e7371728975477b85e36f85ebf4', '08a7b6b31e54481aed30a24b507d48456c977b6ce8bdc2d6fd84dc2c3e6b8b3a', 'cebc8342f6e2c6972eed7962b80911881a5751b0a72307eef32bf02a85a30c02', '6a6bea0ce88850e497f539cbfef27e1cc32b3c5ab72436e7f49ca8bea376246c', '94dce5025c14bea311c7291d38b8dd174c7b21c727b9926c22aa472499047cb9', 'a0180477d1012732b64c747c5a8b266dd0089304c5331d07c2602ef70eb4932c', '293bf744548703b244e18b602cdb2f16b083e5e2ef360d04a1aaff6e14d4fe62', 'af530079a227bddf781270635d79effc935ba65c8bfdfe95b68b583019665dba', '74f5ce6a590a0f5de08213b682bdeb4d826bc70168e55b010f7795a5ff865b78', '35bf2a71d14a859ddb5ddfda4ea605821e5e4a178335970bb344e7a41b37478d', '21ebbc181cc0ec37c168baa53d3ae56cb26a9314a3e9e45e9542ec6a2cabbbde', '7147ad630bd346e772d36c9fa5da04a84f1598d1d5eceea198d45d76e26fbfb5']
Version: 20000000
nBits: 17042e95
nTime: 65841283
Clean Jobs: True
2023-12-21 10:25:07,961 [*] NEW BLOCK 349904fddbc9beb9533181e7f1557f9c492edfcd0001f2300000000000000000 DETECTED ON NETWORK
2023-12-21 10:25:07,962 [*] Best difficulty previous block 822222 was 0.006080695808325444
2023-12-21 10:25:07,962
[*] Bitcoin Miner restarted
2023-12-21 10:25:08,253 [*] Working to solve block at block height 822222
2023-12-21 10:25:08,253 [BEST HASH UPDATE] New best hash: 65b7852f1820f57e9de9580f676fc616fc4ea4051335f239d5b9b26bd4c70df8 with difficulty: 5.859857983592134e-10
2023-12-21 10:25:08,254 [BEST HASH UPDATE] New best hash: 03836ccde2e03ef60b2af15ad88937402feeb623d340f7726ee6db5802acdfd8 with difficulty: 1.696504853802239e-08
2023-12-21 10:25:08,254 [BEST HASH UPDATE] New best hash: 02b9299b642a8ef7f982504cdd69eb08166dd71ef6ce73d7c31109d3748a0a05 with difficulty: 2.1886989710820586e-08
2023-12-21 10:25:08,258 [BEST HASH UPDATE] New best hash: 00912f545396efc81ccc13591df2d29c3044f942fea0e45bbac4ca660460089e with difficulty: 1.050990227979622e-07
2023-12-21 10:25:08,262 [BEST HASH UPDATE] New best hash: 0075b0bdde7dacee6abdf2249b25180155d7ccbcbc0a6d13f4fed7362d0d2097 with difficulty: 1.296519463700919e-07
2023-12-21 10:25:08,305 [BEST HASH UPDATE] New best hash: 00429b2c987fe6617d300bad4806617e9be1571de129a1817b33e78110e0cdac with difficulty: 2.2908979485712655e-07
2023-12-21 10:25:08,419 [BEST HASH UPDATE] New best hash: 00198de895e30d36f14a7f43d0ae99c6590dce4a6638f0b37512f51ae1485332 with difficulty: 5.97111680460128e-07
2023-12-21 10:25:08,496 [BEST HASH UPDATE] New best hash: 00174f3ba93e32dceeaa4931dfc95864ea83c5ea447123032a30c03ff9cb2ef1 with difficulty: 6.54616631609394e-07
2023-12-21 10:25:08,787 [BEST HASH UPDATE] New best hash: 0002673e3f2cc8a66c5ca689001bce556320374cac544211d019575485e05a45 with difficulty: 6.349115777473579e-06
2023-12-21 10:25:09,486 [BEST HASH UPDATE] New best hash: 000253a7f8a8e8da57de0d044090f5d3e25ec88e39a4956969694fe2985697c8 with difficulty: 6.557894313206096e-06
2023-12-21 10:25:11,273 [BEST HASH UPDATE] New best hash: 0002032bd0178b8644c2a21a812eb2dd8c9b2f0a4f8fb40d851a546bdc098e95 with difficulty: 7.582431674667211e-06
2023-12-21 10:25:11,919 [BEST HASH UPDATE] New best hash: 00013a79c0d4a9d9278b36d651082d677e221b522696bf23ec79a58146dcff5a with difficulty: 1.2421472499697014e-05
2023-12-21 10:25:12,321 [BEST HASH UPDATE] New best hash: 000126a69eea12dfb7b1d9a264f6eeb0dad743428db7851acbf0332d5a0e92fa with difficulty: 1.3257215570220232e-05
2023-12-21 10:25:13,129 [BEST HASH UPDATE] New best hash: 0000ba75a6496a9796d31070c709037f65a5709f53d0d431c69e38f2684b2e1f with difficulty: 2.09495818833267e-05
2023-12-21 10:25:13,828 [BEST HASH UPDATE] New best hash: 00002f993735b5260416de75f88d3c863260e7c72d7059f8fa13f20d973263d7 with difficulty: 8.206666403245318e-05
2023-12-21 10:25:23,237 [BEST HASH UPDATE] New best hash: 00001b4d60229cc775f6f792dcaa449491150eb07614c292d70f10ad6d1816f7 with difficulty: 0.000143074298408116
2023-12-21 10:25:23,262 [BEST HASH UPDATE] New best hash: 0000167282564bbf3dd7adfc75f623c02761c7321be3025f3daec663cef95da0 with difficulty: 0.00017401869160989323
2023-12-21 10:25:24,103 [BEST HASH UPDATE] New best hash: 000010363c42f22998d1921e366a32b8c74b7cfa709ad5a22cc249c9cb24be3d with difficulty: 0.00024095018823267985
2023-12-21 10:26:23,708 [BEST HASH UPDATE] New best hash: 00000befd54d1b5be2678fa2f704e254dab315e62f5c86fff0bbff283d1482bf with difficulty: 0.00032724299135340827
2023-12-21 10:26:56,460 [BEST HASH UPDATE] New best hash: 0000074b6a16f7c1a3c8729f966de2a09cbe72c53446aebd21f37315c276decb with difficulty: 0.0005354997760858537
2023-12-21 10:28:11,052 [BEST HASH UPDATE] New best hash: 0000014096e5696620809f5dbd91632c3415131f10b2263ae8f2e6d44ae45088 with difficulty: 0.0031192543525396937
2023-12-21 10:29:32,311 [BEST HASH UPDATE] New best hash: 000000f49686383002a9a996c54842d808646e9e44b49d02a69aa5cfae484ea3 with difficulty: 0.00408850826358574
2023-12-21 10:33:39,352 New Work Received from Pool:
Job ID: 648516380008ef03
Previous Block Hash: 21fd050571c9066b3bea88bdb6825b8ae683b46f0003a8090000000000000000
Coinbase 1: 01000000010000000000000000000000000000000000000000000000000000000000000000ffffffff3503d08b0c00048314846504bf9ab2080c
Coinbase 2: 0a636b706f6f6c112f736f6c6f2e636b706f6f6c2e6f72672fffffffff034248eb2d000000001976a9140b77264c27eddef8af2a19ff48b9a7d2c49bdfb988ac5ae7ef000000000016001451ed61d2f6aa260cc72cdf743e4e436a82c010270000000000000000266a24aa21a9ed038ae70f65d0ab8e246e1fd245dd8a7ea9bf2c9a0075ab1d39206ea2970d4ce400000000
Merkle Branch: ['dc05a3c00350579e42a5ff0ad85a46535341f7b1befbd82709a76946e99a58b4', '152e3c58a1c26ba59f4622b81f19979b88cbfd86f788b172c324209693a5ec90', '6dc5a658413f2d81e398b413353048f900f67a4aea90580a0b301bfe9e0b171e', '83872cf872862a52993cb18736950ab9e2389a4dac74610387a3c001ae412ae4', '213d0d6965adf3f4ac6b1a3455ca8f064bf9fd1d4bcda0c3cddf1a2993de783f', '948524b6c6ee31c1847b0dceb5e96ee7a25c5d707f25df142ef73c0e56969647', '0085f79f7178bf1c7da298762c45b8c07d908ec2de7356eba9b71a3112544ac4', '478b8021ba8ac018f387f22627a43156a976d00006db0a27e200fef33187c5b3', 'd7f43c4e5ab49c986a041ca1b2da682ee5176e5921a6b7be367dc53ee7191d18', '8afc080a03289ebd3f4287cb6825143b4e66f56c723decacceabee58685d3c64', 'cd9b0fd9ebeccee58e77d6a1a26b5065640608ef8bf4978f1ee32536cca5b017', '9037dd761acec84255a6d48411b3dc89fe09f65b00a01de20678b0438e3db4e9', '93b10cd3648cceae4e438e0999c89cbee3264531987bd0e2b93b5fe2f7fea592']
Version: 20000000
nBits: 17042e95
nTime: 65841483
Clean Jobs: True
2023-12-21 10:33:39,352 [*] NEW BLOCK 21fd050571c9066b3bea88bdb6825b8ae683b46f0003a8090000000000000000 DETECTED ON NETWORK
2023-12-21 10:33:39,352 [*] Best difficulty previous block 822222 was 0.00408850826358574
2023-12-21 10:33:39,352
[*] Bitcoin Miner restarted
2023-12-21 10:33:39,690 [*] Working to solve block at block height 822223
2023-12-21 10:33:39,690 [BEST HASH UPDATE] New best hash: 1332c13b1f544d2e855953ac624b899892e6965a096d66a33e9ccce76e6754cb with difficulty: 3.104689787670445e-09
2023-12-21 10:33:39,690 [BEST HASH UPDATE] New best hash: 111d982311d22247395cb9c99c9c9951ee169a05118c3dc1fb8669987e8172a1 with difficulty: 3.48247420221444e-09
2023-12-21 10:33:39,690 [BEST HASH UPDATE] New best hash: 0fe768f65218126e9ce5528e520ab1c17252e97f39f534c366e6b4ef2dfe2a76 with difficulty: 3.747789839499474e-09
2023-12-21 10:33:39,692 [BEST HASH UPDATE] New best hash: 08fa4e40beb1071da653b25d581ab12be9f6df248fc4b5ea3bec430bf7b1af58 with difficulty: 6.639146927074643e-09
2023-12-21 10:33:39,693 [BEST HASH UPDATE] New best hash: 085ceffc324522762e1726e0c698b2ccf4edf9bea46faa46c5dfc8a303abdca0 with difficulty: 7.127153163579793e-09
2023-12-21 10:33:39,696 [BEST HASH UPDATE] New best hash: 0351a69270adbaeb8b6dc9793a92189df1e826aaff3d8afeea746982ef2ed4a8 with difficulty: 1.795889718605585e-08
2023-12-21 10:33:39,697 [BEST HASH UPDATE] New best hash: 003f5ffd898682b56d21462862a5cbf7c318cb1f7d3639671e31d5544208a5db with difficulty: 2.4076998990842845e-07
2023-12-21 10:33:39,708 [BEST HASH UPDATE] New best hash: 0032549a87552a013f6b2bc3c1d3df3b2b5cd3a9b70fca1fed280a53dd559c2b with difficulty: 3.031719184328591e-07
2023-12-21 10:33:39,987 [BEST HASH UPDATE] New best hash: 00075dc73632d355460ff55f5a2fb9f31dea6b3753807391ed2c44992a83fc6b with difficulty: 2.071426035458905e-06
2023-12-21 10:33:40,154 [BEST HASH UPDATE] New best hash: 00014e5fc33d0b19b559cd582b20626e0065e5e824b3f2020166746fc260489e with difficulty: 1.1682275383011119e-05
2023-12-21 10:33:41,156 [BEST HASH UPDATE] New best hash: 00009d425e0748c4a3e17b3d2810a87325979afdf5d4b94d27f4c187575655e0 with difficulty: 2.4839556770439673e-05
2023-12-21 10:33:42,135 [BEST HASH UPDATE] New best hash: 0000495886b356e94e54267661bc074cb406e9e51c383daff631fdac73e05f9d with difficulty: 5.325798769873194e-05
2023-12-21 10:33:55,704 [BEST HASH UPDATE] New best hash: 00000d55f6e8a92ca9feb74671ada5247de400573c2781d057671de31e792bcf with difficulty: 0.0002929145876078991
2023-12-21 10:34:18,731 [BEST HASH UPDATE] New best hash: 00000930bcd78120bd123b51870fc5edad1e0c4ce9b51bb21af66be3596ed4ae with difficulty: 0.00042503676273960883
|
|
|
|
|
Fees are insane now hardly worth using them now seem to have lost any edge cash in cash out still works which is good but dam they sting you on fees when you withdraw anything now.
|
|
|
|
here is the first picture of a bitaxeHex compared to a bitaxeUltra - in my opinion, not much bigger than the 1-chip version here you can see the difference in size very well and what you can also see are the 6 built-in asic chips  fingers crossed!  https://twitter.com/Silexperience/status/1730927131796844706This looks epic! 6 chips! Have you had it running yet? any temps hashrates? Looking at getting a few of them myself the S3's really need to retire. |
|
|
|
What makes me laugh are the fools that think ordinals are to blame. they are a mere tool.
Ordinals are just a tool that has emerged that facilitates this scheme of trying to cause network constation with the aim of increasing fees - as a result, they continue. I am of the opinion that we are entering a time where the large mining pools are close to functioning as a cartel in order to "control" how the network works. It will always be very difficult to prove this, and of course it is just my opinion, but looking at how mining is going, this scenario is quite possible. We are left with just 4 or 5 large mining pools, which control more than 50% of the hash. I think it is increasingly important to decentralize mining, because it is becoming very centralized. How can this be done? Unfortunately, I can't come up with an idea of how to decentralize, but at least putting the issue in public debate is a way forward. I've said it for years: more people running their own pools would help a lot. The reason behind this is simple; pools and mining have always been shrouded in mystery for some reason. Movements like Bitaxe, I believe, are starting to bring mining more into the light, along with pools. 1 Miner - 1 Pool. 1 CPU - 1 Vote. I've said for years that if more user-friendly solutions emerge for running your own pool, many would do this, and the network would look very different in a very short space of time, I believe. Though would people give up on the exsisting way. Probably not but would be pretty spectacular if it happened. |
|
|
|
I have always been interested in the wordlist used by a early version of Electrum. 1626 words was the list size and it related to a US patent no 5892470 were each word does not represent a given digit. Instead, the digit represented by a word is variable, it depends on the previous word. I'm sure it used the list from http://en.wiktionary.org/wiki/Wiktionary:Frequency_lists/Contemporary_poetrySince the wordlist was only 1626 would this not weaken anything generated by the early version of Elecrum 2011. Something I have been looking at for some time now but never really seen it brought up in any of the topics around wordlists. |
|
|
|
Most of the detailed specifications of the chip are not available. What I would advise is to buy chips on AliExpress can get them for a few $ each. https://www.aliexpress.com/item/1005003187958359.htmlThe Antminer BM1362AJS is for the 19j / S19j Pro and the S19j Pro hash board has a total of 126 BM1362AJ chips. Maybe others can share the dimentions and other spec lists if they have. |
|
|
|
|
Why are you bumping something that no longer works.
Omegle was shutdown you cannot sell a script for a site that is no longer working.
You are also bump spamming...
|
|
|
|
Wish me luck {
"hashrate1m": "7.52P",
"hashrate5m": "4.98P",
"hashrate1hr": "1.26P",
"hashrate1d": "64.8T",
"hashrate7d": "9.34T",
"lastshare": 1702709546,
"workers": 37,
"shares": 1318000000,
"bestshare": 9046978672.360407,
"bestever": 9046978672,
"authorised": 1702706924,
|
|
|
|
|
100% scam!
Don't waste your time.
|
|
|
|
The generation of the base point G in ECC, especially for curves like secp256k1, is typically shrouded in some mystery. The "nothing up my sleeve" number is often used in creating these curves to ensure that the base point wasn't chosen to weaken the encryption. Using x = 0x1 and Different Values of kYour observation here is aligned with the properties of elliptic curves where scalar multiplication can lead to different points on the curve, depending on your chosen scalar ( k). Your experiments demonstrate intriguing behaviors when you vary k. This aligns with the cyclic nature of elliptic curves over finite fields. The behavior you noted when using different primes ( p) and modifying the curve shows how these parameters significantly affect the curve's properties.
def ecc_add(p1, p2, p):
# Elliptic curve addition
if p1 == (0, 0):
return p2
if p2 == (0, 0):
return p1
if p1[0] == p2[0] and p1[1] != p2[1]:
return (0, 0)
if p1 != p2:
m = (p2[1] - p1[1]) * pow(p2[0] - p1[0], -1, p) % p
else:
m = (3 * p1[0]**2 + 7) * pow(2 * p1[1], -1, p) % p
x3 = (m**2 - p1[0] - p2[0]) % p
y3 = (m * (p1[0] - x3) - p1[1]) % p
return (x3, y3)
def ecc_mul(point, k, p):
# Elliptic curve scalar multiplication
result = (0, 0)
addend = point
while k:
if k & 1:
result = ecc_add(result, addend, p)
addend = ecc_add(addend, addend, p)
k >>= 1
return result
# Define curve parameters for secp256k1
p = 2**256 - 2**32 - 977 # Prime for the finite field
x = 0x1
y = 0x4218f20ae6c646b363db68605822fb14264ca8d2587fdd6fbc750d587e76a7ee
# usage
k = 2 # Scalar to multiply
point = (x, y)
result = ecc_mul(point, k, p)
print(f"Resulting Point: {result}")
Resulting Point: (14474011154664524427946373126085988481658748083205070504932198000988604333959, 72704176545891799367084825159033606358294843509675418738294063466241294077822) |
|
|
|
|
Instead of running a full node, you may consider using a lightweight client or a Simplified Payment Verification (SPV) client.
Since the SPV clients don't download the entire blockchain but verify transactions by downloading only the block headers, which is significantly less data.
Block headers contain proof-of-work and can be used to check the validity of a block.
They also include the Merkle root to verify the presence of a transaction within a block.
To quickly ascertain that a block is accepted by the network, you can check the number of confirmations it has.
The more confirmations (subsequent blocks added to the chain), the higher the certainty that the network has accepted the block.
Typically, a block with 6 confirmations is considered secure and irreversible. For your purposes, even a block with 1-2 confirmations might suffice, considering you are using it for time verification rather than financial transactions.
One thing to note is the risk of MITM attacks.
To mitigate these risks, consider using multiple, reputable sources to fetch block headers.
This reduces the likelihood of falling prey to targeted attacks on a single source.
You can also cross-verify the block information with public blockchain explorers or through APIs provided by trusted entities in the blockchain space.
One possible way to do this would be to define a protocol within your program to query multiple nodes or sources.?
A possible area to look into is how to establish a criteria for accepting a block's timestamp (e.g., minimum number of confirmations, cross-verification with other sources)
Implement checks for discrepancies in the timestamps received from different nodes.
Since your goal is not to run a full Bitcoin node but to use the blockchain as a clock, your program can be optimized to start the verification process from the most recent block known and work backward as needed.
I think this would be the most logical steps based on your OP.
Best regard.
Raccoon!
|
|
|
|
The recurrence of points like (1, 2) on various elliptic curves is due to their structure and properties. As elliptic curves are typically defined over fields like the real numbers or finite fields and their equation generally follows the form : y^2 = x^3 + ax + b. For a point (1, 2) to satisfy multiple curves, the coefficients a and b must align accordingly. For curves of the form y^2 = x^3 + b, substituting x = 1 and y = 2 gives us 2^2 = 1^3 + b, leading to b = 3. This process can be repeated for any value of b to check if a particular point lies on the curve. Python Script for Analyzing Points on Elliptic Curves:
import matplotlib.pyplot as plt
import numpy as np
def is_on_curve(x, y, b):
return y**2 == x**3 + b
def plot_elliptic_curves(b_values, points, x_range):
fig, ax = plt.subplots(figsize=(12, 8))
x = np.linspace(x_range[0], x_range[1], 400)
for b in b_values:
y_squared = x**3 + b
y_positive = np.sqrt(y_squared)
y_negative = -y_positive
ax.plot(x, y_positive, label=f"y² = x³ + {b}")
ax.plot(x, y_negative, label=f"_")
for point in points:
if is_on_curve(point[0], point[1], b):
ax.plot(point[0], point[1], 'ro')
ax.set_xlabel("x")
ax.set_ylabel("y")
ax.set_title("Elliptic Curves and Points")
ax.legend()
plt.grid(True)
plt.show()
b_values = range(1, 11)
points_to_test = [(1, 2), (1, 3), (2, 3), (2, 4)]
x_range = (-2, 3)
plot_elliptic_curves(b_values, points_to_test, x_range)
This script can be expanded to test a larger set of points and a broader range of b values. Results : For b = 1, the point (2, 3) lies on the curve y^2 = x^3 + 1. For b = 3, the point (1, 2) lies on y^2 = x^3 + 3, as in your example. For b = 8, the points (1, 3) and (2, 4) lie on y^2 = x^3 + 8. No points tested lie on the curves for b = 2, 4, 5, 6, 7, 9, 10.  This script can be expanded to test a larger set of points and a broader range of b values. Your observation about even private keys generating valid x coordinates but invalid y coordinates for secp256k1 is interesting. It suggests a possible pattern or property of the curve that might be worth exploring The use of a specific value like lambda to create a triangle and the effects on the x coordinates is a part of exploring the geometrical properties of elliptic curves. The invariant y coordinate in your experiments is peculiar and might be an artifact of the specific curve and values you're using. While it's theoretically possible to reverse-engineer k from P and G, the computational power required makes it impractical I believe. Magic. |
|
|
|
I am trialling a new feature on solo.ckpool.org in the interests of ultimate transparency that allows you to monitor which transactions are being included in the current block template. From the website explanation: Transaction selection transparency:Solo.ckpool.org does not filter any transactions and uses default bitcoin core transaction selection. Live monitoring of the current transactions can be done at any time by examining the following URL: https://solo.ckpool.org/pool.txnsThis can also be used to monitor the likelihood of your personal transactions being mined in the next block at any pool. As this uses a moderate amount of bandwidth, please minimise your usage of this to avoid me needing to disable this service. I Love the new addition CK, know your not a feature rich guy but this is nice to see. I updated my python code to also display transaction and there data in the template just scrolling over some of them as some output. New output at the bottom of the code will clear the lines and show the new data. It grabs the data from the BTC.com api and from the pool website. Enjoy! ********************************************
* Bitcoin Block Information *
********************************************
Attribute Value
----------------------------- ----------------------------------------------------------------
Block Height 819073
Block Version 655417344
Merkle Root 5072df3548632f8e414508f9056011023c4d5d81f42c5aef62ec9ab9cd19e544
Timestamp 1701318510
Bits 386147408
Nonce 3533778960
Previous Block Hash 00000000000000000001c620ac2780c7367e63a6ccd512d9dbd190e64dac0031
Next Block Hash 0000000000000000000000000000000000000000000000000000000000000000
Block Size (bytes) 1667343
Pool Difficulty 111311022198484
Difficulty Double 67957790298897.88
Reward per Block (BTC) 6.25
Reward Fees (BTC) 0.62521383
Number of Transactions 3484
Confirmations 1
Is Orphan False
Current Max Timestamp 1701318510
Is SegWit Block True
Stripped Size (bytes) 775194
Signature Operations (SigOps) 11551
Block Weight 3992925
Chance per Hash 0.0000000004
********************************************
* CKPool Solo Mining Pool Status *
********************************************
Runtime: 14875099 seconds
Last Update: 1701318676
Users: 4497
Workers: 8004
Idle: 3811
Disconnected: 1664
Hashrates:
1-Minute Hashrate: 87.2P
Mining Stats:
Difficulty: 5.36
Accepted Shares: 3640252011357
Rejected Shares: 8857127383
Best Share: 2440857253248
Shares Per Second (1-Minute): 620.0
Shares Per Second (5-Minute): 605.0
Shares Per Second (15-Minute): 599.0
Shares Per Second (1-Hour): 602.0
Fetching details for TXID: 15f67615bd6b8b59e01166b48ca5e1f19bfa6f10c4b23931bea08110d1274b84
Fetching details for TXID: fd9d85a4b07141c42295716072b726ded275e0f922749d6f3062f306fe2453f1
Fetching details for TXID: 000077a6a17f0da1021fc9b887a6027985319b6f27e446c1b25169bcead9ffa0
Block Height: -1
Transaction Hash: 000077a6a17f0da1021fc9b887a6027985319b6f27e446c1b25169bcead9ffa0
Confirmations: 0
Fee: 12480
Inputs Count: 1
Outputs Count: 1
The Code  # Bitcoin Block Tracking + CK Pool Stats
# Checks for new block data every 5 min from BTC.com
# Checks Solo pool stats and displays them
# Enjoy - MagicByt3
import requests
import json
import time
from tabulate import tabulate
# Define the API URLs
bitcoin_api_url = "https://chain.api.btc.com/v3/block/latest"
ckpool_api_url = "https://solo.ckpool.org/pool/pool.status"
## Fetch transactions in template data from BTC.com API
def fetch_transaction_details(txid):
tx_api_url = f"https://chain.api.btc.com/v3/tx/{txid}?verbose=3"
try:
response = requests.get(tx_api_url)
if response.status_code == 200:
return response.json()
else:
print(f"Failed to fetch details for TXID: {txid}")
return None
except Exception as e:
print(f"An error occurred while fetching transaction details: {str(e)}")
return None
## Fetch transactions in template *new feature*
def fetch_pool_transactions():
ckpool_tx_url = "https://solo.ckpool.org/pool.txns"
try:
response = requests.get(ckpool_tx_url)
if response.status_code == 200:
txns = response.text.strip().split('\n')
return txns
else:
print("Failed to fetch transactions from CKPool")
return None
except Exception as e:
print(f"An error occurred while fetching transactions: {str(e)}")
return None
# Function to fetch and display Bitcoin block data
def fetch_bitcoin_block_data():
try:
# Make an HTTP GET request to the Bitcoin API
response = requests.get(bitcoin_api_url)
# Check if the request was successful
if response.status_code == 200:
# Parse the JSON response
data = response.json()
# Extract Bitcoin block details
version = data["data"]["version"]
merkle_root = data["data"]["mrkl_root"]
timestamp = data["data"]["timestamp"]
bits = data["data"]["bits"]
nonce = data["data"]["nonce"]
prev_block_hash = data["data"]["prev_block_hash"]
next_block_hash = data["data"]["next_block_hash"]
block_size = data["data"]["size"]
pool_difficulty = data["data"]["pool_difficulty"]
difficulty_double = data["data"]["difficulty_double"]
reward_fees = data["data"]["reward_fees"]
confirmations = data["data"]["confirmations"]
is_orphan = data["data"]["is_orphan"]
curr_max_timestamp = data["data"]["curr_max_timestamp"]
is_sw_block = data["data"]["is_sw_block"]
stripped_size = data["data"]["stripped_size"]
sigops = data["data"]["sigops"]
weight = data["data"]["weight"]
# Calculate the chance of solving a block per hash
difficulty = data["data"]["difficulty"]
hashrate = data["data"]["pool_difficulty"]
chance_per_hash = 1 / (difficulty * 2**32 / hashrate)
# Display the Bitcoin block data in a table
print("\n********************************************")
print("* Bitcoin Block Information *")
print("********************************************")
print(tabulate([
["Block Height", data['data']['height']],
["Block Version", version],
["Merkle Root", merkle_root],
["Timestamp", timestamp],
["Bits", bits],
["Nonce", nonce],
["Previous Block Hash", prev_block_hash],
["Next Block Hash", next_block_hash],
["Block Size (bytes)", block_size],
["Pool Difficulty", pool_difficulty],
["Difficulty Double", difficulty_double],
["Reward per Block (BTC)", data['data']['reward_block'] / 100000000],
["Reward Fees (BTC)", reward_fees / 100000000],
["Number of Transactions", data['data']['tx_count']],
["Confirmations", confirmations],
["Is Orphan", is_orphan],
["Current Max Timestamp", curr_max_timestamp],
["Is SegWit Block", is_sw_block],
["Stripped Size (bytes)", stripped_size],
["Signature Operations (SigOps)", sigops],
["Block Weight", weight],
["Chance per Hash", f"{chance_per_hash:.10f}"]
], headers=["Attribute", "Value"]))
else:
print("Failed to fetch Bitcoin block data from the API")
except Exception as e:
print(f"An error occurred while fetching Bitcoin block data: {str(e)}")
# Function to fetch and display CKPool Solo Mining Pool status
def fetch_pool_status():
try:
# Make an HTTP GET request to the CKPool URL
response = requests.get(ckpool_api_url)
# Check if the request was successful
if response.status_code == 200:
# Split the response into individual JSON objects
response_lines = response.text.strip().split('\n')
# Initialize variables to store CKPool data
ckpool_data = {
'runtime': 'N/A',
'lastupdate': 'N/A',
'Users': 'N/A',
'Workers': 'N/A',
'Idle': 'N/A',
'Disconnected': 'N/A',
'hashrate1m': 'N/A',
'diff': 'N/A',
'accepted': 'N/A',
'rejected': 'N/A',
'bestshare': 'N/A',
'SPS1m': 'N/A',
'SPS5m': 'N/A',
'SPS15m': 'N/A',
'SPS1h': 'N/A'
}
# Process each JSON object separately
for response_json in response_lines:
data = json.loads(response_json)
# Update CKPool data with the latest values
ckpool_data.update(data)
# Display the retrieved CKPool data
print("\n********************************************")
print("* CKPool Solo Mining Pool Status *")
print("********************************************")
print(f"Runtime: {ckpool_data['runtime']} seconds")
print(f"Last Update: {ckpool_data['lastupdate']}")
print(f"Users: {ckpool_data['Users']}")
print(f"Workers: {ckpool_data['Workers']}")
print(f"Idle: {ckpool_data['Idle']}")
print(f"Disconnected: {ckpool_data['Disconnected']}")
# Check if "hashrate1m" exists in the CKPool data
hashrate1m = ckpool_data.get('hashrate1m', 'N/A')
if hashrate1m != 'N/A':
print("\nHashrates:")
print(f"1-Minute Hashrate: {hashrate1m}")
# Check if "diff" exists in the CKPool data
diff = ckpool_data.get('diff', 'N/A')
if diff != 'N/A':
print("\nMining Stats:")
print(f"Difficulty: {diff}")
print(f"Accepted Shares: {ckpool_data['accepted']}")
print(f"Rejected Shares: {ckpool_data['rejected']}")
print(f"Best Share: {ckpool_data['bestshare']}")
print(f"Shares Per Second (1-Minute): {ckpool_data['SPS1m']}")
print(f"Shares Per Second (5-Minute): {ckpool_data['SPS5m']}")
print(f"Shares Per Second (15-Minute): {ckpool_data['SPS15m']}")
print(f"Shares Per Second (1-Hour): {ckpool_data['SPS1h']}")
else:
print("Failed to fetch CKPool Solo Mining Pool data")
except Exception as e:
print(f"An error occurred while fetching CKPool Solo Pool statistics: {str(e)}")
def clear_lines(num_lines):
for _ in range(num_lines):
# Move cursor up one line
print("\033[A", end='')
# Clear line
print("\033[K", end='')
while True:
fetch_bitcoin_block_data()
fetch_pool_status()
txns = fetch_pool_transactions()
while txns:
for txn in txns:
print(f"Fetching details for TXID: {txn}")
tx_details = fetch_transaction_details(txn)
if tx_details and tx_details.get('data'):
data = tx_details['data']
print(f"Block Height: {data['block_height']}")
print(f"Transaction Hash: {data['hash']}")
print(f"Confirmations: {data['confirmations']}")
print(f"Fee: {data['fee']}")
print(f"Inputs Count: {data['inputs_count']}")
print(f"Outputs Count: {data['outputs_count']}")
if data['confirmations'] > 0:
clear_lines(7) # Adjust the number based on printed lines
break # Break the inner loop to fetch new transactions
time.sleep(5) # Adjust the duration as needed
clear_lines(7) # Clear the number of lines printed above
# Refetch the transactions list
txns = fetch_pool_transactions()
print("\nNext update in 5 minutes...")
time.sleep(300) # Sleep for 5 minutes before the next update
Keep hashing lads! |
|
|
|
|
Show Posts
