Commit-Reveal

The Commit-Reveal pattern is a fundamental blockchain pattern that enables to:

1. Commit to a value without revealing it (commit phase)
2. Reveal the value later to prove they knew it in advance (reveal phase)

Some use cases:

• Blind Auctions: Bidders commit to their bids first, then reveal them after the bidding period
• Voting Systems: Voters commit their votes early, revealing them only after voting ends
• Knowledge Proofs/Attestations: Proving you knew information at a specific time without revealing it immediately
• Fair Random Number Generation: Players commit to random numbers that get combined later, making it harder to manipulate the outcome

How It Works

1. Commit Phase:

   • User generates a value (secret)
   • User creates a hash of this value
   • User submits only the hash on-chain (commit)

2. Reveal Phase:

   • User submits the original value (reveal)
   • Contract verifies that the hash of the submitted value matches the previously committed hash
   • If it matches then it proves that the user knew the value at the commitment time

Minimal commit-reveal contract:

#[starknet::interface]
pub trait ICommitmentRevealTrait<T> {
    fn commit(ref self: T, commitment: felt252);
    fn reveal(self: @T, secret: felt252) -> bool;
}

#[starknet::contract]
mod CommitmentRevealTraits {
    use starknet::storage::{StoragePointerWriteAccess, StoragePointerReadAccess};
    use core::hash::HashStateTrait;
    use core::pedersen::PedersenTrait;

    #[storage]
    struct Storage {
        commitment: felt252,
    }

    #[abi(embed_v0)]
    impl CommitmentRevealTrait of super::ICommitmentRevealTrait<ContractState> {
        fn commit(ref self: ContractState, commitment: felt252) {
            self.commitment.write(commitment);
        }

        fn reveal(self: @ContractState, secret: felt252) -> bool {
            let hash = PedersenTrait::new(secret).finalize();
            self.commitment.read() == hash
        }
    }
}

Usage example:

// Off-chain, compute the commitment hash for secret
let secret = "My secret";
let offchain_commitment = PedersenTrait::new(secret).finalize();

// Commit on-chain
contract.commit(offchain_commitment);

// Reveal on-chain and assert the result
let reveal_result = contract.reveal(secret);

Some considerations:

• The commit phase must complete before any reveals can start
• Users might choose not to reveal if the outcome is unfavorable (consider adding stake/slashing mechanics to ensure reveals)