Merge pull request #85 from MinterTeam/dev

v0.2.0

CHANGELOG.md

@@ -4,6 +4,29 @@
 
 - [api] Add validators rewards to block api
 
+## 0.2.0
+*Aug 22th, 2018*
+
+BREAKING CHANGES
+
+- [testnet] New testnet id
+- [core] New rewards
+- [core] Validators list are now updated each 12 blocks
+- [core] Set DAO commission to 10% 
+- [core] Add Developers commission of 10%
+- [core] Now stake of custom coin is calculated by selling all such staked coins
+- [api] Reformatted candidates and validators endpoints
+- [api] tx.return tags are now encoded as strings
+
+IMPROVEMENT
+
+- [tendermint] Update tendermint to 0.23.0
+- [api] Add block reward to api
+- [api] Add bip_value field to Stake
+- [api] Add /api/candidates endpoint
+- [api] Add /api/estimateTxCommission endpoint
+- [gui] Minor GUI update
+
 ## 0.1.9
 *Aug 19th, 2018*
 

Gopkg.toml

@@ -63,7 +63,7 @@
 
 [[constraint]]
   name = "github.com/tendermint/tendermint"
-  version = "=v0.22.8"
+  version = "=v0.23.0"
 
 [[constraint]]
   branch = "v1"

api/api.go

@@ -36,6 +36,7 @@ func RunApi(b *minter.Blockchain, node *node.Node) {
 	router := mux.NewRouter().StrictSlash(true)
 
 	router.HandleFunc("/api/bipVolume", GetBipVolume).Methods("GET")
+	router.HandleFunc("/api/candidates", GetCandidates).Methods("GET")
 	router.HandleFunc("/api/candidate/{pubkey}", GetCandidate).Methods("GET")
 	router.HandleFunc("/api/validators", GetValidators).Methods("GET")
 	router.HandleFunc("/api/balance/{address}", GetBalance).Methods("GET")
@@ -52,6 +53,7 @@ func RunApi(b *minter.Blockchain, node *node.Node) {
 	router.HandleFunc("/api/coinInfo/{symbol}", GetCoinInfo).Methods("GET")
 	router.HandleFunc("/api/estimateCoinSell", EstimateCoinSell).Methods("GET")
 	router.HandleFunc("/api/estimateCoinBuy", EstimateCoinBuy).Methods("GET")
+	router.HandleFunc("/api/estimateTxCommission", EstimateTxCommission).Methods("GET")
 
 	c := cors.New(cors.Options{
 		AllowedOrigins:   []string{"*"},

api/block.go

@@ -3,6 +3,7 @@ package api
 import (
 	"encoding/json"
 	"fmt"
+	"github.com/MinterTeam/minter-go-node/core/rewards"
 	"github.com/MinterTeam/minter-go-node/core/transaction"
 	"github.com/MinterTeam/minter-go-node/core/types"
 	"github.com/gorilla/mux"
@@ -21,6 +22,7 @@ type BlockResponse struct {
 	TotalTxs     int64                      `json:"total_txs"`
 	Transactions []BlockTransactionResponse `json:"transactions"`
 	Precommits   json.RawMessage            `json:"precommits"`
+	BlockReward  string                     `json:"block_reward"`
 }
 
 type BlockTransactionResponse struct {
@@ -51,8 +53,8 @@ func Block(w http.ResponseWriter, r *http.Request) {
 	if err != nil {
 		w.WriteHeader(http.StatusBadRequest)
 		json.NewEncoder(w).Encode(Response{
-			Code:   0,
-			Result: err.Error(),
+			Code: 0,
+			Log:  err.Error(),
 		})
 		return
 	}
@@ -97,8 +99,9 @@ func Block(w http.ResponseWriter, r *http.Request) {
 		Time:         block.Block.Time,
 		NumTxs:       block.Block.NumTxs,
 		TotalTxs:     block.Block.TotalTxs,
-		Precommits:   json.RawMessage(precommits),
 		Transactions: txs,
+		Precommits:   json.RawMessage(precommits),
+		BlockReward:  rewards.GetRewardForBlock(uint64(height)).String(),
 	}
 
 	err = json.NewEncoder(w).Encode(Response{

api/candidate.go

@@ -35,7 +35,7 @@ func GetCandidate(w http.ResponseWriter, r *http.Request) {
 		Result: struct {
 			Candidate Candidate `json:"candidate"`
 		}{
-			Candidate: makeResponseCandidate(*candidate),
+			Candidate: makeResponseCandidate(*candidate, cState),
 		},
 	})
 }

api/candidates.go

@@ -0,0 +1,28 @@
+package api
+
+import (
+	"encoding/json"
+	"net/http"
+)
+
+func GetCandidates(w http.ResponseWriter, r *http.Request) {
+
+	cState := GetStateForRequest(r)
+
+	candidates := cState.GetStateCandidates().GetData()
+
+	w.Header().Set("Content-Type", "application/json; charset=UTF-8")
+
+	var result []Candidate
+
+	for _, candidate := range candidates {
+		result = append(result, makeResponseCandidate(candidate, cState))
+	}
+
+	w.WriteHeader(http.StatusOK)
+
+	json.NewEncoder(w).Encode(Response{
+		Code:   0,
+		Result: result,
+	})
+}

api/estimate_tx_commission.go

@@ -0,0 +1,61 @@
+package api
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/MinterTeam/minter-go-node/core/transaction"
+	"github.com/MinterTeam/minter-go-node/formula"
+	"github.com/MinterTeam/minter-go-node/hexutil"
+	"math/big"
+	"net/http"
+)
+
+func EstimateTxCommission(w http.ResponseWriter, r *http.Request) {
+
+	cState := GetStateForRequest(r)
+
+	query := r.URL.Query()
+	rawTx := query.Get("tx")
+	bytesTx, _ := hexutil.Decode(rawTx)
+
+	tx, err := transaction.DecodeFromBytes(bytesTx)
+
+	if err != nil {
+		w.WriteHeader(http.StatusBadRequest)
+		json.NewEncoder(w).Encode(Response{
+			Code: 0,
+			Log:  err.Error(),
+		})
+		return
+	}
+
+	commissionInBaseCoin := big.NewInt(0).Mul(tx.GasPrice, big.NewInt(tx.Gas()))
+	commissionInBaseCoin.Mul(commissionInBaseCoin, transaction.CommissionMultiplier)
+	commission := big.NewInt(0).Set(commissionInBaseCoin)
+
+	if !tx.GasCoin.IsBaseCoin() {
+		coin := cState.GetStateCoin(tx.GasCoin)
+
+		if coin.ReserveBalance().Cmp(commissionInBaseCoin) < 0 {
+
+			w.WriteHeader(http.StatusBadRequest)
+			json.NewEncoder(w).Encode(Response{
+				Code: 0,
+				Log:  fmt.Sprintf("Coin reserve balance is not sufficient for transaction. Has: %s, required %s", coin.ReserveBalance().String(), commissionInBaseCoin.String()),
+			})
+			return
+		}
+
+		commission = formula.CalculateSaleAmount(coin.Volume(), coin.ReserveBalance(), coin.Data().Crr, commissionInBaseCoin)
+	}
+
+	w.WriteHeader(http.StatusOK)
+	json.NewEncoder(w).Encode(Response{
+		Code: 0,
+		Result: struct {
+			Commission string `json:"commission"`
+		}{
+			Commission: commission.String(),
+		},
+	})
+}

api/validators.go

@@ -5,34 +5,62 @@ import (
 	"fmt"
 	"github.com/MinterTeam/minter-go-node/core/state"
 	"github.com/MinterTeam/minter-go-node/core/types"
-	"github.com/MinterTeam/minter-go-node/core/validators"
 	"net/http"
 	"strconv"
 )
 
+type Stake struct {
+	Owner    types.Address    `json:"owner"`
+	Coin     types.CoinSymbol `json:"coin"`
+	Value    string           `json:"value"`
+	BipValue string           `json:"bip_value"`
+}
+
 type Candidate struct {
 	CandidateAddress types.Address `json:"candidate_address"`
 	TotalStake       string        `json:"total_stake"`
 	PubKey           string        `json:"pub_key"`
 	Commission       uint          `json:"commission"`
-	AccumReward      string        `json:"accumulated_reward"`
-	Stakes           []state.Stake `json:"stakes"`
+	Stakes           []Stake       `json:"stakes"`
 	CreatedAtBlock   uint          `json:"created_at_block"`
 	Status           byte          `json:"status"`
-	AbsentTimes      uint          `json:"absent_times"`
 }
 
-func makeResponseCandidate(c state.Candidate) Candidate {
+type Validator struct {
+	AccumReward string    `json:"accumulated_reward"`
+	AbsentTimes uint      `json:"absent_times"`
+	Candidate   Candidate `json:"candidate"`
+}
+
+func makeResponseValidator(v state.Validator, state *state.StateDB) Validator {
+	return Validator{
+		AccumReward: v.AccumReward.String(),
+		AbsentTimes: v.AbsentTimes,
+		Candidate:   makeResponseCandidate(*state.GetStateCandidate(v.PubKey), state),
+	}
+}
+
+func makeResponseCandidate(c state.Candidate, state *state.StateDB) Candidate {
+
+	stakes := make([]Stake, len(c.Stakes))
+
+	for i, stake := range c.Stakes {
+		stakes[i] = Stake{
+			Owner:    stake.Owner,
+			Coin:     stake.Coin,
+			Value:    stake.Value.String(),
+			BipValue: stake.BipValue(state).String(),
+		}
+	}
+
 	return Candidate{
 		CandidateAddress: c.CandidateAddress,
 		TotalStake:       c.TotalBipStake.String(),
 		PubKey:           fmt.Sprintf("Mp%x", c.PubKey),
 		Commission:       c.Commission,
-		AccumReward:      c.AccumReward.String(),
-		Stakes:           c.Stakes,
+		Stakes:           stakes,
 		CreatedAtBlock:   c.CreatedAtBlock,
 		Status:           c.Status,
-		AbsentTimes:      c.AbsentTimes,
 	}
 }
 
@@ -44,19 +72,20 @@ func GetValidators(w http.ResponseWriter, r *http.Request) {
 		height = int(blockchain.Height())
 	}
 
-	_, candidates := GetStateForRequest(r).GetValidators(validators.GetValidatorsCountForBlock(uint64(height)))
+	rState := GetStateForRequest(r)
+	vals := rState.GetStateValidators().Data()
 
 	w.Header().Set("Content-Type", "application/json; charset=UTF-8")
 	w.WriteHeader(http.StatusOK)
 
-	var responseCandidates []Candidate
+	var responseValidators []Validator
 
-	for _, candidate := range candidates {
-		responseCandidates = append(responseCandidates, makeResponseCandidate(candidate))
+	for _, val := range vals {
+		responseValidators = append(responseValidators, makeResponseValidator(val, rState))
 	}
 
 	json.NewEncoder(w).Encode(Response{
 		Code:   0,
-		Result: responseCandidates,
+		Result: responseValidators,
 	})
 }

cmd/minter/main.go

@@ -58,7 +58,7 @@ func startTendermintNode(app *minter.Blockchain) *tmNode.Node {
 		proxy.NewLocalClientCreator(app),
 		genesis.GetTestnetGenesis,
 		tmNode.DefaultDBProvider,
-		tmNode.DefaultMetricsProvider,
+		tmNode.DefaultMetricsProvider(cfg.Instrumentation),
 		log.With("module", "tendermint"),
 	)
 

core/dao/dao.go

@@ -3,6 +3,6 @@ package dao
 import "github.com/MinterTeam/minter-go-node/core/types"
 
 var (
-	Address    = types.HexToAddress("Mxa93163fdf10724dc4785ff5cbfb9ac0b5949409f")
-	Commission = 5
+	Address    = types.HexToAddress("Mxee81347211c72524338f9680072af90744333146")
+	Commission = 10
 )

core/developers/developers.go

@@ -0,0 +1,8 @@
+package developers
+
+import "github.com/MinterTeam/minter-go-node/core/types"
+
+var (
+	Address    = types.HexToAddress("Mx444c4f1953ea170f74eabef4eee52ed8276a7d5e")
+	Commission = 10
+)

core/developers/developers_test.go

@@ -0,0 +1 @@
+package developers