Grant Application - Zcash Mining Job Delivery Benchmark

Project Summary

We will build a self-hosted benchmark that shows Zcash mining pool operators how long it takes fresh work to reach a connected worker after a new block arrives. We will publish results from two open-source pool implementations and give operators the same tool to test their next Zebra upgrade or change to a pool setting.

Project Description

Over eight weeks, we will trace mining jobs through the Zcash Foundation’s s-nomp fork and Sovright’s pool with its Zcash Stratum proxy. In each setup, an operator will be able to see when a local reference node observed the block, when the pool received Zebra’s template, and when the worker received the corresponding job. Those timings show where a release or configuration change made a difference.

Our prototype already reproduces a case where the pool’s behavior matters. We gave the adapter used in Zakura v1.8.9’s mining example a revised template with the same parent and one synthetic transaction. Its ordinary update path kept the old job. An explicit refresh with the identical input produced a job that committed to the revised transaction set. Reviewers can run all three local checks with Node.js 24 and node run.cjs. The grant covers the live measurements. Prototype and instructions

Proposed Problem

When a new block becomes the chain tip, a worker can keep hashing on the previous parent until replacement work reaches it. NU7 reduced Zcash’s target block interval from 75 seconds to 25 seconds. The same delay now consumes three times as much of that interval.

On November 19, 2026, the Zcash Foundation asked miners and pools to compare how quickly new work arrived with Zebra 7.2.0-beta.1 and 7.1.0. Zebra reports how quickly it prepares the first template. The worker receives its job on a separate connection downstream of the pool. An operator can see a better node timing after an upgrade and still have to determine whether the worker gained that time, or whether the pool was waiting to fetch the template or send the job. Foundation release and testing request

There is a second case that a successful switch to the new parent can hide. If Zebra supplies a revised transaction set and the pool keeps serving the earlier job, the worker can build on the right parent while omitting transactions already available to the pool.

Proposed Solution

We will run two side-by-side comparisons. For the Zebra upgrade test, we will run the same documented s-nomp long-poll configuration against two Zebra releases on the same chain. For the pool settings test, we will keep the Zebra release fixed and run Sovright’s pool with its template polling interval set to 1,000 milliseconds and 250 milliseconds.

For each pair we will show when the first job for each shared parent reached each worker. We will also count how often a revised transaction set reached the worker before the next parent arrived. An operator can use the first comparison to evaluate an upgrade and the second to weigh faster polling against the extra RPC requests it makes.

Solution Format

A command-line tool for capture, comparison, and replay, two runnable pool configurations, a documented JSON format, sanitized captures, and an operator guide with the results. Reviewers can replay the published data offline. Operators with synchronized nodes can collect new measurements. We will release our original code under MIT and include license notices for third-party components.

Dependencies

We need mainnet-synced Zebra nodes, temporary Linux servers in two regions, and the public source for both pool implementations. We will run the nodes, pools, and worker clients ourselves. Operators can repeat the study using their own infrastructure. Zebra’s s-nomp integration guide · Sovright mining infrastructure

Technical Approach

At each site, one recorder will use a monotonic clock to timestamp the local reference node’s tip notification, the matching getblocktemplate response on the pool’s own RPC connection, and the worker’s receipt of mining.notify. We will match parent hashes across configurations running at the same site and time. If the worker receives a job before the reference node reports the tip, we preserve that signed difference.

For updates on the same parent, we will match changes in the pool’s non-coinbase transaction list to the outgoing job’s Merkle root. If a pool rebuilds the root, we will record its input-to-job mapping. We will count updates delivered before the next parent, updates with no matching job by then during continuous recording, and cases left indeterminate by a capture gap. We will count timestamp-only refreshes separately. Zcash Stratum protocol

Upstream Merge Opportunities

The benchmark will run alongside Zebra and both pools. Our launcher will use their existing interfaces, including Sovright’s configurable template polling interval. Operators can run the complete benchmark from our repository. If we find an upstream issue, the affected maintainers can use our pinned configuration and capture to reproduce it.

Open Source License

MIT

Hardware/Software Costs (USD)

$0

Hardware/Software Justification

We will use existing development machines and open-source software. The timing measurement ends when the software worker receives the job, so the project requires no mining hardware purchase.

Service Costs (USD)

$2,200

Service Costs Justification

We budgeted $1,800 for temporary servers and node storage in two regions, and $400 for capture storage, transfer, and a clean machine for reproducing the release. These services cover the eight-week project.

Compensation Costs (USD)

$22,800for comoensation .. break it down based i

Compensation Costs Justification

We estimate 240 hours at $95 per hour, for a total of $22,800.

  1. Build and test the job recorder (70 hours, $6,650). Connect the recorder to s-nomp and Sovright. Capture when the reference node sees a new block, when the pool receives Zebra’s template, and when the worker receives the job. Add replay checks for parent changes, same-parent transaction updates, and recording gaps.

  2. Run the live comparisons (90 hours, $8,550). Compare two Zebra releases on s-nomp and two polling intervals on Sovright. Across two sites, collect at least 1,000 matched parent hashes per comparison. Calculate median and 95th-percentile delivery times, count RPC requests, and measure how often revised work reaches the worker before the next parent arrives.

  3. Package the tool and verify the results (80 hours, $7,600). Release the CLI, pinned configurations, and sanitized captures. Reproduce the published counts and timings on a clean Linux machine, then publish the comparison report and instructions for operators to repeat the tests.

Total Budget (USD)

$25,000

Previous Funding

Yes

Previous Funding Details

Dapps over Apps received ZCG funding for ZecKit. We delivered a local Zebra development network and a reusable GitHub Action for end-to-end tests.

Other Funding Sources

No

Other Funding Sources Details

We have no other funding for this project and do not plan to receive any.

Implementation Risks

Release support windows can change during collection. We will choose two mainnet-compatible Zebra releases within their support windows, pin their versions, and record the collection dates. If we have to switch versions, we will keep the runs separate. Reconnects, competing tips, and gaps can make a job hard to match. We will preserve those records, report their counts, and keep ambiguous events out of the timing percentiles.

Potential Side Effects

The recorder can add delay, and shorter polling intervals can increase load on Zebra. We will check worker arrival times with pool-side tracing on and off, and publish RPC request counts alongside delivery times. Our test workers will subscribe to jobs with share submission disabled. Public captures will contain site labels, build versions, relative timestamps, block hashes, template and job fingerprints, and counts. Operators can keep captures from their own deployments private.

Success Metrics

  • Both pool implementations deliver jobs to a software worker, and the replay correctly identifies parent changes, same-parent transaction updates, and capture gaps.
  • Each side-by-side comparison includes at least 1,000 distinct parent hashes matched across its two configurations. Both sites contribute observations. A parent seen at both sites counts once toward the minimum.
  • The report gives the median and 95th-percentile delivery times, matched and unmatched counts by site and configuration, and the outcome counts for same-parent transaction updates.
  • A reviewer with the documented prerequisites can reproduce the published counts and timing statistics from the release archive on a clean Linux machine within 30 minutes.

Startup Funding (USD)

$0

Startup Funding Justification

We will begin work using its existing setup. We request payment after each milestone is accepted.

Milestone Details

  • Milestone: 1
    Name: Capture a job from each pool and replay it
    Amount (USD): 7000
    Proposed Start Date: 2027-01-04
    Expected Completion Date: 2027-01-15
    User Stories:

    • As a pool developer, I want to trace a template to the job my worker receives and recognize an incomplete recording.
      Deliverables:
    • Working capture on both pool implementations, pinned configurations, a documented event format, and a one-command replay.
      Acceptance Criteria:
    • A reviewer can replay a captured job from each pool and match it to its parent and input template.
    • Supplied test cases distinguish a parent change, a same-parent transaction update, and a recording gap.
  • Milestone: 2
    Name: Compare Zebra releases and pool polling intervals on mainnet
    Amount (USD): 10000
    Expected Completion Date: 2027-02-05
    User Stories:

    • As a pool operator, I want to know what changes at the worker when I upgrade Zebra or change how often my pool requests templates.
      Deliverables:
    • Paired captures from both sites for the two Zebra releases on s-nomp and the two polling intervals on Sovright, with versions, settings, and sample counts.
      Acceptance Criteria:
    • Each comparison includes at least 1,000 distinct matched parent hashes across the two sites.
    • A reviewer can reproduce the median and 95th-percentile timings by site and configuration, the RPC request counts, and the delivered, unmatched, and indeterminate same-parent update counts.
  • Milestone: 3
    Name: Publish the operator release and comparison report
    Amount (USD): 8000
    Expected Completion Date: 2027-02-26
    User Stories:

    • As a release engineer, I want to reproduce the published comparison and run the same check before a later upgrade.
      Deliverables:
    • Tagged CLI release, sanitized capture archive, comparison report, operator guide, and contributor instructions.
      Acceptance Criteria:
    • On a clean Linux machine with the documented prerequisites, a reviewer can regenerate the published counts, medians, and 95th percentiles in 30 minutes or less.
    • The guide provides the commands and configurations needed to run a fresh comparison on the operator’s own synchronized nodes.

Supporting Documents

Prototype and replay instructions
https://github.com/Supercoolkayy/zcash-mining-job-delivery-checks

Recorded output from all three local checks at the reviewed commit

Welcome — a fellow applicant here, and this one sits close to the work we do, so we read it end to end.

The sharpest thing in it is the prototype result. You gave the adapter from Zakura v1.8.9’s mining example a revised template — same parent, one synthetic transaction added — and its ordinary update path kept serving the old job, while an explicit refresh with the identical input produced a job that committed to the revised transaction set. A pool can land on the right parent and still leave transactions the node had already offered on the table, and your three local checks make that visible with one command instead of an argument.

The measurement design earns trust the same way. One recorder on one monotonic clock at each site, timing three points: when the local reference node reports the tip, when the pool receives Zebra’s template on its own connection, and when the worker receives the job. Comparisons matched by parent hash across configurations running at the same site and time, at least 1,000 matched parents per comparison — and if a worker receives a job before the reference node reports the tip, that signed difference is preserved rather than clipped away.

The care around the edges matters too: the recorder itself checked with pool-side tracing on and off, so its own delay is measured; RPC request counts published beside the delivery times, so faster polling shows its cost; and events a capture gap leaves uncertain counted as indeterminate, kept out of the timing percentiles rather than folded in.

At a 25-second target interval, the time between a new parent and fresh work reaching a worker is real production time, and until now an operator could see a better node timing after an upgrade without knowing whether the worker gained any of it. This answers that at the worker, where it counts. Good luck with the review.