msm-webgpu 0.1.0

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

use ff::PrimeField;

pub fn field_to_bytes_montgomery<F: PrimeField>(value: &F) -> Vec<u8> {
    let s_bytes = value.to_montgomery_repr();
    let s_bytes_ref = s_bytes.as_ref();
    s_bytes_ref.to_vec()
}

pub fn bytes_to_field_montgomery<F: PrimeField>(bytes: &[u8]) -> F {
    let mut repr = F::Repr::default();
    repr.as_mut()[..bytes.len()].copy_from_slice(bytes);
    F::from_montgomery_repr(repr).unwrap()
}

pub fn fields_to_u16_vec_montgomery<F: PrimeField>(fields: &[F]) -> Vec<u16> {
    fields
        .iter()
        .map(|field| field_to_u16_vec_montgomery(field))
        .flatten()
        .collect()
}

pub fn field_to_u16_vec_montgomery<F: PrimeField>(field: &F) -> Vec<u16> {
    let bytes = field_to_bytes_montgomery(field);
    let mut u16_vec = Vec::new();

    for chunk in bytes.chunks_exact(2) {
        u16_vec.push(u16::from_le_bytes(chunk.try_into().unwrap()));
    }

    u16_vec
}

pub fn field_to_u16_as_u32_as_u8_vec_montgomery<F: PrimeField>(field: &F) -> Vec<u8> {
    let bytes = field_to_bytes_montgomery(field);
    assert!(bytes.len() % 2 == 0);
    
    let mut output = Vec::with_capacity((bytes.len() / 2) * 4); // each u16 → u32 → 4 bytes

    for chunk in bytes.chunks_exact(2) {
        let val = u16::from_le_bytes([chunk[0], chunk[1]]) as u32;
        output.extend_from_slice(&val.to_le_bytes());
    }

    output
}

pub fn u16_vec_to_fields_montgomery<F: PrimeField>(u16_array: &[u16]) -> Vec<F> {
    u16_array
        .chunks_exact(16) // Each field element is 16 u16s (16 * 16 bits)
        .map(|chunk| {
            let bytes = chunk
                .iter()
                .flat_map(|x| x.to_le_bytes())
                .collect::<Vec<u8>>();
            bytes_to_field_montgomery::<F>(&bytes)
        })
        .collect()
}

pub fn fields_to_u32_vec_montgomery<F: PrimeField>(fields: &[F]) -> Vec<u32> {
    fields
        .iter()
        .map(|field| field_to_u32_vec_montgomery(field))
        .flatten()
        .collect()
}

pub fn field_to_u32_vec_montgomery<F: PrimeField>(field: &F) -> Vec<u32> {
    let bytes = field_to_bytes_montgomery(field);
    let mut u32_vec = Vec::new();

    for chunk in bytes.chunks_exact(4) {
        u32_vec.push(u32::from_le_bytes(chunk.try_into().unwrap()));
    }

    u32_vec
}

pub fn u32_vec_to_fields_montgomery<F: PrimeField>(u32_array: &[u32]) -> Vec<F> {
    u32_array
        .chunks_exact(8) // Each field element is 8 u32s (8 * 32 bits)
        .map(|chunk| {
            let bytes = chunk
                .iter()
                .flat_map(|x| x.to_le_bytes())
                .collect::<Vec<u8>>();
            println!("bytes: {:?}", bytes);
            bytes_to_field_montgomery::<F>(&bytes)
        })
        .collect()
}


#[cfg(test)]
mod tests {
    use super::*;
    use ff::Field;
    use halo2curves::bn256::Fq;

    #[test]
    fn test_field_to_bytes_montgomery() {
        let field = Fq::random(rand::thread_rng());
        let bytes = field_to_bytes_montgomery(&field);
        assert_eq!(bytes.len(), 32);
        let field_from_bytes = bytes_to_field_montgomery::<Fq>(&bytes);
        assert_eq!(field, field_from_bytes);
    }
    #[test]
    fn test_fields_to_u16_vec_montgomery() {
        let fields: Vec<Fq> = vec![Fq::from(1), Fq::from(2), Fq::from(3)];
        let u16_vec = fields_to_u16_vec_montgomery(&fields);
        println!("u16_vec: {:?}", u16_vec);
        let new_fields = u16_vec_to_fields_montgomery(&u16_vec);
        assert_eq!(fields, new_fields);
    }

    #[test]
    fn test_fields_to_u32_vec_montgomery() {
        let fields: Vec<Fq> = vec![Fq::from(1), Fq::from(2), Fq::from(3)];
        let u32_vec = fields_to_u32_vec_montgomery(&fields);
        println!("u32_vec: {:?}", u32_vec);
        let new_fields = u32_vec_to_fields_montgomery(&u32_vec);
        assert_eq!(fields, new_fields);
    }

}