rename: witness -> validator

Makefile

@@ -9,21 +9,21 @@ BUILDTIME=$(shell git show -s --format=%cd)
 
 default: all
 
-all: clean witness
+all: clean validator
 
 BUILD_FLAGS=-ldflags "\
--X 'witness/version.GOVersion=$(GOVERSION)' \
--X 'witness/version.GitHash=$(GITHASH)' \
--X 'witness/version.BuildTime=$(BUILDTIME)' \
--X 'witness/version.GitBranch=$(GITBRANCH)'"
+-X 'validator/version.GOVersion=$(GOVERSION)' \
+-X 'validator/version.GitHash=$(GITHASH)' \
+-X 'validator/version.BuildTime=$(BUILDTIME)' \
+-X 'validator/version.GitBranch=$(GITBRANCH)'"
 
 
-witness:
-	go build $(BUILD_FLAGS) -v -o=${GOBIN}/$@ ./cmd/witness
+validator:
+	go build $(BUILD_FLAGS) -v -o=${GOBIN}/$@ ./cmd/validator
 
 
 dev:
-	go build $(BUILD_FLAGS) -v -o=${GOBIN}/$@ -gcflags "all=-N -l" ./cmd/witness
+	go build $(BUILD_FLAGS) -v -o=${GOBIN}/$@ -gcflags "all=-N -l" ./cmd/validator
 
 
 clean:

api/rpc.go

@@ -4,13 +4,13 @@ import (
 	"encoding/json"
 	"net/http"
 	"time"
-	"witness/core"
+	"validator/core"
 
 	"github.com/ethereum/go-ethereum/common"
 	log "github.com/sirupsen/logrus"
 )
 
-var witness *core.Witness
+var validator *core.Validator
 
 func rpcHandle(w http.ResponseWriter, r *http.Request) {
 	req := &jsonrpcMessage{}
@@ -115,7 +115,7 @@ func getWithdrawProofs(params []byte, resp *jsonrpcMessage) {
 		date = paramList[1]
 	}
 
-	workload, proofs := witness.GetMerkleProof(common.HexToAddress(paramList[0]), date)
+	workload, proofs := validator.GetMerkleProof(common.HexToAddress(paramList[0]), date)
 
 	temp := map[string]interface{}{
 		"workload": workload,
@@ -145,7 +145,7 @@ func getPendingWorkload(params []byte, resp *jsonrpcMessage) {
 		return
 	}
 
-	workload, globalWorkload := witness.GetPendingWorkload(common.HexToAddress(addressList[0]))
+	workload, globalWorkload := validator.GetPendingWorkload(common.HexToAddress(addressList[0]))
 	temp := map[string]interface{}{
 		"workload":        workload,
 		"global_workload": globalWorkload,
@@ -197,7 +197,7 @@ func getDailyMerkleNodes(params []byte, resp *jsonrpcMessage) {
 		rootHash = common.HexToHash(paramList[3].(string))
 	}
 
-	nodes := witness.GetDailyMerkleNodes(date, depth, rootHash)
+	nodes := validator.GetDailyMerkleNodes(date, depth, rootHash)
 	resp.Result, _ = json.Marshal(nodes)
 }
 
@@ -243,15 +243,15 @@ func getDailyMerkleSumNodes(params []byte, resp *jsonrpcMessage) {
 		rootHash = common.HexToHash(paramList[3].(string))
 	}
 
-	nodes, vals := witness.GetDailyMerkleSumNodes(date, depth, rootHash)
+	nodes, vals := validator.GetDailyMerkleSumNodes(date, depth, rootHash)
 	resp.Result, _ = json.Marshal(map[string]interface{}{
 		"nodes":  nodes,
 		"values": vals,
 	})
 }
 
-func StartJSONRPC(listenAddress string, w *core.Witness) {
-	witness = w
+func StartJSONRPC(listenAddress string, w *core.Validator) {
+	validator = w
 	http.HandleFunc("/", rpcHandle)
 	log.WithField("listen", listenAddress).Info("start JSON-RPC server")
 	err := http.ListenAndServe(listenAddress, nil)

cmd/witness/flags.go → cmd/validator/flags.go

@@ -62,8 +62,8 @@ var (
 		Usage: "The address of the store contract",
 	}
 
-	witnessContractFlag = &cli.StringFlag{
-		Name:  "witness-contract",
+	validatorContractFlag = &cli.StringFlag{
+		Name:  "validator-contract",
 		Usage: "The address of the reward contract",
 	}
 

cmd/witness/main.go → cmd/validator/main.go

@@ -3,11 +3,11 @@ package main
 import (
 	"net/http"
 	"os"
-	"witness/api"
-	"witness/conf"
-	"witness/core"
-	"witness/quest"
-	"witness/version"
+	"validator/api"
+	"validator/conf"
+	"validator/core"
+	"validator/quest"
+	"validator/version"
 
 	"github.com/prometheus/client_golang/prometheus/promhttp"
 	log "github.com/sirupsen/logrus"
@@ -25,7 +25,7 @@ var (
 		privateKeyFlag,
 		chainRPCFlag,
 		storeContractFlag,
-		witnessContractFlag,
+		validatorContractFlag,
 		commitTimeFlag,
 		questHostFlag,
 		questPortFlag,
@@ -38,8 +38,8 @@ var (
 func main() {
 	app := cli.App{}
 	app.Flags = wrapFlags(append(appFlags, []cli.Flag{}...))
-	app.Name = "witness"
-	app.Usage = "this is witness"
+	app.Name = "validator"
+	app.Usage = "this is validator"
 	app.Version = version.Version
 	app.Before = func(c *cli.Context) error {
 		return loadFlagsFromConfig(c, app.Flags)
@@ -62,7 +62,7 @@ func run(ctx *cli.Context) {
 		PrivateKey:        ctx.String(privateKeyFlag.Name),
 		ChainRPC:          ctx.String(chainRPCFlag.Name),
 		StoreContract:     ctx.String(storeContractFlag.Name),
-		WitnessContract:   ctx.String(witnessContractFlag.Name),
+		ValidatorContract: ctx.String(validatorContractFlag.Name),
 		DataDir:           ctx.String(dataDirFlag.Name),
 		CommitTime:        ctx.Int(commitTimeFlag.Name),
 	}
@@ -79,7 +79,7 @@ func run(ctx *cli.Context) {
 	}
 	q := quest.NewQuest(qCfg)
 
-	w := core.RunWitness(q, cfg)
+	w := core.RunValidator(q, cfg)
 	// runGrpcServer(cfg.GRPCListenAddr, w)
 	runJSONRPCServer(cfg.RPCListenAddr, w)
 	select {}
@@ -105,6 +105,6 @@ func runMetrics(listen string) {
 	}()
 }
 
-func runJSONRPCServer(listen string, w *core.Witness) {
+func runJSONRPCServer(listen string, w *core.Validator) {
 	go api.StartJSONRPC(listen, w)
 }

conf/config.go

@@ -8,7 +8,7 @@ type Config struct {
 	ChainRPC          string
 	PrivateKey        string
 	StoreContract     string
-	WitnessContract   string
+	ValidatorContract string
 	RewardContract    string
 	DataDir           string
 	CommitTime        int

config.toml

@@ -12,7 +12,7 @@ private-key = "529f4efb80ac534f17d873104c71881c0970dbd5a886f183f63c5c6bb7a1fcd9"
 
 store-contract = "0x7Cd36Bc2a477f60A14f08442179B2f626bE026Ea"
 
-witness-contract = "0xf49133dD7B7ed75fA0f877413D293c05Bff0D8F0"
+witness-contract = "0x60376A7A4F5013CCca347A9B320D0b8dD57D87F4"
 
 commit-time = 3600 # utc + n seconds
 

core/chain.go

@@ -7,7 +7,7 @@ import (
 	"fmt"
 	"math/big"
 	"time"
-	"witness/contract"
+	"validator/contract"
 
 	"github.com/btcsuite/btcd/btcec/v2"
 	"github.com/ethereum/go-ethereum"
@@ -24,10 +24,10 @@ type ChainRPC struct {
 	chainID           *big.Int
 	privateKey        *ecdsa.PrivateKey
 	storageContract   *contract.AddressStorage
-	witnessContract *contract.Witness
+	validatorContract *contract.Validator
 }
 
-func newChain(rpc, privateKey, storageCa, witnessCa string) *ChainRPC {
+func newChain(rpc, privateKey, storageCa, validatorCa string) *ChainRPC {
 	ethRpc, err := ethclient.Dial(rpc)
 	if err != nil {
 		panic(err)
@@ -48,7 +48,7 @@ func newChain(rpc, privateKey, storageCa, witnessCa string) *ChainRPC {
 		panic(err)
 	}
 
-	witness, err := contract.NewWitness(common.HexToAddress(witnessCa), ethRpc)
+	validator, err := contract.NewValidator(common.HexToAddress(validatorCa), ethRpc)
 	if err != nil {
 		panic(err)
 	}
@@ -65,7 +65,7 @@ func newChain(rpc, privateKey, storageCa, witnessCa string) *ChainRPC {
 	}
 
 	k, _ := btcec.PrivKeyFromBytes(binPrivateKey)
-	return &ChainRPC{rpc: ethRpc, storageContract: storage, witnessContract: witness, chainID: chainID, privateKey: k.ToECDSA()}
+	return &ChainRPC{rpc: ethRpc, storageContract: storage, validatorContract: validator, chainID: chainID, privateKey: k.ToECDSA()}
 }
 
 func (r *ChainRPC) GetContainerAddresses() (addrs []common.Address, err error) {
@@ -81,7 +81,7 @@ func (r *ChainRPC) GetWorkloadThreshold(totalWorkload uint64) (threshold *big.In
 	return big.NewInt(1), nil
 }
 
-func (r *ChainRPC) SubmitProofs(date string, merkleSumTreeRoot, merkleTreeRoot common.Hash) (txHash common.Hash, err error) {
+func (r *ChainRPC) SubmitProofs(dateTimestamp int64, merkleSumTreeRoot, merkleTreeRoot common.Hash) (txHash common.Hash, err error) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
 	defer cancel()
 	opts, err := bind.NewKeyedTransactorWithChainID(r.privateKey, r.chainID)
@@ -90,7 +90,7 @@ func (r *ChainRPC) SubmitProofs(date string, merkleSumTreeRoot, merkleTreeRoot c
 	}
 	opts.Context = ctx
 	for i := 0; i < 3; i++ {
-		signedTx, err := r.witnessContract.SubmitMerkleRoot(opts, date, merkleSumTreeRoot, merkleTreeRoot)
+		signedTx, err := r.validatorContract.SubmitMerkleRoot(opts, big.NewInt(dateTimestamp), merkleSumTreeRoot, merkleTreeRoot)
 		if err != nil {
 			time.Sleep(time.Second * 3)
 			continue

core/interface.go

@@ -3,43 +3,43 @@ package core
 import (
 	"fmt"
 	"math/big"
-	"witness/tree"
+	"validator/tree"
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/crypto"
 	log "github.com/sirupsen/logrus"
 )
 
-func (w *Witness) GetPendingWorkload(address common.Address) (workload, globalWorkload uint64) {
-	wl, err := w.q.GetPendingWorkload(w.todayTimestamp(), address.Hex())
+func (v *Validator) GetPendingWorkload(address common.Address) (workload, globalWorkload uint64) {
+	wl, err := v.q.GetPendingWorkload(v.todayTimestamp(), address.Hex())
 	if err != nil {
 		log.WithError(err).Error("failed to get pending workload")
 		return
 	}
 	log.WithField("workload", wl).Debug("quest get pending workload")
-	return wl, w.pendingWorkload
+	return wl, v.pendingWorkload
 }
 
-func (w *Witness) GetMerkleProof(address common.Address, date string) (balance string, proofs []common.Hash) {
+func (v *Validator) GetMerkleProof(address common.Address, date string) (balance string, proofs []common.Hash) {
 	if date == "" {
-		date = w.date
+		date = v.date
 	}
-	w.Lock()
-	cacheTree, ok := w.mtTreeCache[date]
-	w.Unlock()
+	v.Lock()
+	cacheTree, ok := v.mtTreeCache[date]
+	v.Unlock()
 	if !ok {
-		if ok = w.LoadMerkleTree(date); !ok {
+		if ok = v.LoadMerkleTree(date); !ok {
 			log.WithFields(log.Fields{
 				"date": date,
 			}).Error("load merkle proof empty")
 			return "0", nil
 		}
 	}
-	w.Lock()
-	cacheTree = w.mtTreeCache[date]
-	w.Unlock()
+	v.Lock()
+	cacheTree = v.mtTreeCache[date]
+	v.Unlock()
 	dateStateRootKey := fmt.Sprintf("sroot:%s", date)
-	dateStateRoot, err := w.lvdb.Get([]byte(dateStateRootKey))
+	dateStateRoot, err := v.lvdb.Get([]byte(dateStateRootKey))
 	if err != nil {
 		log.WithFields(log.Fields{
 			"key": dateStateRootKey,
@@ -48,10 +48,10 @@ func (w *Witness) GetMerkleProof(address common.Address, date string) (balance s
 		return "0", nil
 	}
 	var sdb *StateDB
-	if date == w.date {
-		sdb = w.state
+	if date == v.date {
+		sdb = v.state
 	} else {
-		sdb, err = NewStateDB(w.lvdb, common.BytesToHash(dateStateRoot))
+		sdb, err = NewStateDB(v.lvdb, common.BytesToHash(dateStateRoot))
 		if err != nil {
 			log.WithError(err).Error("failed to create state db")
 			return "0", nil
@@ -72,24 +72,24 @@ func (w *Witness) GetMerkleProof(address common.Address, date string) (balance s
 	return object.Balance, proofs
 }
 
-func (w *Witness) GetDailyMerkleNodes(date string, depth int, rootHash common.Hash) (nodes [][]common.Hash) {
+func (v *Validator) GetDailyMerkleNodes(date string, depth int, rootHash common.Hash) (nodes [][]common.Hash) {
 	if date == "" {
-		date = w.date
+		date = v.date
 	}
-	w.Lock()
-	cacheTree, ok := w.mtTreeCache[date]
-	w.Unlock()
+	v.Lock()
+	cacheTree, ok := v.mtTreeCache[date]
+	v.Unlock()
 	if !ok {
-		if ok = w.LoadMerkleTree(date); !ok {
+		if ok = v.LoadMerkleTree(date); !ok {
 			log.WithFields(log.Fields{
 				"date": date,
 			}).Error("load merkle proof empty")
 			return nil
 		}
 	}
-	w.Lock()
-	cacheTree = w.mtTreeCache[date]
-	w.Unlock()
+	v.Lock()
+	cacheTree = v.mtTreeCache[date]
+	v.Unlock()
 
 	rootNode := cacheTree.GetRootNode()
 	if rootHash.Hex() == (common.Hash{}).Hex() {
@@ -100,24 +100,24 @@ func (w *Witness) GetDailyMerkleNodes(date string, depth int, rootHash common.Ha
 	return tree.MerkleTreeTraversal(rootNode, depth)
 }
 
-func (w *Witness) GetDailyMerkleSumNodes(date string, depth int, rootHash common.Hash) (nodesHash [][]common.Hash, nodesVal [][]string) {
+func (v *Validator) GetDailyMerkleSumNodes(date string, depth int, rootHash common.Hash) (nodesHash [][]common.Hash, nodesVal [][]string) {
 	if date == "" {
-		date = w.date
+		date = v.date
 	}
-	w.Lock()
-	cacheTree, ok := w.mstTreeCache[date]
-	w.Unlock()
+	v.Lock()
+	cacheTree, ok := v.mstTreeCache[date]
+	v.Unlock()
 	if !ok {
-		if ok = w.LoadMerkleSumTree(date); !ok {
+		if ok = v.LoadMerkleSumTree(date); !ok {
 			log.WithFields(log.Fields{
 				"date": date,
 			}).Error("load merkle sum proof empty")
 			return nil, nil
 		}
 	}
-	w.Lock()
-	cacheTree = w.mstTreeCache[date]
-	w.Unlock()
+	v.Lock()
+	cacheTree = v.mstTreeCache[date]
+	v.Unlock()
 
 	rootNode := cacheTree.GetRoot()
 	if rootHash.Hex() == (common.Hash{}).Hex() {

core/job.go

@@ -7,40 +7,40 @@ import (
 )
 
 // UpdateContractAddressJob 定时更新合约内的地址
-func (w *Witness) UpdateContractAddressJob() {
+func (v *Validator) UpdateContractAddressJob() {
 	ticker := time.NewTicker(time.Minute * 10)
 	defer ticker.Stop()
 	log.Info("start update address task")
 	for {
-		addrs, err := w.rpc.GetContainerAddresses()
+		addrs, err := v.rpc.GetContainerAddresses()
 		if err != nil {
 			log.WithError(err).Error("failed to get container addresses")
 		} else {
-			w.containerAddresses = addrs
+			v.containerAddresses = addrs
 		}
-		addrs, err = w.rpc.GetNMAddresses()
+		addrs, err = v.rpc.GetNMAddresses()
 		if err != nil {
 			log.WithError(err).Error("failed to get NM addresses")
 		} else {
-			w.nmAddresses = addrs
+			v.nmAddresses = addrs
 		}
 		log.WithFields(log.Fields{
-			"container_count": len(w.containerAddresses),
-			"nm_count":        len(w.nmAddresses),
+			"container_count": len(v.containerAddresses),
+			"nm_count":        len(v.nmAddresses),
 		}).Info("store contract update address")
 		<-ticker.C
 	}
 }
 
 // UpdateGlobalWorkloadJob 定时从quest更新全局workload
-func (w *Witness) UpdateGlobalWorkloadJob() {
+func (v *Validator) UpdateGlobalWorkloadJob() {
 	ticker := time.NewTicker(time.Second * 30)
 	defer ticker.Stop()
 	log.Info("start update global workload task")
 	for {
-		wl := w.GetGlobalWorkload()
+		wl := v.GetGlobalWorkload()
 		if wl > 0 {
-			w.pendingWorkload = wl
+			v.pendingWorkload = wl
 		}
 		<-ticker.C
 	}

core/quest.go

 package core
 
 import (
-	"witness/quest"
+	"validator/quest"
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/crypto"
-	witnessv1 "github.com/odysseus/odysseus-protocol/gen/proto/go/witness/v1"
+	validatorv1 "github.com/odysseus/odysseus-protocol/gen/proto/go/validator/v1"
 	log "github.com/sirupsen/logrus"
 )
 
-func (w *Witness) LoadPendingProofs(startTimestamp, endTimestamp int64) {
+func (v *Validator) LoadPendingProofs(startTimestamp, endTimestamp int64) {
 	defaultLimit := 100
 	lastTaskID := ""
 	var dbProofs []*quest.ProofModel
 	var err error
 	for {
-		dbProofs, err = w.q.GetProofs(startTimestamp, endTimestamp, lastTaskID, defaultLimit)
+		dbProofs, err = v.q.GetProofs(startTimestamp, endTimestamp, lastTaskID, defaultLimit)
 		if err != nil {
 			log.WithError(err).Error("failed to get proofs")
 			return
@@ -27,16 +27,16 @@ func (w *Witness) LoadPendingProofs(startTimestamp, endTimestamp int64) {
 		}
 
 		for _, dbProof := range dbProofs {
-			miner, proof := w.verifyProof(dbProof)
+			miner, proof := v.verifyProof(dbProof)
 			if proof != nil {
-				w.AddPendingProof(miner, proof)
+				v.AddPendingProof(miner, proof)
 			}
 			lastTaskID = dbProof.TaskId
 		}
 	}
 }
 
-func (w *Witness) verifyProof(dbProof *quest.ProofModel) (miner common.Address, proof *witnessv1.ValidatedProof) {
+func (v *Validator) verifyProof(dbProof *quest.ProofModel) (miner common.Address, proof *validatorv1.ValidatedProof) {
 	if dbProof.TaskWorkload == 0 {
 		return
 	}
@@ -46,7 +46,7 @@ func (w *Witness) verifyProof(dbProof *quest.ProofModel) (miner common.Address,
 		return
 	}
 	containerSigner := crypto.PubkeyToAddress(*containerPubKey)
-	verified := w.IsContainerAddress(containerSigner)
+	verified := v.IsContainerAddress(containerSigner)
 	if !verified {
 		log.WithFields(log.Fields{"taskid": dbProof.TaskId, "signer": containerSigner.Hex()}).Error("invalid container signature")
 		return
@@ -70,21 +70,21 @@ func (w *Witness) verifyProof(dbProof *quest.ProofModel) (miner common.Address,
 	}
 
 	nmAddress := crypto.PubkeyToAddress(*nmPubKey)
-	verified = w.IsNMAddress(nmAddress)
+	verified = v.IsNMAddress(nmAddress)
 	if !verified {
 		log.WithFields(log.Fields{"taskid": dbProof.TaskId, "signer": nmAddress.Hex()}).Error("invalid manager signature")
 		return
 	}
 
-	proof = &witnessv1.ValidatedProof{
+	proof = &validatorv1.ValidatedProof{
 		Workload:  dbProof.TaskWorkload,
 		Timestamp: uint64(dbProof.TaskFinishTimestamp),
 	}
 	return common.HexToAddress(dbProof.TaskProfitAccount), proof
 }
 
-func (w *Witness) GetGlobalWorkload() uint64 {
-	workload, err := w.q.GetGlobalWorkload(w.todayTimestamp())
+func (v *Validator) GetGlobalWorkload() uint64 {
+	workload, err := v.q.GetGlobalWorkload(v.todayTimestamp())
 	if err != nil {
 		log.WithError(err).Error("failed to get global workload")
 		return 0

core/statedb.go

@@ -8,7 +8,7 @@ import (
 	"github.com/ethereum/go-ethereum/trie"
 	"github.com/ethereum/go-ethereum/trie/trienode"
 	"github.com/gogo/protobuf/proto"
-	witnessv1 "github.com/odysseus/odysseus-protocol/gen/proto/go/witness/v1"
+	validatorv1 "github.com/odysseus/odysseus-protocol/gen/proto/go/validator/v1"
 	log "github.com/sirupsen/logrus"
 )
 
@@ -30,8 +30,8 @@ func NewStateDB(lvdb ethdb.KeyValueStore, root common.Hash) (statedb *StateDB, e
 	}, nil
 }
 
-func (s *StateDB) GetMinerObject(miner common.Address) (object *witnessv1.MinerObject) {
-	object = &witnessv1.MinerObject{}
+func (s *StateDB) GetMinerObject(miner common.Address) (object *validatorv1.MinerObject) {
+	object = &validatorv1.MinerObject{}
 	k := crypto.Keccak256(miner.Bytes())
 	v, err := s.trie.Get(k)
 	if err != nil {
@@ -44,7 +44,7 @@ func (s *StateDB) GetMinerObject(miner common.Address) (object *witnessv1.MinerO
 	return
 }
 
-func (s *StateDB) UpdateMinerObject(miner common.Address, object *witnessv1.MinerObject) (err error) {
+func (s *StateDB) UpdateMinerObject(miner common.Address, object *validatorv1.MinerObject) (err error) {
 	k := crypto.Keccak256(miner.Bytes())
 	v, err := proto.Marshal(object)
 	if err != nil {
@@ -77,7 +77,7 @@ func (s *StateDB) Commit() (root common.Hash, err error) {
 	return root, err
 }
 
-func (s *StateDB) IterAllObject() (objects []*witnessv1.MinerObject) {
+func (s *StateDB) IterAllObject() (objects []*validatorv1.MinerObject) {
 	iter, err := s.trie.NodeIterator(nil)
 	if err != nil {
 		return
@@ -87,7 +87,7 @@ func (s *StateDB) IterAllObject() (objects []*witnessv1.MinerObject) {
 			continue
 		}
 		v := iter.LeafBlob()
-		object := &witnessv1.MinerObject{}
+		object := &validatorv1.MinerObject{}
 		err := proto.Unmarshal(v, object)
 		if err != nil {
 			continue

core/tree.go

@@ -6,18 +6,18 @@ import (
 	"math/big"
 	"sort"
 	"time"
-	"witness/tree"
-	"witness/util"
+	"validator/tree"
+	"validator/util"
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/crypto"
-	witnessv1 "github.com/odysseus/odysseus-protocol/gen/proto/go/witness/v1"
+	validatorv1 "github.com/odysseus/odysseus-protocol/gen/proto/go/validator/v1"
 	log "github.com/sirupsen/logrus"
 	"github.com/syndtr/goleveldb/leveldb/errors"
 )
 
 // CommitMST commit workload of per day
-func (w *Witness) CommitMST(proofMap map[common.Address]*witnessv1.ValidatedProof) (root common.Hash, sum *big.Int, err error) {
+func (v *Validator) CommitMST(proofMap map[common.Address]*validatorv1.ValidatedProof) (root common.Hash, sum *big.Int, err error) {
 	if len(proofMap) == 0 {
 		return common.Hash{}, big.NewInt(0), nil
 	}
@@ -43,22 +43,22 @@ func (w *Witness) CommitMST(proofMap map[common.Address]*witnessv1.ValidatedProo
 
 	rootNode := mstTree.GetRoot()
 
-	err = w.lvdb.Put([]byte(fmt.Sprintf("mstroot:%s", w.date)), root.Bytes())
+	err = v.lvdb.Put([]byte(fmt.Sprintf("mstroot:%s", v.date)), root.Bytes())
 	if err != nil {
 		log.Error(err)
 		return
 	}
-	err = w.lvdb.Put([]byte(fmt.Sprintf("mstsum:%s", w.date)), sum.Bytes())
+	err = v.lvdb.Put([]byte(fmt.Sprintf("mstsum:%s", v.date)), sum.Bytes())
 	if err != nil {
 		log.Error(err)
 		return
 	}
 
-	err = w.lvdb.Put([]byte(fmt.Sprintf("mstk:%s", w.date)), dbKey)
+	err = v.lvdb.Put([]byte(fmt.Sprintf("mstk:%s", v.date)), dbKey)
 	if err != nil {
 		return
 	}
-	err = w.lvdb.Put([]byte(fmt.Sprintf("mstv:%s", w.date)), dbVal)
+	err = v.lvdb.Put([]byte(fmt.Sprintf("mstv:%s", v.date)), dbVal)
 	if err != nil {
 		return
 	}
@@ -72,7 +72,7 @@ func (w *Witness) CommitMST(proofMap map[common.Address]*witnessv1.ValidatedProo
 }
 
 // CommitMT commit all workload
-func (w *Witness) CommitMT(objects []*witnessv1.MinerObject) (root common.Hash, err error) {
+func (v *Validator) CommitMT(objects []*validatorv1.MinerObject) (root common.Hash, err error) {
 	if len(objects) == 0 {
 		return common.Hash{}, nil
 	}
@@ -93,24 +93,24 @@ func (w *Witness) CommitMT(objects []*witnessv1.MinerObject) (root common.Hash,
 	root = mtTree.GetRoot()
 
 	st := time.Now()
-	err = w.lvdb.Put([]byte(fmt.Sprintf("mtroot:%s", w.date)), root.Bytes())
+	err = v.lvdb.Put([]byte(fmt.Sprintf("mtroot:%s", v.date)), root.Bytes())
 	if err != nil {
 		return
 	}
 	log.WithFields(log.Fields{
-		"k": fmt.Sprintf("mtroot:%s", w.date),
+		"k": fmt.Sprintf("mtroot:%s", v.date),
 		"v": root.String(),
 	}).Debug()
 
-	err = w.lvdb.Put([]byte(fmt.Sprintf("mtk:%s", w.date)), dbProofs)
+	err = v.lvdb.Put([]byte(fmt.Sprintf("mtk:%s", v.date)), dbProofs)
 	if err != nil {
 		return
 	}
 	log.WithFields(log.Fields{
-		"k":        fmt.Sprintf("mtk:%s", w.date),
+		"k":        fmt.Sprintf("mtk:%s", v.date),
 		"v_length": len(dbProofs),
 	}).Debug()
-	w.mtTreeCache[w.date] = mtTree
+	v.mtTreeCache[v.date] = mtTree
 
 	log.WithFields(log.Fields{
 		"root": root.Hex(),
@@ -120,12 +120,12 @@ func (w *Witness) CommitMT(objects []*witnessv1.MinerObject) (root common.Hash,
 	return
 }
 
-func (w *Witness) LoadMerkleTree(date string) (ok bool) {
+func (v *Validator) LoadMerkleTree(date string) (ok bool) {
 	if date == "" {
 		return false
 	}
 	merkleTreeKey := fmt.Sprintf("mtk:%s", date)
-	data, err := w.lvdb.Get([]byte(merkleTreeKey))
+	data, err := v.lvdb.Get([]byte(merkleTreeKey))
 	if err != nil {
 		if err == errors.ErrNotFound {
 			return
@@ -149,19 +149,19 @@ func (w *Witness) LoadMerkleTree(date string) (ok bool) {
 		log.WithError(err).Error("failed to load merkle proof")
 		return
 	}
-	w.Lock()
-	w.mtTreeCache[date] = mTree
-	w.Unlock()
+	v.Lock()
+	v.mtTreeCache[date] = mTree
+	v.Unlock()
 	log.WithFields(log.Fields{"date": date, "root": mTree.GetRoot().Hex()}).Info("load merkle tree")
 	return true
 }
 
-func (w *Witness) LoadMerkleSumTree(date string) (ok bool) {
+func (v *Validator) LoadMerkleSumTree(date string) (ok bool) {
 	if date == "" {
 		return false
 	}
 	merkleSumTreeKey := fmt.Sprintf("mstk:%s", date)
-	keyData, err := w.lvdb.Get([]byte(merkleSumTreeKey))
+	keyData, err := v.lvdb.Get([]byte(merkleSumTreeKey))
 	if err != nil {
 		if err == errors.ErrNotFound {
 			return
@@ -181,7 +181,7 @@ func (w *Witness) LoadMerkleSumTree(date string) (ok bool) {
 	}
 
 	merkleSumTreeVal := fmt.Sprintf("mstv:%s", date)
-	valData, err := w.lvdb.Get([]byte(merkleSumTreeVal))
+	valData, err := v.lvdb.Get([]byte(merkleSumTreeVal))
 	if err != nil {
 		if err == errors.ErrNotFound {
 			return
@@ -202,9 +202,9 @@ func (w *Witness) LoadMerkleSumTree(date string) (ok bool) {
 	}
 
 	mstTree := tree.NewMerkleSumTree(datas, bigVals)
-	w.Lock()
-	w.mstTreeCache[date] = mstTree
-	w.Unlock()
+	v.Lock()
+	v.mstTreeCache[date] = mstTree
+	v.Unlock()
 	log.WithFields(log.Fields{"date": date, "root": mstTree.GetRoot()}).Info("load merkle sum tree")
 	return true
 }

go.mod

-module witness
+module validator
 
 go 1.21
 

quest/db.go

@@ -2,7 +2,7 @@ package quest
 
 import (
 	"fmt"
-	"witness/conf"
+	"validator/conf"
 
 	log "github.com/sirupsen/logrus"
 	"gorm.io/driver/postgres"

quest/proof.go

@@ -2,7 +2,7 @@ package quest
 
 import (
 	"math/big"
-	"witness/util"
+	"validator/util"
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/crypto"

readme.md

 
-# witness
-
-
+# Validator for AIGIC
 
+## leveldb kv
 
 merkle sum tree:
 
@@ -15,7 +14,6 @@ merkle sum tree:
     mstv:2020-01-01 -> val1:val2
 
 
-
 merkle tree:
 
     mtroot:2020-01-01 -> root

version/version.go

@@ -9,7 +9,7 @@ var (
 )
 
 var mistGauge = prometheus.NewGaugeVec(prometheus.GaugeOpts{
-	Name: "witness_version_gauge",
+	Name: "validator_version_gauge",
 }, []string{"gitHash", "gitBranch", "buildTime", "goVersion", "version"})
 
 func init() {