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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

use ff::PrimeField;


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

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

// ------------------------------------------------------------------------------------------------
// u16
// ------------------------------------------------------------------------------------------------

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

pub fn field_to_u16_vec<F: PrimeField>(field: &F) -> Vec<u16> {
    let bytes = field_to_bytes(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<F: PrimeField>(field: &F) -> Vec<u8> {
    let bytes = field_to_bytes(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<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::<F>(&bytes)
        })
        .collect()
}

pub fn cast_u8_to_u16(u8_array: &[u8]) -> Vec<u16> {
    let u32_slice: &[u32] = bytemuck::cast_slice(u8_array);
    u32_slice.iter().map(|&x| x as u16).collect()
}

// ------------------------------------------------------------------------------------------------
// u32
// ------------------------------------------------------------------------------------------------

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

pub fn field_to_u32_vec<F: PrimeField>(field: &F) -> Vec<u32> {
    let bytes = field_to_bytes(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<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::<F>(&bytes)
        })
        .collect()
}

pub fn cast_u8_to_u32(u8_array: &[u8]) -> Vec<u32> {
    bytemuck::cast_slice::<u8, u32>(u8_array).to_vec()
}



#[cfg(test)]
mod tests {
    use super::*;
    use ff::Field;
    use halo2curves::pasta::pallas::Scalar as Fr;

    #[test]
    fn test_field_to_bytes() {
        let field = Fr::random(rand::thread_rng());
        let bytes = field_to_bytes(&field);
        assert_eq!(bytes.len(), 32);
        let field_from_bytes = bytes_to_field::<Fr>(&bytes);
        assert_eq!(field, field_from_bytes);
    }

    #[test]
    fn test_fields_to_u16_vec() {
        let fields: Vec<Fr> = vec![Fr::from(1), Fr::from(2), Fr::from(3)];
        let u16_vec = fields_to_u16_vec(&fields);
        println!("u16_vec: {:?}", u16_vec);
        let new_fields = u16_vec_to_fields(&u16_vec);
        assert_eq!(fields, new_fields);
    }


    #[test]
    fn test_fields_to_u32_vec() {
        let fields: Vec<Fr> = vec![Fr::from(1), Fr::from(2), Fr::from(3)];
        let u32_vec = fields_to_u32_vec(&fields);
        println!("u32_vec: {:?}", u32_vec);
        let new_fields = u32_vec_to_fields(&u32_vec);
        assert_eq!(fields, new_fields);
    }

}