interface.go

package core

import (
	"fmt"
	"math/big"
	"validator/tree"

	"github.com/ethereum/go-ethereum/common"
	"github.com/ethereum/go-ethereum/crypto"
	log "github.com/sirupsen/logrus"
)

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.WithFields(log.Fields{
		"address":  address.Hex(),
		"workload": wl,
	}).Debug("quest get pending workload")
	return wl, v.pendingWorkload
}

func (v *Validator) GetMerkleProof(address common.Address, date string) (balance string, proofs []common.Hash) {
	if date == "" {
		date = v.date
	}
	if ok := v.LoadMerkleTree(date); !ok {
		log.WithFields(log.Fields{
			"date": date,
		}).Error("load merkle proof empty")
		return "0", nil
	}
	v.Lock()
	cacheTree := v.mtTreeCache[date]
	v.Unlock()
	var sdb *StateDB
	if date == v.date {
		sdb = v.state
	} else {
		dateStateRootKey := fmt.Sprintf("sroot:%s", date)
		dateStateRoot, err := v.lvdb.Get([]byte(dateStateRootKey))
		if err != nil {
			log.WithFields(log.Fields{
				"key": dateStateRootKey,
				"err": err.Error(),
			}).Error("failed to get state root")
			return "0", nil
		}
		sdb, err = NewStateDB(v.lvdb, common.BytesToHash(dateStateRoot))
		if err != nil {
			log.WithError(err).Error("failed to create state db")
			return "0", nil
		}
	}
	object := sdb.GetMinerObject(address)
	if object == nil {
		return "0", nil
	}
	if object.Balance == "" {
		object.Balance = "0"
	}
	bigBalance, _ := new(big.Int).SetString(object.Balance, 10)
	payload := append(common.HexToAddress(object.Miner).Bytes(), common.LeftPadBytes(bigBalance.Bytes(), 32)...)
	leaf := crypto.Keccak256Hash(payload)
	log.WithFields(log.Fields{
		"date":    date,
		"root":    cacheTree.GetRoot().Hex(),
		"payload": payload,
		"leaf":    leaf.Hex(),
	}).Debug("cacheTree.GetProof(leaf)")

	// 遍历tree
	for i, layer := range cacheTree.Layers() {
		log.WithField("depth", i).Debug(layer)
	}

	proofs, err := cacheTree.GetProof(leaf)
	if err != nil {
		log.WithError(err).Error("failed to get merkle proof")
		return "0", make([]common.Hash, 0)
	}
	if len(proofs) == 0 {
		return "0", make([]common.Hash, 0)
	}

	return object.Balance, proofs
}

func (v *Validator) GetDailyMerkleNodes(date string, depth int, rootHash common.Hash) (nodes [][]common.Hash) {
	if date == "" {
		date = v.date
	}
	if ok := v.LoadMerkleTree(date); !ok {
		log.WithFields(log.Fields{
			"date": date,
		}).Error("load merkle proof empty")
		return nil
	}
	v.Lock()
	cacheTree := v.mtTreeCache[date]
	v.Unlock()

	rootNode := cacheTree.GetRootNode()
	if rootHash.Hex() == (common.Hash{}).Hex() {
		rootNode = cacheTree.GetRootNode()
	} else if rootHash.Hex() != rootNode.Hash.Hex() {
		rootNode = cacheTree.FindMerkleNode(rootHash)
	}
	return tree.MerkleTreeTraversal(rootNode, depth)
}

func (v *Validator) GetDailyMerkleSumNodes(date string, depth int, rootHash common.Hash) (nodesHash [][]common.Hash, nodesVal [][]string) {
	if date == "" {
		date = v.date
	}
	v.Lock()
	cacheTree, ok := v.mstTreeCache[date]
	v.Unlock()
	if !ok {
		if ok = v.LoadMerkleSumTree(date); !ok {
			log.WithFields(log.Fields{
				"date": date,
			}).Error("load merkle sum proof empty")
			return nil, nil
		}
	}
	v.Lock()
	cacheTree = v.mstTreeCache[date]
	v.Unlock()

	rootNode := cacheTree.GetRoot()
	if rootHash.Hex() == (common.Hash{}).Hex() {
		rootNode = cacheTree.GetRoot()
	} else if rootHash.Hex() != rootNode.Value.Hash.Hex() {
		rootNode = cacheTree.FindMerkleSumNode(rootHash)
	}
	vlss := tree.MerkleSumTreeTraversal(rootNode, depth)
	for i := 0; i < len(vlss); i++ {
		_nodesHash := make([]common.Hash, 0)
		_nodesVal := make([]string, 0)
		for j := 0; j < len(vlss[i]); j++ {
			_nodesHash = append(_nodesHash, vlss[i][j].Hash)
			_nodesVal = append(_nodesVal, vlss[i][j].BigValue.String())
		}
		nodesHash = append(nodesHash, _nodesHash)
		nodesVal = append(nodesVal, _nodesVal)
	}
	return nodesHash, nodesVal
}

// GetWorkload /api/v1/workload
func (v *Validator) GetWorkload(timestampList []uint64) (ret []map[string]string, err error) {

	for _, timestamp := range timestampList {
		r, w, wei, err := v.rpc.GetWeiPerWorkload(timestamp)
		if err != nil {
			return nil, err
		}
		ret = append(ret, map[string]string{
			"date":           v.timestampToDate(int64(timestamp)),
			"weiPerWorkload": wei.String(),
			"reward":         r.String(),
			"workload":       w.String(),
		})
	}
	return ret, nil
}

// GetReward /api/v1/reward
func (v *Validator) GetReward(address common.Address) (reward *big.Int) {
	object := v.state.GetMinerObject(address)
	if object == nil {
		return big.NewInt(0)
	}
	b, ok := big.NewInt(0).SetString(object.Balance, 10)
	if !ok {
		return big.NewInt(0)
	}
	return b
}