From xdpos 4 fix > 5

XDCx/XDCx.go

@@ -95,8 +95,14 @@ func NewMongoDBEngine(cfg *Config) *XDCxDAO.MongoDatabase {
 }
 
 func New(cfg *Config) *XDCX {
-	tokenDecimalCache, _ := lru.New(defaultCacheLimit)
-	orderCache, _ := lru.New(tradingstate.OrderCacheLimit)
+	tokenDecimalCache, err := lru.New(defaultCacheLimit)
+	if err != nil {
+		log.Warn("[XDCx-New] fail to create new lru for token decimal", "error", err)
+	}
+	orderCache, err := lru.New(tradingstate.OrderCacheLimit)
+	if err != nil {
+		log.Warn("[XDCx-New] fail to create new lru for order", "error", err)
+	}
 	XDCX := &XDCX{
 		orderNonce:        make(map[common.Address]*big.Int),
 		Triegc:            prque.New(),
@@ -121,7 +127,10 @@ func New(cfg *Config) *XDCX {
 
 // Overflow returns an indication if the message queue is full.
 func (XDCx *XDCX) Overflow() bool {
-	val, _ := XDCx.settings.Load(overflowIdx)
+	val, ok := XDCx.settings.Load(overflowIdx)
+	if !ok {
+		log.Warn("[XDCx-Overflow] fail to load overflow index")
+	}
 	return val.(bool)
 }
 
@@ -198,20 +207,12 @@ func (XDCx *XDCX) ProcessOrderPending(header *types.Header, coinbase common.Addr
 				S: common.BigToHash(S),
 			},
 		}
-		cancel := false
-		if order.Status == tradingstate.OrderStatusCancelled {
-			cancel = true
-		}
 
 		log.Info("Process order pending", "orderPending", order, "BaseToken", order.BaseToken.Hex(), "QuoteToken", order.QuoteToken)
 		originalOrder := &tradingstate.OrderItem{}
 		*originalOrder = *order
 		originalOrder.Quantity = tradingstate.CloneBigInt(order.Quantity)
 
-		if cancel {
-			order.Status = tradingstate.OrderStatusCancelled
-		}
-
 		newTrades, newRejectedOrders, err := XDCx.CommitOrder(header, coinbase, chain, statedb, XDCXstatedb, tradingstate.GetTradingOrderBookHash(order.BaseToken, order.QuoteToken), order)
 
 		for _, reject := range newRejectedOrders {
@@ -579,17 +580,16 @@ func (XDCX *XDCX) GetEmptyTradingState() (*tradingstate.TradingStateDB, error) {
 func (XDCx *XDCX) GetStateCache() tradingstate.Database {
 	return XDCx.StateCache
 }
+
 func (XDCx *XDCX) HasTradingState(block *types.Block, author common.Address) bool {
 	root, err := XDCx.GetTradingStateRoot(block, author)
 	if err != nil {
 		return false
 	}
 	_, err = XDCx.StateCache.OpenTrie(root)
-	if err != nil {
-		return false
-	}
-	return true
+	return err == nil
 }
+
 func (XDCx *XDCX) GetTriegc() *prque.Prque {
 	return XDCx.Triegc
 }
@@ -639,7 +639,7 @@ func (XDCx *XDCX) RollbackReorgTxMatch(txhash common.Hash) error {
 				continue
 			}
 			orderCacheAtTxHash := c.(map[common.Hash]tradingstate.OrderHistoryItem)
-			orderHistoryItem, _ := orderCacheAtTxHash[tradingstate.GetOrderHistoryKey(order.BaseToken, order.QuoteToken, order.Hash)]
+			orderHistoryItem := orderCacheAtTxHash[tradingstate.GetOrderHistoryKey(order.BaseToken, order.QuoteToken, order.Hash)]
 			if (orderHistoryItem == tradingstate.OrderHistoryItem{}) {
 				log.Debug("XDCx reorg: remove order due to empty orderHistory", "order", tradingstate.ToJSON(order))
 				if err := db.DeleteObject(order.Hash, &tradingstate.OrderItem{}); err != nil {

XDCx/order_processor.go

@@ -2,11 +2,12 @@ package XDCx
 
 import (
 	"encoding/json"
-	"github.com/XinFinOrg/XDC-Subnet/core/types"
 	"math/big"
 	"strconv"
 	"time"
 
+	"github.com/XinFinOrg/XDC-Subnet/core/types"
+
 	"github.com/XinFinOrg/XDC-Subnet/consensus"
 
 	"fmt"
@@ -303,7 +304,10 @@ func (XDCx *XDCX) processOrderList(coinbase common.Address, chain consensus.Chai
 		}
 		if tradedQuantity.Sign() > 0 {
 			quantityToTrade = tradingstate.Sub(quantityToTrade, tradedQuantity)
-			tradingStateDB.SubAmountOrderItem(orderBook, orderId, price, tradedQuantity, side)
+			err := tradingStateDB.SubAmountOrderItem(orderBook, orderId, price, tradedQuantity, side)
+			if err != nil {
+				log.Warn("processOrderList SubAmountOrderItem", "err", err, "orderBook", orderBook, "orderId", orderId, "price", *price, "tradedQuantity", *tradedQuantity, "side", side)
+			}
 			tradingStateDB.SetLastPrice(orderBook, price)
 			log.Debug("Update quantity for orderId", "orderId", orderId.Hex())
 			log.Debug("TRADE", "orderBook", orderBook, "Taker price", price, "maker price", order.Price, "Amount", tradedQuantity, "orderId", orderId, "side", side)
@@ -589,11 +593,22 @@ func DoSettleBalance(coinbase common.Address, takerOrder, makerOrder *tradingsta
 	masternodeOwner := statedb.GetOwner(coinbase)
 	statedb.AddBalance(masternodeOwner, matchingFee)
 
-	tradingstate.SetTokenBalance(takerOrder.UserAddress, newTakerInTotal, settleBalance.Taker.InToken, statedb)
-	tradingstate.SetTokenBalance(takerOrder.UserAddress, newTakerOutTotal, settleBalance.Taker.OutToken, statedb)
-
-	tradingstate.SetTokenBalance(makerOrder.UserAddress, newMakerInTotal, settleBalance.Maker.InToken, statedb)
-	tradingstate.SetTokenBalance(makerOrder.UserAddress, newMakerOutTotal, settleBalance.Maker.OutToken, statedb)
+	err = tradingstate.SetTokenBalance(takerOrder.UserAddress, newTakerInTotal, settleBalance.Taker.InToken, statedb)
+	if err != nil {
+		log.Warn("DoSettleBalance SetTokenBalance", "err", err, "takerOder.UserAddress", takerOrder.UserAddress, "newTakerInTotal", *newTakerInTotal, "settleBalance.Taker.InToken", settleBalance.Taker.InToken)
+	}
+	err = tradingstate.SetTokenBalance(takerOrder.UserAddress, newTakerOutTotal, settleBalance.Taker.OutToken, statedb)
+	if err != nil {
+		log.Warn("DoSettleBalance SetTokenBalance", "err", err, "takerOrder.UserAddress", takerOrder.UserAddress, "newTakerOutTotal", *newTakerOutTotal, "settleBalance.Taker.OutToken", settleBalance.Taker.OutToken)
+	}
+	err = tradingstate.SetTokenBalance(makerOrder.UserAddress, newMakerInTotal, settleBalance.Maker.InToken, statedb)
+	if err != nil {
+		log.Warn("DoSettleBalance SetTokenBalance", "err", err, "makerOrder.UserAddress", makerOrder.UserAddress, "newMakerInTotal", *newMakerInTotal, "settleBalance.Maker.InToken", settleBalance.Maker.InToken)
+	}
+	err = tradingstate.SetTokenBalance(makerOrder.UserAddress, newMakerOutTotal, settleBalance.Maker.OutToken, statedb)
+	if err != nil {
+		log.Warn("DoSettleBalance SetTokenBalance", "err", err, "makerOrder.UserAddress", makerOrder.UserAddress, "newMakerOutTotal", *newMakerOutTotal, "settleBalance.Maker.OutToken", settleBalance.Maker.OutToken)
+	}
 
 	// add balance for relayers
 	//log.Debug("ApplyXDCXMatchedTransaction settle fee for relayers",
@@ -602,8 +617,14 @@ func DoSettleBalance(coinbase common.Address, takerOrder, makerOrder *tradingsta
 	//	"makerRelayerOwner", makerExOwner,
 	//	"makerFeeToken", quoteToken, "makerFee", settleBalanceResult[makerAddr][XDCx.Fee].(*big.Int))
 	// takerFee
-	tradingstate.SetTokenBalance(takerExOwner, newTakerFee, makerOrder.QuoteToken, statedb)
-	tradingstate.SetTokenBalance(makerExOwner, newMakerFee, makerOrder.QuoteToken, statedb)
+	err = tradingstate.SetTokenBalance(takerExOwner, newTakerFee, makerOrder.QuoteToken, statedb)
+	if err != nil {
+		log.Warn("DoSettleBalance SetTokenBalance", "err", err, "takerExOwner", takerExOwner, "newTakerFee", *newTakerFee, "makerOrder.QuoteToken", makerOrder.QuoteToken)
+	}
+	err = tradingstate.SetTokenBalance(makerExOwner, newMakerFee, makerOrder.QuoteToken, statedb)
+	if err != nil {
+		log.Warn("DoSettleBalance SetTokenBalance", "err", err, "makerExOwner", makerExOwner, "newMakerFee", *newMakerFee, "makerOrder.QuoteToken", makerOrder.QuoteToken)
+	}
 	return nil
 }
 
@@ -652,7 +673,10 @@ func (XDCx *XDCX) ProcessCancelOrder(header *types.Header, tradingStateDB *tradi
 		return err, false
 	}
 	// relayers pay XDC for masternode
-	tradingstate.SubRelayerFee(originOrder.ExchangeAddress, common.RelayerCancelFee, statedb)
+	err = tradingstate.SubRelayerFee(originOrder.ExchangeAddress, common.RelayerCancelFee, statedb)
+	if err != nil {
+		log.Warn("ProcessCancelOrder SubRelayerFee", "err", err, "originOrder.ExchangeAddress", originOrder.ExchangeAddress, "common.RelayerCancelFee", *common.RelayerCancelFee)
+	}
 	masternodeOwner := statedb.GetOwner(coinbase)
 	// relayers pay XDC for masternode
 	statedb.AddBalance(masternodeOwner, common.RelayerCancelFee)
@@ -661,12 +685,24 @@ func (XDCx *XDCX) ProcessCancelOrder(header *types.Header, tradingStateDB *tradi
 	switch originOrder.Side {
 	case tradingstate.Ask:
 		// users pay token (which they have) for relayer
-		tradingstate.SubTokenBalance(originOrder.UserAddress, tokenCancelFee, originOrder.BaseToken, statedb)
-		tradingstate.AddTokenBalance(relayerOwner, tokenCancelFee, originOrder.BaseToken, statedb)
+		err := tradingstate.SubTokenBalance(originOrder.UserAddress, tokenCancelFee, originOrder.BaseToken, statedb)
+		if err != nil {
+			log.Warn("ProcessCancelOrder SubTokenBalance", "err", err, "originOrder.UserAddress", originOrder.UserAddress, "tokenCancelFee", *tokenCancelFee, "originOrder.BaseToken", originOrder.BaseToken)
+		}
+		err = tradingstate.AddTokenBalance(relayerOwner, tokenCancelFee, originOrder.BaseToken, statedb)
+		if err != nil {
+			log.Warn("ProcessCancelOrder AddTokenBalance", "err", err, "relayerOwner", relayerOwner, "tokenCancelFee", *tokenCancelFee, "originOrder.BaseToken", originOrder.BaseToken)
+		}
 	case tradingstate.Bid:
 		// users pay token (which they have) for relayer
-		tradingstate.SubTokenBalance(originOrder.UserAddress, tokenCancelFee, originOrder.QuoteToken, statedb)
-		tradingstate.AddTokenBalance(relayerOwner, tokenCancelFee, originOrder.QuoteToken, statedb)
+		err := tradingstate.SubTokenBalance(originOrder.UserAddress, tokenCancelFee, originOrder.QuoteToken, statedb)
+		if err != nil {
+			log.Warn("ProcessCancelOrder SubTokenBalance", "err", err, "originOrder.UserAddress", originOrder.UserAddress, "tokenCancelFee", *tokenCancelFee, "originOrder.QuoteToken", originOrder.QuoteToken)
+		}
+		err = tradingstate.AddTokenBalance(relayerOwner, tokenCancelFee, originOrder.QuoteToken, statedb)
+		if err != nil {
+			log.Warn("ProcessCancelOrder AddTokenBalance", "err", err, "relayerOwner", relayerOwner, "tokenCancelFee", *tokenCancelFee, "originOrder.QuoteToken", originOrder.QuoteToken)
+		}
 	default:
 	}
 	// update cancel fee

XDCx/tradingstate/journal.go

@@ -20,6 +20,7 @@ import (
 	"math/big"
 
 	"github.com/XinFinOrg/XDC-Subnet/common"
+	"github.com/XinFinOrg/XDC-Subnet/log"
 )
 
 type journalEntry interface {
@@ -78,13 +79,19 @@ type (
 )
 
 func (ch insertOrder) undo(s *TradingStateDB) {
-	s.CancelOrder(ch.orderBook, ch.order)
+	err := s.CancelOrder(ch.orderBook, ch.order)
+	if err != nil {
+		log.Warn("undo CancelOrder", "err", err, "ch.orderBook", ch.orderBook, "ch.order", ch.order)
+	}
 }
 func (ch cancelOrder) undo(s *TradingStateDB) {
 	s.InsertOrderItem(ch.orderBook, ch.orderId, ch.order)
 }
 func (ch insertLiquidationPrice) undo(s *TradingStateDB) {
-	s.RemoveLiquidationPrice(ch.orderBook, ch.price, ch.lendingBook, ch.tradeId)
+	err := s.RemoveLiquidationPrice(ch.orderBook, ch.price, ch.lendingBook, ch.tradeId)
+	if err != nil {
+		log.Warn("undo RemoveLiquidationPrice", "err", err, "ch.orderBook", ch.orderBook, "ch.price", ch.price, "ch.lendingBook", ch.lendingBook, "ch.tradeId", ch.tradeId)
+	}
 }
 func (ch removeLiquidationPrice) undo(s *TradingStateDB) {
 	s.InsertLiquidationPrice(ch.orderBook, ch.price, ch.lendingBook, ch.tradeId)

XDCx/tradingstate/relayer_state.go

@@ -41,10 +41,7 @@ func IsResignedRelayer(relayer common.Address, statedb *state.StateDB) bool {
 	slot := RelayerMappingSlot["RESIGN_REQUESTS"]
 	locBig := GetLocMappingAtKey(relayer.Hash(), slot)
 	locHash := common.BigToHash(locBig)
-	if statedb.GetState(common.HexToAddress(common.RelayerRegistrationSMC), locHash) != (common.Hash{}) {
-		return true
-	}
-	return false
+	return statedb.GetState(common.HexToAddress(common.RelayerRegistrationSMC), locHash) != (common.Hash{})
 }
 
 func GetBaseTokenLength(relayer common.Address, statedb *state.StateDB) uint64 {

XDCx/tradingstate/state_liquidationprice.go

@@ -118,7 +118,11 @@ func (self *liquidationPriceState) updateTrie(db Database) Trie {
 			self.setError(tr.TryDelete(lendingId[:]))
 			continue
 		}
-		stateObject.updateRoot(db)
+		err := stateObject.updateRoot(db)
+		if err != nil {
+			log.Warn("updateTrie updateRoot", "err", err)
+		}
+
 		// Encoding []byte cannot fail, ok to ignore the error.
 		v, _ := rlp.EncodeToBytes(stateObject)
 		self.setError(tr.TryUpdate(lendingId[:], v))

XDCx/tradingstate/state_orderbook.go

@@ -213,7 +213,10 @@ func (self *tradingExchanges) updateAsksTrie(db Database) Trie {
 				self.setError(tr.TryDelete(price[:]))
 				continue
 			}
-			orderList.updateRoot(db)
+			err := orderList.updateRoot(db)
+			if err != nil {
+				log.Warn("updateAsksTrie updateRoot", "err", err, "price", price, "orderList", *orderList)
+			}
 			// Encoding []byte cannot fail, ok to ignore the error.
 			v, _ := rlp.EncodeToBytes(orderList)
 			self.setError(tr.TryUpdate(price[:], v))
@@ -279,7 +282,10 @@ func (self *tradingExchanges) updateBidsTrie(db Database) Trie {
 				self.setError(tr.TryDelete(price[:]))
 				continue
 			}
-			orderList.updateRoot(db)
+			err := orderList.updateRoot(db)
+			if err != nil {
+				log.Warn("updateBidsTrie updateRoot", "err", err, "price", price, "orderList", *orderList)
+			}
 			// Encoding []byte cannot fail, ok to ignore the error.
 			v, _ := rlp.EncodeToBytes(orderList)
 			self.setError(tr.TryUpdate(price[:], v))
@@ -753,7 +759,10 @@ func (self *tradingExchanges) updateLiquidationPriceTrie(db Database) Trie {
 				self.setError(tr.TryDelete(price[:]))
 				continue
 			}
-			stateObject.updateRoot(db)
+			err := stateObject.updateRoot(db)
+			if err != nil {
+				log.Warn("updateLiquidationPriceTrie updateRoot", "err", err, "price", price, "stateObject", *stateObject)
+			}
 			// Encoding []byte cannot fail, ok to ignore the error.
 			v, _ := rlp.EncodeToBytes(stateObject)
 			self.setError(tr.TryUpdate(price[:], v))

XDCx/tradingstate/statedb.go

@@ -539,7 +539,10 @@ func (s *TradingStateDB) Finalise() {
 	for addr, stateObject := range s.stateExhangeObjects {
 		if _, isDirty := s.stateExhangeObjectsDirty[addr]; isDirty {
 			// Write any storage changes in the state object to its storage trie.
-			stateObject.updateAsksRoot(s.db)
+			err := stateObject.updateAsksRoot(s.db)
+			if err != nil {
+				log.Warn("Finalise updateAsksRoot", "err", err, "addr", addr, "stateObject", *stateObject)
+			}
 			stateObject.updateBidsRoot(s.db)
 			stateObject.updateOrdersRoot(s.db)
 			stateObject.updateLiquidationPriceRoot(s.db)
@@ -713,7 +716,10 @@ func (self *TradingStateDB) RemoveLiquidationPrice(orderBook common.Hash, price
 	lendingBookState.subVolume(One)
 	liquidationPriceState.subVolume(One)
 	if liquidationPriceState.Volume().Sign() == 0 {
-		orderbookState.getLiquidationPriceTrie(self.db).TryDelete(priceHash[:])
+		err := orderbookState.getLiquidationPriceTrie(self.db).TryDelete(priceHash[:])
+		if err != nil {
+			log.Warn("RemoveLiquidationPrice getLiquidationPriceTrie.TryDelete", "err", err, "priceHash", priceHash[:])
+		}
 	}
 	orderbookState.subLendingCount(One)
 	self.journal = append(self.journal, removeLiquidationPrice{

XDCxDAO/leveldb.go

@@ -58,7 +58,7 @@ func NewBatchDatabaseWithEncode(datadir string, cacheLimit int) *BatchDatabase {
 }
 
 func (db *BatchDatabase) IsEmptyKey(key []byte) bool {
-	return key == nil || len(key) == 0 || bytes.Equal(key, db.emptyKey)
+	return len(key) == 0 || bytes.Equal(key, db.emptyKey)
 }
 
 func (db *BatchDatabase) getCacheKey(key []byte) string {
@@ -172,13 +172,13 @@ func (db *BatchDatabase) Sync() error {
 }
 
 func (db *BatchDatabase) NewIterator(prefix []byte, start []byte) ethdb.Iterator {
-	return db.NewIterator(prefix, start)
+	panic("NewIterator from XDCxDAO leveldb is not supported")
 }
 
 func (db *BatchDatabase) Stat(property string) (string, error) {
-	return db.Stat(property)
+	return "", errNotSupported
 }
 
 func (db *BatchDatabase) Compact(start []byte, limit []byte) error {
-	return db.Compact(start, limit)
+	return errNotSupported
 }

XDCxDAO/mongodb.go

@@ -4,6 +4,9 @@ import (
 	"bytes"
 	"encoding/hex"
 	"fmt"
+	"strings"
+	"time"
+
 	"github.com/XinFinOrg/XDC-Subnet/XDCx/tradingstate"
 	"github.com/XinFinOrg/XDC-Subnet/XDCxlending/lendingstate"
 	"github.com/XinFinOrg/XDC-Subnet/common"
@@ -12,8 +15,6 @@ import (
 	"github.com/globalsign/mgo"
 	"github.com/globalsign/mgo/bson"
 	lru "github.com/hashicorp/golang-lru"
-	"strings"
-	"time"
 )
 
 const (
@@ -77,7 +78,7 @@ func NewMongoDatabase(session *mgo.Session, dbName string, mongoURL string, repl
 }
 
 func (db *MongoDatabase) IsEmptyKey(key []byte) bool {
-	return key == nil || len(key) == 0 || bytes.Equal(key, db.emptyKey)
+	return len(key) == 0 || bytes.Equal(key, db.emptyKey)
 }
 
 func (db *MongoDatabase) getCacheKey(key []byte) string {
@@ -873,15 +874,15 @@ func (db *MongoDatabase) Sync() error {
 }
 
 func (db *MongoDatabase) NewIterator(prefix []byte, start []byte) ethdb.Iterator {
-	return db.NewIterator(prefix, start)
+	panic("NewIterator from XDCxDAO mongodb is not supported")
 }
 
 func (db *MongoDatabase) Stat(property string) (string, error) {
-	return db.Stat(property)
+	return "", errNotSupported
 }
 
 func (db *MongoDatabase) Compact(start []byte, limit []byte) error {
-	return db.Compact(start, limit)
+	return errNotSupported
 }
 
 func (db *MongoDatabase) NewBatch() ethdb.Batch {