fix some bugs

Author: lowesyang

algorand.go

@@ -41,13 +41,13 @@ func NewAlgorand(id PID) *Algorand {
 
 func (alg *Algorand) start() {
 	alg.quitCh = make(chan struct{})
-	GetPeerPool().add(alg.peer)
+	alg.peer.start()
 	go alg.run()
 }
 
 func (alg *Algorand) stop() {
 	close(alg.quitCh)
-	GetPeerPool().remove(alg.peer)
+	alg.peer.stop()
 }
 
 // round returns the latest round number.
@@ -210,8 +210,8 @@ func (alg *Algorand) blockProposal(resolveFork bool) *Block {
 	round := alg.round() + 1
 	vrf, proof, subusers := alg.sortition(alg.sortitionSeed(round), role(iden, round, PROPOSE), expectedBlockProposers, alg.tokenOwn())
 	// have been selected.
+	log.Infof("node %d get %d sub-users in block proposal", alg.id, subusers)
 	if subusers > 0 {
-		log.Debugf("node %d has %d sub-users selected as block proposer", alg.id, subusers)
 		var (
 			newBlk       *Block
 			proposalType int
@@ -260,7 +260,11 @@ func (alg *Algorand) blockProposal(resolveFork bool) *Block {
 			}
 		case <-ticker.C:
 			// get the block with the highest priority
-			bhash := alg.peer.getMaxProposal(round).Hash
+			pp := alg.peer.getMaxProposal(round)
+			if pp == nil {
+				continue
+			}
+			bhash := pp.Hash
 			blk := alg.peer.getBlock(bhash)
 			if blk != nil {
 				return blk
@@ -521,12 +525,16 @@ func subUsers(expectedNum int, weight uint64, vrf []byte) int {
 	// hash / 2^hashlen ∉ [ ∑0,j B(k;w,p), ∑0,j+1 B(k;w,p))
 	hashBig := new(big.Float).SetInt(new(big.Int).SetBytes(vrf))
 	maxHash := new(big.Float).SetInt(new(big.Int).Exp(big.NewInt(2), big.NewInt(common.HashLength), big.NewInt(0)))
-	for {
+	for uint64(j) <= weight {
 		lower := new(big.Float).Mul(big.NewFloat(binomial.CDF(float64(j))), maxHash)
 		upper := new(big.Float).Mul(big.NewFloat(binomial.CDF(float64(j+1))), maxHash)
 		if hashBig.Cmp(lower) >= 0 && hashBig.Cmp(upper) < 0 {
 			break
 		}
+		j++
+	}
+	if uint64(j) > weight {
+		j = 0
 	}
 	return j
 }

common/types.go

@@ -24,7 +24,7 @@ func BigToHash(b *big.Int) Hash { return BytesToHash(b.Bytes()) }
 func HexToHash(s string) Hash { return BytesToHash(FromHex(s)) }
 
 func (h Hash) String() string {
-	return string(h[:])
+	return h.Hex()
 }
 
 func (h Hash) Bytes() []byte {

docs/剖析Algorand.md

@@ -222,6 +222,6 @@ Algorand论文所模拟的版本，其资源开销如下：
 	- 如何标记该轮共识区块是`FINAL`还是`TENTATIVE`。
 	- 达成`TENTATIVE`共识后是否需要额外的流程？（如进行快速的分叉检查？）
 3. 每一步投票中，`committee memer`的选举都受到step的影响，这要求sortition算法对各种子参数都具有较为稳定且宽松的结果输出，以避免频繁出现票数总数达不到阈值`T*τ`的情况。
-4. 共识流程中多个阶段需要预估超时时间，对于耗时不确定的智能合约运行来说需要加入额外的限制机制。
+4. 共识流程中多个阶段需要预估超时时间。在耗时不确定的智能合约场景，需要加入额外的限制机制。
 5. 算法性能受到网络连通性的影响。
 6. VRF算法的安全性问题。

main.go

@@ -4,10 +4,6 @@ import (
 	"time"
 )
 
-const (
-	userAmount = 10
-)
-
 func main() {
 	var nodes []*Algorand
 	for i := 1; i <= userAmount; i++ {

parameter.go

@@ -5,8 +5,8 @@ import "time"
 const (
 	// Algorand system parameters
 	totalTokenAmount = 10000
-	node             = 10
-	tokenPerNode     = totalTokenAmount / node
+	userAmount       = 20
+	tokenPerNode     = totalTokenAmount / userAmount
 
 	expectedBlockProposers        = 26
 	expectedCommitteeMembers      = 2000

peer.go

@@ -25,9 +25,18 @@ func newPeer(alg *Algorand) *Peer {
 		algorand:      alg,
 		incomingVotes: make(map[string]*List),
 		blocks:        make(map[common.Hash]*Block),
+		maxProposals:  make(map[uint64]*Proposal),
 	}
 }
 
+func (p *Peer) start() {
+	GetPeerPool().add(p.algorand.peer)
+}
+
+func (p *Peer) stop() {
+	GetPeerPool().remove(p.algorand.peer)
+}
+
 func (p *Peer) ID() PID {
 	return p.algorand.id
 }