cougr-core 1.0.0

Cougr - A Soroban-compatible ECS framework for on-chain gaming on Stellar
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

//! Pedersen commitment scheme using BN254 G1 curve points.
//!
//! A Pedersen commitment `C = v*G + r*H` allows committing to a value `v`
//! with blinding factor `r`, such that:
//! - The commitment hides `v` (information-theoretically secure with random `r`)
//! - The commitment is binding (computationally secure under discrete log assumption)

use soroban_sdk::{contracttype, Env};

use super::crypto::{bn254_g1_add, bn254_g1_mul};
use super::error::ZKError;
use super::types::{G1Point, Scalar};

/// Pedersen commitment parameters: two independent G1 generator points.
///
/// `g` is the "value generator" and `h` is the "blinding generator".
/// These must be chosen such that the discrete log of `h` with respect to `g`
/// is unknown (nothing-up-my-sleeve construction recommended).
#[contracttype]
#[derive(Clone, Debug)]
pub struct PedersenParams {
    /// Value generator point (G1).
    pub g: G1Point,
    /// Blinding generator point (G1).
    pub h: G1Point,
}

/// A Pedersen commitment point on BN254 G1.
#[contracttype]
#[derive(Clone, Debug)]
pub struct PedersenCommitment {
    /// The commitment point C = v*G + r*H.
    pub point: G1Point,
}

/// Create a Pedersen commitment: `C = value * G + blinding * H`.
///
/// # Arguments
/// - `params`: Generator points (G, H)
/// - `value`: The value to commit to (scalar field element)
/// - `blinding`: Random blinding factor (scalar field element)
pub fn pedersen_commit(
    env: &Env,
    params: &PedersenParams,
    value: &Scalar,
    blinding: &Scalar,
) -> Result<PedersenCommitment, ZKError> {
    let vg = bn254_g1_mul(env, &params.g, value)?;
    let rh = bn254_g1_mul(env, &params.h, blinding)?;
    let point = bn254_g1_add(env, &vg, &rh)?;
    Ok(PedersenCommitment { point })
}

/// Verify a Pedersen commitment opening.
///
/// Checks that `commitment == value * G + blinding * H`.
pub fn pedersen_verify(
    env: &Env,
    params: &PedersenParams,
    commitment: &PedersenCommitment,
    value: &Scalar,
    blinding: &Scalar,
) -> Result<bool, ZKError> {
    let expected = pedersen_commit(env, params, value, blinding)?;
    Ok(commitment.point.bytes == expected.point.bytes)
}

#[cfg(test)]
mod tests {
    use super::*;
    use soroban_sdk::{BytesN, Env};

    #[test]
    fn test_pedersen_params_creation() {
        let env = Env::default();
        let params = PedersenParams {
            g: G1Point {
                bytes: BytesN::from_array(&env, &[0u8; 64]),
            },
            h: G1Point {
                bytes: BytesN::from_array(&env, &[0u8; 64]),
            },
        };
        assert_eq!(params.g.bytes.len(), 64);
        assert_eq!(params.h.bytes.len(), 64);
    }

    #[test]
    fn test_pedersen_commitment_type_creation() {
        let env = Env::default();
        let commitment = PedersenCommitment {
            point: G1Point {
                bytes: BytesN::from_array(&env, &[0u8; 64]),
            },
        };
        assert_eq!(commitment.point.bytes.len(), 64);
    }

    #[test]
    fn test_pedersen_same_commitment_equals() {
        let env = Env::default();
        let c1 = PedersenCommitment {
            point: G1Point {
                bytes: BytesN::from_array(&env, &[1u8; 64]),
            },
        };
        let c2 = PedersenCommitment {
            point: G1Point {
                bytes: BytesN::from_array(&env, &[1u8; 64]),
            },
        };
        assert_eq!(c1.point.bytes, c2.point.bytes);
    }

    #[test]
    fn test_pedersen_different_commitments_differ() {
        let env = Env::default();
        let c1 = PedersenCommitment {
            point: G1Point {
                bytes: BytesN::from_array(&env, &[1u8; 64]),
            },
        };
        let c2 = PedersenCommitment {
            point: G1Point {
                bytes: BytesN::from_array(&env, &[2u8; 64]),
            },
        };
        assert_ne!(c1.point.bytes, c2.point.bytes);
    }
}