Client.java

import java.util.List;
import java.util.Random;
import java.nio.ByteBuffer;

import org.apache.thrift.TException;
import org.apache.thrift.protocol.TProtocol;
import org.apache.thrift.protocol.TBinaryProtocol;
import org.apache.thrift.transport.TTransport;
import org.apache.thrift.transport.TSocket;
import org.apache.thrift.transport.layered.TFramedTransport;
import org.apache.thrift.transport.TTransportFactory;

import java.time.Instant;
import java.time.temporal.ChronoUnit;
import org.bitcoinj.base.Difficulty;
import org.bitcoinj.base.Sha256Hash;
import org.bitcoinj.core.Block;
import org.bitcoinj.core.Transaction;

public class Client {
    private static volatile boolean miningStarted = false;
    private static volatile boolean shouldExit = false;
    private static volatile long lastCancelTime = 0;
    private static final Object lock = new Object();
    
    public static void main(String [] args) {
	if (args.length != 2) {
	    System.err.println("Usage: java Client host port");
	    System.exit(-1);
	}

	final String host = args[0];
	final int port = Integer.parseInt(args[1]);

	Thread cancelThread = new Thread(new Runnable() {
	    @Override
	    public void run() {
		try {
		    TSocket cancelSock = new TSocket(host, port);
		    TTransport cancelTransport = new TFramedTransport(cancelSock);
		    TProtocol cancelProtocol = new TBinaryProtocol(cancelTransport);
		    MiningPoolService.Client cancelClient = new MiningPoolService.Client(cancelProtocol);
		    cancelTransport.open();

		    while (!shouldExit) {
			synchronized (lock) {
			    while (!miningStarted && !shouldExit) {
				try {
				    lock.wait();
				} catch (InterruptedException e) {
				    return;
				}
			    }
			}
			if (shouldExit) break;

			try {
			    Thread.sleep(10000);
			} catch (InterruptedException e) {
			    break;
			}

			if (!shouldExit && miningStarted) {
			    try {
				cancelClient.cancel();
				lastCancelTime = System.currentTimeMillis();
				System.out.println("[CANCEL] Sent cancel request at " + lastCancelTime);
			    } catch (TException e) {
				System.err.println("[CANCEL] Error: " + e.getMessage());
			    }
			}

			synchronized (lock) {
			    while (miningStarted && !shouldExit) {
				try {
				    lock.wait();
				} catch (InterruptedException e) {
				    return;
				}
			    }
			}
		    }

		    cancelTransport.close();
		} catch (TException x) {
		    System.err.println("[CANCEL] Connection error: " + x.getMessage());
		}
	    }
	});
	cancelThread.setDaemon(true);
	cancelThread.start();

	try {
	    TSocket sock = new TSocket(host, port);
	    TTransport transport = new TFramedTransport(sock);
	    TProtocol protocol = new TBinaryProtocol(transport);
	    MiningPoolService.Client client = new MiningPoolService.Client(protocol);
	    transport.open();

            int version = 1;
            Random random = new Random();
            int runs = 50;
            long totalMs = 0;
            int successfulRuns = 0;
            long firstRunStart = 0;
            long lastRunEnd = 0;
            
            for (int i = 0; i < runs; i++) {
                byte[] bytes1 = new byte[32];
                random.nextBytes(bytes1);
                Sha256Hash prevBlockHash = Sha256Hash.wrap(bytes1);
                byte[] bytes2 = new byte[32];
                random.nextBytes(bytes2);
                Sha256Hash merkleRootHash = Sha256Hash.wrap(bytes2);
                Instant time = Instant.now().truncatedTo(ChronoUnit.SECONDS);
                Difficulty difficulty = Difficulty.ofCompact(0x1e290000);
                long nonce = 0;
                List<Transaction> txns = null;
                Block b = new Block(version, prevBlockHash, merkleRootHash, time, difficulty, nonce, txns);

                lastCancelTime = 0;
                
                synchronized (lock) {
                    miningStarted = true;
                    lock.notifyAll();
                }
                
                long start = System.currentTimeMillis();
                if (i == 0) firstRunStart = start;
                
                try {
                    ByteBuffer buf1 = ByteBuffer.wrap(bytes1);
                    ByteBuffer buf2 = ByteBuffer.wrap(bytes2);
                    nonce = client.mineBlock(version, buf1, buf2, time.getEpochSecond(), difficulty.compact());
                } catch (Exception e) {
                    System.out.println("Exception check: exception thrown");
                }
                long end = System.currentTimeMillis();
                long dur = end - start;
                lastRunEnd = end;
                
                boolean wasCancelled = (lastCancelTime > 0 && lastCancelTime >= start && lastCancelTime <= end);
                
                if (!wasCancelled) {
                    totalMs += dur;
                    b.setNonce(nonce);
                    Sha256Hash hash = b.getHash();
                    boolean ok = Difficulty.ofCompact(0x1e290000).isMetByWork(hash);
                    
                    if (ok) {
                        successfulRuns++;
                    }
                    
                    System.out.println("Run " + (i+1) + "/" + runs + ": duration=" + dur + " ms, nonce=" + nonce + ", ok=" + ok);
                } else {
                    System.out.println("Run " + (i+1) + "/" + runs + ": cancelled (duration=" + dur + " ms, skipping validation)");
                }
                
                synchronized (lock) {
                    miningStarted = false;
                    lock.notifyAll();
                }
            }
            
            double avgDuration = totalMs / (double) successfulRuns;
            long totalElapsedTime = lastRunEnd - firstRunStart;
            double totalElapsedSec = totalElapsedTime / 1000.0;
            double throughput = successfulRuns / totalElapsedSec;
            
            System.out.println("\n========== RESULTS ==========");
            System.out.println("Total runs:              " + runs);
            System.out.println("Successful runs:         " + successfulRuns + " (correct nonce + not cancelled)");
            System.out.println("Cancelled runs:          " + (runs - successfulRuns));
            System.out.println("Total elapsed time:      " + totalElapsedSec + " seconds");
            System.out.println("Average duration:        " + avgDuration + " ms (successful runs only)");
            System.out.println("THROUGHPUT:              " + String.format("%.2f", throughput) + " blocks/s");
            System.out.println("=============================\n");

	    shouldExit = true;
	    transport.close();
	} catch (TException x) {
	    System.err.println("[MAIN] Error: " + x.getMessage());
	    shouldExit = true;
	} 
    }
}