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
 }

core/witness.go

@@ -6,23 +6,23 @@ import (
 	"math/rand"
 	"sync"
 	"time"
-	"witness/conf"
-	"witness/quest"
-	"witness/tree"
-	"witness/util"
+	"validator/conf"
+	"validator/quest"
+	"validator/tree"
+	"validator/util"
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/ethdb/leveldb"
 	"github.com/ethereum/go-ethereum/trie"
-	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"
 )
 
-type Witness struct {
+type Validator struct {
 	lvdb               *leveldb.Database
 	db                 *trie.Database
 	state              *StateDB
-	pendingProof       map[int64]map[common.Address]*witnessv1.ValidatedProof
+	pendingProof       map[int64]map[common.Address]*validatorv1.ValidatedProof
 	pendingWorkload    uint64
 	mtTreeCache        map[string]*tree.MerkleTree
 	mstTreeCache       map[string]*tree.MerkleSumTree
@@ -56,8 +56,8 @@ func getDBLastDayRoot(diskDB *leveldb.Database) (lastDay string, stateRoot commo
 	return lastDay, stateRoot
 }
 
-func RunWitness(q *quest.Quest, cfg *conf.Config) *Witness {
-	_rpc := newChain(cfg.ChainRPC, cfg.PrivateKey, cfg.StoreContract, cfg.WitnessContract)
+func RunValidator(q *quest.Quest, cfg *conf.Config) *Validator {
+	_rpc := newChain(cfg.ChainRPC, cfg.PrivateKey, cfg.StoreContract, cfg.ValidatorContract)
 	diskDB, err := leveldb.New(fmt.Sprintf("%s/db", cfg.DataDir), 128, 1024, "", false)
 	if err != nil {
 		panic(err)
@@ -68,10 +68,10 @@ func RunWitness(q *quest.Quest, cfg *conf.Config) *Witness {
 	if err != nil {
 		panic(err)
 	}
-	w := &Witness{
+	v := &Validator{
 		lvdb:         diskDB,
 		state:        stateDB,
-		pendingProof: make(map[int64]map[common.Address]*witnessv1.ValidatedProof),
+		pendingProof: make(map[int64]map[common.Address]*validatorv1.ValidatedProof),
 		mtTreeCache:  make(map[string]*tree.MerkleTree),
 		mstTreeCache: make(map[string]*tree.MerkleSumTree),
 		rpc:          _rpc,
@@ -79,68 +79,68 @@ func RunWitness(q *quest.Quest, cfg *conf.Config) *Witness {
 		cfg:          cfg,
 		q:            q,
 	}
-	w.LoadMerkleTree(lastDay)
-	w.LoadMerkleSumTree(lastDay)
-	go w.UpdateContractAddressJob()
-	go w.UpdateGlobalWorkloadJob()
+	v.LoadMerkleTree(lastDay)
+	v.LoadMerkleSumTree(lastDay)
+	go v.UpdateContractAddressJob()
+	go v.UpdateGlobalWorkloadJob()
 	<-time.After(time.Second * 3)
-	go w.Ticker()
-	// go w.Mock()
-	// go w.ProcessDay()
+	go v.Ticker()
+	// go v.Mock()
+	// go v.ProcessDay()
 
-	return w
+	return v
 }
 
-func (w *Witness) AddPendingProof(miner common.Address, proof *witnessv1.ValidatedProof) {
-	w.Lock()
-	defer w.Unlock()
+func (v *Validator) AddPendingProof(miner common.Address, proof *validatorv1.ValidatedProof) {
+	v.Lock()
+	defer v.Unlock()
 
 	var userTodayWorkload uint64
-	currentPendingProof, ok := w.pendingProof[w.todayTimestamp()][miner]
+	currentPendingProof, ok := v.pendingProof[v.todayTimestamp()][miner]
 	if ok {
 		userTodayWorkload = currentPendingProof.Workload
 	}
 
-	if w.pendingProof[w.todayTimestamp()] == nil {
-		w.pendingProof[w.todayTimestamp()] = make(map[common.Address]*witnessv1.ValidatedProof)
+	if v.pendingProof[v.todayTimestamp()] == nil {
+		v.pendingProof[v.todayTimestamp()] = make(map[common.Address]*validatorv1.ValidatedProof)
 	}
-	w.pendingProof[w.todayTimestamp()][miner] = &witnessv1.ValidatedProof{Workload: userTodayWorkload + proof.Workload}
+	v.pendingProof[v.todayTimestamp()][miner] = &validatorv1.ValidatedProof{Workload: userTodayWorkload + proof.Workload}
 
 	log.WithFields(log.Fields{
 		"miner":            miner.Hex(),
 		"current_workload": userTodayWorkload + proof.Workload,
 		"workload":         proof.Workload,
-		"global_workload":  w.pendingWorkload,
+		"global_workload":  v.pendingWorkload,
 	}).Debug("add validated proof")
 }
 
-func (w *Witness) ProcessDayJob() {
-	log.Debugln("process day job", w.yesterdayTimestamp(), w.todayTimestamp())
-	w.LoadPendingProofs(w.yesterdayTimestamp(), w.todayTimestamp())
-	w.date = w.yesterdayString()
-	dayProof := w.Commit()
-	mstRoot, _, err := w.CommitMST(dayProof)
+func (v *Validator) ProcessDayJob() {
+	log.Debugln("process day job", v.yesterdayTimestamp(), v.todayTimestamp())
+	v.LoadPendingProofs(v.yesterdayTimestamp(), v.todayTimestamp())
+	v.date = v.yesterdayString()
+	dayProof := v.Commit()
+	mstRoot, _, err := v.CommitMST(dayProof)
 	if err != nil {
 		log.WithError(err).Error("failed to commit merkle sum tree")
 		return
 	}
-	objects := w.state.IterAllObject()
-	mtRoot, err := w.CommitMT(objects)
+	objects := v.state.IterAllObject()
+	mtRoot, err := v.CommitMT(objects)
 	if err != nil {
 		log.WithError(err).Error("failed to commit merkle tree")
 		return
 	}
-	err = w.lvdb.Put([]byte("lastday"), []byte(w.date))
+	err = v.lvdb.Put([]byte("lastday"), []byte(v.date))
 	if err != nil {
 		log.WithError(err).Error("db failed to update last day")
 		return
 	}
-	txHash, err := w.rpc.SubmitProofs(w.date, mstRoot, mtRoot)
+	txHash, err := v.rpc.SubmitProofs(v.dateToTimestamp(v.date), mstRoot, mtRoot)
 	if err != nil {
 		log.WithError(err).Error("submit proofs")
 		return
 	}
-	err = w.lvdb.Put([]byte(fmt.Sprintf("txid:%s", w.date)), txHash.Bytes())
+	err = v.lvdb.Put([]byte(fmt.Sprintf("txid:%s", v.date)), txHash.Bytes())
 	if err != nil {
 		log.WithError(err).Error("db failed to save txid")
 		return
@@ -149,10 +149,10 @@ func (w *Witness) ProcessDayJob() {
 	log.Info("process day done")
 }
 
-func (w *Witness) Commit() (dayProofs map[common.Address]*witnessv1.ValidatedProof) {
+func (v *Validator) Commit() (dayProofs map[common.Address]*validatorv1.ValidatedProof) {
 	st := time.Now()
-	proof, totalWorkload := w.RefreshPendingProof()
-	balancePerWorkload, err := w.rpc.GetWorkloadThreshold(totalWorkload)
+	proof, totalWorkload := v.RefreshPendingProof()
+	balancePerWorkload, err := v.rpc.GetWorkloadThreshold(totalWorkload)
 	if err != nil {
 		log.WithError(err).Error("failed to get workload threshold")
 		return
@@ -161,18 +161,18 @@ func (w *Witness) Commit() (dayProofs map[common.Address]*witnessv1.ValidatedPro
 	for miner, proof := range proof {
 		balance := big.NewInt(0).Mul(balancePerWorkload, big.NewInt(int64(proof.Workload)))
 		proof.Balance = balance.String()
-		err := w.SealProof(miner, proof)
+		err := v.SealProof(miner, proof)
 		if err != nil {
 			log.WithError(err).Error("failed to seal proof")
 			return
 		}
 	}
-	root, err := w.state.Commit()
+	root, err := v.state.Commit()
 	if err != nil {
 		return
 	}
 	log.WithFields(log.Fields{"root": root.Hex(), "cost": time.Since(st).String()}).Info("commit state root")
-	err = w.lvdb.Put([]byte(fmt.Sprintf("sroot:%s", w.date)), root.Bytes())
+	err = v.lvdb.Put([]byte(fmt.Sprintf("sroot:%s", v.date)), root.Bytes())
 	if err != nil {
 		log.WithError(err).Error("failed to update state root")
 		return
@@ -180,11 +180,11 @@ func (w *Witness) Commit() (dayProofs map[common.Address]*witnessv1.ValidatedPro
 	return proof
 }
 
-func (w *Witness) SealProof(miner common.Address, proof *witnessv1.ValidatedProof) (err error) {
-	minerObject := w.state.GetMinerObject(miner)
+func (v *Validator) SealProof(miner common.Address, proof *validatorv1.ValidatedProof) (err error) {
+	minerObject := v.state.GetMinerObject(miner)
 	oldBalance := minerObject.Balance
 	minerObject.Balance = util.MustAddStringToBigInt(oldBalance, proof.Balance).String()
-	err = w.state.UpdateMinerObject(miner, minerObject)
+	err = v.state.UpdateMinerObject(miner, minerObject)
 	if err != nil {
 		return err
 	}
@@ -196,12 +196,12 @@ func (w *Witness) SealProof(miner common.Address, proof *witnessv1.ValidatedProo
 	return err
 }
 
-func (w *Witness) RefreshPendingProof() (proof map[common.Address]*witnessv1.ValidatedProof, totalWorkload uint64) {
-	w.Lock()
-	defer w.Unlock()
-	proof = make(map[common.Address]*witnessv1.ValidatedProof)
-	for timestamp, pendingProofMap := range w.pendingProof {
-		if timestamp != w.todayTimestamp() {
+func (v *Validator) RefreshPendingProof() (proof map[common.Address]*validatorv1.ValidatedProof, totalWorkload uint64) {
+	v.Lock()
+	defer v.Unlock()
+	proof = make(map[common.Address]*validatorv1.ValidatedProof)
+	for timestamp, pendingProofMap := range v.pendingProof {
+		if timestamp != v.todayTimestamp() {
 			continue
 		}
 		for miner, pendingProof := range pendingProofMap {
@@ -209,27 +209,27 @@ func (w *Witness) RefreshPendingProof() (proof map[common.Address]*witnessv1.Val
 			totalWorkload += pendingProof.Workload
 		}
 	}
-	w.pendingProof[w.yesterdayTimestamp()] = make(map[common.Address]*witnessv1.ValidatedProof)
+	v.pendingProof[v.yesterdayTimestamp()] = make(map[common.Address]*validatorv1.ValidatedProof)
 	return
 }
 
-func (w *Witness) Ticker() {
-	executionTime := time.Date(time.Now().Year(), time.Now().Month(), time.Now().Day(), 0, 0, w.cfg.CommitTime, 0, time.UTC).Add(w.duration())
-	// executionTime := time.Now().Add(w.duration())
+func (v *Validator) Ticker() {
+	executionTime := time.Date(time.Now().Year(), time.Now().Month(), time.Now().Day(), 0, 0, v.cfg.CommitTime, 0, time.UTC).Add(v.duration())
+	// executionTime := time.Now().Add(v.duration())
 	waitTime := executionTime.Sub(time.Now())
 	timer := time.NewTimer(waitTime)
 	log.WithField("wait_time", waitTime.String()).Info("prepare commit task")
 	for {
 		<-timer.C
-		w.ProcessDayJob()
-		executionTime = executionTime.Add(w.duration())
+		v.ProcessDayJob()
+		executionTime = executionTime.Add(v.duration())
 		waitTime = executionTime.Sub(time.Now())
 		timer.Reset(waitTime)
 		log.WithField("wait time", waitTime.String()).Info("prepare commit task")
 	}
 }
 
-func (w *Witness) Mock() {
+func (v *Validator) Mock() {
 	addresses := make([]common.Address, 10)
 	rand.Seed(time.Now().Unix())
 	for i := 0; i < 10; i++ {
@@ -240,15 +240,15 @@ func (w *Witness) Mock() {
 
 	for {
 		time.Sleep(time.Second)
-		w.AddPendingProof(addresses[rand.Intn(10)], &witnessv1.ValidatedProof{
+		v.AddPendingProof(addresses[rand.Intn(10)], &validatorv1.ValidatedProof{
 			Workload:  uint64((rand.Int63n(9) + 1) * 100),
 			Timestamp: uint64(time.Now().Unix() - 1),
 		})
 	}
 }
 
-func (w *Witness) IsContainerAddress(address common.Address) bool {
-	for _, addr := range w.containerAddresses {
+func (v *Validator) IsContainerAddress(address common.Address) bool {
+	for _, addr := range v.containerAddresses {
 		if addr.Hex() == address.Hex() {
 			return true
 		}
@@ -256,8 +256,8 @@ func (w *Witness) IsContainerAddress(address common.Address) bool {
 	return false
 }
 
-func (w *Witness) IsNMAddress(address common.Address) bool {
-	for _, addr := range w.nmAddresses {
+func (v *Validator) IsNMAddress(address common.Address) bool {
+	for _, addr := range v.nmAddresses {
 		if addr.Hex() == address.Hex() {
 			return true
 		}
@@ -265,30 +265,30 @@ func (w *Witness) IsNMAddress(address common.Address) bool {
 	return false
 }
 
-func (w *Witness) todayString() string {
-	return time.Unix(w.todayTimestamp(), 0).Format("2006-01-02")
+func (v *Validator) todayString() string {
+	return time.Unix(v.todayTimestamp(), 0).Format("2006-01-02")
 }
 
-func (w *Witness) yesterdayString() string {
-	return time.Unix(w.yesterdayTimestamp(), 0).Format("2006-01-02")
+func (v *Validator) yesterdayString() string {
+	return time.Unix(v.yesterdayTimestamp(), 0).Format("2006-01-02")
 }
 
-func (w *Witness) todayTimestamp() int64 {
+func (v *Validator) todayTimestamp() int64 {
 	now := time.Now().UTC()
-	// today := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, time.UTC)
+	// today := time.Date(nov.Year(), nov.Month(), nov.Day(), 0, 0, 0, 0, time.UTC)
 	today := time.Date(now.Year(), now.Month(), 6, 0, 0, 0, 0, time.UTC)
 	return today.Unix()
 }
 
-func (w *Witness) yesterdayTimestamp() int64 {
-	return w.todayTimestamp() - 86400
+func (v *Validator) yesterdayTimestamp() int64 {
+	return v.todayTimestamp() - 86400
 }
 
-func (w *Witness) dateToTimestamp(date string) int64 {
+func (v *Validator) dateToTimestamp(date string) int64 {
 	t, _ := time.ParseInLocation("2006-01-02", date, time.UTC)
 	return t.Unix()
 }
 
-func (w *Witness) duration() time.Duration {
+func (v *Validator) duration() time.Duration {
 	return 3600 * 24 * time.Second
 }

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() {