sigma-compiler/tests/macro_test.rs

use curve25519_dalek::{RistrettoPoint, Scalar};
use group::Group;
use rand::rngs::OsRng;
use sigma_compiler::sigma_compiler;

type G = RistrettoPoint;

#[allow(non_snake_case)]
#[test]
fn test_cli_proof1() {
    sigma_compiler! {
        client_proof < G >,
        (rand s_iss_cred_UAC, iss_Jattr_UAC_nym_id, pub
        _iss_Rattr_UAC_measurement_count, pub _iss_Rattr_UAC_age,),
        (cind X_iss_Jattr_UAC_nym_id, C_iss_cred_UAC, cind const A_generator, cind
        const B_generator,),
        C_iss_cred_UAC = s_iss_cred_UAC * A_generator + iss_Jattr_UAC_nym_id * X_iss_Jattr_UAC_nym_id,
    };

    // Rng
    let mut rng = OsRng;
    // Witness
    let s_iss_cred_UAC = Scalar::random(&mut rng);
    let iss_Jattr_UAC_nym_id = Scalar::random(&mut rng);
    // Parameters
    let X_iss_Jattr_UAC_nym_id = G::random(&mut rng);
    let A_generator = G::generator();
    let C_iss_cred_UAC =
        s_iss_cred_UAC * A_generator + iss_Jattr_UAC_nym_id * X_iss_Jattr_UAC_nym_id;
    let B_generator = G::default();
    let iss_Rattr_UAC_measurement_count = Scalar::default();
    let iss_Rattr_UAC_age = Scalar::default();

    // Protocol
    let protocol = client_proof::Protocol::new(
        A_generator,
        B_generator,
        C_iss_cred_UAC,
        X_iss_Jattr_UAC_nym_id,
        iss_Rattr_UAC_age,
        iss_Rattr_UAC_measurement_count,
    );

    let witness = client_proof::Witness(vec![iss_Jattr_UAC_nym_id, s_iss_cred_UAC]);

    let proof = client_proof::prove(&protocol, &witness);
    assert!(proof.is_ok());
    let verify_result = client_proof::verify(&protocol, &proof.unwrap());
    assert!(verify_result.is_ok());
}

#[allow(non_snake_case)]
#[test]
fn test_iss_proof() {
    sigma_compiler! {
        issuer_proof < G > ,
        (rand b_iss_cred_UAC, x0_iss_cred_UAC,),
        (P_iss_cred_UAC, X0_iss_cred_UAC, K_iss_cred_UAC, R_iss_cred_UAC, cind
        const A_generator, cind const B_generator,),
        P_iss_cred_UAC = b_iss_cred_UAC * A_generator,
        X0_iss_cred_UAC = x0_iss_cred_UAC * B_generator,
        R_iss_cred_UAC = x0_iss_cred_UAC * P_iss_cred_UAC + b_iss_cred_UAC * K_iss_cred_UAC,
    };

    // Rng
    let mut rng = OsRng;
    // Witness
    let b_iss_cred_UAC = Scalar::random(&mut rng);
    let x0_iss_cred_UAC = Scalar::random(&mut rng);
    // Parameters
    let A_generator = G::generator();
    let B_generator = G::default();
    let K_iss_cred_UAC = G::random(&mut rng);
    let P_iss_cred_UAC = b_iss_cred_UAC * A_generator;
    let R_iss_cred_UAC = x0_iss_cred_UAC * P_iss_cred_UAC + b_iss_cred_UAC * K_iss_cred_UAC;
    let X0_iss_cred_UAC = x0_iss_cred_UAC * B_generator;

    // Protocol
    let protocol = issuer_proof::Protocol::new(
        A_generator,
        B_generator,
        K_iss_cred_UAC,
        P_iss_cred_UAC,
        R_iss_cred_UAC,
        X0_iss_cred_UAC,
    );

    let witness = issuer_proof::Witness(vec![b_iss_cred_UAC, x0_iss_cred_UAC]);

    let proof = issuer_proof::prove(&protocol, &witness);
    assert!(proof.is_ok());
    let verify_result = issuer_proof::verify(&protocol, &proof.unwrap());
    assert!(verify_result.is_ok());
}

#[allow(non_snake_case)]
#[test]
fn test_cli_proof2() {
    sigma_compiler! {
        client_proof < G > ,
        (rand s_iss_cred_New, rand zQ_show_cred_Old, rand z_show_Hattr_Old_nym_id,
        rand z_show_Hattr_Old_age, rand z_show_Hattr_Old_measurement_count,
        iss_Hattr_New_measurement_count, iss_Hattr_New_age, iss_Hattr_New_nym_id,
        show_Hattr_Old_nym_id, show_Hattr_Old_age,
        show_Hattr_Old_measurement_count,),
        (cind X_iss_Hattr_New_measurement_count, cind X_iss_Hattr_New_age, cind
        X_iss_Hattr_New_nym_id, cind P_show_cred_Old, cind
        X_show_Hattr_Old_nym_id, cind X_show_Hattr_Old_age, cind
        X_show_Hattr_Old_measurement_count, C_iss_cred_New, V_show_cred_Old,
        C_show_Hattr_Old_nym_id, C_show_Hattr_Old_age,
        C_show_Hattr_Old_measurement_count, cind const A_generator, cind const
        B_generator,),
        // show_Hattr_Old_nym_id == iss_Hattr_New_nym_id &&
        // show_Hattr_Old_age == iss_Hattr_New_age &&
        // show_Hattr_Old_measurement_count + Scalar :: from(1u64) == iss_Hattr_New_measurement_count,
        C_iss_cred_New = s_iss_cred_New * A_generator + iss_Hattr_New_measurement_count *
            X_iss_Hattr_New_measurement_count + iss_Hattr_New_age *
            X_iss_Hattr_New_age + iss_Hattr_New_nym_id * X_iss_Hattr_New_nym_id,
        C_show_Hattr_Old_nym_id = show_Hattr_Old_nym_id * P_show_cred_Old +
            z_show_Hattr_Old_nym_id * A_generator,
        C_show_Hattr_Old_age = show_Hattr_Old_age * P_show_cred_Old + z_show_Hattr_Old_age * A_generator,
        C_show_Hattr_Old_measurement_count = show_Hattr_Old_measurement_count *
            P_show_cred_Old + z_show_Hattr_Old_measurement_count * A_generator,
        V_show_cred_Old = zQ_show_cred_Old * B_generator + z_show_Hattr_Old_nym_id
            * X_show_Hattr_Old_nym_id + z_show_Hattr_Old_age * X_show_Hattr_Old_age +
            z_show_Hattr_Old_measurement_count * X_show_Hattr_Old_measurement_count,
    }

    // Rng
    let mut rng = OsRng;
    // Witness
    let iss_Hattr_New_age = Scalar::random(&mut rng);
    let iss_Hattr_New_measurement_count = Scalar::random(&mut rng);
    let iss_Hattr_New_nym_id = Scalar::random(&mut rng);
    let show_Hattr_Old_age = Scalar::random(&mut rng);
    let show_Hattr_Old_measurement_count = Scalar::random(&mut rng);
    let show_Hattr_Old_nym_id = Scalar::random(&mut rng);
    let s_iss_cred_New = Scalar::random(&mut rng);
    let zQ_show_cred_Old = Scalar::random(&mut rng);
    let z_show_Hattr_Old_age = Scalar::random(&mut rng);
    let z_show_Hattr_Old_measurement_count = Scalar::random(&mut rng);
    let z_show_Hattr_Old_nym_id = Scalar::random(&mut rng);

    // Parameters
    let A_generator = G::generator();
    let B_generator = G::default();
    let P_show_cred_Old = G::random(&mut rng);
    let X_show_Hattr_Old_age = G::random(&mut rng);
    let X_show_Hattr_Old_nym_id = G::random(&mut rng);
    let X_show_Hattr_Old_measurement_count = G::random(&mut rng);
    let X_iss_Hattr_New_age = G::random(&mut rng);
    let X_iss_Hattr_New_nym_id = G::random(&mut rng);
    let X_iss_Hattr_New_measurement_count = G::random(&mut rng);

    let C_iss_cred_New = s_iss_cred_New * A_generator
        + iss_Hattr_New_measurement_count * X_iss_Hattr_New_measurement_count
        + iss_Hattr_New_age * X_iss_Hattr_New_age
        + iss_Hattr_New_nym_id * X_iss_Hattr_New_nym_id;
    let C_show_Hattr_Old_age =
        show_Hattr_Old_age * P_show_cred_Old + z_show_Hattr_Old_age * A_generator;
    let C_show_Hattr_Old_nym_id =
        show_Hattr_Old_nym_id * P_show_cred_Old + z_show_Hattr_Old_nym_id * A_generator;
    let C_show_Hattr_Old_measurement_count = show_Hattr_Old_measurement_count * P_show_cred_Old
        + z_show_Hattr_Old_measurement_count * A_generator;
    let V_show_cred_Old = zQ_show_cred_Old * B_generator
        + z_show_Hattr_Old_nym_id * X_show_Hattr_Old_nym_id
        + z_show_Hattr_Old_age * X_show_Hattr_Old_age
        + z_show_Hattr_Old_measurement_count * X_show_Hattr_Old_measurement_count;

    // Protocol
    let protocol = client_proof::Protocol::new(
        A_generator,
        B_generator,
        C_iss_cred_New,
        C_show_Hattr_Old_age,
        C_show_Hattr_Old_measurement_count,
        C_show_Hattr_Old_nym_id,
        P_show_cred_Old,
        V_show_cred_Old,
        X_iss_Hattr_New_age,
        X_iss_Hattr_New_measurement_count,
        X_iss_Hattr_New_nym_id,
        X_show_Hattr_Old_age,
        X_show_Hattr_Old_measurement_count,
        X_show_Hattr_Old_nym_id,
    );

    let witness = client_proof::Witness(vec![
        iss_Hattr_New_age,
        iss_Hattr_New_measurement_count,
        iss_Hattr_New_nym_id,
        s_iss_cred_New,
        show_Hattr_Old_age,
        show_Hattr_Old_measurement_count,
        show_Hattr_Old_nym_id,
        zQ_show_cred_Old,
        z_show_Hattr_Old_age,
        z_show_Hattr_Old_measurement_count,
        z_show_Hattr_Old_nym_id,
    ]);

    let proof = client_proof::prove(&protocol, &witness);
    assert!(proof.is_ok());
    let verify_result = client_proof::verify(&protocol, &proof.unwrap());
    assert!(verify_result.is_ok());
}