mirror of
				https://source.quilibrium.com/quilibrium/ceremonyclient.git
				synced 2025-04-04 19:36:54 +00:00 
			
		
		
		
	v1.2.6 (#47)
This commit is contained in:
		
							parent
							
								
									ac5c393745
								
							
						
					
					
						commit
						d499a60937
					
				| @ -886,11 +886,11 @@ func logoVersion(width int) string { | ||||
| 		out += "                     #######################################        ########\n" | ||||
| 		out += "                          #############################                ##\n" | ||||
| 		out += " \n" | ||||
| 		out += "                         Quilibrium Node - v1.2.5 – Dawn\n" | ||||
| 		out += "                         Quilibrium Node - v1.2.6 – Dawn\n" | ||||
| 		out += " \n" | ||||
| 		out += "                                   DB Console\n" | ||||
| 	} else { | ||||
| 		out = "Quilibrium Node - v1.2.5 – Dawn - DB Console\n" | ||||
| 		out = "Quilibrium Node - v1.2.6 – Dawn - DB Console\n" | ||||
| 	} | ||||
| 	return out | ||||
| } | ||||
|  | ||||
| @ -201,15 +201,12 @@ func (e *CeremonyDataClockConsensusEngine) sync( | ||||
| 		from = 1 | ||||
| 	} | ||||
| 
 | ||||
| 	if maxFrame > from && maxFrame > 3 { | ||||
| 		from = maxFrame - 2 | ||||
| 	} | ||||
| 
 | ||||
| 	s, err := client.GetCompressedSyncFrames( | ||||
| 		context.Background(), | ||||
| 		&protobufs.ClockFramesRequest{ | ||||
| 			Filter:          e.filter, | ||||
| 			FromFrameNumber: from, | ||||
| 			ToFrameNumber:   from + 8, | ||||
| 		}, | ||||
| 		grpc.MaxCallRecvMsgSize(600*1024*1024), | ||||
| 	) | ||||
|  | ||||
| @ -59,5 +59,5 @@ func GetMinimumVersion() []byte { | ||||
| } | ||||
| 
 | ||||
| func GetVersion() []byte { | ||||
| 	return []byte{0x01, 0x02, 0x05} | ||||
| 	return []byte{0x01, 0x02, 0x06} | ||||
| } | ||||
|  | ||||
| @ -238,8 +238,15 @@ func (d *DataTimeReel) runLoop() { | ||||
| 					continue | ||||
| 				} | ||||
| 
 | ||||
| 				// If the frame has a gap from the head, mark it as pending:
 | ||||
| 				if frame.FrameNumber-d.head.FrameNumber != 1 { | ||||
| 				headSelector, err := d.head.GetSelector() | ||||
| 				if err != nil { | ||||
| 					panic(err) | ||||
| 				} | ||||
| 
 | ||||
| 				// If the frame has a gap from the head or is not descendent, mark it as
 | ||||
| 				// pending:
 | ||||
| 				if frame.FrameNumber-d.head.FrameNumber != 1 || | ||||
| 					parent.Cmp(headSelector) != 0 { | ||||
| 					d.addPending(selector, parent, distance, frame) | ||||
| 					continue | ||||
| 				} | ||||
| @ -264,10 +271,13 @@ func (d *DataTimeReel) runLoop() { | ||||
| 					distance.Cmp(d.headDistance) < 0 { | ||||
| 					d.totalDistance.Sub(d.totalDistance, d.headDistance) | ||||
| 					d.setHead(frame, distance) | ||||
| 					d.processPending(d.head) | ||||
| 					continue | ||||
| 				} | ||||
| 
 | ||||
| 				// Choose fork
 | ||||
| 				d.forkChoice(frame, distance) | ||||
| 				d.processPending(d.head) | ||||
| 			} else { | ||||
| 				// tag: dusk – we should have some kind of check here to avoid brutal
 | ||||
| 				// thrashing
 | ||||
| @ -359,7 +369,6 @@ func (d *DataTimeReel) processPending(frame *protobufs.ClockFrame) { | ||||
| 			d.pending[frame.FrameNumber][1:] | ||||
| 		if len(d.pending[frame.FrameNumber]) == 0 { | ||||
| 			delete(d.pending, frame.FrameNumber) | ||||
| 			break | ||||
| 		} | ||||
| 
 | ||||
| 		nextFrame, err := d.clockStore.GetCandidateDataClockFrame( | ||||
| @ -380,6 +389,7 @@ func (d *DataTimeReel) processPending(frame *protobufs.ClockFrame) { | ||||
| 		neighborPending, ok = d.pending[frame.FrameNumber] | ||||
| 	} | ||||
| 
 | ||||
| 	above := false | ||||
| 	if !neighbors { | ||||
| 		// Pull the next
 | ||||
| 		nextPending, ok := d.pending[frame.FrameNumber+1] | ||||
| @ -400,6 +410,44 @@ func (d *DataTimeReel) processPending(frame *protobufs.ClockFrame) { | ||||
| 			if err != nil && !errors.Is(err, store.ErrNotFound) { | ||||
| 				panic(err) | ||||
| 			} | ||||
| 			if nextFrame != nil { | ||||
| 				above = true | ||||
| 				go func() { | ||||
| 					d.frames <- nextFrame | ||||
| 				}() | ||||
| 			} | ||||
| 		} | ||||
| 	} | ||||
| 
 | ||||
| 	if !above { | ||||
| 		// Pull below
 | ||||
| 		min := frame.FrameNumber | ||||
| 		for k := range d.pending { | ||||
| 			if k < min { | ||||
| 				min = k | ||||
| 			} | ||||
| 		} | ||||
| 		if min == frame.FrameNumber { | ||||
| 			return | ||||
| 		} | ||||
| 		nextPending, ok := d.pending[min] | ||||
| 		if ok { | ||||
| 			next := nextPending[0] | ||||
| 			d.pending[min] = | ||||
| 				d.pending[min][1:] | ||||
| 			if len(d.pending[min]) == 0 { | ||||
| 				delete(d.pending, min) | ||||
| 			} | ||||
| 
 | ||||
| 			nextFrame, err := d.clockStore.GetCandidateDataClockFrame( | ||||
| 				d.filter, | ||||
| 				min, | ||||
| 				next.parentSelector.FillBytes(make([]byte, 32)), | ||||
| 				next.distance.FillBytes(make([]byte, 32)), | ||||
| 			) | ||||
| 			if err != nil && !errors.Is(err, store.ErrNotFound) { | ||||
| 				panic(err) | ||||
| 			} | ||||
| 			if nextFrame != nil { | ||||
| 				go func() { | ||||
| 					d.frames <- nextFrame | ||||
| @ -509,7 +557,7 @@ func (d *DataTimeReel) forkChoice( | ||||
| 	left := d.head.ParentSelector | ||||
| 	right := frame.ParentSelector | ||||
| 
 | ||||
| 	rightReplaySelectors := [][]byte{selector.FillBytes(make([]byte, 32))} | ||||
| 	rightReplaySelectors := [][]byte{} | ||||
| 
 | ||||
| 	// Walk backwards through the parents, until we find a matching parent
 | ||||
| 	// selector:
 | ||||
| @ -561,6 +609,8 @@ func (d *DataTimeReel) forkChoice( | ||||
| 		rightTotal.Add(rightTotal, rightIndexDistance) | ||||
| 	} | ||||
| 
 | ||||
| 	frameNumber := rightIndex.FrameNumber | ||||
| 
 | ||||
| 	// Choose new fork based on lightest distance sub-tree
 | ||||
| 	if rightTotal.Cmp(leftTotal) < 0 { | ||||
| 		for { | ||||
| @ -568,12 +618,12 @@ func (d *DataTimeReel) forkChoice( | ||||
| 				break | ||||
| 			} | ||||
| 			next := rightReplaySelectors[0] | ||||
| 			rightReplaySelectors[frame.FrameNumber] = | ||||
| 				rightReplaySelectors[frame.FrameNumber][1:] | ||||
| 			rightReplaySelectors = | ||||
| 				rightReplaySelectors[1:] | ||||
| 
 | ||||
| 			rightIndex, err = d.clockStore.GetParentDataClockFrame( | ||||
| 				d.filter, | ||||
| 				rightIndex.FrameNumber+1, | ||||
| 				frameNumber, | ||||
| 				next, | ||||
| 			) | ||||
| 			if err != nil { | ||||
| @ -597,6 +647,26 @@ func (d *DataTimeReel) forkChoice( | ||||
| 			if err = txn.Commit(); err != nil { | ||||
| 				panic(err) | ||||
| 			} | ||||
| 
 | ||||
| 			frameNumber++ | ||||
| 		} | ||||
| 
 | ||||
| 		txn, err := d.clockStore.NewTransaction() | ||||
| 		if err != nil { | ||||
| 			panic(err) | ||||
| 		} | ||||
| 
 | ||||
| 		if err := d.clockStore.PutDataClockFrame( | ||||
| 			frame, | ||||
| 			d.proverTrie, | ||||
| 			txn, | ||||
| 			false, | ||||
| 		); err != nil { | ||||
| 			panic(err) | ||||
| 		} | ||||
| 
 | ||||
| 		if err = txn.Commit(); err != nil { | ||||
| 			panic(err) | ||||
| 		} | ||||
| 
 | ||||
| 		d.head = frame | ||||
|  | ||||
| @ -1,11 +1,11 @@ | ||||
| package time_test | ||||
| 
 | ||||
| import ( | ||||
| 	"encoding/hex" | ||||
| 	"fmt" | ||||
| 	"strings" | ||||
| 	"sync" | ||||
| 	"testing" | ||||
| 	gotime "time" | ||||
| 
 | ||||
| 	"github.com/cloudflare/circl/sign/ed448" | ||||
| 	"github.com/iden3/go-iden3-crypto/poseidon" | ||||
| @ -118,7 +118,7 @@ func TestDataTimeReel(t *testing.T) { | ||||
| 		addrMap, | ||||
| 		proverTrie := generateTestProvers() | ||||
| 
 | ||||
| 	// We're going to set this up by churning 100 master frames so we don't
 | ||||
| 	// We're going to set this up by churning 40 master frames so we don't
 | ||||
| 	// have to zig zag on master and data frames to confirm data time reel
 | ||||
| 	// behaviors
 | ||||
| 	m := time.NewMasterTimeReel( | ||||
| @ -143,14 +143,14 @@ func TestDataTimeReel(t *testing.T) { | ||||
| 	wg.Add(1) | ||||
| 	frameCh := m.NewFrameCh() | ||||
| 	go func() { | ||||
| 		for i := 0; i < 100; i++ { | ||||
| 		for i := 0; i < 40; i++ { | ||||
| 			frames = append(frames, <-frameCh) | ||||
| 		} | ||||
| 		wg.Done() | ||||
| 	}() | ||||
| 
 | ||||
| 	// in order
 | ||||
| 	for i := int64(0); i < 100; i++ { | ||||
| 	for i := int64(0); i < 40; i++ { | ||||
| 		frame, err = prover.ProveMasterClockFrame(frame, i+1, 10) | ||||
| 		assert.NoError(t, err) | ||||
| 
 | ||||
| @ -160,12 +160,23 @@ func TestDataTimeReel(t *testing.T) { | ||||
| 
 | ||||
| 	wg.Wait() | ||||
| 
 | ||||
| 	for i := 0; i < 100; i++ { | ||||
| 	for i := 0; i < 40; i++ { | ||||
| 		assert.NotNil(t, frames[i]) | ||||
| 		assert.Equal(t, frames[i].FrameNumber, uint64(i+1)) | ||||
| 	} | ||||
| 
 | ||||
| 	filterBytes, _ := hex.DecodeString(filter) | ||||
| 	filterBytes := []byte{ | ||||
| 		0x01, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, | ||||
| 		0x01, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, | ||||
| 		0x01, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, | ||||
| 		0x01, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, | ||||
| 		0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, | ||||
| 		0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, | ||||
| 		0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, | ||||
| 		0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, | ||||
| 		0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, | ||||
| 		0xff, 0xff, | ||||
| 	} | ||||
| 
 | ||||
| 	// Ok, now onto the data time reel. We're going to test the following
 | ||||
| 	// scenarios:
 | ||||
| @ -203,7 +214,7 @@ func TestDataTimeReel(t *testing.T) { | ||||
| 	datawg.Add(1) | ||||
| 	dataFrameCh := d.NewFrameCh() | ||||
| 	go func() { | ||||
| 		for i := 0; i < 40; i++ { | ||||
| 		for i := 0; i < 41; i++ { | ||||
| 			dataFrames = append(dataFrames, <-dataFrameCh) | ||||
| 		} | ||||
| 		datawg.Done() | ||||
| @ -211,7 +222,7 @@ func TestDataTimeReel(t *testing.T) { | ||||
| 
 | ||||
| 	// 1. z-dist optimal – proof submission is strictly master-frame evoked leader
 | ||||
| 	for i := int64(0); i < 10; i++ { | ||||
| 		masterSelector, err := frames[i+1].GetSelector() | ||||
| 		masterSelector, err := frames[i].GetSelector() | ||||
| 		assert.NoError(t, err) | ||||
| 
 | ||||
| 		proverSelection := proverTrie.FindNearest( | ||||
| @ -236,7 +247,7 @@ func TestDataTimeReel(t *testing.T) { | ||||
| 	insertFrames := []*protobufs.ClockFrame{} | ||||
| 
 | ||||
| 	for i := int64(10); i < 20; i++ { | ||||
| 		masterSelector, err := frames[i+1].GetSelector() | ||||
| 		masterSelector, err := frames[i].GetSelector() | ||||
| 		assert.NoError(t, err) | ||||
| 
 | ||||
| 		proverSelection := proverTrie.FindNearest( | ||||
| @ -265,7 +276,7 @@ func TestDataTimeReel(t *testing.T) { | ||||
| 	insertFrames = []*protobufs.ClockFrame{} | ||||
| 
 | ||||
| 	for i := int64(20); i < 25; i++ { | ||||
| 		masterSelector, err := frames[i+1].GetSelector() | ||||
| 		masterSelector, err := frames[i].GetSelector() | ||||
| 		assert.NoError(t, err) | ||||
| 
 | ||||
| 		proverSelection := proverTrie.FindNearest( | ||||
| @ -285,7 +296,7 @@ func TestDataTimeReel(t *testing.T) { | ||||
| 		d.Insert(frame) | ||||
| 	} | ||||
| 
 | ||||
| 	masterSelector, err := frames[26].GetSelector() | ||||
| 	masterSelector, err := frames[25].GetSelector() | ||||
| 	assert.NoError(t, err) | ||||
| 
 | ||||
| 	proverSelections := proverTrie.FindNearestAndApproximateNeighbors( | ||||
| @ -307,7 +318,7 @@ func TestDataTimeReel(t *testing.T) { | ||||
| 	insertFrames = append(insertFrames, frame) | ||||
| 
 | ||||
| 	for i := int64(26); i < 30; i++ { | ||||
| 		masterSelector, err := frames[i+1].GetSelector() | ||||
| 		masterSelector, err := frames[i].GetSelector() | ||||
| 		assert.NoError(t, err) | ||||
| 
 | ||||
| 		proverSelection := proverTrie.FindNearest( | ||||
| @ -339,7 +350,7 @@ func TestDataTimeReel(t *testing.T) { | ||||
| 	optimalKeySet := [][]byte{} | ||||
| 	suppressedFrame := frame | ||||
| 	for i := int64(30); i < 40; i++ { | ||||
| 		masterSelector, err := frames[i+1].GetSelector() | ||||
| 		masterSelector, err := frames[i].GetSelector() | ||||
| 		assert.NoError(t, err) | ||||
| 
 | ||||
| 		proverSelections := proverTrie.FindNearestAndApproximateNeighbors( | ||||
| @ -357,7 +368,7 @@ func TestDataTimeReel(t *testing.T) { | ||||
| 
 | ||||
| 		// What we're trying to simulate: the majority is intentionally ignoring
 | ||||
| 		// the most optimal signer
 | ||||
| 		suppressedFrame, err := prover.ProveDataClockFrame( | ||||
| 		suppressedFrame, err = prover.ProveDataClockFrame( | ||||
| 			suppressedFrame, | ||||
| 			[][]byte{}, | ||||
| 			[]*protobufs.InclusionAggregateProof{}, | ||||
| @ -379,26 +390,29 @@ func TestDataTimeReel(t *testing.T) { | ||||
| 
 | ||||
| 	for i := 9; i >= 0; i-- { | ||||
| 		err := d.Insert(conflictFrames[i]) | ||||
| 		// force linear ordering
 | ||||
| 		gotime.Sleep(1 * gotime.Second) | ||||
| 		assert.NoError(t, err) | ||||
| 	} | ||||
| 
 | ||||
| 	// Someone is honest, but clumsy:
 | ||||
| 	// Someone is honest, but running backwards:
 | ||||
| 	for i := 9; i >= 0; i-- { | ||||
| 		err := d.Insert(insertFrames[i]) | ||||
| 		gotime.Sleep(1 * gotime.Second) | ||||
| 		assert.NoError(t, err) | ||||
| 	} | ||||
| 
 | ||||
| 	datawg.Wait() | ||||
| 
 | ||||
| 	for i := 0; i < 40; i++ { | ||||
| 	for i := 0; i < 41; i++ { | ||||
| 		assert.NotNil(t, dataFrames[i]) | ||||
| 
 | ||||
| 		if i >= 40 { | ||||
| 			assert.Equal(t, uint64(i), dataFrames[i].FrameNumber) | ||||
| 			assert.Equal( | ||||
| 				t, | ||||
| 				optimalKeySet[i-31], | ||||
| 				dataFrames[i].GetPublicKeySignatureEd448().PublicKey.KeyValue, | ||||
| 				optimalKeySet[i-30], | ||||
| 			) | ||||
| 		} else { | ||||
| 			assert.Equal(t, uint64(i+1), dataFrames[i].FrameNumber) | ||||
|  | ||||
| @ -284,5 +284,5 @@ func printLogo() { | ||||
| 
 | ||||
| func printVersion() { | ||||
| 	fmt.Println(" ") | ||||
| 	fmt.Println("                         Quilibrium Node - v1.2.5 – Dawn") | ||||
| 	fmt.Println("                         Quilibrium Node - v1.2.6 – Dawn") | ||||
| } | ||||
|  | ||||
| @ -869,18 +869,35 @@ func (p *PebbleClockStore) GetParentDataClockFrame( | ||||
| 	frameNumber uint64, | ||||
| 	parentSelector []byte, | ||||
| ) (*protobufs.ClockFrame, error) { | ||||
| 	check := false | ||||
| 	data, closer, err := p.db.Get( | ||||
| 		clockDataParentIndexKey(filter, frameNumber, parentSelector), | ||||
| 	) | ||||
| 	if err != nil && !errors.Is(err, pebble.ErrNotFound) { | ||||
| 		return nil, errors.Wrap(err, "get parent data clock frame") | ||||
| 	} else if err != nil && errors.Is(err, pebble.ErrNotFound) { | ||||
| 		data, closer, err = p.db.Get(clockDataFrameKey(filter, frameNumber)) | ||||
| 		if err != nil { | ||||
| 			return nil, errors.Wrap(err, "get parent data clock frame") | ||||
| 		} | ||||
| 		check = true | ||||
| 	} | ||||
| 
 | ||||
| 	parent := &protobufs.ClockFrame{} | ||||
| 	if err := proto.Unmarshal(data, parent); err != nil { | ||||
| 		return nil, errors.Wrap(err, "get parent data clock frame") | ||||
| 	} | ||||
| 
 | ||||
| 	if check { | ||||
| 		selector, err := parent.GetSelector() | ||||
| 		if err != nil { | ||||
| 			return nil, errors.Wrap(err, "get parent data clock frame") | ||||
| 		} | ||||
| 		if !bytes.Equal(selector.FillBytes(make([]byte, 32)), parentSelector) { | ||||
| 			return nil, errors.Wrap(ErrNotFound, "get parent data clock frame") | ||||
| 		} | ||||
| 	} | ||||
| 
 | ||||
| 	if err := p.fillAggregateProofs(parent); err != nil { | ||||
| 		return nil, errors.Wrap( | ||||
| 			errors.Wrap(err, ErrInvalidData.Error()), | ||||
| @ -1019,6 +1036,22 @@ func (p *PebbleClockStore) PutDataClockFrame( | ||||
| 		return errors.Wrap(err, "put data clock frame") | ||||
| 	} | ||||
| 
 | ||||
| 	selector, err := frame.GetSelector() | ||||
| 	if err != nil { | ||||
| 		return errors.Wrap(err, "put data clock frame") | ||||
| 	} | ||||
| 
 | ||||
| 	if err = txn.Set( | ||||
| 		clockDataParentIndexKey( | ||||
| 			frame.Filter, | ||||
| 			frame.FrameNumber, | ||||
| 			selector.FillBytes(make([]byte, 32)), | ||||
| 		), | ||||
| 		data, | ||||
| 	); err != nil { | ||||
| 		return errors.Wrap(err, "put data clock frame") | ||||
| 	} | ||||
| 
 | ||||
| 	proverData, err := proverTrie.Serialize() | ||||
| 	if err != nil { | ||||
| 		return errors.Wrap(err, "put data clock frame") | ||||
|  | ||||
| @ -166,7 +166,6 @@ func (t *InMemKVDBTransaction) Set(key []byte, value []byte) error { | ||||
| 	if !t.db.open { | ||||
| 		return errors.New("inmem db closed") | ||||
| 	} | ||||
| 
 | ||||
| 	t.changes = append(t.changes, InMemKVDBOperation{ | ||||
| 		op:    SetOperation, | ||||
| 		key:   key, | ||||
| @ -205,7 +204,6 @@ func (t *InMemKVDBTransaction) Delete(key []byte) error { | ||||
| 	if !t.db.open { | ||||
| 		return errors.New("inmem db closed") | ||||
| 	} | ||||
| 
 | ||||
| 	t.changes = append(t.changes, InMemKVDBOperation{ | ||||
| 		op:  DeleteOperation, | ||||
| 		key: key, | ||||
|  | ||||
		Loading…
	
		Reference in New Issue
	
	Block a user
	 Cassandra Heart
						Cassandra Heart