github.com/consensys/gnark@v0.11.0/backend/groth16/bn254/mpcsetup/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 mpcsetup
    18  
    19  import (
    20  	curve "github.com/consensys/gnark-crypto/ecc/bn254"
    21  	"io"
    22  )
    23  
    24  // WriteTo implements io.WriterTo
    25  func (phase1 *Phase1) WriteTo(writer io.Writer) (int64, error) {
    26  	n, err := phase1.writeTo(writer)
    27  	if err != nil {
    28  		return n, err
    29  	}
    30  	nBytes, err := writer.Write(phase1.Hash)
    31  	return int64(nBytes) + n, err
    32  }
    33  
    34  func (phase1 *Phase1) writeTo(writer io.Writer) (int64, error) {
    35  	toEncode := []interface{}{
    36  		&phase1.PublicKeys.Tau.SG,
    37  		&phase1.PublicKeys.Tau.SXG,
    38  		&phase1.PublicKeys.Tau.XR,
    39  		&phase1.PublicKeys.Alpha.SG,
    40  		&phase1.PublicKeys.Alpha.SXG,
    41  		&phase1.PublicKeys.Alpha.XR,
    42  		&phase1.PublicKeys.Beta.SG,
    43  		&phase1.PublicKeys.Beta.SXG,
    44  		&phase1.PublicKeys.Beta.XR,
    45  		phase1.Parameters.G1.Tau,
    46  		phase1.Parameters.G1.AlphaTau,
    47  		phase1.Parameters.G1.BetaTau,
    48  		phase1.Parameters.G2.Tau,
    49  		&phase1.Parameters.G2.Beta,
    50  	}
    51  
    52  	enc := curve.NewEncoder(writer)
    53  	for _, v := range toEncode {
    54  		if err := enc.Encode(v); err != nil {
    55  			return enc.BytesWritten(), err
    56  		}
    57  	}
    58  	return enc.BytesWritten(), nil
    59  }
    60  
    61  // ReadFrom implements io.ReaderFrom
    62  func (phase1 *Phase1) ReadFrom(reader io.Reader) (int64, error) {
    63  	toEncode := []interface{}{
    64  		&phase1.PublicKeys.Tau.SG,
    65  		&phase1.PublicKeys.Tau.SXG,
    66  		&phase1.PublicKeys.Tau.XR,
    67  		&phase1.PublicKeys.Alpha.SG,
    68  		&phase1.PublicKeys.Alpha.SXG,
    69  		&phase1.PublicKeys.Alpha.XR,
    70  		&phase1.PublicKeys.Beta.SG,
    71  		&phase1.PublicKeys.Beta.SXG,
    72  		&phase1.PublicKeys.Beta.XR,
    73  		&phase1.Parameters.G1.Tau,
    74  		&phase1.Parameters.G1.AlphaTau,
    75  		&phase1.Parameters.G1.BetaTau,
    76  		&phase1.Parameters.G2.Tau,
    77  		&phase1.Parameters.G2.Beta,
    78  	}
    79  
    80  	dec := curve.NewDecoder(reader)
    81  	for _, v := range toEncode {
    82  		if err := dec.Decode(v); err != nil {
    83  			return dec.BytesRead(), err
    84  		}
    85  	}
    86  	phase1.Hash = make([]byte, 32)
    87  	nBytes, err := reader.Read(phase1.Hash)
    88  	return dec.BytesRead() + int64(nBytes), err
    89  }
    90  
    91  // WriteTo implements io.WriterTo
    92  func (phase2 *Phase2) WriteTo(writer io.Writer) (int64, error) {
    93  	n, err := phase2.writeTo(writer)
    94  	if err != nil {
    95  		return n, err
    96  	}
    97  	nBytes, err := writer.Write(phase2.Hash)
    98  	return int64(nBytes) + n, err
    99  }
   100  
   101  func (c *Phase2) writeTo(writer io.Writer) (int64, error) {
   102  	enc := curve.NewEncoder(writer)
   103  	toEncode := []interface{}{
   104  		&c.PublicKey.SG,
   105  		&c.PublicKey.SXG,
   106  		&c.PublicKey.XR,
   107  		&c.Parameters.G1.Delta,
   108  		c.Parameters.G1.L,
   109  		c.Parameters.G1.Z,
   110  		&c.Parameters.G2.Delta,
   111  	}
   112  
   113  	for _, v := range toEncode {
   114  		if err := enc.Encode(v); err != nil {
   115  			return enc.BytesWritten(), err
   116  		}
   117  	}
   118  
   119  	return enc.BytesWritten(), nil
   120  }
   121  
   122  // ReadFrom implements io.ReaderFrom
   123  func (c *Phase2) ReadFrom(reader io.Reader) (int64, error) {
   124  	dec := curve.NewDecoder(reader)
   125  	toEncode := []interface{}{
   126  		&c.PublicKey.SG,
   127  		&c.PublicKey.SXG,
   128  		&c.PublicKey.XR,
   129  		&c.Parameters.G1.Delta,
   130  		&c.Parameters.G1.L,
   131  		&c.Parameters.G1.Z,
   132  		&c.Parameters.G2.Delta,
   133  	}
   134  
   135  	for _, v := range toEncode {
   136  		if err := dec.Decode(v); err != nil {
   137  			return dec.BytesRead(), err
   138  		}
   139  	}
   140  
   141  	c.Hash = make([]byte, 32)
   142  	n, err := reader.Read(c.Hash)
   143  	return int64(n) + dec.BytesRead(), err
   144  
   145  }
   146  
   147  // WriteTo implements io.WriterTo
   148  func (c *Phase2Evaluations) WriteTo(writer io.Writer) (int64, error) {
   149  	enc := curve.NewEncoder(writer)
   150  	toEncode := []interface{}{
   151  		c.G1.A,
   152  		c.G1.B,
   153  		c.G2.B,
   154  	}
   155  
   156  	for _, v := range toEncode {
   157  		if err := enc.Encode(v); err != nil {
   158  			return enc.BytesWritten(), err
   159  		}
   160  	}
   161  
   162  	return enc.BytesWritten(), nil
   163  }
   164  
   165  // ReadFrom implements io.ReaderFrom
   166  func (c *Phase2Evaluations) ReadFrom(reader io.Reader) (int64, error) {
   167  	dec := curve.NewDecoder(reader)
   168  	toEncode := []interface{}{
   169  		&c.G1.A,
   170  		&c.G1.B,
   171  		&c.G2.B,
   172  	}
   173  
   174  	for _, v := range toEncode {
   175  		if err := dec.Decode(v); err != nil {
   176  			return dec.BytesRead(), err
   177  		}
   178  	}
   179  
   180  	return dec.BytesRead(), nil
   181  }