2-player dummy lottery

Signed-off-by: Dikshant <[email protected]>

Author: pingu-73

Cargo.lock

@@ -1,5 +1,5 @@
 [workspace]
-members = ["arkive-core", "arkive-cli"]
+members = ["arkive-core", "arkive-cli", "arkive-lottery", "coinflip-cli"]
 resolver = "2"
 
 [workspace.dependencies]

Cargo.toml

@@ -0,0 +1,22 @@
+[package]
+name = "arkive-lottery"
+version = "0.1.0"
+edition = "2021"
+description = "Zero-collateral lottery implementation"
+authors = ["Dikshant <[email protected]>"]
+license = "MIT OR Apache-2.0"
+
+[dependencies]
+arkive-core = { path = "../arkive-core" }
+bitcoin = { workspace = true }
+serde = { workspace = true, features = ["derive"] }
+serde_json = { workspace = true }
+tokio = { workspace = true }
+anyhow = { workspace = true }
+thiserror = { workspace = true }
+uuid = { workspace = true, features = ["v4", "serde"] }
+chrono = { workspace = true, features = ["serde"] }
+sha2 = "0.10"
+hex = "0.4"
+rand = "0.8"
+tracing = { workspace = true }

arkive-lottery/Cargo.toml

@@ -0,0 +1,89 @@
+pub mod scheme;
+
+pub use scheme::{Commitment, CommitmentScheme};
+
+use rand::RngCore;
+use serde::{Deserialize, Serialize};
+use sha2::{Digest, Sha256};
+
+/// Hash based commitment impl
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct HashCommitment {
+    hash: Vec<u8>,
+    #[serde(skip)]
+    secret: Option<Vec<u8>>,
+}
+
+impl HashCommitment {
+    pub fn new(secret: Vec<u8>) -> Self {
+        let mut hasher = Sha256::new();
+        hasher.update(&secret);
+        let hash = hasher.finalize().to_vec();
+
+        Self {
+            hash,
+            secret: Some(secret),
+        }
+    }
+
+    pub fn from_hash(hash: Vec<u8>) -> Self {
+        Self { hash, secret: None }
+    }
+
+    pub fn hash(&self) -> &[u8] {
+        &self.hash
+    }
+
+    pub fn verify(&self, secret: &[u8]) -> bool {
+        let mut hasher = Sha256::new();
+        hasher.update(secret);
+        let computed_hash = hasher.finalize();
+        computed_hash.as_slice() == self.hash
+    }
+
+    pub fn reveal(self) -> Option<Vec<u8>> {
+        self.secret
+    }
+}
+
+/// Rnd secret for commitment
+pub fn generate_secret() -> Vec<u8> {
+    let mut secret = vec![0u8; 32];
+    rand::thread_rng().fill_bytes(&mut secret);
+    secret
+}
+
+/// Winner from two secrets using XOR
+pub fn determine_winner(secret1: &[u8], secret2: &[u8]) -> bool {
+    let combined = secret1
+        .iter()
+        .zip(secret2.iter())
+        .map(|(a, b)| a ^ b)
+        .collect::<Vec<u8>>();
+
+    let winner_bit = combined.iter().fold(0u8, |acc, &byte| acc ^ byte) & 1;
+    winner_bit == 0 // true = player1 wins, false = player2 wins
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_commitment_scheme() {
+        let secret = generate_secret();
+        let commitment = HashCommitment::new(secret.clone());
+
+        assert!(commitment.verify(&secret));
+        assert!(!commitment.verify(b"wrong secret"));
+    }
+
+    #[test]
+    fn test_winner_determination() {
+        let secret1 = vec![0x00, 0x00, 0x00, 0x00];
+        let secret2 = vec![0x00, 0x00, 0x00, 0x01];
+
+        let winner = determine_winner(&secret1, &secret2);
+        assert!(!winner);
+    }
+}

arkive-lottery/src/commitment/mod.rs

@@ -0,0 +1,66 @@
+use crate::Result;
+use chrono::{DateTime, Utc};
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+
+/// Trait for commitment schemes
+pub trait CommitmentScheme {
+    type Secret;
+    type Commitment;
+
+    fn commit(secret: Self::Secret) -> Self::Commitment;
+    fn verify(commitment: &Self::Commitment, secret: &Self::Secret) -> bool;
+}
+
+/// A commitment in the lottery protocol
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Commitment {
+    pub hash: Vec<u8>,
+    pub player_id: Uuid,
+    pub timestamp: DateTime<Utc>,
+    pub nonce: Vec<u8>, // to prevent replay
+}
+
+impl Commitment {
+    pub fn new(hash: Vec<u8>, player_id: Uuid) -> Self {
+        let mut nonce = vec![0u8; 16];
+        rand::RngCore::fill_bytes(&mut rand::thread_rng(), &mut nonce);
+
+        Self {
+            hash,
+            player_id,
+            timestamp: Utc::now(),
+            nonce,
+        }
+    }
+
+    pub fn verify_secret(&self, secret: &[u8]) -> Result<bool> {
+        use sha2::{Digest, Sha256};
+
+        let mut hasher = Sha256::new();
+        hasher.update(secret);
+        hasher.update(&self.nonce);
+        let computed_hash = hasher.finalize();
+
+        Ok(computed_hash.as_slice() == self.hash)
+    }
+
+    pub fn create_with_secret(secret: &[u8], player_id: Uuid) -> Self {
+        use sha2::{Digest, Sha256};
+
+        let mut nonce = vec![0u8; 16];
+        rand::RngCore::fill_bytes(&mut rand::thread_rng(), &mut nonce);
+
+        let mut hasher = Sha256::new();
+        hasher.update(secret);
+        hasher.update(&nonce);
+        let hash = hasher.finalize().to_vec();
+
+        Self {
+            hash,
+            player_id,
+            timestamp: Utc::now(),
+            nonce,
+        }
+    }
+}

arkive-lottery/src/commitment/scheme.rs

@@ -0,0 +1,43 @@
+use thiserror::Error;
+use uuid::Uuid;
+
+pub type Result<T> = std::result::Result<T, LotteryError>;
+
+#[derive(Error, Debug)]
+pub enum LotteryError {
+    #[error("Arkive core error: {0}")]
+    ArkiveCore(#[from] arkive_core::ArkiveError),
+
+    #[error("Invalid game state: {0}")]
+    InvalidState(String),
+
+    #[error("Player not found: {0}")]
+    PlayerNotFound(Uuid),
+
+    #[error("Game is full")]
+    GameFull,
+
+    #[error("Game not ready")]
+    GameNotReady,
+
+    #[error("Commitment already submitted")]
+    CommitmentAlreadySubmitted,
+
+    #[error("Commitment not revealed for player: {0}")]
+    CommitmentNotRevealed(Uuid),
+
+    #[error("Invalid commitment")]
+    InvalidCommitment,
+
+    #[error("Timeout expired")]
+    TimeoutExpired,
+
+    #[error("Cryptographic error: {0}")]
+    Crypto(String),
+
+    #[error("Serialization error: {0}")]
+    Serialization(#[from] serde_json::Error),
+
+    #[error("Internal error: {0}")]
+    Internal(String),
+}