BlindProcure: Onchain Procurement Without Price Leakage
Public blockchains are great at one thing: making outcomes verifiable.
Anyone can inspect the rules. Anyone can check that a transaction executed. Anyone can verify that the resulting state came from the contract and not from a private operator quietly changing things behind the scenes.
That is exactly why procurement should be onchain.
A tender award should not depend on trust in a spreadsheet, a private portal, or someone saying “we followed the process.” The rules, submissions, and final award should be independently checkable.
But procurement has a second requirement that blockchains are bad at by default:
supplier prices need to stay private.
If every supplier submits a bid on a public blockchain, every competitor can immediately see their price. That breaks sealed bidding. It leaks pricing strategy. It affects future negotiations. It turns transparency into a business risk.
That is the trade-off BlindProcure is built around.
How do you make procurement verifiable without making every bid public?
BlindProcure uses Zama FHE to answer that question.
The Problem
Sealed-bid procurement depends on two things that normally conflict.
The first is fairness. Buyers want to prove that the tender was awarded according to the published rules. Suppliers want confidence that bids were processed correctly and that the award was not quietly manipulated.
The second is confidentiality. Suppliers do not want their prices exposed to every competitor, buyer, analyst, and future counterparty.
Traditional blockchains solve the fairness problem by making everything public.
That works for many crypto applications, but it does not work for procurement. A public tender where every bid price is visible is not really a sealed-bid tender. It is an open pricing leak with an audit trail.
BlindProcure keeps the audit trail, but removes the price leak.
What BlindProcure Does
BlindProcure is a confidential procurement dApp built on Zama FHEVM.
A buyer creates a tender with public metadata: title, specification hash, deadline, and budget cap. Approved suppliers then submit encrypted bid prices. The smart contract compares those encrypted bids and selects the lowest valid offer under the budget cap.
The important part is that the contract can compute over the bids while they are still encrypted.
The losing prices are never revealed.
The winning supplier can be made public, so anyone can verify the award result. The winning price stays controlled and can only be decrypted by the buyer or by an auditor the buyer explicitly approves.
So the workflow has three properties at the same time:
- public rules,
- verifiable award,
- confidential supplier pricing.
That combination is the point.
Why FHE Matters Here
Fully Homomorphic Encryption allows computation on encrypted data.
In BlindProcure, suppliers encrypt their bid prices before submitting them. The bid enters the contract as ciphertext. The contract does not need to decrypt the values to compare them.
Instead, Zama FHE lets the contract run the selection logic directly over encrypted bids.
In simple terms:
The contract finds the lowest valid bid while the bids are still encrypted.
That is what makes BlindProcure different from a normal onchain tender. Without FHE, the contract could only compare bids by seeing them. With FHE, the contract can compare encrypted values and keep the losing prices sealed.
This is not privacy as decoration. It is privacy that makes the application possible.
Demo Flow
The live demo follows one procurement workflow from start to finish.
- A buyer signs in and creates a tender.
- The buyer approves suppliers.
- Suppliers submit encrypted bid prices.
- The tender closes after the deadline.
- The buyer finalizes the tender.
- The contract selects the lowest valid encrypted bid.
- The winning supplier is revealed publicly.
- The winning price can be decrypted only by an authorized party.
The public can see that the tender exists, that bids were submitted, that the contract finalized the selection, and that a winner was recorded.
What they cannot see is every supplier’s pricing.
That is the core privacy boundary.
Why This Is A Real Procurement Use Case
Procurement is not just an auction.
In real procurement, buyers often want controlled participation. Suppliers may need to be approved before bidding. There may be a budget cap. The buyer may need to share the winning price with an auditor, but not with every losing supplier.
BlindProcure models that more realistic workflow.
It is not trying to build a settlement layer, a token economy, or a marketplace with every possible feature. The product is intentionally narrow:
confidential bid selection for auditable procurement.
That focus matters. The app demonstrates one workflow where FHE is not optional. If the bid prices are public, the product fails. If the contract cannot compute over encrypted values, the product fails. Zama FHE is directly in the critical path.
Privacy Model
BlindProcure makes some information public by design.
Public data includes:
- tender title,
- specification hash,
- buyer address,
- supplier addresses,
- deadline,
- budget cap,
- bid count,
- winning supplier after reveal.
Private data includes:
- supplier bid prices,
- losing bid prices permanently,
- winning price unless decrypted by the buyer or an approved auditor.
This is the practical privacy model procurement needs. The process is visible. The sensitive pricing is not.
Why Onchain?
A normal procurement system can hide prices, but it usually asks participants to trust the operator.
An onchain system can make the process verifiable, but normally exposes too much data.
BlindProcure combines both sides.
The chain provides the public execution environment. Zama FHE provides confidentiality for the values that should not be exposed. Together, they make it possible to build procurement software where the award is checkable without turning every bid into public market data.
That is the actual value of confidential smart contracts.
Not making everything private.
Making the right things private while keeping the outcome verifiable.
Links
- Live app: https://blindprocure.xyz
- Repository: https://github.com/officialcmg/blindprocure
BlindProcure was built for the Zama Developer Program Builder Track.