mirror of
				https://source.quilibrium.com/quilibrium/ceremonyclient.git
				synced 2025-11-04 14:47:26 +00:00 
			
		
		
		
	
		
			
				
	
	
		
			137 lines
		
	
	
		
			2.9 KiB
		
	
	
	
		
			Go
		
	
	
	
	
	
			
		
		
	
	
			137 lines
		
	
	
		
			2.9 KiB
		
	
	
	
		
			Go
		
	
	
	
	
	
//
 | 
						|
// Copyright Coinbase, Inc. All Rights Reserved.
 | 
						|
//
 | 
						|
// SPDX-License-Identifier: Apache-2.0
 | 
						|
//
 | 
						|
 | 
						|
package mina
 | 
						|
 | 
						|
import (
 | 
						|
	"source.quilibrium.com/quilibrium/monorepo/nekryptology/pkg/core/curves/native/pasta/fp"
 | 
						|
	"source.quilibrium.com/quilibrium/monorepo/nekryptology/pkg/core/curves/native/pasta/fq"
 | 
						|
)
 | 
						|
 | 
						|
// Handles the packing of bits and fields according to Mina spec
 | 
						|
type roinput struct {
 | 
						|
	fields []*fp.Fp
 | 
						|
	bits   *BitVector
 | 
						|
}
 | 
						|
 | 
						|
var conv = map[bool]int{
 | 
						|
	true:  1,
 | 
						|
	false: 0,
 | 
						|
}
 | 
						|
 | 
						|
func (r *roinput) Init(fields int, bytes int) *roinput {
 | 
						|
	r.fields = make([]*fp.Fp, 0, fields)
 | 
						|
	r.bits = NewBitVector(make([]byte, bytes), 0)
 | 
						|
	return r
 | 
						|
}
 | 
						|
 | 
						|
func (r *roinput) Clone() *roinput {
 | 
						|
	t := new(roinput)
 | 
						|
	t.fields = make([]*fp.Fp, len(r.fields))
 | 
						|
	for i, f := range r.fields {
 | 
						|
		t.fields[i] = new(fp.Fp).Set(f)
 | 
						|
	}
 | 
						|
	buffer := r.bits.Bytes()
 | 
						|
	data := make([]byte, len(buffer))
 | 
						|
	copy(data, buffer)
 | 
						|
	t.bits = NewBitVector(data, r.bits.Length())
 | 
						|
	return t
 | 
						|
}
 | 
						|
 | 
						|
func (r *roinput) AddFp(fp *fp.Fp) {
 | 
						|
	r.fields = append(r.fields, fp)
 | 
						|
}
 | 
						|
 | 
						|
func (r *roinput) AddFq(fq *fq.Fq) {
 | 
						|
	scalar := fq.ToRaw()
 | 
						|
	// Mina handles fields as 255 bit numbers
 | 
						|
	// with each field we lose a bit
 | 
						|
	for i := 0; i < 255; i++ {
 | 
						|
		limb := i / 64
 | 
						|
		idx := i % 64
 | 
						|
		b := (scalar[limb] >> idx) & 1
 | 
						|
		r.bits.Append(byte(b))
 | 
						|
	}
 | 
						|
}
 | 
						|
 | 
						|
func (r *roinput) AddBit(b bool) {
 | 
						|
	r.bits.Append(byte(conv[b]))
 | 
						|
}
 | 
						|
 | 
						|
func (r *roinput) AddBytes(input []byte) {
 | 
						|
	for _, b := range input {
 | 
						|
		for i := 0; i < 8; i++ {
 | 
						|
			r.bits.Append(byte((b >> i) & 1))
 | 
						|
		}
 | 
						|
	}
 | 
						|
}
 | 
						|
 | 
						|
func (r *roinput) AddUint32(x uint32) {
 | 
						|
	for i := 0; i < 32; i++ {
 | 
						|
		r.bits.Append(byte((x >> i) & 1))
 | 
						|
	}
 | 
						|
}
 | 
						|
 | 
						|
func (r *roinput) AddUint64(x uint64) {
 | 
						|
	for i := 0; i < 64; i++ {
 | 
						|
		r.bits.Append(byte((x >> i) & 1))
 | 
						|
	}
 | 
						|
}
 | 
						|
 | 
						|
func (r roinput) Bytes() []byte {
 | 
						|
	out := make([]byte, (r.bits.Length()+7)/8+32*len(r.fields))
 | 
						|
	res := NewBitVector(out, 0)
 | 
						|
	// Mina handles fields as 255 bit numbers
 | 
						|
	// with each field we lose a bit
 | 
						|
	for _, f := range r.fields {
 | 
						|
		buf := f.ToRaw()
 | 
						|
		for i := 0; i < 255; i++ {
 | 
						|
			limb := i / 64
 | 
						|
			idx := i % 64
 | 
						|
			b := (buf[limb] >> idx) & 1
 | 
						|
			res.Append(byte(b))
 | 
						|
		}
 | 
						|
	}
 | 
						|
	for i := 0; i < r.bits.Length(); i++ {
 | 
						|
		res.Append(r.bits.Element(i))
 | 
						|
	}
 | 
						|
	return out
 | 
						|
}
 | 
						|
 | 
						|
func (r roinput) Fields() []*fp.Fp {
 | 
						|
	fields := make([]*fp.Fp, 0, len(r.fields)+r.bits.Length()/256)
 | 
						|
	for _, f := range r.fields {
 | 
						|
		fields = append(fields, new(fp.Fp).Set(f))
 | 
						|
	}
 | 
						|
	const maxChunkSize = 254
 | 
						|
	bitsConsumed := 0
 | 
						|
	bitIdx := 0
 | 
						|
 | 
						|
	for bitsConsumed < r.bits.Length() {
 | 
						|
		var chunk [4]uint64
 | 
						|
 | 
						|
		remaining := r.bits.Length() - bitsConsumed
 | 
						|
		var chunkSizeInBits int
 | 
						|
		if remaining > maxChunkSize {
 | 
						|
			chunkSizeInBits = maxChunkSize
 | 
						|
		} else {
 | 
						|
			chunkSizeInBits = remaining
 | 
						|
		}
 | 
						|
 | 
						|
		for i := 0; i < chunkSizeInBits; i++ {
 | 
						|
			limb := i >> 6
 | 
						|
			idx := i & 0x3F
 | 
						|
			b := r.bits.Element(bitIdx)
 | 
						|
			chunk[limb] |= uint64(b) << idx
 | 
						|
			bitIdx++
 | 
						|
		}
 | 
						|
		fields = append(fields, new(fp.Fp).SetRaw(&chunk))
 | 
						|
		bitsConsumed += chunkSizeInBits
 | 
						|
	}
 | 
						|
 | 
						|
	return fields
 | 
						|
}
 |