Pedersen Commitment - garyyu/rust-secp256k1-zkp GitHub Wiki

	#[test]
	fn test_show_g_and_h() {

		println!("G in (X,Y) coordinates form:\n\tX={:02x?}\n\tY={:02x?}\n\nG in compressed form:\n\t{:02x?}\n\nH in compressed form:\n\t{:02x?}",
                 SecretKey(constants::GENERATOR_X),
                 SecretKey(constants::GENERATOR_Y),
				 Commitment(constants::GENERATOR_G),
                 Commitment(constants::GENERATOR_H),
		);
	}

	#[test]
	fn test_pedersen_zero_r() {

		fn commit(value: u64) -> Commitment {
			let secp = Secp256k1::with_caps(ContextFlag::Commit);
			let blinding = ZERO_KEY;
			secp.commit(value, blinding).unwrap()
		}

		println!("0*G+1*H:\t{:?}\n0*G+2*H:\t{:?}\n0*G+3*H:\t{:?}",
				 commit(1),
				 commit(2),
				 commit(3),
		);
	}

	#[test]
	fn test_pedersen_zero_v() {

		fn commit(blinding: SecretKey) -> Commitment {
			let secp = Secp256k1::with_caps(ContextFlag::Commit);
			secp.commit(0, blinding).unwrap()
		}

		let mut r1 = SecretKey([0;32]);
		let mut r2 = SecretKey([0;32]);
		let mut r3 = SecretKey([0;32]);

		r1.0[31] = 1;
		r2.0[31] = 2;
		r3.0[31] = 3;

		println!("1*G+0*H:\t{:?}\n2*G+0*H:\t{:?}\n3*G+0*H:\t{:?}",
				 commit(r1),
				 commit(r2),
				 commit(r3),
		);
	}

    #[test]
    fn test_pedersen_zero_neg_v() {
        let secp = Secp256k1::with_caps(ContextFlag::Commit);

        fn commit(value: i64, one_or_zero_key: bool) -> Commitment {
            let secp = Secp256k1::with_caps(ContextFlag::Commit);
            let mut blinding = ZERO_KEY;
            if one_or_zero_key {
                blinding = ONE_KEY;
            }

            let v :u64;
            if value >= 0{
                v = value as u64;
                secp.commit(v, blinding).unwrap()
            }else{
                v = -value as u64;
                if blinding != ZERO_KEY {
                    blinding = secp.blind_sum(vec![], vec![blinding]).unwrap();
                }
                let commit = secp.commit(v, blinding).unwrap();
                secp.commit_sum(vec![], vec![commit]).unwrap()
            }
        }

        let commit_1 = commit(-5, false);
        let commit_2 = commit(5, false);

        println!("0*G-5*H:\t{:?}\n0*G+5*H:\t{:?}\n-(0*G-5*H):\t{:?}",
                commit_1,
                commit_2,
                secp.commit_sum(vec![], vec![commit_1]).unwrap(),
        );

        println!("\n");
        let commit_3 = commit(-5, true);
        let commit_4 = commit(5, false);
        let commit_5 = commit(0, true);

        println!("1*G-5*H:\t{:?}\n0*G+5*H:\t{:?}\n1*G+0*H:\t{:?}\nsum first 2:\t{:?}",
                 commit_3,
                 commit_4,
                 commit_5,
                 secp.commit_sum(vec![commit_3, commit_4], vec![]).unwrap(),
        );
    }

    #[test]
    fn bench_generator_h_efficiency() {
        const PC_LENGTH: usize = 1000_000;

        let secp = Secp256k1::with_caps(ContextFlag::Commit);

        /// Generator H' (as compressed curve point (3))
        const GENERATOR_H_V2 : [u8;33] = [
            0x0a,
            0x50, 0x92, 0x9b, 0x74, 0xc1, 0xa0, 0x49, 0x54,
            0xb7, 0x8b, 0x4b, 0x60, 0x35, 0xe9, 0x7a, 0x5e,
            0x07, 0x8a, 0x5a, 0x0f, 0x28, 0xec, 0x96, 0xd5,
            0x47, 0xbf, 0xee, 0x9a, 0xce, 0x80, 0x3a, 0xc0
        ];

        // Creates a pedersen commitment, with another 'H'
        fn commit_v2(secp: *const Secp256k1, value: u64, blind: SecretKey) -> Option<Commitment> {

            let mut commit = [0; 33];

            unsafe {
                if (*secp).caps != ContextFlag::Commit {
                    return None;
                }

                ffi::secp256k1_pedersen_commit(
                    (*secp).ctx,
                    commit.as_mut_ptr(),
                    blind.as_ptr(),
                    value,
                    GENERATOR_H_V2.as_ptr(),
                    constants::GENERATOR_G.as_ptr(),
                )
            };

            Some(Commitment(commit))
        }

        let mut r = SecretKey([0;32]);
        thread_rng().fill_bytes(&mut r.0);
        let value: u64 = 12345678;

        //--- H1

        let now = SystemTime::now();

        for i in 1..PC_LENGTH+1 {
            let _commit = secp.commit(value+i as u64, r);
        }

        if let Ok(elapsed) = now.elapsed() {
            let used_time = elapsed.as_secs();
            println!("spent time:\t{}(s)/({} pedersen commitment with H1)", used_time, PC_LENGTH);
        }

        //--- H2

        let now = SystemTime::now();

        for i in 1..PC_LENGTH+1 {
            let _commit = commit_v2(&secp, value+i as u64, r);
        }

        if let Ok(elapsed) = now.elapsed() {
            let used_time = elapsed.as_secs();
            println!("spent time:\t{}(s)/({} pedersen commitment with H2)", used_time, PC_LENGTH);
        }
    }