github.com/consensys/gnark@v0.11.0/backend/plonk/bls12-381/marshal.go (about) 1 // Copyright 2020 ConsenSys Software Inc. 2 // 3 // Licensed under the Apache License, Version 2.0 (the "License"); 4 // you may not use this file except in compliance with the License. 5 // You may obtain a copy of the License at 6 // 7 // http://www.apache.org/licenses/LICENSE-2.0 8 // 9 // Unless required by applicable law or agreed to in writing, software 10 // distributed under the License is distributed on an "AS IS" BASIS, 11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 // See the License for the specific language governing permissions and 13 // limitations under the License. 14 15 // Code generated by gnark DO NOT EDIT 16 17 package plonk 18 19 import ( 20 curve "github.com/consensys/gnark-crypto/ecc/bls12-381" 21 22 "github.com/consensys/gnark-crypto/ecc/bls12-381/kzg" 23 "io" 24 ) 25 26 // WriteRawTo writes binary encoding of Proof to w without point compression 27 func (proof *Proof) WriteRawTo(w io.Writer) (int64, error) { 28 return proof.writeTo(w, curve.RawEncoding()) 29 } 30 31 // WriteTo writes binary encoding of Proof to w with point compression 32 func (proof *Proof) WriteTo(w io.Writer) (int64, error) { 33 return proof.writeTo(w) 34 } 35 36 func (proof *Proof) writeTo(w io.Writer, options ...func(*curve.Encoder)) (int64, error) { 37 enc := curve.NewEncoder(w, options...) 38 39 toEncode := []interface{}{ 40 &proof.LRO[0], 41 &proof.LRO[1], 42 &proof.LRO[2], 43 &proof.Z, 44 &proof.H[0], 45 &proof.H[1], 46 &proof.H[2], 47 &proof.BatchedProof.H, 48 proof.BatchedProof.ClaimedValues, 49 &proof.ZShiftedOpening.H, 50 &proof.ZShiftedOpening.ClaimedValue, 51 proof.Bsb22Commitments, 52 } 53 54 for _, v := range toEncode { 55 if err := enc.Encode(v); err != nil { 56 return enc.BytesWritten(), err 57 } 58 } 59 60 return enc.BytesWritten(), nil 61 } 62 63 // ReadFrom reads binary representation of Proof from r 64 func (proof *Proof) ReadFrom(r io.Reader) (int64, error) { 65 dec := curve.NewDecoder(r) 66 toDecode := []interface{}{ 67 &proof.LRO[0], 68 &proof.LRO[1], 69 &proof.LRO[2], 70 &proof.Z, 71 &proof.H[0], 72 &proof.H[1], 73 &proof.H[2], 74 &proof.BatchedProof.H, 75 &proof.BatchedProof.ClaimedValues, 76 &proof.ZShiftedOpening.H, 77 &proof.ZShiftedOpening.ClaimedValue, 78 &proof.Bsb22Commitments, 79 } 80 81 for _, v := range toDecode { 82 if err := dec.Decode(v); err != nil { 83 return dec.BytesRead(), err 84 } 85 } 86 87 if proof.Bsb22Commitments == nil { 88 proof.Bsb22Commitments = []kzg.Digest{} 89 } 90 91 return dec.BytesRead(), nil 92 } 93 94 // WriteTo writes binary encoding of ProvingKey to w 95 func (pk *ProvingKey) WriteTo(w io.Writer) (n int64, err error) { 96 return pk.writeTo(w, true) 97 } 98 99 // WriteRawTo writes binary encoding of ProvingKey to w without point compression 100 func (pk *ProvingKey) WriteRawTo(w io.Writer) (n int64, err error) { 101 return pk.writeTo(w, false) 102 } 103 104 func (pk *ProvingKey) writeTo(w io.Writer, withCompression bool) (n int64, err error) { 105 // encode the verifying key 106 if withCompression { 107 n, err = pk.Vk.WriteTo(w) 108 } else { 109 n, err = pk.Vk.WriteRawTo(w) 110 } 111 if err != nil { 112 return 113 } 114 115 var n2 int64 116 // KZG key 117 if withCompression { 118 n2, err = pk.Kzg.WriteTo(w) 119 } else { 120 n2, err = pk.Kzg.WriteRawTo(w) 121 } 122 if err != nil { 123 return 124 } 125 n += n2 126 if withCompression { 127 n2, err = pk.KzgLagrange.WriteTo(w) 128 } else { 129 n2, err = pk.KzgLagrange.WriteRawTo(w) 130 } 131 if err != nil { 132 return 133 } 134 n += n2 135 136 return n, nil 137 } 138 139 // ReadFrom reads from binary representation in r into ProvingKey 140 func (pk *ProvingKey) ReadFrom(r io.Reader) (int64, error) { 141 return pk.readFrom(r, true) 142 } 143 144 // UnsafeReadFrom reads from binary representation in r into ProvingKey without subgroup checks 145 func (pk *ProvingKey) UnsafeReadFrom(r io.Reader) (int64, error) { 146 return pk.readFrom(r, false) 147 } 148 149 func (pk *ProvingKey) readFrom(r io.Reader, withSubgroupChecks bool) (int64, error) { 150 pk.Vk = &VerifyingKey{} 151 n, err := pk.Vk.ReadFrom(r) 152 if err != nil { 153 return n, err 154 } 155 156 var n2 int64 157 if withSubgroupChecks { 158 n2, err = pk.Kzg.ReadFrom(r) 159 } else { 160 n2, err = pk.Kzg.UnsafeReadFrom(r) 161 } 162 n += n2 163 if err != nil { 164 return n, err 165 } 166 if withSubgroupChecks { 167 n2, err = pk.KzgLagrange.ReadFrom(r) 168 } else { 169 n2, err = pk.KzgLagrange.UnsafeReadFrom(r) 170 } 171 n += n2 172 return n, err 173 } 174 175 // WriteTo writes binary encoding of VerifyingKey to w 176 func (vk *VerifyingKey) WriteTo(w io.Writer) (n int64, err error) { 177 return vk.writeTo(w) 178 } 179 180 // WriteRawTo writes binary encoding of VerifyingKey to w without point compression 181 func (vk *VerifyingKey) WriteRawTo(w io.Writer) (int64, error) { 182 return vk.writeTo(w, curve.RawEncoding()) 183 } 184 185 func (vk *VerifyingKey) writeTo(w io.Writer, options ...func(*curve.Encoder)) (n int64, err error) { 186 enc := curve.NewEncoder(w) 187 188 toEncode := []interface{}{ 189 vk.Size, 190 &vk.SizeInv, 191 &vk.Generator, 192 vk.NbPublicVariables, 193 &vk.CosetShift, 194 &vk.S[0], 195 &vk.S[1], 196 &vk.S[2], 197 &vk.Ql, 198 &vk.Qr, 199 &vk.Qm, 200 &vk.Qo, 201 &vk.Qk, 202 vk.Qcp, 203 &vk.Kzg.G1, 204 &vk.Kzg.G2[0], 205 &vk.Kzg.G2[1], 206 &vk.Kzg.Lines, 207 vk.CommitmentConstraintIndexes, 208 } 209 210 for _, v := range toEncode { 211 if err := enc.Encode(v); err != nil { 212 return enc.BytesWritten(), err 213 } 214 } 215 216 return enc.BytesWritten(), nil 217 } 218 219 // UnsafeReadFrom reads from binary representation in r into VerifyingKey. 220 // Current implementation is a passthrough to ReadFrom 221 func (vk *VerifyingKey) UnsafeReadFrom(r io.Reader) (int64, error) { 222 return vk.ReadFrom(r) 223 } 224 225 // ReadFrom reads from binary representation in r into VerifyingKey 226 func (vk *VerifyingKey) ReadFrom(r io.Reader) (int64, error) { 227 dec := curve.NewDecoder(r) 228 toDecode := []interface{}{ 229 &vk.Size, 230 &vk.SizeInv, 231 &vk.Generator, 232 &vk.NbPublicVariables, 233 &vk.CosetShift, 234 &vk.S[0], 235 &vk.S[1], 236 &vk.S[2], 237 &vk.Ql, 238 &vk.Qr, 239 &vk.Qm, 240 &vk.Qo, 241 &vk.Qk, 242 &vk.Qcp, 243 &vk.Kzg.G1, 244 &vk.Kzg.G2[0], 245 &vk.Kzg.G2[1], 246 &vk.Kzg.Lines, 247 &vk.CommitmentConstraintIndexes, 248 } 249 250 for _, v := range toDecode { 251 if err := dec.Decode(v); err != nil { 252 return dec.BytesRead(), err 253 } 254 } 255 256 if vk.Qcp == nil { 257 vk.Qcp = []kzg.Digest{} 258 } 259 260 return dec.BytesRead(), nil 261 }