update

config.toml

@@ -8,7 +8,7 @@ api-listen = "0.0.0.0:20012"
 
 private-key = "529f4efb80ac534f17d873104c71881c0970dbd5a886f183f63c5c6bb7a1fcd9"
 
-chain-rpc = "https://dev.rpc.aonet.ai"
+chain-rpc = "https://dev.rpc.agicoin.ai"
 
 store-contract = "0xA0ec84eCa14CD23afD5D7ba973390E83F0Cbe89A"
 
@@ -16,7 +16,7 @@ validator-contract = "0x7CBD03ecfA9093F83150E9625A25B00F555c81F7" # 测试版本
 
 claim-monitor-server = "http://18.167.203.17:28080"
 
-commit-offset = 3600 # utc + n seconds
+commit-offset = 1800 # utc + n seconds
 
 quest-host = "18.167.203.17"
 
@@ -26,4 +26,4 @@ quest-user = "admin"
 
 quest-pass = "quest"
 
-quest-db = "qdb"
+quest-db = "qdb"
\ No newline at end of file

core/quest.go

@@ -48,10 +48,11 @@ func (v *Validator) LoadMockProofs() {
 		common.HexToAddress("0x7777777777777777777777777777777777777777"),
 		common.HexToAddress("0x8888888888888888888888888888888888888888"),
 		common.HexToAddress("0x9999999999999999999999999999999999999999"),
+		common.HexToAddress("0x99999999953AF2bC757C30824288A706D45fB44b"),
 	}
 
 	proof := &validatorv1.ValidatedProof{
-		Workload: 100,
+		Workload: 1000,
 	}
 
 	for _, address := range mockAddresses {

core/tree.go

@@ -38,7 +38,6 @@ func (v *Validator) CommitMST(proofMap map[common.Address]*validatorv1.Validated
 	}
 
 	st := time.Now()
-
 	mstTree := tree.NewMerkleSumTree(keys, vals)
 
 	rootNode := mstTree.GetRoot()

tree/merkle_sum_tree.go

 package tree
 
 import (
+	"bytes"
 	"math/big"
 
 	"github.com/ethereum/go-ethereum/common"
@@ -8,7 +9,7 @@ import (
 )
 
 type MerkleSumTree struct {
-	Levels   [][]MerkleSumNode
+	Levels   [][]*MerkleSumNode
 	RootNode *MerkleSumNode
 }
 
@@ -25,8 +26,8 @@ type Value struct {
 }
 
 func NewMerkleSumTree(datas [][]byte, vals []*big.Int) *MerkleSumTree {
-	var nodes []MerkleSumNode
-	var levels [][]MerkleSumNode
+	var nodes []*MerkleSumNode
+	var levels [][]*MerkleSumNode
 
 	if len(datas) == 1 {
 		return &MerkleSumTree{
@@ -35,12 +36,18 @@ func NewMerkleSumTree(datas [][]byte, vals []*big.Int) *MerkleSumTree {
 		}
 	}
 
-	if len(datas)%2 != 0 {
-		datas = append(datas, []byte{})
+	for i := range datas {
+		nodes = append(nodes, buildToNode(datas[i], vals[i]))
 	}
 
-	for i := range datas {
-		nodes = append(nodes, *buildToNode(datas[i], vals[i]))
+	if len(nodes)%2 == 1 {
+		// raw = 0x09标识，添加到最后一层
+		nodes = append(nodes, &MerkleSumNode{
+			Value: Value{
+				BigValue: big.NewInt(0),
+				Raw:      []byte{0x09},
+			},
+		})
 	}
 
 	countOfDataNodes := len(nodes)
@@ -55,38 +62,37 @@ func NewMerkleSumTree(datas [][]byte, vals []*big.Int) *MerkleSumTree {
 		}
 	}
 
-	levels = [][]MerkleSumNode{nodes}
+	levels = [][]*MerkleSumNode{nodes}
 
 	for i := 0; i < counterOfLevels; i++ {
-		var level []MerkleSumNode
+		var level []*MerkleSumNode
 
 		lastNodeIndex := len(nodes) - 1
 		for j := 0; j <= lastNodeIndex; j += 2 {
 			if j == lastNodeIndex && lastNodeIndex%2 == 0 {
-				node := newMerkleSumNode(&nodes[j], nil)
-				level = append(level, *node)
+				node := newMerkleSumNode(nodes[j], nil)
+				level = append(level, node)
 			} else {
-				node := newMerkleSumNode(&nodes[j], &nodes[j+1])
-				level = append(level, *node)
+				node := newMerkleSumNode(nodes[j], nodes[j+1])
+				level = append(level, node)
 			}
 		}
-
 		nodes = level
 		levels = append(levels, level)
 	}
 
-	tree := MerkleSumTree{levels, &nodes[0]}
+	tree := MerkleSumTree{levels, nodes[0]}
 
 	return &tree
 }
 
 func newMerkleSumNode(left, right *MerkleSumNode) *MerkleSumNode {
 	var node MerkleSumNode
-	if right == nil {
-		concatLeftNodeData := append(left.Value.BigValue.Bytes(), left.Value.Hash[:]...)
-		concatRightNodeData := append(big.NewInt(0).Bytes(), (common.Hash{}).Bytes()...)
-		prevHashes := append(concatLeftNodeData, concatRightNodeData...)
-		node.Value.Hash = crypto.Keccak256Hash(prevHashes)
+	if right == nil || (right != nil && bytes.Equal(right.Value.Raw, []byte{0x09})) {
+		// concatLeftNodeData := append(left.Value.BigValue.Bytes(), left.Value.Hash[:]...)
+		// concatRightNodeData := append(big.NewInt(0).Bytes(), (common.Hash{}).Bytes()...)
+		// prevHashes := append(concatLeftNodeData)
+		node.Value.Hash = left.Value.Hash
 		node.Value.BigValue = left.Value.BigValue
 	} else {
 		concatLeftNodeData := append(left.Value.BigValue.Bytes(), left.Value.Hash[:]...)