drillhash.com is not publishing the blocks its miners find

We connected four NEXA mining machines to drillhash.com and watched every share they sent in. In 35 hours one of them found a real block, the thing miners get paid for. drillhash.com accepted it, and the block never appeared on the Nexa network. Nobody was paid for it.

What we did

You know the deal as a miner: your machine sends shares to the pool all day, and every share is a lottery ticket. Most of the time a share is just proof that you are working. Once in a while a share is good enough to be a block. That is the moment the pool exists for. It has seconds to publish that block on the Nexa network, the block reward lands in the pool's wallet, and the pool splits it among everyone who sent shares. No published block, no reward, nothing to split. A pool's dashboard shows hashrate and shares, but the blocks it has published on the network are what actually pay you.

drillhash.com has shown a lot of NEXA mining power for weeks and has reported no blocks at all. We wanted to know for sure, so we tested it. We placed a small piece of software between four mining machines and drillhash.com. It changes nothing: every message goes through untouched, and drillhash.com sees the machines exactly as if they had connected directly. But it keeps a copy of every share and checks its quality itself, using the same rule the Nexa network uses. It also writes down what drillhash.com answered.

If a share is good enough to be a block, it is a block. It does not matter what the pool says about it afterwards. That is the whole test.

What we found

On 21 September 2026 at 01:40:48 UTC, the miner nexa:nqtsq5g5nwxfq4n4z7tmw06wyxrfyg90lyu3v8mx4ntm3t6z sent in a share that was 2.31 times better than needed for a block. Its winning guess, the nonce, was 59617ba000002501e1ebca4b83aa61da. drillhash.com answered "accepted". That block should have appeared on the Nexa network moments later. It never did. The next block on the network came nine minutes later, found by somebody else.

What the Nexa network shows for those minutes

Every block on the network is public, numbered, and carries the nonce, the winning guess that made it. Our block was found between block 1152476 and block 1152477. Here are the blocks around that time, straight from the public Nexa explorer. Our winning guess is not in any of them, nor in any block since.

The whole test on one picture

Each dot is one of the best shares our machines sent to drillhash.com over the 35 hours. The higher a dot, the harder the share, and the closer it came to being a block. The dashed line is the network difficulty, the bar a share has to clear to be a block. There is exactly one dot above the line, and that block was never published.

Could this be bad luck or a broken miner?

No. Mining is a game of chance with known odds, like rolling dice. From the amount of work our machines did, we can predict how many "near misses" of each size there should be. The near misses came in right on schedule, which means the machines were working normally and drillhash.com was giving them proper work. The only thing missing is the block itself, and chance cannot explain that: a block that was found and accepted does not disappear on its own.

Check it yourself

You do not have to take our word for any of this. Everything needed to check it is on this page. The first step needs some technical skill; the others need none.

1. For the technical reader: recompute the block. The script below is complete and needs nothing but Python 3. It computes the Nexa proof of work for the header commitment and nonce shown above, exactly as a Nexa node does, and compares it with the network difficulty encoded in the pool's own nbits value 1b00f7f5. It prints the share difficulty, the network difficulty, and whether it is a block.
   Copy

   # NexaPoW check, plain Python 3, no libraries needed. Run: python3 verify_block.py
   import hashlib, hmac
   
   HEADER = "9dd99b372c9b698589fd92fe0dd4a02e422029d18b1599400549a8e3f4d6daac"
   NONCE  = "59617ba000002501e1ebca4b83aa61da"
   NBITS  = "1b00f7f5"
   
   # secp256k1 curve
   P = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F
   N = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141
   G = (0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798,
        0x483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8)
   
   def add(a, b):
       if a is None: return b
       if b is None: return a
       if a[0] == b[0] and a[1] != b[1]: return None
       l = (3*a[0]*a[0]) * pow(2*a[1], P-2, P) if a == b else (b[1]-a[1]) * pow(b[0]-a[0], P-2, P)
       x = (l*l - a[0] - b[0]) % P
       return (x, (l*(a[0]-x) - a[1]) % P)
   
   def mul(k, pt=G):
       r = None
       while k:
           if k & 1: r = add(r, pt)
           pt = add(pt, pt); k >>= 1
       return r
   
   def rfc6979_k(key, msg):                      # deterministic nonce, as libsecp256k1
       blob = key + msg + b"Schnorr+SHA256  "
       V, K = b"\x01"*32, b"\x00"*32
       K = hmac.new(K, V + b"\x00" + blob, hashlib.sha256).digest(); V = hmac.new(K, V, hashlib.sha256).digest()
       K = hmac.new(K, V + b"\x01" + blob, hashlib.sha256).digest(); V = hmac.new(K, V, hashlib.sha256).digest()
       while True:
           V = hmac.new(K, V, hashlib.sha256).digest(); k = int.from_bytes(V, "big")
           if 0 < k < N: return k
           K = hmac.new(K, V + b"\x00", hashlib.sha256).digest(); V = hmac.new(K, V, hashlib.sha256).digest()
   
   def schnorr_sign(key, msg):                   # Bitcoin Cash Schnorr
       d = int.from_bytes(key, "big"); k = rfc6979_k(key, msg)
       Rx, Ry = mul(k)
       if pow(Ry, (P-1)//2, P) != 1: k = N - k
       Px, Py = mul(d)
       pub = (b"\x03" if Py & 1 else b"\x02") + Px.to_bytes(32, "big")
       e = int.from_bytes(hashlib.sha256(Rx.to_bytes(32, "big") + pub + msg).digest(), "big") % N
       return Rx.to_bytes(32, "big") + ((k + e*d) % N).to_bytes(32, "big")
   
   def nexa_pow(header, nonce):                  # exactly what a Nexa node computes
       mining_hash = hashlib.sha256(hashlib.sha256(header + bytes([len(nonce)]) + nonce).digest()).digest()
       sig = schnorr_sign(mining_hash, hashlib.sha256(mining_hash).digest())
       return int.from_bytes(hashlib.sha256(sig).digest(), "little")
   
   def target(nbits):                            # compact bits -> 256-bit target
       b = int(nbits, 16); mant = b & 0x7FFFFF; exp = b >> 24
       return mant << (8*(exp-3)) if exp > 3 else mant >> (8*(3-exp))
   
   value = nexa_pow(bytes.fromhex(HEADER), bytes.fromhex(NONCE))
   need  = target(NBITS)
   MAX   = 2**256 - 1
   def short(d): return f"{d/1e12:.1f} T"           # trillions, as on the report page
   print("header commitment :", HEADER)
   print("nonce             :", NONCE)
   print("nbits             :", NBITS)
   print("share difficulty  :", f"{MAX / value:,.0f}", f"({short(MAX / value)})")
   print("network difficulty:", f"{MAX / need:,.0f}", f"({short(MAX / need)})")
   print("is a block        :", value <= need)

2. Look at the public record. Open block 1152476 and block 1152477 on the Nexa explorer, the public ledger anyone can read. Note their times: 01:39:23 and 01:50:04 UTC. Our block was found at 01:40:48. There is nothing between them.
3. Look at drillhash.com's own block list for 21 September 2026 around 01:40 UTC. No block is listed for that time.

What this means for you

• A pool pays its miners out of the blocks it publishes. If the blocks are not published, there is nothing to pay from. Whatever a pool's website shows, a payout needs a published block behind it.
• Every hour on a pool that does not publish blocks costs electricity and earns nothing.
• Any honest pool publishes every block its miners find, and you can see them on the public Nexa explorer. Any pool should be able to point you to its blocks there. That is the proof that matters.

How we made sure the test was fair

• Our checking software does not touch anything. The machines used drillhash.com's own work assignments and difficulty settings, and every reply the machines saw came from drillhash.com. From the pool's side, nothing looked different from a normal miner.
• The network difficulty we measured against came from drillhash.com's own work assignment, and it matches the difficulty of the real blocks around that time on the public explorer. The pool was handing out correct work; the block it received back was not published.
• The rule we used to judge each share is the same one the Nexa network uses. The same code has found and published more than 4,500 blocks elsewhere without a single one going missing.
• drillhash.com answered "accepted", not "rejected", and reported no problem with the share.
• The machines belong to community members who volunteered them. Wallet addresses are shortened above, except the one that found the block, so the claim can be checked against drillhash.com's own website.

Thank you: rewards for the volunteers

To thank the community members who lent their machines to this audit, every 850M INIBOX earns 2,000,000 NEXA for each 24 hours of audited mining. Rewards are sent to the address each machine mined with.

We are giving our own reward to the volunteers too. Our machines took part in the audit and, at the same rate, earned 3,763,889 NEXA. We are not keeping it. It is shared out among the volunteers, and whoever mined longer gets a larger part. So each volunteer receives two amounts: the reward for their own mining, plus their part of ours.

What drillhash.com says

We sent this report to drillhash.com's operator before publishing it and asked about the missing block. Their answer was that the pool works correctly. We have not received an explanation for where the block went, and it is still not on the network. We do not know what the cause is on their side, and this page does not claim to. What the data shows is simpler: a block was found, the pool accepted it, and the network never saw it. Until that changes, mining there cannot produce a block.

Questions and corrections are welcome through the community channels linked on the home page. If drillhash.com can show this block on the Nexa network, or explain what happened to it, we will update this page.