Poc 1 code review

.gitignore

@@ -0,0 +1,7 @@
+poet-ref
+.idea
+.DS_Store
+*.bin
+*.prof
+*.pdf
+*.test

README.md

@@ -1 +1,18 @@
 # poet-ref
+
+This is a private repo designed to create a refernce poet implementatkon for testing of the open source poet server.
+
+The goal is to dsitribute a binary 'blac box' go component of a verifier that can be used to verify proofs created by a prover.
+
+## Build
+
+```
+go get -u github.com/kardianos/govendor
+govendor sync
+go build
+```
+
+## Run the tests
+```
+go test ./...
+```

internal/bstring.go

@@ -0,0 +1,202 @@
+package internal
+
+import (
+	"crypto/rand"
+	"errors"
+	"math"
+	"math/big"
+	"strconv"
+)
+
+type SMBinaryStringFactory struct {
+	// cache map[uint64] map[uint]*SMBinaryString
+	// cache1 map[string] *SMBinaryString
+}
+
+func NewSMBinaryStringFactory() BinaryStringFactory {
+
+	return &SMBinaryStringFactory{
+		// make(map[uint64] map[uint]*SMBinaryString, 500),
+		// make(map[string]*SMBinaryString, 500),
+	}
+}
+
+type SMBinaryString struct {
+	v uint64 // stored value
+	d uint   // number of binary digits to display
+	f *SMBinaryStringFactory
+}
+
+// digits must be at least as large to represent v
+func (f *SMBinaryStringFactory) NewBinaryStringFromInt(v uint64, d uint) (BinaryString, error) {
+
+	// todo: only test in debug builds but not in production ones
+	/*
+		l := uint(bits.Len64(v))
+		if l > d {
+			return nil, errors.New("invalid digits. Digits must be large enough to represent v in bits")
+		}*/
+
+	res := &SMBinaryString{
+		v: v,
+		d: d,
+		f: f,
+	}
+
+	return res, nil
+}
+
+// Create a new BinaryString from a string of 0s and 1s, e.g. "00111"
+// Returns an error if s is not a valid binary string, e.g. it contains chars
+// other then 0 or 1
+// Any leading 0s will be included in the result
+func (f *SMBinaryStringFactory) NewBinaryString(s string) (BinaryString, error) {
+
+	var v uint64
+
+	if s != "" {
+		parsed, err := strconv.ParseUint(s, 2, 64)
+		if err != nil {
+			return nil, err
+		}
+		v = parsed
+	}
+
+	res := &SMBinaryString{
+		v: v,
+		d: uint(len(s)),
+		f: f,
+	}
+
+	return res, nil
+}
+
+// Create a new random d digits long BinaryString. e.g for digits = 4 "0110"
+// d <= 63
+func (f *SMBinaryStringFactory) NewRandomBinaryString(d uint) (BinaryString, error) {
+
+	if d > 63 {
+		return nil, errors.New("unsupported # of digits. must be less or equals to 64")
+	}
+
+	if d == 0 { // the only id with 0 digits is ""
+		return f.NewBinaryString("")
+	}
+
+	// generate a random number with d digits
+
+	// compute 2^d
+	max := uint64(math.Pow(2, float64(d)))
+	//max := uint64(math.Exp2(float64(d)))
+
+	maxBig := new(big.Int).SetUint64(max)
+
+	// max int with d digits is 2^d - 1. The following returns rnd in range [0...2^d-1]
+	rndBig, err := rand.Int(rand.Reader, maxBig)
+	if err != nil {
+		return nil, err
+	}
+
+	v := rndBig.Uint64()
+	return f.NewBinaryStringFromInt(v, d)
+}
+
+// returns list of siblings on the path from s the root assuming s is a node identifier in a full binary tree
+func (s *SMBinaryString) GetBNSiblings(leftOnly bool) ([]BinaryString, error) {
+
+	// slice of siblings
+	var res []BinaryString
+
+	if s.v == 0 && s.d == 0 { // special case - dag root node
+		return res, nil
+	}
+
+	// current node pointer
+	var nodeId BinaryString
+
+	// initial value
+	nodeId = s
+
+	for {
+
+		// append node's sibling to result
+		siblingNode, err := nodeId.FlipLSB()
+		if err != nil {
+			return nil, err
+		}
+
+		if !leftOnly || siblingNode.IsEven() {
+			// we add to results if caller didn't request leftOnly
+			// or she did and the sibling is a left sibling (LSB == '0')
+			res = append(res, siblingNode)
+		}
+
+		// println("Adding sibling: ", siblingNode.GetStringValue())
+
+		// continue with the node's parent node
+		nodeId, err = nodeId.TruncateLSB()
+
+		if err != nil {
+			return nil, err
+		}
+
+		if len(nodeId.GetStringValue()) == 0 {
+			break
+		}
+	}
+
+	if len(res) == 0 && !leftOnly {
+		return res, errors.New("expected one or more siblings on the path to root")
+	}
+
+	return res, nil
+}
+
+// Returns a new BinaryString with the LSB truncated. e.g. "0010" => "001"
+func (s *SMBinaryString) TruncateLSB() (BinaryString, error) {
+	return s.f.NewBinaryStringFromInt(s.v>>1, s.d-1)
+}
+
+// Flip LSB. e.g. "0010" => "0011"
+func (s *SMBinaryString) FlipLSB() (BinaryString, error) {
+	return s.f.NewBinaryStringFromInt(s.v^1, s.d)
+}
+
+// Get string representation. e.g. "00011"
+func (s *SMBinaryString) GetStringValue() string {
+
+	if s.d == 0 {
+		// special case - empty binary string
+		return ""
+	}
+
+	// binary string encoding of s.v without any leading 0s
+	res := strconv.FormatUint(s.v, 2)
+
+	// prepend any leading 0s if needed
+	n := s.d - uint(len(res))
+	for n > 0 {
+		res = "0" + res
+		n--
+	}
+
+	return res
+}
+
+// Get the binary value encoded in the string. e.g. 12
+func (s *SMBinaryString) GetValue() uint64 {
+	return s.v
+}
+
+func (s *SMBinaryString) IsEven() bool {
+	return s.v%2 == 0
+}
+
+func (s *SMBinaryString) IsOdd() bool {
+	return !s.IsEven()
+}
+
+// return number of digits including leading 0s if any
+func (s *SMBinaryString) GetDigitsCount() uint {
+	return s.d
+}

internal/bstring_test.go

@@ -0,0 +1,166 @@
+package internal
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func TestBTSiblingsBasic(t *testing.T) {
+
+	const d = "00010001011010010001100111000010010101101111111111101110000110"
+	f := NewSMBinaryStringFactory()
+	b, err := f.NewBinaryString(d)
+	assert.NoError(t, err)
+
+	siblings, err := b.GetBNSiblings(false)
+	assert.NoError(t, err)
+
+	// we have this nice invariant regarding the # of siblings
+	// related to the height of b (and the # of bits in its id)
+	assert.Equal(t, len(d), len(siblings))
+
+	for _, s := range siblings {
+		println(s.GetStringValue())
+	}
+}
+
+func TestBTSiblings(t *testing.T) {
+
+	const d = "0101"
+	var expectedResults = [4]string{"0100", "011", "00", "1"}
+
+	f := NewSMBinaryStringFactory()
+	b, err := f.NewBinaryString(d)
+	assert.NoError(t, err)
+
+	siblings, err := b.GetBNSiblings(false)
+	assert.NoError(t, err)
+
+	// we have this nice invariant regarding the # of siblings
+	// related to the height of b (and the # of bits in its id)
+	assert.Equal(t, len(d), len(siblings))
+
+	for idx, s := range siblings {
+		assert.Equal(t, expectedResults[idx], s.GetStringValue())
+	}
+}
+
+func TestBTLeftSiblings(t *testing.T) {
+
+	const d = "0101"
+	var expectedResults = [2]string{"0100", "00"}
+
+	f := NewSMBinaryStringFactory()
+	b, err := f.NewBinaryString(d)
+	assert.NoError(t, err)
+
+	siblings, err := b.GetBNSiblings(true)
+	assert.NoError(t, err)
+
+	assert.Equal(t, len(expectedResults), len(siblings))
+
+	for idx, s := range siblings {
+		println(s.GetStringValue())
+		assert.Equal(t, expectedResults[idx], s.GetStringValue())
+	}
+}
+
+func TestBinaryString(t *testing.T) {
+
+	const d = "00010001011010010001100111000010010101101111111111101110000110"
+	f := NewSMBinaryStringFactory()
+	b, err := f.NewBinaryString(d)
+
+	assert.NoError(t, err)
+	assert.Equal(t, uint(len(d)), b.GetDigitsCount())
+	assert.Equal(t, d, b.GetStringValue())
+}
+
+func TestFlipLSB(t *testing.T) {
+
+	const d = "101011100110000111110011101010101110111101000000001011110101110"
+	f := NewSMBinaryStringFactory()
+
+	b, err := f.NewBinaryString(d)
+	assert.NoError(t, err)
+
+	b1, err := b.FlipLSB()
+	assert.NoError(t, err)
+
+	s := b.GetStringValue()
+	s1 := b1.GetStringValue()
+	assert.NotEqual(t, s[len(s)-1], s1[len(s1)-1])
+}
+
+func TestTruncateLSB(t *testing.T) {
+
+	const d = "101011100110000111110011101010101110111101000000001011110101110"
+	f := NewSMBinaryStringFactory()
+
+	b, err := f.NewBinaryString(d)
+	assert.NoError(t, err)
+
+	b1, err := b.TruncateLSB()
+	assert.NoError(t, err)
+
+	s := b.GetStringValue()
+	s1 := b1.GetStringValue()
+	assert.Equal(t, len(s), len(s1)+1)
+
+	// reconstruct s by appending s[LSB] to s1 - the truncated string
+	s3 := s1 + s[len(s)-1:]
+	assert.Equal(t, s, s3)
+
+}
+
+func TestRandomBinaryString(t *testing.T) {
+	f := NewSMBinaryStringFactory()
+	for i := 0; i < 10000; i++ {
+		const d = uint(63)
+		b, err := f.NewRandomBinaryString(d)
+		assert.NoError(t, err)
+		assert.Equal(t, uint(d), b.GetDigitsCount())
+	}
+}
+
+func TestInvalidBinaryString(t *testing.T) {
+	f := NewSMBinaryStringFactory()
+	// try to create a binary string from an invalid string - contains chars other than 0 and 1
+	_, err := f.NewBinaryString("0102")
+	assert.Error(t, err)
+}
+
+/*
+func TestInvalidBinaryStringFromInt(t *testing.T) {
+	f := NewSMBinaryStringFactory()
+	// try to create from int with insufficient number of digits to encode int value to bits
+	_, err := f.NewBinaryStringFromInt(1025, 5)
+	assert.Error(t, err)
+}*/
+
+func TestBinaryStringFromInt(t *testing.T) {
+	f := NewSMBinaryStringFactory()
+
+	// 126 decimal is 1111101, requiring 7 binary digits
+	v := uint64(125)
+
+	b, err := f.NewBinaryStringFromInt(v, 7)
+	assert.NoError(t, err)
+	//println(b.GetStringValue())
+	assert.Equal(t, uint(7), b.GetDigitsCount())
+	assert.Equal(t, v, b.GetValue())
+
+	// encode to an 8 bits binary string
+	b, err = f.NewBinaryStringFromInt(v, 8)
+	assert.NoError(t, err)
+	//println(b.GetStringValue())
+	assert.Equal(t, uint(8), b.GetDigitsCount())
+	assert.Equal(t, v, b.GetValue())
+
+	// encode to a 63 bits binary string
+	b, err = f.NewBinaryStringFromInt(v, 63)
+	assert.NoError(t, err)
+	//println(b.GetStringValue())
+	assert.Equal(t, uint(63), b.GetDigitsCount())
+	assert.Equal(t, v, b.GetValue())
+}