>>(\\n\\n input: T,\\n\\n existing_len: u64,\\n\\n inner_state: Option<&[u32; 4]>,\\n\\n) -> [u32; 4] {\\n\\n let mut bytes = input.into().to_vec();\\n\\n let orig_bytes_len = bytes.len();\\n\\n let initial_bit_len = ((existing_len << 3) + (bytes.len() << 3) as u64) as u64;\\n\\n\\n\\n // Step 1. Append padding bits\\n\\n // Append one '1' bit, then append 0 ≤ k < 512 bits '0', such that the resulting message\\n\\n // length in bis is congruent to 448 (mod 512).\\n\\n // Since our message is in bytes, we use one byte with a set high-order bit (0x80) plus\\n\\n // a variable number of zero bytes.\\n\\n\\n\\n // Append zeros\\n\\n // Number of padding bytes needed is 448 bits (56 bytes) modulo 512 bits (64 bytes)\\n\\n bytes.push(0x80_u8);\\n\\n while (bytes.len() % 64) != 56 {\\n\\n bytes.push(0_u8);\\n\",\n \"file_path\": \"src/md4.rs\",\n \"rank\": 11,\n \"score\": 105156.87630591044\n },\n {\n \"content\": \"pub fn bytes_to_hex(data: &[u8]) -> String {\\n\\n data.to_vec()\\n\\n .iter()\\n\\n .map(|b| format!(\\\"{:02x}\\\", b))\\n\\n .collect::>()\\n\\n .join(\\\"\\\")\\n\\n}\\n\",\n \"file_path\": \"src/lib.rs\",\n \"rank\": 12,\n \"score\": 104821.4368771918\n },\n {\n \"content\": \"pub fn bytes_to_base64(data: &[u8]) -> String {\\n\\n use std::cmp::min;\\n\\n\\n\\n let uppers = (b'A'..=b'Z').collect::>();\\n\\n let lowers = (b'a'..=b'z').collect::>();\\n\\n let numbers = (b'0'..=b'9').collect::>();\\n\\n let extras = vec![b'+', b'/'];\\n\\n let lookup = vec![uppers, lowers, numbers, extras].concat();\\n\\n\\n\\n let mut current_byte = 0;\\n\\n let mut bit_offset = 0;\\n\\n\\n\\n let mut output = String::new();\\n\\n loop {\\n\\n let take_bits = min(6, 8 - bit_offset);\\n\\n let mut taken_bits = bits_from_byte(data[current_byte], bit_offset, take_bits);\\n\\n\\n\\n // if we are on byte border\\n\\n if take_bits < 6 {\\n\\n let take_from_next = 6 - take_bits;\\n\",\n \"file_path\": \"src/lib.rs\",\n \"rank\": 13,\n \"score\": 104821.4368771918\n },\n {\n \"content\": \"pub fn english_frequency_score(data: &[u8]) -> isize {\\n\\n let reference = \\\"etaoinsETAOINS \\\";\\n\\n\\n\\n let mut score = 0;\\n\\n data.to_vec().windows(3).for_each(|triplet| {\\n\\n let a = triplet[0] as char;\\n\\n let b = triplet[1] as char;\\n\\n let c = triplet[2] as char;\\n\\n\\n\\n if a == b {\\n\\n score -= 1;\\n\\n }\\n\\n if (a == b) && (b == c) {\\n\\n score -= 2;\\n\\n }\\n\\n if a != b && b != c && b == ' ' {\\n\\n score += 2;\\n\\n }\\n\\n\\n\\n if (a == '.' || a == ',') && b == ' ' {\\n\",\n \"file_path\": \"src/lib.rs\",\n \"rank\": 14,\n \"score\": 102170.95737434115\n },\n {\n \"content\": \"pub fn hex_to_bytes(data: &str) -> Vec {\\n\\n let numbers = (b'0'..=b'9').collect::>();\\n\\n let lowers = (b'a'..=b'f').collect::>();\\n\\n let lookup = vec![numbers, lowers].concat();\\n\\n data.to_string()\\n\\n .to_ascii_lowercase()\\n\\n .bytes()\\n\\n .collect::>()\\n\\n .chunks(2)\\n\\n .map(|d| {\\n\\n let val_a = lookup.iter().position(|l| l == &d[0]).expect(\\\"first byte\\\");\\n\\n let val_b = lookup\\n\\n .iter()\\n\\n .position(|l| l == &d[1])\\n\\n .expect(\\\"uneven characters?\\\");\\n\\n (val_a * 16 + val_b) as u8\\n\\n })\\n\\n .collect::>()\\n\\n}\\n\\n\\n\",\n \"file_path\": \"src/lib.rs\",\n \"rank\": 15,\n \"score\": 99612.06268665097\n },\n {\n \"content\": \"pub fn base64_to_bytes(data: &str) -> Vec {\\n\\n use std::cmp::min;\\n\\n\\n\\n let uppers = (b'A'..=b'Z').collect::>();\\n\\n let lowers = (b'a'..=b'z').collect::>();\\n\\n let numbers = (b'0'..=b'9').collect::>();\\n\\n let extras = vec![b'+', b'/'];\\n\\n let lookup = vec![uppers, lowers, numbers, extras].concat();\\n\\n\\n\\n let mut output = vec![];\\n\\n\\n\\n let mut filled_bits = 0;\\n\\n let mut carry = 0;\\n\\n for x in data.bytes() {\\n\\n let bits = lookup.iter().position(|l| l == &x);\\n\\n // skip newlines and such\\n\\n let bits = match bits {\\n\\n Some(b) => b,\\n\\n None => continue,\\n\\n } as u8;\\n\",\n \"file_path\": \"src/lib.rs\",\n \"rank\": 16,\n \"score\": 99612.06268665097\n },\n {\n \"content\": \"fn convert_byte_vec_to_u32(mut bytes: Vec) -> Vec {\\n\\n bytes.shrink_to_fit();\\n\\n let num_bytes = bytes.len();\\n\\n let num_words = num_bytes / 4;\\n\\n unsafe {\\n\\n let words = Vec::from_raw_parts(bytes.as_mut_ptr() as *mut u32, num_words, num_words);\\n\\n mem::forget(bytes);\\n\\n words\\n\\n }\\n\\n}\\n\\n\\n\",\n \"file_path\": \"src/md4.rs\",\n \"rank\": 17,\n \"score\": 92762.45792490905\n },\n {\n \"content\": \"#[inline(always)]\\n\\nfn as_block(input: &[u8]) -> &[u8; 64] {\\n\\n unsafe {\\n\\n assert!(input.len() == 64);\\n\\n let arr: &[u8; 64] = mem::transmute(input.as_ptr());\\n\\n arr\\n\\n }\\n\\n}\\n\\n\\n\\nimpl Default for Sha1 {\\n\\n fn default() -> Sha1 {\\n\\n Sha1::new()\\n\\n }\\n\\n}\\n\\n\\n\\nimpl Sha1 {\\n\\n /// Creates an fresh sha1 hash object.\\n\\n ///\\n\\n /// This is equivalent to creating a hash with `Default::default`.\\n\\n pub fn new() -> Sha1 {\\n\\n Sha1 {\\n\",\n \"file_path\": \"src/sha1.rs\",\n \"rank\": 18,\n \"score\": 85312.87749896166\n },\n {\n \"content\": \"fn bits_from_byte(d: u8, a: u32, b: u32) -> u8 {\\n\\n assert!(a + b <= 8);\\n\\n assert!(b <= 8);\\n\\n d.rotate_left(a) >> (8 - b)\\n\\n}\\n\",\n \"file_path\": \"src/lib.rs\",\n \"rank\": 19,\n \"score\": 77346.51720403964\n },\n {\n \"content\": \"#[test]\\n\\npub fn base64_to_bytes_works() {\\n\\n let result = base64_to_bytes(\\\"QQABAgNC//8=\\\");\\n\\n let reference = [b'A', 0x00, 0x01, 0x02, 0x03, b'B', 0xff, 0xff];\\n\\n assert_eq!(result, reference);\\n\\n\\n\\n let result = base64_to_bytes(\\\"sAAFlG0CAncq3weaDw==\\\");\\n\\n let reference = [\\n\\n 0xb0, 0x00, 0x05, 0x94, 0x6d, 0x02, 0x02, 0x77, 0x2a, 0xdf, 0x07, 0x9a, 0x0f,\\n\\n ];\\n\\n assert_eq!(result, reference);\\n\\n}\\n\\n\\n\",\n \"file_path\": \"src/lib.rs\",\n \"rank\": 20,\n \"score\": 76780.05968468015\n },\n {\n \"content\": \"#[test]\\n\\npub fn bytes_to_hex_works() {\\n\\n assert_eq!(bytes_to_hex(&[0x00, 0x01, 0x02, 0x03, 0xff]), \\\"00010203ff\\\");\\n\\n}\\n\\n\\n\",\n \"file_path\": \"src/lib.rs\",\n \"rank\": 21,\n \"score\": 76780.05968468015\n },\n {\n \"content\": \"pub fn load_stdin() -> String {\\n\\n let mut buffer = String::new();\\n\\n eprintln!(\\\"reading input from stdin...\\\");\\n\\n io::stdin().lock().read_to_string(&mut buffer).unwrap();\\n\\n buffer\\n\\n}\\n\\n\\n\",\n \"file_path\": \"src/lib.rs\",\n \"rank\": 22,\n \"score\": 74445.8590384547\n },\n {\n \"content\": \"pub fn get_timestamp() -> std::time::Duration {\\n\\n SystemTime::now()\\n\\n .duration_since(UNIX_EPOCH)\\n\\n .expect(\\\"timetamp is broken\\\")\\n\\n}\\n\\n\\n\",\n \"file_path\": \"src/lib.rs\",\n \"rank\": 23,\n \"score\": 66682.95430746948\n },\n {\n \"content\": \"#[test]\\n\\nfn test_mt19937() {\\n\\n use std::collections::HashMap;\\n\\n // matches output from:\\n\\n // http://burtleburtle.net/bob/c/readable.c\\n\\n let verification_data: HashMap = [\\n\\n (0, 3331822403),\\n\\n (1, 157471482),\\n\\n (2, 2805605540),\\n\\n (3, 3776487808),\\n\\n (4, 3041352379),\\n\\n (5, 1684094076),\\n\\n (6, 1865610459),\\n\\n (7, 4068209049),\\n\\n (8, 1179506908),\\n\\n (9, 2512518870),\\n\\n (10, 3068092408),\\n\\n (100, 1155969921),\\n\\n (1000, 885714877),\\n\\n (9000, 270018718),\\n\\n (10000, 725707472),\\n\",\n \"file_path\": \"src/mt19937.rs\",\n \"rank\": 24,\n \"score\": 62551.2771435818\n },\n {\n \"content\": \"pub trait SimdExt {\\n\\n fn simd_eq(self, rhs: Self) -> Self;\\n\\n}\\n\\n\\n\\nimpl SimdExt for fake::u32x4 {\\n\\n fn simd_eq(self, rhs: Self) -> Self {\\n\\n if self == rhs {\\n\\n fake::u32x4(0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff)\\n\\n } else {\\n\\n fake::u32x4(0, 0, 0, 0)\\n\\n }\\n\\n }\\n\\n}\\n\\n\\n\\nmod fake {\\n\\n use core::ops::{Add, BitAnd, BitOr, BitXor, Shl, Shr, Sub};\\n\\n\\n\\n #[derive(Clone, Copy, PartialEq, Eq)]\\n\\n #[allow(non_camel_case_types)]\\n\\n pub struct u32x4(pub u32, pub u32, pub u32, pub u32);\\n\",\n \"file_path\": \"src/sha1.rs\",\n \"rank\": 25,\n \"score\": 45255.656363250324\n },\n {\n \"content\": \"#[test]\\n\\nfn hexbytes_works() {\\n\\n let test = vec![0x00, 0x01, 0x02, 0xff];\\n\\n let test2 = bytes_to_hexbytes(&test);\\n\\n let test3 = hexbytes_to_bytes(&test2);\\n\\n assert_eq!(test, test3);\\n\\n}\\n\\n\\n\",\n \"file_path\": \"src/lib.rs\",\n \"rank\": 26,\n \"score\": 36001.20198956437\n },\n {\n \"content\": \"#[test]\\n\\nfn hex_to_bytes_works() {\\n\\n assert_eq!(\\n\\n hex_to_bytes(\\\"49276d206b00010203\\\".into()),\\n\\n [73, 39, 109, 32, 107, 0, 1, 2, 3]\\n\\n );\\n\\n}\\n\\n\\n\",\n \"file_path\": \"src/lib.rs\",\n \"rank\": 27,\n \"score\": 34753.4876429585\n },\n {\n \"content\": \"#[test]\\n\\nfn bytes_to_base64_works() {\\n\\n let bytes = hex_to_bytes(\\\"49276d206b696c6c696e6720796f757220627261696e206c696b65206120706f69736f6e6f7573206d757368726f6f6d\\\".into());\\n\\n assert_eq!(\\n\\n bytes_to_base64(&bytes),\\n\\n \\\"SSdtIGtpbGxpbmcgeW91ciBicmFpbiBsaWtlIGEgcG9pc29ub3VzIG11c2hyb29t\\\"\\n\\n );\\n\\n\\n\\n assert_eq!(\\n\\n bytes_to_base64(&\\\"any carnal pleasure.\\\".bytes().collect::>()),\\n\\n \\\"YW55IGNhcm5hbCBwbGVhc3VyZS4=\\\"\\n\\n );\\n\\n}\\n\\n\\n\",\n \"file_path\": \"src/lib.rs\",\n \"rank\": 28,\n \"score\": 34753.4876429585\n },\n {\n \"content\": \"#[test]\\n\\nfn xor_arrays_works() {\\n\\n let first = hex_to_bytes(\\\"1c0111001f010100061a024b53535009181c\\\");\\n\\n let second = hex_to_bytes(\\\"686974207468652062756c6c277320657965\\\");\\n\\n let result = xor_arrays(&first, &second);\\n\\n let in_hex = bytes_to_hex(&result);\\n\\n assert_eq!(in_hex, \\\"746865206b696420646f6e277420706c6179\\\");\\n\\n}\\n\\n\\n\",\n \"file_path\": \"src/lib.rs\",\n \"rank\": 29,\n \"score\": 34753.4876429585\n },\n {\n \"content\": \"#[test]\\n\\nfn bits_from_byte_works() {\\n\\n assert_eq!(bits_from_byte(43, 0, 2), 0);\\n\\n assert_eq!(bits_from_byte(43, 0, 8), 43);\\n\\n assert_eq!(bits_from_byte(43, 4, 4), 11);\\n\\n assert_eq!(bits_from_byte(43, 5, 3), 3);\\n\\n assert_eq!(bits_from_byte(73, 6, 2), 1);\\n\\n assert_eq!(bits_from_byte(73, 6, 2), 1);\\n\\n}\\n\\n\\n\",\n \"file_path\": \"src/lib.rs\",\n \"rank\": 30,\n \"score\": 34753.4876429585\n },\n {\n \"content\": \"#[test]\\n\\nfn search_xor_key_works() {\\n\\n let data = \\\"LAgaCA9BAQQMCU0EDxEZGBwZBAVSDwAYDEFJUAgIHAUEEwYOGRhPSE1SHwkJTQYOEwdBAwtBFRoOQQ8fGBEGCg8NARgSBksIH00VDlIMAAUDQQABSwwZDglBGwUHAx8MAAYCDgJNABJSGw4fHggDHg5BDQ8OFAZLFQQIQQ4AAgYFAwANXksUAggPAgASERgIBUEWChUNTUlDAgcABQMVBAofQ0VDQSgGSwgfTRQSFw0UAE0VDlIIDgIeCAUXGUEYGg5BExgRCQ4VElIEB0wMAgkbDhcFAwZBBgMIH0NBNRoOQQoEExIGSwgfTQMTFwoKBQMGQQYDBEweGBIGDgxMj+H1Uh8JDRlBCAFLBQUeAg4EDhMFAwZBGgQWTBkJBFIODw8EEQkXGQwJAxVBAhkODwgSElIcDh4GEk9SPwkJTRIEEQQPCE0IElIYDgAbCA8VSxUECEEKFxJBGAUAFVICEkwYDwgDHgRMCw4TUgpBHAwTFRsIFAAME0EXBQIeFBEVFw9BAQgSEhMMBEwCE0EVGQ4ZHUEOFEsMCR4SABUOEkJn\\\";\\n\\n let data = base64_to_bytes(&data);\\n\\n let best_result = search_xor_key(&data, 7);\\n\\n\\n\\n let result_readable = String::from_utf8(best_result.2.clone()).unwrap();\\n\\n\\n\\n assert_eq!(best_result.1, [b'k', b'a', b'l', b'm', b'a', b'a', b'r']);\\n\\n assert!(result_readable.starts_with(\\\"Given some encrypted data (\\\\\\\"ciphertext\\\"));\\n\\n}\\n\",\n \"file_path\": \"src/lib.rs\",\n \"rank\": 32,\n \"score\": 33626.1033810134\n },\n {\n \"content\": \"#[test]\\n\\nfn english_frequency_score_works() {\\n\\n let text = \\\"snniiiooooaaaaatttttteeeeeee \\\";\\n\\n let frequency_delta = english_frequency_score(text.to_string().as_bytes());\\n\\n assert_eq!(frequency_delta, -24);\\n\\n\\n\\n let text = \\\"Man is distinguished, not only by his reason, but by this singular passion from other animals,\\n\\nwhich is a lust of the mind, that by a perseverance of delight in the continued and indefatigable \\n\\ngeneration of knowledge, exceeds the short vehemence of any carnal pleasure.\\\";\\n\\n let frequency_delta = english_frequency_score(text.to_string().as_bytes());\\n\\n assert_eq!(frequency_delta, 166);\\n\\n\\n\\n let text = \\\"esto ia\\\";\\n\\n let frequency_delta = english_frequency_score(text.to_string().as_bytes());\\n\\n assert_eq!(frequency_delta, 7);\\n\\n\\n\\n let text = \\\"estonia hhhhrrrfffmmmlll\\\";\\n\\n let frequency_delta = english_frequency_score(text.to_string().as_bytes());\\n\\n assert_eq!(frequency_delta, -26);\\n\\n\\n\\n let text = \\\"We have students from different countries and continents gathered here to learn our language with you. At Totally English, you will make international friends and live fantastic learning adventures in the United Kingdom. Together, you will become more proficient in all areas of our language. Being fluent in English has become indispensable in the business area, so take your chance now and improve your skills with Totally English! Be more competitive in your job and see doors open left and right for you. English is the key!We have students from different countries and continents gathered here to learn our language with you. At Totally English, you will make international friends and live fantastic learning adventures in the United Kingdom. Together, you will become more proficient in all areas of our language. Being fluent in English has become indispensable in the business area, so take your chance now and improve your skills with Totally English! Be more competitive in your job and see doors open left and right for you. English is the key!\\\";\\n\\n let frequency_delta = english_frequency_score(text.to_string().as_bytes());\\n\\n assert_eq!(frequency_delta, 659);\\n\\n}\\n\\n\\n\",\n \"file_path\": \"src/lib.rs\",\n \"rank\": 35,\n \"score\": 33626.1033810134\n },\n {\n \"content\": \"#[test]\\n\\nfn find_xor_key_eng_works() {\\n\\n let text = \\\"1b37373331363f78151b7f2b783431333d78397828372d363c78373e783a393b3736\\\";\\n\\n let as_bytes = hex_to_bytes(text);\\n\\n let (_score, key, output) = find_xor_key_eng(&as_bytes);\\n\\n let output = String::from_utf8(output).unwrap();\\n\\n assert_eq!(key, 88);\\n\\n assert_eq!(output, \\\"Cooking MC's like a pound of bacon\\\");\\n\\n}\\n\\n\\n\",\n \"file_path\": \"src/lib.rs\",\n \"rank\": 37,\n \"score\": 32602.442937053864\n },\n {\n \"content\": \"fn digest_to_str(digest: &[u32]) -> String {\\n\\n let mut s = String::new();\\n\\n for &word in digest {\\n\\n write!(&mut s, \\\"{:08x}\\\", word).unwrap();\\n\\n }\\n\\n s\\n\\n}\\n\",\n \"file_path\": \"src/md4.rs\",\n \"rank\": 38,\n \"score\": 30226.153675594163\n },\n {\n \"content\": \"#[inline]\\n\\nfn sha1_first(w0: u32x4) -> u32 {\\n\\n w0.0\\n\\n}\\n\\n\\n\\n/// Not an intrinsic, but adds a word to the first element of a vector.\\n\",\n \"file_path\": \"src/sha1.rs\",\n \"rank\": 39,\n \"score\": 30226.153675594163\n },\n {\n \"content\": \"/// Emulates `llvm.x86.sha1msg2` intrinsic.\\n\\nfn sha1msg2(a: u32x4, b: u32x4) -> u32x4 {\\n\\n let u32x4(x0, x1, x2, x3) = a;\\n\\n let u32x4(_, w13, w14, w15) = b;\\n\\n\\n\\n let w16 = (x0 ^ w13).rotate_left(1);\\n\\n let w17 = (x1 ^ w14).rotate_left(1);\\n\\n let w18 = (x2 ^ w15).rotate_left(1);\\n\\n let w19 = (x3 ^ w16).rotate_left(1);\\n\\n\\n\\n u32x4(w16, w17, w18, w19)\\n\\n}\\n\\n\\n\\n/// Emulates `llvm.x86.sha1nexte` intrinsic.\\n\",\n \"file_path\": \"src/sha1.rs\",\n \"rank\": 40,\n \"score\": 30150.959999119677\n },\n {\n \"content\": \"/// Emulates `llvm.x86.sha1msg1` intrinsic.\\n\\nfn sha1msg1(a: u32x4, b: u32x4) -> u32x4 {\\n\\n let u32x4(_, _, w2, w3) = a;\\n\\n let u32x4(w4, w5, _, _) = b;\\n\\n a ^ u32x4(w2, w3, w4, w5)\\n\\n}\\n\\n\\n\",\n \"file_path\": \"src/sha1.rs\",\n \"rank\": 41,\n \"score\": 30150.959999119677\n },\n {\n \"content\": \"// f(X,Y,Z) = XY v not(X)Z\\n\\nfn f(x: u32, y: u32, z: u32) -> u32 {\\n\\n (x & y) | (!x & z)\\n\\n}\\n\\n\\n\",\n \"file_path\": \"src/md4.rs\",\n \"rank\": 42,\n \"score\": 29291.302356088836\n },\n {\n \"content\": \"// h(X,Y,Z) = X xor Y xor Z\\n\\nfn h(x: u32, y: u32, z: u32) -> u32 {\\n\\n x ^ y ^ z\\n\\n}\\n\\n\\n\\n// Round 1 macro\\n\\n// Let [A B C D i s] denote the operation\\n\\n// A = (A + f(B,C,D) + X[i]) <<< s\\n\\nmacro_rules! md4round1 {\\n\\n ( $a:expr, $b:expr, $c:expr, $d:expr, $i:expr, $s:expr, $x:expr) => {{\\n\\n // Rust defaults to non-overflowing arithmetic, so we need to specify wrapping add.\\n\\n $a = ($a.wrapping_add(f($b, $c, $d)).wrapping_add($x[$i])).rotate_left($s);\\n\\n }};\\n\\n}\\n\\n\\n\\n// Round 2 macro\\n\\n// Let [A B C D i s] denote the operation\\n\\n// A = (A + g(B,C,D) + X[i] + 5A827999) <<< s .\\n\\nmacro_rules! md4round2 {\\n\\n ( $a:expr, $b:expr, $c:expr, $d:expr, $i:expr, $s:expr, $x:expr) => {{\\n\\n $a = ($a\\n\",\n \"file_path\": \"src/md4.rs\",\n \"rank\": 43,\n \"score\": 29291.302356088836\n },\n {\n \"content\": \"// g(X,Y,Z) = XY v XZ v YZ\\n\\nfn g(x: u32, y: u32, z: u32) -> u32 {\\n\\n (x & y) | (x & z) | (y & z)\\n\\n}\\n\\n\\n\",\n \"file_path\": \"src/md4.rs\",\n \"rank\": 44,\n \"score\": 29291.302356088836\n },\n {\n \"content\": \"/// Not an intrinsic, but helps emulate `llvm.x86.sha1rnds4` intrinsic.\\n\\nfn sha1rnds4p(abcd: u32x4, msg: u32x4) -> u32x4 {\\n\\n let u32x4(mut a, mut b, mut c, mut d) = abcd;\\n\\n let u32x4(t, u, v, w) = msg;\\n\\n let mut e = 0u32;\\n\\n\\n\\n macro_rules! bool3ary_150 {\\n\\n ($a:expr, $b:expr, $c:expr) => {\\n\\n ($a ^ $b ^ $c)\\n\\n };\\n\\n } // Parity, XOR, MD5H, SHA1P\\n\\n\\n\\n e = e\\n\\n .wrapping_add(a.rotate_left(5))\\n\\n .wrapping_add(bool3ary_150!(b, c, d))\\n\\n .wrapping_add(t);\\n\\n b = b.rotate_left(30);\\n\\n\\n\\n d = d\\n\\n .wrapping_add(e.rotate_left(5))\\n\\n .wrapping_add(bool3ary_150!(a, b, c))\\n\",\n \"file_path\": \"src/sha1.rs\",\n \"rank\": 45,\n \"score\": 28193.677961599264\n },\n {\n \"content\": \"/// Not an intrinsic, but helps emulate `llvm.x86.sha1rnds4` intrinsic.\\n\\nfn sha1rnds4m(abcd: u32x4, msg: u32x4) -> u32x4 {\\n\\n let u32x4(mut a, mut b, mut c, mut d) = abcd;\\n\\n let u32x4(t, u, v, w) = msg;\\n\\n let mut e = 0u32;\\n\\n\\n\\n macro_rules! bool3ary_232 {\\n\\n ($a:expr, $b:expr, $c:expr) => {\\n\\n ($a & $b) ^ ($a & $c) ^ ($b & $c)\\n\\n };\\n\\n } // Majority, SHA1M\\n\\n\\n\\n e = e\\n\\n .wrapping_add(a.rotate_left(5))\\n\\n .wrapping_add(bool3ary_232!(b, c, d))\\n\\n .wrapping_add(t);\\n\\n b = b.rotate_left(30);\\n\\n\\n\\n d = d\\n\\n .wrapping_add(e.rotate_left(5))\\n\\n .wrapping_add(bool3ary_232!(a, b, c))\\n\",\n \"file_path\": \"src/sha1.rs\",\n \"rank\": 46,\n \"score\": 28193.677961599264\n },\n {\n \"content\": \"/// Not an intrinsic, but helps emulate `llvm.x86.sha1rnds4` intrinsic.\\n\\nfn sha1rnds4c(abcd: u32x4, msg: u32x4) -> u32x4 {\\n\\n let u32x4(mut a, mut b, mut c, mut d) = abcd;\\n\\n let u32x4(t, u, v, w) = msg;\\n\\n let mut e = 0u32;\\n\\n\\n\\n macro_rules! bool3ary_202 {\\n\\n ($a:expr, $b:expr, $c:expr) => {\\n\\n ($c ^ ($a & ($b ^ $c)))\\n\\n };\\n\\n } // Choose, MD5F, SHA1C\\n\\n\\n\\n e = e\\n\\n .wrapping_add(a.rotate_left(5))\\n\\n .wrapping_add(bool3ary_202!(b, c, d))\\n\\n .wrapping_add(t);\\n\\n b = b.rotate_left(30);\\n\\n\\n\\n d = d\\n\\n .wrapping_add(e.rotate_left(5))\\n\\n .wrapping_add(bool3ary_202!(a, b, c))\\n\",\n \"file_path\": \"src/sha1.rs\",\n \"rank\": 47,\n \"score\": 28193.677961599264\n },\n {\n \"content\": \"#[inline]\\n\\nfn sha1_first_add(e: u32, w0: u32x4) -> u32x4 {\\n\\n let u32x4(a, b, c, d) = w0;\\n\\n u32x4(e.wrapping_add(a), b, c, d)\\n\\n}\\n\\n\\n\",\n \"file_path\": \"src/sha1.rs\",\n \"rank\": 48,\n \"score\": 27338.71623374519\n },\n {\n \"content\": \"#[inline]\\n\\nfn sha1_first_half(abcd: u32x4, msg: u32x4) -> u32x4 {\\n\\n sha1_first_add(sha1_first(abcd).rotate_left(30), msg)\\n\\n}\\n\\n\\n\",\n \"file_path\": \"src/sha1.rs\",\n \"rank\": 49,\n \"score\": 26552.875292355464\n },\n {\n \"content\": \"/// Emulates `llvm.x86.sha1rnds4` intrinsic.\\n\\n/// Performs 4 rounds of the message block digest.\\n\\nfn sha1_digest_round_x4(abcd: u32x4, work: u32x4, i: i8) -> u32x4 {\\n\\n const K0V: u32x4 = u32x4(K0, K0, K0, K0);\\n\\n const K1V: u32x4 = u32x4(K1, K1, K1, K1);\\n\\n const K2V: u32x4 = u32x4(K2, K2, K2, K2);\\n\\n const K3V: u32x4 = u32x4(K3, K3, K3, K3);\\n\\n\\n\\n match i {\\n\\n 0 => sha1rnds4c(abcd, work + K0V),\\n\\n 1 => sha1rnds4p(abcd, work + K1V),\\n\\n 2 => sha1rnds4m(abcd, work + K2V),\\n\\n 3 => sha1rnds4p(abcd, work + K3V),\\n\\n _ => panic!(\\\"unknown icosaround index\\\"),\\n\\n }\\n\\n}\\n\\n\\n\",\n \"file_path\": \"src/sha1.rs\",\n \"rank\": 50,\n \"score\": 24297.876979791086\n },\n {\n \"content\": \"//extern crate cryptopals;\\n\\nuse std::num::Wrapping;\\n\\n\\n\\nconst N: u32 = 624;\\n\\nconst F: Wrapping = Wrapping(1812433253);\\n\\n\\n\\npub struct Mt19937 {\\n\\n state: [Wrapping; N as usize],\\n\\n index: u32,\\n\\n}\\n\\nimpl Mt19937 {\\n\\n pub fn from_seed(seed: u32) -> Mt19937 {\\n\\n let mut state = [Wrapping(0); N as usize];\\n\\n state[0] = Wrapping(seed);\\n\\n for i in 1..N as usize {\\n\\n state[i] = F * (state[i - 1] ^ (state[i - 1] >> 30)) + Wrapping(i as u32);\\n\\n }\\n\\n Mt19937 {\\n\\n state,\\n\\n index: N as u32,\\n\",\n \"file_path\": \"src/mt19937.rs\",\n \"rank\": 54,\n \"score\": 11.459322334549121\n },\n {\n \"content\": \" (bits >> 56) as u8,\\n\\n (bits >> 48) as u8,\\n\\n (bits >> 40) as u8,\\n\\n (bits >> 32) as u8,\\n\\n (bits >> 24) as u8,\\n\\n (bits >> 16) as u8,\\n\\n (bits >> 8) as u8,\\n\\n (bits >> 0) as u8,\\n\\n ];\\n\\n let mut last = [0; 128];\\n\\n let blocklen = self.blocks.len as usize;\\n\\n last[..blocklen].clone_from_slice(&self.blocks.block[..blocklen]);\\n\\n last[blocklen] = 0x80;\\n\\n\\n\\n if blocklen < 56 {\\n\\n last[56..64].clone_from_slice(&extra);\\n\\n let out = last[0..64].to_vec();\\n\\n //println!(\\\"INNER digest used as last block: {:?}\\\", out);\\n\\n state.process(as_block(&last[0..64]));\\n\\n } else {\\n\",\n \"file_path\": \"src/sha1.rs\",\n \"rank\": 55,\n \"score\": 10.639133830643427\n },\n {\n \"content\": \" (self.data.state[4] >> 0) as u8,\\n\\n ]\\n\\n }\\n\\n}\\n\\n\\n\\nimpl Blocks {\\n\\n fn input(&mut self, mut input: &[u8], mut f: F)\\n\\n where\\n\\n F: FnMut(&[u8; 64]),\\n\\n {\\n\\n if self.len > 0 {\\n\\n let len = self.len as usize;\\n\\n let amt = cmp::min(input.len(), self.block.len() - len);\\n\\n self.block[len..len + amt].clone_from_slice(&input[..amt]);\\n\\n if len + amt == self.block.len() {\\n\\n f(&self.block);\\n\\n self.len = 0;\\n\\n input = &input[amt..];\\n\\n } else {\\n\\n self.len += amt as u32;\\n\",\n \"file_path\": \"src/sha1.rs\",\n \"rank\": 56,\n \"score\": 10.44819216228327\n },\n {\n \"content\": \" }\\n\\n }\\n\\n\\n\\n pub fn from_state(state: [Wrapping; N as usize], index: u32) -> Mt19937 {\\n\\n Mt19937 { state, index }\\n\\n }\\n\\n\\n\\n pub fn extract_number(&mut self) -> u32 {\\n\\n if self.index >= N {\\n\\n self.twist();\\n\\n }\\n\\n let mut y: u32 = self.state[self.index as usize].0;\\n\\n y = self.temper(y);\\n\\n self.index += 1;\\n\\n y\\n\\n }\\n\\n\\n\\n fn temper(&self, num: u32) -> u32 {\\n\\n let mut num = num ^ num >> 11;\\n\\n num ^= num << 7 & 0x9D2C_5680;\\n\",\n \"file_path\": \"src/mt19937.rs\",\n \"rank\": 57,\n \"score\": 10.388521795989655\n },\n {\n \"content\": \" num ^= num >> 22;\\n\\n\\n\\n num\\n\\n }\\n\\n\\n\\n fn twist(&mut self) {\\n\\n let upper_mask: Wrapping = Wrapping(0x8000_0000);\\n\\n let lower_mask: Wrapping = Wrapping(0x7fff_ffff);\\n\\n for i in 0..N as usize {\\n\\n let x = (self.state[i] & upper_mask) + (self.state[(i + 1) % N as usize] & lower_mask);\\n\\n let mut x_a: Wrapping = x >> 1;\\n\\n if x % Wrapping(2) != Wrapping(0) {\\n\\n x_a ^= Wrapping(0x9908_B0DF);\\n\\n }\\n\\n self.state[i] = self.state[(i + 397) % N as usize] ^ x_a;\\n\\n }\\n\\n self.index = 0;\\n\\n }\\n\\n}\\n\\n\\n\\n#[test]\\n\",\n \"file_path\": \"src/mt19937.rs\",\n \"rank\": 58,\n \"score\": 9.928109140688598\n },\n {\n \"content\": \"impl hash::Hash for Blocks {\\n\\n fn hash(&self, state: &mut H) {\\n\\n self.len.hash(state);\\n\\n self.block.hash(state);\\n\\n }\\n\\n}\\n\\n\\n\\nimpl Clone for Blocks {\\n\\n fn clone(&self) -> Blocks {\\n\\n Blocks { ..*self }\\n\\n }\\n\\n}\\n\\n\\n\\n/// Indicates that a digest couldn't be parsed.\\n\\n#[derive(Copy, Clone, Hash, Eq, PartialEq, Ord, PartialOrd, Debug)]\\n\\npub struct DigestParseError(());\\n\\n\\n\\nimpl fmt::Display for DigestParseError {\\n\\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\\n\\n write!(f, \\\"not a valid sha1 hash\\\")\\n\",\n \"file_path\": \"src/sha1.rs\",\n \"rank\": 60,\n \"score\": 8.914232258979624\n },\n {\n \"content\": \" pub fn update(&mut self, data: &[u8]) {\\n\\n let len = &mut self.len;\\n\\n let state = &mut self.state;\\n\\n self.blocks.input(data, |block| {\\n\\n *len += block.len() as u64;\\n\\n state.process(block);\\n\\n })\\n\\n }\\n\\n\\n\\n pub fn digest_now(data: &[u8]) -> Vec {\\n\\n let mut sha1 = Sha1::new();\\n\\n sha1.update(data);\\n\\n sha1.digest().bytes().to_vec()\\n\\n }\\n\\n\\n\\n /// Retrieve digest result.\\n\\n pub fn digest(&self) -> Digest {\\n\\n let mut state = self.state;\\n\\n let bits = (self.len + (self.blocks.len as u64)) * 8;\\n\\n let extra = [\\n\",\n \"file_path\": \"src/sha1.rs\",\n \"rank\": 61,\n \"score\": 8.41682833381891\n },\n {\n \"content\": \"use core::str;\\n\\n\\n\\n/// The length of a SHA1 digest in bytes\\n\\npub const DIGEST_LENGTH: usize = 20;\\n\\n\\n\\n/// Represents a Sha1 hash object in memory.\\n\\n#[derive(Clone, PartialOrd, Ord, PartialEq, Eq, Hash)]\\n\\npub struct Sha1 {\\n\\n state: Sha1State,\\n\\n blocks: Blocks,\\n\\n len: u64,\\n\\n}\\n\\n\\n\",\n \"file_path\": \"src/sha1.rs\",\n \"rank\": 62,\n \"score\": 8.416309251139474\n },\n {\n \"content\": \"\\n\\n use self::std::prelude::v1::*;\\n\\n\\n\\n use Sha1;\\n\\n\\n\\n #[test]\\n\\n fn test_simple() {\\n\\n let mut m = Sha1::new();\\n\\n\\n\\n let tests = [\\n\\n (\\\"The quick brown fox jumps over the lazy dog\\\",\\n\\n \\\"2fd4e1c67a2d28fced849ee1bb76e7391b93eb12\\\"),\\n\\n (\\\"The quick brown fox jumps over the lazy cog\\\",\\n\\n \\\"de9f2c7fd25e1b3afad3e85a0bd17d9b100db4b3\\\"),\\n\\n (\\\"\\\", \\\"da39a3ee5e6b4b0d3255bfef95601890afd80709\\\"),\\n\\n (\\\"testing\\\\n\\\", \\\"9801739daae44ec5293d4e1f53d3f4d2d426d91c\\\"),\\n\\n (\\\"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\\\",\\n\\n \\\"025ecbd5d70f8fb3c5457cd96bab13fda305dc59\\\"),\\n\\n (\\\"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\\\",\\n\\n \\\"4300320394f7ee239bcdce7d3b8bcee173a0cd5c\\\"),\\n\",\n \"file_path\": \"src/sha1.rs\",\n \"rank\": 63,\n \"score\": 7.945956169179095\n },\n {\n \"content\": \"extern crate openssl;\\n\\n\\n\\nuse crate::sha1::Sha1;\\n\\nuse num_bigint::{BigInt, BigUint, RandBigInt, ToBigInt, ToBigUint};\\n\\n\\n\\npub struct DSA {\\n\\n pub p: BigInt,\\n\\n pub q: BigInt,\\n\\n pub g: BigInt,\\n\\n pub pubkey: BigInt,\\n\\n pub privkey: BigInt,\\n\\n}\\n\\n\\n\\nconst DEFAULT_P: &[u8] = b\\\"800000000000000089e1855218a0e7dac38136ffafa72eda7\\\\\\n\\n 859f2171e25e65eac698c1702578b07dc2a1076da241c76c6\\\\\\n\\n 2d374d8389ea5aeffd3226a0530cc565f3bf6b50929139ebe\\\\\\n\\n ac04f48c3c84afb796d61e5a4f9a8fda812ab59494232c7d2\\\\\\n\\n b4deb50aa18ee9e132bfa85ac4374d7f9091abc3d015efc87\\\\\\n\\n 1a584471bb1\\\";\\n\\nconst DEFAULT_Q: &[u8] = b\\\"f4f47f05794b256174bba6e9b396a7707e563c5b\\\";\\n\",\n \"file_path\": \"src/dsa.rs\",\n \"rank\": 64,\n \"score\": 7.9058328667625695\n },\n {\n \"content\": \" }\\n\\n\\n\\n #[test]\\n\\n fn spray_and_pray() {\\n\\n use self::rand::Rng;\\n\\n\\n\\n let mut rng = rand::thread_rng();\\n\\n let mut m = Sha1::new();\\n\\n let mut bytes = [0; 512];\\n\\n\\n\\n for _ in 0..20 {\\n\\n let ty = openssl::hash::MessageDigest::sha1();\\n\\n let mut r = openssl::hash::Hasher::new(ty).unwrap();\\n\\n m.reset();\\n\\n for _ in 0..50 {\\n\\n let len = rng.gen::() % bytes.len();\\n\\n rng.fill_bytes(&mut bytes[..len]);\\n\\n m.update(&bytes[..len]);\\n\\n r.update(&bytes[..len]).unwrap();\\n\\n }\\n\",\n \"file_path\": \"src/sha1.rs\",\n \"rank\": 65,\n \"score\": 7.818020264360822\n },\n {\n \"content\": \"# cryptopals\\n\\nSolving the Cryptopals.com challenges\\n\\n\\n\\ns1c1-s1c3\\n\\n---\\n\\nimplemented in lib.rs as functions (with tests)\\n\\n\\n\\ns1c4\\n\\n---\\n\\ncargo run --bin detect_singlechar_xor < res/s1c4.txt\\n\\n\\n\\ns1c5\\n\\n---\\n\\ncargo run --bin xor_encrypt ICE < res/s1c5.txt\\n\\n\\n\\ns1c6 (find xor key)\\n\\n---\\n\\ncargo run --release --bin find_xor_key 30 < res/s1c6.txt\\n\\n\\n\\ns1c7 (decrypt aes-ecb)\\n\\n---\\n\\ncargo run --release --bin decrypt_aes_ecb \\\"YELLOW SUBMARINE\\\" < res/s1c7.txt\\n\\n\\n\\ns1c8 (detect ecb mode from lines)\\n\\n---\\n\\ncargo run --release --bin detect_ecb_mode < res/s1c8.txt\\n\\n\\n\\ns2c9 (pkcs7 padding)\\n\\n---\\n\\ncreated into block_ciphers.rs\\n\\n\\n\\ns2c10 (decrypt aes-cbc)\\n\\n---\\n\\ncargo run --bin decrypt_aes_cbc \\\"YELLOW SUBMARINE\\\" < res/s2c10.txt\\n\\n\\n\\ns2c11 (cbs vs ecb oracle)\\n\\n---\\n\\ncargo run --bin oracle_cbc_ecb\\n\\n\\n\\ns2c12 (byte-a-time ecb decrypt simple)\\n\\n---\\n\\ncargo run --release --bin break_ecb_byte_simple < res/s2c12.txt\\n\\n\\n\\ns2c13 (ecb cut and paste cookie)\\n\\n---\\n\\ncargo run --bin ecb_cut_and_paste\\n\\n\\n\\ns2c14 (byte-a-time ecb decrypt harder)\\n\\n---\\n\\ncargo run --release --bin break_ecb_byte_harder < res/s2c12.txt\\n\\n\\n\\ns2c16 (cbc bitlipping attack)\\n\\n---\\n\\ncargo run --bin cbc_bitflipping\\n\\n\\n\\ns3c17 (cbc padding oracle)\\n\\n---\\n\\n# FIXME: I do not decrypt the first block, add a virtual empty block before the first one?\\n\\ncargo run --bin cbc_padding_oracle < res/s3c17.txt\\n\\n\\n\\ns3c18 (ctr mode)\\n\\n---\\n\\ncreated into block_ciphers.rs\\n\\n\\n\\ns3c19 (ctr break substitutions - dumb)\\n\\n---\\n\\ncargo run --bin break_ctr_dumb < res/s3c19.txt\\n\\n\\n\\ns3c20 (ctr break sattistic - smart) actually same as previous\\n\\n---\\n\\ncargo run --bin break_ctr_smart < res/s3c20.txt\\n\\n\\n\\ns3c21 (mt19937)\\n\\n---\\n\\nimplemented into lib under mt19937.rs\\n\\n\\n\\ns3c22 (mt19937 epoch seed crack)\\n\\n---\\n\\ncargo run --release --bin s3c22_mt19937_wait_crack\\n\\n\\n\\ns3c23 (mt19937 clone from output)\\n\\n---\\n\\ncargo run --release --bin s3c23_clone_mt19937\\n\\n\\n\\ns3c24 (mt19937 stream cipher + crack)\\n\\n---\\n\\n`cargo run --release --bin s3c24_mt19937_cipher`\\n\\n\\n\\ns4c25 (aes_ctr_random_rw_break)\\n\\n---\\n\\n`cargo run --release --bin s4c25_aes_ctr_random_rw_break < res/s4c25.txt`\\n\\n\\n\\ns4c26\\n\\n---\\n\\n`cargo run --release --bin s4c26_ctr_bitflipping`\\n\\n\\n\",\n \"file_path\": \"README.md\",\n \"rank\": 66,\n \"score\": 7.638759684788892\n },\n {\n \"content\": \" extern crate std;\\n\\n extern crate serde_json;\\n\\n\\n\\n use self::std::prelude::v1::*;\\n\\n\\n\\n use {Sha1, Digest};\\n\\n\\n\\n #[test]\\n\\n fn test_to_json() {\\n\\n let mut s = Sha1::new();\\n\\n s.update(b\\\"Hello World!\\\");\\n\\n let x = s.digest();\\n\\n let y = serde_json::to_vec(&x).unwrap();\\n\\n assert_eq!(y, &b\\\"\\\\\\\"2ef7bde608ce5404e97d5f042f95f89f1c232871\\\\\\\"\\\"[..]);\\n\\n }\\n\\n\\n\\n #[test]\\n\\n fn test_from_json() {\\n\\n let y: Digest = serde_json::from_str(\\\"\\\\\\\"2ef7bde608ce5404e97d5f042f95f89f1c232871\\\\\\\"\\\").unwrap();\\n\\n assert_eq!(y.to_string(), \\\"2ef7bde608ce5404e97d5f042f95f89f1c232871\\\");\\n\",\n \"file_path\": \"src/sha1.rs\",\n \"rank\": 68,\n \"score\": 7.18444494223804\n },\n {\n \"content\": \" if state == 1 && cur_byte == &0xff_u8 && next_byte == 0x00_u8 {\\n\\n // take the 64 bytes of digest\\n\\n let provided_digest: &[u8] = &padded_sig[i + 2..i + 2 + 32];\\n\\n let calced_digest: &[u8] = &Sha256::digest(&m.to_bytes_be());\\n\\n return provided_digest == calced_digest;\\n\\n }\\n\\n }\\n\\n false\\n\\n }\\n\\n\\n\\n pub fn encrypt(&self, m: &BigUint) -> BigUint {\\n\\n m.modpow(&self.e, &self.n)\\n\\n }\\n\\n\\n\\n pub fn decrypt(&self, c: &BigUint) -> BigUint {\\n\\n c.modpow(&self.d, &self.n)\\n\\n }\\n\\n\\n\\n pub fn gen_big_prime(bits: i32) -> BigUint {\\n\\n use openssl::bn::BigNum;\\n\",\n \"file_path\": \"src/rsa.rs\",\n \"rank\": 69,\n \"score\": 7.093468140826138\n },\n {\n \"content\": \" self.0 >> rhs.0,\\n\\n self.1 >> rhs.1,\\n\\n self.2 >> rhs.2,\\n\\n self.3 >> rhs.3,\\n\\n )\\n\\n }\\n\\n }\\n\\n\\n\\n #[derive(Clone, Copy)]\\n\\n #[allow(non_camel_case_types)]\\n\\n pub struct u64x2(pub u64, pub u64);\\n\\n\\n\\n impl Add for u64x2 {\\n\\n type Output = u64x2;\\n\\n\\n\\n fn add(self, rhs: u64x2) -> u64x2 {\\n\\n u64x2(self.0.wrapping_add(rhs.0), self.1.wrapping_add(rhs.1))\\n\\n }\\n\\n }\\n\\n}\\n\",\n \"file_path\": \"src/sha1.rs\",\n \"rank\": 70,\n \"score\": 6.900308910071147\n },\n {\n \"content\": \"\\n\\n#[cfg(feature = \\\"serde\\\")]\\n\\nimpl serde::ser::Serialize for Digest {\\n\\n fn serialize(&self, serializer: S) -> Result\\n\\n where\\n\\n S: serde::ser::Serializer,\\n\\n {\\n\\n fn to_hex(num: u8) -> u8 {\\n\\n b\\\"0123456789abcdef\\\"[num as usize]\\n\\n }\\n\\n\\n\\n let mut hex_str = [0u8; 40];\\n\\n let mut c = 0;\\n\\n for state in self.data.state.iter() {\\n\\n for off in 0..4 {\\n\\n let byte = (state >> (8 * (3 - off))) as u8;\\n\\n hex_str[c] = to_hex(byte >> 4);\\n\\n hex_str[c + 1] = to_hex(byte & 0xf);\\n\\n c += 2;\\n\\n }\\n\",\n \"file_path\": \"src/sha1.rs\",\n \"rank\": 71,\n \"score\": 6.879778416183777\n },\n {\n \"content\": \" pub fn pad_pkcs_1_5(&self, m: &[u8]) -> Vec {\\n\\n let m_b = m.len();\\n\\n let k = self.n.to_bytes_be().len();\\n\\n let ps_len = k - 3 - m_b;\\n\\n assert!(m_b <= k - 11);\\n\\n\\n\\n let mut random_bytes = vec![];\\n\\n let mut rng = rand::thread_rng();\\n\\n\\n\\n // correct way to get unbiased random bytes\\n\\n while random_bytes.len() < ps_len {\\n\\n let b: u8 = rng.gen();\\n\\n if b == 0x00 {\\n\\n continue;\\n\\n }\\n\\n random_bytes.push(b);\\n\\n }\\n\\n\\n\\n vec![\\n\\n [0x00, 0x02].to_vec(),\\n\",\n \"file_path\": \"src/rsa.rs\",\n \"rank\": 72,\n \"score\": 6.817432936350897\n },\n {\n \"content\": \" let S = match attack {\\n\\n None => (B - (k * (g.modpow(&x, &N)))).modpow(&(dh.secret + (u * x)), &N),\\n\\n Some(_) => 0.to_biguint().unwrap(),\\n\\n };\\n\\n println!(\\\"client got S: {}\\\", S);\\n\\n\\n\\n let K: &[u8] = &Sha256::digest(&S.to_bytes_be());\\n\\n\\n\\n /*\\n\\n send our HMAC(K, salt) to server for verification\\n\\n */\\n\\n let hmac = Sha256::digest(&vec![K, &server_salt.to_bytes_be()].concat());\\n\\n stream.write_all(&bytes_to_hexbytes(&hmac)).unwrap();\\n\\n\\n\\n /*\\n\\n read final \\\"OK\\\" or \\\"FAIL\\\"\\n\\n */\\n\\n let mut buffer = [0_u8; 2048];\\n\\n let _ = stream.read(&mut buffer).unwrap();\\n\\n if buffer[0] == 'O' as u8 {\\n\\n true\\n\\n } else {\\n\\n false\\n\\n }\\n\\n }\\n\\n}\\n\",\n \"file_path\": \"src/srp.rs\",\n \"rank\": 73,\n \"score\": 6.631716056249456\n },\n {\n \"content\": \"// reexport block_cipher stuff for cryptopals crate users\\n\\npub mod block_ciphers;\\n\\npub mod dh;\\n\\npub mod dsa;\\n\\npub mod md4;\\n\\npub mod mt19937;\\n\\npub mod rsa;\\n\\npub mod sha1;\\n\\npub mod srp;\\n\\npub mod weakened_srp;\\n\\n\\n\\nuse rand::Rng;\\n\\nuse std::io::{self, Read};\\n\\nuse std::time::{SystemTime, UNIX_EPOCH};\\n\\n\\n\",\n \"file_path\": \"src/lib.rs\",\n \"rank\": 74,\n \"score\": 6.590528491238993\n },\n {\n \"content\": \"use num_bigint::{BigUint, RandBigInt};\\n\\n\\n\\npub struct DiffieHellmanState {\\n\\n pub secret: BigUint,\\n\\n p: BigUint,\\n\\n g: BigUint,\\n\\n pub pubkey: BigUint,\\n\\n}\\n\\n\\n\\nimpl DiffieHellmanState {\\n\\n pub fn new(g: &BigUint, p: &BigUint) -> DiffieHellmanState {\\n\\n let secret = rand::thread_rng().gen_biguint_below(&p);\\n\\n let pubkey = DiffieHellmanState::gen_pubkey(&p, &g, &secret);\\n\\n DiffieHellmanState {\\n\\n secret,\\n\\n p: p.clone(),\\n\\n g: g.clone(),\\n\\n pubkey,\\n\\n }\\n\\n }\\n\",\n \"file_path\": \"src/dh.rs\",\n \"rank\": 75,\n \"score\": 6.5252248376520745\n },\n {\n \"content\": \" }\\n\\n\\n\\n fn handle_connection(&self, mut stream: TcpStream) {\\n\\n let dh = if !self.attack {\\n\\n DiffieHellmanState::new(&self.g, &self.N)\\n\\n } else {\\n\\n let secret = 2.to_biguint().unwrap();\\n\\n DiffieHellmanState::new_static(&self.g, &self.N, &secret)\\n\\n };\\n\\n\\n\\n /*\\n\\n read username+DH_pubkey\\n\\n */\\n\\n\\n\\n let mut buffer = [0; 1024];\\n\\n let read_bytes = stream.read(&mut buffer).unwrap();\\n\\n let data = buffer[..read_bytes].to_vec();\\n\\n let mut tokens = data.splitn(2, |x| x == &0x00_u8);\\n\\n\\n\\n let username = String::from_utf8(tokens.next().unwrap().to_vec()).unwrap();\\n\",\n \"file_path\": \"src/weakened_srp.rs\",\n \"rank\": 76,\n \"score\": 6.520560419501443\n },\n {\n \"content\": \"\\n\\npub struct WeakenedSRPClient {}\\n\\n\\n\\nimpl WeakenedSRPClient {\\n\\n pub fn auth(\\n\\n connstring: String,\\n\\n N: BigUint,\\n\\n g: BigUint,\\n\\n k: BigUint,\\n\\n username: String,\\n\\n password: String,\\n\\n ) -> bool {\\n\\n let mut stream = TcpStream::connect(connstring).unwrap();\\n\\n\\n\\n /*\\n\\n send username and DH pubkey\\n\\n */\\n\\n\\n\\n let dh = DiffieHellmanState::new(&g, &N);\\n\\n let A = dh.pubkey;\\n\",\n \"file_path\": \"src/weakened_srp.rs\",\n \"rank\": 77,\n \"score\": 6.489687607040546\n },\n {\n \"content\": \"\\n\\n UserSRP { v, salt }\\n\\n }\\n\\n}\\n\\n\\n\\npub struct SRPClient {}\\n\\n\\n\\nimpl SRPClient {\\n\\n pub fn auth(\\n\\n connstring: String,\\n\\n N: BigUint,\\n\\n g: BigUint,\\n\\n k: BigUint,\\n\\n username: String,\\n\\n password: String,\\n\\n attack: &Option,\\n\\n ) -> bool {\\n\\n let mut stream = TcpStream::connect(connstring).unwrap();\\n\\n\\n\\n /*\\n\",\n \"file_path\": \"src/srp.rs\",\n \"rank\": 78,\n \"score\": 6.169256388555466\n },\n {\n \"content\": \"//\\n\\n// Copied from https://rosettacode.org/wiki/MD4#Rust\\n\\n//\\n\\n// MD4, based on RFC 1186 and RFC 1320.\\n\\n//\\n\\n// https://www.ietf.org/rfc/rfc1186.txt\\n\\n// https://tools.ietf.org/html/rfc1320\\n\\n//\\n\\n\\n\\nuse std::fmt::Write;\\n\\nuse std::mem;\\n\\n\\n\\n// Let not(X) denote the bit-wise complement of X.\\n\\n// Let X v Y denote the bit-wise OR of X and Y.\\n\\n// Let X xor Y denote the bit-wise XOR of X and Y.\\n\\n// Let XY denote the bit-wise AND of X and Y.\\n\\n\\n\\n// f(X,Y,Z) = XY v not(X)Z\\n\",\n \"file_path\": \"src/md4.rs\",\n \"rank\": 79,\n \"score\": 6.13046394766792\n },\n {\n \"content\": \" }\\n\\n\\n\\n /// Shortcut to create a sha1 from some bytes.\\n\\n ///\\n\\n /// This also lets you create a hash from a utf-8 string. This is equivalent\\n\\n /// to making a new Sha1 object and calling `update` on it once.\\n\\n pub fn from>(data: D) -> Sha1 {\\n\\n let mut rv = Sha1::new();\\n\\n rv.update(data.as_ref());\\n\\n rv\\n\\n }\\n\\n\\n\\n /// Resets the hash object to it's initial state.\\n\\n pub fn reset(&mut self) {\\n\\n self.state = DEFAULT_STATE;\\n\\n self.len = 0;\\n\\n self.blocks.len = 0;\\n\\n }\\n\\n\\n\\n /// Update hash with input data.\\n\",\n \"file_path\": \"src/sha1.rs\",\n \"rank\": 80,\n \"score\": 6.096185078747202\n },\n {\n \"content\": \" stream.write_all(&bytes_to_hexbytes(hmac)).unwrap();\\n\\n\\n\\n /*\\n\\n read final \\\"OK\\\" or \\\"FAIL\\\"\\n\\n */\\n\\n\\n\\n let mut buffer = [0_u8; 2048];\\n\\n let _ = stream.read(&mut buffer).unwrap();\\n\\n buffer[0] == 'O' as u8\\n\\n }\\n\\n}\\n\",\n \"file_path\": \"src/weakened_srp.rs\",\n \"rank\": 81,\n \"score\": 6.023354056320512\n },\n {\n \"content\": \"extern crate openssl;\\n\\n\\n\\nuse rand::prelude::*;\\n\\n\\n\\nuse num_bigint::{BigInt, BigUint, RandBigInt, ToBigInt, ToBigUint};\\n\\nuse sha2::{Digest, Sha256};\\n\\n\\n\\npub struct RSA {\\n\\n pub e: BigUint,\\n\\n pub n: BigUint,\\n\\n pub d: BigUint,\\n\\n pub pubkey: (BigUint, BigUint),\\n\\n privkey: (BigUint, BigUint),\\n\\n}\\n\\n\\n\\nimpl RSA {\\n\\n pub fn new(bits: i32) -> RSA {\\n\\n let big_1 = &1.to_biguint().unwrap();\\n\\n\\n\\n let e = &3.to_biguint().unwrap();\\n\",\n \"file_path\": \"src/rsa.rs\",\n \"rank\": 82,\n \"score\": 5.987354004681382\n },\n {\n \"content\": \" (100000, 3292829284),\\n\\n ]\\n\\n .iter()\\n\\n .cloned()\\n\\n .collect();\\n\\n\\n\\n let largest_test = verification_data.keys().max().expect(\\\"need some tests\\\");\\n\\n\\n\\n let mut mt = Mt19937::from_seed(0x12345678u32);\\n\\n for i in 0..=*largest_test {\\n\\n let out_num = mt.extract_number();\\n\\n if let Some(verification_num) = verification_data.get(&i) {\\n\\n assert_eq!(out_num, *verification_num);\\n\\n }\\n\\n }\\n\\n\\n\\n // test tempering\\n\\n let tempered_1 = mt.temper(42);\\n\\n assert_eq!(42, mt.untemper(tempered_1));\\n\\n\\n\\n let tempered_2 = mt.temper(0xff112233);\\n\\n assert_eq!(0xff112233, mt.untemper(tempered_2));\\n\\n}\\n\",\n \"file_path\": \"src/mt19937.rs\",\n \"rank\": 83,\n \"score\": 5.8938094581970555\n },\n {\n \"content\": \" let v = &self.g.modpow(x, &self.N);\\n\\n\\n\\n let S = (&A * v.modpow(&BigUint::from_bytes_be(fake_u), &self.N))\\n\\n .modpow(&dh.secret, &self.N);\\n\\n let K: &[u8] = &Sha256::digest(&S.to_bytes_be());\\n\\n let guessed_hmac: &[u8] = &Sha256::digest(&vec![K, fake_salt].concat());\\n\\n if guessed_hmac == client_hmac {\\n\\n println!(\\\"\\\\n!!!!cracked password: {}\\\\n\\\", &password);\\n\\n }\\n\\n }\\n\\n }\\n\\n\\n\\n /*\\n\\n proceed with our calculations\\n\\n */\\n\\n\\n\\n let S = (&A * user_v.modpow(&u, &self.N)).modpow(&dh.secret, &self.N);\\n\\n let K: &[u8] = &Sha256::digest(&S.to_bytes_be());\\n\\n\\n\\n let server_hmac = Sha256::digest(&vec![K, &user_salt.to_bytes_be()].concat());\\n\",\n \"file_path\": \"src/weakened_srp.rs\",\n \"rank\": 84,\n \"score\": 5.696340079737459\n },\n {\n \"content\": \" last[120..128].clone_from_slice(&extra);\\n\\n state.process(as_block(&last[0..64]));\\n\\n state.process(as_block(&last[64..128]));\\n\\n }\\n\\n\\n\\n Digest { data: state }\\n\\n }\\n\\n\\n\\n /// Retrieve the digest result as hex string directly.\\n\\n ///\\n\\n /// (The function is only available if the `std` feature is enabled)\\n\\n #[cfg(feature = \\\"std\\\")]\\n\\n pub fn hexdigest(&self) -> std::string::String {\\n\\n self.digest().to_string()\\n\\n }\\n\\n}\\n\\n\\n\\nimpl Digest {\\n\\n /// Returns the 160 bit (20 byte) digest as a byte array.\\n\\n pub fn bytes(&self) -> [u8; DIGEST_LENGTH] {\\n\",\n \"file_path\": \"src/sha1.rs\",\n \"rank\": 85,\n \"score\": 5.369869696698622\n },\n {\n \"content\": \" assert_eq!(r.finish().unwrap().as_ref(), &m.digest().bytes());\\n\\n }\\n\\n }\\n\\n\\n\\n #[test]\\n\\n #[cfg(feature=\\\"std\\\")]\\n\\n fn test_parse() {\\n\\n use Digest;\\n\\n use std::error::Error;\\n\\n let y: Digest = \\\"2ef7bde608ce5404e97d5f042f95f89f1c232871\\\".parse().unwrap();\\n\\n assert_eq!(y.to_string(), \\\"2ef7bde608ce5404e97d5f042f95f89f1c232871\\\");\\n\\n assert!(\\\"asdfasdf\\\".parse::().is_err());\\n\\n assert_eq!(\\\"asdfasdf\\\".parse::()\\n\\n .map_err(|x| x.description().to_string()).unwrap_err(), \\\"not a valid sha1 hash\\\");\\n\\n }\\n\\n}\\n\\n\\n\\n#[cfg_attr(rustfmt, rustfmt_skip)]\\n\\n#[cfg(all(test, feature=\\\"serde\\\"))]\\n\\nmod serde_tests {\\n\",\n \"file_path\": \"src/sha1.rs\",\n \"rank\": 86,\n \"score\": 5.0965902894631165\n },\n {\n \"content\": \" let mut buffer = [0; 1024];\\n\\n let read_bytes = stream.read(&mut buffer).unwrap();\\n\\n let payload = &buffer[..read_bytes];\\n\\n\\n\\n if hexbytes_to_bytes(payload) == etalon.as_slice() {\\n\\n stream.write_all(b\\\"OK\\\").unwrap();\\n\\n } else {\\n\\n stream.write_all(b\\\"FAIL\\\").unwrap();\\n\\n }\\n\\n }\\n\\n\\n\\n fn calc_user_srp(g: &BigUint, N: &BigUint, password: &str) -> UserSRP {\\n\\n let salt = rand::thread_rng().gen_biguint_below(N);\\n\\n\\n\\n let mut hasher = Sha256::new();\\n\\n hasher.update(salt.to_bytes_be());\\n\\n hasher.update(password);\\n\\n\\n\\n let x = BigUint::from_bytes_be(&hasher.finalize());\\n\\n let v = g.modpow(&x, N);\\n\",\n \"file_path\": \"src/srp.rs\",\n \"rank\": 87,\n \"score\": 4.992266786172178\n },\n {\n \"content\": \"\\n\\n pub fn new_static(g: &BigUint, p: &BigUint, secret: &BigUint) -> DiffieHellmanState {\\n\\n let pubkey = DiffieHellmanState::gen_pubkey(&p, &g, &secret);\\n\\n DiffieHellmanState {\\n\\n secret: secret.clone(),\\n\\n p: p.clone(),\\n\\n g: g.clone(),\\n\\n pubkey,\\n\\n }\\n\\n }\\n\\n\\n\\n pub fn gen_shared_key(self, other_pubkey: &BigUint) -> BigUint {\\n\\n other_pubkey.modpow(&self.secret, &self.p)\\n\\n }\\n\\n\\n\\n fn gen_pubkey(p: &BigUint, g: &BigUint, secret: &BigUint) -> BigUint {\\n\\n g.modpow(secret, p)\\n\\n }\\n\\n}\\n\",\n \"file_path\": \"src/dh.rs\",\n \"rank\": 88,\n \"score\": 4.908216851396576\n },\n {\n \"content\": \" stream\\n\\n .write_all(\\n\\n &vec![\\n\\n username.as_bytes(),\\n\\n &[0x00],\\n\\n &bytes_to_hexbytes(&A.to_bytes_be()),\\n\\n ]\\n\\n .concat(),\\n\\n )\\n\\n .unwrap();\\n\\n\\n\\n /*\\n\\n read salt+B from server\\n\\n */\\n\\n\\n\\n let mut buffer = [0; 2048];\\n\\n let read_bytes = stream.read(&mut buffer).unwrap();\\n\\n let data = buffer[..read_bytes].to_vec();\\n\\n let mut tokens = data.splitn(3, |x| x == &0x00_u8);\\n\\n\\n\",\n \"file_path\": \"src/weakened_srp.rs\",\n \"rank\": 89,\n \"score\": 4.788144711476588\n },\n {\n \"content\": \" let mut b = b.clone();\\n\\n\\n\\n while a != 0.to_bigint().unwrap() {\\n\\n let (q, _a) = (&b / &a, &b % &a);\\n\\n b = a;\\n\\n a = _a;\\n\\n let (_y0, _y1) = (&y1, &y0 - (&q * &y1));\\n\\n y0 = _y0.clone();\\n\\n y1 = _y1;\\n\\n let (_x0, _x1) = (&x1, &x0 - (&q * &x1));\\n\\n x0 = _x0.clone();\\n\\n x1 = _x1;\\n\\n }\\n\\n (b, x0, y0)\\n\\n }\\n\\n\\n\\n fn egcd(a: &BigInt, b: &BigInt) -> (BigInt, BigInt, BigInt) {\\n\\n if a == &0.to_bigint().unwrap() {\\n\\n return (b.clone(), 0.to_bigint().unwrap(), 1.to_bigint().unwrap());\\n\\n }\\n\",\n \"file_path\": \"src/rsa.rs\",\n \"rank\": 90,\n \"score\": 4.769502938484949\n },\n {\n \"content\": \" let mut users_srp: HashMap = HashMap::new();\\n\\n for (username, password) in users.iter() {\\n\\n let srp_params = SRPServer::calc_user_srp(&g, &N, password);\\n\\n users_srp.insert(username.to_string(), srp_params);\\n\\n }\\n\\n let server = SRPServer { N, g, k, users_srp };\\n\\n thread::spawn(move || {\\n\\n let listener = TcpListener::bind(connstring).unwrap();\\n\\n for stream in listener.incoming() {\\n\\n server.handle_connection(stream.unwrap());\\n\\n }\\n\\n });\\n\\n }\\n\\n\\n\\n fn handle_connection(&self, mut stream: TcpStream) {\\n\\n let dh = DiffieHellmanState::new(&self.g, &self.N);\\n\\n /*\\n\\n read username+DH_pubkey\\n\\n */\\n\\n let mut buffer = [0; 1024];\\n\",\n \"file_path\": \"src/srp.rs\",\n \"rank\": 91,\n \"score\": 4.715405743019177\n },\n {\n \"content\": \" let mut big = BigNum::new().unwrap();\\n\\n\\n\\n big.generate_prime(bits, true, None, None).unwrap();\\n\\n let prime_bytes = big.to_vec();\\n\\n BigUint::from_bytes_be(&prime_bytes)\\n\\n }\\n\\n\\n\\n /*\\n\\n unusded\\n\\n alternative to egcd\\n\\n */\\n\\n fn _xgcd(a: &BigInt, b: &BigInt) -> (BigInt, BigInt, BigInt) {\\n\\n let (mut x0, mut x1, mut y0, mut y1) = (\\n\\n 0.to_bigint().unwrap(),\\n\\n 1.to_bigint().unwrap(),\\n\\n 1.to_bigint().unwrap(),\\n\\n 0.to_bigint().unwrap(),\\n\\n );\\n\\n\\n\\n let mut a = a.clone();\\n\",\n \"file_path\": \"src/rsa.rs\",\n \"rank\": 92,\n \"score\": 4.692957560191009\n },\n {\n \"content\": \" random_bytes,\\n\\n [0x00].to_vec(),\\n\\n m.to_vec(),\\n\\n ]\\n\\n .concat()\\n\\n }\\n\\n\\n\\n /*\\n\\n this function is 100% fake and does just enough to do the task\\n\\n */\\n\\n pub fn verify(&self, m: &BigUint, sig: &BigUint) -> bool {\\n\\n let padded_sig = self.encrypt(sig).to_bytes_be();\\n\\n let mut state = 0;\\n\\n for (i, cur_byte) in padded_sig.iter().enumerate() {\\n\\n let next_byte = padded_sig[i + 1];\\n\\n if state == 0 {\\n\\n assert_eq!(&0x01_u8, cur_byte);\\n\\n state = 1;\\n\\n continue;\\n\\n }\\n\",\n \"file_path\": \"src/rsa.rs\",\n \"rank\": 93,\n \"score\": 4.678502489065998\n },\n {\n \"content\": \"\\n\\n let h = \\\"2fd4e1c67a2d28fced849ee1bb76e7391b93eb12\\\";\\n\\n assert_eq!(hh.len(), h.len());\\n\\n assert_eq!(hh, &*h);\\n\\n }\\n\\n\\n\\n #[test]\\n\\n fn test_sha1_loop() {\\n\\n let mut m = Sha1::new();\\n\\n let s = \\\"The quick brown fox jumps over the lazy dog.\\\";\\n\\n let n = 1000u64;\\n\\n\\n\\n for _ in 0..3 {\\n\\n m.reset();\\n\\n for _ in 0..n {\\n\\n m.update(s.as_bytes());\\n\\n }\\n\\n assert_eq!(m.digest().to_string(),\\n\\n \\\"7ca27655f67fceaa78ed2e645a81c7f1d6e249d2\\\");\\n\\n }\\n\",\n \"file_path\": \"src/sha1.rs\",\n \"rank\": 94,\n \"score\": 4.666053344037788\n },\n {\n \"content\": \" }\\n\\n}\\n\\n\\n\\n// Copyright (c) 2006-2009 Graydon Hoare\\n\\n// Copyright (c) 2009-2013 Mozilla Foundation\\n\\n\\n\\n// Permission is hereby granted, free of charge, to any\\n\\n// person obtaining a copy of this software and associated\\n\\n// documentation files (the \\\"Software\\\"), to deal in the\\n\\n// Software without restriction, including without\\n\\n// limitation the rights to use, copy, modify, merge,\\n\\n// publish, distribute, sublicense, and/or sell copies of\\n\\n// the Software, and to permit persons to whom the Software\\n\\n// is furnished to do so, subject to the following\\n\\n// conditions:\\n\\n\\n\\n// The above copyright notice and this permission notice\\n\\n// shall be included in all copies or substantial portions\\n\\n// of the Software.\\n\\n\\n\",\n \"file_path\": \"src/sha1.rs\",\n \"rank\": 95,\n \"score\": 4.565573982826924\n },\n {\n \"content\": \" .map_err(|_| DigestParseError(()))?;\\n\\n }\\n\\n Ok(rv)\\n\\n }\\n\\n}\\n\\n\\n\\nimpl fmt::Display for Digest {\\n\\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\\n\\n for i in self.data.state.iter() {\\n\\n write!(f, \\\"{:08x}\\\", i)?;\\n\\n }\\n\\n Ok(())\\n\\n }\\n\\n}\\n\\n\\n\\nimpl fmt::Debug for Digest {\\n\\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\\n\\n write!(f, \\\"Digest {{ \\\\\\\"{}\\\\\\\" }}\\\", self)\\n\\n }\\n\\n}\\n\",\n \"file_path\": \"src/sha1.rs\",\n \"rank\": 96,\n \"score\": 4.479059206514475\n },\n {\n \"content\": \"// THE SOFTWARE IS PROVIDED \\\"AS IS\\\", WITHOUT WARRANTY OF\\n\\n// ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED\\n\\n// TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A\\n\\n// PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT\\n\\n// SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY\\n\\n// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION\\n\\n// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR\\n\\n// IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER\\n\\n// DEALINGS IN THE SOFTWARE.\\n\\n\\n\\npub use self::fake::*;\\n\\n\\n\",\n \"file_path\": \"src/sha1.rs\",\n \"rank\": 97,\n \"score\": 4.3288222745563525\n },\n {\n \"content\": \" }\\n\\n\\n\\n // Everything after this operates on 32-bit words, so reinterpret the buffer.\\n\\n let mut w = convert_byte_vec_to_u32(bytes.clone());\\n\\n\\n\\n // Step 2. Append length\\n\\n // A 64-bit representation of b (the length of the message before the padding bits were added)\\n\\n // is appended to the result of the previous step, low-order bytes first.\\n\\n w.push(initial_bit_len as u32); // Push low-order bytes first\\n\\n w.push((initial_bit_len >> 32) as u32);\\n\\n\\n\\n // Step 3. Initialize MD buffer\\n\\n let (mut a, mut b, mut c, mut d) = match inner_state {\\n\\n Some(is) => (is[0], is[1], is[2], is[3]),\\n\\n None => (\\n\\n 0x67452301_u32,\\n\\n 0xefcdab89_u32,\\n\\n 0x98badcfe_u32,\\n\\n 0x10325476_u32,\\n\\n ),\\n\",\n \"file_path\": \"src/md4.rs\",\n \"rank\": 98,\n \"score\": 4.205034574786506\n },\n {\n \"content\": \" [\\n\\n (self.data.state[0] >> 24) as u8,\\n\\n (self.data.state[0] >> 16) as u8,\\n\\n (self.data.state[0] >> 8) as u8,\\n\\n (self.data.state[0] >> 0) as u8,\\n\\n (self.data.state[1] >> 24) as u8,\\n\\n (self.data.state[1] >> 16) as u8,\\n\\n (self.data.state[1] >> 8) as u8,\\n\\n (self.data.state[1] >> 0) as u8,\\n\\n (self.data.state[2] >> 24) as u8,\\n\\n (self.data.state[2] >> 16) as u8,\\n\\n (self.data.state[2] >> 8) as u8,\\n\\n (self.data.state[2] >> 0) as u8,\\n\\n (self.data.state[3] >> 24) as u8,\\n\\n (self.data.state[3] >> 16) as u8,\\n\\n (self.data.state[3] >> 8) as u8,\\n\\n (self.data.state[3] >> 0) as u8,\\n\\n (self.data.state[4] >> 24) as u8,\\n\\n (self.data.state[4] >> 16) as u8,\\n\\n (self.data.state[4] >> 8) as u8,\\n\",\n \"file_path\": \"src/sha1.rs\",\n \"rank\": 99,\n \"score\": 4.200619750245788\n }\n]"}}},{"rowIdx":2345,"cells":{"lang":{"kind":"string","value":"Rust"},"file_path":{"kind":"string","value":"sigma-tree/src/sigma_protocol.rs"},"repo_name":{"kind":"string","value":"robkorn/sigma-rust"},"commit":{"kind":"string","value":"3aa25d62a2b6f6b071b5b89607d0688e5509a9a6"},"file_code":{"kind":"string","value":"\n\n#![allow(dead_code)]\n#![allow(unused_variables)]\n#![allow(missing_docs)]\n\npub mod dlog_group;\npub mod dlog_protocol;\npub mod prover;\npub mod verifier;\n\nuse k256::arithmetic::Scalar;\n\nuse crate::{big_integer::BigInteger, serialization::op_code::OpCode};\nuse blake2::digest::{Update, VariableOutput};\nuse blake2::VarBlake2b;\nuse dlog_group::EcPoint;\nuse dlog_protocol::{FirstDlogProverMessage, SecondDlogProverMessage};\nuse std::convert::TryInto;\n\npub struct DlogProverInput {\n \n pub w: Scalar,\n}\n\nimpl DlogProverInput {\n \n pub fn random() -> DlogProverInput {\n DlogProverInput {\n w: dlog_group::random_scalar_in_group_range(),\n }\n }\n\n \n fn public_image(&self) -> ProveDlog {\n \n let g = dlog_group::generator();\n ProveDlog::new(dlog_group::exponentiate(&g, &self.w))\n }\n}\n\npub enum PrivateInput {\n DlogProverInput(DlogProverInput),\n DiffieHellmanTupleProverInput,\n}\n\n#[derive(PartialEq, Eq, Debug, Clone)]\npub struct ProveDlog {\n \n pub h: Box,\n}\n\nimpl ProveDlog {\n \n pub fn new(ecpoint: EcPoint) -> ProveDlog {\n ProveDlog {\n h: Box::new(ecpoint),\n }\n }\n}\n\n#[derive(PartialEq, Eq, Debug, Clone)]\npub struct ProveDHTuple {\n gv: Box,\n hv: Box,\n uv: Box,\n vv: Box,\n}\n\n#[derive(PartialEq, Eq, Debug, Clone)]\npub enum SigmaProofOfKnowledgeTree {\n \n ProveDHTuple(ProveDHTuple),\n \n ProveDlog(ProveDlog),\n}\n\n#[derive(PartialEq, Eq, Debug, Clone)]\npub enum SigmaBoolean {\n \n TrivialProp(bool),\n \n ProofOfKnowledge(SigmaProofOfKnowledgeTree),\n \n CAND(Vec),\n}\n\nimpl SigmaBoolean {\n \n pub fn op_code(&self) -> OpCode {\n match self {\n SigmaBoolean::ProofOfKnowledge(SigmaProofOfKnowledgeTree::ProveDlog(_)) => {\n OpCode::PROVE_DLOG\n }\n _ => todo!(),\n }\n }\n}\n\n#[derive(PartialEq, Eq, Debug, Clone)]\npub struct SigmaProp(SigmaBoolean);\n\nimpl SigmaProp {\n \n pub fn new(sbool: SigmaBoolean) -> Self {\n SigmaProp { 0: sbool }\n }\n\n \n pub fn value(&self) -> &SigmaBoolean {\n &self.0\n }\n}\n\npub enum ProofTree {\n \n UncheckedTree(UncheckedTree),\n \n UnprovenTree(UnprovenTree),\n}\n\nimpl ProofTree {\n pub fn with_challenge(&self, challenge: Challenge) -> ProofTree {\n todo!()\n }\n}\n\npub enum UnprovenTree {\n UnprovenSchnorr(UnprovenSchnorr),\n}\n\nimpl UnprovenTree {\n pub fn real(&self) -> bool {\n match self {\n UnprovenTree::UnprovenSchnorr(us) => !us.simulated,\n }\n }\n}\n\npub struct UnprovenSchnorr {\n proposition: ProveDlog,\n commitment_opt: Option,\n randomness_opt: Option,\n challenge_opt: Option,\n simulated: bool,\n}\n\n#[derive(PartialEq, Eq, Debug, Clone)]\npub struct Challenge(FiatShamirHash);\n\npub enum UncheckedSigmaTree {\n UncheckedLeaf(UncheckedLeaf),\n}\n\npub enum UncheckedLeaf {\n UncheckedSchnorr(UncheckedSchnorr),\n}\n\nimpl UncheckedLeaf {\n pub fn proposition(&self) -> SigmaBoolean {\n match self {\n UncheckedLeaf::UncheckedSchnorr(us) => SigmaBoolean::ProofOfKnowledge(\n SigmaProofOfKnowledgeTree::ProveDlog(us.proposition.clone()),\n ),\n }\n }\n}\n\npub struct UncheckedSchnorr {\n proposition: ProveDlog,\n commitment_opt: Option,\n challenge: Challenge,\n second_message: SecondDlogProverMessage,\n}\n\nimpl UncheckedSigmaTree {\n \n \n \n \n \n}\n\npub enum UncheckedTree {\n \n NoProof,\n \n UncheckedSigmaTree(UncheckedSigmaTree),\n}\n\nfn serialize_sig(tree: UncheckedTree) -> Vec {\n match tree {\n UncheckedTree::NoProof => vec![],\n UncheckedTree::UncheckedSigmaTree(_) => todo!(),\n }\n}\n\nfn fiat_shamir_tree_to_bytes(tree: &ProofTree) -> Vec {\n \n \n \n \n \n \n todo!()\n}\n\n/** Size of the binary representation of any group element (2 ^ groupSizeBits == ) */\npub const GROUP_SIZE_BITS: usize = 256;\n/** Number of bytes to represent any group element as byte array */\npub const GROUP_SIZE: usize = GROUP_SIZE_BITS / 8;\n/** A size of challenge in Sigma protocols, in bits.\n * If this anything but 192, threshold won't work, because we have polynomials over GF(2^192) and no others.\n * So DO NOT change the value without implementing polynomials over GF(2^soundnessBits) first\n * and changing code that calls on GF2_192 and GF2_192_Poly classes!!!\n * We get the challenge by reducing hash function output to proper value.\n */\npub const SOUNDNESS_BITS: usize = 192;\npub const SOUNDNESS_BYTES: usize = SOUNDNESS_BITS / 8;\n\n#[derive(PartialEq, Eq, Debug, Clone)]\npub struct FiatShamirHash(pub Box<[u8; SOUNDNESS_BYTES]>);\n\npub fn fiat_shamir_hash_fn(input: &[u8]) -> FiatShamirHash {\n \n let mut hasher = VarBlake2b::new(SOUNDNESS_BYTES).unwrap();\n hasher.update(input);\n let hash = hasher.finalize_boxed();\n \n FiatShamirHash(hash.try_into().unwrap())\n}\n\n#[cfg(test)]\nmod tests {\n use super::*;\n use proptest::prelude::*;\n\n impl Arbitrary for ProveDlog {\n type Parameters = ();\n type Strategy = BoxedStrategy;\n\n fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy {\n (any::()).prop_map(ProveDlog::new).boxed()\n }\n }\n\n impl Arbitrary for SigmaBoolean {\n type Parameters = ();\n type Strategy = BoxedStrategy;\n\n fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy {\n (any::())\n .prop_map(|p| {\n SigmaBoolean::ProofOfKnowledge(SigmaProofOfKnowledgeTree::ProveDlog(p))\n })\n .boxed()\n }\n }\n\n impl Arbitrary for SigmaProp {\n type Parameters = ();\n type Strategy = BoxedStrategy;\n\n fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy {\n (any::()).prop_map(SigmaProp).boxed()\n }\n }\n\n #[test]\n fn ensure_soundness_bits() {\n \n assert!(SOUNDNESS_BITS < GROUP_SIZE_BITS);\n \n assert!(SOUNDNESS_BYTES * 8 <= 512);\n assert!(SOUNDNESS_BYTES % 8 == 0);\n }\n\n \n \n \n \n}\n"},"prefix":{"kind":"string","value":"\n\n#![allow(dead_code)]\n#![allow(unused_variables)]\n#![allow(missing_docs)]\n\npub mod dlog_group;\npub mod dlog_protocol;\npub mod prover;\npub mod verifier;\n\nuse k256::arithmetic::Scalar;\n\nuse crate::{big_integer::BigInteger, serialization::op_code::OpCode};\nuse blake2::digest::{Update, VariableOutput};\nuse blake2::VarBlake2b;\nuse dlog_group::EcPoint;\nuse dlog_protocol::{FirstDlogProverMessage, SecondDlogProverMessage};\nuse std::convert::TryInto;\n\npub struct DlogProverInput {\n \n pub w: Scalar,\n}\n\nimpl DlogProverInput {\n \n pub fn random() -> DlogProverInput {\n DlogProverInput {\n w: dlog_group::random_scalar_in_group_range(),\n }\n }\n\n \n fn public_image(&self) -> ProveDlog {\n \n let g = dlog_group::generator();\n ProveDlog::new(dlog_group::exponentiate(&g, &self.w))\n }\n}\n\npub enum PrivateInput {\n DlogProverInput(DlogProverInput),\n DiffieHellmanTupleProverInput,\n}\n\n#[derive(PartialEq, Eq, Debug, Clone)]\npub struct ProveDlog {\n \n pub h: Box,\n}\n\nimpl ProveDlog {\n \n pub fn new(ecpoint: EcPoint) -> ProveDlog {\n ProveDlog {\n h: Box::new(ecpoint),\n }\n }\n}\n\n#[derive(PartialEq, Eq, Debug, Clone)]\npub struct ProveDHTuple {\n gv: Box,\n hv: Box,\n uv: Box,\n vv: Box,\n}\n\n#[derive(PartialEq, Eq, Debug, Clone)]\npub enum SigmaProofOfKnowledgeTree {\n \n ProveDHTuple(ProveDHTuple),\n \n ProveDlog(ProveDlog),\n}\n\n#[derive(PartialEq, Eq, Debug, Clone)]\npub enum SigmaBoolean {\n \n TrivialProp(bool),\n \n ProofOfKnowledge(SigmaProofOfKnowledgeTree),\n \n CAND(Vec),\n}\n\nimpl SigmaBoolean {\n \n pub fn op_code(&self) -> OpCode {\n match self {\n SigmaBoolean::ProofOfKnowledge(SigmaProofOfKnowledgeTree::ProveDlog(_)) => {\n OpCode::PROVE_DLOG\n }\n _ => todo!(),\n }\n }\n}\n\n#[derive(PartialEq, Eq, Debug, Clone)]\npub struct SigmaProp(SigmaBoolean);\n\nimpl SigmaProp {\n \n pub fn new(sbool: SigmaBoolean) -> Self {\n SigmaProp { 0: sbool }\n }\n\n \n pub fn value(&self) -> &SigmaBoolean {\n &self.0\n }\n}\n\npub enum ProofTree {\n \n UncheckedTree(UncheckedTree),\n \n UnprovenTree(UnprovenTree),\n}\n\nimpl ProofTree {\n pub fn with_challenge(&self, challenge: Challenge) -> ProofTree {\n todo!()\n }\n}\n\npub enum UnprovenTree {\n UnprovenSchnorr(UnprovenSchnorr),\n}\n\nimpl UnprovenTree {\n pub fn real(&self) -> bool {\n match self {\n UnprovenTree::UnprovenSchnorr(us) => !us.simulated,\n }\n }\n}\n\npub struct UnprovenSchnorr {\n proposition: ProveDlog,\n commitment_opt: Option,\n randomness_opt: Option,\n challenge_opt: Option,\n simulated: bool,\n}\n\n#[derive(PartialEq, Eq, Debug, Clone)]\npub struct Challenge(FiatShamirHash);\n\npub enum UncheckedSigmaTree {\n UncheckedLeaf(UncheckedLeaf),\n}\n\npub enum UncheckedLeaf {\n UncheckedSchnorr(UncheckedSchnorr),\n}\n\nimpl UncheckedLeaf {\n pub fn proposition(&self) -> SigmaBoolean {\n match self {\n UncheckedLeaf::UncheckedSchnorr(us) => SigmaBoolean::ProofOfKnowledge(\n SigmaProofOfKnowledgeTree::ProveDlog(us.proposition.clone()),\n ),\n }\n }\n}\n\npub struct UncheckedSchnorr {\n proposition: ProveDlog,\n commitment_opt: Option,\n challenge: Challenge,\n second_message: SecondDlogProverMessage,\n}\n\nimpl UncheckedSigmaTree {\n \n \n \n \n \n}\n\npub enum UncheckedTree {\n \n NoProof,\n \n UncheckedSigmaTree(UncheckedSigmaTree),\n}\n\nfn serialize_sig(tree: UncheckedTree) -> Vec {\n match tree {\n UncheckedTree::NoProof => vec![],\n UncheckedTree::UncheckedSigmaTree(_) => todo!(),\n }\n}\n\nfn fiat_shamir_tree_to_bytes(tree: &ProofTree) -> Vec {\n \n \n \n \n \n \n todo!()\n}\n\n/** Size of the binary representation of any group element (2 ^ groupSizeBits == ) */\npub const GROUP_SIZE_BITS: usize = 256;\n/** Number of bytes to represent any group element as byte array */\npub const GROUP_SIZE: usize = GROUP_SIZE_BITS / 8;\n/** A size of challenge in Sigma protocols, in bits.\n * If this anything but 192, threshold won't work, because we have polynomials over GF(2^192) and no others.\n * So DO NOT change the value without implementing polynomials over GF(2^soundnessBits) first\n * and changing code that calls on GF2_192 and GF2_192_Poly classes!!!\n * We get the challenge by reducing hash function output to proper value.\n */\npub const SOUNDNESS_BITS: usize = 192;\npub const SOUNDNESS_BYTES: usize = SOUNDNESS_BITS / 8;\n\n#[derive(PartialEq, Eq, Debug, Clone)]\npub struct FiatShamirHash(pub Box<[u8; SOUNDNESS_BYTES]>);\n\npub fn fiat_shamir_hash_fn(input: &[u8]) -> FiatShamirHash {\n \n let mut hasher = VarBlake2b::new(SOUNDNESS_BYTES).unwra"},"suffix":{"kind":"string","value":"\n\n#[cfg(test)]\nmod tests {\n use super::*;\n use proptest::prelude::*;\n\n impl Arbitrary for ProveDlog {\n type Parameters = ();\n type Strategy = BoxedStrategy;\n\n fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy {\n (any::()).prop_map(ProveDlog::new).boxed()\n }\n }\n\n impl Arbitrary for SigmaBoolean {\n type Parameters = ();\n type Strategy = BoxedStrategy;\n\n fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy {\n (any::())\n .prop_map(|p| {\n SigmaBoolean::ProofOfKnowledge(SigmaProofOfKnowledgeTree::ProveDlog(p))\n })\n .boxed()\n }\n }\n\n impl Arbitrary for SigmaProp {\n type Parameters = ();\n type Strategy = BoxedStrategy;\n\n fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy {\n (any::()).prop_map(SigmaProp).boxed()\n }\n }\n\n #[test]\n fn ensure_soundness_bits() {\n \n assert!(SOUNDNESS_BITS < GROUP_SIZE_BITS);\n \n assert!(SOUNDNESS_BYTES * 8 <= 512);\n assert!(SOUNDNESS_BYTES % 8 == 0);\n }\n\n \n \n \n \n}\n"},"middle":{"kind":"string","value":"p();\n hasher.update(input);\n let hash = hasher.finalize_boxed();\n \n FiatShamirHash(hash.try_into().unwrap())\n}"},"strategy":{"kind":"string","value":"function_block-function_prefixed"},"context_items":{"kind":"list like","value":[{"content":"/// Creates a random scalar, a big-endian integer in the range [0, n), where n is group order\n\npub fn random_scalar_in_group_range() -> Scalar {\n\n loop {\n\n // Generate a new secret key using the operating system's\n\n // cryptographically secure random number generator\n\n let sk = k256::SecretKey::generate();\n\n let bytes: [u8; 32] = sk\n\n .secret_scalar()\n\n .as_ref()\n\n .as_slice()\n\n .try_into()\n\n .expect(\"expected 32 bytes\");\n\n // Returns None if the byte array does not contain\n\n // a big-endian integer in the range [0, n), where n is group order.\n\n let maybe_scalar = Scalar::from_bytes(bytes);\n\n if bool::from(maybe_scalar.is_some()) {\n\n break maybe_scalar.unwrap();\n\n }\n\n }\n\n}\n\n\n","file_path":"sigma-tree/src/sigma_protocol/dlog_group.rs","rank":0,"score":304795.5759556212},{"content":"/// Creates a random member of this Dlog group\n\npub fn random_element() -> EcPoint {\n\n let sk = DlogProverInput::random();\n\n let bytes = sk.w.to_bytes();\n\n let bi = BigInt::from_bytes_be(Sign::Plus, &bytes[..]);\n\n\n\n exponentiate(&generator(), &sk.w)\n\n}\n\n\n","file_path":"sigma-tree/src/sigma_protocol/dlog_group.rs","rank":1,"score":290281.25990754174},{"content":"pub fn is_identity(ge: &EcPoint) -> bool {\n\n *ge == identity()\n\n}\n\n\n","file_path":"sigma-tree/src/sigma_protocol/dlog_group.rs","rank":4,"score":261162.48115587642},{"content":"/// Blake2b256 hash (256 bit)\n\npub fn blake2b256_hash(bytes: &[u8]) -> Digest32 {\n\n // unwrap is safe 32 bytes is a valid hash size (<= 512 && 32 % 8 == 0)\n\n let mut hasher = VarBlake2b::new(Digest32::SIZE).unwrap();\n\n hasher.update(bytes);\n\n let hash = hasher.finalize_boxed();\n\n // unwrap is safe due to hash size is expected to be Digest32::SIZE\n\n Digest32(hash.try_into().unwrap())\n\n}\n\n\n\nimpl From<[u8; Digest32::SIZE]> for Digest32 {\n\n fn from(bytes: [u8; Digest32::SIZE]) -> Self {\n\n Digest32(Box::new(bytes))\n\n }\n\n}\n\n\n\nimpl Into for Digest32 {\n\n fn into(self) -> Base16EncodedBytes {\n\n Base16EncodedBytes::new(self.0.as_ref())\n\n }\n\n}\n","file_path":"sigma-tree/src/chain/digest32.rs","rank":6,"score":248194.5878895931},{"content":"/// Raises the base GroupElement to the exponent. The result is another GroupElement.\n\npub fn exponentiate(base: &EcPoint, exponent: &Scalar) -> EcPoint {\n\n if !is_identity(base) {\n\n // implement for negative exponent\n\n // see reference impl https://github.com/ScorexFoundation/sigmastate-interpreter/blob/ec71a6f988f7412bc36199f46e7ad8db643478c7/sigmastate/src/main/scala/sigmastate/basics/BcDlogGroup.scala#L201\n\n // see https://github.com/ergoplatform/sigma-rust/issues/36\n\n\n\n // we treat EC as a multiplicative group, therefore, exponentiate point is multiply.\n\n EcPoint(base.0 * exponent)\n\n } else {\n\n base.clone()\n\n }\n\n}\n\n\n","file_path":"sigma-tree/src/sigma_protocol/dlog_group.rs","rank":7,"score":246609.0916878886},{"content":"/// The generator g of the group is an element of the group such that, when written multiplicatively, every element\n\n/// of the group is a power of g.\n\npub fn generator() -> EcPoint {\n\n EcPoint(ProjectivePoint::generator())\n\n}\n\n\n\n/// the identity(infinity) element of this Dlog group\n\npub const fn identity() -> EcPoint {\n\n EcPoint(ProjectivePoint::identity())\n\n}\n\n\n","file_path":"sigma-tree/src/sigma_protocol/dlog_group.rs","rank":8,"score":233539.662568651},{"content":"pub trait Prover: Evaluator {\n\n fn secrets(&self) -> &[PrivateInput];\n\n\n\n fn prove(\n\n &self,\n\n tree: &ErgoTree,\n\n env: &Env,\n\n message: &[u8],\n\n ) -> Result {\n\n let expr = tree.proposition()?;\n\n let proof = self\n\n .reduce_to_crypto(expr.as_ref(), env)\n\n .map_err(ProverError::EvalError)\n\n .and_then(|v| match v.sigma_prop {\n\n SigmaBoolean::TrivialProp(true) => Ok(UncheckedTree::NoProof),\n\n SigmaBoolean::TrivialProp(false) => Err(ProverError::ReducedToFalse),\n\n sb => {\n\n let tree = self.convert_to_unproven(sb);\n\n let unchecked_tree = self.prove_to_unchecked(tree, message)?;\n\n Ok(UncheckedTree::UncheckedSigmaTree(unchecked_tree))\n","file_path":"sigma-tree/src/sigma_protocol/prover.rs","rank":9,"score":201430.14083236712},{"content":"fn get_embeddable_type(code: u8) -> Result {\n\n match TypeCode::new(code) {\n\n TypeCode::SBOOLEAN => Ok(SType::SBoolean),\n\n TypeCode::SBYTE => Ok(SType::SByte),\n\n TypeCode::SSHORT => Ok(SType::SShort),\n\n TypeCode::SINT => Ok(SType::SInt),\n\n TypeCode::SLONG => Ok(SType::SLong),\n\n TypeCode::SBIGINT => Ok(SType::SBigInt),\n\n TypeCode::SGROUP_ELEMENT => Ok(SType::SGroupElement),\n\n TypeCode::SSIGMAPROP => Ok(SType::SSigmaProp),\n\n _ => Err(SerializationError::InvalidOpCode),\n\n }\n\n}\n\n\n","file_path":"sigma-tree/src/serialization/types.rs","rank":10,"score":199649.98139593913},{"content":"pub trait Verifier: Evaluator {\n\n fn verify(\n\n &mut self,\n\n tree: &ErgoTree,\n\n env: &Env,\n\n proof: &[u8],\n\n message: &[u8],\n\n ) -> Result {\n\n let expr = tree.proposition()?;\n\n let cprop = self.reduce_to_crypto(expr.as_ref(), env)?.sigma_prop;\n\n let res: bool = match cprop {\n\n SigmaBoolean::TrivialProp(b) => b,\n\n sb => todo!(),\n\n };\n\n Ok(VerificationResult {\n\n result: res,\n\n cost: 0,\n\n })\n\n }\n\n}\n","file_path":"sigma-tree/src/sigma_protocol/verifier.rs","rank":11,"score":182454.27450487658},{"content":"/// Box serialization with token ids optionally saved in transaction\n\n/// (in this case only token index is saved)\n\npub fn serialize_box_with_indexed_digests(\n\n box_value: &BoxValue,\n\n ergo_tree_bytes: Vec,\n\n tokens: &[TokenAmount],\n\n additional_registers: &NonMandatoryRegisters,\n\n creation_height: u32,\n\n token_ids_in_tx: Option<&IndexSet>,\n\n w: &mut W,\n\n) -> Result<(), io::Error> {\n\n // reference implementation - https://github.com/ScorexFoundation/sigmastate-interpreter/blob/9b20cb110effd1987ff76699d637174a4b2fb441/sigmastate/src/main/scala/org/ergoplatform/ErgoBoxCandidate.scala#L95-L95\n\n box_value.sigma_serialize(w)?;\n\n w.write_all(&ergo_tree_bytes[..])?;\n\n w.put_u32(creation_height)?;\n\n w.put_u8(u8::try_from(tokens.len()).unwrap())?;\n\n\n\n tokens.iter().try_for_each(|t| {\n\n match token_ids_in_tx {\n\n Some(token_ids) => w.put_u32(\n\n u32::try_from(\n\n token_ids\n","file_path":"sigma-tree/src/serialization/ergo_box.rs","rank":12,"score":173133.05255750826},{"content":"#[derive(PartialEq, Eq, Debug, Clone)]\n\nstruct ErgoTreeHeader(u8);\n\n\n\nimpl ErgoTreeHeader {\n\n const CONSTANT_SEGREGATION_FLAG: u8 = 0x10;\n\n\n\n pub fn is_constant_segregation(&self) -> bool {\n\n self.0 & ErgoTreeHeader::CONSTANT_SEGREGATION_FLAG != 0\n\n }\n\n}\n\n\n\n/// Whole ErgoTree parsing (deserialization) error\n\n#[derive(PartialEq, Eq, Debug, Clone)]\n\npub struct ErgoTreeConstantsParsingError {\n\n /// Ergo tree bytes (faild to deserialize)\n\n pub bytes: Vec,\n\n /// Deserialization error\n\n pub error: SerializationError,\n\n}\n\n\n\n/// ErgoTree root expr parsing (deserialization) error\n","file_path":"sigma-tree/src/ergo_tree.rs","rank":13,"score":171467.29386373737},{"content":"pub fn serialize_bytes(bytes: T, serializer: S) -> Result\n\nwhere\n\n S: Serializer,\n\n T: AsRef<[u8]>,\n\n{\n\n serializer.serialize_str(&base16::encode_lower(bytes.as_ref()))\n\n}\n\n\n\npub mod ergo_tree {\n\n\n\n use super::*;\n\n use crate::ErgoTree;\n\n use serde::{Deserialize, Deserializer, Serializer};\n\n use sigma_ser::serializer::SigmaSerializable;\n\n\n\n pub fn serialize(ergo_tree: &ErgoTree, serializer: S) -> Result\n\n where\n\n S: Serializer,\n\n {\n\n let bytes = ergo_tree.sigma_serialise_bytes();\n","file_path":"sigma-tree/src/chain/json.rs","rank":14,"score":145282.7728311161},{"content":"fn is_stype_embeddable(tpe: &SType) -> bool {\n\n match tpe {\n\n SType::SBoolean => true,\n\n SType::SByte => true,\n\n SType::SShort => true,\n\n SType::SInt => true,\n\n SType::SLong => true,\n\n SType::SBigInt => true,\n\n SType::SGroupElement => true,\n\n SType::SSigmaProp => true,\n\n _ => false,\n\n }\n\n}\n\n\n\nimpl SigmaSerializable for SType {\n\n fn sigma_serialize(&self, w: &mut W) -> Result<(), io::Error> {\n\n // for reference see http://github.com/ScorexFoundation/sigmastate-interpreter/blob/25251c1313b0131835f92099f02cef8a5d932b5e/sigmastate/src/main/scala/sigmastate/serialization/TypeSerializer.scala#L25-L25\n\n match self {\n\n SType::SAny => self.type_code().sigma_serialize(w),\n\n\n","file_path":"sigma-tree/src/serialization/types.rs","rank":15,"score":144069.00610777322},{"content":"#[allow(unconditional_recursion)]\n\nfn eval(expr: &Expr, env: &Env, ca: &mut CostAccumulator) -> Result {\n\n match expr {\n\n Expr::Const(Constant {\n\n tpe: SType::SBoolean,\n\n v: ConstantVal::Boolean(b),\n\n }) => Ok(Value::Boolean(*b)),\n\n Expr::Const(Constant {\n\n tpe: SType::SSigmaProp,\n\n v: ConstantVal::SigmaProp(sp),\n\n }) => Ok(Value::SigmaProp(Box::new((*sp.value()).clone()))),\n\n Expr::Coll { .. } => todo!(),\n\n Expr::Tup { .. } => todo!(),\n\n Expr::PredefFunc(_) => todo!(),\n\n Expr::CollM(_) => todo!(),\n\n Expr::BoxM(_) => todo!(),\n\n Expr::CtxM(_) => todo!(),\n\n Expr::MethodCall { .. } => todo!(),\n\n Expr::BinOp(bin_op, l, r) => {\n\n let v_l = eval(l, env, ca)?;\n\n let v_r = eval(r, env, ca)?;\n","file_path":"sigma-tree/src/eval.rs","rank":16,"score":143356.5365707662},{"content":"//! Verifier\n\n\n\n#![allow(dead_code)]\n\n#![allow(unused_variables)]\n\n#![allow(missing_docs)]\n\n\n\nuse super::SigmaBoolean;\n\nuse crate::{\n\n eval::{Env, EvalError, Evaluator},\n\n ErgoTree, ErgoTreeParsingError,\n\n};\n\n\n\npub enum VerifierError {\n\n ErgoTreeError(ErgoTreeParsingError),\n\n EvalError(EvalError),\n\n}\n\n\n\nimpl From for VerifierError {\n\n fn from(err: ErgoTreeParsingError) -> Self {\n\n VerifierError::ErgoTreeError(err)\n","file_path":"sigma-tree/src/sigma_protocol/verifier.rs","rank":17,"score":132343.50952893982},{"content":" }\n\n}\n\n\n\nimpl From for VerifierError {\n\n fn from(err: EvalError) -> Self {\n\n VerifierError::EvalError(err)\n\n }\n\n}\n\n\n\npub struct VerificationResult {\n\n result: bool,\n\n cost: u64,\n\n}\n\n\n","file_path":"sigma-tree/src/sigma_protocol/verifier.rs","rank":18,"score":132336.48822234911},{"content":"\n\nimpl Evaluator for TestProver {}\n\nimpl Prover for TestProver {\n\n fn secrets(&self) -> &[PrivateInput] {\n\n self.secrets.as_ref()\n\n }\n\n}\n\n\n\n#[derive(PartialEq, Eq, Debug, Clone)]\n\npub enum ProverError {\n\n ErgoTreeError(ErgoTreeParsingError),\n\n EvalError(EvalError),\n\n ReducedToFalse,\n\n TreeRootIsNotReal,\n\n SimulatedLeafWithoutChallenge,\n\n RealUnprovenTreeWithoutChallenge,\n\n SecretNotFound,\n\n}\n\n\n\nimpl From for ProverError {\n\n fn from(err: ErgoTreeParsingError) -> Self {\n\n ProverError::ErgoTreeError(err)\n\n }\n\n}\n\n\n","file_path":"sigma-tree/src/sigma_protocol/prover.rs","rank":19,"score":132090.0939276574},{"content":"//! Interpreter with enhanced functionality to prove statements.\n\n\n\n#![allow(dead_code)]\n\n#![allow(unused_variables)]\n\n#![allow(missing_docs)]\n\n\n\nuse super::{\n\n dlog_protocol, fiat_shamir_hash_fn, fiat_shamir_tree_to_bytes, serialize_sig, Challenge,\n\n PrivateInput, ProofTree, SigmaBoolean, SigmaProofOfKnowledgeTree, UncheckedLeaf,\n\n UncheckedSchnorr, UncheckedSigmaTree, UncheckedTree, UnprovenSchnorr, UnprovenTree,\n\n};\n\nuse crate::{\n\n chain::{ContextExtension, ProverResult},\n\n eval::{Env, EvalError, Evaluator},\n\n ErgoTree, ErgoTreeParsingError,\n\n};\n\n\n\npub struct TestProver {\n\n pub secrets: Vec,\n\n}\n","file_path":"sigma-tree/src/sigma_protocol/prover.rs","rank":20,"score":132086.3459287251},{"content":" // and the message being signed.\n\n s.append(&mut message.to_vec());\n\n let root_challenge = fiat_shamir_hash_fn(s.as_slice());\n\n let step8 = step6.with_challenge(Challenge(root_challenge));\n\n\n\n // Prover Step 9: complete the proof by computing challenges at real nodes and additionally responses at real leaves\n\n let step9 = self.proving(step8)?;\n\n\n\n // Prover Step 10: output the right information into the proof\n\n match step9 {\n\n ProofTree::UncheckedTree(UncheckedTree::UncheckedSigmaTree(tree)) => Ok(tree),\n\n _ => todo!(),\n\n }\n\n }\n\n\n\n /**\n\n Prover Step 1: This step will mark as \"real\" every node for which the prover can produce a real proof.\n\n This step may mark as \"real\" more nodes than necessary if the prover has more than the minimal\n\n necessary number of witnesses (for example, more than one child of an OR).\n\n This will be corrected in the next step.\n","file_path":"sigma-tree/src/sigma_protocol/prover.rs","rank":21,"score":132085.12741664032},{"content":" match tree {\n\n ProofTree::UncheckedTree(_) => Ok(tree),\n\n ProofTree::UnprovenTree(unproven_tree) => match unproven_tree {\n\n UnprovenTree::UnprovenSchnorr(us) if unproven_tree.real() => {\n\n if let Some(challenge) = us.challenge_opt.clone() {\n\n if let Some(priv_key) = self\n\n .secrets()\n\n .iter()\n\n .flat_map(|s| match s {\n\n PrivateInput::DlogProverInput(dl) => vec![dl],\n\n _ => vec![],\n\n })\n\n .find(|prover_input| prover_input.public_image() == us.proposition)\n\n {\n\n let z = dlog_protocol::interactive_prover::second_message(\n\n &priv_key,\n\n us.randomness_opt.unwrap(),\n\n &challenge,\n\n );\n\n Ok(ProofTree::UncheckedTree(UncheckedTree::UncheckedSigmaTree(\n","file_path":"sigma-tree/src/sigma_protocol/prover.rs","rank":22,"score":132083.74330649685},{"content":" In a top-down traversal of the tree, do the following for each node:\n\n */\n\n fn polish_simulated(&self, unproven_tree: UnprovenTree) -> UnprovenTree {\n\n todo!()\n\n }\n\n\n\n /**\n\n Prover Step 4: In a top-down traversal of the tree, compute the challenges e for simulated children of every node\n\n Prover Step 5: For every leaf marked \"simulated\", use the simulator of the Sigma-protocol for that leaf\n\n to compute the commitment $a$ and the response z, given the challenge e that is already stored in the leaf.\n\n Prover Step 6: For every leaf marked \"real\", use the first prover step of the Sigma-protocol for that leaf to\n\n compute the commitment a.\n\n */\n\n fn simulate_and_commit(&self, tree: UnprovenTree) -> Result {\n\n match tree {\n\n UnprovenTree::UnprovenSchnorr(us) => {\n\n if us.simulated {\n\n // Step 5 (simulated leaf -- complete the simulation)\n\n if let Some(challenge) = us.challenge_opt {\n\n let (fm, sm) = dlog_protocol::interactive_prover::simulate(\n","file_path":"sigma-tree/src/sigma_protocol/prover.rs","rank":23,"score":132083.60331504315},{"content":"}\n\n\n\n// #[cfg(test)]\n\n// mod tests {\n\n// use super::*;\n\n// use crate::{\n\n// ast::{Constant, ConstantVal, Expr},\n\n// sigma_protocol::{DlogProverInput, SigmaProp},\n\n// types::SType,\n\n// };\n\n// use std::rc::Rc;\n\n\n\n// #[test]\n\n// fn test_prove_true_prop() {\n\n// let bool_true_tree = ErgoTree::from(Rc::new(Expr::Const(Constant {\n\n// tpe: SType::SBoolean,\n\n// v: ConstantVal::Boolean(true),\n\n// })));\n\n// let message = vec![0u8; 100];\n\n\n","file_path":"sigma-tree/src/sigma_protocol/prover.rs","rank":24,"score":132082.14336036408},{"content":" if !step1.real() {\n\n return Err(ProverError::TreeRootIsNotReal);\n\n }\n\n\n\n // Prover Step 3: Change some \"real\" nodes to \"simulated\" to make sure each node\n\n // has the right number of simulated children.\n\n\n\n // skipped, since it leaves UnprovenSchnorr untouched\n\n // let step3 = self.polish_simulated(step1);\n\n\n\n // Prover Steps 4, 5, and 6 together: find challenges for simulated nodes; simulate simulated leaves;\n\n // compute commitments for real leaves\n\n let step6 = self.simulate_and_commit(step1)?;\n\n\n\n // Prover Steps 7: convert the relevant information in the tree (namely, tree structure, node types,\n\n // the statements being proven and commitments at the leaves)\n\n // to a string\n\n let mut s = fiat_shamir_tree_to_bytes(&step6);\n\n\n\n // Prover Step 8: compute the challenge for the root of the tree as the Fiat-Shamir hash of s\n","file_path":"sigma-tree/src/sigma_protocol/prover.rs","rank":25,"score":132080.5613411577},{"content":" &us.proposition,\n\n &challenge,\n\n );\n\n Ok(ProofTree::UncheckedTree(UncheckedTree::UncheckedSigmaTree(\n\n UncheckedSigmaTree::UncheckedLeaf(UncheckedLeaf::UncheckedSchnorr(\n\n UncheckedSchnorr {\n\n proposition: us.proposition,\n\n commitment_opt: Some(fm),\n\n challenge,\n\n second_message: sm,\n\n },\n\n )),\n\n )))\n\n } else {\n\n Err(ProverError::SimulatedLeafWithoutChallenge)\n\n }\n\n } else {\n\n // Step 6 (real leaf -- compute the commitment a)\n\n let (r, commitment) =\n\n dlog_protocol::interactive_prover::first_message(&us.proposition);\n","file_path":"sigma-tree/src/sigma_protocol/prover.rs","rank":26,"score":132080.44406417472},{"content":" }\n\n });\n\n proof.map(|v| ProverResult {\n\n proof: serialize_sig(v),\n\n extension: ContextExtension::empty(),\n\n })\n\n }\n\n\n\n fn convert_to_unproven(&self, sigma_tree: SigmaBoolean) -> UnprovenTree {\n\n match sigma_tree {\n\n SigmaBoolean::TrivialProp(_) => todo!(), // TODO: why it's even here\n\n SigmaBoolean::ProofOfKnowledge(pok) => match pok {\n\n SigmaProofOfKnowledgeTree::ProveDHTuple(_) => todo!(),\n\n SigmaProofOfKnowledgeTree::ProveDlog(prove_dlog) => {\n\n UnprovenTree::UnprovenSchnorr(UnprovenSchnorr {\n\n proposition: prove_dlog,\n\n commitment_opt: None,\n\n randomness_opt: None,\n\n challenge_opt: None,\n\n simulated: false,\n","file_path":"sigma-tree/src/sigma_protocol/prover.rs","rank":27,"score":132080.42293479643},{"content":"// let prover = TestProver { secrets: vec![] };\n\n// let res = prover.prove(&bool_true_tree, &Env::empty(), message.as_slice());\n\n// assert!(res.is_ok());\n\n// assert!(res.unwrap().proof.is_empty());\n\n// }\n\n\n\n// #[test]\n\n// fn test_prove_false_prop() {\n\n// let bool_false_tree = ErgoTree::from(Rc::new(Expr::Const(Constant {\n\n// tpe: SType::SBoolean,\n\n// v: ConstantVal::Boolean(false),\n\n// })));\n\n// let message = vec![0u8; 100];\n\n\n\n// let prover = TestProver { secrets: vec![] };\n\n// let res = prover.prove(&bool_false_tree, &Env::empty(), message.as_slice());\n\n// assert!(res.is_err());\n\n// assert_eq!(res.err().unwrap(), ProverError::ReducedToFalse);\n\n// }\n\n\n","file_path":"sigma-tree/src/sigma_protocol/prover.rs","rank":28,"score":132077.7923285461},{"content":" UncheckedSigmaTree::UncheckedLeaf(UncheckedLeaf::UncheckedSchnorr(\n\n UncheckedSchnorr {\n\n proposition: us.proposition,\n\n commitment_opt: None,\n\n challenge,\n\n second_message: z,\n\n },\n\n )),\n\n )))\n\n } else {\n\n Err(ProverError::SecretNotFound)\n\n }\n\n } else {\n\n Err(ProverError::RealUnprovenTreeWithoutChallenge)\n\n }\n\n }\n\n _ => todo!(),\n\n },\n\n }\n\n }\n","file_path":"sigma-tree/src/sigma_protocol/prover.rs","rank":29,"score":132077.4879540827},{"content":" In a bottom-up traversal of the tree, do the following for each node:\n\n */\n\n fn mark_real(&self, unproven_tree: UnprovenTree) -> UnprovenTree {\n\n match unproven_tree {\n\n UnprovenTree::UnprovenSchnorr(us) => {\n\n let secret_known = self.secrets().iter().any(|s| match s {\n\n PrivateInput::DlogProverInput(dl) => dl.public_image() == us.proposition,\n\n _ => false,\n\n });\n\n UnprovenTree::UnprovenSchnorr(UnprovenSchnorr {\n\n simulated: !secret_known,\n\n ..us\n\n })\n\n }\n\n }\n\n }\n\n\n\n /**\n\n Prover Step 3: This step will change some \"real\" nodes to \"simulated\" to make sure each node has\n\n the right number of simulated children.\n","file_path":"sigma-tree/src/sigma_protocol/prover.rs","rank":30,"score":132075.8234238417},{"content":" })\n\n }\n\n },\n\n SigmaBoolean::CAND(_) => todo!(),\n\n }\n\n }\n\n\n\n /// The comments in this section are taken from the algorithm for the\n\n /// Sigma-protocol prover as described in the white paper\n\n /// https://ergoplatform.org/docs/ErgoScript.pdf (Appendix A)\n\n fn prove_to_unchecked(\n\n &self,\n\n unproven_tree: UnprovenTree,\n\n message: &[u8],\n\n ) -> Result {\n\n // Prover Step 1: Mark as real everything the prover can prove\n\n let step1 = self.mark_real(unproven_tree);\n\n\n\n // Prover Step 2: If the root of the tree is marked \"simulated\" then the prover does not have enough witnesses\n\n // to perform the proof. Abort.\n","file_path":"sigma-tree/src/sigma_protocol/prover.rs","rank":31,"score":132075.221121568},{"content":"// #[test]\n\n// fn test_prove_pk_prop() {\n\n// let secret = DlogProverInput::random();\n\n// let pk = secret.public_image();\n\n// let tree = ErgoTree::from(Rc::new(Expr::Const(Constant {\n\n// tpe: SType::SSigmaProp,\n\n// v: ConstantVal::SigmaProp(Box::new(SigmaProp(SigmaBoolean::ProofOfKnowledge(\n\n// SigmaProofOfKnowledgeTree::ProveDlog(pk),\n\n// )))),\n\n// })));\n\n// let message = vec![0u8; 100];\n\n\n\n// let prover = TestProver {\n\n// secrets: vec![PrivateInput::DlogProverInput(secret)],\n\n// };\n\n// let res = prover.prove(&tree, &Env::empty(), message.as_slice());\n\n// // assert!(res.is_ok());\n\n// assert!(!res.unwrap().proof.is_empty());\n\n// }\n\n// }\n","file_path":"sigma-tree/src/sigma_protocol/prover.rs","rank":32,"score":132074.9440513409},{"content":" Ok(ProofTree::UnprovenTree(UnprovenTree::UnprovenSchnorr(\n\n UnprovenSchnorr {\n\n commitment_opt: Some(commitment),\n\n randomness_opt: Some(r),\n\n ..us\n\n },\n\n )))\n\n }\n\n }\n\n }\n\n }\n\n\n\n /**\n\n Prover Step 9: Perform a top-down traversal of only the portion of the tree marked \"real\" in order to compute\n\n the challenge e for every node marked \"real\" below the root and, additionally, the response z for every leaf\n\n marked \"real\"\n\n */\n\n fn proving(&self, tree: ProofTree) -> Result {\n\n // If the node is a leaf marked \"real\", compute its response according to the second prover step\n\n // of the Sigma-protocol given the commitment, challenge, and witness\n","file_path":"sigma-tree/src/sigma_protocol/prover.rs","rank":33,"score":132071.53000850373},{"content":"/// Box deserialization with token ids optionally parsed in transaction\n\npub fn parse_box_with_indexed_digests(\n\n digests_in_tx: Option<&IndexSet>,\n\n r: &mut R,\n\n) -> Result {\n\n // reference implementation -https://github.com/ScorexFoundation/sigmastate-interpreter/blob/9b20cb110effd1987ff76699d637174a4b2fb441/sigmastate/src/main/scala/org/ergoplatform/ErgoBoxCandidate.scala#L144-L144\n\n\n\n let value = BoxValue::sigma_parse(r)?;\n\n let ergo_tree = ErgoTree::sigma_parse(r)?;\n\n let creation_height = r.get_u32()?;\n\n let tokens_count = r.get_u8()?;\n\n let mut tokens = Vec::with_capacity(tokens_count as usize);\n\n for _ in 0..tokens_count {\n\n let token_id = match digests_in_tx {\n\n None => TokenId::sigma_parse(r)?,\n\n Some(digests) => {\n\n let digest_index = r.get_u32()?;\n\n match digests.get_index(digest_index as usize) {\n\n Some(i) => Ok((*i).clone()),\n\n None => Err(SerializationError::Misc(\n\n \"failed to find token id in tx digests\".to_string(),\n","file_path":"sigma-tree/src/serialization/ergo_box.rs","rank":34,"score":130755.87430331073},{"content":"use num_bigint::{BigInt, Sign};\n\nuse sigma_ser::{\n\n serializer::{SerializationError, SigmaSerializable},\n\n vlq_encode,\n\n};\n\nuse std::{convert::TryInto, io};\n\n\n\n#[derive(PartialEq, Debug, Clone)]\n\npub struct EcPoint(ProjectivePoint);\n\n\n\nimpl EcPoint {\n\n pub const GROUP_SIZE: usize = 33;\n\n}\n\n\n\nimpl Eq for EcPoint {}\n\n\n\n/// The generator g of the group is an element of the group such that, when written multiplicatively, every element\n\n/// of the group is a power of g.\n","file_path":"sigma-tree/src/sigma_protocol/dlog_group.rs","rank":35,"score":128997.84124939927},{"content":"impl SigmaSerializable for EcPoint {\n\n fn sigma_serialize(&self, w: &mut W) -> Result<(), io::Error> {\n\n let caff = self.0.to_affine();\n\n if bool::from(caff.is_some()) {\n\n let pubkey = caff.unwrap().to_compressed_pubkey();\n\n w.write_all(pubkey.as_bytes())?;\n\n } else {\n\n // infinity point\n\n let zeroes = [0u8; EcPoint::GROUP_SIZE];\n\n w.write_all(&zeroes)?;\n\n }\n\n Ok(())\n\n }\n\n\n\n fn sigma_parse(r: &mut R) -> Result {\n\n let mut buf = [0; EcPoint::GROUP_SIZE];\n\n r.read_exact(&mut buf[..])?;\n\n if buf[0] != 0 {\n\n let pubkey = PublicKey::from_bytes(&buf[..]).ok_or_else(|| {\n\n SerializationError::Misc(\"failed to parse PK from bytes\".to_string())\n","file_path":"sigma-tree/src/sigma_protocol/dlog_group.rs","rank":36,"score":128991.06248959851},{"content":"//! This is the general interface for the discrete logarithm prime-order group.\n\n//!\n\n//! The discrete logarithm problem is as follows: given a generator g of a finite\n\n//! group G and a random element h in G, find the (unique) integer x such that\n\n//! `g^x = h`.\n\n//!\n\n//! In cryptography, we are interested in groups for which the discrete logarithm problem\n\n//! (Dlog for short) is assumed to be hard. The most known groups of that kind are some Elliptic curve groups.\n\n//!\n\n//! Another issue pertaining elliptic curves is the need to find a suitable mapping that will convert an arbitrary\n\n//! message (that is some binary string) to an element of the group and vice-versa.\n\n//!\n\n//! Only a subset of the messages can be effectively mapped to a group element in such a way that there is a one-to-one\n\n//! injection that converts the string to a group element and vice-versa.\n\n//!\n\n//! On the other hand, any group element can be mapped to some string.\n\n\n\nuse super::DlogProverInput;\n\nuse k256::arithmetic::{ProjectivePoint, Scalar};\n\nuse k256::{arithmetic::AffinePoint, PublicKey};\n","file_path":"sigma-tree/src/sigma_protocol/dlog_group.rs","rank":37,"score":128984.70460948438},{"content":" use sigma_ser::test_helpers::*;\n\n\n\n impl Arbitrary for EcPoint {\n\n type Parameters = ();\n\n type Strategy = BoxedStrategy;\n\n\n\n fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy {\n\n prop_oneof![Just(generator()), Just(identity()), Just(random_element()),].boxed()\n\n }\n\n }\n\n\n\n proptest! {\n\n\n\n #[test]\n\n fn ser_roundtrip(v in any::()) {\n\n prop_assert_eq![sigma_serialize_roundtrip(&v), v];\n\n }\n\n }\n\n}\n","file_path":"sigma-tree/src/sigma_protocol/dlog_group.rs","rank":38,"score":128982.96969987261},{"content":" })?;\n\n let cp = AffinePoint::from_pubkey(&pubkey);\n\n if bool::from(cp.is_none()) {\n\n Err(SerializationError::Misc(\n\n \"failed to get affine point from PK\".to_string(),\n\n ))\n\n } else {\n\n Ok(EcPoint(ProjectivePoint::from(cp.unwrap())))\n\n }\n\n } else {\n\n // infinity point\n\n Ok(EcPoint(ProjectivePoint::identity()))\n\n }\n\n }\n\n}\n\n\n\n#[cfg(test)]\n\nmod tests {\n\n use super::*;\n\n use proptest::prelude::*;\n","file_path":"sigma-tree/src/sigma_protocol/dlog_group.rs","rank":39,"score":128973.18299612621},{"content":"#[derive(PartialEq, Eq, Debug, Clone)]\n\nstruct ParsedTree {\n\n constants: Vec,\n\n root: Result, ErgoTreeRootParsingError>,\n\n}\n\n\n\n/** The root of ErgoScript IR. Serialized instances of this class are self sufficient and can be passed around.\n\n */\n\n#[derive(PartialEq, Eq, Debug, Clone)]\n\npub struct ErgoTree {\n\n header: ErgoTreeHeader,\n\n tree: Result,\n\n}\n\n\n","file_path":"sigma-tree/src/ergo_tree.rs","rank":40,"score":124535.41137541014},{"content":"/// Consensus-critical serialization for Ergo\n\npub trait SigmaSerializable: Sized {\n\n /// Write `self` to the given `writer`.\n\n /// This function has a `sigma_` prefix to alert the reader that the\n\n /// serialization in use is consensus-critical serialization \n\n /// Notice that the error type is [`std::io::Error`]; this indicates that\n\n /// serialization MUST be infallible up to errors in the underlying writer.\n\n /// In other words, any type implementing `SigmaSerializable`\n\n /// must make illegal states unrepresentable.\n\n fn sigma_serialize(&self, w: &mut W) -> Result<(), io::Error>;\n\n\n\n /// Try to read `self` from the given `reader`.\n\n /// `sigma-` prefix to alert the reader that the serialization in use\n\n /// is consensus-critical\n\n fn sigma_parse(r: &mut R) -> Result;\n\n\n\n /// Serialize any SigmaSerializable value into bytes\n\n fn sigma_serialise_bytes(&self) -> Vec {\n\n let mut data = Vec::new();\n\n self.sigma_serialize(&mut data)\n\n // since serialization may fail only for underlying IO errors it's ok to force unwrap\n","file_path":"sigma-ser/src/serializer.rs","rank":41,"score":115946.81811420254},{"content":"/// Encode a 32-bit value with ZigZag. ZigZag encodes signed integers\n\n/// into values that can be efficiently encoded with VLQ. (Otherwise,\n\n/// negative values must be sign-extended to 64 bits to be varint encoded,\n\n/// thus always taking 10 bytes on the wire.)\n\n/// see https://developers.google.com/protocol-buffers/docs/encoding#types\n\npub fn encode_i32(v: i32) -> u32 {\n\n // Note: the right-shift must be arithmetic\n\n // source: http://github.com/google/protobuf/blob/a7252bf42df8f0841cf3a0c85fdbf1a5172adecb/java/core/src/main/java/com/google/protobuf/CodedOutputStream.java#L934\n\n ((v << 1) ^ (v >> 31)) as u32\n\n}\n\n\n","file_path":"sigma-ser/src/zig_zag_encode.rs","rank":42,"score":113382.27196220358},{"content":"/// Encode a 64-bit value with ZigZag. ZigZag encodes signed integers\n\n/// into values that can be efficiently encoded with varint. (Otherwise,\n\n/// negative values must be sign-extended to 64 bits to be varint encoded,\n\n/// thus always taking 10 bytes on the wire.)\n\n/// see https://developers.google.com/protocol-buffers/docs/encoding#types\n\npub fn encode_i64(v: i64) -> u64 {\n\n // source: http://github.com/google/protobuf/blob/a7252bf42df8f0841cf3a0c85fdbf1a5172adecb/java/core/src/main/java/com/google/protobuf/CodedOutputStream.java#L949\n\n ((v << 1) ^ (v >> 63)) as u64\n\n}\n\n\n","file_path":"sigma-ser/src/zig_zag_encode.rs","rank":43,"score":113382.27196220358},{"content":"/// Decode a signed value previously ZigZag-encoded with [`encode_i32`]\n\n/// see https://developers.google.com/protocol-buffers/docs/encoding#types\n\npub fn decode_u32(v: u32) -> i32 {\n\n // source: http://github.com/google/protobuf/blob/a7252bf42df8f0841cf3a0c85fdbf1a5172adecb/java/core/src/main/java/com/google/protobuf/CodedInputStream.java#L553\n\n ((v >> 1) ^ (-((v & 1) as i32)) as u32) as i32\n\n}\n\n\n","file_path":"sigma-ser/src/zig_zag_encode.rs","rank":44,"score":113375.03674928242},{"content":"/// Decode a signed value previously ZigZag-encoded with [`encode_i64`]\n\n/// see https://developers.google.com/protocol-buffers/docs/encoding#types\n\npub fn decode_u64(v: u64) -> i64 {\n\n // source: http://github.com/google/protobuf/blob/a7252bf42df8f0841cf3a0c85fdbf1a5172adecb/java/core/src/main/java/com/google/protobuf/CodedInputStream.java#L566\n\n ((v >> 1) ^ (-((v & 1) as i64)) as u64) as i64\n\n}\n\n#[cfg(test)]\n\nmod tests {\n\n use super::*;\n\n\n\n #[allow(overflowing_literals)]\n\n #[test]\n\n fn test_expected_values() {\n\n // source: http://github.com/google/protobuf/blob/a7252bf42df8f0841cf3a0c85fdbf1a5172adecb/java/core/src/test/java/com/google/protobuf/CodedOutputStreamTest.java#L281\n\n assert_eq!(0, encode_i32(0));\n\n assert_eq!(1, encode_i32(-1));\n\n assert_eq!(2, encode_i32(1));\n\n assert_eq!(3, encode_i32(-2));\n\n assert_eq!(0x7FFF_FFFE, encode_i32(0x3FFF_FFFF));\n\n assert_eq!(0x7FFF_FFFF, encode_i32(0xC000_0000));\n\n assert_eq!(0xFFFF_FFFE, encode_i32(0x7FFF_FFFF));\n\n assert_eq!(0xFFFF_FFFF, encode_i32(0x8000_0000));\n","file_path":"sigma-ser/src/zig_zag_encode.rs","rank":45,"score":113375.03674928242},{"content":"pub trait Evaluator {\n\n fn reduce_to_crypto(&self, expr: &Expr, env: &Env) -> Result {\n\n let mut ca = CostAccumulator::new(0, None);\n\n eval(expr, env, &mut ca).and_then(|v| match v {\n\n Value::Boolean(b) => Ok(ReductionResult {\n\n sigma_prop: SigmaBoolean::TrivialProp(b),\n\n cost: 0,\n\n }),\n\n Value::SigmaProp(sb) => Ok(ReductionResult {\n\n sigma_prop: *sb,\n\n cost: 0,\n\n }),\n\n _ => Err(EvalError::InvalidResultType),\n\n })\n\n }\n\n}\n\n\n","file_path":"sigma-tree/src/eval.rs","rank":46,"score":110591.21666816529},{"content":"/// serialization roundtrip\n\npub fn sigma_serialize_roundtrip(v: &T) -> T {\n\n let mut data = Vec::new();\n\n v.sigma_serialize(&mut data).expect(\"serialization failed\");\n\n let cursor = Cursor::new(&mut data[..]);\n\n let mut reader = PeekableReader::new(cursor);\n\n T::sigma_parse(&mut reader).expect(\"parse failed\")\n\n}\n","file_path":"sigma-ser/src/test_helpers.rs","rank":47,"score":107673.6881738675},{"content":"/// Conversion to SType\n\npub trait LiftIntoSType {\n\n /// get SType\n\n fn stype() -> SType;\n\n}\n\n\n\nimpl LiftIntoSType for Vec {\n\n fn stype() -> SType {\n\n SType::SColl(Box::new(T::stype()))\n\n }\n\n}\n\n\n\nimpl LiftIntoSType for bool {\n\n fn stype() -> SType {\n\n SType::SBoolean\n\n }\n\n}\n\n\n\nimpl LiftIntoSType for i8 {\n\n fn stype() -> SType {\n\n SType::SByte\n","file_path":"sigma-tree/src/types.rs","rank":48,"score":105828.2680589123},{"content":"/// Marker trait to select types for which CollElems::NonPrimitive is used to store elements as Vec\n\npub trait StoredNonPrimitive {}\n\n\n\nimpl StoredNonPrimitive for bool {}\n\nimpl StoredNonPrimitive for i16 {}\n\nimpl StoredNonPrimitive for i32 {}\n\nimpl StoredNonPrimitive for i64 {}\n\n\n\nimpl> Into for Vec {\n\n fn into(self) -> ConstantVal {\n\n ConstantVal::Coll(ConstantColl::NonPrimitive {\n\n elem_tpe: T::stype(),\n\n v: self.into_iter().map(|i| i.into()).collect(),\n\n })\n\n }\n\n}\n\n\n\nimpl> Into for Vec {\n\n fn into(self) -> Constant {\n\n Constant {\n\n tpe: Self::stype(),\n","file_path":"sigma-tree/src/ast/constant.rs","rank":49,"score":103640.71752145007},{"content":"use super::dlog_group::EcPoint;\n\nuse crate::big_integer::BigInteger;\n\n\n\npub struct FirstDlogProverMessage(EcPoint);\n\npub struct SecondDlogProverMessage(BigInteger);\n\n\n\npub mod interactive_prover {\n\n use super::{FirstDlogProverMessage, SecondDlogProverMessage};\n\n use crate::{\n\n big_integer::BigInteger,\n\n sigma_protocol::{dlog_group, Challenge, DlogProverInput, ProveDlog},\n\n };\n\n\n\n pub fn simulate(\n\n public_input: &ProveDlog,\n\n challenge: &Challenge,\n\n ) -> (FirstDlogProverMessage, SecondDlogProverMessage) {\n\n todo!()\n\n }\n\n\n","file_path":"sigma-tree/src/sigma_protocol/dlog_protocol.rs","rank":50,"score":103559.58389473011},{"content":" pub fn first_message(proposition: &ProveDlog) -> (BigInteger, FirstDlogProverMessage) {\n\n let scalar = dlog_group::random_scalar_in_group_range();\n\n let g = dlog_group::generator();\n\n let a = dlog_group::exponentiate(&g, &scalar);\n\n (scalar.into(), FirstDlogProverMessage(a))\n\n }\n\n\n\n pub fn second_message(\n\n private_input: &DlogProverInput,\n\n rnd: BigInteger,\n\n challenge: &Challenge,\n\n ) -> SecondDlogProverMessage {\n\n todo!()\n\n }\n\n}\n","file_path":"sigma-tree/src/sigma_protocol/dlog_protocol.rs","rank":51,"score":103556.93764173287},{"content":"#[allow(dead_code)]\n\npub fn set_panic_hook() {\n\n // When the `console_error_panic_hook` feature is enabled, we can call the\n\n // `set_panic_hook` function at least once during initialization, and then\n\n // we will get better error messages if our code ever panics.\n\n //\n\n // For more details see\n\n // https://github.com/rustwasm/console_error_panic_hook#readme\n\n #[cfg(feature = \"console_error_panic_hook\")]\n\n console_error_panic_hook::set_once();\n\n}\n","file_path":"bindings/ergo-wallet-lib-wasm/src/utils.rs","rank":52,"score":101352.21596770632},{"content":"use super::op_code::OpCode;\n\nuse crate::sigma_protocol::{\n\n dlog_group::EcPoint, ProveDlog, SigmaBoolean, SigmaProofOfKnowledgeTree,\n\n};\n\nuse sigma_ser::{\n\n serializer::{SerializationError, SigmaSerializable},\n\n vlq_encode,\n\n};\n\nuse std::io;\n\n\n\nimpl SigmaSerializable for SigmaBoolean {\n\n fn sigma_serialize(&self, w: &mut W) -> Result<(), io::Error> {\n\n self.op_code().sigma_serialize(w)?;\n\n match self {\n\n SigmaBoolean::ProofOfKnowledge(proof) => match proof {\n\n SigmaProofOfKnowledgeTree::ProveDHTuple { .. } => todo!(),\n\n SigmaProofOfKnowledgeTree::ProveDlog(v) => v.sigma_serialize(w),\n\n },\n\n SigmaBoolean::CAND(_) => todo!(),\n\n SigmaBoolean::TrivialProp(_) => Ok(()), // besides opCode no additional bytes\n","file_path":"sigma-tree/src/serialization/sigmaboolean.rs","rank":65,"score":93760.16782276653},{"content":" }\n\n }\n\n\n\n fn sigma_parse(r: &mut R) -> Result {\n\n let op_code = OpCode::sigma_parse(r)?;\n\n match op_code {\n\n OpCode::PROVE_DLOG => Ok(SigmaBoolean::ProofOfKnowledge(\n\n SigmaProofOfKnowledgeTree::ProveDlog(ProveDlog::sigma_parse(r)?),\n\n )),\n\n _ => todo!(),\n\n }\n\n }\n\n}\n\n\n\nimpl SigmaSerializable for ProveDlog {\n\n fn sigma_serialize(&self, w: &mut W) -> Result<(), io::Error> {\n\n self.h.sigma_serialize(w)\n\n }\n\n\n\n fn sigma_parse(r: &mut R) -> Result {\n\n let p = EcPoint::sigma_parse(r)?;\n\n Ok(ProveDlog::new(p))\n\n }\n\n}\n","file_path":"sigma-tree/src/serialization/sigmaboolean.rs","rank":66,"score":93751.81868783914},{"content":"use crate::{chain::ErgoBox, sigma_protocol::SigmaBoolean};\n\nuse std::ops::Add;\n\n\n\n#[allow(dead_code)]\n\npub enum Value {\n\n Boolean(bool),\n\n Byte(i8),\n\n Short(i16),\n\n Int(i32),\n\n Long(i64),\n\n BigInt,\n\n GroupElement,\n\n SigmaProp(Box),\n\n Box(Box),\n\n AvlTree,\n\n Coll(Vec),\n\n Tup(Vec),\n\n}\n\n\n\nimpl Value {\n","file_path":"sigma-tree/src/eval/value.rs","rank":67,"score":93679.11921324018},{"content":" #[inline]\n\n pub fn byte(value: i8) -> Self {\n\n Value::Byte(value)\n\n }\n\n}\n\n\n\nimpl Add for Value {\n\n type Output = Self;\n\n fn add(self, other: Self) -> Self {\n\n match (self, other) {\n\n (Value::Byte(s), Value::Byte(o)) => Self::byte(s + o),\n\n _ => todo!(),\n\n }\n\n }\n\n}\n","file_path":"sigma-tree/src/eval/value.rs","rank":68,"score":93670.11107088254},{"content":"use sigma_ser::{\n\n serializer::{SerializationError, SigmaSerializable},\n\n vlq_encode,\n\n};\n\nuse std::io;\n\nuse vlq_encode::WriteSigmaVlqExt;\n\n\n\n#[derive(PartialEq, Eq, Hash, Copy, Clone)]\n\npub struct OpCode(u8);\n\n\n\nimpl OpCode {\n\n pub const LAST_DATA_TYPE: OpCode = OpCode(111);\n\n pub const LAST_CONSTANT_CODE: OpCode = OpCode(Self::LAST_DATA_TYPE.value() + 1);\n\n\n\n pub const FOLD: OpCode = Self::new_op_code(64);\n\n pub const PROVE_DLOG: OpCode = Self::new_op_code(93);\n\n\n\n const fn new_op_code(shift: u8) -> OpCode {\n\n OpCode(Self::LAST_CONSTANT_CODE.value() + shift)\n\n }\n","file_path":"sigma-tree/src/serialization/op_code.rs","rank":69,"score":91145.22622905049},{"content":"\n\n pub fn parse(b: u8) -> OpCode {\n\n OpCode(b)\n\n }\n\n\n\n pub const fn value(self) -> u8 {\n\n self.0\n\n }\n\n}\n\n\n\nimpl SigmaSerializable for OpCode {\n\n fn sigma_serialize(&self, w: &mut W) -> Result<(), io::Error> {\n\n w.put_u8(self.0)?;\n\n Ok(())\n\n }\n\n fn sigma_parse(r: &mut R) -> Result {\n\n let code = r.get_u8()?;\n\n Ok(OpCode::parse(code))\n\n }\n\n}\n","file_path":"sigma-tree/src/serialization/op_code.rs","rank":70,"score":91144.24305277137},{"content":"//! Transitioning type for Base16 encoded bytes in JSON serialization\n\n\n\n#[cfg(feature = \"with-serde\")]\n\nuse serde::{Deserialize, Serialize};\n\nuse std::convert::TryFrom;\n\n\n\n/// Transitioning type for Base16 encoded bytes\n\n#[cfg_attr(feature = \"with-serde\", derive(Serialize, Deserialize))]\n\n#[cfg_attr(feature = \"with-serde\", serde(into = \"String\"))]\n\n#[derive(PartialEq, Eq, Debug, Clone)]\n\npub struct Base16EncodedBytes(String);\n\n\n\nimpl Base16EncodedBytes {\n\n /// Create from byte array ref (&[u8])\n\n pub fn new>(input: &T) -> Base16EncodedBytes {\n\n Base16EncodedBytes(base16::encode_lower(input))\n\n }\n\n}\n\n\n\nimpl Into for Base16EncodedBytes {\n","file_path":"sigma-tree/src/chain/base16_bytes.rs","rank":71,"score":91105.97352877635},{"content":" fn into(self) -> String {\n\n self.0\n\n }\n\n}\n\n\n\n/// Transitioning type for Base16 decoded bytes\n\n#[cfg_attr(feature = \"with-serde\", derive(Serialize, Deserialize))]\n\n#[cfg_attr(feature = \"with-serde\", serde(try_from = \"String\"))]\n\n#[derive(PartialEq, Eq, Debug, Clone)]\n\npub struct Base16DecodedBytes(pub Vec);\n\n\n\nimpl TryFrom for Base16DecodedBytes {\n\n type Error = base16::DecodeError;\n\n fn try_from(str: String) -> Result {\n\n Ok(Base16DecodedBytes(base16::decode(&str)?))\n\n }\n\n}\n","file_path":"sigma-tree/src/chain/base16_bytes.rs","rank":72,"score":91104.22240508255},{"content":"//! ProverResult\n\nuse sigma_ser::serializer::SerializationError;\n\nuse sigma_ser::serializer::SigmaSerializable;\n\nuse sigma_ser::vlq_encode;\n\nuse std::io;\n\n\n\nuse super::context_extension::ContextExtension;\n\n#[cfg(feature = \"with-serde\")]\n\nuse serde::{Deserialize, Serialize};\n\n\n\n/// Proof of correctness of tx spending\n\n#[derive(Debug, PartialEq, Eq, Clone)]\n\n#[cfg_attr(feature = \"with-serde\", derive(Serialize, Deserialize))]\n\npub struct ProverResult {\n\n /// proof that satisfies final sigma proposition\n\n #[cfg_attr(feature = \"with-serde\", serde(rename = \"proofBytes\"))]\n\n pub proof: Vec,\n\n /// user-defined variables to be put into context\n\n #[cfg_attr(feature = \"with-serde\", serde(rename = \"extension\"))]\n\n pub extension: ContextExtension,\n","file_path":"sigma-tree/src/chain/prover_result.rs","rank":73,"score":90873.78550028711},{"content":"}\n\n\n\nimpl SigmaSerializable for ProverResult {\n\n fn sigma_serialize(&self, w: &mut W) -> Result<(), io::Error> {\n\n w.put_u16(self.proof.len() as u16)?;\n\n w.write_all(&self.proof)?;\n\n self.extension.sigma_serialize(w)?;\n\n Ok(())\n\n }\n\n fn sigma_parse(r: &mut R) -> Result {\n\n let proof_len = r.get_u16()?;\n\n let mut proof = vec![0; proof_len as usize];\n\n r.read_exact(&mut proof)?;\n\n let extension = ContextExtension::sigma_parse(r)?;\n\n Ok(ProverResult { proof, extension })\n\n }\n\n}\n\n\n\n#[cfg(test)]\n\nmod tests {\n","file_path":"sigma-tree/src/chain/prover_result.rs","rank":74,"score":90872.3009561621},{"content":" use super::*;\n\n use proptest::{collection::vec, prelude::*};\n\n use sigma_ser::test_helpers::*;\n\n\n\n impl Arbitrary for ProverResult {\n\n type Parameters = ();\n\n\n\n fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy {\n\n (vec(any::(), 0..100))\n\n .prop_map(|v| Self {\n\n proof: v,\n\n extension: ContextExtension::empty(),\n\n })\n\n .boxed()\n\n }\n\n\n\n type Strategy = BoxedStrategy;\n\n }\n\n proptest! {\n\n\n\n #[test]\n\n fn ser_roundtrip(v in any::()) {\n\n prop_assert_eq![sigma_serialize_roundtrip(&v), v];\n\n }\n\n }\n\n}\n","file_path":"sigma-tree/src/chain/prover_result.rs","rank":75,"score":90870.22102646278},{"content":"pub fn address_delete(address: AddressPtr) {\n\n if !address.is_null() {\n\n let boxed = unsafe { Box::from_raw(address) };\n\n std::mem::drop(boxed);\n\n }\n\n}\n","file_path":"bindings/ergo-wallet-lib-c-core/src/lib.rs","rank":76,"score":90512.35178426781},{"content":"impl SigmaSerializable for BoxValue {\n\n fn sigma_serialize(&self, w: &mut W) -> Result<(), io::Error> {\n\n w.put_u64(self.0)\n\n }\n\n fn sigma_parse(r: &mut R) -> Result {\n\n let v = r.get_u64()?;\n\n Ok(BoxValue(v))\n\n }\n\n}\n\n\n\n#[cfg(test)]\n\nmod tests {\n\n use super::*;\n\n use proptest::{arbitrary::Arbitrary, prelude::*};\n\n\n\n impl Arbitrary for BoxValue {\n\n type Parameters = ();\n\n type Strategy = BoxedStrategy;\n\n fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy {\n\n (1..i64::MAX).prop_map(|v| BoxValue(v as u64)).boxed()\n\n }\n\n }\n\n}\n","file_path":"sigma-tree/src/chain/ergo_box/box_value.rs","rank":77,"score":86290.55009248243},{"content":"//! Box value newtype\n\n\n\n#[cfg(feature = \"with-serde\")]\n\nuse serde::{Deserialize, Serialize};\n\nuse sigma_ser::serializer::{SerializationError, SigmaSerializable};\n\nuse sigma_ser::vlq_encode;\n\nuse std::{convert::TryFrom, io};\n\n\n\n/// Box value\n\n#[derive(PartialEq, Eq, Hash, Debug, Clone)]\n\n#[cfg_attr(feature = \"with-serde\", derive(Serialize, Deserialize))]\n\npub struct BoxValue(u64);\n\n\n\nimpl BoxValue {\n\n const MIN_RAW: u64 = 1;\n\n const MAX_RAW: u64 = i64::MAX as u64;\n\n\n\n /// Minimal value\n\n pub const MIN: BoxValue = BoxValue(BoxValue::MIN_RAW);\n\n\n","file_path":"sigma-tree/src/chain/ergo_box/box_value.rs","rank":78,"score":86288.76558877125},{"content":" /// Create from u64 with bounds check\n\n pub fn new(v: u64) -> Result {\n\n BoxValue::try_from(v)\n\n }\n\n\n\n /// Check if a value is in bounds\n\n pub fn within_bounds(v: u64) -> bool {\n\n v >= BoxValue::MIN_RAW && v <= BoxValue::MAX_RAW\n\n }\n\n\n\n /// Get u64 value\n\n pub fn value(&self) -> u64 {\n\n self.0\n\n }\n\n}\n\n\n\n/// BoxValue errors\n\n#[derive(PartialEq, Eq, Debug, Clone)]\n\npub enum BoxValueError {\n\n /// Value is out of bounds\n","file_path":"sigma-tree/src/chain/ergo_box/box_value.rs","rank":79,"score":86284.22098746832},{"content":" OutOfBounds,\n\n}\n\n\n\nimpl TryFrom for BoxValue {\n\n type Error = BoxValueError;\n\n fn try_from(v: u64) -> Result {\n\n if BoxValue::within_bounds(v) {\n\n Ok(BoxValue(v))\n\n } else {\n\n Err(BoxValueError::OutOfBounds)\n\n }\n\n }\n\n}\n\n\n\nimpl Into for BoxValue {\n\n fn into(self) -> u64 {\n\n self.0\n\n }\n\n}\n\n\n","file_path":"sigma-tree/src/chain/ergo_box/box_value.rs","rank":80,"score":86273.21533300132},{"content":"class OutputBoxes {\n\n internal var pointer: OutputBoxesPtr\n\n\n\n init(box: ErgoBoxCandidate) throws {\n\n var ptr: OutputBoxesPtr?\n\n let error = ergo_wallet_output_boxes_new(box.pointer, &ptr)\n\n try checkError(error)\n\n self.pointer = ptr!\n\n }\n\n\n\n deinit {\n\n ergo_wallet_output_boxes_delete(self.pointer)\n\n }\n\n}\n\n\n","file_path":"bindings/ergo-wallet-lib-ios/Sources/ErgoWallet/ErgoWallet.swift","rank":81,"score":84905.9088467529},{"content":"// Tries to get meaningful description from panic-error.\n\npub fn any_to_string(any: &Box) -> String {\n\n if let Some(s) = any.downcast_ref::<&str>() {\n\n s.to_string()\n\n } else if let Some(s) = any.downcast_ref::() {\n\n s.clone()\n\n } else if let Some(error) = any.downcast_ref::>() {\n\n error.to_string()\n\n } else {\n\n \"Unknown error occurred\".to_string()\n\n }\n\n}\n\n\n\n#[cfg(test)]\n\nmod tests {\n\n use super::*;\n\n use std::error::Error;\n\n use std::panic;\n\n\n\n #[test]\n\n fn str_any() {\n","file_path":"bindings/ergo-wallet-lib-android/src/main/rust/exception.rs","rank":82,"score":78793.44584052754},{"content":"/// A wrapper around any struct implementing the `Read` trait, additionally\n\n/// allowing for `peek` operations to be performed. Therefore, the\n\n/// `PeekableReader` struct also implements the `Read` trait.\n\n///\n\n/// The primary invariant of the `PeekableReader` is that after calling the\n\n/// `peek` method, the next `read_byte` call will return the same result as\n\n/// the `peek` does. When the result is a byte (read off the wrapped reader),\n\n/// any read-type method of the `Reader` trait will include the byte as the\n\n/// first one. On the other hand, if the result is an `io::Error`, the error\n\n/// will be returned regardless of which read-type method of the `Reader` is\n\n/// invoked. Consecutive `peek`s before any read-type operation is used\n\n/// always return the same `io::Result`.\n\n///\n\npub trait Peekable: Read {\n\n /// When using peek_u8 you will get a Result, while when you call\n\n /// any of the `Read` functions you will get an io::Result, thereby\n\n /// consuming the io::Error (if any.)\n\n fn peek_u8(&mut self) -> Result;\n\n}\n\n\n\nimpl Peekable for PeekableReader {\n\n /// Returns the `io::Result` which the Reader will return on the next\n\n /// `get_byte` call.\n\n ///\n\n /// If the `io::Result` is indeed an `io::Error`, the error will be returned\n\n /// for any subsequent read operation invoked upon the `Read`er.\n\n fn peek_u8(&mut self) -> Result {\n\n // Return either the currently cached peeked byte or obtain a new one\n\n // from the underlying reader.\n\n match self.peeked_result {\n\n Some(Ok(x)) => Ok(x),\n\n Some(Err(ref e)) => Err(e),\n\n None => {\n","file_path":"sigma-ser/src/peekable_reader.rs","rank":83,"score":75564.83631597302},{"content":"/// Write encoded unsigned values using VLQ and signed values first with ZigZag, then using VLQ\n\n/// for VLQ see [[https://en.wikipedia.org/wiki/Variable-length_quantity]]\n\n/// for ZigZag see https://developers.google.com/protocol-buffers/docs/encoding#types\n\npub trait WriteSigmaVlqExt: io::Write {\n\n /// Write i8 without encoding\n\n fn put_i8(&mut self, v: i8) -> io::Result<()> {\n\n Self::put_u8(self, v as u8)\n\n }\n\n\n\n /// Write u8 without encoding\n\n fn put_u8(&mut self, v: u8) -> io::Result<()> {\n\n self.write_all(&[v])\n\n }\n\n\n\n /// Encode using ZigZag and then VLQ.\n\n fn put_i16(&mut self, v: i16) -> io::Result<()> {\n\n Self::put_u32(self, zig_zag_encode::encode_i32(v as i32))\n\n }\n\n\n\n /// Encode using VLQ.\n\n fn put_u16(&mut self, v: u16) -> io::Result<()> {\n\n Self::put_u64(self, v as u64)\n\n }\n","file_path":"sigma-ser/src/vlq_encode.rs","rank":84,"score":75482.89445492288},{"content":"/// Read and decode values using VLQ (+ ZigZag for signed values) encoded and written with [`WriteSigmaVlqExt`]\n\n/// for VLQ see [[https://en.wikipedia.org/wiki/Variable-length_quantity]]\n\n/// for ZigZag see https://developers.google.com/protocol-buffers/docs/encoding#types\n\npub trait ReadSigmaVlqExt: peekable_reader::Peekable {\n\n /// Read i8 without decoding\n\n fn get_i8(&mut self) -> Result {\n\n Self::get_u8(self).map(|v| v as i8)\n\n }\n\n\n\n /// Read u8 without decoding\n\n fn get_u8(&mut self) -> std::result::Result {\n\n let mut slice = [0u8; 1];\n\n self.read_exact(&mut slice)?;\n\n Ok(slice[0])\n\n }\n\n\n\n /// Read and decode using VLQ and ZigZag value written with [`WriteSigmaVlqExt::put_i16`]\n\n fn get_i16(&mut self) -> Result {\n\n Self::get_u32(self).and_then(|v| {\n\n let vd = zig_zag_encode::decode_u32(v);\n\n i16::try_from(vd).map_err(VlqEncodingError::TryFrom)\n\n })\n\n }\n","file_path":"sigma-ser/src/vlq_encode.rs","rank":85,"score":74328.58198814924},{"content":"#[allow(dead_code)]\n\npub fn unwrap_exc_or_default(env: &JNIEnv, res: ExceptionResult) -> T {\n\n unwrap_exc_or(env, res, T::default())\n\n}\n\n\n","file_path":"bindings/ergo-wallet-lib-android/src/main/rust/exception.rs","rank":86,"score":67504.29583301273},{"content":"// Returns value or \"throws\" exception. `error_val` is returned, because exception will be thrown\n\n// at the Java side. So this function should be used only for the `panic::catch_unwind` result.\n\npub fn unwrap_exc_or(env: &JNIEnv, res: ExceptionResult, error_val: T) -> T {\n\n match res {\n\n Ok(val) => {\n\n match val {\n\n Ok(val) => val,\n\n Err(jni_error) => {\n\n // Do nothing if there is a pending Java-exception that will be thrown\n\n // automatically by the JVM when the native method returns.\n\n if !env.exception_check().unwrap() {\n\n // Throw a Java exception manually in case of an internal error.\n\n throw(env, &jni_error.to_string())\n\n }\n\n error_val\n\n }\n\n }\n\n }\n\n Err(ref e) => {\n\n throw(env, &any_to_string(e));\n\n error_val\n\n }\n\n }\n\n}\n\n\n\n// Same as `unwrap_exc_or` but returns default value.\n","file_path":"bindings/ergo-wallet-lib-android/src/main/rust/exception.rs","rank":87,"score":65457.556864192375},{"content":" pub fn with_segregation(_: Rc) -> ErgoTree {\n\n todo!()\n\n }\n\n}\n\n\n\nimpl From> for ErgoTree {\n\n fn from(expr: Rc) -> Self {\n\n match expr.as_ref() {\n\n Expr::Const(Constant { tpe, .. }) if *tpe == SType::SSigmaProp => {\n\n ErgoTree::without_segregation(expr)\n\n }\n\n _ => ErgoTree::with_segregation(expr),\n\n }\n\n }\n\n}\n\nimpl SigmaSerializable for ErgoTreeHeader {\n\n fn sigma_serialize(&self, w: &mut W) -> Result<(), io::Error> {\n\n w.put_u8(self.0)?;\n\n Ok(())\n\n }\n","file_path":"sigma-tree/src/ergo_tree.rs","rank":88,"score":64578.35108023852},{"content":" fn sigma_parse(r: &mut R) -> Result {\n\n let header = r.get_u8()?;\n\n Ok(ErgoTreeHeader(header))\n\n }\n\n}\n\n\n\nimpl SigmaSerializable for ErgoTree {\n\n fn sigma_serialize(&self, w: &mut W) -> Result<(), io::Error> {\n\n self.header.sigma_serialize(w)?;\n\n match &self.tree {\n\n Ok(ParsedTree { constants, root }) => {\n\n if self.header.is_constant_segregation() {\n\n w.put_usize_as_u32(constants.len())?;\n\n assert!(\n\n constants.is_empty(),\n\n \"separate constants serialization is not yet supported\"\n\n );\n\n }\n\n match root {\n\n Ok(expr) => expr.sigma_serialize(w)?,\n","file_path":"sigma-tree/src/ergo_tree.rs","rank":89,"score":64572.65151070547},{"content":"#[derive(PartialEq, Eq, Debug, Clone)]\n\npub struct ErgoTreeRootParsingError {\n\n /// Ergo tree root expr bytes (faild to deserialize)\n\n pub bytes: Vec,\n\n /// Deserialization error\n\n pub error: SerializationError,\n\n}\n\n\n\n/// ErgoTree parsing (deserialization) error\n\n#[derive(PartialEq, Eq, Debug, Clone)]\n\npub enum ErgoTreeParsingError {\n\n /// Whole ErgoTree parsing (deserialization) error\n\n TreeParsingError(ErgoTreeConstantsParsingError),\n\n /// ErgoTree root expr parsing (deserialization) error\n\n RootParsingError(ErgoTreeRootParsingError),\n\n}\n\n\n\nimpl ErgoTree {\n\n const DEFAULT_HEADER: ErgoTreeHeader = ErgoTreeHeader(0);\n\n\n","file_path":"sigma-tree/src/ergo_tree.rs","rank":90,"score":64570.58744980605},{"content":" Ok(ErgoTree {\n\n header,\n\n tree: Ok(ParsedTree {\n\n constants,\n\n root: Ok(Rc::new(root)),\n\n }),\n\n })\n\n }\n\n\n\n fn sigma_parse_bytes(mut bytes: Vec) -> Result {\n\n let cursor = Cursor::new(&mut bytes[..]);\n\n let mut r = PeekableReader::new(cursor);\n\n let header = ErgoTreeHeader::sigma_parse(&mut r)?;\n\n if header.is_constant_segregation() {\n\n let constants_len = r.get_u32()?;\n\n if constants_len != 0 {\n\n return Ok(ErgoTree {\n\n header,\n\n tree: Err(ErgoTreeConstantsParsingError {\n\n bytes: bytes[1..].to_vec(),\n","file_path":"sigma-tree/src/ergo_tree.rs","rank":91,"score":64569.438522524986},{"content":" error: SerializationError::NotImplementedYet(\n\n \"separate constants serialization is not yet supported\".to_string(),\n\n ),\n\n }),\n\n });\n\n }\n\n }\n\n let constants = Vec::new();\n\n let mut rest_of_the_bytes = Vec::new();\n\n let _ = r.read_to_end(&mut rest_of_the_bytes);\n\n let rest_of_the_bytes_copy = rest_of_the_bytes.clone();\n\n match Expr::sigma_parse_bytes(rest_of_the_bytes) {\n\n Ok(parsed) => Ok(ErgoTree {\n\n header,\n\n tree: Ok(ParsedTree {\n\n constants,\n\n root: Ok(Rc::new(parsed)),\n\n }),\n\n }),\n\n Err(err) => Ok(ErgoTree {\n","file_path":"sigma-tree/src/ergo_tree.rs","rank":92,"score":64568.31162559973},{"content":" Err(ErgoTreeRootParsingError { bytes, .. }) => w.write_all(&bytes[..])?,\n\n }\n\n }\n\n Err(ErgoTreeConstantsParsingError { bytes, .. }) => w.write_all(&bytes[..])?,\n\n }\n\n Ok(())\n\n }\n\n\n\n fn sigma_parse(r: &mut R) -> Result {\n\n let header = ErgoTreeHeader::sigma_parse(r)?;\n\n if header.is_constant_segregation() {\n\n let constants_len = r.get_u32()?;\n\n if constants_len != 0 {\n\n return Err(SerializationError::NotImplementedYet(\n\n \"separate constants serialization is not yet supported\".to_string(),\n\n ));\n\n }\n\n }\n\n let constants = Vec::new();\n\n let root = Expr::sigma_parse(r)?;\n","file_path":"sigma-tree/src/ergo_tree.rs","rank":93,"score":64566.57379992548},{"content":" /// get Expr out of ErgoTree\n\n pub fn proposition(&self) -> Result, ErgoTreeParsingError> {\n\n self.tree\n\n .clone()\n\n .map_err(ErgoTreeParsingError::TreeParsingError)\n\n .and_then(|t| t.root.map_err(ErgoTreeParsingError::RootParsingError))\n\n }\n\n\n\n /// Build ErgoTree using expr as is, without constants segregated\n\n pub fn without_segregation(expr: Rc) -> ErgoTree {\n\n ErgoTree {\n\n header: ErgoTree::DEFAULT_HEADER,\n\n tree: Ok(ParsedTree {\n\n constants: Vec::new(),\n\n root: Ok(expr),\n\n }),\n\n }\n\n }\n\n\n\n /// Build ErgoTree with constants segregated from expr\n","file_path":"sigma-tree/src/ergo_tree.rs","rank":94,"score":64565.3049188236},{"content":" prop_assert_eq![sigma_serialize_roundtrip(&(v)), v];\n\n }\n\n }\n\n\n\n #[test]\n\n fn deserialization_non_parseable_tree_ok() {\n\n // constants length is set\n\n assert!(ErgoTree::sigma_parse_bytes(vec![0, 1]).is_ok());\n\n }\n\n\n\n #[test]\n\n fn deserialization_non_parseable_root_ok() {\n\n // constants length is zero, but Expr is invalid\n\n assert!(ErgoTree::sigma_parse_bytes(vec![0, 0, 1]).is_ok());\n\n }\n\n\n\n #[test]\n\n fn test_constant_segregation_header_flag_support() {\n\n let encoder = chain::AddressEncoder::new(chain::NetworkPrefix::Mainnet);\n\n let address = encoder\n\n .parse_address_from_str(\"9hzP24a2q8KLPVCUk7gdMDXYc7vinmGuxmLp5KU7k9UwptgYBYV\")\n\n .unwrap();\n\n\n\n let contract = chain::Contract::pay_to_address(address).unwrap();\n\n let bytes = &contract.get_ergo_tree().sigma_serialise_bytes();\n\n assert_eq!(&bytes[..2], vec![0u8, 8u8].as_slice());\n\n }\n\n}\n","file_path":"sigma-tree/src/ergo_tree.rs","rank":95,"score":64565.16805310321},{"content":" header,\n\n tree: Ok(ParsedTree {\n\n constants,\n\n root: Err(ErgoTreeRootParsingError {\n\n bytes: rest_of_the_bytes_copy,\n\n error: err,\n\n }),\n\n }),\n\n }),\n\n }\n\n }\n\n}\n\n\n\n#[cfg(test)]\n\nmod tests {\n\n use super::*;\n\n use crate::{ast::ConstantVal, chain, sigma_protocol::SigmaProp, types::SType};\n\n use proptest::prelude::*;\n\n use sigma_ser::test_helpers::*;\n\n\n","file_path":"sigma-tree/src/ergo_tree.rs","rank":96,"score":64564.009160363144},{"content":"//! ErgoTree\n\nuse crate::{\n\n ast::{Constant, Expr},\n\n types::SType,\n\n};\n\nuse io::{Cursor, Read};\n\nuse sigma_ser::serializer::SerializationError;\n\nuse sigma_ser::serializer::SigmaSerializable;\n\nuse sigma_ser::{peekable_reader::PeekableReader, vlq_encode};\n\nuse std::io;\n\nuse std::rc::Rc;\n\nuse vlq_encode::{ReadSigmaVlqExt, WriteSigmaVlqExt};\n\n\n\n#[derive(PartialEq, Eq, Debug, Clone)]\n","file_path":"sigma-tree/src/ergo_tree.rs","rank":97,"score":64562.33551290245},{"content":" impl Arbitrary for ErgoTree {\n\n type Parameters = ();\n\n type Strategy = BoxedStrategy;\n\n\n\n fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy {\n\n (any::())\n\n .prop_map(|p| {\n\n ErgoTree::from(Rc::new(Expr::Const(Constant {\n\n tpe: SType::SSigmaProp,\n\n v: ConstantVal::SigmaProp(Box::new(p)),\n\n })))\n\n })\n\n .boxed()\n\n }\n\n }\n\n\n\n proptest! {\n\n\n\n #[test]\n\n fn ser_roundtrip(v in any::()) {\n","file_path":"sigma-tree/src/ergo_tree.rs","rank":98,"score":64559.99938191821},{"content":"//! AST for ErgoTree\n\nuse crate::{serialization::op_code::OpCode, types::*};\n\nuse core::fmt;\n\nuse Expr::*;\n\n\n\nmod constant;\n\npub mod ops;\n\n\n\npub use constant::*;\n\n\n\n#[derive(PartialEq, Eq, Debug)]\n\n/// newtype for box register id\n\npub struct RegisterId(u8);\n\n\n\n#[derive(PartialEq, Eq, Debug)]\n\n/// Expression in ErgoTree\n\npub enum Expr {\n\n /// Constant value\n\n Const(Constant),\n\n /// Collection of values (same type)\n","file_path":"sigma-tree/src/ast.rs","rank":99,"score":59012.81410275754}],"string":"[\n {\n \"content\": \"/// Creates a random scalar, a big-endian integer in the range [0, n), where n is group order\\n\\npub fn random_scalar_in_group_range() -> Scalar {\\n\\n loop {\\n\\n // Generate a new secret key using the operating system's\\n\\n // cryptographically secure random number generator\\n\\n let sk = k256::SecretKey::generate();\\n\\n let bytes: [u8; 32] = sk\\n\\n .secret_scalar()\\n\\n .as_ref()\\n\\n .as_slice()\\n\\n .try_into()\\n\\n .expect(\\\"expected 32 bytes\\\");\\n\\n // Returns None if the byte array does not contain\\n\\n // a big-endian integer in the range [0, n), where n is group order.\\n\\n let maybe_scalar = Scalar::from_bytes(bytes);\\n\\n if bool::from(maybe_scalar.is_some()) {\\n\\n break maybe_scalar.unwrap();\\n\\n }\\n\\n }\\n\\n}\\n\\n\\n\",\n \"file_path\": \"sigma-tree/src/sigma_protocol/dlog_group.rs\",\n \"rank\": 0,\n \"score\": 304795.5759556212\n },\n {\n \"content\": \"/// Creates a random member of this Dlog group\\n\\npub fn random_element() -> EcPoint {\\n\\n let sk = DlogProverInput::random();\\n\\n let bytes = sk.w.to_bytes();\\n\\n let bi = BigInt::from_bytes_be(Sign::Plus, &bytes[..]);\\n\\n\\n\\n exponentiate(&generator(), &sk.w)\\n\\n}\\n\\n\\n\",\n \"file_path\": \"sigma-tree/src/sigma_protocol/dlog_group.rs\",\n \"rank\": 1,\n \"score\": 290281.25990754174\n },\n {\n \"content\": \"pub fn is_identity(ge: &EcPoint) -> bool {\\n\\n *ge == identity()\\n\\n}\\n\\n\\n\",\n \"file_path\": \"sigma-tree/src/sigma_protocol/dlog_group.rs\",\n \"rank\": 4,\n \"score\": 261162.48115587642\n },\n {\n \"content\": \"/// Blake2b256 hash (256 bit)\\n\\npub fn blake2b256_hash(bytes: &[u8]) -> Digest32 {\\n\\n // unwrap is safe 32 bytes is a valid hash size (<= 512 && 32 % 8 == 0)\\n\\n let mut hasher = VarBlake2b::new(Digest32::SIZE).unwrap();\\n\\n hasher.update(bytes);\\n\\n let hash = hasher.finalize_boxed();\\n\\n // unwrap is safe due to hash size is expected to be Digest32::SIZE\\n\\n Digest32(hash.try_into().unwrap())\\n\\n}\\n\\n\\n\\nimpl From<[u8; Digest32::SIZE]> for Digest32 {\\n\\n fn from(bytes: [u8; Digest32::SIZE]) -> Self {\\n\\n Digest32(Box::new(bytes))\\n\\n }\\n\\n}\\n\\n\\n\\nimpl Into for Digest32 {\\n\\n fn into(self) -> Base16EncodedBytes {\\n\\n Base16EncodedBytes::new(self.0.as_ref())\\n\\n }\\n\\n}\\n\",\n \"file_path\": \"sigma-tree/src/chain/digest32.rs\",\n \"rank\": 6,\n \"score\": 248194.5878895931\n },\n {\n \"content\": \"/// Raises the base GroupElement to the exponent. The result is another GroupElement.\\n\\npub fn exponentiate(base: &EcPoint, exponent: &Scalar) -> EcPoint {\\n\\n if !is_identity(base) {\\n\\n // implement for negative exponent\\n\\n // see reference impl https://github.com/ScorexFoundation/sigmastate-interpreter/blob/ec71a6f988f7412bc36199f46e7ad8db643478c7/sigmastate/src/main/scala/sigmastate/basics/BcDlogGroup.scala#L201\\n\\n // see https://github.com/ergoplatform/sigma-rust/issues/36\\n\\n\\n\\n // we treat EC as a multiplicative group, therefore, exponentiate point is multiply.\\n\\n EcPoint(base.0 * exponent)\\n\\n } else {\\n\\n base.clone()\\n\\n }\\n\\n}\\n\\n\\n\",\n \"file_path\": \"sigma-tree/src/sigma_protocol/dlog_group.rs\",\n \"rank\": 7,\n \"score\": 246609.0916878886\n },\n {\n \"content\": \"/// The generator g of the group is an element of the group such that, when written multiplicatively, every element\\n\\n/// of the group is a power of g.\\n\\npub fn generator() -> EcPoint {\\n\\n EcPoint(ProjectivePoint::generator())\\n\\n}\\n\\n\\n\\n/// the identity(infinity) element of this Dlog group\\n\\npub const fn identity() -> EcPoint {\\n\\n EcPoint(ProjectivePoint::identity())\\n\\n}\\n\\n\\n\",\n \"file_path\": \"sigma-tree/src/sigma_protocol/dlog_group.rs\",\n \"rank\": 8,\n \"score\": 233539.662568651\n },\n {\n \"content\": \"pub trait Prover: Evaluator {\\n\\n fn secrets(&self) -> &[PrivateInput];\\n\\n\\n\\n fn prove(\\n\\n &self,\\n\\n tree: &ErgoTree,\\n\\n env: &Env,\\n\\n message: &[u8],\\n\\n ) -> Result {\\n\\n let expr = tree.proposition()?;\\n\\n let proof = self\\n\\n .reduce_to_crypto(expr.as_ref(), env)\\n\\n .map_err(ProverError::EvalError)\\n\\n .and_then(|v| match v.sigma_prop {\\n\\n SigmaBoolean::TrivialProp(true) => Ok(UncheckedTree::NoProof),\\n\\n SigmaBoolean::TrivialProp(false) => Err(ProverError::ReducedToFalse),\\n\\n sb => {\\n\\n let tree = self.convert_to_unproven(sb);\\n\\n let unchecked_tree = self.prove_to_unchecked(tree, message)?;\\n\\n Ok(UncheckedTree::UncheckedSigmaTree(unchecked_tree))\\n\",\n \"file_path\": \"sigma-tree/src/sigma_protocol/prover.rs\",\n \"rank\": 9,\n \"score\": 201430.14083236712\n },\n {\n \"content\": \"fn get_embeddable_type(code: u8) -> Result {\\n\\n match TypeCode::new(code) {\\n\\n TypeCode::SBOOLEAN => Ok(SType::SBoolean),\\n\\n TypeCode::SBYTE => Ok(SType::SByte),\\n\\n TypeCode::SSHORT => Ok(SType::SShort),\\n\\n TypeCode::SINT => Ok(SType::SInt),\\n\\n TypeCode::SLONG => Ok(SType::SLong),\\n\\n TypeCode::SBIGINT => Ok(SType::SBigInt),\\n\\n TypeCode::SGROUP_ELEMENT => Ok(SType::SGroupElement),\\n\\n TypeCode::SSIGMAPROP => Ok(SType::SSigmaProp),\\n\\n _ => Err(SerializationError::InvalidOpCode),\\n\\n }\\n\\n}\\n\\n\\n\",\n \"file_path\": \"sigma-tree/src/serialization/types.rs\",\n \"rank\": 10,\n \"score\": 199649.98139593913\n },\n {\n \"content\": \"pub trait Verifier: Evaluator {\\n\\n fn verify(\\n\\n &mut self,\\n\\n tree: &ErgoTree,\\n\\n env: &Env,\\n\\n proof: &[u8],\\n\\n message: &[u8],\\n\\n ) -> Result {\\n\\n let expr = tree.proposition()?;\\n\\n let cprop = self.reduce_to_crypto(expr.as_ref(), env)?.sigma_prop;\\n\\n let res: bool = match cprop {\\n\\n SigmaBoolean::TrivialProp(b) => b,\\n\\n sb => todo!(),\\n\\n };\\n\\n Ok(VerificationResult {\\n\\n result: res,\\n\\n cost: 0,\\n\\n })\\n\\n }\\n\\n}\\n\",\n \"file_path\": \"sigma-tree/src/sigma_protocol/verifier.rs\",\n \"rank\": 11,\n \"score\": 182454.27450487658\n },\n {\n \"content\": \"/// Box serialization with token ids optionally saved in transaction\\n\\n/// (in this case only token index is saved)\\n\\npub fn serialize_box_with_indexed_digests(\\n\\n box_value: &BoxValue,\\n\\n ergo_tree_bytes: Vec,\\n\\n tokens: &[TokenAmount],\\n\\n additional_registers: &NonMandatoryRegisters,\\n\\n creation_height: u32,\\n\\n token_ids_in_tx: Option<&IndexSet>,\\n\\n w: &mut W,\\n\\n) -> Result<(), io::Error> {\\n\\n // reference implementation - https://github.com/ScorexFoundation/sigmastate-interpreter/blob/9b20cb110effd1987ff76699d637174a4b2fb441/sigmastate/src/main/scala/org/ergoplatform/ErgoBoxCandidate.scala#L95-L95\\n\\n box_value.sigma_serialize(w)?;\\n\\n w.write_all(&ergo_tree_bytes[..])?;\\n\\n w.put_u32(creation_height)?;\\n\\n w.put_u8(u8::try_from(tokens.len()).unwrap())?;\\n\\n\\n\\n tokens.iter().try_for_each(|t| {\\n\\n match token_ids_in_tx {\\n\\n Some(token_ids) => w.put_u32(\\n\\n u32::try_from(\\n\\n token_ids\\n\",\n \"file_path\": \"sigma-tree/src/serialization/ergo_box.rs\",\n \"rank\": 12,\n \"score\": 173133.05255750826\n },\n {\n \"content\": \"#[derive(PartialEq, Eq, Debug, Clone)]\\n\\nstruct ErgoTreeHeader(u8);\\n\\n\\n\\nimpl ErgoTreeHeader {\\n\\n const CONSTANT_SEGREGATION_FLAG: u8 = 0x10;\\n\\n\\n\\n pub fn is_constant_segregation(&self) -> bool {\\n\\n self.0 & ErgoTreeHeader::CONSTANT_SEGREGATION_FLAG != 0\\n\\n }\\n\\n}\\n\\n\\n\\n/// Whole ErgoTree parsing (deserialization) error\\n\\n#[derive(PartialEq, Eq, Debug, Clone)]\\n\\npub struct ErgoTreeConstantsParsingError {\\n\\n /// Ergo tree bytes (faild to deserialize)\\n\\n pub bytes: Vec,\\n\\n /// Deserialization error\\n\\n pub error: SerializationError,\\n\\n}\\n\\n\\n\\n/// ErgoTree root expr parsing (deserialization) error\\n\",\n \"file_path\": \"sigma-tree/src/ergo_tree.rs\",\n \"rank\": 13,\n \"score\": 171467.29386373737\n },\n {\n \"content\": \"pub fn serialize_bytes(bytes: T, serializer: S) -> Result\\n\\nwhere\\n\\n S: Serializer,\\n\\n T: AsRef<[u8]>,\\n\\n{\\n\\n serializer.serialize_str(&base16::encode_lower(bytes.as_ref()))\\n\\n}\\n\\n\\n\\npub mod ergo_tree {\\n\\n\\n\\n use super::*;\\n\\n use crate::ErgoTree;\\n\\n use serde::{Deserialize, Deserializer, Serializer};\\n\\n use sigma_ser::serializer::SigmaSerializable;\\n\\n\\n\\n pub fn serialize(ergo_tree: &ErgoTree, serializer: S) -> Result\\n\\n where\\n\\n S: Serializer,\\n\\n {\\n\\n let bytes = ergo_tree.sigma_serialise_bytes();\\n\",\n \"file_path\": \"sigma-tree/src/chain/json.rs\",\n \"rank\": 14,\n \"score\": 145282.7728311161\n },\n {\n \"content\": \"fn is_stype_embeddable(tpe: &SType) -> bool {\\n\\n match tpe {\\n\\n SType::SBoolean => true,\\n\\n SType::SByte => true,\\n\\n SType::SShort => true,\\n\\n SType::SInt => true,\\n\\n SType::SLong => true,\\n\\n SType::SBigInt => true,\\n\\n SType::SGroupElement => true,\\n\\n SType::SSigmaProp => true,\\n\\n _ => false,\\n\\n }\\n\\n}\\n\\n\\n\\nimpl SigmaSerializable for SType {\\n\\n fn sigma_serialize(&self, w: &mut W) -> Result<(), io::Error> {\\n\\n // for reference see http://github.com/ScorexFoundation/sigmastate-interpreter/blob/25251c1313b0131835f92099f02cef8a5d932b5e/sigmastate/src/main/scala/sigmastate/serialization/TypeSerializer.scala#L25-L25\\n\\n match self {\\n\\n SType::SAny => self.type_code().sigma_serialize(w),\\n\\n\\n\",\n \"file_path\": \"sigma-tree/src/serialization/types.rs\",\n \"rank\": 15,\n \"score\": 144069.00610777322\n },\n {\n \"content\": \"#[allow(unconditional_recursion)]\\n\\nfn eval(expr: &Expr, env: &Env, ca: &mut CostAccumulator) -> Result {\\n\\n match expr {\\n\\n Expr::Const(Constant {\\n\\n tpe: SType::SBoolean,\\n\\n v: ConstantVal::Boolean(b),\\n\\n }) => Ok(Value::Boolean(*b)),\\n\\n Expr::Const(Constant {\\n\\n tpe: SType::SSigmaProp,\\n\\n v: ConstantVal::SigmaProp(sp),\\n\\n }) => Ok(Value::SigmaProp(Box::new((*sp.value()).clone()))),\\n\\n Expr::Coll { .. } => todo!(),\\n\\n Expr::Tup { .. } => todo!(),\\n\\n Expr::PredefFunc(_) => todo!(),\\n\\n Expr::CollM(_) => todo!(),\\n\\n Expr::BoxM(_) => todo!(),\\n\\n Expr::CtxM(_) => todo!(),\\n\\n Expr::MethodCall { .. } => todo!(),\\n\\n Expr::BinOp(bin_op, l, r) => {\\n\\n let v_l = eval(l, env, ca)?;\\n\\n let v_r = eval(r, env, ca)?;\\n\",\n \"file_path\": \"sigma-tree/src/eval.rs\",\n \"rank\": 16,\n \"score\": 143356.5365707662\n },\n {\n \"content\": \"//! Verifier\\n\\n\\n\\n#![allow(dead_code)]\\n\\n#![allow(unused_variables)]\\n\\n#![allow(missing_docs)]\\n\\n\\n\\nuse super::SigmaBoolean;\\n\\nuse crate::{\\n\\n eval::{Env, EvalError, Evaluator},\\n\\n ErgoTree, ErgoTreeParsingError,\\n\\n};\\n\\n\\n\\npub enum VerifierError {\\n\\n ErgoTreeError(ErgoTreeParsingError),\\n\\n EvalError(EvalError),\\n\\n}\\n\\n\\n\\nimpl From for VerifierError {\\n\\n fn from(err: ErgoTreeParsingError) -> Self {\\n\\n VerifierError::ErgoTreeError(err)\\n\",\n \"file_path\": \"sigma-tree/src/sigma_protocol/verifier.rs\",\n \"rank\": 17,\n \"score\": 132343.50952893982\n },\n {\n \"content\": \" }\\n\\n}\\n\\n\\n\\nimpl From for VerifierError {\\n\\n fn from(err: EvalError) -> Self {\\n\\n VerifierError::EvalError(err)\\n\\n }\\n\\n}\\n\\n\\n\\npub struct VerificationResult {\\n\\n result: bool,\\n\\n cost: u64,\\n\\n}\\n\\n\\n\",\n \"file_path\": \"sigma-tree/src/sigma_protocol/verifier.rs\",\n \"rank\": 18,\n \"score\": 132336.48822234911\n },\n {\n \"content\": \"\\n\\nimpl Evaluator for TestProver {}\\n\\nimpl Prover for TestProver {\\n\\n fn secrets(&self) -> &[PrivateInput] {\\n\\n self.secrets.as_ref()\\n\\n }\\n\\n}\\n\\n\\n\\n#[derive(PartialEq, Eq, Debug, Clone)]\\n\\npub enum ProverError {\\n\\n ErgoTreeError(ErgoTreeParsingError),\\n\\n EvalError(EvalError),\\n\\n ReducedToFalse,\\n\\n TreeRootIsNotReal,\\n\\n SimulatedLeafWithoutChallenge,\\n\\n RealUnprovenTreeWithoutChallenge,\\n\\n SecretNotFound,\\n\\n}\\n\\n\\n\\nimpl From for ProverError {\\n\\n fn from(err: ErgoTreeParsingError) -> Self {\\n\\n ProverError::ErgoTreeError(err)\\n\\n }\\n\\n}\\n\\n\\n\",\n \"file_path\": \"sigma-tree/src/sigma_protocol/prover.rs\",\n \"rank\": 19,\n \"score\": 132090.0939276574\n },\n {\n \"content\": \"//! Interpreter with enhanced functionality to prove statements.\\n\\n\\n\\n#![allow(dead_code)]\\n\\n#![allow(unused_variables)]\\n\\n#![allow(missing_docs)]\\n\\n\\n\\nuse super::{\\n\\n dlog_protocol, fiat_shamir_hash_fn, fiat_shamir_tree_to_bytes, serialize_sig, Challenge,\\n\\n PrivateInput, ProofTree, SigmaBoolean, SigmaProofOfKnowledgeTree, UncheckedLeaf,\\n\\n UncheckedSchnorr, UncheckedSigmaTree, UncheckedTree, UnprovenSchnorr, UnprovenTree,\\n\\n};\\n\\nuse crate::{\\n\\n chain::{ContextExtension, ProverResult},\\n\\n eval::{Env, EvalError, Evaluator},\\n\\n ErgoTree, ErgoTreeParsingError,\\n\\n};\\n\\n\\n\\npub struct TestProver {\\n\\n pub secrets: Vec,\\n\\n}\\n\",\n \"file_path\": \"sigma-tree/src/sigma_protocol/prover.rs\",\n \"rank\": 20,\n \"score\": 132086.3459287251\n },\n {\n \"content\": \" // and the message being signed.\\n\\n s.append(&mut message.to_vec());\\n\\n let root_challenge = fiat_shamir_hash_fn(s.as_slice());\\n\\n let step8 = step6.with_challenge(Challenge(root_challenge));\\n\\n\\n\\n // Prover Step 9: complete the proof by computing challenges at real nodes and additionally responses at real leaves\\n\\n let step9 = self.proving(step8)?;\\n\\n\\n\\n // Prover Step 10: output the right information into the proof\\n\\n match step9 {\\n\\n ProofTree::UncheckedTree(UncheckedTree::UncheckedSigmaTree(tree)) => Ok(tree),\\n\\n _ => todo!(),\\n\\n }\\n\\n }\\n\\n\\n\\n /**\\n\\n Prover Step 1: This step will mark as \\\"real\\\" every node for which the prover can produce a real proof.\\n\\n This step may mark as \\\"real\\\" more nodes than necessary if the prover has more than the minimal\\n\\n necessary number of witnesses (for example, more than one child of an OR).\\n\\n This will be corrected in the next step.\\n\",\n \"file_path\": \"sigma-tree/src/sigma_protocol/prover.rs\",\n \"rank\": 21,\n \"score\": 132085.12741664032\n },\n {\n \"content\": \" match tree {\\n\\n ProofTree::UncheckedTree(_) => Ok(tree),\\n\\n ProofTree::UnprovenTree(unproven_tree) => match unproven_tree {\\n\\n UnprovenTree::UnprovenSchnorr(us) if unproven_tree.real() => {\\n\\n if let Some(challenge) = us.challenge_opt.clone() {\\n\\n if let Some(priv_key) = self\\n\\n .secrets()\\n\\n .iter()\\n\\n .flat_map(|s| match s {\\n\\n PrivateInput::DlogProverInput(dl) => vec![dl],\\n\\n _ => vec![],\\n\\n })\\n\\n .find(|prover_input| prover_input.public_image() == us.proposition)\\n\\n {\\n\\n let z = dlog_protocol::interactive_prover::second_message(\\n\\n &priv_key,\\n\\n us.randomness_opt.unwrap(),\\n\\n &challenge,\\n\\n );\\n\\n Ok(ProofTree::UncheckedTree(UncheckedTree::UncheckedSigmaTree(\\n\",\n \"file_path\": \"sigma-tree/src/sigma_protocol/prover.rs\",\n \"rank\": 22,\n \"score\": 132083.74330649685\n },\n {\n \"content\": \" In a top-down traversal of the tree, do the following for each node:\\n\\n */\\n\\n fn polish_simulated(&self, unproven_tree: UnprovenTree) -> UnprovenTree {\\n\\n todo!()\\n\\n }\\n\\n\\n\\n /**\\n\\n Prover Step 4: In a top-down traversal of the tree, compute the challenges e for simulated children of every node\\n\\n Prover Step 5: For every leaf marked \\\"simulated\\\", use the simulator of the Sigma-protocol for that leaf\\n\\n to compute the commitment $a$ and the response z, given the challenge e that is already stored in the leaf.\\n\\n Prover Step 6: For every leaf marked \\\"real\\\", use the first prover step of the Sigma-protocol for that leaf to\\n\\n compute the commitment a.\\n\\n */\\n\\n fn simulate_and_commit(&self, tree: UnprovenTree) -> Result {\\n\\n match tree {\\n\\n UnprovenTree::UnprovenSchnorr(us) => {\\n\\n if us.simulated {\\n\\n // Step 5 (simulated leaf -- complete the simulation)\\n\\n if let Some(challenge) = us.challenge_opt {\\n\\n let (fm, sm) = dlog_protocol::interactive_prover::simulate(\\n\",\n \"file_path\": \"sigma-tree/src/sigma_protocol/prover.rs\",\n \"rank\": 23,\n \"score\": 132083.60331504315\n },\n {\n \"content\": \"}\\n\\n\\n\\n// #[cfg(test)]\\n\\n// mod tests {\\n\\n// use super::*;\\n\\n// use crate::{\\n\\n// ast::{Constant, ConstantVal, Expr},\\n\\n// sigma_protocol::{DlogProverInput, SigmaProp},\\n\\n// types::SType,\\n\\n// };\\n\\n// use std::rc::Rc;\\n\\n\\n\\n// #[test]\\n\\n// fn test_prove_true_prop() {\\n\\n// let bool_true_tree = ErgoTree::from(Rc::new(Expr::Const(Constant {\\n\\n// tpe: SType::SBoolean,\\n\\n// v: ConstantVal::Boolean(true),\\n\\n// })));\\n\\n// let message = vec![0u8; 100];\\n\\n\\n\",\n \"file_path\": \"sigma-tree/src/sigma_protocol/prover.rs\",\n \"rank\": 24,\n \"score\": 132082.14336036408\n },\n {\n \"content\": \" if !step1.real() {\\n\\n return Err(ProverError::TreeRootIsNotReal);\\n\\n }\\n\\n\\n\\n // Prover Step 3: Change some \\\"real\\\" nodes to \\\"simulated\\\" to make sure each node\\n\\n // has the right number of simulated children.\\n\\n\\n\\n // skipped, since it leaves UnprovenSchnorr untouched\\n\\n // let step3 = self.polish_simulated(step1);\\n\\n\\n\\n // Prover Steps 4, 5, and 6 together: find challenges for simulated nodes; simulate simulated leaves;\\n\\n // compute commitments for real leaves\\n\\n let step6 = self.simulate_and_commit(step1)?;\\n\\n\\n\\n // Prover Steps 7: convert the relevant information in the tree (namely, tree structure, node types,\\n\\n // the statements being proven and commitments at the leaves)\\n\\n // to a string\\n\\n let mut s = fiat_shamir_tree_to_bytes(&step6);\\n\\n\\n\\n // Prover Step 8: compute the challenge for the root of the tree as the Fiat-Shamir hash of s\\n\",\n \"file_path\": \"sigma-tree/src/sigma_protocol/prover.rs\",\n \"rank\": 25,\n \"score\": 132080.5613411577\n },\n {\n \"content\": \" &us.proposition,\\n\\n &challenge,\\n\\n );\\n\\n Ok(ProofTree::UncheckedTree(UncheckedTree::UncheckedSigmaTree(\\n\\n UncheckedSigmaTree::UncheckedLeaf(UncheckedLeaf::UncheckedSchnorr(\\n\\n UncheckedSchnorr {\\n\\n proposition: us.proposition,\\n\\n commitment_opt: Some(fm),\\n\\n challenge,\\n\\n second_message: sm,\\n\\n },\\n\\n )),\\n\\n )))\\n\\n } else {\\n\\n Err(ProverError::SimulatedLeafWithoutChallenge)\\n\\n }\\n\\n } else {\\n\\n // Step 6 (real leaf -- compute the commitment a)\\n\\n let (r, commitment) =\\n\\n dlog_protocol::interactive_prover::first_message(&us.proposition);\\n\",\n \"file_path\": \"sigma-tree/src/sigma_protocol/prover.rs\",\n \"rank\": 26,\n \"score\": 132080.44406417472\n },\n {\n \"content\": \" }\\n\\n });\\n\\n proof.map(|v| ProverResult {\\n\\n proof: serialize_sig(v),\\n\\n extension: ContextExtension::empty(),\\n\\n })\\n\\n }\\n\\n\\n\\n fn convert_to_unproven(&self, sigma_tree: SigmaBoolean) -> UnprovenTree {\\n\\n match sigma_tree {\\n\\n SigmaBoolean::TrivialProp(_) => todo!(), // TODO: why it's even here\\n\\n SigmaBoolean::ProofOfKnowledge(pok) => match pok {\\n\\n SigmaProofOfKnowledgeTree::ProveDHTuple(_) => todo!(),\\n\\n SigmaProofOfKnowledgeTree::ProveDlog(prove_dlog) => {\\n\\n UnprovenTree::UnprovenSchnorr(UnprovenSchnorr {\\n\\n proposition: prove_dlog,\\n\\n commitment_opt: None,\\n\\n randomness_opt: None,\\n\\n challenge_opt: None,\\n\\n simulated: false,\\n\",\n \"file_path\": \"sigma-tree/src/sigma_protocol/prover.rs\",\n \"rank\": 27,\n \"score\": 132080.42293479643\n },\n {\n \"content\": \"// let prover = TestProver { secrets: vec![] };\\n\\n// let res = prover.prove(&bool_true_tree, &Env::empty(), message.as_slice());\\n\\n// assert!(res.is_ok());\\n\\n// assert!(res.unwrap().proof.is_empty());\\n\\n// }\\n\\n\\n\\n// #[test]\\n\\n// fn test_prove_false_prop() {\\n\\n// let bool_false_tree = ErgoTree::from(Rc::new(Expr::Const(Constant {\\n\\n// tpe: SType::SBoolean,\\n\\n// v: ConstantVal::Boolean(false),\\n\\n// })));\\n\\n// let message = vec![0u8; 100];\\n\\n\\n\\n// let prover = TestProver { secrets: vec![] };\\n\\n// let res = prover.prove(&bool_false_tree, &Env::empty(), message.as_slice());\\n\\n// assert!(res.is_err());\\n\\n// assert_eq!(res.err().unwrap(), ProverError::ReducedToFalse);\\n\\n// }\\n\\n\\n\",\n \"file_path\": \"sigma-tree/src/sigma_protocol/prover.rs\",\n \"rank\": 28,\n \"score\": 132077.7923285461\n },\n {\n \"content\": \" UncheckedSigmaTree::UncheckedLeaf(UncheckedLeaf::UncheckedSchnorr(\\n\\n UncheckedSchnorr {\\n\\n proposition: us.proposition,\\n\\n commitment_opt: None,\\n\\n challenge,\\n\\n second_message: z,\\n\\n },\\n\\n )),\\n\\n )))\\n\\n } else {\\n\\n Err(ProverError::SecretNotFound)\\n\\n }\\n\\n } else {\\n\\n Err(ProverError::RealUnprovenTreeWithoutChallenge)\\n\\n }\\n\\n }\\n\\n _ => todo!(),\\n\\n },\\n\\n }\\n\\n }\\n\",\n \"file_path\": \"sigma-tree/src/sigma_protocol/prover.rs\",\n \"rank\": 29,\n \"score\": 132077.4879540827\n },\n {\n \"content\": \" In a bottom-up traversal of the tree, do the following for each node:\\n\\n */\\n\\n fn mark_real(&self, unproven_tree: UnprovenTree) -> UnprovenTree {\\n\\n match unproven_tree {\\n\\n UnprovenTree::UnprovenSchnorr(us) => {\\n\\n let secret_known = self.secrets().iter().any(|s| match s {\\n\\n PrivateInput::DlogProverInput(dl) => dl.public_image() == us.proposition,\\n\\n _ => false,\\n\\n });\\n\\n UnprovenTree::UnprovenSchnorr(UnprovenSchnorr {\\n\\n simulated: !secret_known,\\n\\n ..us\\n\\n })\\n\\n }\\n\\n }\\n\\n }\\n\\n\\n\\n /**\\n\\n Prover Step 3: This step will change some \\\"real\\\" nodes to \\\"simulated\\\" to make sure each node has\\n\\n the right number of simulated children.\\n\",\n \"file_path\": \"sigma-tree/src/sigma_protocol/prover.rs\",\n \"rank\": 30,\n \"score\": 132075.8234238417\n },\n {\n \"content\": \" })\\n\\n }\\n\\n },\\n\\n SigmaBoolean::CAND(_) => todo!(),\\n\\n }\\n\\n }\\n\\n\\n\\n /// The comments in this section are taken from the algorithm for the\\n\\n /// Sigma-protocol prover as described in the white paper\\n\\n /// https://ergoplatform.org/docs/ErgoScript.pdf (Appendix A)\\n\\n fn prove_to_unchecked(\\n\\n &self,\\n\\n unproven_tree: UnprovenTree,\\n\\n message: &[u8],\\n\\n ) -> Result {\\n\\n // Prover Step 1: Mark as real everything the prover can prove\\n\\n let step1 = self.mark_real(unproven_tree);\\n\\n\\n\\n // Prover Step 2: If the root of the tree is marked \\\"simulated\\\" then the prover does not have enough witnesses\\n\\n // to perform the proof. Abort.\\n\",\n \"file_path\": \"sigma-tree/src/sigma_protocol/prover.rs\",\n \"rank\": 31,\n \"score\": 132075.221121568\n },\n {\n \"content\": \"// #[test]\\n\\n// fn test_prove_pk_prop() {\\n\\n// let secret = DlogProverInput::random();\\n\\n// let pk = secret.public_image();\\n\\n// let tree = ErgoTree::from(Rc::new(Expr::Const(Constant {\\n\\n// tpe: SType::SSigmaProp,\\n\\n// v: ConstantVal::SigmaProp(Box::new(SigmaProp(SigmaBoolean::ProofOfKnowledge(\\n\\n// SigmaProofOfKnowledgeTree::ProveDlog(pk),\\n\\n// )))),\\n\\n// })));\\n\\n// let message = vec![0u8; 100];\\n\\n\\n\\n// let prover = TestProver {\\n\\n// secrets: vec![PrivateInput::DlogProverInput(secret)],\\n\\n// };\\n\\n// let res = prover.prove(&tree, &Env::empty(), message.as_slice());\\n\\n// // assert!(res.is_ok());\\n\\n// assert!(!res.unwrap().proof.is_empty());\\n\\n// }\\n\\n// }\\n\",\n \"file_path\": \"sigma-tree/src/sigma_protocol/prover.rs\",\n \"rank\": 32,\n \"score\": 132074.9440513409\n },\n {\n \"content\": \" Ok(ProofTree::UnprovenTree(UnprovenTree::UnprovenSchnorr(\\n\\n UnprovenSchnorr {\\n\\n commitment_opt: Some(commitment),\\n\\n randomness_opt: Some(r),\\n\\n ..us\\n\\n },\\n\\n )))\\n\\n }\\n\\n }\\n\\n }\\n\\n }\\n\\n\\n\\n /**\\n\\n Prover Step 9: Perform a top-down traversal of only the portion of the tree marked \\\"real\\\" in order to compute\\n\\n the challenge e for every node marked \\\"real\\\" below the root and, additionally, the response z for every leaf\\n\\n marked \\\"real\\\"\\n\\n */\\n\\n fn proving(&self, tree: ProofTree) -> Result {\\n\\n // If the node is a leaf marked \\\"real\\\", compute its response according to the second prover step\\n\\n // of the Sigma-protocol given the commitment, challenge, and witness\\n\",\n \"file_path\": \"sigma-tree/src/sigma_protocol/prover.rs\",\n \"rank\": 33,\n \"score\": 132071.53000850373\n },\n {\n \"content\": \"/// Box deserialization with token ids optionally parsed in transaction\\n\\npub fn parse_box_with_indexed_digests(\\n\\n digests_in_tx: Option<&IndexSet>,\\n\\n r: &mut R,\\n\\n) -> Result {\\n\\n // reference implementation -https://github.com/ScorexFoundation/sigmastate-interpreter/blob/9b20cb110effd1987ff76699d637174a4b2fb441/sigmastate/src/main/scala/org/ergoplatform/ErgoBoxCandidate.scala#L144-L144\\n\\n\\n\\n let value = BoxValue::sigma_parse(r)?;\\n\\n let ergo_tree = ErgoTree::sigma_parse(r)?;\\n\\n let creation_height = r.get_u32()?;\\n\\n let tokens_count = r.get_u8()?;\\n\\n let mut tokens = Vec::with_capacity(tokens_count as usize);\\n\\n for _ in 0..tokens_count {\\n\\n let token_id = match digests_in_tx {\\n\\n None => TokenId::sigma_parse(r)?,\\n\\n Some(digests) => {\\n\\n let digest_index = r.get_u32()?;\\n\\n match digests.get_index(digest_index as usize) {\\n\\n Some(i) => Ok((*i).clone()),\\n\\n None => Err(SerializationError::Misc(\\n\\n \\\"failed to find token id in tx digests\\\".to_string(),\\n\",\n \"file_path\": \"sigma-tree/src/serialization/ergo_box.rs\",\n \"rank\": 34,\n \"score\": 130755.87430331073\n },\n {\n \"content\": \"use num_bigint::{BigInt, Sign};\\n\\nuse sigma_ser::{\\n\\n serializer::{SerializationError, SigmaSerializable},\\n\\n vlq_encode,\\n\\n};\\n\\nuse std::{convert::TryInto, io};\\n\\n\\n\\n#[derive(PartialEq, Debug, Clone)]\\n\\npub struct EcPoint(ProjectivePoint);\\n\\n\\n\\nimpl EcPoint {\\n\\n pub const GROUP_SIZE: usize = 33;\\n\\n}\\n\\n\\n\\nimpl Eq for EcPoint {}\\n\\n\\n\\n/// The generator g of the group is an element of the group such that, when written multiplicatively, every element\\n\\n/// of the group is a power of g.\\n\",\n \"file_path\": \"sigma-tree/src/sigma_protocol/dlog_group.rs\",\n \"rank\": 35,\n \"score\": 128997.84124939927\n },\n {\n \"content\": \"impl SigmaSerializable for EcPoint {\\n\\n fn sigma_serialize(&self, w: &mut W) -> Result<(), io::Error> {\\n\\n let caff = self.0.to_affine();\\n\\n if bool::from(caff.is_some()) {\\n\\n let pubkey = caff.unwrap().to_compressed_pubkey();\\n\\n w.write_all(pubkey.as_bytes())?;\\n\\n } else {\\n\\n // infinity point\\n\\n let zeroes = [0u8; EcPoint::GROUP_SIZE];\\n\\n w.write_all(&zeroes)?;\\n\\n }\\n\\n Ok(())\\n\\n }\\n\\n\\n\\n fn sigma_parse(r: &mut R) -> Result {\\n\\n let mut buf = [0; EcPoint::GROUP_SIZE];\\n\\n r.read_exact(&mut buf[..])?;\\n\\n if buf[0] != 0 {\\n\\n let pubkey = PublicKey::from_bytes(&buf[..]).ok_or_else(|| {\\n\\n SerializationError::Misc(\\\"failed to parse PK from bytes\\\".to_string())\\n\",\n \"file_path\": \"sigma-tree/src/sigma_protocol/dlog_group.rs\",\n \"rank\": 36,\n \"score\": 128991.06248959851\n },\n {\n \"content\": \"//! This is the general interface for the discrete logarithm prime-order group.\\n\\n//!\\n\\n//! The discrete logarithm problem is as follows: given a generator g of a finite\\n\\n//! group G and a random element h in G, find the (unique) integer x such that\\n\\n//! `g^x = h`.\\n\\n//!\\n\\n//! In cryptography, we are interested in groups for which the discrete logarithm problem\\n\\n//! (Dlog for short) is assumed to be hard. The most known groups of that kind are some Elliptic curve groups.\\n\\n//!\\n\\n//! Another issue pertaining elliptic curves is the need to find a suitable mapping that will convert an arbitrary\\n\\n//! message (that is some binary string) to an element of the group and vice-versa.\\n\\n//!\\n\\n//! Only a subset of the messages can be effectively mapped to a group element in such a way that there is a one-to-one\\n\\n//! injection that converts the string to a group element and vice-versa.\\n\\n//!\\n\\n//! On the other hand, any group element can be mapped to some string.\\n\\n\\n\\nuse super::DlogProverInput;\\n\\nuse k256::arithmetic::{ProjectivePoint, Scalar};\\n\\nuse k256::{arithmetic::AffinePoint, PublicKey};\\n\",\n \"file_path\": \"sigma-tree/src/sigma_protocol/dlog_group.rs\",\n \"rank\": 37,\n \"score\": 128984.70460948438\n },\n {\n \"content\": \" use sigma_ser::test_helpers::*;\\n\\n\\n\\n impl Arbitrary for EcPoint {\\n\\n type Parameters = ();\\n\\n type Strategy = BoxedStrategy;\\n\\n\\n\\n fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy {\\n\\n prop_oneof![Just(generator()), Just(identity()), Just(random_element()),].boxed()\\n\\n }\\n\\n }\\n\\n\\n\\n proptest! {\\n\\n\\n\\n #[test]\\n\\n fn ser_roundtrip(v in any::()) {\\n\\n prop_assert_eq![sigma_serialize_roundtrip(&v), v];\\n\\n }\\n\\n }\\n\\n}\\n\",\n \"file_path\": \"sigma-tree/src/sigma_protocol/dlog_group.rs\",\n \"rank\": 38,\n \"score\": 128982.96969987261\n },\n {\n \"content\": \" })?;\\n\\n let cp = AffinePoint::from_pubkey(&pubkey);\\n\\n if bool::from(cp.is_none()) {\\n\\n Err(SerializationError::Misc(\\n\\n \\\"failed to get affine point from PK\\\".to_string(),\\n\\n ))\\n\\n } else {\\n\\n Ok(EcPoint(ProjectivePoint::from(cp.unwrap())))\\n\\n }\\n\\n } else {\\n\\n // infinity point\\n\\n Ok(EcPoint(ProjectivePoint::identity()))\\n\\n }\\n\\n }\\n\\n}\\n\\n\\n\\n#[cfg(test)]\\n\\nmod tests {\\n\\n use super::*;\\n\\n use proptest::prelude::*;\\n\",\n \"file_path\": \"sigma-tree/src/sigma_protocol/dlog_group.rs\",\n \"rank\": 39,\n \"score\": 128973.18299612621\n },\n {\n \"content\": \"#[derive(PartialEq, Eq, Debug, Clone)]\\n\\nstruct ParsedTree {\\n\\n constants: Vec,\\n\\n root: Result, ErgoTreeRootParsingError>,\\n\\n}\\n\\n\\n\\n/** The root of ErgoScript IR. Serialized instances of this class are self sufficient and can be passed around.\\n\\n */\\n\\n#[derive(PartialEq, Eq, Debug, Clone)]\\n\\npub struct ErgoTree {\\n\\n header: ErgoTreeHeader,\\n\\n tree: Result,\\n\\n}\\n\\n\\n\",\n \"file_path\": \"sigma-tree/src/ergo_tree.rs\",\n \"rank\": 40,\n \"score\": 124535.41137541014\n },\n {\n \"content\": \"/// Consensus-critical serialization for Ergo\\n\\npub trait SigmaSerializable: Sized {\\n\\n /// Write `self` to the given `writer`.\\n\\n /// This function has a `sigma_` prefix to alert the reader that the\\n\\n /// serialization in use is consensus-critical serialization \\n\\n /// Notice that the error type is [`std::io::Error`]; this indicates that\\n\\n /// serialization MUST be infallible up to errors in the underlying writer.\\n\\n /// In other words, any type implementing `SigmaSerializable`\\n\\n /// must make illegal states unrepresentable.\\n\\n fn sigma_serialize(&self, w: &mut W) -> Result<(), io::Error>;\\n\\n\\n\\n /// Try to read `self` from the given `reader`.\\n\\n /// `sigma-` prefix to alert the reader that the serialization in use\\n\\n /// is consensus-critical\\n\\n fn sigma_parse(r: &mut R) -> Result;\\n\\n\\n\\n /// Serialize any SigmaSerializable value into bytes\\n\\n fn sigma_serialise_bytes(&self) -> Vec {\\n\\n let mut data = Vec::new();\\n\\n self.sigma_serialize(&mut data)\\n\\n // since serialization may fail only for underlying IO errors it's ok to force unwrap\\n\",\n \"file_path\": \"sigma-ser/src/serializer.rs\",\n \"rank\": 41,\n \"score\": 115946.81811420254\n },\n {\n \"content\": \"/// Encode a 32-bit value with ZigZag. ZigZag encodes signed integers\\n\\n/// into values that can be efficiently encoded with VLQ. (Otherwise,\\n\\n/// negative values must be sign-extended to 64 bits to be varint encoded,\\n\\n/// thus always taking 10 bytes on the wire.)\\n\\n/// see https://developers.google.com/protocol-buffers/docs/encoding#types\\n\\npub fn encode_i32(v: i32) -> u32 {\\n\\n // Note: the right-shift must be arithmetic\\n\\n // source: http://github.com/google/protobuf/blob/a7252bf42df8f0841cf3a0c85fdbf1a5172adecb/java/core/src/main/java/com/google/protobuf/CodedOutputStream.java#L934\\n\\n ((v << 1) ^ (v >> 31)) as u32\\n\\n}\\n\\n\\n\",\n \"file_path\": \"sigma-ser/src/zig_zag_encode.rs\",\n \"rank\": 42,\n \"score\": 113382.27196220358\n },\n {\n \"content\": \"/// Encode a 64-bit value with ZigZag. ZigZag encodes signed integers\\n\\n/// into values that can be efficiently encoded with varint. (Otherwise,\\n\\n/// negative values must be sign-extended to 64 bits to be varint encoded,\\n\\n/// thus always taking 10 bytes on the wire.)\\n\\n/// see https://developers.google.com/protocol-buffers/docs/encoding#types\\n\\npub fn encode_i64(v: i64) -> u64 {\\n\\n // source: http://github.com/google/protobuf/blob/a7252bf42df8f0841cf3a0c85fdbf1a5172adecb/java/core/src/main/java/com/google/protobuf/CodedOutputStream.java#L949\\n\\n ((v << 1) ^ (v >> 63)) as u64\\n\\n}\\n\\n\\n\",\n \"file_path\": \"sigma-ser/src/zig_zag_encode.rs\",\n \"rank\": 43,\n \"score\": 113382.27196220358\n },\n {\n \"content\": \"/// Decode a signed value previously ZigZag-encoded with [`encode_i32`]\\n\\n/// see https://developers.google.com/protocol-buffers/docs/encoding#types\\n\\npub fn decode_u32(v: u32) -> i32 {\\n\\n // source: http://github.com/google/protobuf/blob/a7252bf42df8f0841cf3a0c85fdbf1a5172adecb/java/core/src/main/java/com/google/protobuf/CodedInputStream.java#L553\\n\\n ((v >> 1) ^ (-((v & 1) as i32)) as u32) as i32\\n\\n}\\n\\n\\n\",\n \"file_path\": \"sigma-ser/src/zig_zag_encode.rs\",\n \"rank\": 44,\n \"score\": 113375.03674928242\n },\n {\n \"content\": \"/// Decode a signed value previously ZigZag-encoded with [`encode_i64`]\\n\\n/// see https://developers.google.com/protocol-buffers/docs/encoding#types\\n\\npub fn decode_u64(v: u64) -> i64 {\\n\\n // source: http://github.com/google/protobuf/blob/a7252bf42df8f0841cf3a0c85fdbf1a5172adecb/java/core/src/main/java/com/google/protobuf/CodedInputStream.java#L566\\n\\n ((v >> 1) ^ (-((v & 1) as i64)) as u64) as i64\\n\\n}\\n\\n#[cfg(test)]\\n\\nmod tests {\\n\\n use super::*;\\n\\n\\n\\n #[allow(overflowing_literals)]\\n\\n #[test]\\n\\n fn test_expected_values() {\\n\\n // source: http://github.com/google/protobuf/blob/a7252bf42df8f0841cf3a0c85fdbf1a5172adecb/java/core/src/test/java/com/google/protobuf/CodedOutputStreamTest.java#L281\\n\\n assert_eq!(0, encode_i32(0));\\n\\n assert_eq!(1, encode_i32(-1));\\n\\n assert_eq!(2, encode_i32(1));\\n\\n assert_eq!(3, encode_i32(-2));\\n\\n assert_eq!(0x7FFF_FFFE, encode_i32(0x3FFF_FFFF));\\n\\n assert_eq!(0x7FFF_FFFF, encode_i32(0xC000_0000));\\n\\n assert_eq!(0xFFFF_FFFE, encode_i32(0x7FFF_FFFF));\\n\\n assert_eq!(0xFFFF_FFFF, encode_i32(0x8000_0000));\\n\",\n \"file_path\": \"sigma-ser/src/zig_zag_encode.rs\",\n \"rank\": 45,\n \"score\": 113375.03674928242\n },\n {\n \"content\": \"pub trait Evaluator {\\n\\n fn reduce_to_crypto(&self, expr: &Expr, env: &Env) -> Result {\\n\\n let mut ca = CostAccumulator::new(0, None);\\n\\n eval(expr, env, &mut ca).and_then(|v| match v {\\n\\n Value::Boolean(b) => Ok(ReductionResult {\\n\\n sigma_prop: SigmaBoolean::TrivialProp(b),\\n\\n cost: 0,\\n\\n }),\\n\\n Value::SigmaProp(sb) => Ok(ReductionResult {\\n\\n sigma_prop: *sb,\\n\\n cost: 0,\\n\\n }),\\n\\n _ => Err(EvalError::InvalidResultType),\\n\\n })\\n\\n }\\n\\n}\\n\\n\\n\",\n \"file_path\": \"sigma-tree/src/eval.rs\",\n \"rank\": 46,\n \"score\": 110591.21666816529\n },\n {\n \"content\": \"/// serialization roundtrip\\n\\npub fn sigma_serialize_roundtrip(v: &T) -> T {\\n\\n let mut data = Vec::new();\\n\\n v.sigma_serialize(&mut data).expect(\\\"serialization failed\\\");\\n\\n let cursor = Cursor::new(&mut data[..]);\\n\\n let mut reader = PeekableReader::new(cursor);\\n\\n T::sigma_parse(&mut reader).expect(\\\"parse failed\\\")\\n\\n}\\n\",\n \"file_path\": \"sigma-ser/src/test_helpers.rs\",\n \"rank\": 47,\n \"score\": 107673.6881738675\n },\n {\n \"content\": \"/// Conversion to SType\\n\\npub trait LiftIntoSType {\\n\\n /// get SType\\n\\n fn stype() -> SType;\\n\\n}\\n\\n\\n\\nimpl LiftIntoSType for Vec {\\n\\n fn stype() -> SType {\\n\\n SType::SColl(Box::new(T::stype()))\\n\\n }\\n\\n}\\n\\n\\n\\nimpl LiftIntoSType for bool {\\n\\n fn stype() -> SType {\\n\\n SType::SBoolean\\n\\n }\\n\\n}\\n\\n\\n\\nimpl LiftIntoSType for i8 {\\n\\n fn stype() -> SType {\\n\\n SType::SByte\\n\",\n \"file_path\": \"sigma-tree/src/types.rs\",\n \"rank\": 48,\n \"score\": 105828.2680589123\n },\n {\n \"content\": \"/// Marker trait to select types for which CollElems::NonPrimitive is used to store elements as Vec\\n\\npub trait StoredNonPrimitive {}\\n\\n\\n\\nimpl StoredNonPrimitive for bool {}\\n\\nimpl StoredNonPrimitive for i16 {}\\n\\nimpl StoredNonPrimitive for i32 {}\\n\\nimpl StoredNonPrimitive for i64 {}\\n\\n\\n\\nimpl> Into for Vec {\\n\\n fn into(self) -> ConstantVal {\\n\\n ConstantVal::Coll(ConstantColl::NonPrimitive {\\n\\n elem_tpe: T::stype(),\\n\\n v: self.into_iter().map(|i| i.into()).collect(),\\n\\n })\\n\\n }\\n\\n}\\n\\n\\n\\nimpl> Into for Vec {\\n\\n fn into(self) -> Constant {\\n\\n Constant {\\n\\n tpe: Self::stype(),\\n\",\n \"file_path\": \"sigma-tree/src/ast/constant.rs\",\n \"rank\": 49,\n \"score\": 103640.71752145007\n },\n {\n \"content\": \"use super::dlog_group::EcPoint;\\n\\nuse crate::big_integer::BigInteger;\\n\\n\\n\\npub struct FirstDlogProverMessage(EcPoint);\\n\\npub struct SecondDlogProverMessage(BigInteger);\\n\\n\\n\\npub mod interactive_prover {\\n\\n use super::{FirstDlogProverMessage, SecondDlogProverMessage};\\n\\n use crate::{\\n\\n big_integer::BigInteger,\\n\\n sigma_protocol::{dlog_group, Challenge, DlogProverInput, ProveDlog},\\n\\n };\\n\\n\\n\\n pub fn simulate(\\n\\n public_input: &ProveDlog,\\n\\n challenge: &Challenge,\\n\\n ) -> (FirstDlogProverMessage, SecondDlogProverMessage) {\\n\\n todo!()\\n\\n }\\n\\n\\n\",\n \"file_path\": \"sigma-tree/src/sigma_protocol/dlog_protocol.rs\",\n \"rank\": 50,\n \"score\": 103559.58389473011\n },\n {\n \"content\": \" pub fn first_message(proposition: &ProveDlog) -> (BigInteger, FirstDlogProverMessage) {\\n\\n let scalar = dlog_group::random_scalar_in_group_range();\\n\\n let g = dlog_group::generator();\\n\\n let a = dlog_group::exponentiate(&g, &scalar);\\n\\n (scalar.into(), FirstDlogProverMessage(a))\\n\\n }\\n\\n\\n\\n pub fn second_message(\\n\\n private_input: &DlogProverInput,\\n\\n rnd: BigInteger,\\n\\n challenge: &Challenge,\\n\\n ) -> SecondDlogProverMessage {\\n\\n todo!()\\n\\n }\\n\\n}\\n\",\n \"file_path\": \"sigma-tree/src/sigma_protocol/dlog_protocol.rs\",\n \"rank\": 51,\n \"score\": 103556.93764173287\n },\n {\n \"content\": \"#[allow(dead_code)]\\n\\npub fn set_panic_hook() {\\n\\n // When the `console_error_panic_hook` feature is enabled, we can call the\\n\\n // `set_panic_hook` function at least once during initialization, and then\\n\\n // we will get better error messages if our code ever panics.\\n\\n //\\n\\n // For more details see\\n\\n // https://github.com/rustwasm/console_error_panic_hook#readme\\n\\n #[cfg(feature = \\\"console_error_panic_hook\\\")]\\n\\n console_error_panic_hook::set_once();\\n\\n}\\n\",\n \"file_path\": \"bindings/ergo-wallet-lib-wasm/src/utils.rs\",\n \"rank\": 52,\n \"score\": 101352.21596770632\n },\n {\n \"content\": \"use super::op_code::OpCode;\\n\\nuse crate::sigma_protocol::{\\n\\n dlog_group::EcPoint, ProveDlog, SigmaBoolean, SigmaProofOfKnowledgeTree,\\n\\n};\\n\\nuse sigma_ser::{\\n\\n serializer::{SerializationError, SigmaSerializable},\\n\\n vlq_encode,\\n\\n};\\n\\nuse std::io;\\n\\n\\n\\nimpl SigmaSerializable for SigmaBoolean {\\n\\n fn sigma_serialize(&self, w: &mut W) -> Result<(), io::Error> {\\n\\n self.op_code().sigma_serialize(w)?;\\n\\n match self {\\n\\n SigmaBoolean::ProofOfKnowledge(proof) => match proof {\\n\\n SigmaProofOfKnowledgeTree::ProveDHTuple { .. } => todo!(),\\n\\n SigmaProofOfKnowledgeTree::ProveDlog(v) => v.sigma_serialize(w),\\n\\n },\\n\\n SigmaBoolean::CAND(_) => todo!(),\\n\\n SigmaBoolean::TrivialProp(_) => Ok(()), // besides opCode no additional bytes\\n\",\n \"file_path\": \"sigma-tree/src/serialization/sigmaboolean.rs\",\n \"rank\": 65,\n \"score\": 93760.16782276653\n },\n {\n \"content\": \" }\\n\\n }\\n\\n\\n\\n fn sigma_parse(r: &mut R) -> Result {\\n\\n let op_code = OpCode::sigma_parse(r)?;\\n\\n match op_code {\\n\\n OpCode::PROVE_DLOG => Ok(SigmaBoolean::ProofOfKnowledge(\\n\\n SigmaProofOfKnowledgeTree::ProveDlog(ProveDlog::sigma_parse(r)?),\\n\\n )),\\n\\n _ => todo!(),\\n\\n }\\n\\n }\\n\\n}\\n\\n\\n\\nimpl SigmaSerializable for ProveDlog {\\n\\n fn sigma_serialize(&self, w: &mut W) -> Result<(), io::Error> {\\n\\n self.h.sigma_serialize(w)\\n\\n }\\n\\n\\n\\n fn sigma_parse(r: &mut R) -> Result {\\n\\n let p = EcPoint::sigma_parse(r)?;\\n\\n Ok(ProveDlog::new(p))\\n\\n }\\n\\n}\\n\",\n \"file_path\": \"sigma-tree/src/serialization/sigmaboolean.rs\",\n \"rank\": 66,\n \"score\": 93751.81868783914\n },\n {\n \"content\": \"use crate::{chain::ErgoBox, sigma_protocol::SigmaBoolean};\\n\\nuse std::ops::Add;\\n\\n\\n\\n#[allow(dead_code)]\\n\\npub enum Value {\\n\\n Boolean(bool),\\n\\n Byte(i8),\\n\\n Short(i16),\\n\\n Int(i32),\\n\\n Long(i64),\\n\\n BigInt,\\n\\n GroupElement,\\n\\n SigmaProp(Box),\\n\\n Box(Box),\\n\\n AvlTree,\\n\\n Coll(Vec),\\n\\n Tup(Vec),\\n\\n}\\n\\n\\n\\nimpl Value {\\n\",\n \"file_path\": \"sigma-tree/src/eval/value.rs\",\n \"rank\": 67,\n \"score\": 93679.11921324018\n },\n {\n \"content\": \" #[inline]\\n\\n pub fn byte(value: i8) -> Self {\\n\\n Value::Byte(value)\\n\\n }\\n\\n}\\n\\n\\n\\nimpl Add for Value {\\n\\n type Output = Self;\\n\\n fn add(self, other: Self) -> Self {\\n\\n match (self, other) {\\n\\n (Value::Byte(s), Value::Byte(o)) => Self::byte(s + o),\\n\\n _ => todo!(),\\n\\n }\\n\\n }\\n\\n}\\n\",\n \"file_path\": \"sigma-tree/src/eval/value.rs\",\n \"rank\": 68,\n \"score\": 93670.11107088254\n },\n {\n \"content\": \"use sigma_ser::{\\n\\n serializer::{SerializationError, SigmaSerializable},\\n\\n vlq_encode,\\n\\n};\\n\\nuse std::io;\\n\\nuse vlq_encode::WriteSigmaVlqExt;\\n\\n\\n\\n#[derive(PartialEq, Eq, Hash, Copy, Clone)]\\n\\npub struct OpCode(u8);\\n\\n\\n\\nimpl OpCode {\\n\\n pub const LAST_DATA_TYPE: OpCode = OpCode(111);\\n\\n pub const LAST_CONSTANT_CODE: OpCode = OpCode(Self::LAST_DATA_TYPE.value() + 1);\\n\\n\\n\\n pub const FOLD: OpCode = Self::new_op_code(64);\\n\\n pub const PROVE_DLOG: OpCode = Self::new_op_code(93);\\n\\n\\n\\n const fn new_op_code(shift: u8) -> OpCode {\\n\\n OpCode(Self::LAST_CONSTANT_CODE.value() + shift)\\n\\n }\\n\",\n \"file_path\": \"sigma-tree/src/serialization/op_code.rs\",\n \"rank\": 69,\n \"score\": 91145.22622905049\n },\n {\n \"content\": \"\\n\\n pub fn parse(b: u8) -> OpCode {\\n\\n OpCode(b)\\n\\n }\\n\\n\\n\\n pub const fn value(self) -> u8 {\\n\\n self.0\\n\\n }\\n\\n}\\n\\n\\n\\nimpl SigmaSerializable for OpCode {\\n\\n fn sigma_serialize(&self, w: &mut W) -> Result<(), io::Error> {\\n\\n w.put_u8(self.0)?;\\n\\n Ok(())\\n\\n }\\n\\n fn sigma_parse(r: &mut R) -> Result {\\n\\n let code = r.get_u8()?;\\n\\n Ok(OpCode::parse(code))\\n\\n }\\n\\n}\\n\",\n \"file_path\": \"sigma-tree/src/serialization/op_code.rs\",\n \"rank\": 70,\n \"score\": 91144.24305277137\n },\n {\n \"content\": \"//! Transitioning type for Base16 encoded bytes in JSON serialization\\n\\n\\n\\n#[cfg(feature = \\\"with-serde\\\")]\\n\\nuse serde::{Deserialize, Serialize};\\n\\nuse std::convert::TryFrom;\\n\\n\\n\\n/// Transitioning type for Base16 encoded bytes\\n\\n#[cfg_attr(feature = \\\"with-serde\\\", derive(Serialize, Deserialize))]\\n\\n#[cfg_attr(feature = \\\"with-serde\\\", serde(into = \\\"String\\\"))]\\n\\n#[derive(PartialEq, Eq, Debug, Clone)]\\n\\npub struct Base16EncodedBytes(String);\\n\\n\\n\\nimpl Base16EncodedBytes {\\n\\n /// Create from byte array ref (&[u8])\\n\\n pub fn new>(input: &T) -> Base16EncodedBytes {\\n\\n Base16EncodedBytes(base16::encode_lower(input))\\n\\n }\\n\\n}\\n\\n\\n\\nimpl Into for Base16EncodedBytes {\\n\",\n \"file_path\": \"sigma-tree/src/chain/base16_bytes.rs\",\n \"rank\": 71,\n \"score\": 91105.97352877635\n },\n {\n \"content\": \" fn into(self) -> String {\\n\\n self.0\\n\\n }\\n\\n}\\n\\n\\n\\n/// Transitioning type for Base16 decoded bytes\\n\\n#[cfg_attr(feature = \\\"with-serde\\\", derive(Serialize, Deserialize))]\\n\\n#[cfg_attr(feature = \\\"with-serde\\\", serde(try_from = \\\"String\\\"))]\\n\\n#[derive(PartialEq, Eq, Debug, Clone)]\\n\\npub struct Base16DecodedBytes(pub Vec);\\n\\n\\n\\nimpl TryFrom for Base16DecodedBytes {\\n\\n type Error = base16::DecodeError;\\n\\n fn try_from(str: String) -> Result {\\n\\n Ok(Base16DecodedBytes(base16::decode(&str)?))\\n\\n }\\n\\n}\\n\",\n \"file_path\": \"sigma-tree/src/chain/base16_bytes.rs\",\n \"rank\": 72,\n \"score\": 91104.22240508255\n },\n {\n \"content\": \"//! ProverResult\\n\\nuse sigma_ser::serializer::SerializationError;\\n\\nuse sigma_ser::serializer::SigmaSerializable;\\n\\nuse sigma_ser::vlq_encode;\\n\\nuse std::io;\\n\\n\\n\\nuse super::context_extension::ContextExtension;\\n\\n#[cfg(feature = \\\"with-serde\\\")]\\n\\nuse serde::{Deserialize, Serialize};\\n\\n\\n\\n/// Proof of correctness of tx spending\\n\\n#[derive(Debug, PartialEq, Eq, Clone)]\\n\\n#[cfg_attr(feature = \\\"with-serde\\\", derive(Serialize, Deserialize))]\\n\\npub struct ProverResult {\\n\\n /// proof that satisfies final sigma proposition\\n\\n #[cfg_attr(feature = \\\"with-serde\\\", serde(rename = \\\"proofBytes\\\"))]\\n\\n pub proof: Vec