From 47f4237fb3576badfcbb5bd3c0d85fc1fa2b0ee4 Mon Sep 17 00:00:00 2001 From: Daniel Van Der Maden Date: Thu, 4 Feb 2021 16:04:01 -0800 Subject: [PATCH] [explorer] Add compensation for InaccessibleAddresses Signed-off-by: Daniel Van Der Maden --- api/service/explorer/service.go | 93 ++++++++++++++++++++++++++++++--- 1 file changed, 87 insertions(+), 6 deletions(-) diff --git a/api/service/explorer/service.go b/api/service/explorer/service.go index 32f6430f7..91b7357d5 100644 --- a/api/service/explorer/service.go +++ b/api/service/explorer/service.go @@ -4,18 +4,22 @@ import ( "context" "encoding/json" "fmt" + "math/big" "net" "net/http" "strconv" "time" + ethCommon "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/rpc" "github.com/gorilla/mux" msg_pb "github.com/harmony-one/harmony/api/proto/message" "github.com/harmony-one/harmony/api/service/syncing" "github.com/harmony-one/harmony/core" "github.com/harmony-one/harmony/internal/chain" + "github.com/harmony-one/harmony/internal/common" "github.com/harmony-one/harmony/internal/utils" + "github.com/harmony-one/harmony/numeric" "github.com/harmony-one/harmony/p2p" stakingReward "github.com/harmony-one/harmony/staking/reward" ) @@ -84,7 +88,8 @@ func (s *Service) Init() { // Run is to run serving explorer. func (s *Service) Run() *http.Server { // Init address. - addr := net.JoinHostPort("", GetExplorerPort(s.Port)) + port := GetExplorerPort(s.Port) + addr := net.JoinHostPort("", port) s.router = mux.NewRouter() @@ -94,11 +99,11 @@ func (s *Service) Run() *http.Server { s.router.Path("/addresses").Queries("size", "{[0-9]*?}", "prefix", "{[a-zA-Z0-9]*?}").HandlerFunc(s.GetAddresses).Methods("GET") s.router.Path("/addresses").HandlerFunc(s.GetAddresses) - // Set up router for node count. + // Set up router for supply info + s.router.Path("/burn-addresses").Queries().HandlerFunc(s.GetInaccessibleAddressInfo).Methods("GET") + s.router.Path("/burn-addresses").HandlerFunc(s.GetInaccessibleAddressInfo) s.router.Path("/circulating-supply").Queries().HandlerFunc(s.GetCirculatingSupply).Methods("GET") s.router.Path("/circulating-supply").HandlerFunc(s.GetCirculatingSupply) - - // Set up router for node count. s.router.Path("/total-supply").Queries().HandlerFunc(s.GetTotalSupply).Methods("GET") s.router.Path("/total-supply").HandlerFunc(s.GetTotalSupply) @@ -152,7 +157,72 @@ func (s *Service) GetAddresses(w http.ResponseWriter, r *http.Request) { } } +var ( + // InaccessibleAddresses are a list of known eth addresses that cannot spend ONE tokens. + InaccessibleAddresses = []ethCommon.Address{ + // one10000000000000000000000000000dead5shlag + ethCommon.HexToAddress("0x7bDeF7Bdef7BDeF7BDEf7bDef7bdef7bdeF6E7AD"), + } +) + +// InaccessibleAddressInfo .. +type InaccessibleAddressInfo struct { + EthAddress ethCommon.Address `json:"eth-address"` + Address string `json:"address"` + Balance numeric.Dec `json:"balance"` + Nonce uint64 `json:"nonce"` +} + +// getAllInaccessibleAddresses information according to InaccessibleAddresses +func (s *Service) getAllInaccessibleAddresses() ([]*InaccessibleAddressInfo, error) { + state, err := s.blockchain.StateAt(s.blockchain.CurrentHeader().Root()) + if err != nil { + return nil, err + } + + accs := []*InaccessibleAddressInfo{} + for _, addr := range InaccessibleAddresses { + accs = append(accs, &InaccessibleAddressInfo{ + EthAddress: addr, + Address: common.MustAddressToBech32(addr), + Balance: numeric.NewDecFromBigIntWithPrec(state.GetBalance(addr), 18), + Nonce: state.GetNonce(addr), + }) + } + + return accs, nil +} + +// getTotalInaccessibleTokens in ONE at the latest header. +func (s *Service) getTotalInaccessibleTokens() (numeric.Dec, error) { + addrInfos, err := s.getAllInaccessibleAddresses() + if err != nil { + return numeric.Dec{}, err + } + + total := numeric.NewDecFromBigIntWithPrec(big.NewInt(0), 18) + for _, addr := range addrInfos { + total = total.Add(addr.Balance) + } + return total, nil +} + +// GetInaccessibleAddressInfo serves /burn-addresses end-point. +func (s *Service) GetInaccessibleAddressInfo(w http.ResponseWriter, r *http.Request) { + w.Header().Set("Content-Type", "application/json") + accInfos, err := s.getAllInaccessibleAddresses() + if err != nil { + utils.Logger().Warn().Err(err).Msg("unable to fetch inaccessible addresses") + w.WriteHeader(http.StatusInternalServerError) + } + if err := json.NewEncoder(w).Encode(accInfos); err != nil { + utils.Logger().Warn().Msg("cannot JSON-encode inaccessible account info") + w.WriteHeader(http.StatusInternalServerError) + } +} + // GetCirculatingSupply serves /circulating-supply end-point. +// Note that known InaccessibleAddresses have their funds removed from the supply for this endpoint. func (s *Service) GetCirculatingSupply(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "application/json") circulatingSupply, err := chain.GetCirculatingSupply(context.Background(), s.blockchain) @@ -160,13 +230,19 @@ func (s *Service) GetCirculatingSupply(w http.ResponseWriter, r *http.Request) { utils.Logger().Warn().Err(err).Msg("unable to fetch circulating supply") w.WriteHeader(http.StatusInternalServerError) } - if err := json.NewEncoder(w).Encode(circulatingSupply); err != nil { + totalInaccessible, err := s.getTotalInaccessibleTokens() + if err != nil { + utils.Logger().Warn().Err(err).Msg("unable to fetch inaccessible tokens") + w.WriteHeader(http.StatusInternalServerError) + } + if err := json.NewEncoder(w).Encode(circulatingSupply.Sub(totalInaccessible)); err != nil { utils.Logger().Warn().Msg("cannot JSON-encode circulating supply") w.WriteHeader(http.StatusInternalServerError) } } // GetTotalSupply serves /total-supply end-point. +// Note that known InaccessibleAddresses have their funds removed from the supply for this endpoint. func (s *Service) GetTotalSupply(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "application/json") totalSupply, err := stakingReward.GetTotalTokens(s.blockchain) @@ -174,7 +250,12 @@ func (s *Service) GetTotalSupply(w http.ResponseWriter, r *http.Request) { utils.Logger().Warn().Err(err).Msg("unable to fetch total supply") w.WriteHeader(http.StatusInternalServerError) } - if err := json.NewEncoder(w).Encode(totalSupply); err != nil { + totalInaccessible, err := s.getTotalInaccessibleTokens() + if err != nil { + utils.Logger().Warn().Err(err).Msg("unable to fetch inaccessible tokens") + w.WriteHeader(http.StatusInternalServerError) + } + if err := json.NewEncoder(w).Encode(totalSupply.Sub(totalInaccessible)); err != nil { utils.Logger().Warn().Msg("cannot JSON-encode total supply") w.WriteHeader(http.StatusInternalServerError) }