github.com/consensys/gnark@v0.11.0/internal/generator/backend/template/zkpschemes/groth16/mpcsetup/marshal.go.tmpl (about)

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