From 9bb8c8cfd4370ea4454809356f00526b3fd15f4f Mon Sep 17 00:00:00 2001 From: Wanwiset Peerapatanapokin Date: Fri, 19 Jan 2024 15:05:27 +0400 Subject: [PATCH] XDP-03 (#396) * add error catching skeleton * add debug logs * change to Warn level log * change to Warn level 2 * verbose logging --- XDCx/order_processor.go | 64 +++++++++--- XDCx/tradingstate/journal.go | 11 ++- XDCx/tradingstate/state_liquidationprice.go | 6 +- XDCx/tradingstate/state_orderbook.go | 15 ++- XDCx/tradingstate/statedb.go | 10 +- XDCxlending/lendingstate/journal.go | 9 +- XDCxlending/lendingstate/state_lendingbook.go | 38 ++++--- XDCxlending/lendingstate/statedb.go | 10 +- XDCxlending/order_processor.go | 99 ++++++++++++++----- 9 files changed, 203 insertions(+), 59 deletions(-) diff --git a/XDCx/order_processor.go b/XDCx/order_processor.go index 8cf4802024..ca9ca496e3 100644 --- a/XDCx/order_processor.go +++ b/XDCx/order_processor.go @@ -2,11 +2,12 @@ package XDCx import ( "encoding/json" - "github.com/XinFinOrg/XDPoSChain/core/types" "math/big" "strconv" "time" + "github.com/XinFinOrg/XDPoSChain/core/types" + "github.com/XinFinOrg/XDPoSChain/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 diff --git a/XDCx/tradingstate/journal.go b/XDCx/tradingstate/journal.go index 98fa71f9a4..81e190d5f8 100644 --- a/XDCx/tradingstate/journal.go +++ b/XDCx/tradingstate/journal.go @@ -20,6 +20,7 @@ import ( "math/big" "github.com/XinFinOrg/XDPoSChain/common" + "github.com/XinFinOrg/XDPoSChain/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) diff --git a/XDCx/tradingstate/state_liquidationprice.go b/XDCx/tradingstate/state_liquidationprice.go index a169572e36..5a4e4aca63 100644 --- a/XDCx/tradingstate/state_liquidationprice.go +++ b/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)) diff --git a/XDCx/tradingstate/state_orderbook.go b/XDCx/tradingstate/state_orderbook.go index d508e4bd2d..3bfdd33e0e 100644 --- a/XDCx/tradingstate/state_orderbook.go +++ b/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)) diff --git a/XDCx/tradingstate/statedb.go b/XDCx/tradingstate/statedb.go index c0a125636c..68d1278d95 100644 --- a/XDCx/tradingstate/statedb.go +++ b/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{ diff --git a/XDCxlending/lendingstate/journal.go b/XDCxlending/lendingstate/journal.go index 0c04292325..262865602d 100644 --- a/XDCxlending/lendingstate/journal.go +++ b/XDCxlending/lendingstate/journal.go @@ -17,8 +17,10 @@ package lendingstate import ( - "github.com/XinFinOrg/XDPoSChain/common" "math/big" + + "github.com/XinFinOrg/XDPoSChain/common" + "github.com/XinFinOrg/XDPoSChain/log" ) type journalEntry interface { @@ -76,7 +78,10 @@ type ( ) func (ch insertOrder) undo(s *LendingStateDB) { - s.CancelLendingOrder(ch.orderBook, ch.order) + err := s.CancelLendingOrder(ch.orderBook, ch.order) + if err != nil { + log.Warn("undo CancelLendingOrder", "err", err, "ch.orderBook", ch.orderBook, "ch.order", *ch.order) + } } func (ch cancelOrder) undo(s *LendingStateDB) { s.InsertLendingItem(ch.orderBook, ch.orderId, ch.order) diff --git a/XDCxlending/lendingstate/state_lendingbook.go b/XDCxlending/lendingstate/state_lendingbook.go index 5937c406ef..c063f23f7f 100644 --- a/XDCxlending/lendingstate/state_lendingbook.go +++ b/XDCxlending/lendingstate/state_lendingbook.go @@ -18,11 +18,12 @@ package lendingstate import ( "fmt" + "io" + "math/big" + "github.com/XinFinOrg/XDPoSChain/common" "github.com/XinFinOrg/XDPoSChain/log" "github.com/XinFinOrg/XDPoSChain/rlp" - "io" - "math/big" ) type lendingExchangeState struct { @@ -181,8 +182,10 @@ func (self *lendingExchangeState) getLiquidationTimeTrie(db Database) Trie { return self.liquidationTimeTrie } -/** - Get State +/* +* + + Get State */ func (self *lendingExchangeState) getBorrowingOrderList(db Database, rate common.Hash) (stateOrderList *itemListState) { // Prefer 'live' objects. @@ -299,8 +302,10 @@ func (self *lendingExchangeState) getLendingTrade(db Database, tradeId common.Ha return obj } -/** - Update Trie +/* +* + + Update Trie */ func (self *lendingExchangeState) updateLendingTimeTrie(db Database) Trie { tr := self.getLendingItemTrie(db) @@ -344,7 +349,10 @@ func (self *lendingExchangeState) updateBorrowingTrie(db Database) Trie { self.setError(tr.TryDelete(rate[:])) continue } - orderList.updateRoot(db) + err := orderList.updateRoot(db) + if err != nil { + log.Warn("updateBorrowingTrie updateRoot", "err", err, "rate", rate, "orderList", *orderList) + } // Encoding []byte cannot fail, ok to ignore the error. v, _ := rlp.EncodeToBytes(orderList) self.setError(tr.TryUpdate(rate[:], v)) @@ -362,7 +370,10 @@ func (self *lendingExchangeState) updateInvestingTrie(db Database) Trie { self.setError(tr.TryDelete(rate[:])) continue } - orderList.updateRoot(db) + err := orderList.updateRoot(db) + if err != nil { + log.Warn("updateInvestingTrie updateRoot", "err", err, "rate", rate, "orderList", *orderList) + } // Encoding []byte cannot fail, ok to ignore the error. v, _ := rlp.EncodeToBytes(orderList) self.setError(tr.TryUpdate(rate[:], v)) @@ -380,7 +391,10 @@ func (self *lendingExchangeState) updateLiquidationTimeTrie(db Database) Trie { self.setError(tr.TryDelete(time[:])) continue } - itemList.updateRoot(db) + err := itemList.updateRoot(db) + if err != nil { + log.Warn("updateLiquidationTimeTrie updateRoot", "err", err, "time", time, "itemList", *itemList) + } // Encoding []byte cannot fail, ok to ignore the error. v, _ := rlp.EncodeToBytes(itemList) self.setError(tr.TryUpdate(time[:], v)) @@ -513,8 +527,10 @@ func (self *lendingExchangeState) CommitLiquidationTimeTrie(db Database) error { return err } -/** - Get Trie Data +/* +* + + Get Trie Data */ func (self *lendingExchangeState) getBestInvestingInterest(db Database) common.Hash { trie := self.getInvestingTrie(db) diff --git a/XDCxlending/lendingstate/statedb.go b/XDCxlending/lendingstate/statedb.go index 1442cbe0ce..f514f61ba0 100644 --- a/XDCxlending/lendingstate/statedb.go +++ b/XDCxlending/lendingstate/statedb.go @@ -524,7 +524,10 @@ func (s *LendingStateDB) Finalise() { for addr, stateObject := range s.lendingExchangeStates { if _, isDirty := s.lendingExchangeStatesDirty[addr]; isDirty { // Write any storage changes in the state object to its storage trie. - stateObject.updateInvestingRoot(s.db) + err := stateObject.updateInvestingRoot(s.db) + if err != nil { + log.Warn("Finalise updateInvestingRoot", "err", err, "addr", addr, "stateObject", *stateObject) + } stateObject.updateBorrowingRoot(s.db) stateObject.updateOrderRoot(s.db) stateObject.updateLendingTradeRoot(s.db) @@ -630,7 +633,10 @@ func (self *LendingStateDB) RemoveLiquidationTime(lendingBook common.Hash, trade liquidationTime.removeTradeId(self.db, tradeIdHash) liquidationTime.subVolume(One) if liquidationTime.Volume().Sign() == 0 { - lendingExchangeState.getLiquidationTimeTrie(self.db).TryDelete(timeHash[:]) + err := lendingExchangeState.getLiquidationTimeTrie(self.db).TryDelete(timeHash[:]) + if err != nil { + log.Warn("RemoveLiquidationTime getLiquidationTimeTrie.TryDelete", "err", err, "timeHash[:]", timeHash[:]) + } } return nil } diff --git a/XDCxlending/order_processor.go b/XDCxlending/order_processor.go index 2dcfb560e6..5725c2003b 100644 --- a/XDCxlending/order_processor.go +++ b/XDCxlending/order_processor.go @@ -339,7 +339,10 @@ func (l *Lending) processOrderList(header *types.Header, coinbase common.Address } if tradedQuantity.Sign() > 0 { quantityToTrade = lendingstate.Sub(quantityToTrade, tradedQuantity) - lendingStateDB.SubAmountLendingItem(lendingOrderBook, orderId, Interest, tradedQuantity, side) + err := lendingStateDB.SubAmountLendingItem(lendingOrderBook, orderId, Interest, tradedQuantity, side) + if err != nil { + log.Warn("processOrderList SubAmountLendingItem", "err", err, "lendingOrderBook", lendingOrderBook, "orderId", orderId, "Interest", *Interest, "tradedQuantity", *tradedQuantity, "side", side) + } log.Debug("Update quantity for orderId", "orderId", orderId.Hex()) log.Debug("LEND", "lendingOrderBook", lendingOrderBook.Hex(), "Taker Interest", Interest, "maker Interest", order.Interest, "Amount", tradedQuantity, "orderId", orderId, "side", side) tradingId := lendingStateDB.GetTradeNonce(lendingOrderBook) + 1 @@ -669,7 +672,10 @@ func DoSettleBalance(coinbase common.Address, takerOrder, makerOrder *lendingsta statedb.AddBalance(masternodeOwner, matchingFee) for token, balances := range mapBalances { for adrr, value := range balances { - lendingstate.SetTokenBalance(adrr, value, token, statedb) + err := lendingstate.SetTokenBalance(adrr, value, token, statedb) + if err != nil { + log.Warn("DoSettleBalance SetTokenBalance", "err", err, "addr", adrr, "value", *value, "token", token) + } } } return nil @@ -744,12 +750,24 @@ func (l *Lending) ProcessCancelOrder(header *types.Header, lendingStateDB *lendi switch originOrder.Side { case lendingstate.Investing: // users pay token for relayer - lendingstate.SubTokenBalance(originOrder.UserAddress, tokenCancelFee, originOrder.LendingToken, statedb) - lendingstate.AddTokenBalance(relayerOwner, tokenCancelFee, originOrder.LendingToken, statedb) + err := lendingstate.SubTokenBalance(originOrder.UserAddress, tokenCancelFee, originOrder.LendingToken, statedb) + if err != nil { + log.Warn("ProcessCancelOrder SubTokenBalance", "err", err, "originOrder.UserAddress", originOrder.UserAddress, "tokenCancelFee", *tokenCancelFee, "originOrder.LendingToken", originOrder.LendingToken) + } + err = lendingstate.AddTokenBalance(relayerOwner, tokenCancelFee, originOrder.LendingToken, statedb) + if err != nil { + log.Warn("ProcessCancelOrder AddTokenBalance", "err", err, "relayerOwner", relayerOwner, "tokenCancelFee", *tokenCancelFee, "originOrder.LendingToken", originOrder.LendingToken) + } case lendingstate.Borrowing: // users pay token for relayer - lendingstate.SubTokenBalance(originOrder.UserAddress, tokenCancelFee, originOrder.CollateralToken, statedb) - lendingstate.AddTokenBalance(relayerOwner, tokenCancelFee, originOrder.CollateralToken, statedb) + err := lendingstate.SubTokenBalance(originOrder.UserAddress, tokenCancelFee, originOrder.CollateralToken, statedb) + if err != nil { + log.Warn("ProcessCancelOrder SubTokenBalance", "err", err, "originOrder.UserAddress", originOrder.UserAddress, "tokenCancelFee", *tokenCancelFee, "originOrder.CollateralToken", originOrder.CollateralToken) + } + err = lendingstate.AddTokenBalance(relayerOwner, tokenCancelFee, originOrder.CollateralToken, statedb) + if err != nil { + log.Warn("ProcessCancelOrder AddTokenBalance", "err", err, "relayerOwner", relayerOwner, "tokenCancelFee", *tokenCancelFee, "originOrder.CollateralToken", originOrder.CollateralToken) + } default: } extraData, _ := json.Marshal(struct { @@ -829,12 +847,21 @@ func (l *Lending) LiquidationExpiredTrade(header *types.Header, chain consensus. recallAmount := common.Big0 if repayAmount.Cmp(lendingTrade.CollateralLockedAmount) < 0 { recallAmount = new(big.Int).Sub(lendingTrade.CollateralLockedAmount, repayAmount) - lendingstate.AddTokenBalance(lendingTrade.Borrower, recallAmount, lendingTrade.CollateralToken, statedb) + err := lendingstate.AddTokenBalance(lendingTrade.Borrower, recallAmount, lendingTrade.CollateralToken, statedb) + if err != nil { + log.Warn("LiquidationExpiredTrade AddTokenBalance", "err", err, "lendingTrade.Borrower", lendingTrade.Borrower, "recallAmount", *recallAmount, "lendingTrade.CollateralToken", lendingTrade.CollateralToken) + } } else { repayAmount = lendingTrade.CollateralLockedAmount } - lendingstate.SubTokenBalance(common.HexToAddress(common.LendingLockAddress), lendingTrade.CollateralLockedAmount, lendingTrade.CollateralToken, statedb) - lendingstate.AddTokenBalance(lendingTrade.Investor, repayAmount, lendingTrade.CollateralToken, statedb) + err = lendingstate.SubTokenBalance(common.HexToAddress(common.LendingLockAddress), lendingTrade.CollateralLockedAmount, lendingTrade.CollateralToken, statedb) + if err != nil { + log.Warn("LiquidationExpiredTrade SubTokenBalance", "err", err, "LendingLockAddress", common.HexToAddress(common.LendingLockAddress), "lendingTrade.CollateralLockedAmount", *lendingTrade.CollateralLockedAmount, "lendingTrade.CollateralToken", lendingTrade.CollateralToken) + } + err = lendingstate.AddTokenBalance(lendingTrade.Investor, repayAmount, lendingTrade.CollateralToken, statedb) + if err != nil { + log.Warn("LiquidationExpiredTrade AddTokenBalance", "err", err, "lendingTrade.Investor", lendingTrade.Investor, "repayAmount", repayAmount, "lendingTrade.CollateralToken", lendingTrade.CollateralToken) + } err = lendingStateDB.RemoveLiquidationTime(lendingBook, lendingTradeId, lendingTrade.LiquidationTime) if err != nil { @@ -870,10 +897,15 @@ func (l *Lending) LiquidationTrade(lendingStateDB *lendingstate.LendingStateDB, if lendingTrade.TradeId != lendingTradeId { return nil, fmt.Errorf("Lending Trade Id not found : %d ", lendingTradeId) } - lendingstate.SubTokenBalance(common.HexToAddress(common.LendingLockAddress), lendingTrade.CollateralLockedAmount, lendingTrade.CollateralToken, statedb) - lendingstate.AddTokenBalance(lendingTrade.Investor, lendingTrade.CollateralLockedAmount, lendingTrade.CollateralToken, statedb) - - err := lendingStateDB.RemoveLiquidationTime(lendingBook, lendingTradeId, lendingTrade.LiquidationTime) + err := lendingstate.SubTokenBalance(common.HexToAddress(common.LendingLockAddress), lendingTrade.CollateralLockedAmount, lendingTrade.CollateralToken, statedb) + if err != nil { + log.Warn("LiquidationTrade SubTokenBalance", "err", err, "LendingLockAddress", common.HexToAddress(common.LendingLockAddress), "lendingTrade.CollateralLockedAmount", *lendingTrade.CollateralLockedAmount, "lendingTrade.CollateralToken", lendingTrade.CollateralToken) + } + err = lendingstate.AddTokenBalance(lendingTrade.Investor, lendingTrade.CollateralLockedAmount, lendingTrade.CollateralToken, statedb) + if err != nil { + log.Warn("LiquidationTrade AddTokenBalance", "err", err, "lendingTrade.Investor", lendingTrade.Investor, "lendingTrade.CollateralLockedAmount", *lendingTrade.CollateralLockedAmount, "lendingTrade.CollateralToken", lendingTrade.CollateralToken) + } + err = lendingStateDB.RemoveLiquidationTime(lendingBook, lendingTradeId, lendingTrade.LiquidationTime) if err != nil { log.Debug("LiquidationTrade RemoveLiquidationTime", "err", err) return nil, err @@ -1097,8 +1129,14 @@ func (l *Lending) ProcessTopUpLendingTrade(lendingStateDB *lendingstate.LendingS if err != nil { return err, true, nil } - lendingstate.SubTokenBalance(lendingTrade.Borrower, quantity, lendingTrade.CollateralToken, statedb) - lendingstate.AddTokenBalance(common.HexToAddress(common.LendingLockAddress), quantity, lendingTrade.CollateralToken, statedb) + err = lendingstate.SubTokenBalance(lendingTrade.Borrower, quantity, lendingTrade.CollateralToken, statedb) + if err != nil { + log.Warn("ProcessTopUpLendingTrade SubTokenBalance", "err", err, "lendingTrade.Borrower", lendingTrade.Borrower, "quantity", *quantity, "lendingTrade.CollateralToken", lendingTrade.CollateralToken) + } + err = lendingstate.AddTokenBalance(common.HexToAddress(common.LendingLockAddress), quantity, lendingTrade.CollateralToken, statedb) + if err != nil { + log.Warn("ProcessTopUpLendingTrade AddTokenBalance", "err", err, "LendingLockAddress", common.HexToAddress(common.LendingLockAddress), "quantity", *quantity, "lendingTrade.CollateralToken", lendingTrade.CollateralToken) + } oldLockedAmount := lendingTrade.CollateralLockedAmount newLockedAmount := new(big.Int).Add(quantity, oldLockedAmount) newLiquidationPrice := new(big.Int).Mul(lendingTrade.LiquidationPrice, oldLockedAmount) @@ -1153,11 +1191,22 @@ func (l *Lending) ProcessRepayLendingTrade(header *types.Header, chain consensus } return newLendingTrade, err } else { - lendingstate.SubTokenBalance(lendingTrade.Borrower, paymentBalance, lendingTrade.LendingToken, statedb) - lendingstate.AddTokenBalance(lendingTrade.Investor, paymentBalance, lendingTrade.LendingToken, statedb) - - lendingstate.SubTokenBalance(common.HexToAddress(common.LendingLockAddress), lendingTrade.CollateralLockedAmount, lendingTrade.CollateralToken, statedb) - lendingstate.AddTokenBalance(lendingTrade.Borrower, lendingTrade.CollateralLockedAmount, lendingTrade.CollateralToken, statedb) + err := lendingstate.SubTokenBalance(lendingTrade.Borrower, paymentBalance, lendingTrade.LendingToken, statedb) + if err != nil { + log.Warn("ProcessRepayLendingTrade SubTokenBalance", "err", err, "lendingTrade.Borrower", lendingTrade.Borrower, "paymentBalance", *paymentBalance, "lendingTrade.LendingToken", lendingTrade.LendingToken) + } + err = lendingstate.AddTokenBalance(lendingTrade.Investor, paymentBalance, lendingTrade.LendingToken, statedb) + if err != nil { + log.Warn("ProcessRepayLendingTrade AddTokenBalance", "err", err, "lendingTrade.Investor", lendingTrade.Investor, "paymentBalance", *paymentBalance, "lendingTrade.LendingToken", lendingTrade.LendingToken) + } + err = lendingstate.SubTokenBalance(common.HexToAddress(common.LendingLockAddress), lendingTrade.CollateralLockedAmount, lendingTrade.CollateralToken, statedb) + if err != nil { + log.Warn("ProcessRepayLendingTrade SubTokenBalance", "err", err, "LendingLockAddress", common.HexToAddress(common.LendingLockAddress), "lendingTrade.CollateralLockedAmount", *lendingTrade.CollateralLockedAmount, "lendingTrade.CollateralToken", lendingTrade.CollateralToken) + } + err = lendingstate.AddTokenBalance(lendingTrade.Borrower, lendingTrade.CollateralLockedAmount, lendingTrade.CollateralToken, statedb) + if err != nil { + log.Warn("ProcessRepayLendingTrade AddTokenBalance", "err", err, "lendingTrade.Borrower", lendingTrade.Borrower, "lendingTrade.CollateralLockedAmount", *lendingTrade.CollateralLockedAmount, "lendingTrade.CollateralToken", lendingTrade.CollateralToken) + } err = lendingStateDB.RemoveLiquidationTime(lendingBook, lendingTradeId, lendingTrade.LiquidationTime) if err != nil { @@ -1202,8 +1251,14 @@ func (l *Lending) ProcessRecallLendingTrade(lendingStateDB *lendingstate.Lending if err != nil { return err, true, nil } - lendingstate.AddTokenBalance(lendingTrade.Borrower, recallAmount, lendingTrade.CollateralToken, statedb) - lendingstate.SubTokenBalance(common.HexToAddress(common.LendingLockAddress), recallAmount, lendingTrade.CollateralToken, statedb) + err = lendingstate.AddTokenBalance(lendingTrade.Borrower, recallAmount, lendingTrade.CollateralToken, statedb) + if err != nil { + log.Warn("ProcessRecallLendingTrade AddTokenBalance", "err", err, "lendingTrade.Borrower", lendingTrade.Borrower, "recallAmount", *recallAmount, "lendingTrade.CollateralToken", lendingTrade.CollateralToken) + } + err = lendingstate.SubTokenBalance(common.HexToAddress(common.LendingLockAddress), recallAmount, lendingTrade.CollateralToken, statedb) + if err != nil { + log.Warn("ProcessRecallLendingTrade SubTokenBalance", "err", err, "LendingLockAddress", common.HexToAddress(common.LendingLockAddress), "recallAmount", *recallAmount, "lendingTrade.CollateralToken", lendingTrade.CollateralToken) + } lendingStateDB.UpdateLiquidationPrice(lendingBook, lendingTrade.TradeId, newLiquidationPrice) lendingStateDB.UpdateCollateralLockedAmount(lendingBook, lendingTrade.TradeId, newLockedAmount)