Verifiable Incentives: Making Rewards Programs Transparent and Automated

The current state of rewards distribution

Teams want to reward users based on real behavior: sustained participation, cross-application usage, specific onchain actions, or contributions tracked offchain. But executing data-rich logic onchain has historically been difficult or impossible. 

Here's what running a rewards program looks like today:

Data aggregation across multiple sources. Onchain data is difficult to read and extract insights from, which means you have to rely on an indexer to track onchain user activity. Additionally, your rewards might also rely on activity from offchain platforms like Discord. Getting all of this into one place means exporting CSVs, writing scripts to fetch API data, and manually combining datasets that weren't designed to work together.

Manual calculation. Once the data is aggregated, someone has to calculate eligibility and allocations. This might happen in a third-party database, or simply in Excel, with formulas that become increasingly complex as criteria stack up. Conditional logic, weighted scoring, tier thresholds. 

No auditability for users. When allocations are published, users see a wallet address and a number. They have no way to verify how that number was calculated. Even if the protocol publishes the criteria, users have to trust that the team executed the logic correctly and didn't make mistakes in the spreadsheet.

Time-consuming and error prone. The entire process takes days or weeks. And because it's manual, mistakes happen: wrong formulas, missing data, miscalculated weights. When errors surface after distribution, fixing them is costly and damages trust.

What verifiable incentives solve

Space and Time changes this by making rewards programs automated, transparent, and cryptographically verifiable.

Instead of manually aggregating data and calculating allocations in spreadsheets, protocols define the logic once in SQL. Space and Time executes those queries across onchain and offchain data, generates a ZK proof that the computation was performed correctly, and returns verified results that can be enforced onchain.

Automated execution

Protocols specify eligibility criteria and allocation formulas in SQL. Space and Time handles the rest: querying indexed blockchain data, joining it with offchain datasets, computing results, and returning them to a smart contract. No manual exports. No spreadsheet errors. The logic executes deterministically every time.

Transparent and auditable

Users don't just see their allocation, they can verify how it was calculated. Because the queries and results are accompanied by ZK proofs, anyone can confirm that the protocol executed the logic as stated and that the underlying data wasn't tampered with. 

Easier for teams, trustworthy for users

Teams spend less time wrangling data and more time designing meaningful incentive structures. Users get visibility into how rewards are determined and cryptographic assurance that the process was fair. Trust shifts from "believe us" to "verify yourself."

How it works in practice

A protocol wants to reward users based on multiple criteria: transaction volume on their platform, participation in governance votes, and engagement in community campaigns tracked offchain.

With traditional methods:

• Export onchain transaction data from an indexer
• Pull governance voting records from a snapshot tool
• Fetch campaign participation from Galxe or Zealy
• Manually join these datasets in a spreadsheet
• Write formulas to calculate weighted scores
• Spot-check for errors
• Publish allocations with no way for users to verify them

With Space and Time:

• Define the criteria as SQL queries that join onchain activity, governance participation, and offchain engagement data
• Space and Time executes the queries and generates ZK proofs
• Results are returned with cryptographic verification
• Users can see their score and audit the calculation
• The protocol distributes rewards onchain with provable accuracy

The entire process is automated, deterministic, and verifiable.

Rewards programs as verifiable infrastructure

Crypto protocols distribute value based on user behavior, which requires computation over historical data from multiple sources. Running this process manually creates bottlenecks: aggregating data takes time, spreadsheet calculations introduce errors, and users have no way to verify that published allocations are accurate. Operating in a black box undermines the trust that protocols are trying to build.

Verifiable incentives turn rewards programs into infrastructure that protocols can rely on rather than processes they have to manage. The logic becomes transparent because it's expressed as queries anyone can read. Execution is automated, so teams don't spend days reconciling datasets and debugging formulas. Results are cryptographically provable, which means users can verify fairness instead of assuming it. This creates a better experience on both sides: teams build more sophisticated programs without manual overhead, and users participate with confidence that the system works as advertised.