Scribd
Upload
9 views3 pages

Minerbtc

Uploaded by

ertwqtwigknlwe
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
9 views3 pages

Minerbtc

Uploaded by

ertwqtwigknlwe
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
You are on page 1/ 3

import hashlib

import time
import numpy as np
import pyopencl as cl
import tkinter as tk
from tkinter import messagebox
import threading
from PIL import Image, ImageTk, ImageSequence
import platform
import psutil
import requests

# SHA-256 kernel
KERNEL_CODE = """
__constant uint K[64] = {
0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
};

uint ROTR(uint x, uint n) {


return (x >> n) | (x << (32 - n));
}

uint CH(uint x, uint y, uint z) {


return (x & y) ^ (~x & z);
}

uint MAJ(uint x, uint y, uint z) {


return (x & y) ^ (x & z) ^ (y & z);
}

uint EP0(uint x) {
return ROTR(x, 2) ^ ROTR(x, 13) ^ ROTR(x, 22);
}

uint EP1(uint x) {
return ROTR(x, 6) ^ ROTR(x, 11) ^ ROTR(x, 25);
}

uint SIG0(uint x) {
return ROTR(x, 7) ^ ROTR(x, 18) ^ (x >> 3);
}

uint SIG1(uint x) {
return ROTR(x, 17) ^ ROTR(x, 19) ^ (x >> 10);
}

void sha256(uint *data, uint *hash) {


uint W[64];
uint a, b, c, d, e, f, g, h, t1, t2;
uint i;

// Load data
for (i = 0; i < 16; i++) {
W[i] = data[i];
}
for (i = 16; i < 64; i++) {
W[i] = SIG1(W[i-2]) + W[i-7] + SIG0(W[i-15]) + W[i-16];
}

// Initial hash values


a = 0x6a09e667;
b = 0xbb67ae85;
c = 0x3c6ef372;
d = 0xa54ff53a;
e = 0x510e527f;
f = 0x9b05688c;
g = 0x1f83d9ab;
h = 0x5be0cd19;

// Main loop
for (i = 0; i < 64; i++) {
t1 = h + EP1(e) + CH(e, f, g) + K[i] + W[i];
t2 = EP0(a) + MAJ(a, b, c);
h = g;
g = f;
f = e;
e = d + t1;
d = c;
c = b;
b = a;
a = t1 + t2;
}

// Add compressed chunk to current hash value


hash[0] = a + 0x6a09e667;
hash[1] = b + 0xbb67ae85;
hash[2] = c + 0x3c6ef372;
hash[3] = d + 0xa54ff53a;
hash[4] = e + 0x510e527f;
hash[5] = f + 0x9b05688c;
hash[6] = g + 0x1f83d9ab;
hash[7] = h + 0x5be0cd19;
}

__kernel void mine(__global const uint *block_header, __global uint *hash_result,


__global int *found, int difficulty) {
int id = get_global_id(0);
uint hash[8];
uint data[16];

// Copy block header


for (int i = 0; i < 15; i++) {
data[i] = block_header[i];
}
data[15] = id;

// Compute hash
sha256(data, hash);

// Check hash
int found_local = 1;
for (int i = 0; i < difficulty; i++) {
if ((hash[i/8] >> (28 - (i % 8) * 4)) & 0xf) {
found_local = 0;
break;
}
}

// Save result
if (found_local && *found == 0) {
for (int i = 0; i < 8; i++) {
hash_result[i] = hash[i];
}
*found = id;
}
}
"""

class BitcoinMiner:
def __init__(self, difficulty, progress_callback=None):
self.difficulty = difficulty
self.progress_callback = progress_callback
self.platform = cl.get_platforms()[0]
self.device = self.platform.get_devices()[0]
self.context = cl.Context([self.device])
self.queue = cl.CommandQueue(self.context)
self.program = cl.Program(self.context, KERNEL_CODE).build()
self.mining = False

def mine(self, block_number, transactions, previous_hash, stop_event):


nonce = 0
block_header = f"{block_number}{transactions}
{previous_hash}".encode('ascii')
block_header = np.array([int.from_bytes(block_header[i:i+4], 'big') for i
in range(0, len(block_header), 4)], dtype=np.uint32)
if len(block_header) < 16:
block_header = np.pad(block_header, (0, 16 - len(block_header)),
'constant')

block_header_buf = cl.Buffer(self.context, cl.mem_flags.READ_ONLY |


cl.mem_flags.COPY_HOST_PTR, hostbuf=block_header)
hash_result = np.zeros(8, dtype=np.uint32)
hash_result_buf = cl.Buffer(self.context, cl.mem_flags.WRITE_ONLY,
hash_result.nbytes)
found = np.zeros(1, dtype=np.int32)
found_buf = cl.Buffer(self.context, cl.mem_flags.READ_WRITE |
cl.mem_flags.COPY_HOST_PTR, hostbuf=found)

work_group_size = 1024
self.mining = True
while self.mining and not stop_event.is_set():
self.program.mine(self.queue, (

You might also like