From fbecb8c5a566c74248fa9fede461ea037c8e623f Mon Sep 17 00:00:00 2001 From: Daniel Liu Date: Fri, 25 Oct 2024 21:30:54 +0800 Subject: [PATCH] all: fix staticcheck warning ST1006: don't use generic name self MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The name of a method’s receiver should be a reflection of its identity; often a one or two letter abbreviation of its type suffices (such as “c” or “cl” for “Client”). Don’t use generic names such as “me”, “this” or “self”, identifiers typical of object-oriented languages that place more emphasis on methods as opposed to functions. The name need not be as descriptive as that of a method argument, as its role is obvious and serves no documentary purpose. It can be very short as it will appear on almost every line of every method of the type; familiarity admits brevity. Be consistent, too: if you call the receiver “c” in one method, don’t call it “cl” in another. --- XDCx/tradingstate/dump.go | 101 ++-- XDCx/tradingstate/state_lendingbook.go | 126 ++-- XDCx/tradingstate/state_liquidationprice.go | 126 ++-- XDCx/tradingstate/state_orderItem.go | 22 +- XDCx/tradingstate/state_orderList.go | 110 ++-- XDCx/tradingstate/state_orderbook.go | 543 ++++++++--------- XDCx/tradingstate/statedb.go | 364 ++++++------ XDCxlending/lendingstate/dump.go | 89 +-- XDCxlending/lendingstate/state_itemList.go | 127 ++-- XDCxlending/lendingstate/state_lendingbook.go | 555 +++++++++--------- XDCxlending/lendingstate/state_lendingitem.go | 26 +- .../lendingstate/state_lendingtrade.go | 47 +- .../lendingstate/state_liquidationtime.go | 135 ++--- XDCxlending/lendingstate/statedb.go | 370 ++++++------ bmt/bmt.go | 164 +++--- cmd/utils/customflags.go | 78 +-- contracts/ens/ens.go | 32 +- core/state/dump.go | 18 +- core/state/statedb.go | 306 +++++----- core/types/block.go | 14 +- eth/backend.go | 186 +++--- eth/handler.go | 40 +- event/filter/filter.go | 38 +- event/filter/generic_filter.go | 16 +- les/flowcontrol/manager.go | 152 ++--- les/handler.go | 12 +- les/txrelay.go | 80 +-- light/lightchain.go | 264 ++++----- light/txpool.go | 226 +++---- light/txpool_test.go | 12 +- metrics/librato/client.go | 4 +- metrics/librato/librato.go | 46 +- miner/agent.go | 58 +- miner/miner.go | 88 +-- miner/worker.go | 364 ++++++------ p2p/message.go | 62 +- p2p/peer_error.go | 4 +- p2p/simulations/adapters/inproc.go | 132 ++--- p2p/simulations/adapters/state.go | 8 +- p2p/simulations/network.go | 308 +++++----- p2p/testing/peerpool.go | 32 +- p2p/testing/protocolsession.go | 26 +- p2p/testing/protocoltester.go | 54 +- 43 files changed, 2792 insertions(+), 2773 deletions(-) diff --git a/XDCx/tradingstate/dump.go b/XDCx/tradingstate/dump.go index 33de042c85..58026ed2a1 100644 --- a/XDCx/tradingstate/dump.go +++ b/XDCx/tradingstate/dump.go @@ -47,13 +47,13 @@ type DumpOrderBookInfo struct { LowestLiquidationPrice *big.Int } -func (self *TradingStateDB) DumpAskTrie(orderBook common.Hash) (map[*big.Int]DumpOrderList, error) { - exhangeObject := self.getStateExchangeObject(orderBook) +func (t *TradingStateDB) DumpAskTrie(orderBook common.Hash) (map[*big.Int]DumpOrderList, error) { + exhangeObject := t.getStateExchangeObject(orderBook) if exhangeObject == nil { return nil, fmt.Errorf("not found orderBook: %v", orderBook.Hex()) } mapResult := map[*big.Int]DumpOrderList{} - it := trie.NewIterator(exhangeObject.getAsksTrie(self.db).NodeIterator(nil)) + it := trie.NewIterator(exhangeObject.getAsksTrie(t.db).NodeIterator(nil)) for it.Next() { priceHash := common.BytesToHash(it.Key) if common.EmptyHash(priceHash) { @@ -67,13 +67,13 @@ func (self *TradingStateDB) DumpAskTrie(orderBook common.Hash) (map[*big.Int]Dum if err := rlp.DecodeBytes(it.Value, &data); err != nil { return nil, fmt.Errorf("fail when decode order iist orderBook: %v , price :%v", orderBook.Hex(), price) } - stateOrderList := newStateOrderList(self, Ask, orderBook, priceHash, data, nil) - mapResult[price] = stateOrderList.DumpOrderList(self.db) + stateOrderList := newStateOrderList(t, Ask, orderBook, priceHash, data, nil) + mapResult[price] = stateOrderList.DumpOrderList(t.db) } } for priceHash, stateOrderList := range exhangeObject.stateAskObjects { if stateOrderList.Volume().Sign() > 0 { - mapResult[new(big.Int).SetBytes(priceHash.Bytes())] = stateOrderList.DumpOrderList(self.db) + mapResult[new(big.Int).SetBytes(priceHash.Bytes())] = stateOrderList.DumpOrderList(t.db) } } listPrice := []*big.Int{} @@ -90,13 +90,13 @@ func (self *TradingStateDB) DumpAskTrie(orderBook common.Hash) (map[*big.Int]Dum return result, nil } -func (self *TradingStateDB) DumpBidTrie(orderBook common.Hash) (map[*big.Int]DumpOrderList, error) { - exhangeObject := self.getStateExchangeObject(orderBook) +func (t *TradingStateDB) DumpBidTrie(orderBook common.Hash) (map[*big.Int]DumpOrderList, error) { + exhangeObject := t.getStateExchangeObject(orderBook) if exhangeObject == nil { return nil, fmt.Errorf("not found orderBook: %v", orderBook.Hex()) } mapResult := map[*big.Int]DumpOrderList{} - it := trie.NewIterator(exhangeObject.getBidsTrie(self.db).NodeIterator(nil)) + it := trie.NewIterator(exhangeObject.getBidsTrie(t.db).NodeIterator(nil)) for it.Next() { priceHash := common.BytesToHash(it.Key) if common.EmptyHash(priceHash) { @@ -110,13 +110,13 @@ func (self *TradingStateDB) DumpBidTrie(orderBook common.Hash) (map[*big.Int]Dum if err := rlp.DecodeBytes(it.Value, &data); err != nil { return nil, fmt.Errorf("fail when decode order iist orderBook: %v , price :%v", orderBook.Hex(), price) } - stateOrderList := newStateOrderList(self, Bid, orderBook, priceHash, data, nil) - mapResult[price] = stateOrderList.DumpOrderList(self.db) + stateOrderList := newStateOrderList(t, Bid, orderBook, priceHash, data, nil) + mapResult[price] = stateOrderList.DumpOrderList(t.db) } } for priceHash, stateOrderList := range exhangeObject.stateBidObjects { if stateOrderList.Volume().Sign() > 0 { - mapResult[new(big.Int).SetBytes(priceHash.Bytes())] = stateOrderList.DumpOrderList(self.db) + mapResult[new(big.Int).SetBytes(priceHash.Bytes())] = stateOrderList.DumpOrderList(t.db) } } listPrice := []*big.Int{} @@ -133,13 +133,13 @@ func (self *TradingStateDB) DumpBidTrie(orderBook common.Hash) (map[*big.Int]Dum return mapResult, nil } -func (self *TradingStateDB) GetBids(orderBook common.Hash) (map[*big.Int]*big.Int, error) { - exhangeObject := self.getStateExchangeObject(orderBook) +func (t *TradingStateDB) GetBids(orderBook common.Hash) (map[*big.Int]*big.Int, error) { + exhangeObject := t.getStateExchangeObject(orderBook) if exhangeObject == nil { return nil, fmt.Errorf("not found orderBook: %v", orderBook.Hex()) } mapResult := map[*big.Int]*big.Int{} - it := trie.NewIterator(exhangeObject.getBidsTrie(self.db).NodeIterator(nil)) + it := trie.NewIterator(exhangeObject.getBidsTrie(t.db).NodeIterator(nil)) for it.Next() { priceHash := common.BytesToHash(it.Key) if common.EmptyHash(priceHash) { @@ -153,7 +153,7 @@ func (self *TradingStateDB) GetBids(orderBook common.Hash) (map[*big.Int]*big.In if err := rlp.DecodeBytes(it.Value, &data); err != nil { return nil, fmt.Errorf("fail when decode order iist orderBook: %v , price :%v", orderBook.Hex(), price) } - stateOrderList := newStateOrderList(self, Bid, orderBook, priceHash, data, nil) + stateOrderList := newStateOrderList(t, Bid, orderBook, priceHash, data, nil) mapResult[price] = stateOrderList.data.Volume } } @@ -176,13 +176,13 @@ func (self *TradingStateDB) GetBids(orderBook common.Hash) (map[*big.Int]*big.In return mapResult, nil } -func (self *TradingStateDB) GetAsks(orderBook common.Hash) (map[*big.Int]*big.Int, error) { - exhangeObject := self.getStateExchangeObject(orderBook) +func (t *TradingStateDB) GetAsks(orderBook common.Hash) (map[*big.Int]*big.Int, error) { + exhangeObject := t.getStateExchangeObject(orderBook) if exhangeObject == nil { return nil, fmt.Errorf("not found orderBook: %v", orderBook.Hex()) } mapResult := map[*big.Int]*big.Int{} - it := trie.NewIterator(exhangeObject.getAsksTrie(self.db).NodeIterator(nil)) + it := trie.NewIterator(exhangeObject.getAsksTrie(t.db).NodeIterator(nil)) for it.Next() { priceHash := common.BytesToHash(it.Key) if common.EmptyHash(priceHash) { @@ -196,7 +196,7 @@ func (self *TradingStateDB) GetAsks(orderBook common.Hash) (map[*big.Int]*big.In if err := rlp.DecodeBytes(it.Value, &data); err != nil { return nil, fmt.Errorf("fail when decode order iist orderBook: %v , price : %v", orderBook.Hex(), price) } - stateOrderList := newStateOrderList(self, Ask, orderBook, priceHash, data, nil) + stateOrderList := newStateOrderList(t, Ask, orderBook, priceHash, data, nil) mapResult[price] = stateOrderList.data.Volume } } @@ -218,22 +218,23 @@ func (self *TradingStateDB) GetAsks(orderBook common.Hash) (map[*big.Int]*big.In } return result, nil } -func (self *stateOrderList) DumpOrderList(db Database) DumpOrderList { - mapResult := DumpOrderList{Volume: self.Volume(), Orders: map[*big.Int]*big.Int{}} - orderListIt := trie.NewIterator(self.getTrie(db).NodeIterator(nil)) + +func (s *stateOrderList) DumpOrderList(db Database) DumpOrderList { + mapResult := DumpOrderList{Volume: s.Volume(), Orders: map[*big.Int]*big.Int{}} + orderListIt := trie.NewIterator(s.getTrie(db).NodeIterator(nil)) for orderListIt.Next() { keyHash := common.BytesToHash(orderListIt.Key) if common.EmptyHash(keyHash) { continue } - if _, exist := self.cachedStorage[keyHash]; exist { + if _, exist := s.cachedStorage[keyHash]; exist { continue } else { _, content, _, _ := rlp.Split(orderListIt.Value) mapResult.Orders[new(big.Int).SetBytes(keyHash.Bytes())] = new(big.Int).SetBytes(content) } } - for key, value := range self.cachedStorage { + for key, value := range s.cachedStorage { if !common.EmptyHash(value) { mapResult.Orders[new(big.Int).SetBytes(key.Bytes())] = new(big.Int).SetBytes(value.Bytes()) } @@ -245,15 +246,15 @@ func (self *stateOrderList) DumpOrderList(db Database) DumpOrderList { sort.Slice(listIds, func(i, j int) bool { return listIds[i].Cmp(listIds[j]) < 0 }) - result := DumpOrderList{Volume: self.Volume(), Orders: map[*big.Int]*big.Int{}} + result := DumpOrderList{Volume: s.Volume(), Orders: map[*big.Int]*big.Int{}} for _, id := range listIds { result.Orders[id] = mapResult.Orders[id] } return mapResult } -func (self *TradingStateDB) DumpOrderBookInfo(orderBook common.Hash) (*DumpOrderBookInfo, error) { - exhangeObject := self.getStateExchangeObject(orderBook) +func (t *TradingStateDB) DumpOrderBookInfo(orderBook common.Hash) (*DumpOrderBookInfo, error) { + exhangeObject := t.getStateExchangeObject(orderBook) if exhangeObject == nil { return nil, fmt.Errorf("not found orderBook: %v", orderBook.Hex()) } @@ -264,29 +265,29 @@ func (self *TradingStateDB) DumpOrderBookInfo(orderBook common.Hash) (*DumpOrder result.MediumPriceBeforeEpoch = exhangeObject.data.MediumPriceBeforeEpoch result.Nonce = exhangeObject.data.Nonce result.TotalQuantity = exhangeObject.data.TotalQuantity - result.BestAsk = new(big.Int).SetBytes(exhangeObject.getBestPriceAsksTrie(self.db).Bytes()) - result.BestBid = new(big.Int).SetBytes(exhangeObject.getBestBidsTrie(self.db).Bytes()) - lowestPrice, _ := exhangeObject.getLowestLiquidationPrice(self.db) + result.BestAsk = new(big.Int).SetBytes(exhangeObject.getBestPriceAsksTrie(t.db).Bytes()) + result.BestBid = new(big.Int).SetBytes(exhangeObject.getBestBidsTrie(t.db).Bytes()) + lowestPrice, _ := exhangeObject.getLowestLiquidationPrice(t.db) result.LowestLiquidationPrice = new(big.Int).SetBytes(lowestPrice.Bytes()) return result, nil } -func (self *stateLendingBook) DumpOrderList(db Database) DumpOrderList { - mapResult := DumpOrderList{Volume: self.Volume(), Orders: map[*big.Int]*big.Int{}} - orderListIt := trie.NewIterator(self.getTrie(db).NodeIterator(nil)) +func (s *stateLendingBook) DumpOrderList(db Database) DumpOrderList { + mapResult := DumpOrderList{Volume: s.Volume(), Orders: map[*big.Int]*big.Int{}} + orderListIt := trie.NewIterator(s.getTrie(db).NodeIterator(nil)) for orderListIt.Next() { keyHash := common.BytesToHash(orderListIt.Key) if common.EmptyHash(keyHash) { continue } - if _, exist := self.cachedStorage[keyHash]; exist { + if _, exist := s.cachedStorage[keyHash]; exist { continue } else { _, content, _, _ := rlp.Split(orderListIt.Value) mapResult.Orders[new(big.Int).SetBytes(keyHash.Bytes())] = new(big.Int).SetBytes(content) } } - for key, value := range self.cachedStorage { + for key, value := range s.cachedStorage { if !common.EmptyHash(value) { mapResult.Orders[new(big.Int).SetBytes(key.Bytes())] = new(big.Int).SetBytes(value.Bytes()) } @@ -298,33 +299,33 @@ func (self *stateLendingBook) DumpOrderList(db Database) DumpOrderList { sort.Slice(listIds, func(i, j int) bool { return listIds[i].Cmp(listIds[j]) < 0 }) - result := DumpOrderList{Volume: self.Volume(), Orders: map[*big.Int]*big.Int{}} + result := DumpOrderList{Volume: s.Volume(), Orders: map[*big.Int]*big.Int{}} for _, id := range listIds { result.Orders[id] = mapResult.Orders[id] } return mapResult } -func (self *liquidationPriceState) DumpLendingBook(db Database) (DumpLendingBook, error) { - result := DumpLendingBook{Volume: self.Volume(), LendingBooks: map[common.Hash]DumpOrderList{}} - it := trie.NewIterator(self.getTrie(db).NodeIterator(nil)) +func (l *liquidationPriceState) DumpLendingBook(db Database) (DumpLendingBook, error) { + result := DumpLendingBook{Volume: l.Volume(), LendingBooks: map[common.Hash]DumpOrderList{}} + it := trie.NewIterator(l.getTrie(db).NodeIterator(nil)) for it.Next() { lendingBook := common.BytesToHash(it.Key) if common.EmptyHash(lendingBook) { continue } - if _, exist := self.stateLendingBooks[lendingBook]; exist { + if _, exist := l.stateLendingBooks[lendingBook]; exist { continue } else { var data orderList if err := rlp.DecodeBytes(it.Value, &data); err != nil { - return result, fmt.Errorf("failed to decode state lending book orderbook: %s , liquidation price : %s , lendingBook : %s , err : %v", self.orderBook, self.liquidationPrice, lendingBook, err) + return result, fmt.Errorf("failed to decode state lending book orderbook: %s, liquidation price: %s , lendingBook: %s , err: %v", l.orderBook, l.liquidationPrice, lendingBook, err) } - stateLendingBook := newStateLendingBook(self.orderBook, self.liquidationPrice, lendingBook, data, nil) + stateLendingBook := newStateLendingBook(l.orderBook, l.liquidationPrice, lendingBook, data, nil) result.LendingBooks[lendingBook] = stateLendingBook.DumpOrderList(db) } } - for lendingBook, stateLendingBook := range self.stateLendingBooks { + for lendingBook, stateLendingBook := range l.stateLendingBooks { if !common.EmptyHash(lendingBook) { result.LendingBooks[lendingBook] = stateLendingBook.DumpOrderList(db) } @@ -332,13 +333,13 @@ func (self *liquidationPriceState) DumpLendingBook(db Database) (DumpLendingBook return result, nil } -func (self *TradingStateDB) DumpLiquidationPriceTrie(orderBook common.Hash) (map[*big.Int]DumpLendingBook, error) { - exhangeObject := self.getStateExchangeObject(orderBook) +func (t *TradingStateDB) DumpLiquidationPriceTrie(orderBook common.Hash) (map[*big.Int]DumpLendingBook, error) { + exhangeObject := t.getStateExchangeObject(orderBook) if exhangeObject == nil { return nil, fmt.Errorf("not found orderBook: %v", orderBook.Hex()) } mapResult := map[*big.Int]DumpLendingBook{} - it := trie.NewIterator(exhangeObject.getLiquidationPriceTrie(self.db).NodeIterator(nil)) + it := trie.NewIterator(exhangeObject.getLiquidationPriceTrie(t.db).NodeIterator(nil)) for it.Next() { priceHash := common.BytesToHash(it.Key) if common.EmptyHash(priceHash) { @@ -352,8 +353,8 @@ func (self *TradingStateDB) DumpLiquidationPriceTrie(orderBook common.Hash) (map if err := rlp.DecodeBytes(it.Value, &data); err != nil { return nil, fmt.Errorf("fail when decode order iist orderBook: %v , price : %v", orderBook.Hex(), price) } - liquidationPriceState := newLiquidationPriceState(self, orderBook, priceHash, data, nil) - dumpLendingBook, err := liquidationPriceState.DumpLendingBook(self.db) + liquidationPriceState := newLiquidationPriceState(t, orderBook, priceHash, data, nil) + dumpLendingBook, err := liquidationPriceState.DumpLendingBook(t.db) if err != nil { return nil, err } @@ -362,7 +363,7 @@ func (self *TradingStateDB) DumpLiquidationPriceTrie(orderBook common.Hash) (map } for priceHash, liquidationPriceState := range exhangeObject.liquidationPriceStates { if liquidationPriceState.Volume().Sign() > 0 { - dumpLendingBook, err := liquidationPriceState.DumpLendingBook(self.db) + dumpLendingBook, err := liquidationPriceState.DumpLendingBook(t.db) if err != nil { return nil, err } diff --git a/XDCx/tradingstate/state_lendingbook.go b/XDCx/tradingstate/state_lendingbook.go index b6af4aded1..6f8b77695b 100644 --- a/XDCx/tradingstate/state_lendingbook.go +++ b/XDCx/tradingstate/state_lendingbook.go @@ -65,59 +65,59 @@ func newStateLendingBook(orderBook common.Hash, price common.Hash, lendingBook c } } -func (self *stateLendingBook) EncodeRLP(w io.Writer) error { - return rlp.Encode(w, self.data) +func (s *stateLendingBook) EncodeRLP(w io.Writer) error { + return rlp.Encode(w, s.data) } -func (self *stateLendingBook) setError(err error) { - if self.dbErr == nil { - self.dbErr = err +func (s *stateLendingBook) setError(err error) { + if s.dbErr == nil { + s.dbErr = err } } -func (self *stateLendingBook) getTrie(db Database) Trie { - if self.trie == nil { +func (s *stateLendingBook) getTrie(db Database) Trie { + if s.trie == nil { var err error - self.trie, err = db.OpenStorageTrie(self.lendingBook, self.data.Root) + s.trie, err = db.OpenStorageTrie(s.lendingBook, s.data.Root) if err != nil { - self.trie, _ = db.OpenStorageTrie(self.price, EmptyHash) - self.setError(fmt.Errorf("can't create storage trie: %v", err)) + s.trie, _ = db.OpenStorageTrie(s.price, EmptyHash) + s.setError(fmt.Errorf("can't create storage trie: %v", err)) } } - return self.trie + return s.trie } -func (self *stateLendingBook) Exist(db Database, lendingId common.Hash) bool { - amount, exists := self.cachedStorage[lendingId] +func (s *stateLendingBook) Exist(db Database, lendingId common.Hash) bool { + amount, exists := s.cachedStorage[lendingId] if exists { return true } // Load from DB in case it is missing. - enc, err := self.getTrie(db).TryGet(lendingId[:]) + enc, err := s.getTrie(db).TryGet(lendingId[:]) if err != nil { - self.setError(err) + s.setError(err) return false } if len(enc) > 0 { _, content, _, err := rlp.Split(enc) if err != nil { - self.setError(err) + s.setError(err) } amount.SetBytes(content) } if (amount != common.Hash{}) { - self.cachedStorage[lendingId] = amount + s.cachedStorage[lendingId] = amount } return true } -func (self *stateLendingBook) getAllTradeIds(db Database) []common.Hash { +func (s *stateLendingBook) getAllTradeIds(db Database) []common.Hash { tradeIds := []common.Hash{} - lendingBookTrie := self.getTrie(db) + lendingBookTrie := s.getTrie(db) if lendingBookTrie == nil { return tradeIds } - for id, value := range self.cachedStorage { + for id, value := range s.cachedStorage { if !common.EmptyHash(value) { tradeIds = append(tradeIds, id) } @@ -125,7 +125,7 @@ func (self *stateLendingBook) getAllTradeIds(db Database) []common.Hash { orderListIt := trie.NewIterator(lendingBookTrie.NodeIterator(nil)) for orderListIt.Next() { id := common.BytesToHash(orderListIt.Key) - if _, exist := self.cachedStorage[id]; exist { + if _, exist := s.cachedStorage[id]; exist { continue } tradeIds = append(tradeIds, id) @@ -133,83 +133,83 @@ func (self *stateLendingBook) getAllTradeIds(db Database) []common.Hash { return tradeIds } -func (self *stateLendingBook) insertTradingId(db Database, tradeId common.Hash) { - self.setTradingId(tradeId, tradeId) - self.setError(self.getTrie(db).TryUpdate(tradeId[:], tradeId[:])) +func (s *stateLendingBook) insertTradingId(db Database, tradeId common.Hash) { + s.setTradingId(tradeId, tradeId) + s.setError(s.getTrie(db).TryUpdate(tradeId[:], tradeId[:])) } -func (self *stateLendingBook) removeTradingId(db Database, tradeId common.Hash) { - tr := self.getTrie(db) - self.setError(tr.TryDelete(tradeId[:])) - self.setTradingId(tradeId, EmptyHash) +func (s *stateLendingBook) removeTradingId(db Database, tradeId common.Hash) { + tr := s.getTrie(db) + s.setError(tr.TryDelete(tradeId[:])) + s.setTradingId(tradeId, EmptyHash) } -func (self *stateLendingBook) setTradingId(tradeId common.Hash, value common.Hash) { - self.cachedStorage[tradeId] = value - self.dirtyStorage[tradeId] = value +func (s *stateLendingBook) setTradingId(tradeId common.Hash, value common.Hash) { + s.cachedStorage[tradeId] = value + s.dirtyStorage[tradeId] = value - if self.onDirty != nil { - self.onDirty(self.lendingBook) - self.onDirty = nil + if s.onDirty != nil { + s.onDirty(s.lendingBook) + s.onDirty = nil } } -func (self *stateLendingBook) updateTrie(db Database) Trie { - tr := self.getTrie(db) - for key, value := range self.dirtyStorage { - delete(self.dirtyStorage, key) +func (s *stateLendingBook) updateTrie(db Database) Trie { + tr := s.getTrie(db) + for key, value := range s.dirtyStorage { + delete(s.dirtyStorage, key) if value == EmptyHash { - self.setError(tr.TryDelete(key[:])) + s.setError(tr.TryDelete(key[:])) continue } v, _ := rlp.EncodeToBytes(bytes.TrimLeft(value[:], "\x00")) - self.setError(tr.TryUpdate(key[:], v)) + s.setError(tr.TryUpdate(key[:], v)) } return tr } -func (self *stateLendingBook) updateRoot(db Database) error { - self.updateTrie(db) - if self.dbErr != nil { - return self.dbErr +func (s *stateLendingBook) updateRoot(db Database) error { + s.updateTrie(db) + if s.dbErr != nil { + return s.dbErr } - root, err := self.trie.Commit(nil) + root, err := s.trie.Commit(nil) if err == nil { - self.data.Root = root + s.data.Root = root } return err } -func (self *stateLendingBook) deepCopy(db *TradingStateDB, onDirty func(price common.Hash)) *stateLendingBook { - stateLendingBook := newStateLendingBook(self.lendingBook, self.orderBook, self.price, self.data, onDirty) - if self.trie != nil { - stateLendingBook.trie = db.db.CopyTrie(self.trie) +func (s *stateLendingBook) deepCopy(db *TradingStateDB, onDirty func(price common.Hash)) *stateLendingBook { + stateLendingBook := newStateLendingBook(s.lendingBook, s.orderBook, s.price, s.data, onDirty) + if s.trie != nil { + stateLendingBook.trie = db.db.CopyTrie(s.trie) } - for key, value := range self.dirtyStorage { + for key, value := range s.dirtyStorage { stateLendingBook.dirtyStorage[key] = value } - for key, value := range self.cachedStorage { + for key, value := range s.cachedStorage { stateLendingBook.cachedStorage[key] = value } return stateLendingBook } -func (c *stateLendingBook) AddVolume(amount *big.Int) { - c.setVolume(new(big.Int).Add(c.data.Volume, amount)) +func (s *stateLendingBook) AddVolume(amount *big.Int) { + s.setVolume(new(big.Int).Add(s.data.Volume, amount)) } -func (c *stateLendingBook) subVolume(amount *big.Int) { - c.setVolume(new(big.Int).Sub(c.data.Volume, amount)) +func (s *stateLendingBook) subVolume(amount *big.Int) { + s.setVolume(new(big.Int).Sub(s.data.Volume, amount)) } -func (self *stateLendingBook) setVolume(volume *big.Int) { - self.data.Volume = volume - if self.onDirty != nil { - self.onDirty(self.lendingBook) - self.onDirty = nil +func (s *stateLendingBook) setVolume(volume *big.Int) { + s.data.Volume = volume + if s.onDirty != nil { + s.onDirty(s.lendingBook) + s.onDirty = nil } } -func (self *stateLendingBook) Volume() *big.Int { - return self.data.Volume +func (s *stateLendingBook) Volume() *big.Int { + return s.data.Volume } diff --git a/XDCx/tradingstate/state_liquidationprice.go b/XDCx/tradingstate/state_liquidationprice.go index 5a4e4aca63..d978512dc6 100644 --- a/XDCx/tradingstate/state_liquidationprice.go +++ b/XDCx/tradingstate/state_liquidationprice.go @@ -68,54 +68,54 @@ func newLiquidationPriceState(db *TradingStateDB, orderBook common.Hash, price c } // EncodeRLP implements rlp.Encoder. -func (c *liquidationPriceState) EncodeRLP(w io.Writer) error { - return rlp.Encode(w, c.data) +func (l *liquidationPriceState) EncodeRLP(w io.Writer) error { + return rlp.Encode(w, l.data) } // setError remembers the first non-nil error it is called with. -func (self *liquidationPriceState) setError(err error) { - if self.dbErr == nil { - self.dbErr = err +func (l *liquidationPriceState) setError(err error) { + if l.dbErr == nil { + l.dbErr = err } } -func (self *liquidationPriceState) MarkStateLendingBookDirty(price common.Hash) { - self.stateLendingBooksDirty[price] = struct{}{} - if self.onDirty != nil { - self.onDirty(self.liquidationPrice) - self.onDirty = nil +func (l *liquidationPriceState) MarkStateLendingBookDirty(price common.Hash) { + l.stateLendingBooksDirty[price] = struct{}{} + if l.onDirty != nil { + l.onDirty(l.liquidationPrice) + l.onDirty = nil } } -func (self *liquidationPriceState) createLendingBook(db Database, lendingBook common.Hash) (newobj *stateLendingBook) { - newobj = newStateLendingBook(self.orderBook, self.liquidationPrice, lendingBook, orderList{Volume: Zero}, self.MarkStateLendingBookDirty) - self.stateLendingBooks[lendingBook] = newobj - self.stateLendingBooksDirty[lendingBook] = struct{}{} - if self.onDirty != nil { - self.onDirty(self.liquidationPrice) - self.onDirty = nil +func (l *liquidationPriceState) createLendingBook(db Database, lendingBook common.Hash) (newobj *stateLendingBook) { + newobj = newStateLendingBook(l.orderBook, l.liquidationPrice, lendingBook, orderList{Volume: Zero}, l.MarkStateLendingBookDirty) + l.stateLendingBooks[lendingBook] = newobj + l.stateLendingBooksDirty[lendingBook] = struct{}{} + if l.onDirty != nil { + l.onDirty(l.liquidationPrice) + l.onDirty = nil } return newobj } -func (self *liquidationPriceState) getTrie(db Database) Trie { - if self.trie == nil { +func (l *liquidationPriceState) getTrie(db Database) Trie { + if l.trie == nil { var err error - self.trie, err = db.OpenStorageTrie(self.liquidationPrice, self.data.Root) + l.trie, err = db.OpenStorageTrie(l.liquidationPrice, l.data.Root) if err != nil { - self.trie, _ = db.OpenStorageTrie(self.liquidationPrice, EmptyHash) - self.setError(fmt.Errorf("can't create storage trie: %v", err)) + l.trie, _ = db.OpenStorageTrie(l.liquidationPrice, EmptyHash) + l.setError(fmt.Errorf("can't create storage trie: %v", err)) } } - return self.trie + return l.trie } -func (self *liquidationPriceState) updateTrie(db Database) Trie { - tr := self.getTrie(db) - for lendingId, stateObject := range self.stateLendingBooks { - delete(self.stateLendingBooksDirty, lendingId) +func (l *liquidationPriceState) updateTrie(db Database) Trie { + tr := l.getTrie(db) + for lendingId, stateObject := range l.stateLendingBooks { + delete(l.stateLendingBooksDirty, lendingId) if stateObject.empty() { - self.setError(tr.TryDelete(lendingId[:])) + l.setError(tr.TryDelete(lendingId[:])) continue } err := stateObject.updateRoot(db) @@ -125,17 +125,17 @@ func (self *liquidationPriceState) updateTrie(db Database) Trie { // Encoding []byte cannot fail, ok to ignore the error. v, _ := rlp.EncodeToBytes(stateObject) - self.setError(tr.TryUpdate(lendingId[:], v)) + l.setError(tr.TryUpdate(lendingId[:], v)) } return tr } -func (self *liquidationPriceState) updateRoot(db Database) error { - self.updateTrie(db) - if self.dbErr != nil { - return self.dbErr +func (l *liquidationPriceState) updateRoot(db Database) error { + l.updateTrie(db) + if l.dbErr != nil { + return l.dbErr } - root, err := self.trie.Commit(func(leaf []byte, parent common.Hash) error { + root, err := l.trie.Commit(func(leaf []byte, parent common.Hash) error { var orderList orderList if err := rlp.DecodeBytes(leaf, &orderList); err != nil { return nil @@ -146,57 +146,57 @@ func (self *liquidationPriceState) updateRoot(db Database) error { return nil }) if err == nil { - self.data.Root = root + l.data.Root = root } return err } -func (self *liquidationPriceState) deepCopy(db *TradingStateDB, onDirty func(liquidationPrice common.Hash)) *liquidationPriceState { - stateOrderList := newLiquidationPriceState(db, self.orderBook, self.liquidationPrice, self.data, onDirty) - if self.trie != nil { - stateOrderList.trie = db.db.CopyTrie(self.trie) +func (l *liquidationPriceState) deepCopy(db *TradingStateDB, onDirty func(liquidationPrice common.Hash)) *liquidationPriceState { + stateOrderList := newLiquidationPriceState(db, l.orderBook, l.liquidationPrice, l.data, onDirty) + if l.trie != nil { + stateOrderList.trie = db.db.CopyTrie(l.trie) } - for key, value := range self.stateLendingBooks { - stateOrderList.stateLendingBooks[key] = value.deepCopy(db, self.MarkStateLendingBookDirty) + for key, value := range l.stateLendingBooks { + stateOrderList.stateLendingBooks[key] = value.deepCopy(db, l.MarkStateLendingBookDirty) } - for key, value := range self.stateLendingBooksDirty { + for key, value := range l.stateLendingBooksDirty { stateOrderList.stateLendingBooksDirty[key] = value } return stateOrderList } // Retrieve a state object given my the address. Returns nil if not found. -func (self *liquidationPriceState) getStateLendingBook(db Database, lendingBook common.Hash) (stateObject *stateLendingBook) { +func (l *liquidationPriceState) getStateLendingBook(db Database, lendingBook common.Hash) (stateObject *stateLendingBook) { // Prefer 'live' objects. - if obj := self.stateLendingBooks[lendingBook]; obj != nil { + if obj := l.stateLendingBooks[lendingBook]; obj != nil { return obj } // Load the object from the database. - enc, err := self.getTrie(db).TryGet(lendingBook[:]) + enc, err := l.getTrie(db).TryGet(lendingBook[:]) if len(enc) == 0 { - self.setError(err) + l.setError(err) return nil } var data orderList if err := rlp.DecodeBytes(enc, &data); err != nil { - log.Error("Failed to decode state lending book ", "orderbook", self.orderBook, "liquidation price", self.liquidationPrice, "lendingBook", lendingBook, "err", err) + log.Error("Failed to decode state lending book ", "orderbook", l.orderBook, "liquidation price", l.liquidationPrice, "lendingBook", lendingBook, "err", err) return nil } // Insert into the live set. - obj := newStateLendingBook(self.orderBook, self.liquidationPrice, lendingBook, data, self.MarkStateLendingBookDirty) - self.stateLendingBooks[lendingBook] = obj + obj := newStateLendingBook(l.orderBook, l.liquidationPrice, lendingBook, data, l.MarkStateLendingBookDirty) + l.stateLendingBooks[lendingBook] = obj return obj } -func (self *liquidationPriceState) getAllLiquidationData(db Database) map[common.Hash][]common.Hash { +func (l *liquidationPriceState) getAllLiquidationData(db Database) map[common.Hash][]common.Hash { liquidationData := map[common.Hash][]common.Hash{} - lendingBookTrie := self.getTrie(db) + lendingBookTrie := l.getTrie(db) if lendingBookTrie == nil { return liquidationData } lendingBooks := []common.Hash{} - for id, stateLendingBook := range self.stateLendingBooks { + for id, stateLendingBook := range l.stateLendingBooks { if !stateLendingBook.empty() { lendingBooks = append(lendingBooks, id) } @@ -204,13 +204,13 @@ func (self *liquidationPriceState) getAllLiquidationData(db Database) map[common lendingBookListIt := trie.NewIterator(lendingBookTrie.NodeIterator(nil)) for lendingBookListIt.Next() { id := common.BytesToHash(lendingBookListIt.Key) - if _, exist := self.stateLendingBooks[id]; exist { + if _, exist := l.stateLendingBooks[id]; exist { continue } lendingBooks = append(lendingBooks, id) } for _, lendingBook := range lendingBooks { - stateLendingBook := self.getStateLendingBook(db, lendingBook) + stateLendingBook := l.getStateLendingBook(db, lendingBook) if stateLendingBook != nil { liquidationData[lendingBook] = stateLendingBook.getAllTradeIds(db) } @@ -218,22 +218,22 @@ func (self *liquidationPriceState) getAllLiquidationData(db Database) map[common return liquidationData } -func (c *liquidationPriceState) AddVolume(amount *big.Int) { - c.setVolume(new(big.Int).Add(c.data.Volume, amount)) +func (l *liquidationPriceState) AddVolume(amount *big.Int) { + l.setVolume(new(big.Int).Add(l.data.Volume, amount)) } func (c *liquidationPriceState) subVolume(amount *big.Int) { c.setVolume(new(big.Int).Sub(c.data.Volume, amount)) } -func (self *liquidationPriceState) setVolume(volume *big.Int) { - self.data.Volume = volume - if self.onDirty != nil { - self.onDirty(self.liquidationPrice) - self.onDirty = nil +func (l *liquidationPriceState) setVolume(volume *big.Int) { + l.data.Volume = volume + if l.onDirty != nil { + l.onDirty(l.liquidationPrice) + l.onDirty = nil } } -func (self *liquidationPriceState) Volume() *big.Int { - return self.data.Volume +func (l *liquidationPriceState) Volume() *big.Int { + return l.data.Volume } diff --git a/XDCx/tradingstate/state_orderItem.go b/XDCx/tradingstate/state_orderItem.go index b1e390b505..758dba829f 100644 --- a/XDCx/tradingstate/state_orderItem.go +++ b/XDCx/tradingstate/state_orderItem.go @@ -53,23 +53,23 @@ func newStateOrderItem(orderBook common.Hash, orderId common.Hash, data OrderIte } // EncodeRLP implements rlp.Encoder. -func (c *stateOrderItem) EncodeRLP(w io.Writer) error { - return rlp.Encode(w, c.data) +func (s *stateOrderItem) EncodeRLP(w io.Writer) error { + return rlp.Encode(w, s.data) } -func (self *stateOrderItem) deepCopy(onDirty func(orderId common.Hash)) *stateOrderItem { - stateOrderList := newStateOrderItem(self.orderBook, self.orderId, self.data, onDirty) +func (s *stateOrderItem) deepCopy(onDirty func(orderId common.Hash)) *stateOrderItem { + stateOrderList := newStateOrderItem(s.orderBook, s.orderId, s.data, onDirty) return stateOrderList } -func (self *stateOrderItem) setVolume(volume *big.Int) { - self.data.Quantity = volume - if self.onDirty != nil { - self.onDirty(self.orderId) - self.onDirty = nil +func (s *stateOrderItem) setVolume(volume *big.Int) { + s.data.Quantity = volume + if s.onDirty != nil { + s.onDirty(s.orderId) + s.onDirty = nil } } -func (self *stateOrderItem) Quantity() *big.Int { - return self.data.Quantity +func (s *stateOrderItem) Quantity() *big.Int { + return s.data.Quantity } diff --git a/XDCx/tradingstate/state_orderList.go b/XDCx/tradingstate/state_orderList.go index 44de770e9d..7946ec538f 100644 --- a/XDCx/tradingstate/state_orderList.go +++ b/XDCx/tradingstate/state_orderList.go @@ -75,14 +75,14 @@ func newStateOrderList(db *TradingStateDB, orderType string, orderBook common.Ha } // EncodeRLP implements rlp.Encoder. -func (c *stateOrderList) EncodeRLP(w io.Writer) error { - return rlp.Encode(w, c.data) +func (s *stateOrderList) EncodeRLP(w io.Writer) error { + return rlp.Encode(w, s.data) } // setError remembers the first non-nil error it is called with. -func (self *stateOrderList) setError(err error) { - if self.dbErr == nil { - self.dbErr = err +func (s *stateOrderList) setError(err error) { + if s.dbErr == nil { + s.dbErr = err } } @@ -99,90 +99,90 @@ func (c *stateOrderList) getTrie(db Database) Trie { } // GetState returns a value in orderId storage. -func (self *stateOrderList) GetOrderAmount(db Database, orderId common.Hash) common.Hash { - amount, exists := self.cachedStorage[orderId] +func (s *stateOrderList) GetOrderAmount(db Database, orderId common.Hash) common.Hash { + amount, exists := s.cachedStorage[orderId] if exists { return amount } // Load from DB in case it is missing. - enc, err := self.getTrie(db).TryGet(orderId[:]) + enc, err := s.getTrie(db).TryGet(orderId[:]) if err != nil { - self.setError(err) + s.setError(err) return EmptyHash } if len(enc) > 0 { _, content, _, err := rlp.Split(enc) if err != nil { - self.setError(err) + s.setError(err) } amount.SetBytes(content) } if (amount != common.Hash{}) { - self.cachedStorage[orderId] = amount + s.cachedStorage[orderId] = amount } return amount } // SetState updates a value in orderId storage. -func (self *stateOrderList) insertOrderItem(db Database, orderId common.Hash, amount common.Hash) { - self.setOrderItem(orderId, amount) - self.setError(self.getTrie(db).TryUpdate(orderId[:], amount[:])) +func (s *stateOrderList) insertOrderItem(db Database, orderId common.Hash, amount common.Hash) { + s.setOrderItem(orderId, amount) + s.setError(s.getTrie(db).TryUpdate(orderId[:], amount[:])) } // SetState updates a value in orderId storage. -func (self *stateOrderList) removeOrderItem(db Database, orderId common.Hash) { - tr := self.getTrie(db) - self.setError(tr.TryDelete(orderId[:])) - self.setOrderItem(orderId, EmptyHash) +func (s *stateOrderList) removeOrderItem(db Database, orderId common.Hash) { + tr := s.getTrie(db) + s.setError(tr.TryDelete(orderId[:])) + s.setOrderItem(orderId, EmptyHash) } -func (self *stateOrderList) setOrderItem(orderId common.Hash, amount common.Hash) { - self.cachedStorage[orderId] = amount - self.dirtyStorage[orderId] = amount +func (s *stateOrderList) setOrderItem(orderId common.Hash, amount common.Hash) { + s.cachedStorage[orderId] = amount + s.dirtyStorage[orderId] = amount - if self.onDirty != nil { - self.onDirty(self.Price()) - self.onDirty = nil + if s.onDirty != nil { + s.onDirty(s.Price()) + s.onDirty = nil } } // updateAskTrie writes cached storage modifications into the object's storage trie. -func (self *stateOrderList) updateTrie(db Database) Trie { - tr := self.getTrie(db) - for orderId, amount := range self.dirtyStorage { - delete(self.dirtyStorage, orderId) +func (s *stateOrderList) updateTrie(db Database) Trie { + tr := s.getTrie(db) + for orderId, amount := range s.dirtyStorage { + delete(s.dirtyStorage, orderId) if amount == EmptyHash { - self.setError(tr.TryDelete(orderId[:])) + s.setError(tr.TryDelete(orderId[:])) continue } v, _ := rlp.EncodeToBytes(bytes.TrimLeft(amount[:], "\x00")) - self.setError(tr.TryUpdate(orderId[:], v)) + s.setError(tr.TryUpdate(orderId[:], v)) } return tr } // UpdateRoot sets the trie root to the current root orderId of -func (self *stateOrderList) updateRoot(db Database) error { - self.updateTrie(db) - if self.dbErr != nil { - return self.dbErr +func (s *stateOrderList) updateRoot(db Database) error { + s.updateTrie(db) + if s.dbErr != nil { + return s.dbErr } - root, err := self.trie.Commit(nil) + root, err := s.trie.Commit(nil) if err == nil { - self.data.Root = root + s.data.Root = root } return err } -func (self *stateOrderList) deepCopy(db *TradingStateDB, onDirty func(price common.Hash)) *stateOrderList { - stateOrderList := newStateOrderList(db, self.orderType, self.orderBook, self.price, self.data, onDirty) - if self.trie != nil { - stateOrderList.trie = db.db.CopyTrie(self.trie) +func (s *stateOrderList) deepCopy(db *TradingStateDB, onDirty func(price common.Hash)) *stateOrderList { + stateOrderList := newStateOrderList(db, s.orderType, s.orderBook, s.price, s.data, onDirty) + if s.trie != nil { + stateOrderList.trie = db.db.CopyTrie(s.trie) } - for orderId, amount := range self.dirtyStorage { + for orderId, amount := range s.dirtyStorage { stateOrderList.dirtyStorage[orderId] = amount } - for orderId, amount := range self.cachedStorage { + for orderId, amount := range s.cachedStorage { stateOrderList.cachedStorage[orderId] = amount } return stateOrderList @@ -190,29 +190,29 @@ func (self *stateOrderList) deepCopy(db *TradingStateDB, onDirty func(price comm // AddVolume removes amount from c's balance. // It is used to add funds to the destination exchanges of a transfer. -func (c *stateOrderList) AddVolume(amount *big.Int) { - c.setVolume(new(big.Int).Add(c.data.Volume, amount)) +func (s *stateOrderList) AddVolume(amount *big.Int) { + s.setVolume(new(big.Int).Add(s.data.Volume, amount)) } // AddVolume removes amount from c's balance. // It is used to add funds to the destination exchanges of a transfer. -func (c *stateOrderList) subVolume(amount *big.Int) { - c.setVolume(new(big.Int).Sub(c.data.Volume, amount)) +func (s *stateOrderList) subVolume(amount *big.Int) { + s.setVolume(new(big.Int).Sub(s.data.Volume, amount)) } -func (self *stateOrderList) setVolume(volume *big.Int) { - self.data.Volume = volume - if self.onDirty != nil { - self.onDirty(self.price) - self.onDirty = nil +func (s *stateOrderList) setVolume(volume *big.Int) { + s.data.Volume = volume + if s.onDirty != nil { + s.onDirty(s.price) + s.onDirty = nil } } // Returns the address of the contract/orderId -func (c *stateOrderList) Price() common.Hash { - return c.price +func (s *stateOrderList) Price() common.Hash { + return s.price } -func (self *stateOrderList) Volume() *big.Int { - return self.data.Volume +func (s *stateOrderList) Volume() *big.Int { + return s.data.Volume } diff --git a/XDCx/tradingstate/state_orderbook.go b/XDCx/tradingstate/state_orderbook.go index 3bfdd33e0e..8d74d748e4 100644 --- a/XDCx/tradingstate/state_orderbook.go +++ b/XDCx/tradingstate/state_orderbook.go @@ -66,35 +66,35 @@ type tradingExchanges struct { } // empty returns whether the orderId is considered empty. -func (s *tradingExchanges) empty() bool { - if s.data.Nonce != 0 { +func (te *tradingExchanges) empty() bool { + if te.data.Nonce != 0 { return false } - if s.data.LendingCount != nil && s.data.LendingCount.Sign() > 0 { + if te.data.LendingCount != nil && te.data.LendingCount.Sign() > 0 { return false } - if s.data.LastPrice != nil && s.data.LastPrice.Sign() > 0 { + if te.data.LastPrice != nil && te.data.LastPrice.Sign() > 0 { return false } - if s.data.MediumPrice != nil && s.data.MediumPrice.Sign() > 0 { + if te.data.MediumPrice != nil && te.data.MediumPrice.Sign() > 0 { return false } - if s.data.MediumPriceBeforeEpoch != nil && s.data.MediumPriceBeforeEpoch.Sign() > 0 { + if te.data.MediumPriceBeforeEpoch != nil && te.data.MediumPriceBeforeEpoch.Sign() > 0 { return false } - if s.data.TotalQuantity != nil && s.data.TotalQuantity.Sign() > 0 { + if te.data.TotalQuantity != nil && te.data.TotalQuantity.Sign() > 0 { return false } - if !common.EmptyHash(s.data.AskRoot) { + if !common.EmptyHash(te.data.AskRoot) { return false } - if !common.EmptyHash(s.data.BidRoot) { + if !common.EmptyHash(te.data.BidRoot) { return false } - if !common.EmptyHash(s.data.OrderRoot) { + if !common.EmptyHash(te.data.OrderRoot) { return false } - if !common.EmptyHash(s.data.LiquidationPriceRoot) { + if !common.EmptyHash(te.data.LiquidationPriceRoot) { return false } return true @@ -119,46 +119,46 @@ func newStateExchanges(db *TradingStateDB, hash common.Hash, data tradingExchang } // EncodeRLP implements rlp.Encoder. -func (c *tradingExchanges) EncodeRLP(w io.Writer) error { - return rlp.Encode(w, c.data) +func (te *tradingExchanges) EncodeRLP(w io.Writer) error { + return rlp.Encode(w, te.data) } // setError remembers the first non-nil error it is called with. -func (self *tradingExchanges) setError(err error) { - if self.dbErr == nil { - self.dbErr = err +func (te *tradingExchanges) setError(err error) { + if te.dbErr == nil { + te.dbErr = err } } -func (c *tradingExchanges) getAsksTrie(db Database) Trie { - if c.asksTrie == nil { +func (te *tradingExchanges) getAsksTrie(db Database) Trie { + if te.asksTrie == nil { var err error - c.asksTrie, err = db.OpenStorageTrie(c.orderBookHash, c.data.AskRoot) + te.asksTrie, err = db.OpenStorageTrie(te.orderBookHash, te.data.AskRoot) if err != nil { - c.asksTrie, _ = db.OpenStorageTrie(c.orderBookHash, EmptyHash) - c.setError(fmt.Errorf("can't create asks trie: %v", err)) + te.asksTrie, _ = db.OpenStorageTrie(te.orderBookHash, EmptyHash) + te.setError(fmt.Errorf("can't create asks trie: %v", err)) } } - return c.asksTrie + return te.asksTrie } -func (c *tradingExchanges) getOrdersTrie(db Database) Trie { - if c.ordersTrie == nil { +func (te *tradingExchanges) getOrdersTrie(db Database) Trie { + if te.ordersTrie == nil { var err error - c.ordersTrie, err = db.OpenStorageTrie(c.orderBookHash, c.data.OrderRoot) + te.ordersTrie, err = db.OpenStorageTrie(te.orderBookHash, te.data.OrderRoot) if err != nil { - c.ordersTrie, _ = db.OpenStorageTrie(c.orderBookHash, EmptyHash) - c.setError(fmt.Errorf("can't create asks trie: %v", err)) + te.ordersTrie, _ = db.OpenStorageTrie(te.orderBookHash, EmptyHash) + te.setError(fmt.Errorf("can't create asks trie: %v", err)) } } - return c.ordersTrie + return te.ordersTrie } -func (c *tradingExchanges) getBestPriceAsksTrie(db Database) common.Hash { - trie := c.getAsksTrie(db) +func (te *tradingExchanges) getBestPriceAsksTrie(db Database) common.Hash { + trie := te.getAsksTrie(db) encKey, encValue, err := trie.TryGetBestLeftKeyAndValue() if err != nil { - log.Error("Failed find best price ask trie ", "orderbook", c.orderBookHash.Hex()) + log.Error("Failed find best price ask trie ", "orderbook", te.orderBookHash.Hex()) return EmptyHash } if len(encKey) == 0 || len(encValue) == 0 { @@ -166,23 +166,23 @@ func (c *tradingExchanges) getBestPriceAsksTrie(db Database) common.Hash { return EmptyHash } price := common.BytesToHash(encKey) - if _, exit := c.stateAskObjects[price]; !exit { + if _, exit := te.stateAskObjects[price]; !exit { var data orderList if err := rlp.DecodeBytes(encValue, &data); err != nil { log.Error("Failed to decode state get best ask trie", "err", err) return EmptyHash } - obj := newStateOrderList(c.db, Bid, c.orderBookHash, price, data, c.MarkStateAskObjectDirty) - c.stateAskObjects[price] = obj + obj := newStateOrderList(te.db, Bid, te.orderBookHash, price, data, te.MarkStateAskObjectDirty) + te.stateAskObjects[price] = obj } return common.BytesToHash(encKey) } -func (c *tradingExchanges) getBestBidsTrie(db Database) common.Hash { - trie := c.getBidsTrie(db) +func (te *tradingExchanges) getBestBidsTrie(db Database) common.Hash { + trie := te.getBidsTrie(db) encKey, encValue, err := trie.TryGetBestRightKeyAndValue() if err != nil { - log.Error("Failed find best price bid trie ", "orderbook", c.orderBookHash.Hex()) + log.Error("Failed find best price bid trie ", "orderbook", te.orderBookHash.Hex()) return EmptyHash } if len(encKey) == 0 || len(encValue) == 0 { @@ -190,27 +190,27 @@ func (c *tradingExchanges) getBestBidsTrie(db Database) common.Hash { return EmptyHash } price := common.BytesToHash(encKey) - if _, exit := c.stateBidObjects[price]; !exit { + if _, exit := te.stateBidObjects[price]; !exit { var data orderList if err := rlp.DecodeBytes(encValue, &data); err != nil { log.Error("Failed to decode state get best bid trie", "err", err) return EmptyHash } // Insert into the live set. - obj := newStateOrderList(c.db, Bid, c.orderBookHash, price, data, c.MarkStateBidObjectDirty) - c.stateBidObjects[price] = obj + obj := newStateOrderList(te.db, Bid, te.orderBookHash, price, data, te.MarkStateBidObjectDirty) + te.stateBidObjects[price] = obj } return common.BytesToHash(encKey) } // updateAskTrie writes cached storage modifications into the object's storage trie. -func (self *tradingExchanges) updateAsksTrie(db Database) Trie { - tr := self.getAsksTrie(db) - for price, orderList := range self.stateAskObjects { - if _, isDirty := self.stateAskObjectsDirty[price]; isDirty { - delete(self.stateAskObjectsDirty, price) +func (te *tradingExchanges) updateAsksTrie(db Database) Trie { + tr := te.getAsksTrie(db) + for price, orderList := range te.stateAskObjects { + if _, isDirty := te.stateAskObjectsDirty[price]; isDirty { + delete(te.stateAskObjectsDirty, price) if orderList.empty() { - self.setError(tr.TryDelete(price[:])) + te.setError(tr.TryDelete(price[:])) continue } err := orderList.updateRoot(db) @@ -219,7 +219,7 @@ func (self *tradingExchanges) updateAsksTrie(db Database) Trie { } // Encoding []byte cannot fail, ok to ignore the error. v, _ := rlp.EncodeToBytes(orderList) - self.setError(tr.TryUpdate(price[:], v)) + te.setError(tr.TryUpdate(price[:], v)) } } @@ -228,23 +228,23 @@ func (self *tradingExchanges) updateAsksTrie(db Database) Trie { // CommitAskTrie the storage trie of the object to dwb. // This updates the trie root. -func (self *tradingExchanges) updateAsksRoot(db Database) error { - self.updateAsksTrie(db) - if self.dbErr != nil { - return self.dbErr +func (te *tradingExchanges) updateAsksRoot(db Database) error { + te.updateAsksTrie(db) + if te.dbErr != nil { + return te.dbErr } - self.data.AskRoot = self.asksTrie.Hash() + te.data.AskRoot = te.asksTrie.Hash() return nil } // CommitAskTrie the storage trie of the object to dwb. // This updates the trie root. -func (self *tradingExchanges) CommitAsksTrie(db Database) error { - self.updateAsksTrie(db) - if self.dbErr != nil { - return self.dbErr +func (te *tradingExchanges) CommitAsksTrie(db Database) error { + te.updateAsksTrie(db) + if te.dbErr != nil { + return te.dbErr } - root, err := self.asksTrie.Commit(func(leaf []byte, parent common.Hash) error { + root, err := te.asksTrie.Commit(func(leaf []byte, parent common.Hash) error { var orderList orderList if err := rlp.DecodeBytes(leaf, &orderList); err != nil { return nil @@ -255,31 +255,31 @@ func (self *tradingExchanges) CommitAsksTrie(db Database) error { return nil }) if err == nil { - self.data.AskRoot = root + te.data.AskRoot = root } return err } -func (c *tradingExchanges) getBidsTrie(db Database) Trie { - if c.bidsTrie == nil { +func (te *tradingExchanges) getBidsTrie(db Database) Trie { + if te.bidsTrie == nil { var err error - c.bidsTrie, err = db.OpenStorageTrie(c.orderBookHash, c.data.BidRoot) + te.bidsTrie, err = db.OpenStorageTrie(te.orderBookHash, te.data.BidRoot) if err != nil { - c.bidsTrie, _ = db.OpenStorageTrie(c.orderBookHash, EmptyHash) - c.setError(fmt.Errorf("can't create bids trie: %v", err)) + te.bidsTrie, _ = db.OpenStorageTrie(te.orderBookHash, EmptyHash) + te.setError(fmt.Errorf("can't create bids trie: %v", err)) } } - return c.bidsTrie + return te.bidsTrie } // updateAskTrie writes cached storage modifications into the object's storage trie. -func (self *tradingExchanges) updateBidsTrie(db Database) Trie { - tr := self.getBidsTrie(db) - for price, orderList := range self.stateBidObjects { - if _, isDirty := self.stateBidObjectsDirty[price]; isDirty { - delete(self.stateBidObjectsDirty, price) +func (te *tradingExchanges) updateBidsTrie(db Database) Trie { + tr := te.getBidsTrie(db) + for price, orderList := range te.stateBidObjects { + if _, isDirty := te.stateBidObjectsDirty[price]; isDirty { + delete(te.stateBidObjectsDirty, price) if orderList.empty() { - self.setError(tr.TryDelete(price[:])) + te.setError(tr.TryDelete(price[:])) continue } err := orderList.updateRoot(db) @@ -288,25 +288,25 @@ func (self *tradingExchanges) updateBidsTrie(db Database) Trie { } // Encoding []byte cannot fail, ok to ignore the error. v, _ := rlp.EncodeToBytes(orderList) - self.setError(tr.TryUpdate(price[:], v)) + te.setError(tr.TryUpdate(price[:], v)) } } return tr } -func (self *tradingExchanges) updateBidsRoot(db Database) { - self.updateBidsTrie(db) - self.data.BidRoot = self.bidsTrie.Hash() +func (te *tradingExchanges) updateBidsRoot(db Database) { + te.updateBidsTrie(db) + te.data.BidRoot = te.bidsTrie.Hash() } // CommitAskTrie the storage trie of the object to dwb. // This updates the trie root. -func (self *tradingExchanges) CommitBidsTrie(db Database) error { - self.updateBidsTrie(db) - if self.dbErr != nil { - return self.dbErr +func (te *tradingExchanges) CommitBidsTrie(db Database) error { + te.updateBidsTrie(db) + if te.dbErr != nil { + return te.dbErr } - root, err := self.bidsTrie.Commit(func(leaf []byte, parent common.Hash) error { + root, err := te.bidsTrie.Commit(func(leaf []byte, parent common.Hash) error { var orderList orderList if err := rlp.DecodeBytes(leaf, &orderList); err != nil { return nil @@ -317,116 +317,116 @@ func (self *tradingExchanges) CommitBidsTrie(db Database) error { return nil }) if err == nil { - self.data.BidRoot = root + te.data.BidRoot = root } return err } -func (self *tradingExchanges) deepCopy(db *TradingStateDB, onDirty func(hash common.Hash)) *tradingExchanges { - stateExchanges := newStateExchanges(db, self.orderBookHash, self.data, onDirty) - if self.asksTrie != nil { - stateExchanges.asksTrie = db.db.CopyTrie(self.asksTrie) +func (te *tradingExchanges) deepCopy(db *TradingStateDB, onDirty func(hash common.Hash)) *tradingExchanges { + stateExchanges := newStateExchanges(db, te.orderBookHash, te.data, onDirty) + if te.asksTrie != nil { + stateExchanges.asksTrie = db.db.CopyTrie(te.asksTrie) } - if self.bidsTrie != nil { - stateExchanges.bidsTrie = db.db.CopyTrie(self.bidsTrie) + if te.bidsTrie != nil { + stateExchanges.bidsTrie = db.db.CopyTrie(te.bidsTrie) } - if self.ordersTrie != nil { - stateExchanges.ordersTrie = db.db.CopyTrie(self.ordersTrie) + if te.ordersTrie != nil { + stateExchanges.ordersTrie = db.db.CopyTrie(te.ordersTrie) } - for price, bidObject := range self.stateBidObjects { - stateExchanges.stateBidObjects[price] = bidObject.deepCopy(db, self.MarkStateBidObjectDirty) + for price, bidObject := range te.stateBidObjects { + stateExchanges.stateBidObjects[price] = bidObject.deepCopy(db, te.MarkStateBidObjectDirty) } - for price := range self.stateBidObjectsDirty { + for price := range te.stateBidObjectsDirty { stateExchanges.stateBidObjectsDirty[price] = struct{}{} } - for price, askObject := range self.stateAskObjects { - stateExchanges.stateAskObjects[price] = askObject.deepCopy(db, self.MarkStateAskObjectDirty) + for price, askObject := range te.stateAskObjects { + stateExchanges.stateAskObjects[price] = askObject.deepCopy(db, te.MarkStateAskObjectDirty) } - for price := range self.stateAskObjectsDirty { + for price := range te.stateAskObjectsDirty { stateExchanges.stateAskObjectsDirty[price] = struct{}{} } - for orderId, orderItem := range self.stateOrderObjects { - stateExchanges.stateOrderObjects[orderId] = orderItem.deepCopy(self.MarkStateOrderObjectDirty) + for orderId, orderItem := range te.stateOrderObjects { + stateExchanges.stateOrderObjects[orderId] = orderItem.deepCopy(te.MarkStateOrderObjectDirty) } - for orderId := range self.stateOrderObjectsDirty { + for orderId := range te.stateOrderObjectsDirty { stateExchanges.stateOrderObjectsDirty[orderId] = struct{}{} } - for price, liquidationPrice := range self.liquidationPriceStates { - stateExchanges.liquidationPriceStates[price] = liquidationPrice.deepCopy(db, self.MarkStateLiquidationPriceDirty) + for price, liquidationPrice := range te.liquidationPriceStates { + stateExchanges.liquidationPriceStates[price] = liquidationPrice.deepCopy(db, te.MarkStateLiquidationPriceDirty) } - for price := range self.liquidationPriceStatesDirty { + for price := range te.liquidationPriceStatesDirty { stateExchanges.liquidationPriceStatesDirty[price] = struct{}{} } return stateExchanges } // Returns the address of the contract/orderId -func (c *tradingExchanges) Hash() common.Hash { - return c.orderBookHash +func (te *tradingExchanges) Hash() common.Hash { + return te.orderBookHash } -func (self *tradingExchanges) SetNonce(nonce uint64) { - self.setNonce(nonce) +func (te *tradingExchanges) SetNonce(nonce uint64) { + te.setNonce(nonce) } -func (self *tradingExchanges) setNonce(nonce uint64) { - self.data.Nonce = nonce - if self.onDirty != nil { - self.onDirty(self.Hash()) - self.onDirty = nil +func (te *tradingExchanges) setNonce(nonce uint64) { + te.data.Nonce = nonce + if te.onDirty != nil { + te.onDirty(te.Hash()) + te.onDirty = nil } } -func (self *tradingExchanges) Nonce() uint64 { - return self.data.Nonce +func (te *tradingExchanges) Nonce() uint64 { + return te.data.Nonce } -func (self *tradingExchanges) setLastPrice(price *big.Int) { - self.data.LastPrice = price - if self.onDirty != nil { - self.onDirty(self.Hash()) - self.onDirty = nil +func (te *tradingExchanges) setLastPrice(price *big.Int) { + te.data.LastPrice = price + if te.onDirty != nil { + te.onDirty(te.Hash()) + te.onDirty = nil } } -func (self *tradingExchanges) setMediumPriceBeforeEpoch(price *big.Int) { - self.data.MediumPriceBeforeEpoch = price - if self.onDirty != nil { - self.onDirty(self.Hash()) - self.onDirty = nil +func (te *tradingExchanges) setMediumPriceBeforeEpoch(price *big.Int) { + te.data.MediumPriceBeforeEpoch = price + if te.onDirty != nil { + te.onDirty(te.Hash()) + te.onDirty = nil } } -func (self *tradingExchanges) setMediumPrice(price *big.Int, quantity *big.Int) { - self.data.MediumPrice = price - self.data.TotalQuantity = quantity - if self.onDirty != nil { - self.onDirty(self.Hash()) - self.onDirty = nil +func (te *tradingExchanges) setMediumPrice(price *big.Int, quantity *big.Int) { + te.data.MediumPrice = price + te.data.TotalQuantity = quantity + if te.onDirty != nil { + te.onDirty(te.Hash()) + te.onDirty = nil } } // updateStateExchangeObject writes the given object to the trie. -func (self *tradingExchanges) removeStateOrderListAskObject(db Database, stateOrderList *stateOrderList) { - self.setError(self.asksTrie.TryDelete(stateOrderList.price[:])) +func (te *tradingExchanges) removeStateOrderListAskObject(db Database, stateOrderList *stateOrderList) { + te.setError(te.asksTrie.TryDelete(stateOrderList.price[:])) } // updateStateExchangeObject writes the given object to the trie. -func (self *tradingExchanges) removeStateOrderListBidObject(db Database, stateOrderList *stateOrderList) { - self.setError(self.bidsTrie.TryDelete(stateOrderList.price[:])) +func (te *tradingExchanges) removeStateOrderListBidObject(db Database, stateOrderList *stateOrderList) { + te.setError(te.bidsTrie.TryDelete(stateOrderList.price[:])) } // Retrieve a state object given my the address. Returns nil if not found. -func (self *tradingExchanges) getStateOrderListAskObject(db Database, price common.Hash) (stateOrderList *stateOrderList) { +func (te *tradingExchanges) getStateOrderListAskObject(db Database, price common.Hash) (stateOrderList *stateOrderList) { // Prefer 'live' objects. - if obj := self.stateAskObjects[price]; obj != nil { + if obj := te.stateAskObjects[price]; obj != nil { return obj } // Load the object from the database. - enc, err := self.getAsksTrie(db).TryGet(price[:]) + enc, err := te.getAsksTrie(db).TryGet(price[:]) if len(enc) == 0 { - self.setError(err) + te.setError(err) return nil } var data orderList @@ -435,50 +435,50 @@ func (self *tradingExchanges) getStateOrderListAskObject(db Database, price comm return nil } // Insert into the live set. - obj := newStateOrderList(self.db, Bid, self.orderBookHash, price, data, self.MarkStateAskObjectDirty) - self.stateAskObjects[price] = obj + obj := newStateOrderList(te.db, Bid, te.orderBookHash, price, data, te.MarkStateAskObjectDirty) + te.stateAskObjects[price] = obj return obj } // MarkStateAskObjectDirty adds the specified object to the dirty map to avoid costly // state object cache iteration to find a handful of modified ones. -func (self *tradingExchanges) MarkStateAskObjectDirty(price common.Hash) { - self.stateAskObjectsDirty[price] = struct{}{} - if self.onDirty != nil { - self.onDirty(self.Hash()) - self.onDirty = nil +func (te *tradingExchanges) MarkStateAskObjectDirty(price common.Hash) { + te.stateAskObjectsDirty[price] = struct{}{} + if te.onDirty != nil { + te.onDirty(te.Hash()) + te.onDirty = nil } } // createStateOrderListObject creates a new state object. If there is an existing orderId with // the given address, it is overwritten and returned as the second return value. -func (self *tradingExchanges) createStateOrderListAskObject(db Database, price common.Hash) (newobj *stateOrderList) { - newobj = newStateOrderList(self.db, Ask, self.orderBookHash, price, orderList{Volume: Zero}, self.MarkStateAskObjectDirty) - self.stateAskObjects[price] = newobj - self.stateAskObjectsDirty[price] = struct{}{} +func (te *tradingExchanges) createStateOrderListAskObject(db Database, price common.Hash) (newobj *stateOrderList) { + newobj = newStateOrderList(te.db, Ask, te.orderBookHash, price, orderList{Volume: Zero}, te.MarkStateAskObjectDirty) + te.stateAskObjects[price] = newobj + te.stateAskObjectsDirty[price] = struct{}{} data, err := rlp.EncodeToBytes(newobj) if err != nil { panic(fmt.Errorf("can't encode order list object at %x: %v", price[:], err)) } - self.setError(self.asksTrie.TryUpdate(price[:], data)) - if self.onDirty != nil { - self.onDirty(self.Hash()) - self.onDirty = nil + te.setError(te.asksTrie.TryUpdate(price[:], data)) + if te.onDirty != nil { + te.onDirty(te.Hash()) + te.onDirty = nil } return newobj } // Retrieve a state object given my the address. Returns nil if not found. -func (self *tradingExchanges) getStateBidOrderListObject(db Database, price common.Hash) (stateOrderList *stateOrderList) { +func (te *tradingExchanges) getStateBidOrderListObject(db Database, price common.Hash) (stateOrderList *stateOrderList) { // Prefer 'live' objects. - if obj := self.stateBidObjects[price]; obj != nil { + if obj := te.stateBidObjects[price]; obj != nil { return obj } // Load the object from the database. - enc, err := self.getBidsTrie(db).TryGet(price[:]) + enc, err := te.getBidsTrie(db).TryGet(price[:]) if len(enc) == 0 { - self.setError(err) + te.setError(err) return nil } var data orderList @@ -487,50 +487,50 @@ func (self *tradingExchanges) getStateBidOrderListObject(db Database, price comm return nil } // Insert into the live set. - obj := newStateOrderList(self.db, Bid, self.orderBookHash, price, data, self.MarkStateBidObjectDirty) - self.stateBidObjects[price] = obj + obj := newStateOrderList(te.db, Bid, te.orderBookHash, price, data, te.MarkStateBidObjectDirty) + te.stateBidObjects[price] = obj return obj } // MarkStateAskObjectDirty adds the specified object to the dirty map to avoid costly // state object cache iteration to find a handful of modified ones. -func (self *tradingExchanges) MarkStateBidObjectDirty(price common.Hash) { - self.stateBidObjectsDirty[price] = struct{}{} - if self.onDirty != nil { - self.onDirty(self.Hash()) - self.onDirty = nil +func (te *tradingExchanges) MarkStateBidObjectDirty(price common.Hash) { + te.stateBidObjectsDirty[price] = struct{}{} + if te.onDirty != nil { + te.onDirty(te.Hash()) + te.onDirty = nil } } // createStateOrderListObject creates a new state object. If there is an existing orderId with // the given address, it is overwritten and returned as the second return value. -func (self *tradingExchanges) createStateBidOrderListObject(db Database, price common.Hash) (newobj *stateOrderList) { - newobj = newStateOrderList(self.db, Bid, self.orderBookHash, price, orderList{Volume: Zero}, self.MarkStateBidObjectDirty) - self.stateBidObjects[price] = newobj - self.stateBidObjectsDirty[price] = struct{}{} +func (te *tradingExchanges) createStateBidOrderListObject(db Database, price common.Hash) (newobj *stateOrderList) { + newobj = newStateOrderList(te.db, Bid, te.orderBookHash, price, orderList{Volume: Zero}, te.MarkStateBidObjectDirty) + te.stateBidObjects[price] = newobj + te.stateBidObjectsDirty[price] = struct{}{} data, err := rlp.EncodeToBytes(newobj) if err != nil { panic(fmt.Errorf("can't encode order list object at %x: %v", price[:], err)) } - self.setError(self.bidsTrie.TryUpdate(price[:], data)) - if self.onDirty != nil { - self.onDirty(self.Hash()) - self.onDirty = nil + te.setError(te.bidsTrie.TryUpdate(price[:], data)) + if te.onDirty != nil { + te.onDirty(te.Hash()) + te.onDirty = nil } return newobj } // Retrieve a state object given my the address. Returns nil if not found. -func (self *tradingExchanges) getStateOrderObject(db Database, orderId common.Hash) (stateOrderItem *stateOrderItem) { +func (te *tradingExchanges) getStateOrderObject(db Database, orderId common.Hash) (stateOrderItem *stateOrderItem) { // Prefer 'live' objects. - if obj := self.stateOrderObjects[orderId]; obj != nil { + if obj := te.stateOrderObjects[orderId]; obj != nil { return obj } // Load the object from the database. - enc, err := self.getOrdersTrie(db).TryGet(orderId[:]) + enc, err := te.getOrdersTrie(db).TryGet(orderId[:]) if len(enc) == 0 { - self.setError(err) + te.setError(err) return nil } var data OrderItem @@ -539,48 +539,48 @@ func (self *tradingExchanges) getStateOrderObject(db Database, orderId common.Ha return nil } // Insert into the live set. - obj := newStateOrderItem(self.orderBookHash, orderId, data, self.MarkStateOrderObjectDirty) - self.stateOrderObjects[orderId] = obj + obj := newStateOrderItem(te.orderBookHash, orderId, data, te.MarkStateOrderObjectDirty) + te.stateOrderObjects[orderId] = obj return obj } // MarkStateAskObjectDirty adds the specified object to the dirty map to avoid costly // state object cache iteration to find a handful of modified ones. -func (self *tradingExchanges) MarkStateOrderObjectDirty(orderId common.Hash) { - self.stateOrderObjectsDirty[orderId] = struct{}{} - if self.onDirty != nil { - self.onDirty(self.Hash()) - self.onDirty = nil +func (te *tradingExchanges) MarkStateOrderObjectDirty(orderId common.Hash) { + te.stateOrderObjectsDirty[orderId] = struct{}{} + if te.onDirty != nil { + te.onDirty(te.Hash()) + te.onDirty = nil } } // createStateOrderListObject creates a new state object. If there is an existing orderId with // the given address, it is overwritten and returned as the second return value. -func (self *tradingExchanges) createStateOrderObject(db Database, orderId common.Hash, order OrderItem) (newobj *stateOrderItem) { - newobj = newStateOrderItem(self.orderBookHash, orderId, order, self.MarkStateOrderObjectDirty) +func (t *tradingExchanges) createStateOrderObject(db Database, orderId common.Hash, order OrderItem) (newobj *stateOrderItem) { + newobj = newStateOrderItem(t.orderBookHash, orderId, order, t.MarkStateOrderObjectDirty) orderIdHash := common.BigToHash(new(big.Int).SetUint64(order.OrderID)) - self.stateOrderObjects[orderIdHash] = newobj - self.stateOrderObjectsDirty[orderIdHash] = struct{}{} - if self.onDirty != nil { - self.onDirty(self.orderBookHash) - self.onDirty = nil + t.stateOrderObjects[orderIdHash] = newobj + t.stateOrderObjectsDirty[orderIdHash] = struct{}{} + if t.onDirty != nil { + t.onDirty(t.orderBookHash) + t.onDirty = nil } return newobj } // updateAskTrie writes cached storage modifications into the object's storage trie. -func (self *tradingExchanges) updateOrdersTrie(db Database) Trie { - tr := self.getOrdersTrie(db) - for orderId, orderItem := range self.stateOrderObjects { - if _, isDirty := self.stateOrderObjectsDirty[orderId]; isDirty { - delete(self.stateOrderObjectsDirty, orderId) +func (t *tradingExchanges) updateOrdersTrie(db Database) Trie { + tr := t.getOrdersTrie(db) + for orderId, orderItem := range t.stateOrderObjects { + if _, isDirty := t.stateOrderObjectsDirty[orderId]; isDirty { + delete(t.stateOrderObjectsDirty, orderId) if orderItem.empty() { - self.setError(tr.TryDelete(orderId[:])) + t.setError(tr.TryDelete(orderId[:])) continue } // Encoding []byte cannot fail, ok to ignore the error. v, _ := rlp.EncodeToBytes(orderItem) - self.setError(tr.TryUpdate(orderId[:], v)) + t.setError(tr.TryUpdate(orderId[:], v)) } } return tr @@ -588,71 +588,71 @@ func (self *tradingExchanges) updateOrdersTrie(db Database) Trie { // CommitAskTrie the storage trie of the object to dwb. // This updates the trie root. -func (self *tradingExchanges) updateOrdersRoot(db Database) { - self.updateOrdersTrie(db) - self.data.OrderRoot = self.ordersTrie.Hash() +func (t *tradingExchanges) updateOrdersRoot(db Database) { + t.updateOrdersTrie(db) + t.data.OrderRoot = t.ordersTrie.Hash() } // CommitAskTrie the storage trie of the object to dwb. // This updates the trie root. -func (self *tradingExchanges) CommitOrdersTrie(db Database) error { - self.updateOrdersTrie(db) - if self.dbErr != nil { - return self.dbErr +func (t *tradingExchanges) CommitOrdersTrie(db Database) error { + t.updateOrdersTrie(db) + if t.dbErr != nil { + return t.dbErr } - root, err := self.ordersTrie.Commit(nil) + root, err := t.ordersTrie.Commit(nil) if err == nil { - self.data.OrderRoot = root + t.data.OrderRoot = root } return err } -func (self *tradingExchanges) MarkStateLiquidationPriceDirty(price common.Hash) { - self.liquidationPriceStatesDirty[price] = struct{}{} - if self.onDirty != nil { - self.onDirty(self.Hash()) - self.onDirty = nil +func (t *tradingExchanges) MarkStateLiquidationPriceDirty(price common.Hash) { + t.liquidationPriceStatesDirty[price] = struct{}{} + if t.onDirty != nil { + t.onDirty(t.Hash()) + t.onDirty = nil } } -func (self *tradingExchanges) createStateLiquidationPrice(db Database, liquidationPrice common.Hash) (newobj *liquidationPriceState) { - newobj = newLiquidationPriceState(self.db, self.orderBookHash, liquidationPrice, orderList{Volume: Zero}, self.MarkStateLiquidationPriceDirty) - self.liquidationPriceStates[liquidationPrice] = newobj - self.liquidationPriceStatesDirty[liquidationPrice] = struct{}{} +func (t *tradingExchanges) createStateLiquidationPrice(db Database, liquidationPrice common.Hash) (newobj *liquidationPriceState) { + newobj = newLiquidationPriceState(t.db, t.orderBookHash, liquidationPrice, orderList{Volume: Zero}, t.MarkStateLiquidationPriceDirty) + t.liquidationPriceStates[liquidationPrice] = newobj + t.liquidationPriceStatesDirty[liquidationPrice] = struct{}{} data, err := rlp.EncodeToBytes(newobj) if err != nil { panic(fmt.Errorf("can't encode liquidation price object at %x: %v", liquidationPrice[:], err)) } - self.setError(self.getLiquidationPriceTrie(db).TryUpdate(liquidationPrice[:], data)) - if self.onDirty != nil { - self.onDirty(self.Hash()) - self.onDirty = nil + t.setError(t.getLiquidationPriceTrie(db).TryUpdate(liquidationPrice[:], data)) + if t.onDirty != nil { + t.onDirty(t.Hash()) + t.onDirty = nil } return newobj } -func (self *tradingExchanges) getLiquidationPriceTrie(db Database) Trie { - if self.liquidationPriceTrie == nil { +func (t *tradingExchanges) getLiquidationPriceTrie(db Database) Trie { + if t.liquidationPriceTrie == nil { var err error - self.liquidationPriceTrie, err = db.OpenStorageTrie(self.orderBookHash, self.data.LiquidationPriceRoot) + t.liquidationPriceTrie, err = db.OpenStorageTrie(t.orderBookHash, t.data.LiquidationPriceRoot) if err != nil { - self.liquidationPriceTrie, _ = db.OpenStorageTrie(self.orderBookHash, EmptyHash) - self.setError(fmt.Errorf("can't create liquidation liquidationPrice trie: %v", err)) + t.liquidationPriceTrie, _ = db.OpenStorageTrie(t.orderBookHash, EmptyHash) + t.setError(fmt.Errorf("can't create liquidation liquidationPrice trie: %v", err)) } } - return self.liquidationPriceTrie + return t.liquidationPriceTrie } -func (self *tradingExchanges) getStateLiquidationPrice(db Database, price common.Hash) (stateObject *liquidationPriceState) { +func (t *tradingExchanges) getStateLiquidationPrice(db Database, price common.Hash) (stateObject *liquidationPriceState) { // Prefer 'live' objects. - if obj := self.liquidationPriceStates[price]; obj != nil { + if obj := t.liquidationPriceStates[price]; obj != nil { return obj } // Load the object from the database. - enc, err := self.getLiquidationPriceTrie(db).TryGet(price[:]) + enc, err := t.getLiquidationPriceTrie(db).TryGet(price[:]) if len(enc) == 0 { - self.setError(err) + t.setError(err) return nil } var data orderList @@ -661,16 +661,16 @@ func (self *tradingExchanges) getStateLiquidationPrice(db Database, price common return nil } // Insert into the live set. - obj := newLiquidationPriceState(self.db, self.orderBookHash, price, data, self.MarkStateLiquidationPriceDirty) - self.liquidationPriceStates[price] = obj + obj := newLiquidationPriceState(t.db, t.orderBookHash, price, data, t.MarkStateLiquidationPriceDirty) + t.liquidationPriceStates[price] = obj return obj } -func (self *tradingExchanges) getLowestLiquidationPrice(db Database) (common.Hash, *liquidationPriceState) { - trie := self.getLiquidationPriceTrie(db) +func (t *tradingExchanges) getLowestLiquidationPrice(db Database) (common.Hash, *liquidationPriceState) { + trie := t.getLiquidationPriceTrie(db) encKey, encValue, err := trie.TryGetBestLeftKeyAndValue() if err != nil { - log.Error("Failed find best liquidationPrice ask trie ", "orderbook", self.orderBookHash.Hex()) + log.Error("Failed find best liquidationPrice ask trie ", "orderbook", t.orderBookHash.Hex()) return EmptyHash, nil } if len(encKey) == 0 || len(encValue) == 0 { @@ -678,25 +678,25 @@ func (self *tradingExchanges) getLowestLiquidationPrice(db Database) (common.Has return EmptyHash, nil } price := common.BytesToHash(encKey) - obj := self.liquidationPriceStates[price] + obj := t.liquidationPriceStates[price] if obj == nil { var data orderList if err := rlp.DecodeBytes(encValue, &data); err != nil { log.Error("Failed to decode state get best ask trie", "err", err) return EmptyHash, nil } - obj = newLiquidationPriceState(self.db, self.orderBookHash, price, data, self.MarkStateLiquidationPriceDirty) - self.liquidationPriceStates[price] = obj + obj = newLiquidationPriceState(t.db, t.orderBookHash, price, data, t.MarkStateLiquidationPriceDirty) + t.liquidationPriceStates[price] = obj } return price, obj } -func (self *tradingExchanges) getAllLowerLiquidationPrice(db Database, limit common.Hash) map[common.Hash]*liquidationPriceState { - trie := self.getLiquidationPriceTrie(db) +func (t *tradingExchanges) getAllLowerLiquidationPrice(db Database, limit common.Hash) map[common.Hash]*liquidationPriceState { + trie := t.getLiquidationPriceTrie(db) encKeys, encValues, err := trie.TryGetAllLeftKeyAndValue(limit.Bytes()) result := map[common.Hash]*liquidationPriceState{} if err != nil || len(encKeys) != len(encValues) { - log.Error("Failed get lower liquidation price trie ", "orderbook", self.orderBookHash.Hex(), "encKeys", len(encKeys), "encValues", len(encValues)) + log.Error("Failed get lower liquidation price trie ", "orderbook", t.orderBookHash.Hex(), "encKeys", len(encKeys), "encValues", len(encValues)) return result } if len(encKeys) == 0 || len(encValues) == 0 { @@ -705,15 +705,15 @@ func (self *tradingExchanges) getAllLowerLiquidationPrice(db Database, limit com } for i := range encKeys { price := common.BytesToHash(encKeys[i]) - obj := self.liquidationPriceStates[price] + obj := t.liquidationPriceStates[price] if obj == nil { var data orderList if err := rlp.DecodeBytes(encValues[i], &data); err != nil { log.Error("Failed to decode state get all lower liquidation price trie", "price", price, "encValues", encValues[i], "err", err) return result } - obj = newLiquidationPriceState(self.db, self.orderBookHash, price, data, self.MarkStateLiquidationPriceDirty) - self.liquidationPriceStates[price] = obj + obj = newLiquidationPriceState(t.db, t.orderBookHash, price, data, t.MarkStateLiquidationPriceDirty) + t.liquidationPriceStates[price] = obj } if obj.empty() { continue @@ -723,11 +723,11 @@ func (self *tradingExchanges) getAllLowerLiquidationPrice(db Database, limit com return result } -func (self *tradingExchanges) getHighestLiquidationPrice(db Database) (common.Hash, *liquidationPriceState) { - trie := self.getLiquidationPriceTrie(db) +func (t *tradingExchanges) getHighestLiquidationPrice(db Database) (common.Hash, *liquidationPriceState) { + trie := t.getLiquidationPriceTrie(db) encKey, encValue, err := trie.TryGetBestRightKeyAndValue() if err != nil { - log.Error("Failed find best liquidationPrice ask trie ", "orderbook", self.orderBookHash.Hex()) + log.Error("Failed find best liquidationPrice ask trie ", "orderbook", t.orderBookHash.Hex()) return EmptyHash, nil } if len(encKey) == 0 || len(encValue) == 0 { @@ -735,28 +735,29 @@ func (self *tradingExchanges) getHighestLiquidationPrice(db Database) (common.Ha return EmptyHash, nil } price := common.BytesToHash(encKey) - obj := self.liquidationPriceStates[price] + obj := t.liquidationPriceStates[price] if obj == nil { var data orderList if err := rlp.DecodeBytes(encValue, &data); err != nil { log.Error("Failed to decode state get best ask trie", "err", err) return EmptyHash, nil } - obj = newLiquidationPriceState(self.db, self.orderBookHash, price, data, self.MarkStateLiquidationPriceDirty) - self.liquidationPriceStates[price] = obj + obj = newLiquidationPriceState(t.db, t.orderBookHash, price, data, t.MarkStateLiquidationPriceDirty) + t.liquidationPriceStates[price] = obj } if obj.empty() { return EmptyHash, nil } return price, obj } -func (self *tradingExchanges) updateLiquidationPriceTrie(db Database) Trie { - tr := self.getLiquidationPriceTrie(db) - for price, stateObject := range self.liquidationPriceStates { - if _, isDirty := self.liquidationPriceStatesDirty[price]; isDirty { - delete(self.liquidationPriceStatesDirty, price) + +func (t *tradingExchanges) updateLiquidationPriceTrie(db Database) Trie { + tr := t.getLiquidationPriceTrie(db) + for price, stateObject := range t.liquidationPriceStates { + if _, isDirty := t.liquidationPriceStatesDirty[price]; isDirty { + delete(t.liquidationPriceStatesDirty, price) if stateObject.empty() { - self.setError(tr.TryDelete(price[:])) + t.setError(tr.TryDelete(price[:])) continue } err := stateObject.updateRoot(db) @@ -765,23 +766,23 @@ func (self *tradingExchanges) updateLiquidationPriceTrie(db Database) Trie { } // Encoding []byte cannot fail, ok to ignore the error. v, _ := rlp.EncodeToBytes(stateObject) - self.setError(tr.TryUpdate(price[:], v)) + t.setError(tr.TryUpdate(price[:], v)) } } return tr } -func (self *tradingExchanges) updateLiquidationPriceRoot(db Database) { - self.updateLiquidationPriceTrie(db) - self.data.LiquidationPriceRoot = self.liquidationPriceTrie.Hash() +func (t *tradingExchanges) updateLiquidationPriceRoot(db Database) { + t.updateLiquidationPriceTrie(db) + t.data.LiquidationPriceRoot = t.liquidationPriceTrie.Hash() } -func (self *tradingExchanges) CommitLiquidationPriceTrie(db Database) error { - self.updateLiquidationPriceTrie(db) - if self.dbErr != nil { - return self.dbErr +func (t *tradingExchanges) CommitLiquidationPriceTrie(db Database) error { + t.updateLiquidationPriceTrie(db) + if t.dbErr != nil { + return t.dbErr } - root, err := self.liquidationPriceTrie.Commit(func(leaf []byte, parent common.Hash) error { + root, err := t.liquidationPriceTrie.Commit(func(leaf []byte, parent common.Hash) error { var orderList orderList if err := rlp.DecodeBytes(leaf, &orderList); err != nil { return nil @@ -792,23 +793,23 @@ func (self *tradingExchanges) CommitLiquidationPriceTrie(db Database) error { return nil }) if err == nil { - self.data.LiquidationPriceRoot = root + t.data.LiquidationPriceRoot = root } return err } -func (c *tradingExchanges) addLendingCount(amount *big.Int) { - c.setLendingCount(new(big.Int).Add(c.data.LendingCount, amount)) +func (t *tradingExchanges) addLendingCount(amount *big.Int) { + t.setLendingCount(new(big.Int).Add(t.data.LendingCount, amount)) } -func (c *tradingExchanges) subLendingCount(amount *big.Int) { - c.setLendingCount(new(big.Int).Sub(c.data.LendingCount, amount)) +func (t *tradingExchanges) subLendingCount(amount *big.Int) { + t.setLendingCount(new(big.Int).Sub(t.data.LendingCount, amount)) } -func (self *tradingExchanges) setLendingCount(volume *big.Int) { - self.data.LendingCount = volume - if self.onDirty != nil { - self.onDirty(self.orderBookHash) - self.onDirty = nil +func (t *tradingExchanges) setLendingCount(volume *big.Int) { + t.data.LendingCount = volume + if t.onDirty != nil { + t.onDirty(t.orderBookHash) + t.onDirty = nil } } diff --git a/XDCx/tradingstate/statedb.go b/XDCx/tradingstate/statedb.go index e5e4f4b06f..036b5cac4c 100644 --- a/XDCx/tradingstate/statedb.go +++ b/XDCx/tradingstate/statedb.go @@ -78,55 +78,55 @@ func New(root common.Hash, db Database) (*TradingStateDB, error) { } // setError remembers the first non-nil error it is called with. -func (self *TradingStateDB) setError(err error) { - if self.dbErr == nil { - self.dbErr = err +func (t *TradingStateDB) setError(err error) { + if t.dbErr == nil { + t.dbErr = err } } -func (self *TradingStateDB) Error() error { - return self.dbErr +func (t *TradingStateDB) Error() error { + return t.dbErr } // Exist reports whether the given orderId address exists in the state. // Notably this also returns true for suicided exchanges. -func (self *TradingStateDB) Exist(addr common.Hash) bool { - return self.getStateExchangeObject(addr) != nil +func (t *TradingStateDB) Exist(addr common.Hash) bool { + return t.getStateExchangeObject(addr) != nil } // Empty returns whether the state object is either non-existent // or empty according to the EIP161 specification (balance = nonce = code = 0) -func (self *TradingStateDB) Empty(addr common.Hash) bool { - so := self.getStateExchangeObject(addr) +func (t *TradingStateDB) Empty(addr common.Hash) bool { + so := t.getStateExchangeObject(addr) return so == nil || so.empty() } -func (self *TradingStateDB) GetNonce(addr common.Hash) uint64 { - stateObject := self.getStateExchangeObject(addr) +func (t *TradingStateDB) GetNonce(addr common.Hash) uint64 { + stateObject := t.getStateExchangeObject(addr) if stateObject != nil { return stateObject.Nonce() } return 0 } -func (self *TradingStateDB) GetLastPrice(addr common.Hash) *big.Int { - stateObject := self.getStateExchangeObject(addr) +func (t *TradingStateDB) GetLastPrice(addr common.Hash) *big.Int { + stateObject := t.getStateExchangeObject(addr) if stateObject != nil { return stateObject.data.LastPrice } return nil } -func (self *TradingStateDB) GetMediumPriceBeforeEpoch(addr common.Hash) *big.Int { - stateObject := self.getStateExchangeObject(addr) +func (t *TradingStateDB) GetMediumPriceBeforeEpoch(addr common.Hash) *big.Int { + stateObject := t.getStateExchangeObject(addr) if stateObject != nil { return stateObject.data.MediumPriceBeforeEpoch } return Zero } -func (self *TradingStateDB) GetMediumPriceAndTotalAmount(addr common.Hash) (*big.Int, *big.Int) { - stateObject := self.getStateExchangeObject(addr) +func (t *TradingStateDB) GetMediumPriceAndTotalAmount(addr common.Hash) (*big.Int, *big.Int) { + stateObject := t.getStateExchangeObject(addr) if stateObject != nil { return stateObject.data.MediumPrice, stateObject.data.TotalQuantity } @@ -134,25 +134,25 @@ func (self *TradingStateDB) GetMediumPriceAndTotalAmount(addr common.Hash) (*big } // Database retrieves the low level database supporting the lower level trie ops. -func (self *TradingStateDB) Database() Database { - return self.db +func (t *TradingStateDB) Database() Database { + return t.db } -func (self *TradingStateDB) SetNonce(addr common.Hash, nonce uint64) { - stateObject := self.GetOrNewStateExchangeObject(addr) +func (t *TradingStateDB) SetNonce(addr common.Hash, nonce uint64) { + stateObject := t.GetOrNewStateExchangeObject(addr) if stateObject != nil { - self.journal = append(self.journal, nonceChange{ + t.journal = append(t.journal, nonceChange{ hash: addr, - prev: self.GetNonce(addr), + prev: t.GetNonce(addr), }) stateObject.SetNonce(nonce) } } -func (self *TradingStateDB) SetLastPrice(addr common.Hash, price *big.Int) { - stateObject := self.GetOrNewStateExchangeObject(addr) +func (t *TradingStateDB) SetLastPrice(addr common.Hash, price *big.Int) { + stateObject := t.GetOrNewStateExchangeObject(addr) if stateObject != nil { - self.journal = append(self.journal, lastPriceChange{ + t.journal = append(t.journal, lastPriceChange{ hash: addr, prev: stateObject.data.LastPrice, }) @@ -160,10 +160,10 @@ func (self *TradingStateDB) SetLastPrice(addr common.Hash, price *big.Int) { } } -func (self *TradingStateDB) SetMediumPrice(addr common.Hash, price *big.Int, quantity *big.Int) { - stateObject := self.GetOrNewStateExchangeObject(addr) +func (t *TradingStateDB) SetMediumPrice(addr common.Hash, price *big.Int, quantity *big.Int) { + stateObject := t.GetOrNewStateExchangeObject(addr) if stateObject != nil { - self.journal = append(self.journal, mediumPriceChange{ + t.journal = append(t.journal, mediumPriceChange{ hash: addr, prevPrice: stateObject.data.MediumPrice, prevQuantity: stateObject.data.TotalQuantity, @@ -172,10 +172,10 @@ func (self *TradingStateDB) SetMediumPrice(addr common.Hash, price *big.Int, qua } } -func (self *TradingStateDB) SetMediumPriceBeforeEpoch(addr common.Hash, price *big.Int) { - stateObject := self.GetOrNewStateExchangeObject(addr) +func (t *TradingStateDB) SetMediumPriceBeforeEpoch(addr common.Hash, price *big.Int) { + stateObject := t.GetOrNewStateExchangeObject(addr) if stateObject != nil { - self.journal = append(self.journal, mediumPriceBeforeEpochChange{ + t.journal = append(t.journal, mediumPriceBeforeEpochChange{ hash: addr, prevPrice: stateObject.data.MediumPriceBeforeEpoch, }) @@ -183,78 +183,79 @@ func (self *TradingStateDB) SetMediumPriceBeforeEpoch(addr common.Hash, price *b } } -func (self *TradingStateDB) InsertOrderItem(orderBook common.Hash, orderId common.Hash, order OrderItem) { +func (t *TradingStateDB) InsertOrderItem(orderBook common.Hash, orderId common.Hash, order OrderItem) { priceHash := common.BigToHash(order.Price) - stateExchange := self.getStateExchangeObject(orderBook) + stateExchange := t.getStateExchangeObject(orderBook) if stateExchange == nil { - stateExchange = self.createExchangeObject(orderBook) + stateExchange = t.createExchangeObject(orderBook) } var stateOrderList *stateOrderList switch order.Side { case Ask: - stateOrderList = stateExchange.getStateOrderListAskObject(self.db, priceHash) + stateOrderList = stateExchange.getStateOrderListAskObject(t.db, priceHash) if stateOrderList == nil { - stateOrderList = stateExchange.createStateOrderListAskObject(self.db, priceHash) + stateOrderList = stateExchange.createStateOrderListAskObject(t.db, priceHash) } case Bid: - stateOrderList = stateExchange.getStateBidOrderListObject(self.db, priceHash) + stateOrderList = stateExchange.getStateBidOrderListObject(t.db, priceHash) if stateOrderList == nil { - stateOrderList = stateExchange.createStateBidOrderListObject(self.db, priceHash) + stateOrderList = stateExchange.createStateBidOrderListObject(t.db, priceHash) } default: return } - self.journal = append(self.journal, insertOrder{ + t.journal = append(t.journal, insertOrder{ orderBook: orderBook, orderId: orderId, order: &order, }) - stateExchange.createStateOrderObject(self.db, orderId, order) - stateOrderList.insertOrderItem(self.db, orderId, common.BigToHash(order.Quantity)) + stateExchange.createStateOrderObject(t.db, orderId, order) + stateOrderList.insertOrderItem(t.db, orderId, common.BigToHash(order.Quantity)) stateOrderList.AddVolume(order.Quantity) } -func (self *TradingStateDB) GetOrder(orderBook common.Hash, orderId common.Hash) OrderItem { - stateObject := self.GetOrNewStateExchangeObject(orderBook) +func (t *TradingStateDB) GetOrder(orderBook common.Hash, orderId common.Hash) OrderItem { + stateObject := t.GetOrNewStateExchangeObject(orderBook) if stateObject == nil { return EmptyOrder } - stateOrderItem := stateObject.getStateOrderObject(self.db, orderId) + stateOrderItem := stateObject.getStateOrderObject(t.db, orderId) if stateOrderItem == nil { return EmptyOrder } return stateOrderItem.data } -func (self *TradingStateDB) SubAmountOrderItem(orderBook common.Hash, orderId common.Hash, price *big.Int, amount *big.Int, side string) error { + +func (t *TradingStateDB) SubAmountOrderItem(orderBook common.Hash, orderId common.Hash, price *big.Int, amount *big.Int, side string) error { priceHash := common.BigToHash(price) - stateObject := self.GetOrNewStateExchangeObject(orderBook) + stateObject := t.GetOrNewStateExchangeObject(orderBook) if stateObject == nil { return fmt.Errorf("not found orderBook: %s", orderBook.Hex()) } var stateOrderList *stateOrderList switch side { case Ask: - stateOrderList = stateObject.getStateOrderListAskObject(self.db, priceHash) + stateOrderList = stateObject.getStateOrderListAskObject(t.db, priceHash) case Bid: - stateOrderList = stateObject.getStateBidOrderListObject(self.db, priceHash) + stateOrderList = stateObject.getStateBidOrderListObject(t.db, priceHash) default: return fmt.Errorf("not found order type: %s", side) } if stateOrderList == nil || stateOrderList.empty() { return fmt.Errorf("empty Orderlist: order book: %s , order id : %s , price : %s", orderBook, orderId.Hex(), priceHash.Hex()) } - stateOrderItem := stateObject.getStateOrderObject(self.db, orderId) + stateOrderItem := stateObject.getStateOrderObject(t.db, orderId) if stateOrderItem == nil || stateOrderItem.empty() { return fmt.Errorf("empty OrderItem: order book: %s , order id : %s , price : %s", orderBook, orderId.Hex(), priceHash.Hex()) } - currentAmount := new(big.Int).SetBytes(stateOrderList.GetOrderAmount(self.db, orderId).Bytes()[:]) + currentAmount := new(big.Int).SetBytes(stateOrderList.GetOrderAmount(t.db, orderId).Bytes()[:]) if currentAmount.Cmp(amount) < 0 { return fmt.Errorf("not enough order amount: %s , have : %d , want : %d ", orderId.Hex(), currentAmount, amount) } - self.journal = append(self.journal, subAmountOrder{ + t.journal = append(t.journal, subAmountOrder{ orderBook: orderBook, orderId: orderId, - order: self.GetOrder(orderBook, orderId), + order: t.GetOrder(orderBook, orderId), amount: amount, }) newAmount := new(big.Int).Sub(currentAmount, amount) @@ -262,29 +263,29 @@ func (self *TradingStateDB) SubAmountOrderItem(orderBook common.Hash, orderId co stateOrderList.subVolume(amount) stateOrderItem.setVolume(newAmount) if newAmount.Sign() == 0 { - stateOrderList.removeOrderItem(self.db, orderId) + stateOrderList.removeOrderItem(t.db, orderId) } else { stateOrderList.setOrderItem(orderId, common.BigToHash(newAmount)) } if stateOrderList.empty() { switch side { case Ask: - stateObject.removeStateOrderListAskObject(self.db, stateOrderList) + stateObject.removeStateOrderListAskObject(t.db, stateOrderList) case Bid: - stateObject.removeStateOrderListBidObject(self.db, stateOrderList) + stateObject.removeStateOrderListBidObject(t.db, stateOrderList) default: } } return nil } -func (self *TradingStateDB) CancelOrder(orderBook common.Hash, order *OrderItem) error { +func (t *TradingStateDB) CancelOrder(orderBook common.Hash, order *OrderItem) error { orderIdHash := common.BigToHash(new(big.Int).SetUint64(order.OrderID)) - stateObject := self.GetOrNewStateExchangeObject(orderBook) + stateObject := t.GetOrNewStateExchangeObject(orderBook) if stateObject == nil { return fmt.Errorf("not found orderBook: %s", orderBook.Hex()) } - stateOrderItem := stateObject.getStateOrderObject(self.db, orderIdHash) + stateOrderItem := stateObject.getStateOrderObject(t.db, orderIdHash) if stateOrderItem == nil || stateOrderItem.empty() { return fmt.Errorf("empty OrderItem: order book: %s , order id : %s", orderBook, orderIdHash.Hex()) } @@ -292,9 +293,9 @@ func (self *TradingStateDB) CancelOrder(orderBook common.Hash, order *OrderItem) var stateOrderList *stateOrderList switch stateOrderItem.data.Side { case Ask: - stateOrderList = stateObject.getStateOrderListAskObject(self.db, priceHash) + stateOrderList = stateObject.getStateOrderListAskObject(t.db, priceHash) case Bid: - stateOrderList = stateObject.getStateBidOrderListObject(self.db, priceHash) + stateOrderList = stateObject.getStateBidOrderListObject(t.db, priceHash) default: return fmt.Errorf("not found order.Side: %s", order.Side) } @@ -311,37 +312,37 @@ func (self *TradingStateDB) CancelOrder(orderBook common.Hash, order *OrderItem) if stateOrderItem.data.ExchangeAddress != order.ExchangeAddress { return fmt.Errorf("mismatch ExchangeAddress when cancel: order book : %s , order id : %s , got : %s , expect : %s", orderBook, orderIdHash.Hex(), order.ExchangeAddress.Hex(), stateOrderItem.data.ExchangeAddress.Hex()) } - self.journal = append(self.journal, cancelOrder{ + t.journal = append(t.journal, cancelOrder{ orderBook: orderBook, orderId: orderIdHash, order: stateOrderItem.data, }) - currentAmount := new(big.Int).SetBytes(stateOrderList.GetOrderAmount(self.db, orderIdHash).Bytes()[:]) + currentAmount := new(big.Int).SetBytes(stateOrderList.GetOrderAmount(t.db, orderIdHash).Bytes()[:]) stateOrderItem.setVolume(big.NewInt(0)) stateOrderList.subVolume(currentAmount) - stateOrderList.removeOrderItem(self.db, orderIdHash) + stateOrderList.removeOrderItem(t.db, orderIdHash) if stateOrderList.empty() { switch stateOrderItem.data.Side { case Ask: - stateObject.removeStateOrderListAskObject(self.db, stateOrderList) + stateObject.removeStateOrderListAskObject(t.db, stateOrderList) case Bid: - stateObject.removeStateOrderListBidObject(self.db, stateOrderList) + stateObject.removeStateOrderListBidObject(t.db, stateOrderList) default: } } return nil } -func (self *TradingStateDB) GetVolume(orderBook common.Hash, price *big.Int, orderType string) *big.Int { - stateObject := self.GetOrNewStateExchangeObject(orderBook) +func (t *TradingStateDB) GetVolume(orderBook common.Hash, price *big.Int, orderType string) *big.Int { + stateObject := t.GetOrNewStateExchangeObject(orderBook) var volume *big.Int = nil if stateObject != nil { var stateOrderList *stateOrderList switch orderType { case Ask: - stateOrderList = stateObject.getStateOrderListAskObject(self.db, common.BigToHash(price)) + stateOrderList = stateObject.getStateOrderListAskObject(t.db, common.BigToHash(price)) case Bid: - stateOrderList = stateObject.getStateBidOrderListObject(self.db, common.BigToHash(price)) + stateOrderList = stateObject.getStateBidOrderListObject(t.db, common.BigToHash(price)) default: return Zero } @@ -352,14 +353,15 @@ func (self *TradingStateDB) GetVolume(orderBook common.Hash, price *big.Int, ord } return volume } -func (self *TradingStateDB) GetBestAskPrice(orderBook common.Hash) (*big.Int, *big.Int) { - stateObject := self.getStateExchangeObject(orderBook) + +func (t *TradingStateDB) GetBestAskPrice(orderBook common.Hash) (*big.Int, *big.Int) { + stateObject := t.getStateExchangeObject(orderBook) if stateObject != nil { - priceHash := stateObject.getBestPriceAsksTrie(self.db) + priceHash := stateObject.getBestPriceAsksTrie(t.db) if common.EmptyHash(priceHash) { return Zero, Zero } - orderList := stateObject.getStateOrderListAskObject(self.db, priceHash) + orderList := stateObject.getStateOrderListAskObject(t.db, priceHash) if orderList == nil { log.Error("order list ask not found", "price", priceHash.Hex()) return Zero, Zero @@ -369,14 +371,14 @@ func (self *TradingStateDB) GetBestAskPrice(orderBook common.Hash) (*big.Int, *b return Zero, Zero } -func (self *TradingStateDB) GetBestBidPrice(orderBook common.Hash) (*big.Int, *big.Int) { - stateObject := self.getStateExchangeObject(orderBook) +func (t *TradingStateDB) GetBestBidPrice(orderBook common.Hash) (*big.Int, *big.Int) { + stateObject := t.getStateExchangeObject(orderBook) if stateObject != nil { - priceHash := stateObject.getBestBidsTrie(self.db) + priceHash := stateObject.getBestBidsTrie(t.db) if common.EmptyHash(priceHash) { return Zero, Zero } - orderList := stateObject.getStateBidOrderListObject(self.db, priceHash) + orderList := stateObject.getStateBidOrderListObject(t.db, priceHash) if orderList == nil { log.Error("order list bid not found", "price", priceHash.Hex()) return Zero, Zero @@ -386,25 +388,25 @@ func (self *TradingStateDB) GetBestBidPrice(orderBook common.Hash) (*big.Int, *b return Zero, Zero } -func (self *TradingStateDB) GetBestOrderIdAndAmount(orderBook common.Hash, price *big.Int, side string) (common.Hash, *big.Int, error) { - stateObject := self.GetOrNewStateExchangeObject(orderBook) +func (t *TradingStateDB) GetBestOrderIdAndAmount(orderBook common.Hash, price *big.Int, side string) (common.Hash, *big.Int, error) { + stateObject := t.GetOrNewStateExchangeObject(orderBook) if stateObject != nil { var stateOrderList *stateOrderList switch side { case Ask: - stateOrderList = stateObject.getStateOrderListAskObject(self.db, common.BigToHash(price)) + stateOrderList = stateObject.getStateOrderListAskObject(t.db, common.BigToHash(price)) case Bid: - stateOrderList = stateObject.getStateBidOrderListObject(self.db, common.BigToHash(price)) + stateOrderList = stateObject.getStateBidOrderListObject(t.db, common.BigToHash(price)) default: return EmptyHash, Zero, fmt.Errorf("not found side: %s", side) } if stateOrderList != nil { - key, _, err := stateOrderList.getTrie(self.db).TryGetBestLeftKeyAndValue() + key, _, err := stateOrderList.getTrie(t.db).TryGetBestLeftKeyAndValue() if err != nil { return EmptyHash, Zero, err } orderId := common.BytesToHash(key) - amount := stateOrderList.GetOrderAmount(self.db, orderId) + amount := stateOrderList.GetOrderAmount(t.db, orderId) return orderId, new(big.Int).SetBytes(amount.Bytes()), nil } return EmptyHash, Zero, fmt.Errorf("not found order list with orderBook: %s , price : %d , side : %s", orderBook.Hex(), price, side) @@ -413,25 +415,25 @@ func (self *TradingStateDB) GetBestOrderIdAndAmount(orderBook common.Hash, price } // updateStateExchangeObject writes the given object to the trie. -func (self *TradingStateDB) updateStateExchangeObject(stateObject *tradingExchanges) { +func (t *TradingStateDB) updateStateExchangeObject(stateObject *tradingExchanges) { addr := stateObject.Hash() data, err := rlp.EncodeToBytes(stateObject) if err != nil { panic(fmt.Errorf("can't encode object at %x: %v", addr[:], err)) } - self.setError(self.trie.TryUpdate(addr[:], data)) + t.setError(t.trie.TryUpdate(addr[:], data)) } // Retrieve a state object given my the address. Returns nil if not found. -func (self *TradingStateDB) getStateExchangeObject(addr common.Hash) (stateObject *tradingExchanges) { +func (t *TradingStateDB) getStateExchangeObject(addr common.Hash) (stateObject *tradingExchanges) { // Prefer 'live' objects. - if obj := self.stateExhangeObjects[addr]; obj != nil { + if obj := t.stateExhangeObjects[addr]; obj != nil { return obj } // Load the object from the database. - enc, err := self.trie.TryGet(addr[:]) + enc, err := t.trie.TryGet(addr[:]) if len(enc) == 0 { - self.setError(err) + t.setError(err) return nil } var data tradingExchangeObject @@ -440,169 +442,169 @@ func (self *TradingStateDB) getStateExchangeObject(addr common.Hash) (stateObjec return nil } // Insert into the live set. - obj := newStateExchanges(self, addr, data, self.MarkStateExchangeObjectDirty) - self.stateExhangeObjects[addr] = obj + obj := newStateExchanges(t, addr, data, t.MarkStateExchangeObjectDirty) + t.stateExhangeObjects[addr] = obj return obj } -func (self *TradingStateDB) setStateExchangeObject(object *tradingExchanges) { - self.stateExhangeObjects[object.Hash()] = object - self.stateExhangeObjectsDirty[object.Hash()] = struct{}{} +func (t *TradingStateDB) setStateExchangeObject(object *tradingExchanges) { + t.stateExhangeObjects[object.Hash()] = object + t.stateExhangeObjectsDirty[object.Hash()] = struct{}{} } // Retrieve a state object or create a new state object if nil. -func (self *TradingStateDB) GetOrNewStateExchangeObject(addr common.Hash) *tradingExchanges { - stateExchangeObject := self.getStateExchangeObject(addr) +func (t *TradingStateDB) GetOrNewStateExchangeObject(addr common.Hash) *tradingExchanges { + stateExchangeObject := t.getStateExchangeObject(addr) if stateExchangeObject == nil { - stateExchangeObject = self.createExchangeObject(addr) + stateExchangeObject = t.createExchangeObject(addr) } return stateExchangeObject } // MarkStateAskObjectDirty adds the specified object to the dirty map to avoid costly // state object cache iteration to find a handful of modified ones. -func (self *TradingStateDB) MarkStateExchangeObjectDirty(addr common.Hash) { - self.stateExhangeObjectsDirty[addr] = struct{}{} +func (t *TradingStateDB) MarkStateExchangeObjectDirty(addr common.Hash) { + t.stateExhangeObjectsDirty[addr] = struct{}{} } // createStateOrderListObject creates a new state object. If there is an existing orderId with // the given address, it is overwritten and returned as the second return value. -func (self *TradingStateDB) createExchangeObject(hash common.Hash) (newobj *tradingExchanges) { - newobj = newStateExchanges(self, hash, tradingExchangeObject{LendingCount: Zero, MediumPrice: Zero, MediumPriceBeforeEpoch: Zero, TotalQuantity: Zero}, self.MarkStateExchangeObjectDirty) +func (t *TradingStateDB) createExchangeObject(hash common.Hash) (newobj *tradingExchanges) { + newobj = newStateExchanges(t, hash, tradingExchangeObject{LendingCount: Zero, MediumPrice: Zero, MediumPriceBeforeEpoch: Zero, TotalQuantity: Zero}, t.MarkStateExchangeObjectDirty) newobj.setNonce(0) // sets the object to dirty - self.setStateExchangeObject(newobj) + t.setStateExchangeObject(newobj) return newobj } // Copy creates a deep, independent copy of the state. // Snapshots of the copied state cannot be applied to the copy. -func (self *TradingStateDB) Copy() *TradingStateDB { - self.lock.Lock() - defer self.lock.Unlock() +func (t *TradingStateDB) Copy() *TradingStateDB { + t.lock.Lock() + defer t.lock.Unlock() // Copy all the basic fields, initialize the memory ones state := &TradingStateDB{ - db: self.db, - trie: self.db.CopyTrie(self.trie), - stateExhangeObjects: make(map[common.Hash]*tradingExchanges, len(self.stateExhangeObjectsDirty)), - stateExhangeObjectsDirty: make(map[common.Hash]struct{}, len(self.stateExhangeObjectsDirty)), + db: t.db, + trie: t.db.CopyTrie(t.trie), + stateExhangeObjects: make(map[common.Hash]*tradingExchanges, len(t.stateExhangeObjectsDirty)), + stateExhangeObjectsDirty: make(map[common.Hash]struct{}, len(t.stateExhangeObjectsDirty)), } // Copy the dirty states, logs, and preimages - for addr := range self.stateExhangeObjectsDirty { + for addr := range t.stateExhangeObjectsDirty { state.stateExhangeObjectsDirty[addr] = struct{}{} } - for addr, exchangeObject := range self.stateExhangeObjects { + for addr, exchangeObject := range t.stateExhangeObjects { state.stateExhangeObjects[addr] = exchangeObject.deepCopy(state, state.MarkStateExchangeObjectDirty) } return state } -func (s *TradingStateDB) clearJournalAndRefund() { - s.journal = nil - s.validRevisions = s.validRevisions[:0] +func (t *TradingStateDB) clearJournalAndRefund() { + t.journal = nil + t.validRevisions = t.validRevisions[:0] } // Snapshot returns an identifier for the current revision of the state. -func (self *TradingStateDB) Snapshot() int { - id := self.nextRevisionId - self.nextRevisionId++ - self.validRevisions = append(self.validRevisions, revision{id, len(self.journal)}) +func (t *TradingStateDB) Snapshot() int { + id := t.nextRevisionId + t.nextRevisionId++ + t.validRevisions = append(t.validRevisions, revision{id, len(t.journal)}) return id } // RevertToSnapshot reverts all state changes made since the given revision. -func (self *TradingStateDB) RevertToSnapshot(revid int) { +func (t *TradingStateDB) RevertToSnapshot(revid int) { // Find the snapshot in the stack of valid snapshots. - idx := sort.Search(len(self.validRevisions), func(i int) bool { - return self.validRevisions[i].id >= revid + idx := sort.Search(len(t.validRevisions), func(i int) bool { + return t.validRevisions[i].id >= revid }) - if idx == len(self.validRevisions) || self.validRevisions[idx].id != revid { + if idx == len(t.validRevisions) || t.validRevisions[idx].id != revid { panic(fmt.Errorf("revision id %v cannot be reverted", revid)) } - snapshot := self.validRevisions[idx].journalIndex + snapshot := t.validRevisions[idx].journalIndex // Replay the journal to undo changes. - for i := len(self.journal) - 1; i >= snapshot; i-- { - self.journal[i].undo(self) + for i := len(t.journal) - 1; i >= snapshot; i-- { + t.journal[i].undo(t) } - self.journal = self.journal[:snapshot] + t.journal = t.journal[:snapshot] // Remove invalidated snapshots from the stack. - self.validRevisions = self.validRevisions[:idx] + t.validRevisions = t.validRevisions[:idx] } // Finalise finalises the state by removing the self destructed objects // and clears the journal as well as the refunds. -func (s *TradingStateDB) Finalise() { +func (t *TradingStateDB) Finalise() { // Commit objects to the trie. - for addr, stateObject := range s.stateExhangeObjects { - if _, isDirty := s.stateExhangeObjectsDirty[addr]; isDirty { + for addr, stateObject := range t.stateExhangeObjects { + if _, isDirty := t.stateExhangeObjectsDirty[addr]; isDirty { // Write any storage changes in the state object to its storage trie. - err := stateObject.updateAsksRoot(s.db) + err := stateObject.updateAsksRoot(t.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) + stateObject.updateBidsRoot(t.db) + stateObject.updateOrdersRoot(t.db) + stateObject.updateLiquidationPriceRoot(t.db) // Update the object in the main orderId trie. - s.updateStateExchangeObject(stateObject) + t.updateStateExchangeObject(stateObject) //delete(s.stateExhangeObjectsDirty, addr) } } - s.clearJournalAndRefund() + t.clearJournalAndRefund() } // IntermediateRoot computes the current root orderBookHash of the state trie. // It is called in between transactions to get the root orderBookHash that // goes into transaction receipts. -func (s *TradingStateDB) IntermediateRoot() common.Hash { - s.Finalise() - return s.trie.Hash() +func (t *TradingStateDB) IntermediateRoot() common.Hash { + t.Finalise() + return t.trie.Hash() } // Commit writes the state to the underlying in-memory trie database. -func (s *TradingStateDB) Commit() (root common.Hash, err error) { - defer s.clearJournalAndRefund() +func (t *TradingStateDB) Commit() (root common.Hash, err error) { + defer t.clearJournalAndRefund() // Commit objects to the trie. - for addr, stateObject := range s.stateExhangeObjects { - if _, isDirty := s.stateExhangeObjectsDirty[addr]; isDirty { + for addr, stateObject := range t.stateExhangeObjects { + if _, isDirty := t.stateExhangeObjectsDirty[addr]; isDirty { // Write any storage changes in the state object to its storage trie. - if err := stateObject.CommitAsksTrie(s.db); err != nil { + if err := stateObject.CommitAsksTrie(t.db); err != nil { return EmptyHash, err } - if err := stateObject.CommitBidsTrie(s.db); err != nil { + if err := stateObject.CommitBidsTrie(t.db); err != nil { return EmptyHash, err } - if err := stateObject.CommitOrdersTrie(s.db); err != nil { + if err := stateObject.CommitOrdersTrie(t.db); err != nil { return EmptyHash, err } - if err := stateObject.CommitLiquidationPriceTrie(s.db); err != nil { + if err := stateObject.CommitLiquidationPriceTrie(t.db); err != nil { return EmptyHash, err } // Update the object in the main orderId trie. - s.updateStateExchangeObject(stateObject) - delete(s.stateExhangeObjectsDirty, addr) + t.updateStateExchangeObject(stateObject) + delete(t.stateExhangeObjectsDirty, addr) } } // Write trie changes. - root, err = s.trie.Commit(func(leaf []byte, parent common.Hash) error { + root, err = t.trie.Commit(func(leaf []byte, parent common.Hash) error { var exchange tradingExchangeObject if err := rlp.DecodeBytes(leaf, &exchange); err != nil { return nil } if exchange.AskRoot != EmptyRoot { - s.db.TrieDB().Reference(exchange.AskRoot, parent) + t.db.TrieDB().Reference(exchange.AskRoot, parent) } if exchange.BidRoot != EmptyRoot { - s.db.TrieDB().Reference(exchange.BidRoot, parent) + t.db.TrieDB().Reference(exchange.BidRoot, parent) } if exchange.OrderRoot != EmptyRoot { - s.db.TrieDB().Reference(exchange.OrderRoot, parent) + t.db.TrieDB().Reference(exchange.OrderRoot, parent) } if exchange.LiquidationPriceRoot != EmptyRoot { - s.db.TrieDB().Reference(exchange.LiquidationPriceRoot, parent) + t.db.TrieDB().Reference(exchange.LiquidationPriceRoot, parent) } return nil }) @@ -610,19 +612,19 @@ func (s *TradingStateDB) Commit() (root common.Hash, err error) { return root, err } -func (self *TradingStateDB) GetAllLowerLiquidationPriceData(orderBook common.Hash, limit *big.Int) map[*big.Int]map[common.Hash][]common.Hash { +func (t *TradingStateDB) GetAllLowerLiquidationPriceData(orderBook common.Hash, limit *big.Int) map[*big.Int]map[common.Hash][]common.Hash { result := map[*big.Int]map[common.Hash][]common.Hash{} - orderbookState := self.getStateExchangeObject(orderBook) + orderbookState := t.getStateExchangeObject(orderBook) if orderbookState == nil { return result } - mapPrices := orderbookState.getAllLowerLiquidationPrice(self.db, common.BigToHash(limit)) + mapPrices := orderbookState.getAllLowerLiquidationPrice(t.db, common.BigToHash(limit)) for priceHash, liquidationState := range mapPrices { price := new(big.Int).SetBytes(priceHash[:]) log.Debug("GetAllLowerLiquidationPriceData", "price", price, "limit", limit) if liquidationState != nil && price.Sign() > 0 && price.Cmp(limit) < 0 { liquidationData := map[common.Hash][]common.Hash{} - priceLiquidationData := liquidationState.getAllLiquidationData(self.db) + priceLiquidationData := liquidationState.getAllLiquidationData(t.db) for lendingBook, data := range priceLiquidationData { if len(data) == 0 { continue @@ -641,16 +643,16 @@ func (self *TradingStateDB) GetAllLowerLiquidationPriceData(orderBook common.Has return result } -func (self *TradingStateDB) GetHighestLiquidationPriceData(orderBook common.Hash, price *big.Int) (*big.Int, map[common.Hash][]common.Hash) { +func (t *TradingStateDB) GetHighestLiquidationPriceData(orderBook common.Hash, price *big.Int) (*big.Int, map[common.Hash][]common.Hash) { liquidationData := map[common.Hash][]common.Hash{} - orderbookState := self.getStateExchangeObject(orderBook) + orderbookState := t.getStateExchangeObject(orderBook) if orderbookState == nil { return common.Big0, liquidationData } - highestPriceHash, liquidationState := orderbookState.getHighestLiquidationPrice(self.db) + highestPriceHash, liquidationState := orderbookState.getHighestLiquidationPrice(t.db) highestPrice := new(big.Int).SetBytes(highestPriceHash[:]) if liquidationState != nil && highestPrice.Sign() > 0 && price.Cmp(highestPrice) < 0 { - priceLiquidationData := liquidationState.getAllLiquidationData(self.db) + priceLiquidationData := liquidationState.getAllLiquidationData(t.db) for lendingBook, data := range priceLiquidationData { if len(data) == 0 { continue @@ -667,26 +669,26 @@ func (self *TradingStateDB) GetHighestLiquidationPriceData(orderBook common.Hash return highestPrice, liquidationData } -func (self *TradingStateDB) InsertLiquidationPrice(orderBook common.Hash, price *big.Int, lendingBook common.Hash, tradeId uint64) { +func (t *TradingStateDB) InsertLiquidationPrice(orderBook common.Hash, price *big.Int, lendingBook common.Hash, tradeId uint64) { tradIdHash := common.Uint64ToHash(tradeId) priceHash := common.BigToHash(price) - orderBookState := self.getStateExchangeObject(orderBook) + orderBookState := t.getStateExchangeObject(orderBook) if orderBookState == nil { - orderBookState = self.createExchangeObject(orderBook) + orderBookState = t.createExchangeObject(orderBook) } - liquidationPriceState := orderBookState.getStateLiquidationPrice(self.db, priceHash) + liquidationPriceState := orderBookState.getStateLiquidationPrice(t.db, priceHash) if liquidationPriceState == nil { - liquidationPriceState = orderBookState.createStateLiquidationPrice(self.db, priceHash) + liquidationPriceState = orderBookState.createStateLiquidationPrice(t.db, priceHash) } - lendingBookState := liquidationPriceState.getStateLendingBook(self.db, lendingBook) + lendingBookState := liquidationPriceState.getStateLendingBook(t.db, lendingBook) if lendingBookState == nil { - lendingBookState = liquidationPriceState.createLendingBook(self.db, lendingBook) + lendingBookState = liquidationPriceState.createLendingBook(t.db, lendingBook) } - lendingBookState.insertTradingId(self.db, tradIdHash) + lendingBookState.insertTradingId(t.db, tradIdHash) lendingBookState.AddVolume(One) liquidationPriceState.AddVolume(One) orderBookState.addLendingCount(One) - self.journal = append(self.journal, insertLiquidationPrice{ + t.journal = append(t.journal, insertLiquidationPrice{ orderBook: orderBook, price: price, lendingBook: lendingBook, @@ -694,35 +696,35 @@ func (self *TradingStateDB) InsertLiquidationPrice(orderBook common.Hash, price }) } -func (self *TradingStateDB) RemoveLiquidationPrice(orderBook common.Hash, price *big.Int, lendingBook common.Hash, tradeId uint64) error { +func (t *TradingStateDB) RemoveLiquidationPrice(orderBook common.Hash, price *big.Int, lendingBook common.Hash, tradeId uint64) error { tradeIdHash := common.Uint64ToHash(tradeId) priceHash := common.BigToHash(price) - orderbookState := self.getStateExchangeObject(orderBook) + orderbookState := t.getStateExchangeObject(orderBook) if orderbookState == nil { return fmt.Errorf("not found order book: %s", orderBook.Hex()) } - liquidationPriceState := orderbookState.getStateLiquidationPrice(self.db, priceHash) + liquidationPriceState := orderbookState.getStateLiquidationPrice(t.db, priceHash) if liquidationPriceState == nil { return fmt.Errorf("not found liquidation price: %s , %s", orderBook.Hex(), priceHash.Hex()) } - lendingBookState := liquidationPriceState.getStateLendingBook(self.db, lendingBook) + lendingBookState := liquidationPriceState.getStateLendingBook(t.db, lendingBook) if lendingBookState == nil { return fmt.Errorf("not found lending book: %s , %s ,%s", orderBook.Hex(), priceHash.Hex(), lendingBook.Hex()) } - if !lendingBookState.Exist(self.db, tradeIdHash) { - return fmt.Errorf("not found trade id: %s , %s ,%s , %d ", orderBook.Hex(), priceHash.Hex(), lendingBook.Hex(), tradeId) + if !lendingBookState.Exist(t.db, tradeIdHash) { + return fmt.Errorf("not found trade id: %s, %s ,%s , %d", orderBook.Hex(), priceHash.Hex(), lendingBook.Hex(), tradeId) } - lendingBookState.removeTradingId(self.db, tradeIdHash) + lendingBookState.removeTradingId(t.db, tradeIdHash) lendingBookState.subVolume(One) liquidationPriceState.subVolume(One) if liquidationPriceState.Volume().Sign() == 0 { - err := orderbookState.getLiquidationPriceTrie(self.db).TryDelete(priceHash[:]) + err := orderbookState.getLiquidationPriceTrie(t.db).TryDelete(priceHash[:]) if err != nil { log.Warn("RemoveLiquidationPrice getLiquidationPriceTrie.TryDelete", "err", err, "priceHash", priceHash[:]) } } orderbookState.subLendingCount(One) - self.journal = append(self.journal, removeLiquidationPrice{ + t.journal = append(t.journal, removeLiquidationPrice{ orderBook: orderBook, price: price, lendingBook: lendingBook, diff --git a/XDCxlending/lendingstate/dump.go b/XDCxlending/lendingstate/dump.go index 2b26d43099..f3fe43742e 100644 --- a/XDCxlending/lendingstate/dump.go +++ b/XDCxlending/lendingstate/dump.go @@ -39,13 +39,13 @@ type DumpOrderBookInfo struct { LowestLiquidationTime *big.Int } -func (self *LendingStateDB) DumpInvestingTrie(orderBook common.Hash) (map[*big.Int]DumpOrderList, error) { - exhangeObject := self.getLendingExchange(orderBook) +func (ls *LendingStateDB) DumpInvestingTrie(orderBook common.Hash) (map[*big.Int]DumpOrderList, error) { + exhangeObject := ls.getLendingExchange(orderBook) if exhangeObject == nil { return nil, fmt.Errorf("not found orderBook: %v", orderBook.Hex()) } mapResult := map[*big.Int]DumpOrderList{} - it := trie.NewIterator(exhangeObject.getInvestingTrie(self.db).NodeIterator(nil)) + it := trie.NewIterator(exhangeObject.getInvestingTrie(ls.db).NodeIterator(nil)) for it.Next() { interestHash := common.BytesToHash(it.Key) if common.EmptyHash(interestHash) { @@ -60,12 +60,12 @@ func (self *LendingStateDB) DumpInvestingTrie(orderBook common.Hash) (map[*big.I return nil, fmt.Errorf("fail when decode order iist orderBook: %v , interest : %v", orderBook.Hex(), interest) } stateOrderList := newItemListState(orderBook, interestHash, data, nil) - mapResult[interest] = stateOrderList.DumpItemList(self.db) + mapResult[interest] = stateOrderList.DumpItemList(ls.db) } } for interestHash, itemList := range exhangeObject.investingStates { if itemList.Volume().Sign() > 0 { - mapResult[new(big.Int).SetBytes(interestHash.Bytes())] = itemList.DumpItemList(self.db) + mapResult[new(big.Int).SetBytes(interestHash.Bytes())] = itemList.DumpItemList(ls.db) } } listInterest := []*big.Int{} @@ -82,13 +82,13 @@ func (self *LendingStateDB) DumpInvestingTrie(orderBook common.Hash) (map[*big.I return result, nil } -func (self *LendingStateDB) DumpBorrowingTrie(orderBook common.Hash) (map[*big.Int]DumpOrderList, error) { - exhangeObject := self.getLendingExchange(orderBook) +func (ls *LendingStateDB) DumpBorrowingTrie(orderBook common.Hash) (map[*big.Int]DumpOrderList, error) { + exhangeObject := ls.getLendingExchange(orderBook) if exhangeObject == nil { return nil, fmt.Errorf("not found orderBook: %v", orderBook.Hex()) } mapResult := map[*big.Int]DumpOrderList{} - it := trie.NewIterator(exhangeObject.getBorrowingTrie(self.db).NodeIterator(nil)) + it := trie.NewIterator(exhangeObject.getBorrowingTrie(ls.db).NodeIterator(nil)) for it.Next() { interestHash := common.BytesToHash(it.Key) if common.EmptyHash(interestHash) { @@ -103,12 +103,12 @@ func (self *LendingStateDB) DumpBorrowingTrie(orderBook common.Hash) (map[*big.I return nil, fmt.Errorf("fail when decode order iist orderBook: %v , interest : %v", orderBook.Hex(), interest) } stateOrderList := newItemListState(orderBook, interestHash, data, nil) - mapResult[interest] = stateOrderList.DumpItemList(self.db) + mapResult[interest] = stateOrderList.DumpItemList(ls.db) } } for interestHash, itemList := range exhangeObject.borrowingStates { if itemList.Volume().Sign() > 0 { - mapResult[new(big.Int).SetBytes(interestHash.Bytes())] = itemList.DumpItemList(self.db) + mapResult[new(big.Int).SetBytes(interestHash.Bytes())] = itemList.DumpItemList(ls.db) } } listInterest := []*big.Int{} @@ -125,13 +125,13 @@ func (self *LendingStateDB) DumpBorrowingTrie(orderBook common.Hash) (map[*big.I return result, nil } -func (self *LendingStateDB) GetInvestings(orderBook common.Hash) (map[*big.Int]*big.Int, error) { - exhangeObject := self.getLendingExchange(orderBook) +func (ls *LendingStateDB) GetInvestings(orderBook common.Hash) (map[*big.Int]*big.Int, error) { + exhangeObject := ls.getLendingExchange(orderBook) if exhangeObject == nil { return nil, fmt.Errorf("not found orderBook: %v", orderBook.Hex()) } mapResult := map[*big.Int]*big.Int{} - it := trie.NewIterator(exhangeObject.getInvestingTrie(self.db).NodeIterator(nil)) + it := trie.NewIterator(exhangeObject.getInvestingTrie(ls.db).NodeIterator(nil)) for it.Next() { interestHash := common.BytesToHash(it.Key) if common.EmptyHash(interestHash) { @@ -168,13 +168,13 @@ func (self *LendingStateDB) GetInvestings(orderBook common.Hash) (map[*big.Int]* return result, nil } -func (self *LendingStateDB) GetBorrowings(orderBook common.Hash) (map[*big.Int]*big.Int, error) { - exhangeObject := self.getLendingExchange(orderBook) +func (ls *LendingStateDB) GetBorrowings(orderBook common.Hash) (map[*big.Int]*big.Int, error) { + exhangeObject := ls.getLendingExchange(orderBook) if exhangeObject == nil { return nil, fmt.Errorf("not found orderBook: %v", orderBook.Hex()) } mapResult := map[*big.Int]*big.Int{} - it := trie.NewIterator(exhangeObject.getBorrowingTrie(self.db).NodeIterator(nil)) + it := trie.NewIterator(exhangeObject.getBorrowingTrie(ls.db).NodeIterator(nil)) for it.Next() { interestHash := common.BytesToHash(it.Key) if common.EmptyHash(interestHash) { @@ -211,22 +211,22 @@ func (self *LendingStateDB) GetBorrowings(orderBook common.Hash) (map[*big.Int]* return result, nil } -func (self *itemListState) DumpItemList(db Database) DumpOrderList { - mapResult := DumpOrderList{Volume: self.Volume(), Orders: map[*big.Int]*big.Int{}} - orderListIt := trie.NewIterator(self.getTrie(db).NodeIterator(nil)) +func (il *itemListState) DumpItemList(db Database) DumpOrderList { + mapResult := DumpOrderList{Volume: il.Volume(), Orders: map[*big.Int]*big.Int{}} + orderListIt := trie.NewIterator(il.getTrie(db).NodeIterator(nil)) for orderListIt.Next() { keyHash := common.BytesToHash(orderListIt.Key) if common.EmptyHash(keyHash) { continue } - if _, exist := self.cachedStorage[keyHash]; exist { + if _, exist := il.cachedStorage[keyHash]; exist { continue } else { _, content, _, _ := rlp.Split(orderListIt.Value) mapResult.Orders[new(big.Int).SetBytes(keyHash.Bytes())] = new(big.Int).SetBytes(content) } } - for key, value := range self.cachedStorage { + for key, value := range il.cachedStorage { if !common.EmptyHash(value) { mapResult.Orders[new(big.Int).SetBytes(key.Bytes())] = new(big.Int).SetBytes(value.Bytes()) } @@ -238,44 +238,44 @@ func (self *itemListState) DumpItemList(db Database) DumpOrderList { sort.Slice(listIds, func(i, j int) bool { return listIds[i].Cmp(listIds[j]) < 0 }) - result := DumpOrderList{Volume: self.Volume(), Orders: map[*big.Int]*big.Int{}} + result := DumpOrderList{Volume: il.Volume(), Orders: map[*big.Int]*big.Int{}} for _, id := range listIds { result.Orders[id] = mapResult.Orders[id] } return result } -func (self *LendingStateDB) DumpOrderBookInfo(orderBook common.Hash) (*DumpOrderBookInfo, error) { - exhangeObject := self.getLendingExchange(orderBook) +func (ls *LendingStateDB) DumpOrderBookInfo(orderBook common.Hash) (*DumpOrderBookInfo, error) { + exhangeObject := ls.getLendingExchange(orderBook) if exhangeObject == nil { return nil, fmt.Errorf("not found orderBook: %v", orderBook.Hex()) } result := &DumpOrderBookInfo{} result.Nonce = exhangeObject.data.Nonce result.TradeNonce = exhangeObject.data.TradeNonce - result.BestInvesting = new(big.Int).SetBytes(exhangeObject.getBestInvestingInterest(self.db).Bytes()) - result.BestBorrowing = new(big.Int).SetBytes(exhangeObject.getBestBorrowingInterest(self.db).Bytes()) - lowestLiquidationTime, _ := exhangeObject.getLowestLiquidationTime(self.db) + result.BestInvesting = new(big.Int).SetBytes(exhangeObject.getBestInvestingInterest(ls.db).Bytes()) + result.BestBorrowing = new(big.Int).SetBytes(exhangeObject.getBestBorrowingInterest(ls.db).Bytes()) + lowestLiquidationTime, _ := exhangeObject.getLowestLiquidationTime(ls.db) result.LowestLiquidationTime = new(big.Int).SetBytes(lowestLiquidationTime.Bytes()) return result, nil } -func (self *liquidationTimeState) DumpItemList(db Database) DumpOrderList { - mapResult := DumpOrderList{Volume: self.Volume(), Orders: map[*big.Int]*big.Int{}} - orderListIt := trie.NewIterator(self.getTrie(db).NodeIterator(nil)) +func (lts *liquidationTimeState) DumpItemList(db Database) DumpOrderList { + mapResult := DumpOrderList{Volume: lts.Volume(), Orders: map[*big.Int]*big.Int{}} + orderListIt := trie.NewIterator(lts.getTrie(db).NodeIterator(nil)) for orderListIt.Next() { keyHash := common.BytesToHash(orderListIt.Key) if common.EmptyHash(keyHash) { continue } - if _, exist := self.cachedStorage[keyHash]; exist { + if _, exist := lts.cachedStorage[keyHash]; exist { continue } else { _, content, _, _ := rlp.Split(orderListIt.Value) mapResult.Orders[new(big.Int).SetBytes(keyHash.Bytes())] = new(big.Int).SetBytes(content) } } - for key, value := range self.cachedStorage { + for key, value := range lts.cachedStorage { if !common.EmptyHash(value) { mapResult.Orders[new(big.Int).SetBytes(key.Bytes())] = new(big.Int).SetBytes(value.Bytes()) } @@ -287,19 +287,20 @@ func (self *liquidationTimeState) DumpItemList(db Database) DumpOrderList { sort.Slice(listIds, func(i, j int) bool { return listIds[i].Cmp(listIds[j]) < 0 }) - result := DumpOrderList{Volume: self.Volume(), Orders: map[*big.Int]*big.Int{}} + result := DumpOrderList{Volume: lts.Volume(), Orders: map[*big.Int]*big.Int{}} for _, id := range listIds { result.Orders[id] = mapResult.Orders[id] } return mapResult } -func (self *LendingStateDB) DumpLiquidationTimeTrie(orderBook common.Hash) (map[*big.Int]DumpOrderList, error) { - exhangeObject := self.getLendingExchange(orderBook) + +func (ls *LendingStateDB) DumpLiquidationTimeTrie(orderBook common.Hash) (map[*big.Int]DumpOrderList, error) { + exhangeObject := ls.getLendingExchange(orderBook) if exhangeObject == nil { return nil, fmt.Errorf("not found orderBook: %v", orderBook.Hex()) } mapResult := map[*big.Int]DumpOrderList{} - it := trie.NewIterator(exhangeObject.getLiquidationTimeTrie(self.db).NodeIterator(nil)) + it := trie.NewIterator(exhangeObject.getLiquidationTimeTrie(ls.db).NodeIterator(nil)) for it.Next() { unixTimeHash := common.BytesToHash(it.Key) if common.EmptyHash(unixTimeHash) { @@ -314,12 +315,12 @@ func (self *LendingStateDB) DumpLiquidationTimeTrie(orderBook common.Hash) (map[ return nil, fmt.Errorf("fail when decode order iist orderBook: %v , unixTime : %v", orderBook.Hex(), unixTime) } stateOrderList := newLiquidationTimeState(orderBook, unixTimeHash, data, nil) - mapResult[unixTime] = stateOrderList.DumpItemList(self.db) + mapResult[unixTime] = stateOrderList.DumpItemList(ls.db) } } for unixTimeHash, itemList := range exhangeObject.liquidationTimeStates { if itemList.Volume().Sign() > 0 { - mapResult[new(big.Int).SetBytes(unixTimeHash.Bytes())] = itemList.DumpItemList(self.db) + mapResult[new(big.Int).SetBytes(unixTimeHash.Bytes())] = itemList.DumpItemList(ls.db) } } listUnixTime := []*big.Int{} @@ -336,13 +337,13 @@ func (self *LendingStateDB) DumpLiquidationTimeTrie(orderBook common.Hash) (map[ return result, nil } -func (self *LendingStateDB) DumpLendingOrderTrie(orderBook common.Hash) (map[*big.Int]LendingItem, error) { - exhangeObject := self.getLendingExchange(orderBook) +func (ls *LendingStateDB) DumpLendingOrderTrie(orderBook common.Hash) (map[*big.Int]LendingItem, error) { + exhangeObject := ls.getLendingExchange(orderBook) if exhangeObject == nil { return nil, fmt.Errorf("not found orderBook: %v", orderBook.Hex()) } mapResult := map[*big.Int]LendingItem{} - it := trie.NewIterator(exhangeObject.getLendingItemTrie(self.db).NodeIterator(nil)) + it := trie.NewIterator(exhangeObject.getLendingItemTrie(ls.db).NodeIterator(nil)) for it.Next() { orderIdHash := common.BytesToHash(it.Key) if common.EmptyHash(orderIdHash) { @@ -376,13 +377,13 @@ func (self *LendingStateDB) DumpLendingOrderTrie(orderBook common.Hash) (map[*bi return result, nil } -func (self *LendingStateDB) DumpLendingTradeTrie(orderBook common.Hash) (map[*big.Int]LendingTrade, error) { - exhangeObject := self.getLendingExchange(orderBook) +func (ls *LendingStateDB) DumpLendingTradeTrie(orderBook common.Hash) (map[*big.Int]LendingTrade, error) { + exhangeObject := ls.getLendingExchange(orderBook) if exhangeObject == nil { return nil, fmt.Errorf("not found orderBook: %v", orderBook.Hex()) } mapResult := map[*big.Int]LendingTrade{} - it := trie.NewIterator(exhangeObject.getLendingTradeTrie(self.db).NodeIterator(nil)) + it := trie.NewIterator(exhangeObject.getLendingTradeTrie(ls.db).NodeIterator(nil)) for it.Next() { tradeIdHash := common.BytesToHash(it.Key) if common.EmptyHash(tradeIdHash) { diff --git a/XDCxlending/lendingstate/state_itemList.go b/XDCxlending/lendingstate/state_itemList.go index ad48c8c857..7737e5b159 100644 --- a/XDCxlending/lendingstate/state_itemList.go +++ b/XDCxlending/lendingstate/state_itemList.go @@ -19,10 +19,11 @@ package lendingstate import ( "bytes" "fmt" - "github.com/XinFinOrg/XDPoSChain/common" - "github.com/XinFinOrg/XDPoSChain/rlp" "io" "math/big" + + "github.com/XinFinOrg/XDPoSChain/common" + "github.com/XinFinOrg/XDPoSChain/rlp" ) type itemListState struct { @@ -46,8 +47,8 @@ type itemListState struct { onDirty func(price common.Hash) // Callback method to mark a state object newly dirty } -func (s *itemListState) empty() bool { - return s.data.Volume == nil || s.data.Volume.Sign() == 0 +func (il *itemListState) empty() bool { + return il.data.Volume == nil || il.data.Volume.Sign() == 0 } func newItemListState(lendingBook common.Hash, key common.Hash, data itemList, onDirty func(price common.Hash)) *itemListState { @@ -62,132 +63,132 @@ func newItemListState(lendingBook common.Hash, key common.Hash, data itemList, o } // EncodeRLP implements rlp.Encoder. -func (c *itemListState) EncodeRLP(w io.Writer) error { - return rlp.Encode(w, c.data) +func (il *itemListState) EncodeRLP(w io.Writer) error { + return rlp.Encode(w, il.data) } // setError remembers the first non-nil error it is called with. -func (self *itemListState) setError(err error) { - if self.dbErr == nil { - self.dbErr = err +func (il *itemListState) setError(err error) { + if il.dbErr == nil { + il.dbErr = err } } -func (c *itemListState) getTrie(db Database) Trie { - if c.trie == nil { +func (il *itemListState) getTrie(db Database) Trie { + if il.trie == nil { var err error - c.trie, err = db.OpenStorageTrie(c.key, c.data.Root) + il.trie, err = db.OpenStorageTrie(il.key, il.data.Root) if err != nil { - c.trie, _ = db.OpenStorageTrie(c.key, EmptyHash) - c.setError(fmt.Errorf("can't create storage trie: %v", err)) + il.trie, _ = db.OpenStorageTrie(il.key, EmptyHash) + il.setError(fmt.Errorf("can't create storage trie: %v", err)) } } - return c.trie + return il.trie } -func (self *itemListState) GetOrderAmount(db Database, orderId common.Hash) common.Hash { - amount, exists := self.cachedStorage[orderId] +func (il *itemListState) GetOrderAmount(db Database, orderId common.Hash) common.Hash { + amount, exists := il.cachedStorage[orderId] if exists { return amount } // Load from DB in case it is missing. - enc, err := self.getTrie(db).TryGet(orderId[:]) + enc, err := il.getTrie(db).TryGet(orderId[:]) if err != nil { - self.setError(err) + il.setError(err) return EmptyHash } if len(enc) > 0 { _, content, _, err := rlp.Split(enc) if err != nil { - self.setError(err) + il.setError(err) } amount.SetBytes(content) } if (amount != common.Hash{}) { - self.cachedStorage[orderId] = amount + il.cachedStorage[orderId] = amount } return amount } -func (self *itemListState) insertLendingItem(db Database, orderId common.Hash, amount common.Hash) { - self.setOrderItem(orderId, amount) - self.setError(self.getTrie(db).TryUpdate(orderId[:], amount[:])) +func (il *itemListState) insertLendingItem(db Database, orderId common.Hash, amount common.Hash) { + il.setOrderItem(orderId, amount) + il.setError(il.getTrie(db).TryUpdate(orderId[:], amount[:])) } -func (self *itemListState) removeOrderItem(db Database, orderId common.Hash) { - tr := self.getTrie(db) - self.setError(tr.TryDelete(orderId[:])) - self.setOrderItem(orderId, EmptyHash) +func (il *itemListState) removeOrderItem(db Database, orderId common.Hash) { + tr := il.getTrie(db) + il.setError(tr.TryDelete(orderId[:])) + il.setOrderItem(orderId, EmptyHash) } -func (self *itemListState) setOrderItem(orderId common.Hash, amount common.Hash) { - self.cachedStorage[orderId] = amount - self.dirtyStorage[orderId] = amount +func (il *itemListState) setOrderItem(orderId common.Hash, amount common.Hash) { + il.cachedStorage[orderId] = amount + il.dirtyStorage[orderId] = amount - if self.onDirty != nil { - self.onDirty(self.key) - self.onDirty = nil + if il.onDirty != nil { + il.onDirty(il.key) + il.onDirty = nil } } // updateAskTrie writes cached storage modifications into the object's storage trie. -func (self *itemListState) updateTrie(db Database) Trie { - tr := self.getTrie(db) - for orderId, amount := range self.dirtyStorage { - delete(self.dirtyStorage, orderId) +func (il *itemListState) updateTrie(db Database) Trie { + tr := il.getTrie(db) + for orderId, amount := range il.dirtyStorage { + delete(il.dirtyStorage, orderId) if amount == EmptyHash { - self.setError(tr.TryDelete(orderId[:])) + il.setError(tr.TryDelete(orderId[:])) continue } v, _ := rlp.EncodeToBytes(bytes.TrimLeft(amount[:], "\x00")) - self.setError(tr.TryUpdate(orderId[:], v)) + il.setError(tr.TryUpdate(orderId[:], v)) } return tr } // UpdateRoot sets the trie root to the current root tradeId of -func (self *itemListState) updateRoot(db Database) error { - self.updateTrie(db) - if self.dbErr != nil { - return self.dbErr +func (il *itemListState) updateRoot(db Database) error { + il.updateTrie(db) + if il.dbErr != nil { + return il.dbErr } - root, err := self.trie.Commit(nil) + root, err := il.trie.Commit(nil) if err == nil { - self.data.Root = root + il.data.Root = root } return err } -func (self *itemListState) deepCopy(db *LendingStateDB, onDirty func(price common.Hash)) *itemListState { - stateOrderList := newItemListState(self.lendingBook, self.key, self.data, onDirty) - if self.trie != nil { - stateOrderList.trie = db.db.CopyTrie(self.trie) +func (il *itemListState) deepCopy(db *LendingStateDB, onDirty func(price common.Hash)) *itemListState { + stateOrderList := newItemListState(il.lendingBook, il.key, il.data, onDirty) + if il.trie != nil { + stateOrderList.trie = db.db.CopyTrie(il.trie) } - for orderId, amount := range self.dirtyStorage { + for orderId, amount := range il.dirtyStorage { stateOrderList.dirtyStorage[orderId] = amount } - for orderId, amount := range self.cachedStorage { + for orderId, amount := range il.cachedStorage { stateOrderList.cachedStorage[orderId] = amount } return stateOrderList } -func (c *itemListState) AddVolume(amount *big.Int) { - c.setVolume(new(big.Int).Add(c.data.Volume, amount)) +func (il *itemListState) AddVolume(amount *big.Int) { + il.setVolume(new(big.Int).Add(il.data.Volume, amount)) } -func (c *itemListState) subVolume(amount *big.Int) { - c.setVolume(new(big.Int).Sub(c.data.Volume, amount)) +func (il *itemListState) subVolume(amount *big.Int) { + il.setVolume(new(big.Int).Sub(il.data.Volume, amount)) } -func (self *itemListState) setVolume(volume *big.Int) { - self.data.Volume = volume - if self.onDirty != nil { - self.onDirty(self.key) - self.onDirty = nil +func (il *itemListState) setVolume(volume *big.Int) { + il.data.Volume = volume + if il.onDirty != nil { + il.onDirty(il.key) + il.onDirty = nil } } -func (self *itemListState) Volume() *big.Int { - return self.data.Volume +func (il *itemListState) Volume() *big.Int { + return il.data.Volume } diff --git a/XDCxlending/lendingstate/state_lendingbook.go b/XDCxlending/lendingstate/state_lendingbook.go index c063f23f7f..1cc3fda077 100644 --- a/XDCxlending/lendingstate/state_lendingbook.go +++ b/XDCxlending/lendingstate/state_lendingbook.go @@ -108,14 +108,14 @@ func newStateExchanges(db *LendingStateDB, hash common.Hash, data lendingObject, } // EncodeRLP implements rlp.Encoder. -func (self *lendingExchangeState) EncodeRLP(w io.Writer) error { - return rlp.Encode(w, self.data) +func (le *lendingExchangeState) EncodeRLP(w io.Writer) error { + return rlp.Encode(w, le.data) } // setError remembers the first non-nil error it is called with. -func (self *lendingExchangeState) setError(err error) { - if self.dbErr == nil { - self.dbErr = err +func (le *lendingExchangeState) setError(err error) { + if le.dbErr == nil { + le.dbErr = err } } @@ -123,63 +123,64 @@ func (self *lendingExchangeState) setError(err error) { Get Trie */ -func (self *lendingExchangeState) getLendingItemTrie(db Database) Trie { - if self.lendingItemTrie == nil { +func (le *lendingExchangeState) getLendingItemTrie(db Database) Trie { + if le.lendingItemTrie == nil { var err error - self.lendingItemTrie, err = db.OpenStorageTrie(self.lendingBook, self.data.LendingItemRoot) + le.lendingItemTrie, err = db.OpenStorageTrie(le.lendingBook, le.data.LendingItemRoot) if err != nil { - self.lendingItemTrie, _ = db.OpenStorageTrie(self.lendingBook, EmptyHash) - self.setError(fmt.Errorf("can't create Lendings trie: %v", err)) + le.lendingItemTrie, _ = db.OpenStorageTrie(le.lendingBook, EmptyHash) + le.setError(fmt.Errorf("can't create Lendings trie: %v", err)) } } - return self.lendingItemTrie + return le.lendingItemTrie } -func (self *lendingExchangeState) getLendingTradeTrie(db Database) Trie { - if self.lendingTradeTrie == nil { +func (le *lendingExchangeState) getLendingTradeTrie(db Database) Trie { + if le.lendingTradeTrie == nil { var err error - self.lendingTradeTrie, err = db.OpenStorageTrie(self.lendingBook, self.data.LendingTradeRoot) + le.lendingTradeTrie, err = db.OpenStorageTrie(le.lendingBook, le.data.LendingTradeRoot) if err != nil { - self.lendingTradeTrie, _ = db.OpenStorageTrie(self.lendingBook, EmptyHash) - self.setError(fmt.Errorf("can't create Lendings trie: %v", err)) + le.lendingTradeTrie, _ = db.OpenStorageTrie(le.lendingBook, EmptyHash) + le.setError(fmt.Errorf("can't create Lendings trie: %v", err)) } } - return self.lendingTradeTrie -} -func (self *lendingExchangeState) getInvestingTrie(db Database) Trie { - if self.investingTrie == nil { - var err error - self.investingTrie, err = db.OpenStorageTrie(self.lendingBook, self.data.InvestingRoot) - if err != nil { - self.investingTrie, _ = db.OpenStorageTrie(self.lendingBook, EmptyHash) - self.setError(fmt.Errorf("can't create Lendings trie: %v", err)) - } - } - return self.investingTrie + return le.lendingTradeTrie } -func (self *lendingExchangeState) getBorrowingTrie(db Database) Trie { - if self.borrowingTrie == nil { +func (le *lendingExchangeState) getInvestingTrie(db Database) Trie { + if le.investingTrie == nil { var err error - self.borrowingTrie, err = db.OpenStorageTrie(self.lendingBook, self.data.BorrowingRoot) + le.investingTrie, err = db.OpenStorageTrie(le.lendingBook, le.data.InvestingRoot) if err != nil { - self.borrowingTrie, _ = db.OpenStorageTrie(self.lendingBook, EmptyHash) - self.setError(fmt.Errorf("can't create bids trie: %v", err)) + le.investingTrie, _ = db.OpenStorageTrie(le.lendingBook, EmptyHash) + le.setError(fmt.Errorf("can't create Lendings trie: %v", err)) } } - return self.borrowingTrie + return le.investingTrie } -func (self *lendingExchangeState) getLiquidationTimeTrie(db Database) Trie { - if self.liquidationTimeTrie == nil { +func (le *lendingExchangeState) getBorrowingTrie(db Database) Trie { + if le.borrowingTrie == nil { var err error - self.liquidationTimeTrie, err = db.OpenStorageTrie(self.lendingBook, self.data.LiquidationTimeRoot) + le.borrowingTrie, err = db.OpenStorageTrie(le.lendingBook, le.data.BorrowingRoot) if err != nil { - self.liquidationTimeTrie, _ = db.OpenStorageTrie(self.lendingBook, EmptyHash) - self.setError(fmt.Errorf("can't create bids trie: %v", err)) + le.borrowingTrie, _ = db.OpenStorageTrie(le.lendingBook, EmptyHash) + le.setError(fmt.Errorf("can't create bids trie: %v", err)) } } - return self.liquidationTimeTrie + return le.borrowingTrie +} + +func (le *lendingExchangeState) getLiquidationTimeTrie(db Database) Trie { + if le.liquidationTimeTrie == nil { + var err error + le.liquidationTimeTrie, err = db.OpenStorageTrie(le.lendingBook, le.data.LiquidationTimeRoot) + if err != nil { + le.liquidationTimeTrie, _ = db.OpenStorageTrie(le.lendingBook, EmptyHash) + le.setError(fmt.Errorf("can't create bids trie: %v", err)) + } + } + return le.liquidationTimeTrie } /* @@ -187,16 +188,16 @@ func (self *lendingExchangeState) getLiquidationTimeTrie(db Database) Trie { Get State */ -func (self *lendingExchangeState) getBorrowingOrderList(db Database, rate common.Hash) (stateOrderList *itemListState) { +func (le *lendingExchangeState) getBorrowingOrderList(db Database, rate common.Hash) (stateOrderList *itemListState) { // Prefer 'live' objects. - if obj := self.borrowingStates[rate]; obj != nil { + if obj := le.borrowingStates[rate]; obj != nil { return obj } // Load the object from the database. - enc, err := self.getBorrowingTrie(db).TryGet(rate[:]) + enc, err := le.getBorrowingTrie(db).TryGet(rate[:]) if len(enc) == 0 { - self.setError(err) + le.setError(err) return nil } var data itemList @@ -205,21 +206,21 @@ func (self *lendingExchangeState) getBorrowingOrderList(db Database, rate common return nil } // Insert into the live set. - obj := newItemListState(self.lendingBook, rate, data, self.MarkBorrowingDirty) - self.borrowingStates[rate] = obj + obj := newItemListState(le.lendingBook, rate, data, le.MarkBorrowingDirty) + le.borrowingStates[rate] = obj return obj } -func (self *lendingExchangeState) getInvestingOrderList(db Database, rate common.Hash) (stateOrderList *itemListState) { +func (le *lendingExchangeState) getInvestingOrderList(db Database, rate common.Hash) (stateOrderList *itemListState) { // Prefer 'live' objects. - if obj := self.investingStates[rate]; obj != nil { + if obj := le.investingStates[rate]; obj != nil { return obj } // Load the object from the database. - enc, err := self.getInvestingTrie(db).TryGet(rate[:]) + enc, err := le.getInvestingTrie(db).TryGet(rate[:]) if len(enc) == 0 { - self.setError(err) + le.setError(err) return nil } var data itemList @@ -228,21 +229,21 @@ func (self *lendingExchangeState) getInvestingOrderList(db Database, rate common return nil } // Insert into the live set. - obj := newItemListState(self.lendingBook, rate, data, self.MarkInvestingDirty) - self.investingStates[rate] = obj + obj := newItemListState(le.lendingBook, rate, data, le.MarkInvestingDirty) + le.investingStates[rate] = obj return obj } -func (self *lendingExchangeState) getLiquidationTimeOrderList(db Database, time common.Hash) (stateObject *liquidationTimeState) { +func (le *lendingExchangeState) getLiquidationTimeOrderList(db Database, time common.Hash) (stateObject *liquidationTimeState) { // Prefer 'live' objects. - if obj := self.liquidationTimeStates[time]; obj != nil { + if obj := le.liquidationTimeStates[time]; obj != nil { return obj } // Load the object from the database. - enc, err := self.getLiquidationTimeTrie(db).TryGet(time[:]) + enc, err := le.getLiquidationTimeTrie(db).TryGet(time[:]) if len(enc) == 0 { - self.setError(err) + le.setError(err) return nil } var data itemList @@ -251,21 +252,21 @@ func (self *lendingExchangeState) getLiquidationTimeOrderList(db Database, time return nil } // Insert into the live set. - obj := newLiquidationTimeState(self.lendingBook, time, data, self.MarkLiquidationTimeDirty) - self.liquidationTimeStates[time] = obj + obj := newLiquidationTimeState(le.lendingBook, time, data, le.MarkLiquidationTimeDirty) + le.liquidationTimeStates[time] = obj return obj } -func (self *lendingExchangeState) getLendingItem(db Database, lendingId common.Hash) (stateObject *lendingItemState) { +func (le *lendingExchangeState) getLendingItem(db Database, lendingId common.Hash) (stateObject *lendingItemState) { // Prefer 'live' objects. - if obj := self.lendingItemStates[lendingId]; obj != nil { + if obj := le.lendingItemStates[lendingId]; obj != nil { return obj } // Load the object from the database. - enc, err := self.getLendingItemTrie(db).TryGet(lendingId[:]) + enc, err := le.getLendingItemTrie(db).TryGet(lendingId[:]) if len(enc) == 0 { - self.setError(err) + le.setError(err) return nil } var data LendingItem @@ -274,21 +275,21 @@ func (self *lendingExchangeState) getLendingItem(db Database, lendingId common.H return nil } // Insert into the live set. - obj := newLendinItemState(self.lendingBook, lendingId, data, self.MarkLendingItemDirty) - self.lendingItemStates[lendingId] = obj + obj := newLendinItemState(le.lendingBook, lendingId, data, le.MarkLendingItemDirty) + le.lendingItemStates[lendingId] = obj return obj } -func (self *lendingExchangeState) getLendingTrade(db Database, tradeId common.Hash) (stateObject *lendingTradeState) { +func (le *lendingExchangeState) getLendingTrade(db Database, tradeId common.Hash) (stateObject *lendingTradeState) { // Prefer 'live' objects. - if obj := self.lendingTradeStates[tradeId]; obj != nil { + if obj := le.lendingTradeStates[tradeId]; obj != nil { return obj } // Load the object from the database. - enc, err := self.getLendingTradeTrie(db).TryGet(tradeId[:]) + enc, err := le.getLendingTradeTrie(db).TryGet(tradeId[:]) if len(enc) == 0 { - self.setError(err) + le.setError(err) return nil } var data LendingTrade @@ -297,8 +298,8 @@ func (self *lendingExchangeState) getLendingTrade(db Database, tradeId common.Ha return nil } // Insert into the live set. - obj := newLendingTradeState(self.lendingBook, tradeId, data, self.MarkLendingTradeDirty) - self.lendingTradeStates[tradeId] = obj + obj := newLendingTradeState(le.lendingBook, tradeId, data, le.MarkLendingTradeDirty) + le.lendingTradeStates[tradeId] = obj return obj } @@ -307,46 +308,47 @@ func (self *lendingExchangeState) getLendingTrade(db Database, tradeId common.Ha Update Trie */ -func (self *lendingExchangeState) updateLendingTimeTrie(db Database) Trie { - tr := self.getLendingItemTrie(db) - for lendingId, lendingItem := range self.lendingItemStates { - if _, isDirty := self.lendingItemStatesDirty[lendingId]; isDirty { - delete(self.lendingItemStatesDirty, lendingId) +func (le *lendingExchangeState) updateLendingTimeTrie(db Database) Trie { + tr := le.getLendingItemTrie(db) + for lendingId, lendingItem := range le.lendingItemStates { + if _, isDirty := le.lendingItemStatesDirty[lendingId]; isDirty { + delete(le.lendingItemStatesDirty, lendingId) if lendingItem.empty() { - self.setError(tr.TryDelete(lendingId[:])) + le.setError(tr.TryDelete(lendingId[:])) continue } // Encoding []byte cannot fail, ok to ignore the error. v, _ := rlp.EncodeToBytes(lendingItem) - self.setError(tr.TryUpdate(lendingId[:], v)) + le.setError(tr.TryUpdate(lendingId[:], v)) } } return tr } -func (self *lendingExchangeState) updateLendingTradeTrie(db Database) Trie { - tr := self.getLendingTradeTrie(db) - for tradeId, lendingTradeItem := range self.lendingTradeStates { - if _, isDirty := self.lendingTradeStatesDirty[tradeId]; isDirty { - delete(self.lendingTradeStatesDirty, tradeId) +func (le *lendingExchangeState) updateLendingTradeTrie(db Database) Trie { + tr := le.getLendingTradeTrie(db) + for tradeId, lendingTradeItem := range le.lendingTradeStates { + if _, isDirty := le.lendingTradeStatesDirty[tradeId]; isDirty { + delete(le.lendingTradeStatesDirty, tradeId) if lendingTradeItem.empty() { - self.setError(tr.TryDelete(tradeId[:])) + le.setError(tr.TryDelete(tradeId[:])) continue } // Encoding []byte cannot fail, ok to ignore the error. v, _ := rlp.EncodeToBytes(lendingTradeItem) - self.setError(tr.TryUpdate(tradeId[:], v)) + le.setError(tr.TryUpdate(tradeId[:], v)) } } return tr } -func (self *lendingExchangeState) updateBorrowingTrie(db Database) Trie { - tr := self.getBorrowingTrie(db) - for rate, orderList := range self.borrowingStates { - if _, isDirty := self.borrowingStatesDirty[rate]; isDirty { - delete(self.borrowingStatesDirty, rate) + +func (le *lendingExchangeState) updateBorrowingTrie(db Database) Trie { + tr := le.getBorrowingTrie(db) + for rate, orderList := range le.borrowingStates { + if _, isDirty := le.borrowingStatesDirty[rate]; isDirty { + delete(le.borrowingStatesDirty, rate) if orderList.empty() { - self.setError(tr.TryDelete(rate[:])) + le.setError(tr.TryDelete(rate[:])) continue } err := orderList.updateRoot(db) @@ -355,19 +357,19 @@ func (self *lendingExchangeState) updateBorrowingTrie(db Database) Trie { } // Encoding []byte cannot fail, ok to ignore the error. v, _ := rlp.EncodeToBytes(orderList) - self.setError(tr.TryUpdate(rate[:], v)) + le.setError(tr.TryUpdate(rate[:], v)) } } return tr } -func (self *lendingExchangeState) updateInvestingTrie(db Database) Trie { - tr := self.getInvestingTrie(db) - for rate, orderList := range self.investingStates { - if _, isDirty := self.investingStatesDirty[rate]; isDirty { - delete(self.investingStatesDirty, rate) +func (le *lendingExchangeState) updateInvestingTrie(db Database) Trie { + tr := le.getInvestingTrie(db) + for rate, orderList := range le.investingStates { + if _, isDirty := le.investingStatesDirty[rate]; isDirty { + delete(le.investingStatesDirty, rate) if orderList.empty() { - self.setError(tr.TryDelete(rate[:])) + le.setError(tr.TryDelete(rate[:])) continue } err := orderList.updateRoot(db) @@ -376,19 +378,19 @@ func (self *lendingExchangeState) updateInvestingTrie(db Database) Trie { } // Encoding []byte cannot fail, ok to ignore the error. v, _ := rlp.EncodeToBytes(orderList) - self.setError(tr.TryUpdate(rate[:], v)) + le.setError(tr.TryUpdate(rate[:], v)) } } return tr } -func (self *lendingExchangeState) updateLiquidationTimeTrie(db Database) Trie { - tr := self.getLiquidationTimeTrie(db) - for time, itemList := range self.liquidationTimeStates { - if _, isDirty := self.liquidationTimestatesDirty[time]; isDirty { - delete(self.liquidationTimestatesDirty, time) +func (le *lendingExchangeState) updateLiquidationTimeTrie(db Database) Trie { + tr := le.getLiquidationTimeTrie(db) + for time, itemList := range le.liquidationTimeStates { + if _, isDirty := le.liquidationTimestatesDirty[time]; isDirty { + delete(le.liquidationTimestatesDirty, time) if itemList.empty() { - self.setError(tr.TryDelete(time[:])) + le.setError(tr.TryDelete(time[:])) continue } err := itemList.updateRoot(db) @@ -397,7 +399,7 @@ func (self *lendingExchangeState) updateLiquidationTimeTrie(db Database) Trie { } // Encoding []byte cannot fail, ok to ignore the error. v, _ := rlp.EncodeToBytes(itemList) - self.setError(tr.TryUpdate(time[:], v)) + le.setError(tr.TryUpdate(time[:], v)) } } return tr @@ -407,69 +409,69 @@ func (self *lendingExchangeState) updateLiquidationTimeTrie(db Database) Trie { Update Root */ -func (self *lendingExchangeState) updateOrderRoot(db Database) { - self.updateLendingTimeTrie(db) - self.data.LendingItemRoot = self.lendingItemTrie.Hash() +func (le *lendingExchangeState) updateOrderRoot(db Database) { + le.updateLendingTimeTrie(db) + le.data.LendingItemRoot = le.lendingItemTrie.Hash() } -func (self *lendingExchangeState) updateInvestingRoot(db Database) error { - self.updateInvestingTrie(db) - if self.dbErr != nil { - return self.dbErr +func (le *lendingExchangeState) updateInvestingRoot(db Database) error { + le.updateInvestingTrie(db) + if le.dbErr != nil { + return le.dbErr } - self.data.InvestingRoot = self.investingTrie.Hash() + le.data.InvestingRoot = le.investingTrie.Hash() return nil } -func (self *lendingExchangeState) updateBorrowingRoot(db Database) { - self.updateBorrowingTrie(db) - self.data.BorrowingRoot = self.borrowingTrie.Hash() +func (le *lendingExchangeState) updateBorrowingRoot(db Database) { + le.updateBorrowingTrie(db) + le.data.BorrowingRoot = le.borrowingTrie.Hash() } -func (self *lendingExchangeState) updateLiquidationTimeRoot(db Database) { - self.updateLiquidationTimeTrie(db) - self.data.LiquidationTimeRoot = self.liquidationTimeTrie.Hash() +func (le *lendingExchangeState) updateLiquidationTimeRoot(db Database) { + le.updateLiquidationTimeTrie(db) + le.data.LiquidationTimeRoot = le.liquidationTimeTrie.Hash() } -func (self *lendingExchangeState) updateLendingTradeRoot(db Database) { - self.updateLendingTradeTrie(db) - self.data.LendingTradeRoot = self.lendingTradeTrie.Hash() +func (le *lendingExchangeState) updateLendingTradeRoot(db Database) { + le.updateLendingTradeTrie(db) + le.data.LendingTradeRoot = le.lendingTradeTrie.Hash() } /** Commit Trie */ -func (self *lendingExchangeState) CommitLendingItemTrie(db Database) error { - self.updateLendingTimeTrie(db) - if self.dbErr != nil { - return self.dbErr +func (le *lendingExchangeState) CommitLendingItemTrie(db Database) error { + le.updateLendingTimeTrie(db) + if le.dbErr != nil { + return le.dbErr } - root, err := self.lendingItemTrie.Commit(nil) + root, err := le.lendingItemTrie.Commit(nil) if err == nil { - self.data.LendingItemRoot = root + le.data.LendingItemRoot = root } return err } -func (self *lendingExchangeState) CommitLendingTradeTrie(db Database) error { - self.updateLendingTradeTrie(db) - if self.dbErr != nil { - return self.dbErr +func (le *lendingExchangeState) CommitLendingTradeTrie(db Database) error { + le.updateLendingTradeTrie(db) + if le.dbErr != nil { + return le.dbErr } - root, err := self.lendingTradeTrie.Commit(nil) + root, err := le.lendingTradeTrie.Commit(nil) if err == nil { - self.data.LendingTradeRoot = root + le.data.LendingTradeRoot = root } return err } -func (self *lendingExchangeState) CommitInvestingTrie(db Database) error { - self.updateInvestingTrie(db) - if self.dbErr != nil { - return self.dbErr +func (le *lendingExchangeState) CommitInvestingTrie(db Database) error { + le.updateInvestingTrie(db) + if le.dbErr != nil { + return le.dbErr } - root, err := self.investingTrie.Commit(func(leaf []byte, parent common.Hash) error { + root, err := le.investingTrie.Commit(func(leaf []byte, parent common.Hash) error { var orderList itemList if err := rlp.DecodeBytes(leaf, &orderList); err != nil { return nil @@ -480,17 +482,17 @@ func (self *lendingExchangeState) CommitInvestingTrie(db Database) error { return nil }) if err == nil { - self.data.InvestingRoot = root + le.data.InvestingRoot = root } return err } -func (self *lendingExchangeState) CommitBorrowingTrie(db Database) error { - self.updateBorrowingTrie(db) - if self.dbErr != nil { - return self.dbErr +func (le *lendingExchangeState) CommitBorrowingTrie(db Database) error { + le.updateBorrowingTrie(db) + if le.dbErr != nil { + return le.dbErr } - root, err := self.borrowingTrie.Commit(func(leaf []byte, parent common.Hash) error { + root, err := le.borrowingTrie.Commit(func(leaf []byte, parent common.Hash) error { var orderList itemList if err := rlp.DecodeBytes(leaf, &orderList); err != nil { return nil @@ -501,17 +503,17 @@ func (self *lendingExchangeState) CommitBorrowingTrie(db Database) error { return nil }) if err == nil { - self.data.BorrowingRoot = root + le.data.BorrowingRoot = root } return err } -func (self *lendingExchangeState) CommitLiquidationTimeTrie(db Database) error { - self.updateLiquidationTimeTrie(db) - if self.dbErr != nil { - return self.dbErr +func (le *lendingExchangeState) CommitLiquidationTimeTrie(db Database) error { + le.updateLiquidationTimeTrie(db) + if le.dbErr != nil { + return le.dbErr } - root, err := self.liquidationTimeTrie.Commit(func(leaf []byte, parent common.Hash) error { + root, err := le.liquidationTimeTrie.Commit(func(leaf []byte, parent common.Hash) error { var orderList itemList if err := rlp.DecodeBytes(leaf, &orderList); err != nil { return nil @@ -522,7 +524,7 @@ func (self *lendingExchangeState) CommitLiquidationTimeTrie(db Database) error { return nil }) if err == nil { - self.data.LiquidationTimeRoot = root + le.data.LiquidationTimeRoot = root } return err } @@ -532,11 +534,11 @@ func (self *lendingExchangeState) CommitLiquidationTimeTrie(db Database) error { Get Trie Data */ -func (self *lendingExchangeState) getBestInvestingInterest(db Database) common.Hash { - trie := self.getInvestingTrie(db) +func (le *lendingExchangeState) getBestInvestingInterest(db Database) common.Hash { + trie := le.getInvestingTrie(db) encKey, encValue, err := trie.TryGetBestLeftKeyAndValue() if err != nil { - log.Error("Failed find best investing rate", "orderbook", self.lendingBook.Hex()) + log.Error("Failed find best investing rate", "orderbook", le.lendingBook.Hex()) return EmptyHash } if len(encKey) == 0 || len(encValue) == 0 { @@ -545,23 +547,23 @@ func (self *lendingExchangeState) getBestInvestingInterest(db Database) common.H } // Insert into the live set. interest := common.BytesToHash(encKey) - if _, exist := self.investingStates[interest]; !exist { + if _, exist := le.investingStates[interest]; !exist { var data itemList if err := rlp.DecodeBytes(encValue, &data); err != nil { log.Error("Failed to decode state get best investing rate", "err", err) return EmptyHash } - obj := newItemListState(self.lendingBook, interest, data, self.MarkInvestingDirty) - self.investingStates[interest] = obj + obj := newItemListState(le.lendingBook, interest, data, le.MarkInvestingDirty) + le.investingStates[interest] = obj } return interest } -func (self *lendingExchangeState) getBestBorrowingInterest(db Database) common.Hash { - trie := self.getBorrowingTrie(db) +func (le *lendingExchangeState) getBestBorrowingInterest(db Database) common.Hash { + trie := le.getBorrowingTrie(db) encKey, encValue, err := trie.TryGetBestRightKeyAndValue() if err != nil { - log.Error("Failed find best key bid trie ", "orderbook", self.lendingBook.Hex()) + log.Error("Failed find best key bid trie ", "orderbook", le.lendingBook.Hex()) return EmptyHash } if len(encKey) == 0 || len(encValue) == 0 { @@ -570,23 +572,23 @@ func (self *lendingExchangeState) getBestBorrowingInterest(db Database) common.H } // Insert into the live set. interest := common.BytesToHash(encKey) - if _, exist := self.borrowingStates[interest]; !exist { + if _, exist := le.borrowingStates[interest]; !exist { var data itemList if err := rlp.DecodeBytes(encValue, &data); err != nil { log.Error("Failed to decode state get best bid trie", "err", err) return EmptyHash } - obj := newItemListState(self.lendingBook, interest, data, self.MarkBorrowingDirty) - self.borrowingStates[interest] = obj + obj := newItemListState(le.lendingBook, interest, data, le.MarkBorrowingDirty) + le.borrowingStates[interest] = obj } return interest } -func (self *lendingExchangeState) getLowestLiquidationTime(db Database) (common.Hash, *liquidationTimeState) { - trie := self.getLiquidationTimeTrie(db) +func (le *lendingExchangeState) getLowestLiquidationTime(db Database) (common.Hash, *liquidationTimeState) { + trie := le.getLiquidationTimeTrie(db) encKey, encValue, err := trie.TryGetBestLeftKeyAndValue() if err != nil { - log.Error("Failed find best liquidation time trie ", "orderBook", self.lendingBook.Hex()) + log.Error("Failed find best liquidation time trie ", "orderBook", le.lendingBook.Hex()) return EmptyHash, nil } if len(encKey) == 0 || len(encValue) == 0 { @@ -594,15 +596,15 @@ func (self *lendingExchangeState) getLowestLiquidationTime(db Database) (common. return EmptyHash, nil } price := common.BytesToHash(encKey) - obj, exist := self.liquidationTimeStates[price] + obj, exist := le.liquidationTimeStates[price] if !exist { var data itemList if err := rlp.DecodeBytes(encValue, &data); err != nil { log.Error("Failed to decode state get liquidation time trie", "err", err) return EmptyHash, nil } - obj = newLiquidationTimeState(self.lendingBook, price, data, self.MarkLiquidationTimeDirty) - self.liquidationTimeStates[price] = obj + obj = newLiquidationTimeState(le.lendingBook, price, data, le.MarkLiquidationTimeDirty) + le.liquidationTimeStates[price] = obj } if obj.empty() { return EmptyHash, nil @@ -610,193 +612,194 @@ func (self *lendingExchangeState) getLowestLiquidationTime(db Database) (common. return price, obj } -func (self *lendingExchangeState) deepCopy(db *LendingStateDB, onDirty func(hash common.Hash)) *lendingExchangeState { - stateExchanges := newStateExchanges(db, self.lendingBook, self.data, onDirty) - if self.investingTrie != nil { - stateExchanges.investingTrie = db.db.CopyTrie(self.investingTrie) +func (le *lendingExchangeState) deepCopy(db *LendingStateDB, onDirty func(hash common.Hash)) *lendingExchangeState { + stateExchanges := newStateExchanges(db, le.lendingBook, le.data, onDirty) + if le.investingTrie != nil { + stateExchanges.investingTrie = db.db.CopyTrie(le.investingTrie) } - if self.borrowingTrie != nil { - stateExchanges.borrowingTrie = db.db.CopyTrie(self.borrowingTrie) + if le.borrowingTrie != nil { + stateExchanges.borrowingTrie = db.db.CopyTrie(le.borrowingTrie) } - if self.lendingItemTrie != nil { - stateExchanges.lendingItemTrie = db.db.CopyTrie(self.lendingItemTrie) + if le.lendingItemTrie != nil { + stateExchanges.lendingItemTrie = db.db.CopyTrie(le.lendingItemTrie) } - for key, value := range self.borrowingStates { - stateExchanges.borrowingStates[key] = value.deepCopy(db, self.MarkBorrowingDirty) + for key, value := range le.borrowingStates { + stateExchanges.borrowingStates[key] = value.deepCopy(db, le.MarkBorrowingDirty) } - for key := range self.borrowingStatesDirty { + for key := range le.borrowingStatesDirty { stateExchanges.borrowingStatesDirty[key] = struct{}{} } - for key, value := range self.investingStates { - stateExchanges.investingStates[key] = value.deepCopy(db, self.MarkInvestingDirty) + for key, value := range le.investingStates { + stateExchanges.investingStates[key] = value.deepCopy(db, le.MarkInvestingDirty) } - for key := range self.investingStatesDirty { + for key := range le.investingStatesDirty { stateExchanges.investingStatesDirty[key] = struct{}{} } - for key, value := range self.lendingItemStates { - stateExchanges.lendingItemStates[key] = value.deepCopy(self.MarkLendingItemDirty) + for key, value := range le.lendingItemStates { + stateExchanges.lendingItemStates[key] = value.deepCopy(le.MarkLendingItemDirty) } - for orderId := range self.lendingItemStatesDirty { + for orderId := range le.lendingItemStatesDirty { stateExchanges.lendingItemStatesDirty[orderId] = struct{}{} } - for key, value := range self.lendingTradeStates { - stateExchanges.lendingTradeStates[key] = value.deepCopy(self.MarkLendingTradeDirty) + for key, value := range le.lendingTradeStates { + stateExchanges.lendingTradeStates[key] = value.deepCopy(le.MarkLendingTradeDirty) } - for orderId := range self.lendingTradeStatesDirty { + for orderId := range le.lendingTradeStatesDirty { stateExchanges.lendingTradeStatesDirty[orderId] = struct{}{} } - for time, orderList := range self.liquidationTimeStates { - stateExchanges.liquidationTimeStates[time] = orderList.deepCopy(db, self.MarkLiquidationTimeDirty) + for time, orderList := range le.liquidationTimeStates { + stateExchanges.liquidationTimeStates[time] = orderList.deepCopy(db, le.MarkLiquidationTimeDirty) } - for time := range self.liquidationTimestatesDirty { + for time := range le.liquidationTimestatesDirty { stateExchanges.liquidationTimestatesDirty[time] = struct{}{} } return stateExchanges } // Returns the address of the contract/tradeId -func (self *lendingExchangeState) Hash() common.Hash { - return self.lendingBook +func (le *lendingExchangeState) Hash() common.Hash { + return le.lendingBook } -func (self *lendingExchangeState) setNonce(nonce uint64) { - self.data.Nonce = nonce - if self.onDirty != nil { - self.onDirty(self.Hash()) - self.onDirty = nil +func (le *lendingExchangeState) setNonce(nonce uint64) { + le.data.Nonce = nonce + if le.onDirty != nil { + le.onDirty(le.Hash()) + le.onDirty = nil } } -func (self *lendingExchangeState) Nonce() uint64 { - return self.data.Nonce +func (le *lendingExchangeState) Nonce() uint64 { + return le.data.Nonce } -func (self *lendingExchangeState) setTradeNonce(nonce uint64) { - self.data.TradeNonce = nonce - if self.onDirty != nil { - self.onDirty(self.Hash()) - self.onDirty = nil +func (le *lendingExchangeState) setTradeNonce(nonce uint64) { + le.data.TradeNonce = nonce + if le.onDirty != nil { + le.onDirty(le.Hash()) + le.onDirty = nil } } -func (self *lendingExchangeState) TradeNonce() uint64 { - return self.data.TradeNonce + +func (le *lendingExchangeState) TradeNonce() uint64 { + return le.data.TradeNonce } -func (self *lendingExchangeState) removeInvestingOrderList(db Database, stateOrderList *itemListState) { - self.setError(self.investingTrie.TryDelete(stateOrderList.key[:])) +func (le *lendingExchangeState) removeInvestingOrderList(db Database, stateOrderList *itemListState) { + le.setError(le.investingTrie.TryDelete(stateOrderList.key[:])) } -func (self *lendingExchangeState) removeBorrowingOrderList(db Database, stateOrderList *itemListState) { - self.setError(self.borrowingTrie.TryDelete(stateOrderList.key[:])) +func (le *lendingExchangeState) removeBorrowingOrderList(db Database, stateOrderList *itemListState) { + le.setError(le.borrowingTrie.TryDelete(stateOrderList.key[:])) } -func (self *lendingExchangeState) createInvestingOrderList(db Database, price common.Hash) (newobj *itemListState) { - newobj = newItemListState(self.lendingBook, price, itemList{Volume: Zero}, self.MarkInvestingDirty) - self.investingStates[price] = newobj - self.investingStatesDirty[price] = struct{}{} +func (le *lendingExchangeState) createInvestingOrderList(db Database, price common.Hash) (newobj *itemListState) { + newobj = newItemListState(le.lendingBook, price, itemList{Volume: Zero}, le.MarkInvestingDirty) + le.investingStates[price] = newobj + le.investingStatesDirty[price] = struct{}{} data, err := rlp.EncodeToBytes(newobj) if err != nil { panic(fmt.Errorf("can't encode order list object at %x: %v", price[:], err)) } - self.setError(self.getInvestingTrie(db).TryUpdate(price[:], data)) - if self.onDirty != nil { - self.onDirty(self.Hash()) - self.onDirty = nil + le.setError(le.getInvestingTrie(db).TryUpdate(price[:], data)) + if le.onDirty != nil { + le.onDirty(le.Hash()) + le.onDirty = nil } return newobj } -func (self *lendingExchangeState) MarkBorrowingDirty(price common.Hash) { - self.borrowingStatesDirty[price] = struct{}{} - if self.onDirty != nil { - self.onDirty(self.Hash()) - self.onDirty = nil +func (le *lendingExchangeState) MarkBorrowingDirty(price common.Hash) { + le.borrowingStatesDirty[price] = struct{}{} + if le.onDirty != nil { + le.onDirty(le.Hash()) + le.onDirty = nil } } -func (self *lendingExchangeState) MarkInvestingDirty(price common.Hash) { - self.investingStatesDirty[price] = struct{}{} - if self.onDirty != nil { - self.onDirty(self.Hash()) - self.onDirty = nil +func (le *lendingExchangeState) MarkInvestingDirty(price common.Hash) { + le.investingStatesDirty[price] = struct{}{} + if le.onDirty != nil { + le.onDirty(le.Hash()) + le.onDirty = nil } } -func (self *lendingExchangeState) MarkLendingItemDirty(lending common.Hash) { - self.lendingItemStatesDirty[lending] = struct{}{} - if self.onDirty != nil { - self.onDirty(self.Hash()) - self.onDirty = nil +func (le *lendingExchangeState) MarkLendingItemDirty(lending common.Hash) { + le.lendingItemStatesDirty[lending] = struct{}{} + if le.onDirty != nil { + le.onDirty(le.Hash()) + le.onDirty = nil } } -func (self *lendingExchangeState) MarkLendingTradeDirty(tradeId common.Hash) { - self.lendingTradeStatesDirty[tradeId] = struct{}{} - if self.onDirty != nil { - self.onDirty(self.Hash()) - self.onDirty = nil +func (le *lendingExchangeState) MarkLendingTradeDirty(tradeId common.Hash) { + le.lendingTradeStatesDirty[tradeId] = struct{}{} + if le.onDirty != nil { + le.onDirty(le.Hash()) + le.onDirty = nil } } -func (self *lendingExchangeState) MarkLiquidationTimeDirty(orderId common.Hash) { - self.liquidationTimestatesDirty[orderId] = struct{}{} - if self.onDirty != nil { - self.onDirty(self.Hash()) - self.onDirty = nil +func (le *lendingExchangeState) MarkLiquidationTimeDirty(orderId common.Hash) { + le.liquidationTimestatesDirty[orderId] = struct{}{} + if le.onDirty != nil { + le.onDirty(le.Hash()) + le.onDirty = nil } } -func (self *lendingExchangeState) createBorrowingOrderList(db Database, price common.Hash) (newobj *itemListState) { - newobj = newItemListState(self.lendingBook, price, itemList{Volume: Zero}, self.MarkBorrowingDirty) - self.borrowingStates[price] = newobj - self.borrowingStatesDirty[price] = struct{}{} +func (le *lendingExchangeState) createBorrowingOrderList(db Database, price common.Hash) (newobj *itemListState) { + newobj = newItemListState(le.lendingBook, price, itemList{Volume: Zero}, le.MarkBorrowingDirty) + le.borrowingStates[price] = newobj + le.borrowingStatesDirty[price] = struct{}{} data, err := rlp.EncodeToBytes(newobj) if err != nil { panic(fmt.Errorf("can't encode order list object at %x: %v", price[:], err)) } - self.setError(self.getBorrowingTrie(db).TryUpdate(price[:], data)) - if self.onDirty != nil { - self.onDirty(self.Hash()) - self.onDirty = nil + le.setError(le.getBorrowingTrie(db).TryUpdate(price[:], data)) + if le.onDirty != nil { + le.onDirty(le.Hash()) + le.onDirty = nil } return newobj } -func (self *lendingExchangeState) createLendingItem(db Database, orderId common.Hash, order LendingItem) (newobj *lendingItemState) { - newobj = newLendinItemState(self.lendingBook, orderId, order, self.MarkLendingItemDirty) +func (le *lendingExchangeState) createLendingItem(db Database, orderId common.Hash, order LendingItem) (newobj *lendingItemState) { + newobj = newLendinItemState(le.lendingBook, orderId, order, le.MarkLendingItemDirty) orderIdHash := common.BigToHash(new(big.Int).SetUint64(order.LendingId)) - self.lendingItemStates[orderIdHash] = newobj - self.lendingItemStatesDirty[orderIdHash] = struct{}{} - if self.onDirty != nil { - self.onDirty(self.lendingBook) - self.onDirty = nil + le.lendingItemStates[orderIdHash] = newobj + le.lendingItemStatesDirty[orderIdHash] = struct{}{} + if le.onDirty != nil { + le.onDirty(le.lendingBook) + le.onDirty = nil } return newobj } -func (self *lendingExchangeState) createLiquidationTime(db Database, time common.Hash) (newobj *liquidationTimeState) { - newobj = newLiquidationTimeState(time, self.lendingBook, itemList{Volume: Zero}, self.MarkLiquidationTimeDirty) - self.liquidationTimeStates[time] = newobj - self.liquidationTimestatesDirty[time] = struct{}{} +func (le *lendingExchangeState) createLiquidationTime(db Database, time common.Hash) (newobj *liquidationTimeState) { + newobj = newLiquidationTimeState(time, le.lendingBook, itemList{Volume: Zero}, le.MarkLiquidationTimeDirty) + le.liquidationTimeStates[time] = newobj + le.liquidationTimestatesDirty[time] = struct{}{} data, err := rlp.EncodeToBytes(newobj) if err != nil { panic(fmt.Errorf("can't encode liquidation time at %x: %v", time[:], err)) } - self.setError(self.getLiquidationTimeTrie(db).TryUpdate(time[:], data)) - if self.onDirty != nil { - self.onDirty(self.lendingBook) - self.onDirty = nil + le.setError(le.getLiquidationTimeTrie(db).TryUpdate(time[:], data)) + if le.onDirty != nil { + le.onDirty(le.lendingBook) + le.onDirty = nil } return newobj } -func (self *lendingExchangeState) insertLendingTrade(tradeId common.Hash, order LendingTrade) (newobj *lendingTradeState) { - newobj = newLendingTradeState(self.lendingBook, tradeId, order, self.MarkLendingTradeDirty) - self.lendingTradeStates[tradeId] = newobj - self.lendingTradeStatesDirty[tradeId] = struct{}{} - if self.onDirty != nil { - self.onDirty(self.lendingBook) - self.onDirty = nil +func (le *lendingExchangeState) insertLendingTrade(tradeId common.Hash, order LendingTrade) (newobj *lendingTradeState) { + newobj = newLendingTradeState(le.lendingBook, tradeId, order, le.MarkLendingTradeDirty) + le.lendingTradeStates[tradeId] = newobj + le.lendingTradeStatesDirty[tradeId] = struct{}{} + if le.onDirty != nil { + le.onDirty(le.lendingBook) + le.onDirty = nil } return newobj } diff --git a/XDCxlending/lendingstate/state_lendingitem.go b/XDCxlending/lendingstate/state_lendingitem.go index 10d95ef68b..ef9d193653 100644 --- a/XDCxlending/lendingstate/state_lendingitem.go +++ b/XDCxlending/lendingstate/state_lendingitem.go @@ -31,8 +31,8 @@ type lendingItemState struct { onDirty func(orderId common.Hash) // Callback method to mark a state object newly dirty } -func (s *lendingItemState) empty() bool { - return s.data.Quantity == nil || s.data.Quantity.Cmp(Zero) == 0 +func (li *lendingItemState) empty() bool { + return li.data.Quantity == nil || li.data.Quantity.Cmp(Zero) == 0 } func newLendinItemState(orderBook common.Hash, orderId common.Hash, data LendingItem, onDirty func(orderId common.Hash)) *lendingItemState { @@ -45,23 +45,23 @@ func newLendinItemState(orderBook common.Hash, orderId common.Hash, data Lending } // EncodeRLP implements rlp.Encoder. -func (c *lendingItemState) EncodeRLP(w io.Writer) error { - return rlp.Encode(w, c.data) +func (li *lendingItemState) EncodeRLP(w io.Writer) error { + return rlp.Encode(w, li.data) } -func (self *lendingItemState) deepCopy(onDirty func(orderId common.Hash)) *lendingItemState { - stateOrderList := newLendinItemState(self.orderBook, self.orderId, self.data, onDirty) +func (li *lendingItemState) deepCopy(onDirty func(orderId common.Hash)) *lendingItemState { + stateOrderList := newLendinItemState(li.orderBook, li.orderId, li.data, onDirty) return stateOrderList } -func (self *lendingItemState) setVolume(volume *big.Int) { - self.data.Quantity = volume - if self.onDirty != nil { - self.onDirty(self.orderId) - self.onDirty = nil +func (li *lendingItemState) setVolume(volume *big.Int) { + li.data.Quantity = volume + if li.onDirty != nil { + li.onDirty(li.orderId) + li.onDirty = nil } } -func (self *lendingItemState) Quantity() *big.Int { - return self.data.Quantity +func (li *lendingItemState) Quantity() *big.Int { + return li.data.Quantity } diff --git a/XDCxlending/lendingstate/state_lendingtrade.go b/XDCxlending/lendingstate/state_lendingtrade.go index 893a6063eb..ab3ce84e2d 100644 --- a/XDCxlending/lendingstate/state_lendingtrade.go +++ b/XDCxlending/lendingstate/state_lendingtrade.go @@ -17,10 +17,11 @@ package lendingstate import ( - "github.com/XinFinOrg/XDPoSChain/common" - "github.com/XinFinOrg/XDPoSChain/rlp" "io" "math/big" + + "github.com/XinFinOrg/XDPoSChain/common" + "github.com/XinFinOrg/XDPoSChain/rlp" ) type lendingTradeState struct { @@ -30,8 +31,8 @@ type lendingTradeState struct { onDirty func(orderId common.Hash) // Callback method to mark a state object newly dirty } -func (s *lendingTradeState) empty() bool { - return s.data.Amount.Sign() == 0 +func (lt *lendingTradeState) empty() bool { + return lt.data.Amount.Sign() == 0 } func newLendingTradeState(orderBook common.Hash, tradeId common.Hash, data LendingTrade, onDirty func(orderId common.Hash)) *lendingTradeState { @@ -44,35 +45,35 @@ func newLendingTradeState(orderBook common.Hash, tradeId common.Hash, data Lendi } // EncodeRLP implements rlp.Encoder. -func (c *lendingTradeState) EncodeRLP(w io.Writer) error { - return rlp.Encode(w, c.data) +func (lt *lendingTradeState) EncodeRLP(w io.Writer) error { + return rlp.Encode(w, lt.data) } -func (self *lendingTradeState) deepCopy(onDirty func(orderId common.Hash)) *lendingTradeState { - stateOrderList := newLendingTradeState(self.orderBook, self.tradeId, self.data, onDirty) +func (lt *lendingTradeState) deepCopy(onDirty func(orderId common.Hash)) *lendingTradeState { + stateOrderList := newLendingTradeState(lt.orderBook, lt.tradeId, lt.data, onDirty) return stateOrderList } -func (self *lendingTradeState) SetCollateralLockedAmount(amount *big.Int) { - self.data.CollateralLockedAmount = amount - if self.onDirty != nil { - self.onDirty(self.tradeId) - self.onDirty = nil +func (lt *lendingTradeState) SetCollateralLockedAmount(amount *big.Int) { + lt.data.CollateralLockedAmount = amount + if lt.onDirty != nil { + lt.onDirty(lt.tradeId) + lt.onDirty = nil } } -func (self *lendingTradeState) SetLiquidationPrice(price *big.Int) { - self.data.LiquidationPrice = price - if self.onDirty != nil { - self.onDirty(self.tradeId) - self.onDirty = nil +func (lt *lendingTradeState) SetLiquidationPrice(price *big.Int) { + lt.data.LiquidationPrice = price + if lt.onDirty != nil { + lt.onDirty(lt.tradeId) + lt.onDirty = nil } } -func (self *lendingTradeState) SetAmount(amount *big.Int) { - self.data.Amount = amount - if self.onDirty != nil { - self.onDirty(self.tradeId) - self.onDirty = nil +func (lt *lendingTradeState) SetAmount(amount *big.Int) { + lt.data.Amount = amount + if lt.onDirty != nil { + lt.onDirty(lt.tradeId) + lt.onDirty = nil } } diff --git a/XDCxlending/lendingstate/state_liquidationtime.go b/XDCxlending/lendingstate/state_liquidationtime.go index 3661b46287..558650989a 100644 --- a/XDCxlending/lendingstate/state_liquidationtime.go +++ b/XDCxlending/lendingstate/state_liquidationtime.go @@ -19,11 +19,12 @@ package lendingstate import ( "bytes" "fmt" + "io" + "math/big" + "github.com/XinFinOrg/XDPoSChain/common" "github.com/XinFinOrg/XDPoSChain/rlp" "github.com/XinFinOrg/XDPoSChain/trie" - "io" - "math/big" ) type liquidationTimeState struct { @@ -47,8 +48,8 @@ type liquidationTimeState struct { onDirty func(time common.Hash) // Callback method to mark a state object newly dirty } -func (s *liquidationTimeState) empty() bool { - return s.data.Volume == nil || s.data.Volume.Sign() == 0 +func (lt *liquidationTimeState) empty() bool { + return lt.data.Volume == nil || lt.data.Volume.Sign() == 0 } func newLiquidationTimeState(time common.Hash, lendingBook common.Hash, data itemList, onDirty func(time common.Hash)) *liquidationTimeState { @@ -62,59 +63,59 @@ func newLiquidationTimeState(time common.Hash, lendingBook common.Hash, data ite } } -func (self *liquidationTimeState) EncodeRLP(w io.Writer) error { - return rlp.Encode(w, self.data) +func (lt *liquidationTimeState) EncodeRLP(w io.Writer) error { + return rlp.Encode(w, lt.data) } -func (self *liquidationTimeState) setError(err error) { - if self.dbErr == nil { - self.dbErr = err +func (lt *liquidationTimeState) setError(err error) { + if lt.dbErr == nil { + lt.dbErr = err } } -func (self *liquidationTimeState) getTrie(db Database) Trie { - if self.trie == nil { +func (lt *liquidationTimeState) getTrie(db Database) Trie { + if lt.trie == nil { var err error - self.trie, err = db.OpenStorageTrie(self.lendingBook, self.data.Root) + lt.trie, err = db.OpenStorageTrie(lt.lendingBook, lt.data.Root) if err != nil { - self.trie, _ = db.OpenStorageTrie(self.time, EmptyHash) - self.setError(fmt.Errorf("can't create storage trie: %v", err)) + lt.trie, _ = db.OpenStorageTrie(lt.time, EmptyHash) + lt.setError(fmt.Errorf("can't create storage trie: %v", err)) } } - return self.trie + return lt.trie } -func (self *liquidationTimeState) Exist(db Database, tradeId common.Hash) bool { - amount, exists := self.cachedStorage[tradeId] +func (lt *liquidationTimeState) Exist(db Database, tradeId common.Hash) bool { + amount, exists := lt.cachedStorage[tradeId] if exists { return true } // Load from DB in case it is missing. - enc, err := self.getTrie(db).TryGet(tradeId[:]) + enc, err := lt.getTrie(db).TryGet(tradeId[:]) if err != nil { - self.setError(err) + lt.setError(err) return false } if len(enc) > 0 { _, content, _, err := rlp.Split(enc) if err != nil { - self.setError(err) + lt.setError(err) } amount.SetBytes(content) } if (amount != common.Hash{}) { - self.cachedStorage[tradeId] = amount + lt.cachedStorage[tradeId] = amount } return true } -func (self *liquidationTimeState) getAllTradeIds(db Database) []common.Hash { +func (lt *liquidationTimeState) getAllTradeIds(db Database) []common.Hash { tradeIds := []common.Hash{} - lendingBookTrie := self.getTrie(db) + lendingBookTrie := lt.getTrie(db) if lendingBookTrie == nil { return tradeIds } - for id, value := range self.cachedStorage { + for id, value := range lt.cachedStorage { if !common.EmptyHash(value) { tradeIds = append(tradeIds, id) } @@ -122,7 +123,7 @@ func (self *liquidationTimeState) getAllTradeIds(db Database) []common.Hash { orderListIt := trie.NewIterator(lendingBookTrie.NodeIterator(nil)) for orderListIt.Next() { id := common.BytesToHash(orderListIt.Key) - if _, exist := self.cachedStorage[id]; exist { + if _, exist := lt.cachedStorage[id]; exist { continue } tradeIds = append(tradeIds, id) @@ -130,83 +131,83 @@ func (self *liquidationTimeState) getAllTradeIds(db Database) []common.Hash { return tradeIds } -func (self *liquidationTimeState) insertTradeId(db Database, tradeId common.Hash) { - self.setTradeId(tradeId, tradeId) - self.setError(self.getTrie(db).TryUpdate(tradeId[:], tradeId[:])) +func (lt *liquidationTimeState) insertTradeId(db Database, tradeId common.Hash) { + lt.setTradeId(tradeId, tradeId) + lt.setError(lt.getTrie(db).TryUpdate(tradeId[:], tradeId[:])) } -func (self *liquidationTimeState) removeTradeId(db Database, tradeId common.Hash) { - tr := self.getTrie(db) - self.setError(tr.TryDelete(tradeId[:])) - self.setTradeId(tradeId, EmptyHash) +func (lt *liquidationTimeState) removeTradeId(db Database, tradeId common.Hash) { + tr := lt.getTrie(db) + lt.setError(tr.TryDelete(tradeId[:])) + lt.setTradeId(tradeId, EmptyHash) } -func (self *liquidationTimeState) setTradeId(tradeId common.Hash, value common.Hash) { - self.cachedStorage[tradeId] = value - self.dirtyStorage[tradeId] = value +func (lt *liquidationTimeState) setTradeId(tradeId common.Hash, value common.Hash) { + lt.cachedStorage[tradeId] = value + lt.dirtyStorage[tradeId] = value - if self.onDirty != nil { - self.onDirty(self.lendingBook) - self.onDirty = nil + if lt.onDirty != nil { + lt.onDirty(lt.lendingBook) + lt.onDirty = nil } } -func (self *liquidationTimeState) updateTrie(db Database) Trie { - tr := self.getTrie(db) - for key, value := range self.dirtyStorage { - delete(self.dirtyStorage, key) +func (lt *liquidationTimeState) updateTrie(db Database) Trie { + tr := lt.getTrie(db) + for key, value := range lt.dirtyStorage { + delete(lt.dirtyStorage, key) if value == EmptyHash { - self.setError(tr.TryDelete(key[:])) + lt.setError(tr.TryDelete(key[:])) continue } v, _ := rlp.EncodeToBytes(bytes.TrimLeft(value[:], "\x00")) - self.setError(tr.TryUpdate(key[:], v)) + lt.setError(tr.TryUpdate(key[:], v)) } return tr } -func (self *liquidationTimeState) updateRoot(db Database) error { - self.updateTrie(db) - if self.dbErr != nil { - return self.dbErr +func (lt *liquidationTimeState) updateRoot(db Database) error { + lt.updateTrie(db) + if lt.dbErr != nil { + return lt.dbErr } - root, err := self.trie.Commit(nil) + root, err := lt.trie.Commit(nil) if err == nil { - self.data.Root = root + lt.data.Root = root } return err } -func (self *liquidationTimeState) deepCopy(db *LendingStateDB, onDirty func(time common.Hash)) *liquidationTimeState { - stateLendingBook := newLiquidationTimeState(self.lendingBook, self.time, self.data, onDirty) - if self.trie != nil { - stateLendingBook.trie = db.db.CopyTrie(self.trie) +func (lt *liquidationTimeState) deepCopy(db *LendingStateDB, onDirty func(time common.Hash)) *liquidationTimeState { + stateLendingBook := newLiquidationTimeState(lt.lendingBook, lt.time, lt.data, onDirty) + if lt.trie != nil { + stateLendingBook.trie = db.db.CopyTrie(lt.trie) } - for key, value := range self.dirtyStorage { + for key, value := range lt.dirtyStorage { stateLendingBook.dirtyStorage[key] = value } - for key, value := range self.cachedStorage { + for key, value := range lt.cachedStorage { stateLendingBook.cachedStorage[key] = value } return stateLendingBook } -func (c *liquidationTimeState) AddVolume(amount *big.Int) { - c.setVolume(new(big.Int).Add(c.data.Volume, amount)) +func (lt *liquidationTimeState) AddVolume(amount *big.Int) { + lt.setVolume(new(big.Int).Add(lt.data.Volume, amount)) } -func (c *liquidationTimeState) subVolume(amount *big.Int) { - c.setVolume(new(big.Int).Sub(c.data.Volume, amount)) +func (lt *liquidationTimeState) subVolume(amount *big.Int) { + lt.setVolume(new(big.Int).Sub(lt.data.Volume, amount)) } -func (self *liquidationTimeState) setVolume(volume *big.Int) { - self.data.Volume = volume - if self.onDirty != nil { - self.onDirty(self.lendingBook) - self.onDirty = nil +func (lt *liquidationTimeState) setVolume(volume *big.Int) { + lt.data.Volume = volume + if lt.onDirty != nil { + lt.onDirty(lt.lendingBook) + lt.onDirty = nil } } -func (self *liquidationTimeState) Volume() *big.Int { - return self.data.Volume +func (lt *liquidationTimeState) Volume() *big.Int { + return lt.data.Volume } diff --git a/XDCxlending/lendingstate/statedb.go b/XDCxlending/lendingstate/statedb.go index ee029a862b..e5a5cbf6ed 100644 --- a/XDCxlending/lendingstate/statedb.go +++ b/XDCxlending/lendingstate/statedb.go @@ -73,39 +73,39 @@ func New(root common.Hash, db Database) (*LendingStateDB, error) { } // setError remembers the first non-nil error it is called with. -func (self *LendingStateDB) setError(err error) { - if self.dbErr == nil { - self.dbErr = err +func (ls *LendingStateDB) setError(err error) { + if ls.dbErr == nil { + ls.dbErr = err } } -func (self *LendingStateDB) Error() error { - return self.dbErr +func (ls *LendingStateDB) Error() error { + return ls.dbErr } // Exist reports whether the given tradeId address exists in the state. // Notably this also returns true for suicided lenddinges. -func (self *LendingStateDB) Exist(addr common.Hash) bool { - return self.getLendingExchange(addr) != nil +func (ls *LendingStateDB) Exist(addr common.Hash) bool { + return ls.getLendingExchange(addr) != nil } // Empty returns whether the state object is either non-existent // or empty according to the EIP161 specification (balance = nonce = code = 0) -func (self *LendingStateDB) Empty(addr common.Hash) bool { - so := self.getLendingExchange(addr) +func (ls *LendingStateDB) Empty(addr common.Hash) bool { + so := ls.getLendingExchange(addr) return so == nil || so.empty() } -func (self *LendingStateDB) GetNonce(addr common.Hash) uint64 { - stateObject := self.getLendingExchange(addr) +func (ls *LendingStateDB) GetNonce(addr common.Hash) uint64 { + stateObject := ls.getLendingExchange(addr) if stateObject != nil { return stateObject.Nonce() } return 0 } -func (self *LendingStateDB) GetTradeNonce(addr common.Hash) uint64 { - stateObject := self.getLendingExchange(addr) +func (ls *LendingStateDB) GetTradeNonce(addr common.Hash) uint64 { + stateObject := ls.getLendingExchange(addr) if stateObject != nil { return stateObject.TradeNonce() } @@ -113,14 +113,14 @@ func (self *LendingStateDB) GetTradeNonce(addr common.Hash) uint64 { } // Database retrieves the low level database supporting the lower level trie ops. -func (self *LendingStateDB) Database() Database { - return self.db +func (ls *LendingStateDB) Database() Database { + return ls.db } -func (self *LendingStateDB) SetNonce(addr common.Hash, nonce uint64) { - stateObject := self.GetOrNewLendingExchangeObject(addr) +func (ls *LendingStateDB) SetNonce(addr common.Hash, nonce uint64) { + stateObject := ls.GetOrNewLendingExchangeObject(addr) if stateObject != nil { - self.journal = append(self.journal, nonceChange{ + ls.journal = append(ls.journal, nonceChange{ hash: addr, prev: stateObject.Nonce(), }) @@ -128,10 +128,10 @@ func (self *LendingStateDB) SetNonce(addr common.Hash, nonce uint64) { } } -func (self *LendingStateDB) SetTradeNonce(addr common.Hash, nonce uint64) { - stateObject := self.GetOrNewLendingExchangeObject(addr) +func (ls *LendingStateDB) SetTradeNonce(addr common.Hash, nonce uint64) { + stateObject := ls.GetOrNewLendingExchangeObject(addr) if stateObject != nil { - self.journal = append(self.journal, tradeNonceChange{ + ls.journal = append(ls.journal, tradeNonceChange{ hash: addr, prev: stateObject.TradeNonce(), }) @@ -139,45 +139,45 @@ func (self *LendingStateDB) SetTradeNonce(addr common.Hash, nonce uint64) { } } -func (self *LendingStateDB) InsertLendingItem(orderBook common.Hash, orderId common.Hash, order LendingItem) { +func (ls *LendingStateDB) InsertLendingItem(orderBook common.Hash, orderId common.Hash, order LendingItem) { interestHash := common.BigToHash(order.Interest) - stateExchange := self.getLendingExchange(orderBook) + stateExchange := ls.getLendingExchange(orderBook) if stateExchange == nil { - stateExchange = self.createLendingExchangeObject(orderBook) + stateExchange = ls.createLendingExchangeObject(orderBook) } var stateOrderList *itemListState switch order.Side { case Investing: - stateOrderList = stateExchange.getInvestingOrderList(self.db, interestHash) + stateOrderList = stateExchange.getInvestingOrderList(ls.db, interestHash) if stateOrderList == nil { - stateOrderList = stateExchange.createInvestingOrderList(self.db, interestHash) + stateOrderList = stateExchange.createInvestingOrderList(ls.db, interestHash) } case Borrowing: - stateOrderList = stateExchange.getBorrowingOrderList(self.db, interestHash) + stateOrderList = stateExchange.getBorrowingOrderList(ls.db, interestHash) if stateOrderList == nil { - stateOrderList = stateExchange.createBorrowingOrderList(self.db, interestHash) + stateOrderList = stateExchange.createBorrowingOrderList(ls.db, interestHash) } default: return } - self.journal = append(self.journal, insertOrder{ + ls.journal = append(ls.journal, insertOrder{ orderBook: orderBook, orderId: orderId, order: &order, }) - stateExchange.createLendingItem(self.db, orderId, order) - stateOrderList.insertLendingItem(self.db, orderId, common.BigToHash(order.Quantity)) + stateExchange.createLendingItem(ls.db, orderId, order) + stateOrderList.insertLendingItem(ls.db, orderId, common.BigToHash(order.Quantity)) stateOrderList.AddVolume(order.Quantity) } -func (self *LendingStateDB) InsertTradingItem(orderBook common.Hash, tradeId uint64, order LendingTrade) { +func (ls *LendingStateDB) InsertTradingItem(orderBook common.Hash, tradeId uint64, order LendingTrade) { tradeIdHash := common.Uint64ToHash(tradeId) - stateExchange := self.getLendingExchange(orderBook) + stateExchange := ls.getLendingExchange(orderBook) if stateExchange == nil { - stateExchange = self.createLendingExchangeObject(orderBook) + stateExchange = ls.createLendingExchangeObject(orderBook) } - prvTrade := self.GetLendingTrade(orderBook, tradeIdHash) - self.journal = append(self.journal, insertTrading{ + prvTrade := ls.GetLendingTrade(orderBook, tradeIdHash) + ls.journal = append(ls.journal, insertTrading{ orderBook: orderBook, tradeId: tradeId, prvTrade: &prvTrade, @@ -185,88 +185,90 @@ func (self *LendingStateDB) InsertTradingItem(orderBook common.Hash, tradeId uin stateExchange.insertLendingTrade(tradeIdHash, order) } -func (self *LendingStateDB) UpdateLiquidationPrice(orderBook common.Hash, tradeId uint64, price *big.Int) { +func (ls *LendingStateDB) UpdateLiquidationPrice(orderBook common.Hash, tradeId uint64, price *big.Int) { tradeIdHash := common.Uint64ToHash(tradeId) - stateExchange := self.getLendingExchange(orderBook) + stateExchange := ls.getLendingExchange(orderBook) if stateExchange == nil { - stateExchange = self.createLendingExchangeObject(orderBook) + stateExchange = ls.createLendingExchangeObject(orderBook) } - stateLendingTrade := stateExchange.getLendingTrade(self.db, tradeIdHash) - self.journal = append(self.journal, liquidationPriceChange{ + stateLendingTrade := stateExchange.getLendingTrade(ls.db, tradeIdHash) + ls.journal = append(ls.journal, liquidationPriceChange{ orderBook: orderBook, tradeId: tradeIdHash, prev: stateLendingTrade.data.LiquidationPrice, }) stateLendingTrade.SetLiquidationPrice(price) } -func (self *LendingStateDB) UpdateCollateralLockedAmount(orderBook common.Hash, tradeId uint64, amount *big.Int) { + +func (ls *LendingStateDB) UpdateCollateralLockedAmount(orderBook common.Hash, tradeId uint64, amount *big.Int) { tradeIdHash := common.Uint64ToHash(tradeId) - stateExchange := self.getLendingExchange(orderBook) + stateExchange := ls.getLendingExchange(orderBook) if stateExchange == nil { - stateExchange = self.createLendingExchangeObject(orderBook) + stateExchange = ls.createLendingExchangeObject(orderBook) } - stateLendingTrade := stateExchange.getLendingTrade(self.db, tradeIdHash) - self.journal = append(self.journal, collateralLockedAmount{ + stateLendingTrade := stateExchange.getLendingTrade(ls.db, tradeIdHash) + ls.journal = append(ls.journal, collateralLockedAmount{ orderBook: orderBook, tradeId: tradeIdHash, prev: stateLendingTrade.data.CollateralLockedAmount, }) stateLendingTrade.SetCollateralLockedAmount(amount) } -func (self *LendingStateDB) GetLendingOrder(orderBook common.Hash, orderId common.Hash) LendingItem { - stateObject := self.GetOrNewLendingExchangeObject(orderBook) + +func (ls *LendingStateDB) GetLendingOrder(orderBook common.Hash, orderId common.Hash) LendingItem { + stateObject := ls.GetOrNewLendingExchangeObject(orderBook) if stateObject == nil { return EmptyLendingOrder } - stateOrderItem := stateObject.getLendingItem(self.db, orderId) + stateOrderItem := stateObject.getLendingItem(ls.db, orderId) if stateOrderItem == nil { return EmptyLendingOrder } return stateOrderItem.data } -func (self *LendingStateDB) GetLendingTrade(orderBook common.Hash, tradeId common.Hash) LendingTrade { - stateObject := self.GetOrNewLendingExchangeObject(orderBook) +func (ls *LendingStateDB) GetLendingTrade(orderBook common.Hash, tradeId common.Hash) LendingTrade { + stateObject := ls.GetOrNewLendingExchangeObject(orderBook) if stateObject == nil { return EmptyLendingTrade } - stateOrderItem := stateObject.getLendingTrade(self.db, tradeId) + stateOrderItem := stateObject.getLendingTrade(ls.db, tradeId) if stateOrderItem == nil || stateOrderItem.empty() { return EmptyLendingTrade } return stateOrderItem.data } -func (self *LendingStateDB) SubAmountLendingItem(orderBook common.Hash, orderId common.Hash, price *big.Int, amount *big.Int, side string) error { +func (ls *LendingStateDB) SubAmountLendingItem(orderBook common.Hash, orderId common.Hash, price *big.Int, amount *big.Int, side string) error { priceHash := common.BigToHash(price) - lendingExchange := self.GetOrNewLendingExchangeObject(orderBook) + lendingExchange := ls.GetOrNewLendingExchangeObject(orderBook) if lendingExchange == nil { return fmt.Errorf("not found order book: %s", orderBook.Hex()) } var orderList *itemListState switch side { case Investing: - orderList = lendingExchange.getInvestingOrderList(self.db, priceHash) + orderList = lendingExchange.getInvestingOrderList(ls.db, priceHash) case Borrowing: - orderList = lendingExchange.getBorrowingOrderList(self.db, priceHash) + orderList = lendingExchange.getBorrowingOrderList(ls.db, priceHash) default: return fmt.Errorf("not found order type: %s", side) } if orderList == nil || orderList.empty() { return fmt.Errorf("empty orderList: order book : %s , order id : %s , key : %s", orderBook, orderId.Hex(), priceHash.Hex()) } - lendingItem := lendingExchange.getLendingItem(self.db, orderId) + lendingItem := lendingExchange.getLendingItem(ls.db, orderId) if lendingItem == nil || lendingItem.empty() { return fmt.Errorf("empty order item: order book : %s , order id : %s , key : %s", orderBook, orderId.Hex(), priceHash.Hex()) } - currentAmount := new(big.Int).SetBytes(orderList.GetOrderAmount(self.db, orderId).Bytes()[:]) + currentAmount := new(big.Int).SetBytes(orderList.GetOrderAmount(ls.db, orderId).Bytes()[:]) if currentAmount.Cmp(amount) < 0 { return fmt.Errorf("not enough order amount %s: have : %d , want : %d", orderId.Hex(), currentAmount, amount) } - self.journal = append(self.journal, subAmountOrder{ + ls.journal = append(ls.journal, subAmountOrder{ orderBook: orderBook, orderId: orderId, - order: self.GetLendingOrder(orderBook, orderId), + order: ls.GetLendingOrder(orderBook, orderId), amount: amount, }) newAmount := new(big.Int).Sub(currentAmount, amount) @@ -274,36 +276,36 @@ func (self *LendingStateDB) SubAmountLendingItem(orderBook common.Hash, orderId log.Debug("SubAmountOrderItem", "tradeId", orderId.Hex(), "side", side, "key", price.Uint64(), "amount", amount.Uint64(), "new amount", newAmount.Uint64()) orderList.subVolume(amount) if newAmount.Sign() == 0 { - orderList.removeOrderItem(self.db, orderId) + orderList.removeOrderItem(ls.db, orderId) } else { orderList.setOrderItem(orderId, common.BigToHash(newAmount)) } if orderList.empty() { switch side { case Investing: - lendingExchange.removeInvestingOrderList(self.db, orderList) + lendingExchange.removeInvestingOrderList(ls.db, orderList) case Borrowing: - lendingExchange.removeBorrowingOrderList(self.db, orderList) + lendingExchange.removeBorrowingOrderList(ls.db, orderList) default: } } return nil } -func (self *LendingStateDB) CancelLendingOrder(orderBook common.Hash, order *LendingItem) error { +func (ls *LendingStateDB) CancelLendingOrder(orderBook common.Hash, order *LendingItem) error { interestHash := common.BigToHash(order.Interest) orderIdHash := common.BigToHash(new(big.Int).SetUint64(order.LendingId)) - stateObject := self.GetOrNewLendingExchangeObject(orderBook) + stateObject := ls.GetOrNewLendingExchangeObject(orderBook) if stateObject == nil { return fmt.Errorf("not found order book: %s", orderBook.Hex()) } - lendingItem := stateObject.getLendingItem(self.db, orderIdHash) + lendingItem := stateObject.getLendingItem(ls.db, orderIdHash) var orderList *itemListState switch lendingItem.data.Side { case Investing: - orderList = stateObject.getInvestingOrderList(self.db, interestHash) + orderList = stateObject.getInvestingOrderList(ls.db, interestHash) case Borrowing: - orderList = stateObject.getBorrowingOrderList(self.db, interestHash) + orderList = stateObject.getBorrowingOrderList(ls.db, interestHash) default: return fmt.Errorf("not found order side: %s", order.Side) } @@ -316,35 +318,35 @@ func (self *LendingStateDB) CancelLendingOrder(orderBook common.Hash, order *Len if lendingItem.data.UserAddress != order.UserAddress { return fmt.Errorf("error Order UserAddress mismatch when cancel order book: %s , order id : %s , got : %s , expect : %s", orderBook, orderIdHash.Hex(), lendingItem.data.UserAddress.Hex(), order.UserAddress.Hex()) } - self.journal = append(self.journal, cancelOrder{ + ls.journal = append(ls.journal, cancelOrder{ orderBook: orderBook, orderId: orderIdHash, - order: self.GetLendingOrder(orderBook, orderIdHash), + order: ls.GetLendingOrder(orderBook, orderIdHash), }) lendingItem.setVolume(big.NewInt(0)) - currentAmount := new(big.Int).SetBytes(orderList.GetOrderAmount(self.db, orderIdHash).Bytes()[:]) + currentAmount := new(big.Int).SetBytes(orderList.GetOrderAmount(ls.db, orderIdHash).Bytes()[:]) orderList.subVolume(currentAmount) - orderList.removeOrderItem(self.db, orderIdHash) + orderList.removeOrderItem(ls.db, orderIdHash) if orderList.empty() { switch order.Side { case Investing: - stateObject.removeInvestingOrderList(self.db, orderList) + stateObject.removeInvestingOrderList(ls.db, orderList) case Borrowing: - stateObject.removeBorrowingOrderList(self.db, orderList) + stateObject.removeBorrowingOrderList(ls.db, orderList) default: } } return nil } -func (self *LendingStateDB) GetBestInvestingRate(orderBook common.Hash) (*big.Int, *big.Int) { - stateObject := self.getLendingExchange(orderBook) +func (ls *LendingStateDB) GetBestInvestingRate(orderBook common.Hash) (*big.Int, *big.Int) { + stateObject := ls.getLendingExchange(orderBook) if stateObject != nil { - investingHash := stateObject.getBestInvestingInterest(self.db) + investingHash := stateObject.getBestInvestingInterest(ls.db) if common.EmptyHash(investingHash) { return Zero, Zero } - orderList := stateObject.getInvestingOrderList(self.db, investingHash) + orderList := stateObject.getInvestingOrderList(ls.db, investingHash) if orderList == nil { log.Error("order list investing not found", "key", investingHash.Hex()) return Zero, Zero @@ -354,14 +356,14 @@ func (self *LendingStateDB) GetBestInvestingRate(orderBook common.Hash) (*big.In return Zero, Zero } -func (self *LendingStateDB) GetBestBorrowRate(orderBook common.Hash) (*big.Int, *big.Int) { - stateObject := self.getLendingExchange(orderBook) +func (ls *LendingStateDB) GetBestBorrowRate(orderBook common.Hash) (*big.Int, *big.Int) { + stateObject := ls.getLendingExchange(orderBook) if stateObject != nil { - priceHash := stateObject.getBestBorrowingInterest(self.db) + priceHash := stateObject.getBestBorrowingInterest(ls.db) if common.EmptyHash(priceHash) { return Zero, Zero } - orderList := stateObject.getBorrowingOrderList(self.db, priceHash) + orderList := stateObject.getBorrowingOrderList(ls.db, priceHash) if orderList == nil { log.Error("order list ask not found", "key", priceHash.Hex()) return Zero, Zero @@ -371,25 +373,25 @@ func (self *LendingStateDB) GetBestBorrowRate(orderBook common.Hash) (*big.Int, return Zero, Zero } -func (self *LendingStateDB) GetBestLendingIdAndAmount(orderBook common.Hash, price *big.Int, side string) (common.Hash, *big.Int, error) { - stateObject := self.GetOrNewLendingExchangeObject(orderBook) +func (ls *LendingStateDB) GetBestLendingIdAndAmount(orderBook common.Hash, price *big.Int, side string) (common.Hash, *big.Int, error) { + stateObject := ls.GetOrNewLendingExchangeObject(orderBook) if stateObject != nil { var stateOrderList *itemListState switch side { case Investing: - stateOrderList = stateObject.getInvestingOrderList(self.db, common.BigToHash(price)) + stateOrderList = stateObject.getInvestingOrderList(ls.db, common.BigToHash(price)) case Borrowing: - stateOrderList = stateObject.getBorrowingOrderList(self.db, common.BigToHash(price)) + stateOrderList = stateObject.getBorrowingOrderList(ls.db, common.BigToHash(price)) default: return EmptyHash, Zero, fmt.Errorf("not found side: %s", side) } if stateOrderList != nil { - key, _, err := stateOrderList.getTrie(self.db).TryGetBestLeftKeyAndValue() + key, _, err := stateOrderList.getTrie(ls.db).TryGetBestLeftKeyAndValue() if err != nil { return EmptyHash, Zero, err } orderId := common.BytesToHash(key) - amount := stateOrderList.GetOrderAmount(self.db, orderId) + amount := stateOrderList.GetOrderAmount(ls.db, orderId) return orderId, new(big.Int).SetBytes(amount.Bytes()), nil } return EmptyHash, Zero, fmt.Errorf("not found order list with orderBook: %s , key : %d , side : %s", orderBook.Hex(), price, side) @@ -398,25 +400,25 @@ func (self *LendingStateDB) GetBestLendingIdAndAmount(orderBook common.Hash, pri } // updateLendingExchange writes the given object to the trie. -func (self *LendingStateDB) updateLendingExchange(stateObject *lendingExchangeState) { +func (ls *LendingStateDB) updateLendingExchange(stateObject *lendingExchangeState) { addr := stateObject.Hash() data, err := rlp.EncodeToBytes(stateObject) if err != nil { panic(fmt.Errorf("can't encode object at %x: %v", addr[:], err)) } - self.setError(self.trie.TryUpdate(addr[:], data)) + ls.setError(ls.trie.TryUpdate(addr[:], data)) } // Retrieve a state object given my the address. Returns nil if not found. -func (self *LendingStateDB) getLendingExchange(addr common.Hash) (stateObject *lendingExchangeState) { +func (ls *LendingStateDB) getLendingExchange(addr common.Hash) (stateObject *lendingExchangeState) { // Prefer 'live' objects. - if obj := self.lendingExchangeStates[addr]; obj != nil { + if obj := ls.lendingExchangeStates[addr]; obj != nil { return obj } // Load the object from the database. - enc, err := self.trie.TryGet(addr[:]) + enc, err := ls.trie.TryGet(addr[:]) if len(enc) == 0 { - self.setError(err) + ls.setError(err) return nil } var data lendingObject @@ -425,176 +427,176 @@ func (self *LendingStateDB) getLendingExchange(addr common.Hash) (stateObject *l return nil } // Insert into the live set. - obj := newStateExchanges(self, addr, data, self.MarkLendingExchangeObjectDirty) - self.lendingExchangeStates[addr] = obj + obj := newStateExchanges(ls, addr, data, ls.MarkLendingExchangeObjectDirty) + ls.lendingExchangeStates[addr] = obj return obj } -func (self *LendingStateDB) setLendingExchangeObject(object *lendingExchangeState) { - self.lendingExchangeStates[object.Hash()] = object - self.lendingExchangeStatesDirty[object.Hash()] = struct{}{} +func (ls *LendingStateDB) setLendingExchangeObject(object *lendingExchangeState) { + ls.lendingExchangeStates[object.Hash()] = object + ls.lendingExchangeStatesDirty[object.Hash()] = struct{}{} } // Retrieve a state object or create a new state object if nil. -func (self *LendingStateDB) GetOrNewLendingExchangeObject(addr common.Hash) *lendingExchangeState { - stateExchangeObject := self.getLendingExchange(addr) +func (ls *LendingStateDB) GetOrNewLendingExchangeObject(addr common.Hash) *lendingExchangeState { + stateExchangeObject := ls.getLendingExchange(addr) if stateExchangeObject == nil { - stateExchangeObject = self.createLendingExchangeObject(addr) + stateExchangeObject = ls.createLendingExchangeObject(addr) } return stateExchangeObject } // MarkStateLendObjectDirty adds the specified object to the dirty map to avoid costly // state object cache iteration to find a handful of modified ones. -func (self *LendingStateDB) MarkLendingExchangeObjectDirty(addr common.Hash) { - self.lendingExchangeStatesDirty[addr] = struct{}{} +func (ls *LendingStateDB) MarkLendingExchangeObjectDirty(addr common.Hash) { + ls.lendingExchangeStatesDirty[addr] = struct{}{} } // createStateOrderListObject creates a new state object. If there is an existing tradeId with // the given address, it is overwritten and returned as the second return value. -func (self *LendingStateDB) createLendingExchangeObject(hash common.Hash) (newobj *lendingExchangeState) { - newobj = newStateExchanges(self, hash, lendingObject{}, self.MarkLendingExchangeObjectDirty) +func (ls *LendingStateDB) createLendingExchangeObject(hash common.Hash) (newobj *lendingExchangeState) { + newobj = newStateExchanges(ls, hash, lendingObject{}, ls.MarkLendingExchangeObjectDirty) newobj.setNonce(0) // sets the object to dirty - self.setLendingExchangeObject(newobj) + ls.setLendingExchangeObject(newobj) return newobj } // Copy creates a deep, independent copy of the state. // Snapshots of the copied state cannot be applied to the copy. -func (self *LendingStateDB) Copy() *LendingStateDB { - self.lock.Lock() - defer self.lock.Unlock() +func (ls *LendingStateDB) Copy() *LendingStateDB { + ls.lock.Lock() + defer ls.lock.Unlock() // Copy all the basic fields, initialize the memory ones state := &LendingStateDB{ - db: self.db, - trie: self.db.CopyTrie(self.trie), - lendingExchangeStates: make(map[common.Hash]*lendingExchangeState, len(self.lendingExchangeStatesDirty)), - lendingExchangeStatesDirty: make(map[common.Hash]struct{}, len(self.lendingExchangeStatesDirty)), + db: ls.db, + trie: ls.db.CopyTrie(ls.trie), + lendingExchangeStates: make(map[common.Hash]*lendingExchangeState, len(ls.lendingExchangeStatesDirty)), + lendingExchangeStatesDirty: make(map[common.Hash]struct{}, len(ls.lendingExchangeStatesDirty)), } // Copy the dirty states, logs, and preimages - for addr := range self.lendingExchangeStatesDirty { + for addr := range ls.lendingExchangeStatesDirty { state.lendingExchangeStatesDirty[addr] = struct{}{} } - for addr, exchangeObject := range self.lendingExchangeStates { + for addr, exchangeObject := range ls.lendingExchangeStates { state.lendingExchangeStates[addr] = exchangeObject.deepCopy(state, state.MarkLendingExchangeObjectDirty) } return state } -func (s *LendingStateDB) clearJournalAndRefund() { - s.journal = nil - s.validRevisions = s.validRevisions[:0] +func (ls *LendingStateDB) clearJournalAndRefund() { + ls.journal = nil + ls.validRevisions = ls.validRevisions[:0] } // Snapshot returns an identifier for the current revision of the state. -func (self *LendingStateDB) Snapshot() int { - id := self.nextRevisionId - self.nextRevisionId++ - self.validRevisions = append(self.validRevisions, revision{id, len(self.journal)}) +func (ls *LendingStateDB) Snapshot() int { + id := ls.nextRevisionId + ls.nextRevisionId++ + ls.validRevisions = append(ls.validRevisions, revision{id, len(ls.journal)}) return id } // RevertToSnapshot reverts all state changes made since the given revision. -func (self *LendingStateDB) RevertToSnapshot(revid int) { +func (ls *LendingStateDB) RevertToSnapshot(revid int) { // Find the snapshot in the stack of valid snapshots. - idx := sort.Search(len(self.validRevisions), func(i int) bool { - return self.validRevisions[i].id >= revid + idx := sort.Search(len(ls.validRevisions), func(i int) bool { + return ls.validRevisions[i].id >= revid }) - if idx == len(self.validRevisions) || self.validRevisions[idx].id != revid { + if idx == len(ls.validRevisions) || ls.validRevisions[idx].id != revid { panic(fmt.Errorf("revision id %v cannot be reverted", revid)) } - snapshot := self.validRevisions[idx].journalIndex + snapshot := ls.validRevisions[idx].journalIndex // Replay the journal to undo changes. - for i := len(self.journal) - 1; i >= snapshot; i-- { - self.journal[i].undo(self) + for i := len(ls.journal) - 1; i >= snapshot; i-- { + ls.journal[i].undo(ls) } - self.journal = self.journal[:snapshot] + ls.journal = ls.journal[:snapshot] // Remove invalidated snapshots from the stack. - self.validRevisions = self.validRevisions[:idx] + ls.validRevisions = ls.validRevisions[:idx] } // Finalise finalises the state by removing the self destructed objects // and clears the journal as well as the refunds. -func (s *LendingStateDB) Finalise() { +func (ls *LendingStateDB) Finalise() { // Commit objects to the trie. - for addr, stateObject := range s.lendingExchangeStates { - if _, isDirty := s.lendingExchangeStatesDirty[addr]; isDirty { + for addr, stateObject := range ls.lendingExchangeStates { + if _, isDirty := ls.lendingExchangeStatesDirty[addr]; isDirty { // Write any storage changes in the state object to its storage trie. - err := stateObject.updateInvestingRoot(s.db) + err := stateObject.updateInvestingRoot(ls.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) - stateObject.updateLiquidationTimeRoot(s.db) + stateObject.updateBorrowingRoot(ls.db) + stateObject.updateOrderRoot(ls.db) + stateObject.updateLendingTradeRoot(ls.db) + stateObject.updateLiquidationTimeRoot(ls.db) // Update the object in the main tradeId trie. - s.updateLendingExchange(stateObject) + ls.updateLendingExchange(stateObject) //delete(s.investingStatesDirty, addr) } } - s.clearJournalAndRefund() + ls.clearJournalAndRefund() } // IntermediateRoot computes the current root orderBook of the state trie. // It is called in between transactions to get the root orderBook that // goes into transaction receipts. -func (s *LendingStateDB) IntermediateRoot() common.Hash { - s.Finalise() - return s.trie.Hash() +func (ls *LendingStateDB) IntermediateRoot() common.Hash { + ls.Finalise() + return ls.trie.Hash() } // Commit writes the state to the underlying in-memory trie database. -func (s *LendingStateDB) Commit() (root common.Hash, err error) { - defer s.clearJournalAndRefund() +func (ls *LendingStateDB) Commit() (root common.Hash, err error) { + defer ls.clearJournalAndRefund() // Commit objects to the trie. - for addr, stateObject := range s.lendingExchangeStates { - if _, isDirty := s.lendingExchangeStatesDirty[addr]; isDirty { + for addr, stateObject := range ls.lendingExchangeStates { + if _, isDirty := ls.lendingExchangeStatesDirty[addr]; isDirty { // Write any storage changes in the state object to its storage trie. - if err := stateObject.CommitInvestingTrie(s.db); err != nil { + if err := stateObject.CommitInvestingTrie(ls.db); err != nil { return EmptyHash, err } - if err := stateObject.CommitBorrowingTrie(s.db); err != nil { + if err := stateObject.CommitBorrowingTrie(ls.db); err != nil { return EmptyHash, err } - if err := stateObject.CommitLendingItemTrie(s.db); err != nil { + if err := stateObject.CommitLendingItemTrie(ls.db); err != nil { return EmptyHash, err } - if err := stateObject.CommitLendingTradeTrie(s.db); err != nil { + if err := stateObject.CommitLendingTradeTrie(ls.db); err != nil { return EmptyHash, err } - if err := stateObject.CommitLiquidationTimeTrie(s.db); err != nil { + if err := stateObject.CommitLiquidationTimeTrie(ls.db); err != nil { return EmptyHash, err } // Update the object in the main tradeId trie. - s.updateLendingExchange(stateObject) - delete(s.lendingExchangeStatesDirty, addr) + ls.updateLendingExchange(stateObject) + delete(ls.lendingExchangeStatesDirty, addr) } } // Write trie changes. - root, err = s.trie.Commit(func(leaf []byte, parent common.Hash) error { + root, err = ls.trie.Commit(func(leaf []byte, parent common.Hash) error { var exchange lendingObject if err := rlp.DecodeBytes(leaf, &exchange); err != nil { return nil } if exchange.InvestingRoot != EmptyRoot { - s.db.TrieDB().Reference(exchange.InvestingRoot, parent) + ls.db.TrieDB().Reference(exchange.InvestingRoot, parent) } if exchange.BorrowingRoot != EmptyRoot { - s.db.TrieDB().Reference(exchange.BorrowingRoot, parent) + ls.db.TrieDB().Reference(exchange.BorrowingRoot, parent) } if exchange.LendingItemRoot != EmptyRoot { - s.db.TrieDB().Reference(exchange.LendingItemRoot, parent) + ls.db.TrieDB().Reference(exchange.LendingItemRoot, parent) } if exchange.LendingTradeRoot != EmptyRoot { - s.db.TrieDB().Reference(exchange.LendingTradeRoot, parent) + ls.db.TrieDB().Reference(exchange.LendingTradeRoot, parent) } if exchange.LiquidationTimeRoot != EmptyRoot { - s.db.TrieDB().Reference(exchange.LiquidationTimeRoot, parent) + ls.db.TrieDB().Reference(exchange.LiquidationTimeRoot, parent) } return nil }) @@ -602,38 +604,38 @@ func (s *LendingStateDB) Commit() (root common.Hash, err error) { return root, err } -func (self *LendingStateDB) InsertLiquidationTime(lendingBook common.Hash, time *big.Int, tradeId uint64) { +func (ls *LendingStateDB) InsertLiquidationTime(lendingBook common.Hash, time *big.Int, tradeId uint64) { timeHash := common.BigToHash(time) - lendingExchangeState := self.getLendingExchange(lendingBook) + lendingExchangeState := ls.getLendingExchange(lendingBook) if lendingExchangeState == nil { - lendingExchangeState = self.createLendingExchangeObject(lendingBook) + lendingExchangeState = ls.createLendingExchangeObject(lendingBook) } - liquidationTime := lendingExchangeState.getLiquidationTimeOrderList(self.db, timeHash) + liquidationTime := lendingExchangeState.getLiquidationTimeOrderList(ls.db, timeHash) if liquidationTime == nil { - liquidationTime = lendingExchangeState.createLiquidationTime(self.db, timeHash) + liquidationTime = lendingExchangeState.createLiquidationTime(ls.db, timeHash) } - liquidationTime.insertTradeId(self.db, common.Uint64ToHash(tradeId)) + liquidationTime.insertTradeId(ls.db, common.Uint64ToHash(tradeId)) liquidationTime.AddVolume(One) } -func (self *LendingStateDB) RemoveLiquidationTime(lendingBook common.Hash, tradeId uint64, time uint64) error { +func (ls *LendingStateDB) RemoveLiquidationTime(lendingBook common.Hash, tradeId uint64, time uint64) error { timeHash := common.Uint64ToHash(time) tradeIdHash := common.Uint64ToHash(tradeId) - lendingExchangeState := self.getLendingExchange(lendingBook) + lendingExchangeState := ls.getLendingExchange(lendingBook) if lendingExchangeState == nil { return fmt.Errorf("lending book not found: %s", lendingBook.Hex()) } - liquidationTime := lendingExchangeState.getLiquidationTimeOrderList(self.db, timeHash) + liquidationTime := lendingExchangeState.getLiquidationTimeOrderList(ls.db, timeHash) if liquidationTime == nil { return fmt.Errorf("not found liquidation time: %s , %d", lendingBook.Hex(), time) } - if !liquidationTime.Exist(self.db, tradeIdHash) { - return fmt.Errorf("not exist tradeId: %s , %d , %d", lendingBook.Hex(), time, tradeId) + if !liquidationTime.Exist(ls.db, tradeIdHash) { + return fmt.Errorf("not exist tradeId: %s, %d, %d", lendingBook.Hex(), time, tradeId) } - liquidationTime.removeTradeId(self.db, tradeIdHash) + liquidationTime.removeTradeId(ls.db, tradeIdHash) liquidationTime.subVolume(One) if liquidationTime.Volume().Sign() == 0 { - err := lendingExchangeState.getLiquidationTimeTrie(self.db).TryDelete(timeHash[:]) + err := lendingExchangeState.getLiquidationTimeTrie(ls.db).TryDelete(timeHash[:]) if err != nil { log.Warn("RemoveLiquidationTime getLiquidationTimeTrie.TryDelete", "err", err, "timeHash[:]", timeHash[:]) } @@ -641,33 +643,33 @@ func (self *LendingStateDB) RemoveLiquidationTime(lendingBook common.Hash, trade return nil } -func (self *LendingStateDB) GetLowestLiquidationTime(lendingBook common.Hash, time *big.Int) (*big.Int, []common.Hash) { +func (ls *LendingStateDB) GetLowestLiquidationTime(lendingBook common.Hash, time *big.Int) (*big.Int, []common.Hash) { liquidationData := []common.Hash{} - lendingExchangeState := self.getLendingExchange(lendingBook) + lendingExchangeState := ls.getLendingExchange(lendingBook) if lendingExchangeState == nil { return common.Big0, liquidationData } - lowestPriceHash, liquidationState := lendingExchangeState.getLowestLiquidationTime(self.db) + lowestPriceHash, liquidationState := lendingExchangeState.getLowestLiquidationTime(ls.db) lowestTime := new(big.Int).SetBytes(lowestPriceHash[:]) if liquidationState != nil && lowestTime.Sign() > 0 && lowestTime.Cmp(time) <= 0 { - liquidationData = liquidationState.getAllTradeIds(self.db) + liquidationData = liquidationState.getAllTradeIds(ls.db) } return lowestTime, liquidationData } -func (self *LendingStateDB) CancelLendingTrade(orderBook common.Hash, tradeId uint64) error { +func (ls *LendingStateDB) CancelLendingTrade(orderBook common.Hash, tradeId uint64) error { tradeIdHash := common.Uint64ToHash(tradeId) - stateObject := self.GetOrNewLendingExchangeObject(orderBook) + stateObject := ls.GetOrNewLendingExchangeObject(orderBook) if stateObject == nil { return fmt.Errorf("not found order book: %s", orderBook.Hex()) } - lendingTrade := stateObject.getLendingTrade(self.db, tradeIdHash) + lendingTrade := stateObject.getLendingTrade(ls.db, tradeIdHash) if lendingTrade == nil || lendingTrade.empty() { return fmt.Errorf("lending trade empty order book: %s , trade id : %s , trade id hash : %s", orderBook, tradeIdHash.Hex(), tradeIdHash.Hex()) } - self.journal = append(self.journal, cancelTrading{ + ls.journal = append(ls.journal, cancelTrading{ orderBook: orderBook, - order: self.GetLendingTrade(orderBook, tradeIdHash), + order: ls.GetLendingTrade(orderBook, tradeIdHash), }) lendingTrade.SetAmount(Zero) return nil diff --git a/bmt/bmt.go b/bmt/bmt.go index bba4f86039..d03bc72d4e 100644 --- a/bmt/bmt.go +++ b/bmt/bmt.go @@ -150,29 +150,29 @@ func NewTreePool(hasher BaseHasher, segmentCount, capacity int) *TreePool { } // Drain drains the pool uptil it has no more than n resources -func (self *TreePool) Drain(n int) { - self.lock.Lock() - defer self.lock.Unlock() - for len(self.c) > n { - <-self.c - self.count-- +func (tp *TreePool) Drain(n int) { + tp.lock.Lock() + defer tp.lock.Unlock() + for len(tp.c) > n { + <-tp.c + tp.count-- } } // Reserve is blocking until it returns an available Tree // it reuses free Trees or creates a new one if size is not reached -func (self *TreePool) Reserve() *Tree { - self.lock.Lock() - defer self.lock.Unlock() +func (tp *TreePool) Reserve() *Tree { + tp.lock.Lock() + defer tp.lock.Unlock() var t *Tree - if self.count == self.Capacity { - return <-self.c + if tp.count == tp.Capacity { + return <-tp.c } select { - case t = <-self.c: + case t = <-tp.c: default: - t = NewTree(self.hasher, self.SegmentSize, self.SegmentCount) - self.count++ + t = NewTree(tp.hasher, tp.SegmentSize, tp.SegmentCount) + tp.count++ } return t } @@ -180,8 +180,8 @@ func (self *TreePool) Reserve() *Tree { // Release gives back a Tree to the pool. // This Tree is guaranteed to be in reusable state // does not need locking -func (self *TreePool) Release(t *Tree) { - self.c <- t // can never fail but... +func (tp *TreePool) Release(t *Tree) { + tp.c <- t // can never fail but... } // Tree is a reusable control structure representing a BMT @@ -193,17 +193,17 @@ type Tree struct { } // Draw draws the BMT (badly) -func (self *Tree) Draw(hash []byte, d int) string { +func (t *Tree) Draw(hash []byte, d int) string { var left, right []string var anc []*Node - for i, n := range self.leaves { + for i, n := range t.leaves { left = append(left, fmt.Sprintf("%v", hashstr(n.left))) if i%2 == 0 { anc = append(anc, n.parent) } right = append(right, fmt.Sprintf("%v", hashstr(n.right))) } - anc = self.leaves + anc = t.leaves var hashes [][]string for l := 0; len(anc) > 0; l++ { var nodes []*Node @@ -277,42 +277,42 @@ func NewTree(hasher BaseHasher, segmentSize, segmentCount int) *Tree { // methods needed by hash.Hash // Size returns the size -func (self *Hasher) Size() int { - return self.size +func (ha *Hasher) Size() int { + return ha.size } // BlockSize returns the block size -func (self *Hasher) BlockSize() int { - return self.blocksize +func (ha *Hasher) BlockSize() int { + return ha.blocksize } // Sum returns the hash of the buffer // hash.Hash interface Sum method appends the byte slice to the underlying // data before it calculates and returns the hash of the chunk -func (self *Hasher) Sum(b []byte) (r []byte) { - t := self.bmt - i := self.cur +func (ha *Hasher) Sum(b []byte) (r []byte) { + t := ha.bmt + i := ha.cur n := t.leaves[i] j := i // must run strictly before all nodes calculate // datanodes are guaranteed to have a parent - if len(self.segment) > self.size && i > 0 && n.parent != nil { + if len(ha.segment) > ha.size && i > 0 && n.parent != nil { n = n.parent } else { i *= 2 } - d := self.finalise(n, i) - self.writeSegment(j, self.segment, d) - c := <-self.result - self.releaseTree() + d := ha.finalise(n, i) + ha.writeSegment(j, ha.segment, d) + c := <-ha.result + ha.releaseTree() // sha3(length + BMT(pure_chunk)) - if self.blockLength == nil { + if ha.blockLength == nil { return c } - res := self.pool.hasher() + res := ha.pool.hasher() res.Reset() - res.Write(self.blockLength) + res.Write(ha.blockLength) res.Write(c) return res.Sum(nil) } @@ -321,8 +321,8 @@ func (self *Hasher) Sum(b []byte) (r []byte) { // Hash waits for the hasher result and returns it // caller must call this on a BMT Hasher being written to -func (self *Hasher) Hash() []byte { - return <-self.result +func (ha *Hasher) Hash() []byte { + return <-ha.result } // Hasher implements the io.Writer interface @@ -330,16 +330,16 @@ func (self *Hasher) Hash() []byte { // Write fills the buffer to hash // with every full segment complete launches a hasher go routine // that shoots up the BMT -func (self *Hasher) Write(b []byte) (int, error) { +func (ha *Hasher) Write(b []byte) (int, error) { l := len(b) if l <= 0 { return 0, nil } - s := self.segment - i := self.cur - count := (self.count + 1) / 2 - need := self.count*self.size - self.cur*2*self.size - size := self.size + s := ha.segment + i := ha.cur + count := (ha.count + 1) / 2 + need := ha.count*ha.size - ha.cur*2*ha.size + size := ha.size if need > size { size *= 2 } @@ -356,7 +356,7 @@ func (self *Hasher) Write(b []byte) (int, error) { // read full segments and the last possibly partial segment for need > 0 && i < count-1 { // push all finished chunks we read - self.writeSegment(i, s, self.depth) + ha.writeSegment(i, s, ha.depth) need -= size if need < 0 { size += need @@ -365,8 +365,8 @@ func (self *Hasher) Write(b []byte) (int, error) { rest += size i++ } - self.segment = s - self.cur = i + ha.segment = s + ha.cur = i // otherwise, we can assume len(s) == 0, so all buffer is read and chunk is not yet full return l, nil } @@ -376,8 +376,8 @@ func (self *Hasher) Write(b []byte) (int, error) { // ReadFrom reads from io.Reader and appends to the data to hash using Write // it reads so that chunk to hash is maximum length or reader reaches EOF // caller must Reset the hasher prior to call -func (self *Hasher) ReadFrom(r io.Reader) (m int64, err error) { - bufsize := self.size*self.count - self.size*self.cur - len(self.segment) +func (ha *Hasher) ReadFrom(r io.Reader) (m int64, err error) { + bufsize := ha.size*ha.count - ha.size*ha.cur - len(ha.segment) buf := make([]byte, bufsize) var read int for { @@ -385,7 +385,7 @@ func (self *Hasher) ReadFrom(r io.Reader) (m int64, err error) { n, err = r.Read(buf) read += n if err == io.EOF || read == len(buf) { - hash := self.Sum(buf[:n]) + hash := ha.Sum(buf[:n]) if read == len(buf) { err = NewEOC(hash) } @@ -394,7 +394,7 @@ func (self *Hasher) ReadFrom(r io.Reader) (m int64, err error) { if err != nil { break } - _, err = self.Write(buf[:n]) + _, err = ha.Write(buf[:n]) if err != nil { break } @@ -403,9 +403,9 @@ func (self *Hasher) ReadFrom(r io.Reader) (m int64, err error) { } // Reset needs to be called before writing to the hasher -func (self *Hasher) Reset() { - self.getTree() - self.blockLength = nil +func (ha *Hasher) Reset() { + ha.getTree() + ha.blockLength = nil } // Hasher implements the SwarmHash interface @@ -413,53 +413,53 @@ func (self *Hasher) Reset() { // ResetWithLength needs to be called before writing to the hasher // the argument is supposed to be the byte slice binary representation of // the legth of the data subsumed under the hash -func (self *Hasher) ResetWithLength(l []byte) { - self.Reset() - self.blockLength = l +func (ha *Hasher) ResetWithLength(l []byte) { + ha.Reset() + ha.blockLength = l } // Release gives back the Tree to the pool whereby it unlocks // it resets tree, segment and index -func (self *Hasher) releaseTree() { - if self.bmt != nil { - n := self.bmt.leaves[self.cur] +func (ha *Hasher) releaseTree() { + if ha.bmt != nil { + n := ha.bmt.leaves[ha.cur] for ; n != nil; n = n.parent { n.unbalanced = false if n.parent != nil { n.root = false } } - self.pool.Release(self.bmt) - self.bmt = nil + ha.pool.Release(ha.bmt) + ha.bmt = nil } - self.cur = 0 - self.segment = nil + ha.cur = 0 + ha.segment = nil } -func (self *Hasher) writeSegment(i int, s []byte, d int) { - h := self.pool.hasher() - n := self.bmt.leaves[i] +func (ha *Hasher) writeSegment(i int, s []byte, d int) { + h := ha.pool.hasher() + n := ha.bmt.leaves[i] - if len(s) > self.size && n.parent != nil { + if len(s) > ha.size && n.parent != nil { go func() { h.Reset() h.Write(s) s = h.Sum(nil) if n.root { - self.result <- s + ha.result <- s return } - self.run(n.parent, h, d, n.index, s) + ha.run(n.parent, h, d, n.index, s) }() return } - go self.run(n, h, d, i*2, s) + go ha.run(n, h, d, i*2, s) } -func (self *Hasher) run(n *Node, h hash.Hash, d int, i int, s []byte) { +func (ha *Hasher) run(n *Node, h hash.Hash, d int, i int, s []byte) { isLeft := i%2 == 0 for { if isLeft { @@ -480,9 +480,9 @@ func (self *Hasher) run(n *Node, h hash.Hash, d int, i int, s []byte) { s = append(n.left, n.right...) } - self.hash = s + ha.hash = s if n.root { - self.result <- s + ha.result <- s return } @@ -493,20 +493,20 @@ func (self *Hasher) run(n *Node, h hash.Hash, d int, i int, s []byte) { } // getTree obtains a BMT resource by reserving one from the pool -func (self *Hasher) getTree() *Tree { - if self.bmt != nil { - return self.bmt +func (ha *Hasher) getTree() *Tree { + if ha.bmt != nil { + return ha.bmt } - t := self.pool.Reserve() - self.bmt = t + t := ha.pool.Reserve() + ha.bmt = t return t } // atomic bool toggle implementing a concurrent reusable 2-state object // atomic addint with %2 implements atomic bool toggle // it returns true if the toggler just put it in the active/waiting state -func (self *Node) toggle() bool { - return atomic.AddInt32(&self.state, 1)%2 == 1 +func (n *Node) toggle() bool { + return atomic.AddInt32(&n.state, 1)%2 == 1 } func hashstr(b []byte) string { @@ -526,7 +526,7 @@ func depth(n int) (d int) { // finalise is following the zigzags on the tree belonging // to the final datasegment -func (self *Hasher) finalise(n *Node, i int) (d int) { +func (ha *Hasher) finalise(n *Node, i int) (d int) { isLeft := i%2 == 0 for { // when the final segment's path is going via left segments @@ -551,8 +551,8 @@ type EOC struct { } // Error returns the error string -func (self *EOC) Error() string { - return fmt.Sprintf("hasher limit reached, chunk hash: %x", self.Hash) +func (e *EOC) Error() string { + return fmt.Sprintf("hasher limit reached, chunk hash: %x", e.Hash) } // NewEOC creates new end of chunk error with the hash diff --git a/cmd/utils/customflags.go b/cmd/utils/customflags.go index 5f7833daf9..2304678344 100644 --- a/cmd/utils/customflags.go +++ b/cmd/utils/customflags.go @@ -38,12 +38,12 @@ type DirectoryString struct { Value string } -func (self *DirectoryString) String() string { - return self.Value +func (ds *DirectoryString) String() string { + return ds.Value } -func (self *DirectoryString) Set(value string) error { - self.Value = expandPath(value) +func (ds *DirectoryString) Set(value string) error { + ds.Value = expandPath(value) return nil } @@ -55,12 +55,12 @@ type DirectoryFlag struct { Usage string } -func (self DirectoryFlag) String() string { +func (df DirectoryFlag) String() string { fmtString := "%s %v\t%v" - if len(self.Value.Value) > 0 { + if len(df.Value.Value) > 0 { fmtString = "%s \"%v\"\t%v" } - return fmt.Sprintf(fmtString, prefixedNames(self.Name), self.Value.Value, self.Usage) + return fmt.Sprintf(fmtString, prefixedNames(df.Name), df.Value.Value, df.Usage) } func eachName(longName string, fn func(string)) { @@ -73,9 +73,9 @@ func eachName(longName string, fn func(string)) { // called by cli library, grabs variable from environment (if in env) // and adds variable to flag set for parsing. -func (self DirectoryFlag) Apply(set *flag.FlagSet) { - eachName(self.Name, func(name string) { - set.Var(&self.Value, self.Name, self.Usage) +func (df DirectoryFlag) Apply(set *flag.FlagSet) { + eachName(df.Name, func(name string) { + set.Var(&df.Value, df.Name, df.Usage) }) } @@ -89,16 +89,16 @@ type textMarshalerVal struct { v TextMarshaler } -func (v textMarshalerVal) String() string { - if v.v == nil { +func (t textMarshalerVal) String() string { + if t.v == nil { return "" } - text, _ := v.v.MarshalText() + text, _ := t.v.MarshalText() return string(text) } -func (v textMarshalerVal) Set(s string) error { - return v.v.UnmarshalText([]byte(s)) +func (t textMarshalerVal) Set(s string) error { + return t.v.UnmarshalText([]byte(s)) } // TextMarshalerFlag wraps a TextMarshaler value. @@ -108,17 +108,17 @@ type TextMarshalerFlag struct { Usage string } -func (f TextMarshalerFlag) GetName() string { - return f.Name +func (t TextMarshalerFlag) GetName() string { + return t.Name } -func (f TextMarshalerFlag) String() string { - return fmt.Sprintf("%s \"%v\"\t%v", prefixedNames(f.Name), f.Value, f.Usage) +func (t TextMarshalerFlag) String() string { + return fmt.Sprintf("%s \"%v\"\t%v", prefixedNames(t.Name), t.Value, t.Usage) } -func (f TextMarshalerFlag) Apply(set *flag.FlagSet) { - eachName(f.Name, func(name string) { - set.Var(textMarshalerVal{f.Value}, f.Name, f.Usage) +func (t TextMarshalerFlag) Apply(set *flag.FlagSet) { + eachName(t.Name, func(name string) { + set.Var(textMarshalerVal{t.Value}, t.Name, t.Usage) }) } @@ -142,37 +142,37 @@ type BigFlag struct { // bigValue turns *big.Int into a flag.Value type bigValue big.Int -func (b *bigValue) String() string { - if b == nil { +func (bv *bigValue) String() string { + if bv == nil { return "" } - return (*big.Int)(b).String() + return (*big.Int)(bv).String() } -func (b *bigValue) Set(s string) error { +func (bv *bigValue) Set(s string) error { int, ok := math.ParseBig256(s) if !ok { return errors.New("invalid integer syntax") } - *b = (bigValue)(*int) + *bv = (bigValue)(*int) return nil } -func (f BigFlag) GetName() string { - return f.Name +func (bf BigFlag) GetName() string { + return bf.Name } -func (f BigFlag) String() string { +func (bf BigFlag) String() string { fmtString := "%s %v\t%v" - if f.Value != nil { + if bf.Value != nil { fmtString = "%s \"%v\"\t%v" } - return fmt.Sprintf(fmtString, prefixedNames(f.Name), f.Value, f.Usage) + return fmt.Sprintf(fmtString, prefixedNames(bf.Name), bf.Value, bf.Usage) } -func (f BigFlag) Apply(set *flag.FlagSet) { - eachName(f.Name, func(name string) { - set.Var((*bigValue)(f.Value), f.Name, f.Usage) +func (bf BigFlag) Apply(set *flag.FlagSet) { + eachName(bf.Name, func(name string) { + set.Var((*bigValue)(bf.Value), bf.Name, bf.Usage) }) } @@ -207,12 +207,12 @@ func prefixedNames(fullName string) (prefixed string) { return } -func (self DirectoryFlag) GetName() string { - return self.Name +func (df DirectoryFlag) GetName() string { + return df.Name } -func (self *DirectoryFlag) Set(value string) { - self.Value.Value = value +func (df *DirectoryFlag) Set(value string) { + df.Value.Value = value } // Expands a file path diff --git a/contracts/ens/ens.go b/contracts/ens/ens.go index d12efa690c..7c47865097 100644 --- a/contracts/ens/ens.go +++ b/contracts/ens/ens.go @@ -100,45 +100,45 @@ func ensNode(name string) common.Hash { return crypto.Keccak256Hash(parentNode[:], parentLabel[:]) } -func (self *ENS) getResolver(node [32]byte) (*contract.PublicResolverSession, error) { - resolverAddr, err := self.Resolver(node) +func (e *ENS) getResolver(node [32]byte) (*contract.PublicResolverSession, error) { + resolverAddr, err := e.Resolver(node) if err != nil { return nil, err } - resolver, err := contract.NewPublicResolver(resolverAddr, self.contractBackend) + resolver, err := contract.NewPublicResolver(resolverAddr, e.contractBackend) if err != nil { return nil, err } return &contract.PublicResolverSession{ Contract: resolver, - TransactOpts: self.TransactOpts, + TransactOpts: e.TransactOpts, }, nil } -func (self *ENS) getRegistrar(node [32]byte) (*contract.FIFSRegistrarSession, error) { - registrarAddr, err := self.Owner(node) +func (e *ENS) getRegistrar(node [32]byte) (*contract.FIFSRegistrarSession, error) { + registrarAddr, err := e.Owner(node) if err != nil { return nil, err } - registrar, err := contract.NewFIFSRegistrar(registrarAddr, self.contractBackend) + registrar, err := contract.NewFIFSRegistrar(registrarAddr, e.contractBackend) if err != nil { return nil, err } return &contract.FIFSRegistrarSession{ Contract: registrar, - TransactOpts: self.TransactOpts, + TransactOpts: e.TransactOpts, }, nil } // Resolve is a non-transactional call that returns the content hash associated with a name. -func (self *ENS) Resolve(name string) (common.Hash, error) { +func (e *ENS) Resolve(name string) (common.Hash, error) { node := ensNode(name) - resolver, err := self.getResolver(node) + resolver, err := e.getResolver(node) if err != nil { return common.Hash{}, err } @@ -153,26 +153,26 @@ func (self *ENS) Resolve(name string) (common.Hash, error) { // Register registers a new domain name for the caller, making them the owner of the new name. // Only works if the registrar for the parent domain implements the FIFS registrar protocol. -func (self *ENS) Register(name string) (*types.Transaction, error) { +func (e *ENS) Register(name string) (*types.Transaction, error) { parentNode, label := ensParentNode(name) - registrar, err := self.getRegistrar(parentNode) + registrar, err := e.getRegistrar(parentNode) if err != nil { return nil, err } - return registrar.Contract.Register(&self.TransactOpts, label, self.TransactOpts.From) + return registrar.Contract.Register(&e.TransactOpts, label, e.TransactOpts.From) } // SetContentHash sets the content hash associated with a name. Only works if the caller // owns the name, and the associated resolver implements a `setContent` function. -func (self *ENS) SetContentHash(name string, hash common.Hash) (*types.Transaction, error) { +func (e *ENS) SetContentHash(name string, hash common.Hash) (*types.Transaction, error) { node := ensNode(name) - resolver, err := self.getResolver(node) + resolver, err := e.getResolver(node) if err != nil { return nil, err } - opts := self.TransactOpts + opts := e.TransactOpts opts.GasLimit = 200000 return resolver.Contract.SetContent(&opts, node, hash) } diff --git a/core/state/dump.go b/core/state/dump.go index d99b580bc4..ba4bfee0e1 100644 --- a/core/state/dump.go +++ b/core/state/dump.go @@ -39,15 +39,15 @@ type Dump struct { Accounts map[string]DumpAccount `json:"accounts"` } -func (self *StateDB) RawDump() Dump { +func (s *StateDB) RawDump() Dump { dump := Dump{ - Root: fmt.Sprintf("%x", self.trie.Hash()), + Root: fmt.Sprintf("%x", s.trie.Hash()), Accounts: make(map[string]DumpAccount), } - it := trie.NewIterator(self.trie.NodeIterator(nil)) + it := trie.NewIterator(s.trie.NodeIterator(nil)) for it.Next() { - addr := self.trie.GetKey(it.Key) + addr := s.trie.GetKey(it.Key) var data Account if err := rlp.DecodeBytes(it.Value, &data); err != nil { panic(err) @@ -59,20 +59,20 @@ func (self *StateDB) RawDump() Dump { Nonce: data.Nonce, Root: common.Bytes2Hex(data.Root[:]), CodeHash: common.Bytes2Hex(data.CodeHash), - Code: common.Bytes2Hex(obj.Code(self.db)), + Code: common.Bytes2Hex(obj.Code(s.db)), Storage: make(map[string]string), } - storageIt := trie.NewIterator(obj.getTrie(self.db).NodeIterator(nil)) + storageIt := trie.NewIterator(obj.getTrie(s.db).NodeIterator(nil)) for storageIt.Next() { - account.Storage[common.Bytes2Hex(self.trie.GetKey(storageIt.Key))] = common.Bytes2Hex(storageIt.Value) + account.Storage[common.Bytes2Hex(s.trie.GetKey(storageIt.Key))] = common.Bytes2Hex(storageIt.Value) } dump.Accounts[common.Bytes2Hex(addr)] = account } return dump } -func (self *StateDB) Dump() []byte { - json, err := json.MarshalIndent(self.RawDump(), "", " ") +func (s *StateDB) Dump() []byte { + json, err := json.MarshalIndent(s.RawDump(), "", " ") if err != nil { fmt.Println("dump err", err) } diff --git a/core/state/statedb.go b/core/state/statedb.go index 8a13f46dcb..aa2495cf40 100644 --- a/core/state/statedb.go +++ b/core/state/statedb.go @@ -86,19 +86,19 @@ type AccountInfo struct { StorageHash common.Hash } -func (self *StateDB) SubRefund(gas uint64) { - self.journal = append(self.journal, refundChange{ - prev: self.refund}) - if gas > self.refund { - panic(fmt.Sprintf("Refund counter below zero (gas: %d > refund: %d)", gas, self.refund)) +func (s *StateDB) SubRefund(gas uint64) { + s.journal = append(s.journal, refundChange{ + prev: s.refund}) + if gas > s.refund { + panic(fmt.Sprintf("Refund counter below zero (gas: %d > refund: %d)", gas, s.refund)) } - self.refund -= gas + s.refund -= gas } -func (self *StateDB) GetCommittedState(addr common.Address, hash common.Hash) common.Hash { - stateObject := self.getStateObject(addr) +func (s *StateDB) GetCommittedState(addr common.Address, hash common.Hash) common.Hash { + stateObject := s.getStateObject(addr) if stateObject != nil { - return stateObject.GetCommittedState(self.db, hash) + return stateObject.GetCommittedState(s.db, hash) } return common.Hash{} } @@ -121,44 +121,44 @@ func New(root common.Hash, db Database) (*StateDB, error) { } // setError remembers the first non-nil error it is called with. -func (self *StateDB) setError(err error) { - if self.dbErr == nil { - self.dbErr = err +func (s *StateDB) setError(err error) { + if s.dbErr == nil { + s.dbErr = err } } -func (self *StateDB) Error() error { - return self.dbErr +func (s *StateDB) Error() error { + return s.dbErr } // Reset clears out all ephemeral state objects from the state db, but keeps // the underlying state trie to avoid reloading data for the next operations. -func (self *StateDB) Reset(root common.Hash) error { - tr, err := self.db.OpenTrie(root) +func (s *StateDB) Reset(root common.Hash) error { + tr, err := s.db.OpenTrie(root) if err != nil { return err } - self.trie = tr - self.stateObjects = make(map[common.Address]*stateObject) - self.stateObjectsDirty = make(map[common.Address]struct{}) - self.thash = common.Hash{} - self.txIndex = 0 - self.logs = make(map[common.Hash][]*types.Log) - self.logSize = 0 - self.preimages = make(map[common.Hash][]byte) - self.clearJournalAndRefund() - self.accessList = newAccessList() + s.trie = tr + s.stateObjects = make(map[common.Address]*stateObject) + s.stateObjectsDirty = make(map[common.Address]struct{}) + s.thash = common.Hash{} + s.txIndex = 0 + s.logs = make(map[common.Hash][]*types.Log) + s.logSize = 0 + s.preimages = make(map[common.Hash][]byte) + s.clearJournalAndRefund() + s.accessList = newAccessList() return nil } -func (self *StateDB) AddLog(log *types.Log) { - self.journal = append(self.journal, addLogChange{txhash: self.thash}) +func (s *StateDB) AddLog(log *types.Log) { + s.journal = append(s.journal, addLogChange{txhash: s.thash}) - log.TxHash = self.thash - log.TxIndex = uint(self.txIndex) - log.Index = self.logSize - self.logs[self.thash] = append(self.logs[self.thash], log) - self.logSize++ + log.TxHash = s.thash + log.TxIndex = uint(s.txIndex) + log.Index = s.logSize + s.logs[s.thash] = append(s.logs[s.thash], log) + s.logSize++ } func (s *StateDB) GetLogs(hash common.Hash, blockHash common.Hash) []*types.Log { @@ -169,58 +169,58 @@ func (s *StateDB) GetLogs(hash common.Hash, blockHash common.Hash) []*types.Log return logs } -func (self *StateDB) Logs() []*types.Log { +func (s *StateDB) Logs() []*types.Log { var logs []*types.Log - for _, lgs := range self.logs { + for _, lgs := range s.logs { logs = append(logs, lgs...) } return logs } // AddPreimage records a SHA3 preimage seen by the VM. -func (self *StateDB) AddPreimage(hash common.Hash, preimage []byte) { - if _, ok := self.preimages[hash]; !ok { - self.journal = append(self.journal, addPreimageChange{hash: hash}) +func (s *StateDB) AddPreimage(hash common.Hash, preimage []byte) { + if _, ok := s.preimages[hash]; !ok { + s.journal = append(s.journal, addPreimageChange{hash: hash}) pi := make([]byte, len(preimage)) copy(pi, preimage) - self.preimages[hash] = pi + s.preimages[hash] = pi } } // Preimages returns a list of SHA3 preimages that have been submitted. -func (self *StateDB) Preimages() map[common.Hash][]byte { - return self.preimages +func (s *StateDB) Preimages() map[common.Hash][]byte { + return s.preimages } -func (self *StateDB) AddRefund(gas uint64) { - self.journal = append(self.journal, refundChange{prev: self.refund}) - self.refund += gas +func (s *StateDB) AddRefund(gas uint64) { + s.journal = append(s.journal, refundChange{prev: s.refund}) + s.refund += gas } // Exist reports whether the given account address exists in the state. // Notably this also returns true for suicided accounts. -func (self *StateDB) Exist(addr common.Address) bool { - return self.getStateObject(addr) != nil +func (s *StateDB) Exist(addr common.Address) bool { + return s.getStateObject(addr) != nil } // Empty returns whether the state object is either non-existent // or empty according to the EIP161 specification (balance = nonce = code = 0) -func (self *StateDB) Empty(addr common.Address) bool { - so := self.getStateObject(addr) +func (s *StateDB) Empty(addr common.Address) bool { + so := s.getStateObject(addr) return so == nil || so.empty() } // Retrieve the balance from the given address or 0 if object not found -func (self *StateDB) GetBalance(addr common.Address) *big.Int { - stateObject := self.getStateObject(addr) +func (s *StateDB) GetBalance(addr common.Address) *big.Int { + stateObject := s.getStateObject(addr) if stateObject != nil { return stateObject.Balance() } return common.Big0 } -func (self *StateDB) GetNonce(addr common.Address) uint64 { - stateObject := self.getStateObject(addr) +func (s *StateDB) GetNonce(addr common.Address) uint64 { + stateObject := s.getStateObject(addr) if stateObject != nil { return stateObject.Nonce() } @@ -230,8 +230,8 @@ func (self *StateDB) GetNonce(addr common.Address) uint64 { // GetStorageRoot retrieves the storage root from the given address or empty // if object not found. -func (self *StateDB) GetStorageRoot(addr common.Address) common.Hash { - stateObject := self.getStateObject(addr) +func (s *StateDB) GetStorageRoot(addr common.Address) common.Hash { + stateObject := s.getStateObject(addr) if stateObject != nil { return stateObject.Root() } @@ -239,45 +239,45 @@ func (self *StateDB) GetStorageRoot(addr common.Address) common.Hash { } // TxIndex returns the current transaction index set by Prepare. -func (self *StateDB) TxIndex() int { - return self.txIndex +func (s *StateDB) TxIndex() int { + return s.txIndex } -func (self *StateDB) GetCode(addr common.Address) []byte { - stateObject := self.getStateObject(addr) +func (s *StateDB) GetCode(addr common.Address) []byte { + stateObject := s.getStateObject(addr) if stateObject != nil { - return stateObject.Code(self.db) + return stateObject.Code(s.db) } return nil } -func (self *StateDB) GetCodeSize(addr common.Address) int { - stateObject := self.getStateObject(addr) +func (s *StateDB) GetCodeSize(addr common.Address) int { + stateObject := s.getStateObject(addr) if stateObject == nil { return 0 } if stateObject.code != nil { return len(stateObject.code) } - size, err := self.db.ContractCodeSize(stateObject.addrHash, common.BytesToHash(stateObject.CodeHash())) + size, err := s.db.ContractCodeSize(stateObject.addrHash, common.BytesToHash(stateObject.CodeHash())) if err != nil { - self.setError(err) + s.setError(err) } return size } -func (self *StateDB) GetCodeHash(addr common.Address) common.Hash { - stateObject := self.getStateObject(addr) +func (s *StateDB) GetCodeHash(addr common.Address) common.Hash { + stateObject := s.getStateObject(addr) if stateObject == nil { return common.Hash{} } return common.BytesToHash(stateObject.CodeHash()) } -func (self *StateDB) GetAccountInfo(addr common.Address) *AccountInfo { +func (s *StateDB) GetAccountInfo(addr common.Address) *AccountInfo { result := AccountInfo{} - stateObject := self.getStateObject(addr) + stateObject := s.getStateObject(addr) if stateObject == nil { result.Balance = common.Big0 return &result @@ -286,7 +286,7 @@ func (self *StateDB) GetAccountInfo(addr common.Address) *AccountInfo { if stateObject.code != nil { result.CodeSize = len(stateObject.code) } else { - result.CodeSize, _ = self.db.ContractCodeSize(stateObject.addrHash, common.BytesToHash(stateObject.CodeHash())) + result.CodeSize, _ = s.db.ContractCodeSize(stateObject.addrHash, common.BytesToHash(stateObject.CodeHash())) } result.Nonce = stateObject.Nonce() result.Balance = stateObject.Balance() @@ -296,32 +296,32 @@ func (self *StateDB) GetAccountInfo(addr common.Address) *AccountInfo { return &result } -func (self *StateDB) GetState(addr common.Address, bhash common.Hash) common.Hash { - stateObject := self.getStateObject(addr) +func (s *StateDB) GetState(addr common.Address, bhash common.Hash) common.Hash { + stateObject := s.getStateObject(addr) if stateObject != nil { - return stateObject.GetState(self.db, bhash) + return stateObject.GetState(s.db, bhash) } return common.Hash{} } // Database retrieves the low level database supporting the lower level trie ops. -func (self *StateDB) Database() Database { - return self.db +func (s *StateDB) Database() Database { + return s.db } // StorageTrie returns the storage trie of an account. // The return value is a copy and is nil for non-existent accounts. -func (self *StateDB) StorageTrie(addr common.Address) Trie { - stateObject := self.getStateObject(addr) +func (s *StateDB) StorageTrie(addr common.Address) Trie { + stateObject := s.getStateObject(addr) if stateObject == nil { return nil } - cpy := stateObject.deepCopy(self, nil) - return cpy.updateTrie(self.db) + cpy := stateObject.deepCopy(s, nil) + return cpy.updateTrie(s.db) } -func (self *StateDB) HasSuicided(addr common.Address) bool { - stateObject := self.getStateObject(addr) +func (s *StateDB) HasSuicided(addr common.Address) bool { + stateObject := s.getStateObject(addr) if stateObject != nil { return stateObject.suicided } @@ -333,46 +333,46 @@ func (self *StateDB) HasSuicided(addr common.Address) bool { */ // AddBalance adds amount to the account associated with addr. -func (self *StateDB) AddBalance(addr common.Address, amount *big.Int) { - stateObject := self.GetOrNewStateObject(addr) +func (s *StateDB) AddBalance(addr common.Address, amount *big.Int) { + stateObject := s.GetOrNewStateObject(addr) if stateObject != nil { stateObject.AddBalance(amount) } } // SubBalance subtracts amount from the account associated with addr. -func (self *StateDB) SubBalance(addr common.Address, amount *big.Int) { - stateObject := self.GetOrNewStateObject(addr) +func (s *StateDB) SubBalance(addr common.Address, amount *big.Int) { + stateObject := s.GetOrNewStateObject(addr) if stateObject != nil { stateObject.SubBalance(amount) } } -func (self *StateDB) SetBalance(addr common.Address, amount *big.Int) { - stateObject := self.GetOrNewStateObject(addr) +func (s *StateDB) SetBalance(addr common.Address, amount *big.Int) { + stateObject := s.GetOrNewStateObject(addr) if stateObject != nil { stateObject.SetBalance(amount) } } -func (self *StateDB) SetNonce(addr common.Address, nonce uint64) { - stateObject := self.GetOrNewStateObject(addr) +func (s *StateDB) SetNonce(addr common.Address, nonce uint64) { + stateObject := s.GetOrNewStateObject(addr) if stateObject != nil { stateObject.SetNonce(nonce) } } -func (self *StateDB) SetCode(addr common.Address, code []byte) { - stateObject := self.GetOrNewStateObject(addr) +func (s *StateDB) SetCode(addr common.Address, code []byte) { + stateObject := s.GetOrNewStateObject(addr) if stateObject != nil { stateObject.SetCode(crypto.Keccak256Hash(code), code) } } -func (self *StateDB) SetState(addr common.Address, key, value common.Hash) { - stateObject := self.GetOrNewStateObject(addr) +func (s *StateDB) SetState(addr common.Address, key, value common.Hash) { + stateObject := s.GetOrNewStateObject(addr) if stateObject != nil { - stateObject.SetState(self.db, key, value) + stateObject.SetState(s.db, key, value) } } @@ -390,12 +390,12 @@ func (s *StateDB) SetStorage(addr common.Address, storage map[common.Hash]common // // The account's state object is still available until the state is committed, // getStateObject will return a non-nil account after Suicide. -func (self *StateDB) Suicide(addr common.Address) bool { - stateObject := self.getStateObject(addr) +func (s *StateDB) Suicide(addr common.Address) bool { + stateObject := s.getStateObject(addr) if stateObject == nil { return false } - self.journal = append(self.journal, suicideChange{ + s.journal = append(s.journal, suicideChange{ account: &addr, prev: stateObject.suicided, prevbalance: new(big.Int).Set(stateObject.Balance()), @@ -411,34 +411,34 @@ func (self *StateDB) Suicide(addr common.Address) bool { // // updateStateObject writes the given object to the trie. -func (self *StateDB) updateStateObject(stateObject *stateObject) { +func (s *StateDB) updateStateObject(stateObject *stateObject) { addr := stateObject.Address() data, err := rlp.EncodeToBytes(stateObject) if err != nil { panic(fmt.Errorf("can't encode object at %x: %v", addr[:], err)) } - self.setError(self.trie.TryUpdate(addr[:], data)) + s.setError(s.trie.TryUpdate(addr[:], data)) } // deleteStateObject removes the given object from the state trie. -func (self *StateDB) deleteStateObject(stateObject *stateObject) { +func (s *StateDB) deleteStateObject(stateObject *stateObject) { stateObject.deleted = true addr := stateObject.Address() - self.setError(self.trie.TryDelete(addr[:])) + s.setError(s.trie.TryDelete(addr[:])) } // DeleteAddress removes the address from the state trie. -func (self *StateDB) DeleteAddress(addr common.Address) { - stateObject := self.getStateObject(addr) +func (s *StateDB) DeleteAddress(addr common.Address) { + stateObject := s.getStateObject(addr) if stateObject != nil && !stateObject.deleted { - self.deleteStateObject(stateObject) + s.deleteStateObject(stateObject) } } // Retrieve a state object given my the address. Returns nil if not found. -func (self *StateDB) getStateObject(addr common.Address) (stateObject *stateObject) { +func (s *StateDB) getStateObject(addr common.Address) (stateObject *stateObject) { // Prefer 'live' objects. - if obj := self.stateObjects[addr]; obj != nil { + if obj := s.stateObjects[addr]; obj != nil { if obj.deleted { return nil } @@ -446,9 +446,9 @@ func (self *StateDB) getStateObject(addr common.Address) (stateObject *stateObje } // Load the object from the database. - enc, err := self.trie.TryGet(addr[:]) + enc, err := s.trie.TryGet(addr[:]) if len(enc) == 0 { - self.setError(err) + s.setError(err) return nil } var data Account @@ -457,42 +457,42 @@ func (self *StateDB) getStateObject(addr common.Address) (stateObject *stateObje return nil } // Insert into the live set. - obj := newObject(self, addr, data, self.MarkStateObjectDirty) - self.setStateObject(obj) + obj := newObject(s, addr, data, s.MarkStateObjectDirty) + s.setStateObject(obj) return obj } -func (self *StateDB) setStateObject(object *stateObject) { - self.stateObjects[object.Address()] = object +func (s *StateDB) setStateObject(object *stateObject) { + s.stateObjects[object.Address()] = object } // Retrieve a state object or create a new state object if nil. -func (self *StateDB) GetOrNewStateObject(addr common.Address) *stateObject { - stateObject := self.getStateObject(addr) +func (s *StateDB) GetOrNewStateObject(addr common.Address) *stateObject { + stateObject := s.getStateObject(addr) if stateObject == nil || stateObject.deleted { - stateObject, _ = self.createObject(addr) + stateObject, _ = s.createObject(addr) } return stateObject } // MarkStateObjectDirty adds the specified object to the dirty map to avoid costly // state object cache iteration to find a handful of modified ones. -func (self *StateDB) MarkStateObjectDirty(addr common.Address) { - self.stateObjectsDirty[addr] = struct{}{} +func (s *StateDB) MarkStateObjectDirty(addr common.Address) { + s.stateObjectsDirty[addr] = struct{}{} } // createObject creates a new state object. If there is an existing account with // the given address, it is overwritten and returned as the second return value. -func (self *StateDB) createObject(addr common.Address) (newobj, prev *stateObject) { - prev = self.getStateObject(addr) - newobj = newObject(self, addr, Account{}, self.MarkStateObjectDirty) +func (s *StateDB) createObject(addr common.Address) (newobj, prev *stateObject) { + prev = s.getStateObject(addr) + newobj = newObject(s, addr, Account{}, s.MarkStateObjectDirty) newobj.setNonce(0) // sets the object to dirty if prev == nil { - self.journal = append(self.journal, createObjectChange{account: &addr}) + s.journal = append(s.journal, createObjectChange{account: &addr}) } else { - self.journal = append(self.journal, resetObjectChange{prev: prev}) + s.journal = append(s.journal, resetObjectChange{prev: prev}) } - self.setStateObject(newobj) + s.setStateObject(newobj) return newobj, prev } @@ -506,8 +506,8 @@ func (self *StateDB) createObject(addr common.Address) (newobj, prev *stateObjec // 2. tx_create(sha(account ++ nonce)) (note that this gets the address of 1) // // Carrying over the balance ensures that Ether doesn't disappear. -func (self *StateDB) CreateAccount(addr common.Address) { - new, prev := self.createObject(addr) +func (s *StateDB) CreateAccount(addr common.Address) { + new, prev := s.createObject(addr) if prev != nil { new.setBalance(prev.data.Balance) } @@ -537,29 +537,29 @@ func (db *StateDB) ForEachStorage(addr common.Address, cb func(key, value common // Copy creates a deep, independent copy of the state. // Snapshots of the copied state cannot be applied to the copy. -func (self *StateDB) Copy() *StateDB { - self.lock.Lock() - defer self.lock.Unlock() +func (s *StateDB) Copy() *StateDB { + s.lock.Lock() + defer s.lock.Unlock() // Copy all the basic fields, initialize the memory ones state := &StateDB{ - db: self.db, - trie: self.db.CopyTrie(self.trie), - stateObjects: make(map[common.Address]*stateObject, len(self.stateObjectsDirty)), - stateObjectsDirty: make(map[common.Address]struct{}, len(self.stateObjectsDirty)), - refund: self.refund, - logs: make(map[common.Hash][]*types.Log, len(self.logs)), - logSize: self.logSize, + db: s.db, + trie: s.db.CopyTrie(s.trie), + stateObjects: make(map[common.Address]*stateObject, len(s.stateObjectsDirty)), + stateObjectsDirty: make(map[common.Address]struct{}, len(s.stateObjectsDirty)), + refund: s.refund, + logs: make(map[common.Hash][]*types.Log, len(s.logs)), + logSize: s.logSize, preimages: make(map[common.Hash][]byte), } // Copy the dirty states, logs, and preimages - for addr := range self.stateObjectsDirty { - state.stateObjects[addr] = self.stateObjects[addr].deepCopy(state, state.MarkStateObjectDirty) + for addr := range s.stateObjectsDirty { + state.stateObjects[addr] = s.stateObjects[addr].deepCopy(state, state.MarkStateObjectDirty) state.stateObjectsDirty[addr] = struct{}{} } // Deep copy the logs occurred in the scope of block - for hash, logs := range self.logs { + for hash, logs := range s.logs { cpy := make([]*types.Log, len(logs)) for i, l := range logs { cpy[i] = new(types.Log) @@ -568,7 +568,7 @@ func (self *StateDB) Copy() *StateDB { state.logs[hash] = cpy } - for hash, preimage := range self.preimages { + for hash, preimage := range s.preimages { state.preimages[hash] = preimage } // Do we need to copy the access list? In practice: No. At the start of a @@ -576,42 +576,42 @@ func (self *StateDB) Copy() *StateDB { // _between_ transactions/blocks, never in the middle of a transaction. // However, it doesn't cost us much to copy an empty list, so we do it anyway // to not blow up if we ever decide copy it in the middle of a transaction - state.accessList = self.accessList.Copy() + state.accessList = s.accessList.Copy() return state } // Snapshot returns an identifier for the current revision of the state. -func (self *StateDB) Snapshot() int { - id := self.nextRevisionId - self.nextRevisionId++ - self.validRevisions = append(self.validRevisions, revision{id, len(self.journal)}) +func (s *StateDB) Snapshot() int { + id := s.nextRevisionId + s.nextRevisionId++ + s.validRevisions = append(s.validRevisions, revision{id, len(s.journal)}) return id } // RevertToSnapshot reverts all state changes made since the given revision. -func (self *StateDB) RevertToSnapshot(revid int) { +func (s *StateDB) RevertToSnapshot(revid int) { // Find the snapshot in the stack of valid snapshots. - idx := sort.Search(len(self.validRevisions), func(i int) bool { - return self.validRevisions[i].id >= revid + idx := sort.Search(len(s.validRevisions), func(i int) bool { + return s.validRevisions[i].id >= revid }) - if idx == len(self.validRevisions) || self.validRevisions[idx].id != revid { + if idx == len(s.validRevisions) || s.validRevisions[idx].id != revid { panic(fmt.Errorf("revision id %v cannot be reverted", revid)) } - snapshot := self.validRevisions[idx].journalIndex + snapshot := s.validRevisions[idx].journalIndex // Replay the journal to undo changes. - for i := len(self.journal) - 1; i >= snapshot; i-- { - self.journal[i].undo(self) + for i := len(s.journal) - 1; i >= snapshot; i-- { + s.journal[i].undo(s) } - self.journal = self.journal[:snapshot] + s.journal = s.journal[:snapshot] // Remove invalidated snapshots from the stack. - self.validRevisions = self.validRevisions[:idx] + s.validRevisions = s.validRevisions[:idx] } // GetRefund returns the current value of the refund counter. -func (self *StateDB) GetRefund() uint64 { - return self.refund +func (s *StateDB) GetRefund() uint64 { + return s.refund } // Finalise finalises the state by removing the self destructed objects diff --git a/core/types/block.go b/core/types/block.go index 139f641bdb..4f973e79c3 100644 --- a/core/types/block.go +++ b/core/types/block.go @@ -450,10 +450,10 @@ type Blocks []*Block type BlockBy func(b1, b2 *Block) bool -func (self BlockBy) Sort(blocks Blocks) { +func (bb BlockBy) Sort(blocks Blocks) { bs := blockSorter{ blocks: blocks, - by: self, + by: bb, } sort.Sort(bs) } @@ -463,10 +463,12 @@ type blockSorter struct { by func(b1, b2 *Block) bool } -func (self blockSorter) Len() int { return len(self.blocks) } -func (self blockSorter) Swap(i, j int) { - self.blocks[i], self.blocks[j] = self.blocks[j], self.blocks[i] +func (bs blockSorter) Len() int { return len(bs.blocks) } + +func (bs blockSorter) Swap(i, j int) { + bs.blocks[i], bs.blocks[j] = bs.blocks[j], bs.blocks[i] } -func (self blockSorter) Less(i, j int) bool { return self.by(self.blocks[i], self.blocks[j]) } + +func (bs blockSorter) Less(i, j int) bool { return bs.by(bs.blocks[i], bs.blocks[j]) } func Number(b1, b2 *Block) bool { return b1.header.Number.Cmp(b2.header.Number) < 0 } diff --git a/eth/backend.go b/eth/backend.go index e3a7490207..3b6138bb96 100644 --- a/eth/backend.go +++ b/eth/backend.go @@ -103,9 +103,9 @@ type Ethereum struct { Lending *XDCxlending.Lending } -func (s *Ethereum) AddLesServer(ls LesServer) { - s.lesServer = ls - ls.SetBloomBitsIndexer(s.bloomIndexer) +func (e *Ethereum) AddLesServer(ls LesServer) { + e.lesServer = ls + ls.SetBloomBitsIndexer(e.bloomIndexer) } // New creates a new Ethereum object (including the @@ -371,80 +371,80 @@ func CreateConsensusEngine(ctx *node.ServiceContext, config *ethash.Config, chai // APIs returns the collection of RPC services the ethereum package offers. // NOTE, some of these services probably need to be moved to somewhere else. -func (s *Ethereum) APIs() []rpc.API { - apis := ethapi.GetAPIs(s.ApiBackend, s.BlockChain()) +func (e *Ethereum) APIs() []rpc.API { + apis := ethapi.GetAPIs(e.ApiBackend, e.BlockChain()) // Append any APIs exposed explicitly by the consensus engine - apis = append(apis, s.engine.APIs(s.BlockChain())...) + apis = append(apis, e.engine.APIs(e.BlockChain())...) // Append all the local APIs and return return append(apis, []rpc.API{ { Namespace: "eth", Version: "1.0", - Service: NewPublicEthereumAPI(s), + Service: NewPublicEthereumAPI(e), Public: true, }, { Namespace: "eth", Version: "1.0", - Service: NewPublicMinerAPI(s), + Service: NewPublicMinerAPI(e), Public: true, }, { Namespace: "eth", Version: "1.0", - Service: downloader.NewPublicDownloaderAPI(s.protocolManager.downloader, s.eventMux), + Service: downloader.NewPublicDownloaderAPI(e.protocolManager.downloader, e.eventMux), Public: true, }, { Namespace: "miner", Version: "1.0", - Service: NewPrivateMinerAPI(s), + Service: NewPrivateMinerAPI(e), Public: false, }, { Namespace: "eth", Version: "1.0", - Service: filters.NewFilterAPI(filters.NewFilterSystem(s.ApiBackend, filters.Config{LogCacheSize: s.config.FilterLogCacheSize}), false), + Service: filters.NewFilterAPI(filters.NewFilterSystem(e.ApiBackend, filters.Config{LogCacheSize: e.config.FilterLogCacheSize}), false), Public: true, }, { Namespace: "admin", Version: "1.0", - Service: NewPrivateAdminAPI(s), + Service: NewPrivateAdminAPI(e), }, { Namespace: "debug", Version: "1.0", - Service: NewPublicDebugAPI(s), + Service: NewPublicDebugAPI(e), Public: true, }, { Namespace: "debug", Version: "1.0", - Service: NewPrivateDebugAPI(s.chainConfig, s), + Service: NewPrivateDebugAPI(e.chainConfig, e), }, { Namespace: "net", Version: "1.0", - Service: s.netRPCService, + Service: e.netRPCService, Public: true, }, }...) } -func (s *Ethereum) ResetWithGenesisBlock(gb *types.Block) { - s.blockchain.ResetWithGenesisBlock(gb) +func (e *Ethereum) ResetWithGenesisBlock(gb *types.Block) { + e.blockchain.ResetWithGenesisBlock(gb) } -func (s *Ethereum) Etherbase() (eb common.Address, err error) { - s.lock.RLock() - etherbase := s.etherbase - s.lock.RUnlock() +func (e *Ethereum) Etherbase() (eb common.Address, err error) { + e.lock.RLock() + etherbase := e.etherbase + e.lock.RUnlock() if etherbase != (common.Address{}) { return etherbase, nil } - if wallets := s.AccountManager().Wallets(); len(wallets) > 0 { + if wallets := e.AccountManager().Wallets(); len(wallets) > 0 { if accounts := wallets[0].Accounts(); len(accounts) > 0 { etherbase := accounts[0].Address - s.lock.Lock() - s.etherbase = etherbase - s.lock.Unlock() + e.lock.Lock() + e.etherbase = etherbase + e.lock.Unlock() log.Info("Etherbase automatically configured", "address", etherbase) return etherbase, nil @@ -454,25 +454,25 @@ func (s *Ethereum) Etherbase() (eb common.Address, err error) { } // set in js console via admin interface or wrapper from cli flags -func (self *Ethereum) SetEtherbase(etherbase common.Address) { - self.lock.Lock() - self.etherbase = etherbase - self.lock.Unlock() +func (e *Ethereum) SetEtherbase(etherbase common.Address) { + e.lock.Lock() + e.etherbase = etherbase + e.lock.Unlock() - self.miner.SetEtherbase(etherbase) + e.miner.SetEtherbase(etherbase) } // ValidateMasternode checks if node's address is in set of masternodes -func (s *Ethereum) ValidateMasternode() (bool, error) { - eb, err := s.Etherbase() +func (e *Ethereum) ValidateMasternode() (bool, error) { + eb, err := e.Etherbase() if err != nil { return false, err } - if s.chainConfig.XDPoS != nil { + if e.chainConfig.XDPoS != nil { //check if miner's wallet is in set of validators - c := s.engine.(*XDPoS.XDPoS) + c := e.engine.(*XDPoS.XDPoS) - authorized := c.IsAuthorisedAddress(s.blockchain, s.blockchain.CurrentHeader(), eb) + authorized := c.IsAuthorisedAddress(e.blockchain, e.blockchain.CurrentHeader(), eb) if !authorized { //This miner doesn't belong to set of validators return false, nil @@ -483,14 +483,14 @@ func (s *Ethereum) ValidateMasternode() (bool, error) { return true, nil } -func (s *Ethereum) StartStaking(local bool) error { - eb, err := s.Etherbase() +func (e *Ethereum) StartStaking(local bool) error { + eb, err := e.Etherbase() if err != nil { log.Error("Cannot start mining without etherbase", "err", err) return fmt.Errorf("etherbase missing: %v", err) } - if XDPoS, ok := s.engine.(*XDPoS.XDPoS); ok { - wallet, err := s.accountManager.Find(accounts.Account{Address: eb}) + if XDPoS, ok := e.engine.(*XDPoS.XDPoS); ok { + wallet, err := e.accountManager.Find(accounts.Account{Address: eb}) if wallet == nil || err != nil { log.Error("Etherbase account unavailable locally", "address", eb, "err", err) return fmt.Errorf("signer missing: %v", err) @@ -502,102 +502,104 @@ func (s *Ethereum) StartStaking(local bool) error { // mechanism introduced to speed sync times. CPU mining on mainnet is ludicrous // so noone will ever hit this path, whereas marking sync done on CPU mining // will ensure that private networks work in single miner mode too. - atomic.StoreUint32(&s.protocolManager.acceptTxs, 1) + atomic.StoreUint32(&e.protocolManager.acceptTxs, 1) } - go s.miner.Start(eb) + go e.miner.Start(eb) return nil } -func (s *Ethereum) StopStaking() { - s.miner.Stop() +func (e *Ethereum) StopStaking() { + e.miner.Stop() } -func (s *Ethereum) IsStaking() bool { return s.miner.Mining() } -func (s *Ethereum) Miner() *miner.Miner { return s.miner } -func (s *Ethereum) AccountManager() *accounts.Manager { return s.accountManager } -func (s *Ethereum) BlockChain() *core.BlockChain { return s.blockchain } -func (s *Ethereum) TxPool() *core.TxPool { return s.txPool } -func (s *Ethereum) EventMux() *event.TypeMux { return s.eventMux } -func (s *Ethereum) Engine() consensus.Engine { return s.engine } -func (s *Ethereum) ChainDb() ethdb.Database { return s.chainDb } -func (s *Ethereum) IsListening() bool { return true } // Always listening -func (s *Ethereum) EthVersion() int { return int(s.protocolManager.SubProtocols[0].Version) } -func (s *Ethereum) NetVersion() uint64 { return s.networkId } -func (s *Ethereum) Downloader() *downloader.Downloader { return s.protocolManager.downloader } +func (e *Ethereum) IsStaking() bool { return e.miner.Mining() } +func (e *Ethereum) Miner() *miner.Miner { return e.miner } + +func (e *Ethereum) AccountManager() *accounts.Manager { return e.accountManager } +func (e *Ethereum) BlockChain() *core.BlockChain { return e.blockchain } +func (e *Ethereum) TxPool() *core.TxPool { return e.txPool } +func (e *Ethereum) EventMux() *event.TypeMux { return e.eventMux } +func (e *Ethereum) Engine() consensus.Engine { return e.engine } +func (e *Ethereum) ChainDb() ethdb.Database { return e.chainDb } +func (e *Ethereum) IsListening() bool { return true } // Always listening +func (e *Ethereum) EthVersion() int { return int(e.protocolManager.SubProtocols[0].Version) } +func (e *Ethereum) NetVersion() uint64 { return e.networkId } +func (e *Ethereum) Downloader() *downloader.Downloader { return e.protocolManager.downloader } // Protocols implements node.Service, returning all the currently configured // network protocols to start. -func (s *Ethereum) Protocols() []p2p.Protocol { - if s.lesServer == nil { - return s.protocolManager.SubProtocols +func (e *Ethereum) Protocols() []p2p.Protocol { + if e.lesServer == nil { + return e.protocolManager.SubProtocols } - return append(s.protocolManager.SubProtocols, s.lesServer.Protocols()...) + return append(e.protocolManager.SubProtocols, e.lesServer.Protocols()...) } // Start implements node.Service, starting all internal goroutines needed by the // Ethereum protocol implementation. -func (s *Ethereum) Start(srvr *p2p.Server) error { +func (e *Ethereum) Start(srvr *p2p.Server) error { // Start the bloom bits servicing goroutines - s.startBloomHandlers() + e.startBloomHandlers() // Start the RPC service - s.netRPCService = ethapi.NewPublicNetAPI(srvr, s.NetVersion()) + e.netRPCService = ethapi.NewPublicNetAPI(srvr, e.NetVersion()) // Figure out a max peers count based on the server limits maxPeers := srvr.MaxPeers - if s.config.LightServ > 0 { - if s.config.LightPeers >= srvr.MaxPeers { - return fmt.Errorf("invalid peer config: light peer count (%d) >= total peer count (%d)", s.config.LightPeers, srvr.MaxPeers) + if e.config.LightServ > 0 { + if e.config.LightPeers >= srvr.MaxPeers { + return fmt.Errorf("invalid peer config: light peer count (%d) >= total peer count (%d)", e.config.LightPeers, srvr.MaxPeers) } - maxPeers -= s.config.LightPeers + maxPeers -= e.config.LightPeers } // Start the networking layer and the light server if requested - s.protocolManager.Start(maxPeers) - if s.lesServer != nil { - s.lesServer.Start(srvr) + e.protocolManager.Start(maxPeers) + if e.lesServer != nil { + e.lesServer.Start(srvr) } return nil } -func (s *Ethereum) SaveData() { - s.blockchain.SaveData() + +func (e *Ethereum) SaveData() { + e.blockchain.SaveData() } // Stop implements node.Service, terminating all internal goroutines used by the // Ethereum protocol. -func (s *Ethereum) Stop() error { - s.bloomIndexer.Close() - s.blockchain.Stop() - s.protocolManager.Stop() - if s.lesServer != nil { - s.lesServer.Stop() +func (e *Ethereum) Stop() error { + e.bloomIndexer.Close() + e.blockchain.Stop() + e.protocolManager.Stop() + if e.lesServer != nil { + e.lesServer.Stop() } - s.txPool.Stop() - s.miner.Stop() - s.eventMux.Stop() + e.txPool.Stop() + e.miner.Stop() + e.eventMux.Stop() - s.chainDb.Close() - close(s.shutdownChan) + e.chainDb.Close() + close(e.shutdownChan) return nil } -func (s *Ethereum) GetPeer() int { - return len(s.protocolManager.peers.peers) +func (e *Ethereum) GetPeer() int { + return len(e.protocolManager.peers.peers) } -func (s *Ethereum) GetXDCX() *XDCx.XDCX { - return s.XDCX +func (e *Ethereum) GetXDCX() *XDCx.XDCX { + return e.XDCX } -func (s *Ethereum) OrderPool() *core.OrderPool { - return s.orderPool +func (e *Ethereum) OrderPool() *core.OrderPool { + return e.orderPool } -func (s *Ethereum) GetXDCXLending() *XDCxlending.Lending { - return s.Lending +func (e *Ethereum) GetXDCXLending() *XDCxlending.Lending { + return e.Lending } // LendingPool geth eth lending pool -func (s *Ethereum) LendingPool() *core.LendingPool { - return s.lendingPool +func (e *Ethereum) LendingPool() *core.LendingPool { + return e.lendingPool } diff --git a/eth/handler.go b/eth/handler.go index 76733fb8d8..913d7f07b3 100644 --- a/eth/handler.go +++ b/eth/handler.go @@ -266,9 +266,11 @@ func NewProtocolManager(config *params.ChainConfig, mode downloader.SyncMode, ne func (pm *ProtocolManager) addOrderPoolProtocol(orderpool orderPool) { pm.orderpool = orderpool } + func (pm *ProtocolManager) addLendingPoolProtocol(lendingpool lendingPool) { pm.lendingpool = lendingpool } + func (pm *ProtocolManager) removePeer(id string) { // Short circuit if the peer was already removed peer := pm.peers.Peer(id) @@ -1037,12 +1039,12 @@ func (pm *ProtocolManager) LendingBroadcastTx(hash common.Hash, tx *types.Lendin } // minedBroadcastLoop broadcast loop -func (self *ProtocolManager) minedBroadcastLoop() { +func (pm *ProtocolManager) minedBroadcastLoop() { // automatically stops if unsubscribe - for obj := range self.minedBlockSub.Chan() { + for obj := range pm.minedBlockSub.Chan() { switch ev := obj.Data.(type) { case core.NewMinedBlockEvent: - self.BroadcastBlock(ev.Block, true) // First propagate block to peers + pm.BroadcastBlock(ev.Block, true) // First propagate block to peers //self.BroadcastBlock(ev.Block, false) // Only then announce to the rest } } @@ -1062,34 +1064,34 @@ func (pm *ProtocolManager) txBroadcastLoop() { } // orderTxBroadcastLoop broadcast order -func (self *ProtocolManager) orderTxBroadcastLoop() { - if self.orderTxSub == nil { +func (pm *ProtocolManager) orderTxBroadcastLoop() { + if pm.orderTxSub == nil { return } for { select { - case event := <-self.orderTxCh: - self.OrderBroadcastTx(event.Tx.Hash(), event.Tx) + case event := <-pm.orderTxCh: + pm.OrderBroadcastTx(event.Tx.Hash(), event.Tx) // Err() channel will be closed when unsubscribing. - case <-self.orderTxSub.Err(): + case <-pm.orderTxSub.Err(): return } } } // lendingTxBroadcastLoop broadcast order -func (self *ProtocolManager) lendingTxBroadcastLoop() { - if self.lendingTxSub == nil { +func (pm *ProtocolManager) lendingTxBroadcastLoop() { + if pm.lendingTxSub == nil { return } for { select { - case event := <-self.lendingTxCh: - self.LendingBroadcastTx(event.Tx.Hash(), event.Tx) + case event := <-pm.lendingTxCh: + pm.LendingBroadcastTx(event.Tx.Hash(), event.Tx) // Err() channel will be closed when unsubscribing. - case <-self.lendingTxSub.Err(): + case <-pm.lendingTxSub.Err(): return } } @@ -1106,13 +1108,13 @@ type NodeInfo struct { } // NodeInfo retrieves some protocol metadata about the running host node. -func (self *ProtocolManager) NodeInfo() *NodeInfo { - currentBlock := self.blockchain.CurrentBlock() +func (pm *ProtocolManager) NodeInfo() *NodeInfo { + currentBlock := pm.blockchain.CurrentBlock() return &NodeInfo{ - Network: self.networkId, - Difficulty: self.blockchain.GetTd(currentBlock.Hash(), currentBlock.NumberU64()), - Genesis: self.blockchain.Genesis().Hash(), - Config: self.blockchain.Config(), + Network: pm.networkId, + Difficulty: pm.blockchain.GetTd(currentBlock.Hash(), currentBlock.NumberU64()), + Genesis: pm.blockchain.Genesis().Hash(), + Config: pm.blockchain.Config(), Head: currentBlock.Hash(), } } diff --git a/event/filter/filter.go b/event/filter/filter.go index b1fbf30ee4..a6fe46d6a0 100644 --- a/event/filter/filter.go +++ b/event/filter/filter.go @@ -45,37 +45,37 @@ func New() *Filters { } } -func (self *Filters) Start() { - go self.loop() +func (f *Filters) Start() { + go f.loop() } -func (self *Filters) Stop() { - close(self.quit) +func (f *Filters) Stop() { + close(f.quit) } -func (self *Filters) Notify(filter Filter, data interface{}) { - self.ch <- FilterEvent{filter, data} +func (f *Filters) Notify(filter Filter, data interface{}) { + f.ch <- FilterEvent{filter, data} } -func (self *Filters) Install(watcher Filter) int { - self.watchers[self.id] = watcher - self.id++ +func (f *Filters) Install(watcher Filter) int { + f.watchers[f.id] = watcher + f.id++ - return self.id - 1 + return f.id - 1 } -func (self *Filters) Uninstall(id int) { - delete(self.watchers, id) +func (f *Filters) Uninstall(id int) { + delete(f.watchers, id) } -func (self *Filters) loop() { +func (f *Filters) loop() { out: for { select { - case <-self.quit: + case <-f.quit: break out - case event := <-self.ch: - for _, watcher := range self.watchers { + case event := <-f.ch: + for _, watcher := range f.watchers { if reflect.TypeOf(watcher) == reflect.TypeOf(event.filter) { if watcher.Compare(event.filter) { watcher.Trigger(event.data) @@ -86,10 +86,10 @@ out: } } -func (self *Filters) Match(a, b Filter) bool { +func (f *Filters) Match(a, b Filter) bool { return reflect.TypeOf(a) == reflect.TypeOf(b) && a.Compare(b) } -func (self *Filters) Get(i int) Filter { - return self.watchers[i] +func (f *Filters) Get(i int) Filter { + return f.watchers[i] } diff --git a/event/filter/generic_filter.go b/event/filter/generic_filter.go index d679b8bfa8..b641f5f070 100644 --- a/event/filter/generic_filter.go +++ b/event/filter/generic_filter.go @@ -23,18 +23,18 @@ type Generic struct { Fn func(data interface{}) } -// self = registered, f = incoming -func (self Generic) Compare(f Filter) bool { +// g = registered, f = incoming +func (g Generic) Compare(f Filter) bool { var strMatch, dataMatch = true, true filter := f.(Generic) - if (len(self.Str1) > 0 && filter.Str1 != self.Str1) || - (len(self.Str2) > 0 && filter.Str2 != self.Str2) || - (len(self.Str3) > 0 && filter.Str3 != self.Str3) { + if (len(g.Str1) > 0 && filter.Str1 != g.Str1) || + (len(g.Str2) > 0 && filter.Str2 != g.Str2) || + (len(g.Str3) > 0 && filter.Str3 != g.Str3) { strMatch = false } - for k := range self.Data { + for k := range g.Data { if _, ok := filter.Data[k]; !ok { return false } @@ -43,6 +43,6 @@ func (self Generic) Compare(f Filter) bool { return strMatch && dataMatch } -func (self Generic) Trigger(data interface{}) { - self.Fn(data) +func (g Generic) Trigger(data interface{}) { + g.Fn(data) } diff --git a/les/flowcontrol/manager.go b/les/flowcontrol/manager.go index 571b87bdb9..e22cd5ae92 100644 --- a/les/flowcontrol/manager.go +++ b/les/flowcontrol/manager.go @@ -35,35 +35,35 @@ type cmNode struct { finishRecharge mclock.AbsTime } -func (node *cmNode) update(time mclock.AbsTime) { - dt := int64(time - node.lastUpdate) - node.rcValue += node.rcDelta * dt / rcConst - node.lastUpdate = time - if node.recharging && time >= node.finishRecharge { - node.recharging = false - node.rcDelta = 0 - node.rcValue = 0 +func (n *cmNode) update(time mclock.AbsTime) { + dt := int64(time - n.lastUpdate) + n.rcValue += n.rcDelta * dt / rcConst + n.lastUpdate = time + if n.recharging && time >= n.finishRecharge { + n.recharging = false + n.rcDelta = 0 + n.rcValue = 0 } } -func (node *cmNode) set(serving bool, simReqCnt, sumWeight uint64) { - if node.serving && !serving { - node.recharging = true - sumWeight += node.rcWeight +func (n *cmNode) set(serving bool, simReqCnt, sumWeight uint64) { + if n.serving && !serving { + n.recharging = true + sumWeight += n.rcWeight } - node.serving = serving - if node.recharging && serving { - node.recharging = false - sumWeight -= node.rcWeight + n.serving = serving + if n.recharging && serving { + n.recharging = false + sumWeight -= n.rcWeight } - node.rcDelta = 0 + n.rcDelta = 0 if serving { - node.rcDelta = int64(rcConst / simReqCnt) + n.rcDelta = int64(rcConst / simReqCnt) } - if node.recharging { - node.rcDelta = -int64(node.node.cm.rcRecharge * node.rcWeight / sumWeight) - node.finishRecharge = node.lastUpdate + mclock.AbsTime(node.rcValue*rcConst/(-node.rcDelta)) + if n.recharging { + n.rcDelta = -int64(n.node.cm.rcRecharge * n.rcWeight / sumWeight) + n.finishRecharge = n.lastUpdate + mclock.AbsTime(n.rcValue*rcConst/(-n.rcDelta)) } } @@ -89,16 +89,16 @@ func NewClientManager(rcTarget, maxSimReq, maxRcSum uint64) *ClientManager { return cm } -func (self *ClientManager) Stop() { - self.lock.Lock() - defer self.lock.Unlock() +func (cm *ClientManager) Stop() { + cm.lock.Lock() + defer cm.lock.Unlock() // signal any waiting accept routines to return false - self.nodes = make(map[*cmNode]struct{}) - close(self.resumeQueue) + cm.nodes = make(map[*cmNode]struct{}) + close(cm.resumeQueue) } -func (self *ClientManager) addNode(cnode *ClientNode) *cmNode { +func (cm *ClientManager) addNode(cnode *ClientNode) *cmNode { time := mclock.Now() node := &cmNode{ node: cnode, @@ -106,28 +106,28 @@ func (self *ClientManager) addNode(cnode *ClientNode) *cmNode { finishRecharge: time, rcWeight: 1, } - self.lock.Lock() - defer self.lock.Unlock() + cm.lock.Lock() + defer cm.lock.Unlock() - self.nodes[node] = struct{}{} - self.update(mclock.Now()) + cm.nodes[node] = struct{}{} + cm.update(mclock.Now()) return node } -func (self *ClientManager) removeNode(node *cmNode) { - self.lock.Lock() - defer self.lock.Unlock() +func (cm *ClientManager) removeNode(node *cmNode) { + cm.lock.Lock() + defer cm.lock.Unlock() time := mclock.Now() - self.stop(node, time) - delete(self.nodes, node) - self.update(time) + cm.stop(node, time) + delete(cm.nodes, node) + cm.update(time) } // recalc sumWeight -func (self *ClientManager) updateNodes(time mclock.AbsTime) (rce bool) { +func (cm *ClientManager) updateNodes(time mclock.AbsTime) (rce bool) { var sumWeight, rcSum uint64 - for node := range self.nodes { + for node := range cm.nodes { rc := node.recharging node.update(time) if rc && !node.recharging { @@ -138,44 +138,44 @@ func (self *ClientManager) updateNodes(time mclock.AbsTime) (rce bool) { } rcSum += uint64(node.rcValue) } - self.sumWeight = sumWeight - self.rcSumValue = rcSum + cm.sumWeight = sumWeight + cm.rcSumValue = rcSum return } -func (self *ClientManager) update(time mclock.AbsTime) { +func (cm *ClientManager) update(time mclock.AbsTime) { for { firstTime := time - for node := range self.nodes { + for node := range cm.nodes { if node.recharging && node.finishRecharge < firstTime { firstTime = node.finishRecharge } } - if self.updateNodes(firstTime) { - for node := range self.nodes { + if cm.updateNodes(firstTime) { + for node := range cm.nodes { if node.recharging { - node.set(node.serving, self.simReqCnt, self.sumWeight) + node.set(node.serving, cm.simReqCnt, cm.sumWeight) } } } else { - self.time = time + cm.time = time return } } } -func (self *ClientManager) canStartReq() bool { - return self.simReqCnt < self.maxSimReq && self.rcSumValue < self.maxRcSum +func (cm *ClientManager) canStartReq() bool { + return cm.simReqCnt < cm.maxSimReq && cm.rcSumValue < cm.maxRcSum } -func (self *ClientManager) queueProc() { - for rc := range self.resumeQueue { +func (cm *ClientManager) queueProc() { + for rc := range cm.resumeQueue { for { time.Sleep(time.Millisecond * 10) - self.lock.Lock() - self.update(mclock.Now()) - cs := self.canStartReq() - self.lock.Unlock() + cm.lock.Lock() + cm.update(mclock.Now()) + cs := cm.canStartReq() + cm.lock.Unlock() if cs { break } @@ -184,41 +184,41 @@ func (self *ClientManager) queueProc() { } } -func (self *ClientManager) accept(node *cmNode, time mclock.AbsTime) bool { - self.lock.Lock() - defer self.lock.Unlock() +func (cm *ClientManager) accept(node *cmNode, time mclock.AbsTime) bool { + cm.lock.Lock() + defer cm.lock.Unlock() - self.update(time) - if !self.canStartReq() { + cm.update(time) + if !cm.canStartReq() { resume := make(chan bool) - self.lock.Unlock() - self.resumeQueue <- resume + cm.lock.Unlock() + cm.resumeQueue <- resume <-resume - self.lock.Lock() - if _, ok := self.nodes[node]; !ok { + cm.lock.Lock() + if _, ok := cm.nodes[node]; !ok { return false // reject if node has been removed or manager has been stopped } } - self.simReqCnt++ - node.set(true, self.simReqCnt, self.sumWeight) + cm.simReqCnt++ + node.set(true, cm.simReqCnt, cm.sumWeight) node.startValue = node.rcValue - self.update(self.time) + cm.update(cm.time) return true } -func (self *ClientManager) stop(node *cmNode, time mclock.AbsTime) { +func (cm *ClientManager) stop(node *cmNode, time mclock.AbsTime) { if node.serving { - self.update(time) - self.simReqCnt-- - node.set(false, self.simReqCnt, self.sumWeight) - self.update(time) + cm.update(time) + cm.simReqCnt-- + node.set(false, cm.simReqCnt, cm.sumWeight) + cm.update(time) } } -func (self *ClientManager) processed(node *cmNode, time mclock.AbsTime) (rcValue, rcCost uint64) { - self.lock.Lock() - defer self.lock.Unlock() +func (cm *ClientManager) processed(node *cmNode, time mclock.AbsTime) (rcValue, rcCost uint64) { + cm.lock.Lock() + defer cm.lock.Unlock() - self.stop(node, time) + cm.stop(node, time) return uint64(node.rcValue), uint64(node.rcValue - node.startValue) } diff --git a/les/handler.go b/les/handler.go index 6a4ba688ea..bb8c89f156 100644 --- a/les/handler.go +++ b/les/handler.go @@ -1181,15 +1181,15 @@ type NodeInfo struct { } // NodeInfo retrieves some protocol metadata about the running host node. -func (self *ProtocolManager) NodeInfo() *NodeInfo { - head := self.blockchain.CurrentHeader() +func (pm *ProtocolManager) NodeInfo() *NodeInfo { + head := pm.blockchain.CurrentHeader() hash := head.Hash() return &NodeInfo{ - Network: self.networkId, - Difficulty: self.blockchain.GetTd(hash, head.Number.Uint64()), - Genesis: self.blockchain.Genesis().Hash(), - Config: self.blockchain.Config(), + Network: pm.networkId, + Difficulty: pm.blockchain.GetTd(hash, head.Number.Uint64()), + Genesis: pm.blockchain.Genesis().Hash(), + Config: pm.blockchain.Config(), Head: hash, } } diff --git a/les/txrelay.go b/les/txrelay.go index a78d9f4974..b5488a8ad5 100644 --- a/les/txrelay.go +++ b/les/txrelay.go @@ -50,47 +50,47 @@ func NewLesTxRelay(ps *peerSet, reqDist *requestDistributor) *LesTxRelay { return r } -func (self *LesTxRelay) registerPeer(p *peer) { - self.lock.Lock() - defer self.lock.Unlock() +func (l *LesTxRelay) registerPeer(p *peer) { + l.lock.Lock() + defer l.lock.Unlock() - self.peerList = self.ps.AllPeers() + l.peerList = l.ps.AllPeers() } -func (self *LesTxRelay) unregisterPeer(p *peer) { - self.lock.Lock() - defer self.lock.Unlock() +func (l *LesTxRelay) unregisterPeer(p *peer) { + l.lock.Lock() + defer l.lock.Unlock() - self.peerList = self.ps.AllPeers() + l.peerList = l.ps.AllPeers() } // send sends a list of transactions to at most a given number of peers at // once, never resending any particular transaction to the same peer twice -func (self *LesTxRelay) send(txs types.Transactions, count int) { +func (l *LesTxRelay) send(txs types.Transactions, count int) { sendTo := make(map[*peer]types.Transactions) - self.peerStartPos++ // rotate the starting position of the peer list - if self.peerStartPos >= len(self.peerList) { - self.peerStartPos = 0 + l.peerStartPos++ // rotate the starting position of the peer list + if l.peerStartPos >= len(l.peerList) { + l.peerStartPos = 0 } for _, tx := range txs { hash := tx.Hash() - ltr, ok := self.txSent[hash] + ltr, ok := l.txSent[hash] if !ok { ltr = <rInfo{ tx: tx, sentTo: make(map[*peer]struct{}), } - self.txSent[hash] = ltr - self.txPending[hash] = struct{}{} + l.txSent[hash] = ltr + l.txPending[hash] = struct{}{} } - if len(self.peerList) > 0 { + if len(l.peerList) > 0 { cnt := count - pos := self.peerStartPos + pos := l.peerStartPos for { - peer := self.peerList[pos] + peer := l.peerList[pos] if _, ok := ltr.sentTo[peer]; !ok { sendTo[peer] = append(sendTo[peer], tx) ltr.sentTo[peer] = struct{}{} @@ -100,10 +100,10 @@ func (self *LesTxRelay) send(txs types.Transactions, count int) { break // sent it to the desired number of peers } pos++ - if pos == len(self.peerList) { + if pos == len(l.peerList) { pos = 0 } - if pos == self.peerStartPos { + if pos == l.peerStartPos { break // tried all available peers } } @@ -130,46 +130,46 @@ func (self *LesTxRelay) send(txs types.Transactions, count int) { return func() { peer.SendTxs(reqID, cost, ll) } }, } - self.reqDist.queue(rq) + l.reqDist.queue(rq) } } -func (self *LesTxRelay) Send(txs types.Transactions) { - self.lock.Lock() - defer self.lock.Unlock() +func (l *LesTxRelay) Send(txs types.Transactions) { + l.lock.Lock() + defer l.lock.Unlock() - self.send(txs, 3) + l.send(txs, 3) } -func (self *LesTxRelay) NewHead(head common.Hash, mined []common.Hash, rollback []common.Hash) { - self.lock.Lock() - defer self.lock.Unlock() +func (l *LesTxRelay) NewHead(head common.Hash, mined []common.Hash, rollback []common.Hash) { + l.lock.Lock() + defer l.lock.Unlock() for _, hash := range mined { - delete(self.txPending, hash) + delete(l.txPending, hash) } for _, hash := range rollback { - self.txPending[hash] = struct{}{} + l.txPending[hash] = struct{}{} } - if len(self.txPending) > 0 { - txs := make(types.Transactions, len(self.txPending)) + if len(l.txPending) > 0 { + txs := make(types.Transactions, len(l.txPending)) i := 0 - for hash := range self.txPending { - txs[i] = self.txSent[hash].tx + for hash := range l.txPending { + txs[i] = l.txSent[hash].tx i++ } - self.send(txs, 1) + l.send(txs, 1) } } -func (self *LesTxRelay) Discard(hashes []common.Hash) { - self.lock.Lock() - defer self.lock.Unlock() +func (l *LesTxRelay) Discard(hashes []common.Hash) { + l.lock.Lock() + defer l.lock.Unlock() for _, hash := range hashes { - delete(self.txSent, hash) - delete(self.txPending, hash) + delete(l.txSent, hash) + delete(l.txPending, hash) } } diff --git a/light/lightchain.go b/light/lightchain.go index dd3e57f624..236d1ed85b 100644 --- a/light/lightchain.go +++ b/light/lightchain.go @@ -116,45 +116,45 @@ func NewLightChain(odr OdrBackend, config *params.ChainConfig, engine consensus. } // addTrustedCheckpoint adds a trusted checkpoint to the blockchain -func (self *LightChain) addTrustedCheckpoint(cp trustedCheckpoint) { - if self.odr.ChtIndexer() != nil { - StoreChtRoot(self.chainDb, cp.sectionIdx, cp.sectionHead, cp.chtRoot) - self.odr.ChtIndexer().AddKnownSectionHead(cp.sectionIdx, cp.sectionHead) +func (lc *LightChain) addTrustedCheckpoint(cp trustedCheckpoint) { + if lc.odr.ChtIndexer() != nil { + StoreChtRoot(lc.chainDb, cp.sectionIdx, cp.sectionHead, cp.chtRoot) + lc.odr.ChtIndexer().AddKnownSectionHead(cp.sectionIdx, cp.sectionHead) } - if self.odr.BloomTrieIndexer() != nil { - StoreBloomTrieRoot(self.chainDb, cp.sectionIdx, cp.sectionHead, cp.bloomTrieRoot) - self.odr.BloomTrieIndexer().AddKnownSectionHead(cp.sectionIdx, cp.sectionHead) + if lc.odr.BloomTrieIndexer() != nil { + StoreBloomTrieRoot(lc.chainDb, cp.sectionIdx, cp.sectionHead, cp.bloomTrieRoot) + lc.odr.BloomTrieIndexer().AddKnownSectionHead(cp.sectionIdx, cp.sectionHead) } - if self.odr.BloomIndexer() != nil { - self.odr.BloomIndexer().AddKnownSectionHead(cp.sectionIdx, cp.sectionHead) + if lc.odr.BloomIndexer() != nil { + lc.odr.BloomIndexer().AddKnownSectionHead(cp.sectionIdx, cp.sectionHead) } log.Info("Added trusted checkpoint", "chain", cp.name, "block", (cp.sectionIdx+1)*CHTFrequencyClient-1, "hash", cp.sectionHead) } -func (self *LightChain) getProcInterrupt() bool { - return atomic.LoadInt32(&self.procInterrupt) == 1 +func (lc *LightChain) getProcInterrupt() bool { + return atomic.LoadInt32(&lc.procInterrupt) == 1 } // Odr returns the ODR backend of the chain -func (self *LightChain) Odr() OdrBackend { - return self.odr +func (lc *LightChain) Odr() OdrBackend { + return lc.odr } // loadLastState loads the last known chain state from the database. This method // assumes that the chain manager mutex is held. -func (self *LightChain) loadLastState() error { - if head := core.GetHeadHeaderHash(self.chainDb); head == (common.Hash{}) { +func (lc *LightChain) loadLastState() error { + if head := core.GetHeadHeaderHash(lc.chainDb); head == (common.Hash{}) { // Corrupt or empty database, init from scratch - self.Reset() + lc.Reset() } else { - if header := self.GetHeaderByHash(head); header != nil { - self.hc.SetCurrentHeader(header) + if header := lc.GetHeaderByHash(head); header != nil { + lc.hc.SetCurrentHeader(header) } } // Issue a status log and return - header := self.hc.CurrentHeader() - headerTd := self.GetTd(header.Hash(), header.Number.Uint64()) + header := lc.hc.CurrentHeader() + headerTd := lc.GetTd(header.Hash(), header.Number.Uint64()) log.Info("Loaded most recent local header", "number", header.Number, "hash", header.Hash(), "td", headerTd) return nil @@ -162,128 +162,128 @@ func (self *LightChain) loadLastState() error { // SetHead rewinds the local chain to a new head. Everything above the new // head will be deleted and the new one set. -func (bc *LightChain) SetHead(head uint64) { - bc.mu.Lock() - defer bc.mu.Unlock() +func (lc *LightChain) SetHead(head uint64) { + lc.mu.Lock() + defer lc.mu.Unlock() - bc.hc.SetHead(head, nil) - bc.loadLastState() + lc.hc.SetHead(head, nil) + lc.loadLastState() } // GasLimit returns the gas limit of the current HEAD block. -func (self *LightChain) GasLimit() uint64 { - return self.hc.CurrentHeader().GasLimit +func (lc *LightChain) GasLimit() uint64 { + return lc.hc.CurrentHeader().GasLimit } // Reset purges the entire blockchain, restoring it to its genesis state. -func (bc *LightChain) Reset() { - bc.ResetWithGenesisBlock(bc.genesisBlock) +func (lc *LightChain) Reset() { + lc.ResetWithGenesisBlock(lc.genesisBlock) } // ResetWithGenesisBlock purges the entire blockchain, restoring it to the // specified genesis state. -func (bc *LightChain) ResetWithGenesisBlock(genesis *types.Block) { +func (lc *LightChain) ResetWithGenesisBlock(genesis *types.Block) { // Dump the entire block chain and purge the caches - bc.SetHead(0) + lc.SetHead(0) - bc.mu.Lock() - defer bc.mu.Unlock() + lc.mu.Lock() + defer lc.mu.Unlock() // Prepare the genesis block and reinitialise the chain - if err := core.WriteTd(bc.chainDb, genesis.Hash(), genesis.NumberU64(), genesis.Difficulty()); err != nil { + if err := core.WriteTd(lc.chainDb, genesis.Hash(), genesis.NumberU64(), genesis.Difficulty()); err != nil { log.Crit("Failed to write genesis block TD", "err", err) } - rawdb.WriteBlock(bc.chainDb, genesis) - bc.genesisBlock = genesis - bc.hc.SetGenesis(bc.genesisBlock.Header()) - bc.hc.SetCurrentHeader(bc.genesisBlock.Header()) + rawdb.WriteBlock(lc.chainDb, genesis) + lc.genesisBlock = genesis + lc.hc.SetGenesis(lc.genesisBlock.Header()) + lc.hc.SetCurrentHeader(lc.genesisBlock.Header()) } // Accessors // Engine retrieves the light chain's consensus engine. -func (bc *LightChain) Engine() consensus.Engine { return bc.engine } +func (lc *LightChain) Engine() consensus.Engine { return lc.engine } // Genesis returns the genesis block -func (bc *LightChain) Genesis() *types.Block { - return bc.genesisBlock +func (lc *LightChain) Genesis() *types.Block { + return lc.genesisBlock } // State returns a new mutable state based on the current HEAD block. -func (bc *LightChain) State() (*state.StateDB, error) { +func (lc *LightChain) State() (*state.StateDB, error) { return nil, errors.New("not implemented, needs client/server interface split") } // GetBody retrieves a block body (transactions and uncles) from the database // or ODR service by hash, caching it if found. -func (self *LightChain) GetBody(ctx context.Context, hash common.Hash) (*types.Body, error) { +func (lc *LightChain) GetBody(ctx context.Context, hash common.Hash) (*types.Body, error) { // Short circuit if the body's already in the cache, retrieve otherwise - if cached, ok := self.bodyCache.Get(hash); ok { + if cached, ok := lc.bodyCache.Get(hash); ok { body := cached.(*types.Body) return body, nil } - body, err := GetBody(ctx, self.odr, hash, self.hc.GetBlockNumber(hash)) + body, err := GetBody(ctx, lc.odr, hash, lc.hc.GetBlockNumber(hash)) if err != nil { return nil, err } // Cache the found body for next time and return - self.bodyCache.Add(hash, body) + lc.bodyCache.Add(hash, body) return body, nil } // GetBodyRLP retrieves a block body in RLP encoding from the database or // ODR service by hash, caching it if found. -func (self *LightChain) GetBodyRLP(ctx context.Context, hash common.Hash) (rlp.RawValue, error) { +func (lc *LightChain) GetBodyRLP(ctx context.Context, hash common.Hash) (rlp.RawValue, error) { // Short circuit if the body's already in the cache, retrieve otherwise - if cached, ok := self.bodyRLPCache.Get(hash); ok { + if cached, ok := lc.bodyRLPCache.Get(hash); ok { return cached.(rlp.RawValue), nil } - body, err := GetBodyRLP(ctx, self.odr, hash, self.hc.GetBlockNumber(hash)) + body, err := GetBodyRLP(ctx, lc.odr, hash, lc.hc.GetBlockNumber(hash)) if err != nil { return nil, err } // Cache the found body for next time and return - self.bodyRLPCache.Add(hash, body) + lc.bodyRLPCache.Add(hash, body) return body, nil } // HasBlock checks if a block is fully present in the database or not, caching // it if present. -func (bc *LightChain) HasBlock(hash common.Hash, number uint64) bool { - blk, _ := bc.GetBlock(NoOdr, hash, number) +func (lc *LightChain) HasBlock(hash common.Hash, number uint64) bool { + blk, _ := lc.GetBlock(NoOdr, hash, number) return blk != nil } // GetBlock retrieves a block from the database or ODR service by hash and number, // caching it if found. -func (self *LightChain) GetBlock(ctx context.Context, hash common.Hash, number uint64) (*types.Block, error) { +func (lc *LightChain) GetBlock(ctx context.Context, hash common.Hash, number uint64) (*types.Block, error) { // Short circuit if the block's already in the cache, retrieve otherwise - if block, ok := self.blockCache.Get(hash); ok { + if block, ok := lc.blockCache.Get(hash); ok { return block.(*types.Block), nil } - block, err := GetBlock(ctx, self.odr, hash, number) + block, err := GetBlock(ctx, lc.odr, hash, number) if err != nil { return nil, err } // Cache the found block for next time and return - self.blockCache.Add(block.Hash(), block) + lc.blockCache.Add(block.Hash(), block) return block, nil } // GetBlockByHash retrieves a block from the database or ODR service by hash, // caching it if found. -func (self *LightChain) GetBlockByHash(ctx context.Context, hash common.Hash) (*types.Block, error) { - return self.GetBlock(ctx, hash, self.hc.GetBlockNumber(hash)) +func (lc *LightChain) GetBlockByHash(ctx context.Context, hash common.Hash) (*types.Block, error) { + return lc.GetBlock(ctx, hash, lc.hc.GetBlockNumber(hash)) } // GetBlockByNumber retrieves a block from the database or ODR service by // number, caching it (associated with its hash) if found. -func (self *LightChain) GetBlockByNumber(ctx context.Context, number uint64) (*types.Block, error) { - hash, err := GetCanonicalHash(ctx, self.odr, number) +func (lc *LightChain) GetBlockByNumber(ctx context.Context, number uint64) (*types.Block, error) { + hash, err := GetCanonicalHash(ctx, lc.odr, number) if hash == (common.Hash{}) || err != nil { return nil, err } - return self.GetBlock(ctx, hash, number) + return lc.GetBlock(ctx, hash, number) } func (bc *LightChain) SaveData() { @@ -291,44 +291,44 @@ func (bc *LightChain) SaveData() { // Stop stops the blockchain service. If any imports are currently in progress // it will abort them using the procInterrupt. -func (bc *LightChain) Stop() { - if !atomic.CompareAndSwapInt32(&bc.running, 0, 1) { +func (lc *LightChain) Stop() { + if !atomic.CompareAndSwapInt32(&lc.running, 0, 1) { return } - close(bc.quit) - atomic.StoreInt32(&bc.procInterrupt, 1) + close(lc.quit) + atomic.StoreInt32(&lc.procInterrupt, 1) - bc.wg.Wait() + lc.wg.Wait() log.Info("Blockchain manager stopped") } // Rollback is designed to remove a chain of links from the database that aren't // certain enough to be valid. -func (self *LightChain) Rollback(chain []common.Hash) { - self.mu.Lock() - defer self.mu.Unlock() +func (lc *LightChain) Rollback(chain []common.Hash) { + lc.mu.Lock() + defer lc.mu.Unlock() for i := len(chain) - 1; i >= 0; i-- { hash := chain[i] - if head := self.hc.CurrentHeader(); head.Hash() == hash { - self.hc.SetCurrentHeader(self.GetHeader(head.ParentHash, head.Number.Uint64()-1)) + if head := lc.hc.CurrentHeader(); head.Hash() == hash { + lc.hc.SetCurrentHeader(lc.GetHeader(head.ParentHash, head.Number.Uint64()-1)) } } } // postChainEvents iterates over the events generated by a chain insertion and // posts them into the event feed. -func (self *LightChain) postChainEvents(events []interface{}) { +func (lc *LightChain) postChainEvents(events []interface{}) { for _, event := range events { switch ev := event.(type) { case core.ChainEvent: - if self.CurrentHeader().Hash() == ev.Hash { - self.chainHeadFeed.Send(core.ChainHeadEvent{Block: ev.Block}) + if lc.CurrentHeader().Hash() == ev.Hash { + lc.chainHeadFeed.Send(core.ChainHeadEvent{Block: ev.Block}) } - self.chainFeed.Send(ev) + lc.chainFeed.Send(ev) case core.ChainSideEvent: - self.chainSideFeed.Send(ev) + lc.chainSideFeed.Send(ev) } } } @@ -344,28 +344,28 @@ func (self *LightChain) postChainEvents(events []interface{}) { // // In the case of a light chain, InsertHeaderChain also creates and posts light // chain events when necessary. -func (self *LightChain) InsertHeaderChain(chain []*types.Header, checkFreq int) (int, error) { +func (lc *LightChain) InsertHeaderChain(chain []*types.Header, checkFreq int) (int, error) { start := time.Now() - if i, err := self.hc.ValidateHeaderChain(chain, checkFreq); err != nil { + if i, err := lc.hc.ValidateHeaderChain(chain, checkFreq); err != nil { return i, err } // Make sure only one thread manipulates the chain at once - self.chainmu.Lock() + lc.chainmu.Lock() defer func() { - self.chainmu.Unlock() + lc.chainmu.Unlock() time.Sleep(time.Millisecond * 10) // ugly hack; do not hog chain lock in case syncing is CPU-limited by validation }() - self.wg.Add(1) - defer self.wg.Done() + lc.wg.Add(1) + defer lc.wg.Done() var events []interface{} whFunc := func(header *types.Header) error { - self.mu.Lock() - defer self.mu.Unlock() + lc.mu.Lock() + defer lc.mu.Unlock() - status, err := self.hc.WriteHeader(header) + status, err := lc.hc.WriteHeader(header) switch status { case core.CanonStatTy: @@ -378,91 +378,91 @@ func (self *LightChain) InsertHeaderChain(chain []*types.Header, checkFreq int) } return err } - i, err := self.hc.InsertHeaderChain(chain, whFunc, start) - self.postChainEvents(events) + i, err := lc.hc.InsertHeaderChain(chain, whFunc, start) + lc.postChainEvents(events) return i, err } // CurrentHeader retrieves the current head header of the canonical chain. The // header is retrieved from the HeaderChain's internal cache. -func (self *LightChain) CurrentHeader() *types.Header { - return self.hc.CurrentHeader() +func (lc *LightChain) CurrentHeader() *types.Header { + return lc.hc.CurrentHeader() } // GetTd retrieves a block's total difficulty in the canonical chain from the // database by hash and number, caching it if found. -func (self *LightChain) GetTd(hash common.Hash, number uint64) *big.Int { - return self.hc.GetTd(hash, number) +func (lc *LightChain) GetTd(hash common.Hash, number uint64) *big.Int { + return lc.hc.GetTd(hash, number) } // GetTdByHash retrieves a block's total difficulty in the canonical chain from the // database by hash, caching it if found. -func (self *LightChain) GetTdByHash(hash common.Hash) *big.Int { - return self.hc.GetTdByHash(hash) +func (lc *LightChain) GetTdByHash(hash common.Hash) *big.Int { + return lc.hc.GetTdByHash(hash) } // GetHeader retrieves a block header from the database by hash and number, // caching it if found. -func (self *LightChain) GetHeader(hash common.Hash, number uint64) *types.Header { - return self.hc.GetHeader(hash, number) +func (lc *LightChain) GetHeader(hash common.Hash, number uint64) *types.Header { + return lc.hc.GetHeader(hash, number) } // GetHeaderByHash retrieves a block header from the database by hash, caching it if // found. -func (self *LightChain) GetHeaderByHash(hash common.Hash) *types.Header { - return self.hc.GetHeaderByHash(hash) +func (lc *LightChain) GetHeaderByHash(hash common.Hash) *types.Header { + return lc.hc.GetHeaderByHash(hash) } // HasHeader checks if a block header is present in the database or not, caching // it if present. -func (bc *LightChain) HasHeader(hash common.Hash, number uint64) bool { - return bc.hc.HasHeader(hash, number) +func (lc *LightChain) HasHeader(hash common.Hash, number uint64) bool { + return lc.hc.HasHeader(hash, number) } // GetCanonicalHash returns the canonical hash for a given block number -func (bc *LightChain) GetCanonicalHash(number uint64) common.Hash { - return bc.hc.GetCanonicalHash(number) +func (lc *LightChain) GetCanonicalHash(number uint64) common.Hash { + return lc.hc.GetCanonicalHash(number) } // GetBlockHashesFromHash retrieves a number of block hashes starting at a given // hash, fetching towards the genesis block. -func (self *LightChain) GetBlockHashesFromHash(hash common.Hash, max uint64) []common.Hash { - return self.hc.GetBlockHashesFromHash(hash, max) +func (lc *LightChain) GetBlockHashesFromHash(hash common.Hash, max uint64) []common.Hash { + return lc.hc.GetBlockHashesFromHash(hash, max) } // GetHeaderByNumber retrieves a block header from the database by number, // caching it (associated with its hash) if found. -func (self *LightChain) GetHeaderByNumber(number uint64) *types.Header { - return self.hc.GetHeaderByNumber(number) +func (lc *LightChain) GetHeaderByNumber(number uint64) *types.Header { + return lc.hc.GetHeaderByNumber(number) } // GetHeaderByNumberOdr retrieves a block header from the database or network // by number, caching it (associated with its hash) if found. -func (self *LightChain) GetHeaderByNumberOdr(ctx context.Context, number uint64) (*types.Header, error) { - if header := self.hc.GetHeaderByNumber(number); header != nil { +func (lc *LightChain) GetHeaderByNumberOdr(ctx context.Context, number uint64) (*types.Header, error) { + if header := lc.hc.GetHeaderByNumber(number); header != nil { return header, nil } - return GetHeaderByNumber(ctx, self.odr, number) + return GetHeaderByNumber(ctx, lc.odr, number) } // Config retrieves the header chain's chain configuration. -func (self *LightChain) Config() *params.ChainConfig { return self.hc.Config() } +func (lc *LightChain) Config() *params.ChainConfig { return lc.hc.Config() } -func (self *LightChain) SyncCht(ctx context.Context) bool { - if self.odr.ChtIndexer() == nil { +func (lc *LightChain) SyncCht(ctx context.Context) bool { + if lc.odr.ChtIndexer() == nil { return false } - headNum := self.CurrentHeader().Number.Uint64() - chtCount, _, _ := self.odr.ChtIndexer().Sections() + headNum := lc.CurrentHeader().Number.Uint64() + chtCount, _, _ := lc.odr.ChtIndexer().Sections() if headNum+1 < chtCount*CHTFrequencyClient { num := chtCount*CHTFrequencyClient - 1 - header, err := GetHeaderByNumber(ctx, self.odr, num) + header, err := GetHeaderByNumber(ctx, lc.odr, num) if header != nil && err == nil { - self.mu.Lock() - if self.hc.CurrentHeader().Number.Uint64() < header.Number.Uint64() { - self.hc.SetCurrentHeader(header) + lc.mu.Lock() + if lc.hc.CurrentHeader().Number.Uint64() < header.Number.Uint64() { + lc.hc.SetCurrentHeader(header) } - self.mu.Unlock() + lc.mu.Unlock() return true } } @@ -471,38 +471,38 @@ func (self *LightChain) SyncCht(ctx context.Context) bool { // LockChain locks the chain mutex for reading so that multiple canonical hashes can be // retrieved while it is guaranteed that they belong to the same version of the chain -func (self *LightChain) LockChain() { - self.chainmu.RLock() +func (lc *LightChain) LockChain() { + lc.chainmu.RLock() } // UnlockChain unlocks the chain mutex -func (self *LightChain) UnlockChain() { - self.chainmu.RUnlock() +func (lc *LightChain) UnlockChain() { + lc.chainmu.RUnlock() } // SubscribeChainEvent registers a subscription of ChainEvent. -func (self *LightChain) SubscribeChainEvent(ch chan<- core.ChainEvent) event.Subscription { - return self.scope.Track(self.chainFeed.Subscribe(ch)) +func (lc *LightChain) SubscribeChainEvent(ch chan<- core.ChainEvent) event.Subscription { + return lc.scope.Track(lc.chainFeed.Subscribe(ch)) } // SubscribeChainHeadEvent registers a subscription of ChainHeadEvent. -func (self *LightChain) SubscribeChainHeadEvent(ch chan<- core.ChainHeadEvent) event.Subscription { - return self.scope.Track(self.chainHeadFeed.Subscribe(ch)) +func (lc *LightChain) SubscribeChainHeadEvent(ch chan<- core.ChainHeadEvent) event.Subscription { + return lc.scope.Track(lc.chainHeadFeed.Subscribe(ch)) } // SubscribeChainSideEvent registers a subscription of ChainSideEvent. -func (self *LightChain) SubscribeChainSideEvent(ch chan<- core.ChainSideEvent) event.Subscription { - return self.scope.Track(self.chainSideFeed.Subscribe(ch)) +func (lc *LightChain) SubscribeChainSideEvent(ch chan<- core.ChainSideEvent) event.Subscription { + return lc.scope.Track(lc.chainSideFeed.Subscribe(ch)) } // SubscribeLogsEvent implements the interface of filters.Backend // LightChain does not send logs events, so return an empty subscription. -func (self *LightChain) SubscribeLogsEvent(ch chan<- []*types.Log) event.Subscription { - return self.scope.Track(new(event.Feed).Subscribe(ch)) +func (lc *LightChain) SubscribeLogsEvent(ch chan<- []*types.Log) event.Subscription { + return lc.scope.Track(new(event.Feed).Subscribe(ch)) } // SubscribeRemovedLogsEvent implements the interface of filters.Backend // LightChain does not send core.RemovedLogsEvent, so return an empty subscription. -func (self *LightChain) SubscribeRemovedLogsEvent(ch chan<- core.RemovedLogsEvent) event.Subscription { - return self.scope.Track(new(event.Feed).Subscribe(ch)) +func (lc *LightChain) SubscribeRemovedLogsEvent(ch chan<- core.RemovedLogsEvent) event.Subscription { + return lc.scope.Track(new(event.Feed).Subscribe(ch)) } diff --git a/light/txpool.go b/light/txpool.go index ed551e2329..92e42101a7 100644 --- a/light/txpool.go +++ b/light/txpool.go @@ -113,25 +113,25 @@ func NewTxPool(config *params.ChainConfig, chain *LightChain, relay TxRelayBacke } // currentState returns the light state of the current head header -func (pool *TxPool) currentState(ctx context.Context) *state.StateDB { - return NewState(ctx, pool.chain.CurrentHeader(), pool.odr) +func (p *TxPool) currentState(ctx context.Context) *state.StateDB { + return NewState(ctx, p.chain.CurrentHeader(), p.odr) } // GetNonce returns the "pending" nonce of a given address. It always queries // the nonce belonging to the latest header too in order to detect if another // client using the same key sent a transaction. -func (pool *TxPool) GetNonce(ctx context.Context, addr common.Address) (uint64, error) { - state := pool.currentState(ctx) +func (p *TxPool) GetNonce(ctx context.Context, addr common.Address) (uint64, error) { + state := p.currentState(ctx) nonce := state.GetNonce(addr) if state.Error() != nil { return 0, state.Error() } - sn, ok := pool.nonce[addr] + sn, ok := p.nonce[addr] if ok && sn > nonce { nonce = sn } if !ok || sn < nonce { - pool.nonce[addr] = nonce + p.nonce[addr] = nonce } return nonce, nil } @@ -165,52 +165,52 @@ func (txc txStateChanges) getLists() (mined []common.Hash, rollback []common.Has // checkMinedTxs checks newly added blocks for the currently pending transactions // and marks them as mined if necessary. It also stores block position in the db // and adds them to the received txStateChanges map. -func (pool *TxPool) checkMinedTxs(ctx context.Context, hash common.Hash, number uint64, txc txStateChanges) error { +func (p *TxPool) checkMinedTxs(ctx context.Context, hash common.Hash, number uint64, txc txStateChanges) error { // If no transactions are pending, we don't care about anything - if len(pool.pending) == 0 { + if len(p.pending) == 0 { return nil } - block, err := GetBlock(ctx, pool.odr, hash, number) + block, err := GetBlock(ctx, p.odr, hash, number) if err != nil { return err } // Gather all the local transaction mined in this block - list := pool.mined[hash] + list := p.mined[hash] for _, tx := range block.Transactions() { - if _, ok := pool.pending[tx.Hash()]; ok { + if _, ok := p.pending[tx.Hash()]; ok { list = append(list, tx) } } // If some transactions have been mined, write the needed data to disk and update if list != nil { // Retrieve all the receipts belonging to this block and write the lookup table - if _, err := GetBlockReceipts(ctx, pool.odr, hash, number); err != nil { // ODR caches, ignore results + if _, err := GetBlockReceipts(ctx, p.odr, hash, number); err != nil { // ODR caches, ignore results return err } - if err := core.WriteTxLookupEntries(pool.chainDb, block); err != nil { + if err := core.WriteTxLookupEntries(p.chainDb, block); err != nil { return err } // Update the transaction pool's state for _, tx := range list { - delete(pool.pending, tx.Hash()) + delete(p.pending, tx.Hash()) txc.setState(tx.Hash(), true) } - pool.mined[hash] = list + p.mined[hash] = list } return nil } // rollbackTxs marks the transactions contained in recently rolled back blocks // as rolled back. It also removes any positional lookup entries. -func (pool *TxPool) rollbackTxs(hash common.Hash, txc txStateChanges) { - if list, ok := pool.mined[hash]; ok { +func (p *TxPool) rollbackTxs(hash common.Hash, txc txStateChanges) { + if list, ok := p.mined[hash]; ok { for _, tx := range list { txHash := tx.Hash() - core.DeleteTxLookupEntry(pool.chainDb, txHash) - pool.pending[txHash] = tx + core.DeleteTxLookupEntry(p.chainDb, txHash) + p.pending[txHash] = tx txc.setState(txHash, false) } - delete(pool.mined, hash) + delete(p.mined, hash) } } @@ -220,60 +220,60 @@ func (pool *TxPool) rollbackTxs(hash common.Hash, txc txStateChanges) { // timeout) occurs during checking new blocks, it leaves the locally known head // at the latest checked block and still returns a valid txStateChanges, making it // possible to continue checking the missing blocks at the next chain head event -func (pool *TxPool) reorgOnNewHead(ctx context.Context, newHeader *types.Header) (txStateChanges, error) { +func (p *TxPool) reorgOnNewHead(ctx context.Context, newHeader *types.Header) (txStateChanges, error) { txc := make(txStateChanges) - oldh := pool.chain.GetHeaderByHash(pool.head) + oldh := p.chain.GetHeaderByHash(p.head) newh := newHeader // find common ancestor, create list of rolled back and new block hashes var oldHashes, newHashes []common.Hash for oldh.Hash() != newh.Hash() { if oldh.Number.Uint64() >= newh.Number.Uint64() { oldHashes = append(oldHashes, oldh.Hash()) - oldh = pool.chain.GetHeader(oldh.ParentHash, oldh.Number.Uint64()-1) + oldh = p.chain.GetHeader(oldh.ParentHash, oldh.Number.Uint64()-1) } if oldh.Number.Uint64() < newh.Number.Uint64() { newHashes = append(newHashes, newh.Hash()) - newh = pool.chain.GetHeader(newh.ParentHash, newh.Number.Uint64()-1) + newh = p.chain.GetHeader(newh.ParentHash, newh.Number.Uint64()-1) if newh == nil { // happens when CHT syncing, nothing to do newh = oldh } } } - if oldh.Number.Uint64() < pool.clearIdx { - pool.clearIdx = oldh.Number.Uint64() + if oldh.Number.Uint64() < p.clearIdx { + p.clearIdx = oldh.Number.Uint64() } // roll back old blocks for _, hash := range oldHashes { - pool.rollbackTxs(hash, txc) + p.rollbackTxs(hash, txc) } - pool.head = oldh.Hash() + p.head = oldh.Hash() // check mined txs of new blocks (array is in reversed order) for i := len(newHashes) - 1; i >= 0; i-- { hash := newHashes[i] - if err := pool.checkMinedTxs(ctx, hash, newHeader.Number.Uint64()-uint64(i), txc); err != nil { + if err := p.checkMinedTxs(ctx, hash, newHeader.Number.Uint64()-uint64(i), txc); err != nil { return txc, err } - pool.head = hash + p.head = hash } // clear old mined tx entries of old blocks - if idx := newHeader.Number.Uint64(); idx > pool.clearIdx+txPermanent { + if idx := newHeader.Number.Uint64(); idx > p.clearIdx+txPermanent { idx2 := idx - txPermanent - if len(pool.mined) > 0 { - for i := pool.clearIdx; i < idx2; i++ { - hash := core.GetCanonicalHash(pool.chainDb, i) - if list, ok := pool.mined[hash]; ok { + if len(p.mined) > 0 { + for i := p.clearIdx; i < idx2; i++ { + hash := core.GetCanonicalHash(p.chainDb, i) + if list, ok := p.mined[hash]; ok { hashes := make([]common.Hash, len(list)) for i, tx := range list { hashes[i] = tx.Hash() } - pool.relay.Discard(hashes) - delete(pool.mined, hash) + p.relay.Discard(hashes) + delete(p.mined, hash) } } } - pool.clearIdx = idx2 + p.clearIdx = idx2 } return txc, nil @@ -285,66 +285,66 @@ const blockCheckTimeout = time.Second * 3 // eventLoop processes chain head events and also notifies the tx relay backend // about the new head hash and tx state changes -func (pool *TxPool) eventLoop() { +func (p *TxPool) eventLoop() { for { select { - case ev := <-pool.chainHeadCh: - pool.setNewHead(ev.Block.Header()) + case ev := <-p.chainHeadCh: + p.setNewHead(ev.Block.Header()) // hack in order to avoid hogging the lock; this part will // be replaced by a subsequent PR. time.Sleep(time.Millisecond) // System stopped - case <-pool.chainHeadSub.Err(): + case <-p.chainHeadSub.Err(): return } } } -func (pool *TxPool) setNewHead(head *types.Header) { - pool.mu.Lock() - defer pool.mu.Unlock() +func (p *TxPool) setNewHead(head *types.Header) { + p.mu.Lock() + defer p.mu.Unlock() ctx, cancel := context.WithTimeout(context.Background(), blockCheckTimeout) defer cancel() - txc, _ := pool.reorgOnNewHead(ctx, head) + txc, _ := p.reorgOnNewHead(ctx, head) m, r := txc.getLists() - pool.relay.NewHead(pool.head, m, r) + p.relay.NewHead(p.head, m, r) // Update fork indicator by next pending block number next := new(big.Int).Add(head.Number, big.NewInt(1)) - pool.homestead = pool.config.IsHomestead(head.Number) - pool.eip2718 = pool.config.IsEIP1559(next) + p.homestead = p.config.IsHomestead(head.Number) + p.eip2718 = p.config.IsEIP1559(next) } // Stop stops the light transaction pool -func (pool *TxPool) Stop() { +func (p *TxPool) Stop() { // Unsubscribe all subscriptions registered from txpool - pool.scope.Close() + p.scope.Close() // Unsubscribe subscriptions registered from blockchain - pool.chainHeadSub.Unsubscribe() - close(pool.quit) + p.chainHeadSub.Unsubscribe() + close(p.quit) log.Info("Transaction pool stopped") } // SubscribeNewTxsEvent registers a subscription of core.NewTxsEvent and // starts sending event to the given channel. -func (pool *TxPool) SubscribeNewTxsEvent(ch chan<- core.NewTxsEvent) event.Subscription { - return pool.scope.Track(pool.txFeed.Subscribe(ch)) +func (p *TxPool) SubscribeNewTxsEvent(ch chan<- core.NewTxsEvent) event.Subscription { + return p.scope.Track(p.txFeed.Subscribe(ch)) } // Stats returns the number of currently pending (locally created) transactions -func (pool *TxPool) Stats() (pending int) { - pool.mu.RLock() - defer pool.mu.RUnlock() +func (p *TxPool) Stats() (pending int) { + p.mu.RLock() + defer p.mu.RUnlock() - pending = len(pool.pending) + pending = len(p.pending) return } // validateTx checks whether a transaction is valid according to the consensus rules. -func (pool *TxPool) validateTx(ctx context.Context, tx *types.Transaction) error { +func (p *TxPool) validateTx(ctx context.Context, tx *types.Transaction) error { // Validate sender var ( from common.Address @@ -362,33 +362,33 @@ func (pool *TxPool) validateTx(ctx context.Context, tx *types.Transaction) error // validate minFee slot for XDCZ if tx.IsXDCZApplyTransaction() { - copyState := pool.currentState(ctx).Copy() - if err := core.ValidateXDCZApplyTransaction(pool.chain, nil, copyState, common.BytesToAddress(tx.Data()[4:])); err != nil { + copyState := p.currentState(ctx).Copy() + if err := core.ValidateXDCZApplyTransaction(p.chain, nil, copyState, common.BytesToAddress(tx.Data()[4:])); err != nil { return err } } // validate balance slot, token decimal for XDCX if tx.IsXDCXApplyTransaction() { - copyState := pool.currentState(ctx).Copy() - if err := core.ValidateXDCXApplyTransaction(pool.chain, nil, copyState, common.BytesToAddress(tx.Data()[4:])); err != nil { + copyState := p.currentState(ctx).Copy() + if err := core.ValidateXDCXApplyTransaction(p.chain, nil, copyState, common.BytesToAddress(tx.Data()[4:])); err != nil { return err } } // Validate the transaction sender and it's sig. Throw // if the from fields is invalid. - if from, err = types.Sender(pool.signer, tx); err != nil { + if from, err = types.Sender(p.signer, tx); err != nil { return core.ErrInvalidSender } // Last but not least check for nonce errors - currentState := pool.currentState(ctx) + currentState := p.currentState(ctx) if n := currentState.GetNonce(from); n > tx.Nonce() { return core.ErrNonceTooLow } // Check the transaction doesn't exceed the current // block limit gas. - header := pool.chain.GetHeaderByHash(pool.head) + header := p.chain.GetHeaderByHash(p.head) if header.GasLimit < tx.Gas() { return core.ErrGasLimit } @@ -407,7 +407,7 @@ func (pool *TxPool) validateTx(ctx context.Context, tx *types.Transaction) error } // Should supply enough intrinsic gas - gas, err := core.IntrinsicGas(tx.Data(), tx.AccessList(), tx.To() == nil, pool.homestead) + gas, err := core.IntrinsicGas(tx.Data(), tx.AccessList(), tx.To() == nil, p.homestead) if err != nil { return err } @@ -419,80 +419,80 @@ func (pool *TxPool) validateTx(ctx context.Context, tx *types.Transaction) error // add validates a new transaction and sets its state pending if processable. // It also updates the locally stored nonce if necessary. -func (self *TxPool) add(ctx context.Context, tx *types.Transaction) error { +func (p *TxPool) add(ctx context.Context, tx *types.Transaction) error { hash := tx.Hash() - if self.pending[hash] != nil { + if p.pending[hash] != nil { return fmt.Errorf("known transaction (%x)", hash[:4]) } - err := self.validateTx(ctx, tx) + err := p.validateTx(ctx, tx) if err != nil { return err } - if _, ok := self.pending[hash]; !ok { - self.pending[hash] = tx + if _, ok := p.pending[hash]; !ok { + p.pending[hash] = tx nonce := tx.Nonce() + 1 - addr, _ := types.Sender(self.signer, tx) - if nonce > self.nonce[addr] { - self.nonce[addr] = nonce + addr, _ := types.Sender(p.signer, tx) + if nonce > p.nonce[addr] { + p.nonce[addr] = nonce } // Notify the subscribers. This event is posted in a goroutine // because it's possible that somewhere during the post "Remove transaction" // gets called which will then wait for the global tx pool lock and deadlock. - go self.txFeed.Send(core.NewTxsEvent{Txs: types.Transactions{tx}}) + go p.txFeed.Send(core.NewTxsEvent{Txs: types.Transactions{tx}}) } // Print a log message if low enough level is set - log.Debug("Pooled new transaction", "hash", hash, "from", log.Lazy{Fn: func() common.Address { from, _ := types.Sender(self.signer, tx); return from }}, "to", tx.To()) + log.Debug("Pooled new transaction", "hash", hash, "from", log.Lazy{Fn: func() common.Address { from, _ := types.Sender(p.signer, tx); return from }}, "to", tx.To()) return nil } // Add adds a transaction to the pool if valid and passes it to the tx relay // backend -func (self *TxPool) Add(ctx context.Context, tx *types.Transaction) error { - self.mu.Lock() - defer self.mu.Unlock() +func (p *TxPool) Add(ctx context.Context, tx *types.Transaction) error { + p.mu.Lock() + defer p.mu.Unlock() data, err := tx.MarshalBinary() if err != nil { return err } - if err := self.add(ctx, tx); err != nil { + if err := p.add(ctx, tx); err != nil { return err } //fmt.Println("Send", tx.Hash()) - self.relay.Send(types.Transactions{tx}) + p.relay.Send(types.Transactions{tx}) - self.chainDb.Put(tx.Hash().Bytes(), data) + p.chainDb.Put(tx.Hash().Bytes(), data) return nil } // AddTransactions adds all valid transactions to the pool and passes them to // the tx relay backend -func (self *TxPool) AddBatch(ctx context.Context, txs []*types.Transaction) { - self.mu.Lock() - defer self.mu.Unlock() +func (p *TxPool) AddBatch(ctx context.Context, txs []*types.Transaction) { + p.mu.Lock() + defer p.mu.Unlock() var sendTx types.Transactions for _, tx := range txs { - if err := self.add(ctx, tx); err == nil { + if err := p.add(ctx, tx); err == nil { sendTx = append(sendTx, tx) } } if len(sendTx) > 0 { - self.relay.Send(sendTx) + p.relay.Send(sendTx) } } // GetTransaction returns a transaction if it is contained in the pool // and nil otherwise. -func (tp *TxPool) GetTransaction(hash common.Hash) *types.Transaction { +func (p *TxPool) GetTransaction(hash common.Hash) *types.Transaction { // check the txs first - if tx, ok := tp.pending[hash]; ok { + if tx, ok := p.pending[hash]; ok { return tx } return nil @@ -500,13 +500,13 @@ func (tp *TxPool) GetTransaction(hash common.Hash) *types.Transaction { // GetTransactions returns all currently processable transactions. // The returned slice may be modified by the caller. -func (self *TxPool) GetTransactions() (txs types.Transactions, err error) { - self.mu.RLock() - defer self.mu.RUnlock() +func (p *TxPool) GetTransactions() (txs types.Transactions, err error) { + p.mu.RLock() + defer p.mu.RUnlock() - txs = make(types.Transactions, len(self.pending)) + txs = make(types.Transactions, len(p.pending)) i := 0 - for _, tx := range self.pending { + for _, tx := range p.pending { txs[i] = tx i++ } @@ -515,14 +515,14 @@ func (self *TxPool) GetTransactions() (txs types.Transactions, err error) { // Content retrieves the data content of the transaction pool, returning all the // pending as well as queued transactions, grouped by account and nonce. -func (self *TxPool) Content() (map[common.Address]types.Transactions, map[common.Address]types.Transactions) { - self.mu.RLock() - defer self.mu.RUnlock() +func (p *TxPool) Content() (map[common.Address]types.Transactions, map[common.Address]types.Transactions) { + p.mu.RLock() + defer p.mu.RUnlock() // Retrieve all the pending transactions and sort by account and by nonce pending := make(map[common.Address]types.Transactions) - for _, tx := range self.pending { - account, _ := types.Sender(self.signer, tx) + for _, tx := range p.pending { + account, _ := types.Sender(p.signer, tx) pending[account] = append(pending[account], tx) } // There are no queued transactions in a light pool, just return an empty map @@ -531,26 +531,26 @@ func (self *TxPool) Content() (map[common.Address]types.Transactions, map[common } // RemoveTransactions removes all given transactions from the pool. -func (self *TxPool) RemoveTransactions(txs types.Transactions) { - self.mu.Lock() - defer self.mu.Unlock() +func (p *TxPool) RemoveTransactions(txs types.Transactions) { + p.mu.Lock() + defer p.mu.Unlock() var hashes []common.Hash for _, tx := range txs { //self.RemoveTx(tx.Hash()) hash := tx.Hash() - delete(self.pending, hash) - self.chainDb.Delete(hash[:]) + delete(p.pending, hash) + p.chainDb.Delete(hash[:]) hashes = append(hashes, hash) } - self.relay.Discard(hashes) + p.relay.Discard(hashes) } // RemoveTx removes the transaction with the given hash from the pool. -func (pool *TxPool) RemoveTx(hash common.Hash) { - pool.mu.Lock() - defer pool.mu.Unlock() +func (p *TxPool) RemoveTx(hash common.Hash) { + p.mu.Lock() + defer p.mu.Unlock() // delete from pending pool - delete(pool.pending, hash) - pool.chainDb.Delete(hash[:]) - pool.relay.Discard([]common.Hash{hash}) + delete(p.pending, hash) + p.chainDb.Delete(hash[:]) + p.relay.Discard([]common.Hash{hash}) } diff --git a/light/txpool_test.go b/light/txpool_test.go index 4ada980daf..467efb9cd0 100644 --- a/light/txpool_test.go +++ b/light/txpool_test.go @@ -36,19 +36,19 @@ type testTxRelay struct { send, discard, mined chan int } -func (self *testTxRelay) Send(txs types.Transactions) { - self.send <- len(txs) +func (r *testTxRelay) Send(txs types.Transactions) { + r.send <- len(txs) } -func (self *testTxRelay) NewHead(head common.Hash, mined []common.Hash, rollback []common.Hash) { +func (r *testTxRelay) NewHead(head common.Hash, mined []common.Hash, rollback []common.Hash) { m := len(mined) if m != 0 { - self.mined <- m + r.mined <- m } } -func (self *testTxRelay) Discard(hashes []common.Hash) { - self.discard <- len(hashes) +func (r *testTxRelay) Discard(hashes []common.Hash) { + r.discard <- len(hashes) } const poolTestTxs = 1000 diff --git a/metrics/librato/client.go b/metrics/librato/client.go index 75503bb19d..a807c392af 100644 --- a/metrics/librato/client.go +++ b/metrics/librato/client.go @@ -65,7 +65,7 @@ type Batch struct { Source string `json:"source"` } -func (self *LibratoClient) PostMetrics(batch Batch) (err error) { +func (lc *LibratoClient) PostMetrics(batch Batch) (err error) { var ( js []byte req *http.Request @@ -85,7 +85,7 @@ func (self *LibratoClient) PostMetrics(batch Batch) (err error) { } req.Header.Set("Content-Type", "application/json") - req.SetBasicAuth(self.Email, self.Token) + req.SetBasicAuth(lc.Email, lc.Token) if resp, err = http.DefaultClient.Do(req); err != nil { return diff --git a/metrics/librato/librato.go b/metrics/librato/librato.go index 58ced3bf9a..45bf6cf297 100644 --- a/metrics/librato/librato.go +++ b/metrics/librato/librato.go @@ -40,14 +40,14 @@ func Librato(r metrics.Registry, d time.Duration, e string, t string, s string, NewReporter(r, d, e, t, s, p, u).Run() } -func (self *Reporter) Run() { +func (re *Reporter) Run() { log.Printf("WARNING: This client has been DEPRECATED! It has been moved to https://github.com/mihasya/go-metrics-librato and will be removed from rcrowley/go-metrics on August 5th 2015") - ticker := time.Tick(self.Interval) - metricsApi := &LibratoClient{self.Email, self.Token} + ticker := time.Tick(re.Interval) + metricsApi := &LibratoClient{re.Email, re.Token} for now := range ticker { var metrics Batch var err error - if metrics, err = self.BuildRequest(now, self.Registry); err != nil { + if metrics, err = re.BuildRequest(now, re.Registry); err != nil { log.Printf("ERROR constructing librato request body %s", err) continue } @@ -79,21 +79,21 @@ func sumSquaresTimer(t metrics.Timer) float64 { return sumSquares } -func (self *Reporter) BuildRequest(now time.Time, r metrics.Registry) (snapshot Batch, err error) { +func (re *Reporter) BuildRequest(now time.Time, r metrics.Registry) (snapshot Batch, err error) { snapshot = Batch{ // coerce timestamps to a stepping fn so that they line up in Librato graphs - MeasureTime: (now.Unix() / self.intervalSec) * self.intervalSec, - Source: self.Source, + MeasureTime: (now.Unix() / re.intervalSec) * re.intervalSec, + Source: re.Source, } snapshot.Gauges = make([]Measurement, 0) snapshot.Counters = make([]Measurement, 0) - histogramGaugeCount := 1 + len(self.Percentiles) + histogramGaugeCount := 1 + len(re.Percentiles) r.Each(func(name string, metric interface{}) { - if self.Namespace != "" { - name = fmt.Sprintf("%s.%s", self.Namespace, name) + if re.Namespace != "" { + name = fmt.Sprintf("%s.%s", re.Namespace, name) } measurement := Measurement{} - measurement[Period] = self.Interval.Seconds() + measurement[Period] = re.Interval.Seconds() switch m := metric.(type) { case metrics.Counter: if m.Count() > 0 { @@ -125,7 +125,7 @@ func (self *Reporter) BuildRequest(now time.Time, r metrics.Registry) (snapshot measurement[Sum] = float64(s.Sum()) measurement[SumSquares] = sumSquares(s) gauges[0] = measurement - for i, p := range self.Percentiles { + for i, p := range re.Percentiles { gauges[i+1] = Measurement{ Name: fmt.Sprintf("%s.%.2f", measurement[Name], p), Value: s.Percentile(p), @@ -142,7 +142,7 @@ func (self *Reporter) BuildRequest(now time.Time, r metrics.Registry) (snapshot Measurement{ Name: fmt.Sprintf("%s.%s", name, "1min"), Value: m.Rate1(), - Period: int64(self.Interval.Seconds()), + Period: int64(re.Interval.Seconds()), Attributes: map[string]interface{}{ DisplayUnitsLong: Operations, DisplayUnitsShort: OperationsShort, @@ -152,7 +152,7 @@ func (self *Reporter) BuildRequest(now time.Time, r metrics.Registry) (snapshot Measurement{ Name: fmt.Sprintf("%s.%s", name, "5min"), Value: m.Rate5(), - Period: int64(self.Interval.Seconds()), + Period: int64(re.Interval.Seconds()), Attributes: map[string]interface{}{ DisplayUnitsLong: Operations, DisplayUnitsShort: OperationsShort, @@ -162,7 +162,7 @@ func (self *Reporter) BuildRequest(now time.Time, r metrics.Registry) (snapshot Measurement{ Name: fmt.Sprintf("%s.%s", name, "15min"), Value: m.Rate15(), - Period: int64(self.Interval.Seconds()), + Period: int64(re.Interval.Seconds()), Attributes: map[string]interface{}{ DisplayUnitsLong: Operations, DisplayUnitsShort: OperationsShort, @@ -184,15 +184,15 @@ func (self *Reporter) BuildRequest(now time.Time, r metrics.Registry) (snapshot Max: float64(m.Max()), Min: float64(m.Min()), SumSquares: sumSquaresTimer(m), - Period: int64(self.Interval.Seconds()), - Attributes: self.TimerAttributes, + Period: int64(re.Interval.Seconds()), + Attributes: re.TimerAttributes, } - for i, p := range self.Percentiles { + for i, p := range re.Percentiles { gauges[i+1] = Measurement{ Name: fmt.Sprintf("%s.timer.%2.0f", name, p*100), Value: m.Percentile(p), - Period: int64(self.Interval.Seconds()), - Attributes: self.TimerAttributes, + Period: int64(re.Interval.Seconds()), + Attributes: re.TimerAttributes, } } snapshot.Gauges = append(snapshot.Gauges, gauges...) @@ -200,7 +200,7 @@ func (self *Reporter) BuildRequest(now time.Time, r metrics.Registry) (snapshot Measurement{ Name: fmt.Sprintf("%s.%s", name, "rate.1min"), Value: m.Rate1(), - Period: int64(self.Interval.Seconds()), + Period: int64(re.Interval.Seconds()), Attributes: map[string]interface{}{ DisplayUnitsLong: Operations, DisplayUnitsShort: OperationsShort, @@ -210,7 +210,7 @@ func (self *Reporter) BuildRequest(now time.Time, r metrics.Registry) (snapshot Measurement{ Name: fmt.Sprintf("%s.%s", name, "rate.5min"), Value: m.Rate5(), - Period: int64(self.Interval.Seconds()), + Period: int64(re.Interval.Seconds()), Attributes: map[string]interface{}{ DisplayUnitsLong: Operations, DisplayUnitsShort: OperationsShort, @@ -220,7 +220,7 @@ func (self *Reporter) BuildRequest(now time.Time, r metrics.Registry) (snapshot Measurement{ Name: fmt.Sprintf("%s.%s", name, "rate.15min"), Value: m.Rate15(), - Period: int64(self.Interval.Seconds()), + Period: int64(re.Interval.Seconds()), Attributes: map[string]interface{}{ DisplayUnitsLong: Operations, DisplayUnitsShort: OperationsShort, diff --git a/miner/agent.go b/miner/agent.go index 5ea0a17ddd..4616c2c5bc 100644 --- a/miner/agent.go +++ b/miner/agent.go @@ -49,70 +49,70 @@ func NewCpuAgent(chain consensus.ChainReader, engine consensus.Engine) *CpuAgent return miner } -func (self *CpuAgent) Work() chan<- *Work { return self.workCh } -func (self *CpuAgent) SetReturnCh(ch chan<- *Result) { self.returnCh = ch } +func (ca *CpuAgent) Work() chan<- *Work { return ca.workCh } +func (ca *CpuAgent) SetReturnCh(ch chan<- *Result) { ca.returnCh = ch } -func (self *CpuAgent) Stop() { - if !atomic.CompareAndSwapInt32(&self.isMining, 1, 0) { +func (ca *CpuAgent) Stop() { + if !atomic.CompareAndSwapInt32(&ca.isMining, 1, 0) { return // agent already stopped } - self.stop <- struct{}{} + ca.stop <- struct{}{} done: // Empty work channel for { select { - case <-self.workCh: + case <-ca.workCh: default: break done } } } -func (self *CpuAgent) Start() { - if !atomic.CompareAndSwapInt32(&self.isMining, 0, 1) { +func (ca *CpuAgent) Start() { + if !atomic.CompareAndSwapInt32(&ca.isMining, 0, 1) { return // agent already started } - go self.update() + go ca.update() } -func (self *CpuAgent) update() { +func (ca *CpuAgent) update() { out: for { select { - case work := <-self.workCh: - self.mu.Lock() - if self.quitCurrentOp != nil { - close(self.quitCurrentOp) + case work := <-ca.workCh: + ca.mu.Lock() + if ca.quitCurrentOp != nil { + close(ca.quitCurrentOp) } - self.quitCurrentOp = make(chan struct{}) - go self.mine(work, self.quitCurrentOp) - self.mu.Unlock() - case <-self.stop: - self.mu.Lock() - if self.quitCurrentOp != nil { - close(self.quitCurrentOp) - self.quitCurrentOp = nil + ca.quitCurrentOp = make(chan struct{}) + go ca.mine(work, ca.quitCurrentOp) + ca.mu.Unlock() + case <-ca.stop: + ca.mu.Lock() + if ca.quitCurrentOp != nil { + close(ca.quitCurrentOp) + ca.quitCurrentOp = nil } - self.mu.Unlock() + ca.mu.Unlock() break out } } } -func (self *CpuAgent) mine(work *Work, stop <-chan struct{}) { - if result, err := self.engine.Seal(self.chain, work.Block, stop); result != nil { +func (ca *CpuAgent) mine(work *Work, stop <-chan struct{}) { + if result, err := ca.engine.Seal(ca.chain, work.Block, stop); result != nil { log.Info("Successfully sealed new block", "number", result.Number(), "hash", result.Hash()) - self.returnCh <- &Result{work, result} + ca.returnCh <- &Result{work, result} } else { if err != nil { log.Warn("Block sealing failed", "err", err) } - self.returnCh <- nil + ca.returnCh <- nil } } -func (self *CpuAgent) GetHashRate() int64 { - if pow, ok := self.engine.(consensus.PoW); ok { +func (ca *CpuAgent) GetHashRate() int64 { + if pow, ok := ca.engine.(consensus.PoW); ok { return int64(pow.Hashrate()) } return 0 diff --git a/miner/miner.go b/miner/miner.go index 8177e45c8e..0b4354c4d8 100644 --- a/miner/miner.go +++ b/miner/miner.go @@ -82,73 +82,73 @@ func New(eth Backend, config *params.ChainConfig, mux *event.TypeMux, engine con // It's entered once and as soon as `Done` or `Failed` has been broadcasted the events are unregistered and // the loop is exited. This to prevent a major security vuln where external parties can DOS you with blocks // and halt your mining operation for as long as the DOS continues. -func (self *Miner) update() { - events := self.mux.Subscribe(downloader.StartEvent{}, downloader.DoneEvent{}, downloader.FailedEvent{}) +func (m *Miner) update() { + events := m.mux.Subscribe(downloader.StartEvent{}, downloader.DoneEvent{}, downloader.FailedEvent{}) for ev := range events.Chan() { switch ev.Data.(type) { case downloader.StartEvent: - atomic.StoreInt32(&self.canStart, 0) - if self.Mining() { - self.Stop() - atomic.StoreInt32(&self.shouldStart, 1) + atomic.StoreInt32(&m.canStart, 0) + if m.Mining() { + m.Stop() + atomic.StoreInt32(&m.shouldStart, 1) log.Info("Mining aborted due to sync") } case downloader.DoneEvent, downloader.FailedEvent: - shouldStart := atomic.LoadInt32(&self.shouldStart) == 1 + shouldStart := atomic.LoadInt32(&m.shouldStart) == 1 - atomic.StoreInt32(&self.canStart, 1) - atomic.StoreInt32(&self.shouldStart, 0) + atomic.StoreInt32(&m.canStart, 1) + atomic.StoreInt32(&m.shouldStart, 0) if shouldStart { - self.Start(self.coinbase) + m.Start(m.coinbase) } } } } -func (self *Miner) Start(coinbase common.Address) { - atomic.StoreInt32(&self.shouldStart, 1) - self.SetEtherbase(coinbase) +func (m *Miner) Start(coinbase common.Address) { + atomic.StoreInt32(&m.shouldStart, 1) + m.SetEtherbase(coinbase) - if atomic.LoadInt32(&self.canStart) == 0 { + if atomic.LoadInt32(&m.canStart) == 0 { log.Info("Network syncing, will start miner afterwards") return } - atomic.StoreInt32(&self.mining, 1) + atomic.StoreInt32(&m.mining, 1) log.Info("Starting mining operation") - self.worker.start() - self.worker.commitNewWork() + m.worker.start() + m.worker.commitNewWork() } -func (self *Miner) Stop() { - self.worker.stop() - atomic.StoreInt32(&self.mining, 0) - atomic.StoreInt32(&self.shouldStart, 0) +func (m *Miner) Stop() { + m.worker.stop() + atomic.StoreInt32(&m.mining, 0) + atomic.StoreInt32(&m.shouldStart, 0) } -func (self *Miner) Register(agent Agent) { - if self.Mining() { +func (m *Miner) Register(agent Agent) { + if m.Mining() { agent.Start() } - self.worker.register(agent) + m.worker.register(agent) } -func (self *Miner) Unregister(agent Agent) { - self.worker.unregister(agent) +func (m *Miner) Unregister(agent Agent) { + m.worker.unregister(agent) } -func (self *Miner) Mining() bool { - return atomic.LoadInt32(&self.mining) > 0 +func (m *Miner) Mining() bool { + return atomic.LoadInt32(&m.mining) > 0 } -func (self *Miner) HashRate() (tot int64) { - if pow, ok := self.engine.(consensus.PoW); ok { +func (m *Miner) HashRate() (tot int64) { + if pow, ok := m.engine.(consensus.PoW); ok { tot += int64(pow.Hashrate()) } // do we care this might race? is it worth we're rewriting some // aspects of the worker/locking up agents so we can get an accurate // hashrate? - for agent := range self.worker.agents { + for agent := range m.worker.agents { if _, ok := agent.(*CpuAgent); !ok { tot += agent.GetHashRate() } @@ -156,17 +156,17 @@ func (self *Miner) HashRate() (tot int64) { return } -func (self *Miner) SetExtra(extra []byte) error { +func (m *Miner) SetExtra(extra []byte) error { if uint64(len(extra)) > params.MaximumExtraDataSize { return fmt.Errorf("extra exceeds max length: %d > %v", len(extra), params.MaximumExtraDataSize) } - self.worker.setExtra(extra) + m.worker.setExtra(extra) return nil } // Pending returns the currently pending block and associated state. -func (self *Miner) Pending() (*types.Block, *state.StateDB) { - return self.worker.pending() +func (m *Miner) Pending() (*types.Block, *state.StateDB) { + return m.worker.pending() } // PendingBlock returns the currently pending block. @@ -174,22 +174,22 @@ func (self *Miner) Pending() (*types.Block, *state.StateDB) { // Note, to access both the pending block and the pending state // simultaneously, please use Pending(), as the pending state can // change between multiple method calls -func (self *Miner) PendingBlock() *types.Block { - return self.worker.pendingBlock() +func (m *Miner) PendingBlock() *types.Block { + return m.worker.pendingBlock() } // PendingBlockAndReceipts returns the currently pending block and corresponding receipts. -func (miner *Miner) PendingBlockAndReceipts() (*types.Block, types.Receipts) { - return miner.worker.pendingBlockAndReceipts() +func (m *Miner) PendingBlockAndReceipts() (*types.Block, types.Receipts) { + return m.worker.pendingBlockAndReceipts() } -func (self *Miner) SetEtherbase(addr common.Address) { - self.coinbase = addr - self.worker.setEtherbase(addr) +func (m *Miner) SetEtherbase(addr common.Address) { + m.coinbase = addr + m.worker.setEtherbase(addr) } // SubscribePendingLogs starts delivering logs from pending transactions // to the given channel. -func (self *Miner) SubscribePendingLogs(ch chan<- []*types.Log) event.Subscription { - return self.worker.pendingLogsFeed.Subscribe(ch) +func (m *Miner) SubscribePendingLogs(ch chan<- []*types.Log) event.Subscription { + return m.worker.pendingLogsFeed.Subscribe(ch) } diff --git a/miner/worker.go b/miner/worker.go index a312d902ba..38e576a323 100644 --- a/miner/worker.go +++ b/miner/worker.go @@ -182,16 +182,16 @@ func newWorker(config *params.ChainConfig, engine consensus.Engine, coinbase com return worker } -func (self *worker) setEtherbase(addr common.Address) { - self.mu.Lock() - defer self.mu.Unlock() - self.coinbase = addr +func (w *worker) setEtherbase(addr common.Address) { + w.mu.Lock() + defer w.mu.Unlock() + w.coinbase = addr } -func (self *worker) setExtra(extra []byte) { - self.mu.Lock() - defer self.mu.Unlock() - self.extra = extra +func (w *worker) setExtra(extra []byte) { + w.mu.Lock() + defer w.mu.Unlock() + w.extra = extra } // pending returns the pending state and corresponding block. The returned @@ -221,56 +221,56 @@ func (w *worker) pendingBlockAndReceipts() (*types.Block, types.Receipts) { return w.snapshotBlock, w.snapshotReceipts } -func (self *worker) start() { - self.mu.Lock() - defer self.mu.Unlock() +func (w *worker) start() { + w.mu.Lock() + defer w.mu.Unlock() - atomic.StoreInt32(&self.mining, 1) + atomic.StoreInt32(&w.mining, 1) // spin up agents - for agent := range self.agents { + for agent := range w.agents { agent.Start() } } -func (self *worker) stop() { - self.wg.Wait() +func (w *worker) stop() { + w.wg.Wait() - self.mu.Lock() - defer self.mu.Unlock() - if atomic.LoadInt32(&self.mining) == 1 { - for agent := range self.agents { + w.mu.Lock() + defer w.mu.Unlock() + if atomic.LoadInt32(&w.mining) == 1 { + for agent := range w.agents { agent.Stop() } } - atomic.StoreInt32(&self.mining, 0) - atomic.StoreInt32(&self.atWork, 0) + atomic.StoreInt32(&w.mining, 0) + atomic.StoreInt32(&w.atWork, 0) } -func (self *worker) register(agent Agent) { - self.mu.Lock() - defer self.mu.Unlock() - self.agents[agent] = struct{}{} - agent.SetReturnCh(self.recv) +func (w *worker) register(agent Agent) { + w.mu.Lock() + defer w.mu.Unlock() + w.agents[agent] = struct{}{} + agent.SetReturnCh(w.recv) } -func (self *worker) unregister(agent Agent) { - self.mu.Lock() - defer self.mu.Unlock() - delete(self.agents, agent) +func (w *worker) unregister(agent Agent) { + w.mu.Lock() + defer w.mu.Unlock() + delete(w.agents, agent) agent.Stop() } -func (self *worker) update() { - if self.announceTxs { - defer self.txsSub.Unsubscribe() +func (w *worker) update() { + if w.announceTxs { + defer w.txsSub.Unsubscribe() } - defer self.chainHeadSub.Unsubscribe() - defer self.chainSideSub.Unsubscribe() + defer w.chainHeadSub.Unsubscribe() + defer w.chainSideSub.Unsubscribe() // timeout waiting for v1 inital value minePeriod := 2 - MinePeriodCh := self.engine.(*XDPoS.XDPoS).MinePeriodCh + MinePeriodCh := w.engine.(*XDPoS.XDPoS).MinePeriodCh defer close(MinePeriodCh) timeout := time.NewTimer(time.Duration(minePeriod) * time.Second) @@ -298,73 +298,73 @@ func (self *worker) update() { timeout.Reset(time.Duration(minePeriod) * time.Second) case <-c: - if atomic.LoadInt32(&self.mining) == 1 { - self.commitNewWork() + if atomic.LoadInt32(&w.mining) == 1 { + w.commitNewWork() } timeout.Reset(time.Duration(minePeriod) * time.Second) // Handle ChainHeadEvent - case <-self.chainHeadCh: - self.commitNewWork() + case <-w.chainHeadCh: + w.commitNewWork() timeout.Reset(time.Duration(minePeriod) * time.Second) // Handle ChainSideEvent - case <-self.chainSideCh: + case <-w.chainSideCh: // Handle NewTxsEvent - case ev := <-self.txsCh: + case ev := <-w.txsCh: // Apply transactions to the pending state if we're not mining. // // Note all transactions received may not be continuous with transactions // already included in the current mining block. These transactions will // be automatically eliminated. - if atomic.LoadInt32(&self.mining) == 0 { - self.currentMu.Lock() + if atomic.LoadInt32(&w.mining) == 0 { + w.currentMu.Lock() txs := make(map[common.Address]types.Transactions) for _, tx := range ev.Txs { - acc, _ := types.Sender(self.current.signer, tx) + acc, _ := types.Sender(w.current.signer, tx) txs[acc] = append(txs[acc], tx) } - feeCapacity := state.GetTRC21FeeCapacityFromState(self.current.state) - txset, specialTxs := types.NewTransactionsByPriceAndNonce(self.current.signer, txs, nil, feeCapacity) + feeCapacity := state.GetTRC21FeeCapacityFromState(w.current.state) + txset, specialTxs := types.NewTransactionsByPriceAndNonce(w.current.signer, txs, nil, feeCapacity) - tcount := self.current.tcount - self.current.commitTransactions(self.mux, feeCapacity, txset, specialTxs, self.chain, self.coinbase, &self.pendingLogsFeed) + tcount := w.current.tcount + w.current.commitTransactions(w.mux, feeCapacity, txset, specialTxs, w.chain, w.coinbase, &w.pendingLogsFeed) // Only update the snapshot if any new transactions were added // to the pending block - if tcount != self.current.tcount { - self.updateSnapshot() + if tcount != w.current.tcount { + w.updateSnapshot() } - self.currentMu.Unlock() + w.currentMu.Unlock() } else { // If we're mining, but nothing is being processed, wake on new transactions - if self.config.XDPoS != nil && self.config.XDPoS.Period == 0 { - self.commitNewWork() + if w.config.XDPoS != nil && w.config.XDPoS.Period == 0 { + w.commitNewWork() } } - case <-self.chainHeadSub.Err(): + case <-w.chainHeadSub.Err(): return - case <-self.chainSideSub.Err(): + case <-w.chainSideSub.Err(): return } } } -func (self *worker) wait() { +func (w *worker) wait() { for { mustCommitNewWork := true - for result := range self.recv { - atomic.AddInt32(&self.atWork, -1) + for result := range w.recv { + atomic.AddInt32(&w.atWork, -1) if result == nil { continue } block := result.Block - if self.config.XDPoS != nil && block.NumberU64() >= self.config.XDPoS.Epoch && len(block.Validator()) == 0 { - self.mux.Post(core.NewMinedBlockEvent{Block: block}) + if w.config.XDPoS != nil && block.NumberU64() >= w.config.XDPoS.Epoch && len(block.Validator()) == 0 { + w.mux.Post(core.NewMinedBlockEvent{Block: block}) continue } work := result.Work @@ -387,9 +387,9 @@ func (self *worker) wait() { log.BlockHash = hash } // Commit block and state to database. - self.currentMu.Lock() - stat, err := self.chain.WriteBlockWithState(block, receipts, work.state, work.tradingState, work.lendingState) - self.currentMu.Unlock() + w.currentMu.Lock() + stat, err := w.chain.WriteBlockWithState(block, receipts, work.state, work.tradingState, work.lendingState) + w.currentMu.Unlock() if err != nil { log.Error("Failed writing block to chain", "err", err) continue @@ -400,7 +400,7 @@ func (self *worker) wait() { mustCommitNewWork = false } // Broadcast the block and announce chain insertion event - self.mux.Post(core.NewMinedBlockEvent{Block: block}) + w.mux.Post(core.NewMinedBlockEvent{Block: block}) var ( events []interface{} logs = work.state.Logs() @@ -411,7 +411,7 @@ func (self *worker) wait() { } if work.config.XDPoS != nil { // epoch block - isEpochSwitchBlock, _, err := self.engine.(*XDPoS.XDPoS).IsEpochSwitch(block.Header()) + isEpochSwitchBlock, _, err := w.engine.(*XDPoS.XDPoS).IsEpochSwitch(block.Header()) if err != nil { log.Error("[wait] fail to check if block is epoch switch block when worker waiting", "BlockNum", block.Number(), "Hash", block.Hash()) } @@ -419,29 +419,29 @@ func (self *worker) wait() { core.CheckpointCh <- 1 } } - self.chain.UpdateBlocksHashCache(block) - self.chain.PostChainEvents(events, logs) + w.chain.UpdateBlocksHashCache(block) + w.chain.PostChainEvents(events, logs) // Insert the block into the set of pending ones to wait for confirmations - self.unconfirmed.Insert(block.NumberU64(), block.Hash()) + w.unconfirmed.Insert(block.NumberU64(), block.Hash()) if mustCommitNewWork { - self.commitNewWork() + w.commitNewWork() } - if self.config.XDPoS != nil { - c := self.engine.(*XDPoS.XDPoS) - err = c.HandleProposedBlock(self.chain, block.Header()) + if w.config.XDPoS != nil { + c := w.engine.(*XDPoS.XDPoS) + err = c.HandleProposedBlock(w.chain, block.Header()) if err != nil { log.Warn("[wait] Unable to handle new proposed block", "err", err, "number", block.Number(), "hash", block.Hash()) } - authorized := c.IsAuthorisedAddress(self.chain, block.Header(), self.coinbase) + authorized := c.IsAuthorisedAddress(w.chain, block.Header(), w.coinbase) if !authorized { valid := false - masternodes := c.GetMasternodes(self.chain, block.Header()) + masternodes := c.GetMasternodes(w.chain, block.Header()) for _, m := range masternodes { - if m == self.coinbase { + if m == w.coinbase { valid = true break } @@ -452,8 +452,8 @@ func (self *worker) wait() { } } // Send tx sign to smart contract blockSigners. - if block.NumberU64()%common.MergeSignRange == 0 || !self.config.IsTIP2019(block.Number()) { - if err := contracts.CreateTransactionSign(self.config, self.eth.TxPool(), self.eth.AccountManager(), block, self.chainDb, self.coinbase); err != nil { + if block.NumberU64()%common.MergeSignRange == 0 || !w.config.IsTIP2019(block.Number()) { + if err := contracts.CreateTransactionSign(w.config, w.eth.TxPool(), w.eth.AccountManager(), block, w.chainDb, w.coinbase); err != nil { log.Error("Fail to create tx sign for signer", "error", err) } } @@ -463,12 +463,12 @@ func (self *worker) wait() { } // push sends a new work task to currently live miner agents. -func (self *worker) push(work *Work) { - if atomic.LoadInt32(&self.mining) != 1 { +func (w *worker) push(work *Work) { + if atomic.LoadInt32(&w.mining) != 1 { return } - for agent := range self.agents { - atomic.AddInt32(&self.atWork, 1) + for agent := range w.agents { + atomic.AddInt32(&w.atWork, 1) if ch := agent.Work(); ch != nil { ch <- work } @@ -502,25 +502,25 @@ func (w *worker) updateSnapshot() { } // makeCurrent creates a new environment for the current cycle. -func (self *worker) makeCurrent(parent *types.Block, header *types.Header) error { +func (w *worker) makeCurrent(parent *types.Block, header *types.Header) error { // Retrieve the parent state to execute on top and start a prefetcher for // the miner to speed block sealing up a bit - state, err := self.chain.StateAt(parent.Root()) + state, err := w.chain.StateAt(parent.Root()) if err != nil { return err } - author, _ := self.chain.Engine().Author(parent.Header()) + author, _ := w.chain.Engine().Author(parent.Header()) var XDCxState *tradingstate.TradingStateDB var lendingState *lendingstate.LendingStateDB - if self.config.XDPoS != nil { - XDCX := self.eth.GetXDCX() + if w.config.XDPoS != nil { + XDCX := w.eth.GetXDCX() XDCxState, err = XDCX.GetTradingState(parent, author) if err != nil { log.Error("Failed to get XDCx state ", "number", parent.Number(), "err", err) return err } - lending := self.eth.GetXDCXLending() + lending := w.eth.GetXDCXLending() lendingState, err = lending.GetLendingState(parent, author) if err != nil { log.Error("Failed to get lending state ", "number", parent.Number(), "err", err) @@ -529,8 +529,8 @@ func (self *worker) makeCurrent(parent *types.Block, header *types.Header) error } work := &Work{ - config: self.config, - signer: types.MakeSigner(self.config, header.Number), + config: w.config, + signer: types.MakeSigner(w.config, header.Number), state: state, parentState: state.Copy(), tradingState: XDCxState, @@ -544,7 +544,7 @@ func (self *worker) makeCurrent(parent *types.Block, header *types.Header) error // Keep track of transactions which return errors so they can be removed work.tcount = 0 - self.current = work + w.current = work return nil } @@ -555,37 +555,37 @@ func abs(x int64) int64 { return x } -func (self *worker) commitNewWork() { - self.mu.Lock() - defer self.mu.Unlock() - self.uncleMu.Lock() - defer self.uncleMu.Unlock() - self.currentMu.Lock() - defer self.currentMu.Unlock() +func (w *worker) commitNewWork() { + w.mu.Lock() + defer w.mu.Unlock() + w.uncleMu.Lock() + defer w.uncleMu.Unlock() + w.currentMu.Lock() + defer w.currentMu.Unlock() tstart := time.Now() - c := self.engine.(*XDPoS.XDPoS) + c := w.engine.(*XDPoS.XDPoS) var parent *types.Block if c != nil { - parent = c.FindParentBlockToAssign(self.chain, self.chain.CurrentBlock()) + parent = c.FindParentBlockToAssign(w.chain, w.chain.CurrentBlock()) } else { - parent = self.chain.CurrentBlock() + parent = w.chain.CurrentBlock() } var signers map[common.Address]struct{} - if parent.Hash().Hex() == self.lastParentBlockCommit { + if parent.Hash().Hex() == w.lastParentBlockCommit { return } - if !self.announceTxs && atomic.LoadInt32(&self.mining) == 0 { + if !w.announceTxs && atomic.LoadInt32(&w.mining) == 0 { return } // Only try to commit new work if we are mining - if atomic.LoadInt32(&self.mining) == 1 { + if atomic.LoadInt32(&w.mining) == 1 { // check if we are right after parent's coinbase in the list - if self.config.XDPoS != nil { - ok, err := c.YourTurn(self.chain, parent.Header(), self.coinbase) + if w.config.XDPoS != nil { + ok, err := c.YourTurn(w.chain, parent.Header(), w.coinbase) if err != nil { log.Warn("Failed when trying to commit new work", "err", err) return @@ -612,15 +612,15 @@ func (self *worker) commitNewWork() { ParentHash: parent.Hash(), Number: num.Add(num, common.Big1), GasLimit: params.TargetGasLimit, - Extra: self.extra, + Extra: w.extra, Time: big.NewInt(tstamp), } // Only set the coinbase if we are mining (avoid spurious block rewards) - if atomic.LoadInt32(&self.mining) == 1 { - header.Coinbase = self.coinbase + if atomic.LoadInt32(&w.mining) == 1 { + header.Coinbase = w.coinbase } - if err := self.engine.Prepare(self.chain, header); err != nil { + if err := w.engine.Prepare(w.chain, header); err != nil { if err == consensus.ErrNotReadyToPropose { log.Info("Waiting...", "err", err) return @@ -629,12 +629,12 @@ func (self *worker) commitNewWork() { return } // If we are care about TheDAO hard-fork check whether to override the extra-data or not - if daoBlock := self.config.DAOForkBlock; daoBlock != nil { + if daoBlock := w.config.DAOForkBlock; daoBlock != nil { // Check whether the block is among the fork extra-override range limit := new(big.Int).Add(daoBlock, params.DAOForkExtraRange) if header.Number.Cmp(daoBlock) >= 0 && header.Number.Cmp(limit) < 0 { // Depending whether we support or oppose the fork, override differently - if self.config.DAOForkSupport { + if w.config.DAOForkSupport { header.Extra = common.CopyBytes(params.DAOForkBlockExtra) } else if bytes.Equal(header.Extra, params.DAOForkBlockExtra) { header.Extra = []byte{} // If miner opposes, don't let it use the reserved extra-data @@ -642,14 +642,14 @@ func (self *worker) commitNewWork() { } } // Could potentially happen if starting to mine in an odd state. - err := self.makeCurrent(parent, header) + err := w.makeCurrent(parent, header) if err != nil { log.Error("Failed to create mining context", "err", err) return } // Create the current work task and check any fork transitions needed - work := self.current - if self.config.DAOForkSupport && self.config.DAOForkBlock != nil && self.config.DAOForkBlock.Cmp(header.Number) == 0 { + work := w.current + if w.config.DAOForkSupport && w.config.DAOForkBlock != nil && w.config.DAOForkBlock.Cmp(header.Number) == 0 { misc.ApplyDAOHardFork(work.state) } if common.TIPSigning.Cmp(header.Number) == 0 { @@ -670,31 +670,31 @@ func (self *worker) commitNewWork() { lendingFinalizedTradeTransaction *types.Transaction ) feeCapacity := state.GetTRC21FeeCapacityFromStateWithCache(parent.Root(), work.state) - if self.config.XDPoS != nil { - isEpochSwitchBlock, _, err := self.engine.(*XDPoS.XDPoS).IsEpochSwitch(header) + if w.config.XDPoS != nil { + isEpochSwitchBlock, _, err := w.engine.(*XDPoS.XDPoS).IsEpochSwitch(header) if err != nil { log.Error("[commitNewWork] fail to check if block is epoch switch block when fetching pending transactions", "BlockNum", header.Number, "Hash", header.Hash()) } if !isEpochSwitchBlock { - pending, err := self.eth.TxPool().Pending() + pending, err := w.eth.TxPool().Pending() if err != nil { log.Error("Failed to fetch pending transactions", "err", err) return } - txs, specialTxs = types.NewTransactionsByPriceAndNonce(self.current.signer, pending, signers, feeCapacity) + txs, specialTxs = types.NewTransactionsByPriceAndNonce(w.current.signer, pending, signers, feeCapacity) } } - if atomic.LoadInt32(&self.mining) == 1 { - wallet, err := self.eth.AccountManager().Find(accounts.Account{Address: self.coinbase}) + if atomic.LoadInt32(&w.mining) == 1 { + wallet, err := w.eth.AccountManager().Find(accounts.Account{Address: w.coinbase}) if err != nil { - log.Warn("Can't find coinbase account wallet", "coinbase", self.coinbase, "err", err) + log.Warn("Can't find coinbase account wallet", "coinbase", w.coinbase, "err", err) return } - if self.config.XDPoS != nil && self.chain.Config().IsTIPXDCXMiner(header.Number) { - XDCX := self.eth.GetXDCX() - XDCXLending := self.eth.GetXDCXLending() - if XDCX != nil && header.Number.Uint64() > self.config.XDPoS.Epoch { - isEpochSwitchBlock, epochNumber, err := self.engine.(*XDPoS.XDPoS).IsEpochSwitch(header) + if w.config.XDPoS != nil && w.chain.Config().IsTIPXDCXMiner(header.Number) { + XDCX := w.eth.GetXDCX() + XDCXLending := w.eth.GetXDCXLending() + if XDCX != nil && header.Number.Uint64() > w.config.XDPoS.Epoch { + isEpochSwitchBlock, epochNumber, err := w.engine.(*XDPoS.XDPoS).IsEpochSwitch(header) if err != nil { log.Error("[commitNewWork] fail to check if block is epoch switch block when performing XDCX and XDCXLending operations", "BlockNum", header.Number, "Hash", header.Hash()) } @@ -709,16 +709,16 @@ func (self *worker) commitNewWork() { // won't grasp tx at checkpoint //https://github.com/XinFinOrg/XDPoSChain-v1/pull/416 log.Debug("Start processing order pending") - tradingOrderPending, _ := self.eth.OrderPool().Pending() + tradingOrderPending, _ := w.eth.OrderPool().Pending() log.Debug("Start processing order pending", "len", len(tradingOrderPending)) - tradingTxMatches, tradingMatchingResults = XDCX.ProcessOrderPending(header, self.coinbase, self.chain, tradingOrderPending, work.state, work.tradingState) + tradingTxMatches, tradingMatchingResults = XDCX.ProcessOrderPending(header, w.coinbase, w.chain, tradingOrderPending, work.state, work.tradingState) log.Debug("trading transaction matches found", "tradingTxMatches", len(tradingTxMatches)) - lendingOrderPending, _ := self.eth.LendingPool().Pending() - lendingInput, lendingMatchingResults = XDCXLending.ProcessOrderPending(header, self.coinbase, self.chain, lendingOrderPending, work.state, work.lendingState, work.tradingState) + lendingOrderPending, _ := w.eth.LendingPool().Pending() + lendingInput, lendingMatchingResults = XDCXLending.ProcessOrderPending(header, w.coinbase, w.chain, lendingOrderPending, work.state, work.lendingState, work.tradingState) log.Debug("lending transaction matches found", "lendingInput", len(lendingInput), "lendingMatchingResults", len(lendingMatchingResults)) - if header.Number.Uint64()%self.config.XDPoS.Epoch == common.LiquidateLendingTradeBlock { - updatedTrades, liquidatedTrades, autoRepayTrades, autoTopUpTrades, autoRecallTrades, err = XDCXLending.ProcessLiquidationData(header, self.chain, work.state, work.tradingState, work.lendingState) + if header.Number.Uint64()%w.config.XDPoS.Epoch == common.LiquidateLendingTradeBlock { + updatedTrades, liquidatedTrades, autoRepayTrades, autoTopUpTrades, autoRecallTrades, err = XDCXLending.ProcessLiquidationData(header, w.chain, work.state, work.tradingState, work.lendingState) if err != nil { log.Error("Fail when process lending liquidation data ", "error", err) return @@ -737,16 +737,16 @@ func (self *worker) commitNewWork() { log.Error("Fail to marshal txMatch", "error", err) return } - nonce := work.state.GetNonce(self.coinbase) + nonce := work.state.GetNonce(w.coinbase) tx := types.NewTransaction(nonce, common.XDCXAddrBinary, big.NewInt(0), txMatchGasLimit, big.NewInt(0), txMatchBytes) - txM, err := wallet.SignTx(accounts.Account{Address: self.coinbase}, tx, self.config.ChainId) + txM, err := wallet.SignTx(accounts.Account{Address: w.coinbase}, tx, w.config.ChainId) if err != nil { log.Error("Fail to create tx matches", "error", err) return } else { tradingTransaction = txM if XDCX.IsSDKNode() { - self.chain.AddMatchingResult(tradingTransaction.Hash(), tradingMatchingResults) + w.chain.AddMatchingResult(tradingTransaction.Hash(), tradingMatchingResults) } // force adding trading, lending transaction to this block if tradingTransaction != nil { @@ -767,16 +767,16 @@ func (self *worker) commitNewWork() { log.Error("Fail to marshal lendingData", "error", err) return } - nonce := work.state.GetNonce(self.coinbase) + nonce := work.state.GetNonce(w.coinbase) lendingTx := types.NewTransaction(nonce, common.XDCXLendingAddressBinary, big.NewInt(0), txMatchGasLimit, big.NewInt(0), lendingDataBytes) - signedLendingTx, err := wallet.SignTx(accounts.Account{Address: self.coinbase}, lendingTx, self.config.ChainId) + signedLendingTx, err := wallet.SignTx(accounts.Account{Address: w.coinbase}, lendingTx, w.config.ChainId) if err != nil { log.Error("Fail to create lending tx", "error", err) return } else { lendingTransaction = signedLendingTx if XDCX.IsSDKNode() { - self.chain.AddLendingResult(lendingTransaction.Hash(), lendingMatchingResults) + w.chain.AddLendingResult(lendingTransaction.Hash(), lendingMatchingResults) } if lendingTransaction != nil { specialTxs = append(specialTxs, lendingTransaction) @@ -791,16 +791,16 @@ func (self *worker) commitNewWork() { log.Error("Fail to marshal lendingData", "error", err) return } - nonce := work.state.GetNonce(self.coinbase) + nonce := work.state.GetNonce(w.coinbase) finalizedTx := types.NewTransaction(nonce, common.XDCXLendingFinalizedTradeAddressBinary, big.NewInt(0), txMatchGasLimit, big.NewInt(0), finalizedTradeData) - signedFinalizedTx, err := wallet.SignTx(accounts.Account{Address: self.coinbase}, finalizedTx, self.config.ChainId) + signedFinalizedTx, err := wallet.SignTx(accounts.Account{Address: w.coinbase}, finalizedTx, w.config.ChainId) if err != nil { log.Error("Fail to create lending tx", "error", err) return } else { lendingFinalizedTradeTransaction = signedFinalizedTx if XDCX.IsSDKNode() { - self.chain.AddFinalizedTrades(lendingFinalizedTradeTransaction.Hash(), updatedTrades) + w.chain.AddFinalizedTrades(lendingFinalizedTradeTransaction.Hash(), updatedTrades) } if lendingFinalizedTradeTransaction != nil { specialTxs = append(specialTxs, lendingFinalizedTradeTransaction) @@ -811,8 +811,8 @@ func (self *worker) commitNewWork() { XDCxStateRoot := work.tradingState.IntermediateRoot() LendingStateRoot := work.lendingState.IntermediateRoot() txData := append(XDCxStateRoot.Bytes(), LendingStateRoot.Bytes()...) - tx := types.NewTransaction(work.state.GetNonce(self.coinbase), common.TradingStateAddrBinary, big.NewInt(0), txMatchGasLimit, big.NewInt(0), txData) - txStateRoot, err := wallet.SignTx(accounts.Account{Address: self.coinbase}, tx, self.config.ChainId) + tx := types.NewTransaction(work.state.GetNonce(w.coinbase), common.TradingStateAddrBinary, big.NewInt(0), txMatchGasLimit, big.NewInt(0), txData) + txStateRoot, err := wallet.SignTx(accounts.Account{Address: w.coinbase}, tx, w.config.ChainId) if err != nil { log.Error("Fail to create tx state root", "error", err) return @@ -820,29 +820,29 @@ func (self *worker) commitNewWork() { specialTxs = append(specialTxs, txStateRoot) } } - work.commitTransactions(self.mux, feeCapacity, txs, specialTxs, self.chain, self.coinbase, &self.pendingLogsFeed) + work.commitTransactions(w.mux, feeCapacity, txs, specialTxs, w.chain, w.coinbase, &w.pendingLogsFeed) // compute uncles for the new block. var ( uncles []*types.Header ) // Create the new block to seal with the consensus engine - if work.Block, err = self.engine.Finalize(self.chain, header, work.state, work.parentState, work.txs, uncles, work.receipts); err != nil { + if work.Block, err = w.engine.Finalize(w.chain, header, work.state, work.parentState, work.txs, uncles, work.receipts); err != nil { log.Error("Failed to finalize block for sealing", "err", err) return } - if atomic.LoadInt32(&self.mining) == 1 { + if atomic.LoadInt32(&w.mining) == 1 { log.Info("Committing new block", "number", work.Block.Number(), "txs", work.tcount, "special-txs", len(specialTxs), "uncles", len(uncles), "elapsed", common.PrettyDuration(time.Since(tstart))) - self.unconfirmed.Shift(work.Block.NumberU64() - 1) - self.lastParentBlockCommit = parent.Hash().Hex() + w.unconfirmed.Shift(work.Block.NumberU64() - 1) + w.lastParentBlockCommit = parent.Hash().Hex() } - self.push(work) - self.updateSnapshot() + w.push(work) + w.updateSnapshot() } -func (env *Work) commitTransactions(mux *event.TypeMux, balanceFee map[common.Address]*big.Int, txs *types.TransactionsByPriceAndNonce, specialTxs types.Transactions, bc *core.BlockChain, coinbase common.Address, pendingLogsFeed *event.Feed) { - gp := new(core.GasPool).AddGas(env.header.GasLimit) +func (w *Work) commitTransactions(mux *event.TypeMux, balanceFee map[common.Address]*big.Int, txs *types.TransactionsByPriceAndNonce, specialTxs types.Transactions, bc *core.BlockChain, coinbase common.Address, pendingLogsFeed *event.Feed) { + gp := new(core.GasPool).AddGas(w.header.GasLimit) balanceUpdated := map[common.Address]*big.Int{} totalFeeUsed := big.NewInt(0) var coalescedLogs []*types.Log @@ -850,7 +850,7 @@ func (env *Work) commitTransactions(mux *event.TypeMux, balanceFee map[common.Ad for _, tx := range specialTxs { to := tx.To() //HF number for black-list - if (env.header.Number.Uint64() >= common.BlackListHFNumber) && !common.IsTestnet { + if (w.header.Number.Uint64() >= common.BlackListHFNumber) && !common.IsTestnet { from := tx.From() // check if sender is in black list if from != nil && common.Blacklist[*from] { @@ -891,12 +891,12 @@ func (env *Work) commitTransactions(mux *event.TypeMux, balanceFee map[common.Ad // during transaction acceptance is the transaction pool. // // We use the eip155 signer regardless of the current hf. - from, _ := types.Sender(env.signer, tx) + from, _ := types.Sender(w.signer, tx) // Check whether the tx is replay protected. If we're not in the EIP155 hf // phase, start ignoring the sender until we do. hash := tx.Hash() - if tx.Protected() && !env.config.IsEIP155(env.header.Number) { - log.Trace("Ignoring reply protected special transaction", "hash", hash, "eip155", env.config.EIP155Block) + if tx.Protected() && !w.config.IsEIP155(w.header.Number) { + log.Trace("Ignoring reply protected special transaction", "hash", hash, "eip155", w.config.EIP155Block) continue } if *to == common.BlockSignersBinary { @@ -905,20 +905,20 @@ func (env *Work) commitTransactions(mux *event.TypeMux, balanceFee map[common.Ad continue } blkNumber := binary.BigEndian.Uint64(data[8:40]) - if blkNumber >= env.header.Number.Uint64() || blkNumber <= env.header.Number.Uint64()-env.config.XDPoS.Epoch*2 { - log.Trace("Data special transaction invalid number", "hash", hash, "blkNumber", blkNumber, "miner", env.header.Number) + if blkNumber >= w.header.Number.Uint64() || blkNumber <= w.header.Number.Uint64()-w.config.XDPoS.Epoch*2 { + log.Trace("Data special transaction invalid number", "hash", hash, "blkNumber", blkNumber, "miner", w.header.Number) continue } } // Start executing the transaction - env.state.Prepare(hash, env.tcount) + w.state.Prepare(hash, w.tcount) - nonce := env.state.GetNonce(from) + nonce := w.state.GetNonce(from) if nonce != tx.Nonce() && !tx.IsSkipNonceTransaction() { log.Trace("Skipping account with special transaction invalid nonce", "sender", from, "nonce", nonce, "tx nonce ", tx.Nonce(), "to", to) continue } - err, logs, tokenFeeUsed, gas := env.commitTransaction(balanceFee, tx, bc, coinbase, gp) + err, logs, tokenFeeUsed, gas := w.commitTransaction(balanceFee, tx, bc, coinbase, gp) switch err { case core.ErrNonceTooLow: // New head notification data race between the transaction pool and miner, shift @@ -930,7 +930,7 @@ func (env *Work) commitTransactions(mux *event.TypeMux, balanceFee map[common.Ad case nil: // Everything ok, collect the logs and shift in the next transaction from the same account coalescedLogs = append(coalescedLogs, logs...) - env.tcount++ + w.tcount++ default: // Strange error, discard the transaction and get the next in line (note, the @@ -938,7 +938,7 @@ func (env *Work) commitTransactions(mux *event.TypeMux, balanceFee map[common.Ad log.Debug("Add Special Transaction failed, account skipped", "hash", hash, "sender", from, "nonce", tx.Nonce(), "to", to, "err", err) } if tokenFeeUsed { - fee := common.GetGasFee(env.header.Number.Uint64(), gas) + fee := common.GetGasFee(w.header.Number.Uint64(), gas) balanceFee[*to] = new(big.Int).Sub(balanceFee[*to], fee) balanceUpdated[*to] = balanceFee[*to] totalFeeUsed = totalFeeUsed.Add(totalFeeUsed, fee) @@ -963,7 +963,7 @@ func (env *Work) commitTransactions(mux *event.TypeMux, balanceFee map[common.Ad //HF number for black-list to := tx.To() - if (env.header.Number.Uint64() >= common.BlackListHFNumber) && !common.IsTestnet { + if (w.header.Number.Uint64() >= common.BlackListHFNumber) && !common.IsTestnet { from := tx.From() // check if sender is in black list if from != nil && common.Blacklist[*from] { @@ -1002,18 +1002,18 @@ func (env *Work) commitTransactions(mux *event.TypeMux, balanceFee map[common.Ad // during transaction acceptance is the transaction pool. // // We use the eip155 signer regardless of the current hf. - from, _ := types.Sender(env.signer, tx) + from, _ := types.Sender(w.signer, tx) hash := tx.Hash() // Check whether the tx is replay protected. If we're not in the EIP155 hf // phase, start ignoring the sender until we do. - if tx.Protected() && !env.config.IsEIP155(env.header.Number) { - log.Trace("Ignoring reply protected transaction", "hash", hash, "eip155", env.config.EIP155Block) + if tx.Protected() && !w.config.IsEIP155(w.header.Number) { + log.Trace("Ignoring reply protected transaction", "hash", hash, "eip155", w.config.EIP155Block) txs.Pop() continue } // Start executing the transaction - env.state.Prepare(hash, env.tcount) - nonce := env.state.GetNonce(from) + w.state.Prepare(hash, w.tcount) + nonce := w.state.GetNonce(from) if nonce > tx.Nonce() { // New head notification data race between the transaction pool and miner, shift log.Trace("Skipping transaction with low nonce", "sender", from, "nonce", tx.Nonce()) @@ -1026,7 +1026,7 @@ func (env *Work) commitTransactions(mux *event.TypeMux, balanceFee map[common.Ad txs.Pop() continue } - err, logs, tokenFeeUsed, gas := env.commitTransaction(balanceFee, tx, bc, coinbase, gp) + err, logs, tokenFeeUsed, gas := w.commitTransaction(balanceFee, tx, bc, coinbase, gp) switch { case errors.Is(err, core.ErrGasLimitReached): // Pop the current out-of-gas transaction without shifting in the next from the account @@ -1046,7 +1046,7 @@ func (env *Work) commitTransactions(mux *event.TypeMux, balanceFee map[common.Ad case errors.Is(err, nil): // Everything ok, collect the logs and shift in the next transaction from the same account coalescedLogs = append(coalescedLogs, logs...) - env.tcount++ + w.tcount++ txs.Shift() case errors.Is(err, core.ErrTxTypeNotSupported): @@ -1061,13 +1061,13 @@ func (env *Work) commitTransactions(mux *event.TypeMux, balanceFee map[common.Ad txs.Shift() } if tokenFeeUsed { - fee := common.GetGasFee(env.header.Number.Uint64(), gas) + fee := common.GetGasFee(w.header.Number.Uint64(), gas) balanceFee[*to] = new(big.Int).Sub(balanceFee[*to], fee) balanceUpdated[*to] = balanceFee[*to] totalFeeUsed = totalFeeUsed.Add(totalFeeUsed, fee) } } - state.UpdateTRC21Fee(env.state, balanceUpdated, totalFeeUsed) + state.UpdateTRC21Fee(w.state, balanceUpdated, totalFeeUsed) // make a copy, the state caches the logs and these logs get "upgraded" from pending to mined // logs by filling in the block hash when the block was mined by the local miner. This can // cause a race condition if a log was "upgraded" before the PendingLogsEvent is processed. @@ -1079,27 +1079,27 @@ func (env *Work) commitTransactions(mux *event.TypeMux, balanceFee map[common.Ad } pendingLogsFeed.Send(cpy) } - if env.tcount > 0 { + if w.tcount > 0 { go func(tcount int) { err := mux.Post(core.PendingStateEvent{}) if err != nil { log.Warn("[commitTransactions] Error when sending PendingStateEvent", "tcount", tcount) } - }(env.tcount) + }(w.tcount) } } -func (env *Work) commitTransaction(balanceFee map[common.Address]*big.Int, tx *types.Transaction, bc *core.BlockChain, coinbase common.Address, gp *core.GasPool) (error, []*types.Log, bool, uint64) { - snap := env.state.Snapshot() +func (w *Work) commitTransaction(balanceFee map[common.Address]*big.Int, tx *types.Transaction, bc *core.BlockChain, coinbase common.Address, gp *core.GasPool) (error, []*types.Log, bool, uint64) { + snap := w.state.Snapshot() - receipt, gas, err, tokenFeeUsed := core.ApplyTransaction(env.config, balanceFee, bc, &coinbase, gp, env.state, env.tradingState, env.header, tx, &env.header.GasUsed, vm.Config{}) + receipt, gas, err, tokenFeeUsed := core.ApplyTransaction(w.config, balanceFee, bc, &coinbase, gp, w.state, w.tradingState, w.header, tx, &w.header.GasUsed, vm.Config{}) if err != nil { - env.state.RevertToSnapshot(snap) + w.state.RevertToSnapshot(snap) return err, nil, false, 0 } - env.txs = append(env.txs, tx) - env.receipts = append(env.receipts, receipt) + w.txs = append(w.txs, tx) + w.receipts = append(w.receipts, receipt) return nil, receipt.Logs, tokenFeeUsed, gas } diff --git a/p2p/message.go b/p2p/message.go index d39bcb31f6..58c159ee79 100644 --- a/p2p/message.go +++ b/p2p/message.go @@ -47,21 +47,21 @@ type Msg struct { // the given value, which must be a pointer. // // For the decoding rules, please see package rlp. -func (msg Msg) Decode(val interface{}) error { - s := rlp.NewStream(msg.Payload, uint64(msg.Size)) +func (m Msg) Decode(val interface{}) error { + s := rlp.NewStream(m.Payload, uint64(m.Size)) if err := s.Decode(val); err != nil { - return newPeerError(errInvalidMsg, "(code %x) (size %d) %v", msg.Code, msg.Size, err) + return newPeerError(errInvalidMsg, "(code %x) (size %d) %v", m.Code, m.Size, err) } return nil } -func (msg Msg) String() string { - return fmt.Sprintf("msg #%v (%v bytes)", msg.Code, msg.Size) +func (m Msg) String() string { + return fmt.Sprintf("msg #%v (%v bytes)", m.Code, m.Size) } // Discard reads any remaining payload data into a black hole. -func (msg Msg) Discard() error { - _, err := io.Copy(io.Discard, msg.Payload) +func (m Msg) Discard() error { + _, err := io.Copy(io.Discard, m.Payload) return err } @@ -119,24 +119,24 @@ type eofSignal struct { // note: when using eofSignal to detect whether a message payload // has been read, Read might not be called for zero sized messages. -func (r *eofSignal) Read(buf []byte) (int, error) { - if r.count == 0 { - if r.eof != nil { - r.eof <- struct{}{} - r.eof = nil +func (s *eofSignal) Read(buf []byte) (int, error) { + if s.count == 0 { + if s.eof != nil { + s.eof <- struct{}{} + s.eof = nil } return 0, io.EOF } max := len(buf) - if int(r.count) < len(buf) { - max = int(r.count) + if int(s.count) < len(buf) { + max = int(s.count) } - n, err := r.wrapped.Read(buf[:max]) - r.count -= uint32(n) - if (err != nil || r.count == 0) && r.eof != nil { - r.eof <- struct{}{} // tell Peer that msg has been consumed - r.eof = nil + n, err := s.wrapped.Read(buf[:max]) + s.count -= uint32(n) + if (err != nil || s.count == 0) && s.eof != nil { + s.eof <- struct{}{} // tell Peer that msg has been consumed + s.eof = nil } return n, err } @@ -269,15 +269,15 @@ func newMsgEventer(rw MsgReadWriter, feed *event.Feed, peerID discover.NodeID, p // ReadMsg reads a message from the underlying MsgReadWriter and emits a // "message received" event -func (self *msgEventer) ReadMsg() (Msg, error) { - msg, err := self.MsgReadWriter.ReadMsg() +func (e *msgEventer) ReadMsg() (Msg, error) { + msg, err := e.MsgReadWriter.ReadMsg() if err != nil { return msg, err } - self.feed.Send(&PeerEvent{ + e.feed.Send(&PeerEvent{ Type: PeerEventTypeMsgRecv, - Peer: self.peerID, - Protocol: self.Protocol, + Peer: e.peerID, + Protocol: e.Protocol, MsgCode: &msg.Code, MsgSize: &msg.Size, }) @@ -286,15 +286,15 @@ func (self *msgEventer) ReadMsg() (Msg, error) { // WriteMsg writes a message to the underlying MsgReadWriter and emits a // "message sent" event -func (self *msgEventer) WriteMsg(msg Msg) error { - err := self.MsgReadWriter.WriteMsg(msg) +func (e *msgEventer) WriteMsg(msg Msg) error { + err := e.MsgReadWriter.WriteMsg(msg) if err != nil { return err } - self.feed.Send(&PeerEvent{ + e.feed.Send(&PeerEvent{ Type: PeerEventTypeMsgSend, - Peer: self.peerID, - Protocol: self.Protocol, + Peer: e.peerID, + Protocol: e.Protocol, MsgCode: &msg.Code, MsgSize: &msg.Size, }) @@ -303,8 +303,8 @@ func (self *msgEventer) WriteMsg(msg Msg) error { // Close closes the underlying MsgReadWriter if it implements the io.Closer // interface -func (self *msgEventer) Close() error { - if v, ok := self.MsgReadWriter.(io.Closer); ok { +func (e *msgEventer) Close() error { + if v, ok := e.MsgReadWriter.(io.Closer); ok { return v.Close() } return nil diff --git a/p2p/peer_error.go b/p2p/peer_error.go index 64530116e6..3ee1e1ab25 100644 --- a/p2p/peer_error.go +++ b/p2p/peer_error.go @@ -48,8 +48,8 @@ func newPeerError(code int, format string, v ...interface{}) *peerError { return err } -func (self *peerError) Error() string { - return self.message +func (e *peerError) Error() string { + return e.message } var errProtocolReturned = errors.New("protocol returned") diff --git a/p2p/simulations/adapters/inproc.go b/p2p/simulations/adapters/inproc.go index fce627d906..1f64941dfa 100644 --- a/p2p/simulations/adapters/inproc.go +++ b/p2p/simulations/adapters/inproc.go @@ -51,18 +51,18 @@ func NewSimAdapter(services map[string]ServiceFunc) *SimAdapter { } // Name returns the name of the adapter for logging purposes -func (s *SimAdapter) Name() string { +func (sa *SimAdapter) Name() string { return "sim-adapter" } // NewNode returns a new SimNode using the given config -func (s *SimAdapter) NewNode(config *NodeConfig) (Node, error) { - s.mtx.Lock() - defer s.mtx.Unlock() +func (sa *SimAdapter) NewNode(config *NodeConfig) (Node, error) { + sa.mtx.Lock() + defer sa.mtx.Unlock() // check a node with the ID doesn't already exist id := config.ID - if _, exists := s.nodes[id]; exists { + if _, exists := sa.nodes[id]; exists { return nil, fmt.Errorf("node already exists: %s", id) } @@ -71,7 +71,7 @@ func (s *SimAdapter) NewNode(config *NodeConfig) (Node, error) { return nil, errors.New("node must have at least one service") } for _, service := range config.Services { - if _, exists := s.services[service]; !exists { + if _, exists := sa.services[service]; !exists { return nil, fmt.Errorf("unknown node service %q", service) } } @@ -81,7 +81,7 @@ func (s *SimAdapter) NewNode(config *NodeConfig) (Node, error) { PrivateKey: config.PrivateKey, MaxPeers: math.MaxInt32, NoDiscovery: true, - Dialer: s, + Dialer: sa, EnableMsgEvents: true, }, NoUSB: true, @@ -95,18 +95,18 @@ func (s *SimAdapter) NewNode(config *NodeConfig) (Node, error) { ID: id, config: config, node: n, - adapter: s, + adapter: sa, running: make(map[string]node.Service), connected: make(map[discover.NodeID]bool), } - s.nodes[id] = simNode + sa.nodes[id] = simNode return simNode, nil } // Dial implements the p2p.NodeDialer interface by connecting to the node using // an in-memory net.Pipe connection -func (s *SimAdapter) Dial(dest *discover.Node) (conn net.Conn, err error) { - node, ok := s.GetNode(dest.ID) +func (sa *SimAdapter) Dial(dest *discover.Node) (conn net.Conn, err error) { + node, ok := sa.GetNode(dest.ID) if !ok { return nil, fmt.Errorf("unknown node: %s", dest.ID) } @@ -125,8 +125,8 @@ func (s *SimAdapter) Dial(dest *discover.Node) (conn net.Conn, err error) { // DialRPC implements the RPCDialer interface by creating an in-memory RPC // client of the given node -func (s *SimAdapter) DialRPC(id discover.NodeID) (*rpc.Client, error) { - node, ok := s.GetNode(id) +func (sa *SimAdapter) DialRPC(id discover.NodeID) (*rpc.Client, error) { + node, ok := sa.GetNode(id) if !ok { return nil, fmt.Errorf("unknown node: %s", id) } @@ -138,10 +138,10 @@ func (s *SimAdapter) DialRPC(id discover.NodeID) (*rpc.Client, error) { } // GetNode returns the node with the given ID if it exists -func (s *SimAdapter) GetNode(id discover.NodeID) (*SimNode, bool) { - s.mtx.RLock() - defer s.mtx.RUnlock() - node, ok := s.nodes[id] +func (sa *SimAdapter) GetNode(id discover.NodeID) (*SimNode, bool) { + sa.mtx.RLock() + defer sa.mtx.RUnlock() + node, ok := sa.nodes[id] return node, ok } @@ -161,30 +161,30 @@ type SimNode struct { } // Addr returns the node's discovery address -func (self *SimNode) Addr() []byte { - return []byte(self.Node().String()) +func (sn *SimNode) Addr() []byte { + return []byte(sn.Node().String()) } // Node returns a discover.Node representing the SimNode -func (self *SimNode) Node() *discover.Node { - return discover.NewNode(self.ID, net.IP{127, 0, 0, 1}, 30303, 30303) +func (sn *SimNode) Node() *discover.Node { + return discover.NewNode(sn.ID, net.IP{127, 0, 0, 1}, 30303, 30303) } // Client returns an rpc.Client which can be used to communicate with the // underlying services (it is set once the node has started) -func (self *SimNode) Client() (*rpc.Client, error) { - self.lock.RLock() - defer self.lock.RUnlock() - if self.client == nil { +func (sn *SimNode) Client() (*rpc.Client, error) { + sn.lock.RLock() + defer sn.lock.RUnlock() + if sn.client == nil { return nil, errors.New("node not started") } - return self.client, nil + return sn.client, nil } // ServeRPC serves RPC requests over the given connection by creating an // in-memory client to the node's RPC server -func (self *SimNode) ServeRPC(conn *websocket.Conn) error { - handler, err := self.node.RPCHandler() +func (sn *SimNode) ServeRPC(conn *websocket.Conn) error { + handler, err := sn.node.RPCHandler() if err != nil { return err } @@ -195,13 +195,13 @@ func (self *SimNode) ServeRPC(conn *websocket.Conn) error { // Snapshots creates snapshots of the services by calling the // simulation_snapshot RPC method -func (self *SimNode) Snapshots() (map[string][]byte, error) { - self.lock.RLock() - services := make(map[string]node.Service, len(self.running)) - for name, service := range self.running { +func (sn *SimNode) Snapshots() (map[string][]byte, error) { + sn.lock.RLock() + services := make(map[string]node.Service, len(sn.running)) + for name, service := range sn.running { services[name] = service } - self.lock.RUnlock() + sn.lock.RUnlock() if len(services) == 0 { return nil, errors.New("no running services") } @@ -221,23 +221,23 @@ func (self *SimNode) Snapshots() (map[string][]byte, error) { } // Start registers the services and starts the underlying devp2p node -func (self *SimNode) Start(snapshots map[string][]byte) error { +func (sn *SimNode) Start(snapshots map[string][]byte) error { newService := func(name string) func(ctx *node.ServiceContext) (node.Service, error) { return func(nodeCtx *node.ServiceContext) (node.Service, error) { ctx := &ServiceContext{ - RPCDialer: self.adapter, + RPCDialer: sn.adapter, NodeContext: nodeCtx, - Config: self.config, + Config: sn.config, } if snapshots != nil { ctx.Snapshot = snapshots[name] } - serviceFunc := self.adapter.services[name] + serviceFunc := sn.adapter.services[name] service, err := serviceFunc(ctx) if err != nil { return nil, err } - self.running[name] = service + sn.running[name] = service return service, nil } } @@ -245,9 +245,9 @@ func (self *SimNode) Start(snapshots map[string][]byte) error { // ensure we only register the services once in the case of the node // being stopped and then started again var regErr error - self.registerOnce.Do(func() { - for _, name := range self.config.Services { - if err := self.node.Register(newService(name)); err != nil { + sn.registerOnce.Do(func() { + for _, name := range sn.config.Services { + if err := sn.node.Register(newService(name)); err != nil { regErr = err return } @@ -257,54 +257,54 @@ func (self *SimNode) Start(snapshots map[string][]byte) error { return regErr } - if err := self.node.Start(); err != nil { + if err := sn.node.Start(); err != nil { return err } // create an in-process RPC client - handler, err := self.node.RPCHandler() + handler, err := sn.node.RPCHandler() if err != nil { return err } - self.lock.Lock() - self.client = rpc.DialInProc(handler) - self.lock.Unlock() + sn.lock.Lock() + sn.client = rpc.DialInProc(handler) + sn.lock.Unlock() return nil } // Stop closes the RPC client and stops the underlying devp2p node -func (self *SimNode) Stop() error { - self.lock.Lock() - if self.client != nil { - self.client.Close() - self.client = nil +func (sn *SimNode) Stop() error { + sn.lock.Lock() + if sn.client != nil { + sn.client.Close() + sn.client = nil } - self.lock.Unlock() - return self.node.Stop() + sn.lock.Unlock() + return sn.node.Stop() } // Services returns a copy of the underlying services -func (self *SimNode) Services() []node.Service { - self.lock.RLock() - defer self.lock.RUnlock() - services := make([]node.Service, 0, len(self.running)) - for _, service := range self.running { +func (sn *SimNode) Services() []node.Service { + sn.lock.RLock() + defer sn.lock.RUnlock() + services := make([]node.Service, 0, len(sn.running)) + for _, service := range sn.running { services = append(services, service) } return services } // Server returns the underlying p2p.Server -func (self *SimNode) Server() *p2p.Server { - return self.node.Server() +func (sn *SimNode) Server() *p2p.Server { + return sn.node.Server() } // SubscribeEvents subscribes the given channel to peer events from the // underlying p2p.Server -func (self *SimNode) SubscribeEvents(ch chan *p2p.PeerEvent) event.Subscription { - srv := self.Server() +func (sn *SimNode) SubscribeEvents(ch chan *p2p.PeerEvent) event.Subscription { + srv := sn.Server() if srv == nil { panic("node not running") } @@ -312,12 +312,12 @@ func (self *SimNode) SubscribeEvents(ch chan *p2p.PeerEvent) event.Subscription } // NodeInfo returns information about the node -func (self *SimNode) NodeInfo() *p2p.NodeInfo { - server := self.Server() +func (sn *SimNode) NodeInfo() *p2p.NodeInfo { + server := sn.Server() if server == nil { return &p2p.NodeInfo{ - ID: self.ID.String(), - Enode: self.Node().String(), + ID: sn.ID.String(), + Enode: sn.Node().String(), } } return server.NodeInfo() diff --git a/p2p/simulations/adapters/state.go b/p2p/simulations/adapters/state.go index 0d4ecfb0ff..416c504d2a 100644 --- a/p2p/simulations/adapters/state.go +++ b/p2p/simulations/adapters/state.go @@ -20,12 +20,12 @@ type SimStateStore struct { m map[string][]byte } -func (self *SimStateStore) Load(s string) ([]byte, error) { - return self.m[s], nil +func (sss *SimStateStore) Load(s string) ([]byte, error) { + return sss.m[s], nil } -func (self *SimStateStore) Save(s string, data []byte) error { - self.m[s] = data +func (sss *SimStateStore) Save(s string, data []byte) error { + sss.m[s] = data return nil } diff --git a/p2p/simulations/network.go b/p2p/simulations/network.go index 5be5697da3..4c992fd1d5 100644 --- a/p2p/simulations/network.go +++ b/p2p/simulations/network.go @@ -74,22 +74,22 @@ func NewNetwork(nodeAdapter adapters.NodeAdapter, conf *NetworkConfig) *Network } // Events returns the output event feed of the Network. -func (self *Network) Events() *event.Feed { - return &self.events +func (net *Network) Events() *event.Feed { + return &net.events } // NewNode adds a new node to the network with a random ID -func (self *Network) NewNode() (*Node, error) { +func (net *Network) NewNode() (*Node, error) { conf := adapters.RandomNodeConfig() - conf.Services = []string{self.DefaultService} - return self.NewNodeWithConfig(conf) + conf.Services = []string{net.DefaultService} + return net.NewNodeWithConfig(conf) } // NewNodeWithConfig adds a new node to the network with the given config, // returning an error if a node with the same ID or name already exists -func (self *Network) NewNodeWithConfig(conf *adapters.NodeConfig) (*Node, error) { - self.lock.Lock() - defer self.lock.Unlock() +func (net *Network) NewNodeWithConfig(conf *adapters.NodeConfig) (*Node, error) { + net.lock.Lock() + defer net.lock.Unlock() // create a random ID and PrivateKey if not set if conf.ID == (discover.NodeID{}) { @@ -100,31 +100,31 @@ func (self *Network) NewNodeWithConfig(conf *adapters.NodeConfig) (*Node, error) id := conf.ID if conf.Reachable == nil { conf.Reachable = func(otherID discover.NodeID) bool { - _, err := self.InitConn(conf.ID, otherID) + _, err := net.InitConn(conf.ID, otherID) return err == nil } } // assign a name to the node if not set if conf.Name == "" { - conf.Name = fmt.Sprintf("node%02d", len(self.Nodes)+1) + conf.Name = fmt.Sprintf("node%02d", len(net.Nodes)+1) } // check the node doesn't already exist - if node := self.getNode(id); node != nil { + if node := net.getNode(id); node != nil { return nil, fmt.Errorf("node with ID %q already exists", id) } - if node := self.getNodeByName(conf.Name); node != nil { + if node := net.getNodeByName(conf.Name); node != nil { return nil, fmt.Errorf("node with name %q already exists", conf.Name) } // if no services are configured, use the default service if len(conf.Services) == 0 { - conf.Services = []string{self.DefaultService} + conf.Services = []string{net.DefaultService} } // use the NodeAdapter to create the node - adapterNode, err := self.nodeAdapter.NewNode(conf) + adapterNode, err := net.nodeAdapter.NewNode(conf) if err != nil { return nil, err } @@ -133,27 +133,27 @@ func (self *Network) NewNodeWithConfig(conf *adapters.NodeConfig) (*Node, error) Config: conf, } log.Trace(fmt.Sprintf("node %v created", id)) - self.nodeMap[id] = len(self.Nodes) - self.Nodes = append(self.Nodes, node) + net.nodeMap[id] = len(net.Nodes) + net.Nodes = append(net.Nodes, node) // emit a "control" event - self.events.Send(ControlEvent(node)) + net.events.Send(ControlEvent(node)) return node, nil } // Config returns the network configuration -func (self *Network) Config() *NetworkConfig { - return &self.NetworkConfig +func (net *Network) Config() *NetworkConfig { + return &net.NetworkConfig } // StartAll starts all nodes in the network -func (self *Network) StartAll() error { - for _, node := range self.Nodes { +func (net *Network) StartAll() error { + for _, node := range net.Nodes { if node.Up { continue } - if err := self.Start(node.ID()); err != nil { + if err := net.Start(node.ID()); err != nil { return err } } @@ -161,12 +161,12 @@ func (self *Network) StartAll() error { } // StopAll stops all nodes in the network -func (self *Network) StopAll() error { - for _, node := range self.Nodes { +func (net *Network) StopAll() error { + for _, node := range net.Nodes { if !node.Up { continue } - if err := self.Stop(node.ID()); err != nil { + if err := net.Stop(node.ID()); err != nil { return err } } @@ -174,21 +174,21 @@ func (self *Network) StopAll() error { } // Start starts the node with the given ID -func (self *Network) Start(id discover.NodeID) error { - return self.startWithSnapshots(id, nil) +func (net *Network) Start(id discover.NodeID) error { + return net.startWithSnapshots(id, nil) } // startWithSnapshots starts the node with the given ID using the give // snapshots -func (self *Network) startWithSnapshots(id discover.NodeID, snapshots map[string][]byte) error { - node := self.GetNode(id) +func (net *Network) startWithSnapshots(id discover.NodeID, snapshots map[string][]byte) error { + node := net.GetNode(id) if node == nil { return fmt.Errorf("node %v does not exist", id) } if node.Up { return fmt.Errorf("node %v already up", id) } - log.Trace(fmt.Sprintf("starting node %v: %v using %v", id, node.Up, self.nodeAdapter.Name())) + log.Trace(fmt.Sprintf("starting node %v: %v using %v", id, node.Up, net.nodeAdapter.Name())) if err := node.Start(snapshots); err != nil { log.Warn(fmt.Sprintf("start up failed: %v", err)) return err @@ -196,7 +196,7 @@ func (self *Network) startWithSnapshots(id discover.NodeID, snapshots map[string node.Up = true log.Info(fmt.Sprintf("started node %v: %v", id, node.Up)) - self.events.Send(NewEvent(node)) + net.events.Send(NewEvent(node)) // subscribe to peer events client, err := node.Client() @@ -208,22 +208,22 @@ func (self *Network) startWithSnapshots(id discover.NodeID, snapshots map[string if err != nil { return fmt.Errorf("error getting peer events for node %v: %s", id, err) } - go self.watchPeerEvents(id, events, sub) + go net.watchPeerEvents(id, events, sub) return nil } // watchPeerEvents reads peer events from the given channel and emits // corresponding network events -func (self *Network) watchPeerEvents(id discover.NodeID, events chan *p2p.PeerEvent, sub event.Subscription) { +func (net *Network) watchPeerEvents(id discover.NodeID, events chan *p2p.PeerEvent, sub event.Subscription) { defer func() { sub.Unsubscribe() // assume the node is now down - self.lock.Lock() - node := self.getNode(id) + net.lock.Lock() + node := net.getNode(id) node.Up = false - self.lock.Unlock() - self.events.Send(NewEvent(node)) + net.lock.Unlock() + net.events.Send(NewEvent(node)) }() for { select { @@ -235,16 +235,16 @@ func (self *Network) watchPeerEvents(id discover.NodeID, events chan *p2p.PeerEv switch event.Type { case p2p.PeerEventTypeAdd: - self.DidConnect(id, peer) + net.DidConnect(id, peer) case p2p.PeerEventTypeDrop: - self.DidDisconnect(id, peer) + net.DidDisconnect(id, peer) case p2p.PeerEventTypeMsgSend: - self.DidSend(id, peer, event.Protocol, *event.MsgCode) + net.DidSend(id, peer, event.Protocol, *event.MsgCode) case p2p.PeerEventTypeMsgRecv: - self.DidReceive(peer, id, event.Protocol, *event.MsgCode) + net.DidReceive(peer, id, event.Protocol, *event.MsgCode) } @@ -258,8 +258,8 @@ func (self *Network) watchPeerEvents(id discover.NodeID, events chan *p2p.PeerEv } // Stop stops the node with the given ID -func (self *Network) Stop(id discover.NodeID) error { - node := self.GetNode(id) +func (net *Network) Stop(id discover.NodeID) error { + node := net.GetNode(id) if node == nil { return fmt.Errorf("node %v does not exist", id) } @@ -272,15 +272,15 @@ func (self *Network) Stop(id discover.NodeID) error { node.Up = false log.Info(fmt.Sprintf("stop node %v: %v", id, node.Up)) - self.events.Send(ControlEvent(node)) + net.events.Send(ControlEvent(node)) return nil } // Connect connects two nodes together by calling the "admin_addPeer" RPC // method on the "one" node so that it connects to the "other" node -func (self *Network) Connect(oneID, otherID discover.NodeID) error { +func (net *Network) Connect(oneID, otherID discover.NodeID) error { log.Debug(fmt.Sprintf("connecting %s to %s", oneID, otherID)) - conn, err := self.InitConn(oneID, otherID) + conn, err := net.InitConn(oneID, otherID) if err != nil { return err } @@ -288,14 +288,14 @@ func (self *Network) Connect(oneID, otherID discover.NodeID) error { if err != nil { return err } - self.events.Send(ControlEvent(conn)) + net.events.Send(ControlEvent(conn)) return client.Call(nil, "admin_addPeer", string(conn.other.Addr())) } // Disconnect disconnects two nodes by calling the "admin_removePeer" RPC // method on the "one" node so that it disconnects from the "other" node -func (self *Network) Disconnect(oneID, otherID discover.NodeID) error { - conn := self.GetConn(oneID, otherID) +func (net *Network) Disconnect(oneID, otherID discover.NodeID) error { + conn := net.GetConn(oneID, otherID) if conn == nil { return fmt.Errorf("connection between %v and %v does not exist", oneID, otherID) } @@ -306,13 +306,13 @@ func (self *Network) Disconnect(oneID, otherID discover.NodeID) error { if err != nil { return err } - self.events.Send(ControlEvent(conn)) + net.events.Send(ControlEvent(conn)) return client.Call(nil, "admin_removePeer", string(conn.other.Addr())) } // DidConnect tracks the fact that the "one" node connected to the "other" node -func (self *Network) DidConnect(one, other discover.NodeID) error { - conn, err := self.GetOrCreateConn(one, other) +func (net *Network) DidConnect(one, other discover.NodeID) error { + conn, err := net.GetOrCreateConn(one, other) if err != nil { return fmt.Errorf("connection between %v and %v does not exist", one, other) } @@ -320,14 +320,14 @@ func (self *Network) DidConnect(one, other discover.NodeID) error { return fmt.Errorf("%v and %v already connected", one, other) } conn.Up = true - self.events.Send(NewEvent(conn)) + net.events.Send(NewEvent(conn)) return nil } // DidDisconnect tracks the fact that the "one" node disconnected from the // "other" node -func (self *Network) DidDisconnect(one, other discover.NodeID) error { - conn := self.GetConn(one, other) +func (net *Network) DidDisconnect(one, other discover.NodeID) error { + conn := net.GetConn(one, other) if conn == nil { return fmt.Errorf("connection between %v and %v does not exist", one, other) } @@ -336,12 +336,12 @@ func (self *Network) DidDisconnect(one, other discover.NodeID) error { } conn.Up = false conn.initiated = time.Now().Add(-dialBanTimeout) - self.events.Send(NewEvent(conn)) + net.events.Send(NewEvent(conn)) return nil } // DidSend tracks the fact that "sender" sent a message to "receiver" -func (self *Network) DidSend(sender, receiver discover.NodeID, proto string, code uint64) error { +func (net *Network) DidSend(sender, receiver discover.NodeID, proto string, code uint64) error { msg := &Msg{ One: sender, Other: receiver, @@ -349,12 +349,12 @@ func (self *Network) DidSend(sender, receiver discover.NodeID, proto string, cod Code: code, Received: false, } - self.events.Send(NewEvent(msg)) + net.events.Send(NewEvent(msg)) return nil } // DidReceive tracks the fact that "receiver" received a message from "sender" -func (self *Network) DidReceive(sender, receiver discover.NodeID, proto string, code uint64) error { +func (net *Network) DidReceive(sender, receiver discover.NodeID, proto string, code uint64) error { msg := &Msg{ One: sender, Other: receiver, @@ -362,36 +362,36 @@ func (self *Network) DidReceive(sender, receiver discover.NodeID, proto string, Code: code, Received: true, } - self.events.Send(NewEvent(msg)) + net.events.Send(NewEvent(msg)) return nil } // GetNode gets the node with the given ID, returning nil if the node does not // exist -func (self *Network) GetNode(id discover.NodeID) *Node { - self.lock.Lock() - defer self.lock.Unlock() - return self.getNode(id) +func (net *Network) GetNode(id discover.NodeID) *Node { + net.lock.Lock() + defer net.lock.Unlock() + return net.getNode(id) } // GetNode gets the node with the given name, returning nil if the node does // not exist -func (self *Network) GetNodeByName(name string) *Node { - self.lock.Lock() - defer self.lock.Unlock() - return self.getNodeByName(name) +func (net *Network) GetNodeByName(name string) *Node { + net.lock.Lock() + defer net.lock.Unlock() + return net.getNodeByName(name) } -func (self *Network) getNode(id discover.NodeID) *Node { - i, found := self.nodeMap[id] +func (net *Network) getNode(id discover.NodeID) *Node { + i, found := net.nodeMap[id] if !found { return nil } - return self.Nodes[i] + return net.Nodes[i] } -func (self *Network) getNodeByName(name string) *Node { - for _, node := range self.Nodes { +func (net *Network) getNodeByName(name string) *Node { + for _, node := range net.Nodes { if node.Config.Name == name { return node } @@ -400,40 +400,40 @@ func (self *Network) getNodeByName(name string) *Node { } // GetNodes returns the existing nodes -func (self *Network) GetNodes() (nodes []*Node) { - self.lock.Lock() - defer self.lock.Unlock() +func (net *Network) GetNodes() (nodes []*Node) { + net.lock.Lock() + defer net.lock.Unlock() - nodes = append(nodes, self.Nodes...) + nodes = append(nodes, net.Nodes...) return nodes } // GetConn returns the connection which exists between "one" and "other" // regardless of which node initiated the connection -func (self *Network) GetConn(oneID, otherID discover.NodeID) *Conn { - self.lock.Lock() - defer self.lock.Unlock() - return self.getConn(oneID, otherID) +func (net *Network) GetConn(oneID, otherID discover.NodeID) *Conn { + net.lock.Lock() + defer net.lock.Unlock() + return net.getConn(oneID, otherID) } // GetOrCreateConn is like GetConn but creates the connection if it doesn't // already exist -func (self *Network) GetOrCreateConn(oneID, otherID discover.NodeID) (*Conn, error) { - self.lock.Lock() - defer self.lock.Unlock() - return self.getOrCreateConn(oneID, otherID) +func (net *Network) GetOrCreateConn(oneID, otherID discover.NodeID) (*Conn, error) { + net.lock.Lock() + defer net.lock.Unlock() + return net.getOrCreateConn(oneID, otherID) } -func (self *Network) getOrCreateConn(oneID, otherID discover.NodeID) (*Conn, error) { - if conn := self.getConn(oneID, otherID); conn != nil { +func (net *Network) getOrCreateConn(oneID, otherID discover.NodeID) (*Conn, error) { + if conn := net.getConn(oneID, otherID); conn != nil { return conn, nil } - one := self.getNode(oneID) + one := net.getNode(oneID) if one == nil { return nil, fmt.Errorf("node %v does not exist", oneID) } - other := self.getNode(otherID) + other := net.getNode(otherID) if other == nil { return nil, fmt.Errorf("node %v does not exist", otherID) } @@ -444,18 +444,18 @@ func (self *Network) getOrCreateConn(oneID, otherID discover.NodeID) (*Conn, err other: other, } label := ConnLabel(oneID, otherID) - self.connMap[label] = len(self.Conns) - self.Conns = append(self.Conns, conn) + net.connMap[label] = len(net.Conns) + net.Conns = append(net.Conns, conn) return conn, nil } -func (self *Network) getConn(oneID, otherID discover.NodeID) *Conn { +func (net *Network) getConn(oneID, otherID discover.NodeID) *Conn { label := ConnLabel(oneID, otherID) - i, found := self.connMap[label] + i, found := net.connMap[label] if !found { return nil } - return self.Conns[i] + return net.Conns[i] } // InitConn(one, other) retrieves the connectiton model for the connection between @@ -466,13 +466,13 @@ func (self *Network) getConn(oneID, otherID discover.NodeID) *Conn { // it also checks whether there has been recent attempt to connect the peers // this is cheating as the simulation is used as an oracle and know about // remote peers attempt to connect to a node which will then not initiate the connection -func (self *Network) InitConn(oneID, otherID discover.NodeID) (*Conn, error) { - self.lock.Lock() - defer self.lock.Unlock() +func (net *Network) InitConn(oneID, otherID discover.NodeID) (*Conn, error) { + net.lock.Lock() + defer net.lock.Unlock() if oneID == otherID { return nil, fmt.Errorf("refusing to connect to self %v", oneID) } - conn, err := self.getOrCreateConn(oneID, otherID) + conn, err := net.getOrCreateConn(oneID, otherID) if err != nil { return nil, err } @@ -491,28 +491,28 @@ func (self *Network) InitConn(oneID, otherID discover.NodeID) (*Conn, error) { } // Shutdown stops all nodes in the network and closes the quit channel -func (self *Network) Shutdown() { - for _, node := range self.Nodes { +func (net *Network) Shutdown() { + for _, node := range net.Nodes { log.Debug(fmt.Sprintf("stopping node %s", node.ID().TerminalString())) if err := node.Stop(); err != nil { log.Warn(fmt.Sprintf("error stopping node %s", node.ID().TerminalString()), "err", err) } } - close(self.quitc) + close(net.quitc) } //Reset resets all network properties: //emtpies the nodes and the connection list -func (self *Network) Reset() { - self.lock.Lock() - defer self.lock.Unlock() +func (net *Network) Reset() { + net.lock.Lock() + defer net.lock.Unlock() //re-initialize the maps - self.connMap = make(map[string]int) - self.nodeMap = make(map[discover.NodeID]int) + net.connMap = make(map[string]int) + net.nodeMap = make(map[discover.NodeID]int) - self.Nodes = nil - self.Conns = nil + net.Nodes = nil + net.Conns = nil } // Node is a wrapper around adapters.Node which is used to track the status @@ -528,37 +528,37 @@ type Node struct { } // ID returns the ID of the node -func (self *Node) ID() discover.NodeID { - return self.Config.ID +func (n *Node) ID() discover.NodeID { + return n.Config.ID } // String returns a log-friendly string -func (self *Node) String() string { - return fmt.Sprintf("Node %v", self.ID().TerminalString()) +func (n *Node) String() string { + return fmt.Sprintf("Node %v", n.ID().TerminalString()) } // NodeInfo returns information about the node -func (self *Node) NodeInfo() *p2p.NodeInfo { +func (n *Node) NodeInfo() *p2p.NodeInfo { // avoid a panic if the node is not started yet - if self.Node == nil { + if n.Node == nil { return nil } - info := self.Node.NodeInfo() - info.Name = self.Config.Name + info := n.Node.NodeInfo() + info.Name = n.Config.Name return info } // MarshalJSON implements the json.Marshaler interface so that the encoded // JSON includes the NodeInfo -func (self *Node) MarshalJSON() ([]byte, error) { +func (n *Node) MarshalJSON() ([]byte, error) { return json.Marshal(struct { Info *p2p.NodeInfo `json:"info,omitempty"` Config *adapters.NodeConfig `json:"config,omitempty"` Up bool `json:"up"` }{ - Info: self.NodeInfo(), - Config: self.Config, - Up: self.Up, + Info: n.NodeInfo(), + Config: n.Config, + Up: n.Up, }) } @@ -580,19 +580,19 @@ type Conn struct { } // nodesUp returns whether both nodes are currently up -func (self *Conn) nodesUp() error { - if !self.one.Up { - return fmt.Errorf("one %v is not up", self.One) +func (c *Conn) nodesUp() error { + if !c.one.Up { + return fmt.Errorf("one %v is not up", c.One) } - if !self.other.Up { - return fmt.Errorf("other %v is not up", self.Other) + if !c.other.Up { + return fmt.Errorf("other %v is not up", c.Other) } return nil } // String returns a log-friendly string -func (self *Conn) String() string { - return fmt.Sprintf("Conn %v->%v", self.One.TerminalString(), self.Other.TerminalString()) +func (c *Conn) String() string { + return fmt.Sprintf("Conn %v->%v", c.One.TerminalString(), c.Other.TerminalString()) } // Msg represents a p2p message sent between two nodes in the network @@ -605,8 +605,8 @@ type Msg struct { } // String returns a log-friendly string -func (self *Msg) String() string { - return fmt.Sprintf("Msg(%d) %v->%v", self.Code, self.One.TerminalString(), self.Other.TerminalString()) +func (m *Msg) String() string { + return fmt.Sprintf("Msg(%d) %v->%v", m.Code, m.One.TerminalString(), m.Other.TerminalString()) } // ConnLabel generates a deterministic string which represents a connection @@ -640,14 +640,14 @@ type NodeSnapshot struct { } // Snapshot creates a network snapshot -func (self *Network) Snapshot() (*Snapshot, error) { - self.lock.Lock() - defer self.lock.Unlock() +func (net *Network) Snapshot() (*Snapshot, error) { + net.lock.Lock() + defer net.lock.Unlock() snap := &Snapshot{ - Nodes: make([]NodeSnapshot, len(self.Nodes)), - Conns: make([]Conn, len(self.Conns)), + Nodes: make([]NodeSnapshot, len(net.Nodes)), + Conns: make([]Conn, len(net.Conns)), } - for i, node := range self.Nodes { + for i, node := range net.Nodes { snap.Nodes[i] = NodeSnapshot{Node: *node} if !node.Up { continue @@ -658,33 +658,33 @@ func (self *Network) Snapshot() (*Snapshot, error) { } snap.Nodes[i].Snapshots = snapshots } - for i, conn := range self.Conns { + for i, conn := range net.Conns { snap.Conns[i] = *conn } return snap, nil } // Load loads a network snapshot -func (self *Network) Load(snap *Snapshot) error { +func (net *Network) Load(snap *Snapshot) error { for _, n := range snap.Nodes { - if _, err := self.NewNodeWithConfig(n.Node.Config); err != nil { + if _, err := net.NewNodeWithConfig(n.Node.Config); err != nil { return err } if !n.Node.Up { continue } - if err := self.startWithSnapshots(n.Node.Config.ID, n.Snapshots); err != nil { + if err := net.startWithSnapshots(n.Node.Config.ID, n.Snapshots); err != nil { return err } } for _, conn := range snap.Conns { - if !self.GetNode(conn.One).Up || !self.GetNode(conn.Other).Up { + if !net.GetNode(conn.One).Up || !net.GetNode(conn.Other).Up { //in this case, at least one of the nodes of a connection is not up, //so it would result in the snapshot `Load` to fail continue } - if err := self.Connect(conn.One, conn.Other); err != nil { + if err := net.Connect(conn.One, conn.Other); err != nil { return err } } @@ -692,7 +692,7 @@ func (self *Network) Load(snap *Snapshot) error { } // Subscribe reads control events from a channel and executes them -func (self *Network) Subscribe(events chan *Event) { +func (net *Network) Subscribe(events chan *Event) { for { select { case event, ok := <-events: @@ -700,23 +700,23 @@ func (self *Network) Subscribe(events chan *Event) { return } if event.Control { - self.executeControlEvent(event) + net.executeControlEvent(event) } - case <-self.quitc: + case <-net.quitc: return } } } -func (self *Network) executeControlEvent(event *Event) { +func (net *Network) executeControlEvent(event *Event) { log.Trace("execute control event", "type", event.Type, "event", event) switch event.Type { case EventTypeNode: - if err := self.executeNodeEvent(event); err != nil { + if err := net.executeNodeEvent(event); err != nil { log.Error("error executing node event", "event", event, "err", err) } case EventTypeConn: - if err := self.executeConnEvent(event); err != nil { + if err := net.executeConnEvent(event); err != nil { log.Error("error executing conn event", "event", event, "err", err) } case EventTypeMsg: @@ -724,21 +724,21 @@ func (self *Network) executeControlEvent(event *Event) { } } -func (self *Network) executeNodeEvent(e *Event) error { +func (net *Network) executeNodeEvent(e *Event) error { if !e.Node.Up { - return self.Stop(e.Node.ID()) + return net.Stop(e.Node.ID()) } - if _, err := self.NewNodeWithConfig(e.Node.Config); err != nil { + if _, err := net.NewNodeWithConfig(e.Node.Config); err != nil { return err } - return self.Start(e.Node.ID()) + return net.Start(e.Node.ID()) } -func (self *Network) executeConnEvent(e *Event) error { +func (net *Network) executeConnEvent(e *Event) error { if e.Conn.Up { - return self.Connect(e.Conn.One, e.Conn.Other) + return net.Connect(e.Conn.One, e.Conn.Other) } else { - return self.Disconnect(e.Conn.One, e.Conn.Other) + return net.Disconnect(e.Conn.One, e.Conn.Other) } } diff --git a/p2p/testing/peerpool.go b/p2p/testing/peerpool.go index 6f8a5d7a52..d34b4c0780 100644 --- a/p2p/testing/peerpool.go +++ b/p2p/testing/peerpool.go @@ -39,29 +39,29 @@ func NewTestPeerPool() *TestPeerPool { return &TestPeerPool{peers: make(map[discover.NodeID]TestPeer)} } -func (self *TestPeerPool) Add(p TestPeer) { - self.lock.Lock() - defer self.lock.Unlock() +func (pp *TestPeerPool) Add(p TestPeer) { + pp.lock.Lock() + defer pp.lock.Unlock() log.Trace(fmt.Sprintf("pp add peer %v", p.ID())) - self.peers[p.ID()] = p + pp.peers[p.ID()] = p } -func (self *TestPeerPool) Remove(p TestPeer) { - self.lock.Lock() - defer self.lock.Unlock() - delete(self.peers, p.ID()) +func (pp *TestPeerPool) Remove(p TestPeer) { + pp.lock.Lock() + defer pp.lock.Unlock() + delete(pp.peers, p.ID()) } -func (self *TestPeerPool) Has(id discover.NodeID) bool { - self.lock.Lock() - defer self.lock.Unlock() - _, ok := self.peers[id] +func (pp *TestPeerPool) Has(id discover.NodeID) bool { + pp.lock.Lock() + defer pp.lock.Unlock() + _, ok := pp.peers[id] return ok } -func (self *TestPeerPool) Get(id discover.NodeID) TestPeer { - self.lock.Lock() - defer self.lock.Unlock() - return self.peers[id] +func (pp *TestPeerPool) Get(id discover.NodeID) TestPeer { + pp.lock.Lock() + defer pp.lock.Unlock() + return pp.peers[id] } diff --git a/p2p/testing/protocolsession.go b/p2p/testing/protocolsession.go index 2c0133b111..39ccc70bd0 100644 --- a/p2p/testing/protocolsession.go +++ b/p2p/testing/protocolsession.go @@ -78,10 +78,10 @@ type Disconnect struct { } // trigger sends messages from peers -func (self *ProtocolSession) trigger(trig Trigger) error { - simNode, ok := self.adapter.GetNode(trig.Peer) +func (ps *ProtocolSession) trigger(trig Trigger) error { + simNode, ok := ps.adapter.GetNode(trig.Peer) if !ok { - return fmt.Errorf("trigger: peer %v does not exist (1- %v)", trig.Peer, len(self.IDs)) + return fmt.Errorf("trigger: peer %v does not exist (1- %v)", trig.Peer, len(ps.IDs)) } mockNode, ok := simNode.Services()[0].(*mockNode) if !ok { @@ -107,7 +107,7 @@ func (self *ProtocolSession) trigger(trig Trigger) error { } // expect checks an expectation of a message sent out by the pivot node -func (self *ProtocolSession) expect(exps []Expect) error { +func (ps *ProtocolSession) expect(exps []Expect) error { // construct a map of expectations for each node peerExpects := make(map[discover.NodeID][]Expect) for _, exp := range exps { @@ -120,9 +120,9 @@ func (self *ProtocolSession) expect(exps []Expect) error { // construct a map of mockNodes for each node mockNodes := make(map[discover.NodeID]*mockNode) for nodeID := range peerExpects { - simNode, ok := self.adapter.GetNode(nodeID) + simNode, ok := ps.adapter.GetNode(nodeID) if !ok { - return fmt.Errorf("trigger: peer %v does not exist (1- %v)", nodeID, len(self.IDs)) + return fmt.Errorf("trigger: peer %v does not exist (1- %v)", nodeID, len(ps.IDs)) } mockNode, ok := simNode.Services()[0].(*mockNode) if !ok { @@ -202,9 +202,9 @@ func (self *ProtocolSession) expect(exps []Expect) error { } // TestExchanges tests a series of exchanges against the session -func (self *ProtocolSession) TestExchanges(exchanges ...Exchange) error { +func (ps *ProtocolSession) TestExchanges(exchanges ...Exchange) error { for i, e := range exchanges { - if err := self.testExchange(e); err != nil { + if err := ps.testExchange(e); err != nil { return fmt.Errorf("exchange #%d %q: %v", i, e.Label, err) } log.Trace(fmt.Sprintf("exchange #%d %q: run successfully", i, e.Label)) @@ -214,14 +214,14 @@ func (self *ProtocolSession) TestExchanges(exchanges ...Exchange) error { // testExchange tests a single Exchange. // Default timeout value is 2 seconds. -func (self *ProtocolSession) testExchange(e Exchange) error { +func (ps *ProtocolSession) testExchange(e Exchange) error { errc := make(chan error) done := make(chan struct{}) defer close(done) go func() { for _, trig := range e.Triggers { - err := self.trigger(trig) + err := ps.trigger(trig) if err != nil { errc <- err return @@ -229,7 +229,7 @@ func (self *ProtocolSession) testExchange(e Exchange) error { } select { - case errc <- self.expect(e.Expects): + case errc <- ps.expect(e.Expects): case <-done: } }() @@ -250,7 +250,7 @@ func (self *ProtocolSession) testExchange(e Exchange) error { // TestDisconnected tests the disconnections given as arguments // the disconnect structs describe what disconnect error is expected on which peer -func (self *ProtocolSession) TestDisconnected(disconnects ...*Disconnect) error { +func (ps *ProtocolSession) TestDisconnected(disconnects ...*Disconnect) error { expects := make(map[discover.NodeID]error) for _, disconnect := range disconnects { expects[disconnect.Peer] = disconnect.Error @@ -259,7 +259,7 @@ func (self *ProtocolSession) TestDisconnected(disconnects ...*Disconnect) error timeout := time.After(time.Second) for len(expects) > 0 { select { - case event := <-self.events: + case event := <-ps.events: if event.Type != p2p.PeerEventTypeDrop { continue } diff --git a/p2p/testing/protocoltester.go b/p2p/testing/protocoltester.go index 21a57fd09c..622d63bfe3 100644 --- a/p2p/testing/protocoltester.go +++ b/p2p/testing/protocoltester.go @@ -100,24 +100,24 @@ func NewProtocolTester(t *testing.T, id discover.NodeID, n int, run func(*p2p.Pe } // Stop stops the p2p server -func (self *ProtocolTester) Stop() error { - self.Server.Stop() +func (pt *ProtocolTester) Stop() error { + pt.Server.Stop() return nil } // Connect brings up the remote peer node and connects it using the // p2p/simulations network connection with the in memory network adapter -func (self *ProtocolTester) Connect(selfID discover.NodeID, peers ...*adapters.NodeConfig) { +func (pt *ProtocolTester) Connect(selfID discover.NodeID, peers ...*adapters.NodeConfig) { for _, peer := range peers { log.Trace(fmt.Sprintf("start node %v", peer.ID)) - if _, err := self.network.NewNodeWithConfig(peer); err != nil { + if _, err := pt.network.NewNodeWithConfig(peer); err != nil { panic(fmt.Sprintf("error starting peer %v: %v", peer.ID, err)) } - if err := self.network.Start(peer.ID); err != nil { + if err := pt.network.Start(peer.ID); err != nil { panic(fmt.Sprintf("error starting peer %v: %v", peer.ID, err)) } log.Trace(fmt.Sprintf("connect to %v", peer.ID)) - if err := self.network.Connect(selfID, peer.ID); err != nil { + if err := pt.network.Connect(selfID, peer.ID); err != nil { panic(fmt.Sprintf("error connecting to peer %v: %v", peer.ID, err)) } } @@ -130,25 +130,25 @@ type testNode struct { run func(*p2p.Peer, p2p.MsgReadWriter) error } -func (t *testNode) Protocols() []p2p.Protocol { +func (tn *testNode) Protocols() []p2p.Protocol { return []p2p.Protocol{{ Length: 100, - Run: t.run, + Run: tn.run, }} } -func (t *testNode) APIs() []rpc.API { +func (tn *testNode) APIs() []rpc.API { return nil } -func (t *testNode) Start(server *p2p.Server) error { +func (tn *testNode) Start(server *p2p.Server) error { return nil } -func (t *testNode) SaveData() { +func (tn *testNode) SaveData() { } -func (t *testNode) Stop() error { +func (tn *testNode) Stop() error { return nil } @@ -178,34 +178,34 @@ func newMockNode() *mockNode { // Run is a protocol run function which just loops waiting for tests to // instruct it to either trigger or expect a message from the peer -func (m *mockNode) Run(peer *p2p.Peer, rw p2p.MsgReadWriter) error { +func (mn *mockNode) Run(peer *p2p.Peer, rw p2p.MsgReadWriter) error { for { select { - case trig := <-m.trigger: - m.err <- p2p.Send(rw, trig.Code, trig.Msg) - case exps := <-m.expect: - m.err <- expectMsgs(rw, exps) - case <-m.stop: + case trig := <-mn.trigger: + mn.err <- p2p.Send(rw, trig.Code, trig.Msg) + case exps := <-mn.expect: + mn.err <- expectMsgs(rw, exps) + case <-mn.stop: return nil } } } -func (m *mockNode) Trigger(trig *Trigger) error { - m.trigger <- trig - return <-m.err +func (mn *mockNode) Trigger(trig *Trigger) error { + mn.trigger <- trig + return <-mn.err } -func (m *mockNode) Expect(exp ...Expect) error { - m.expect <- exp - return <-m.err +func (mn *mockNode) Expect(exp ...Expect) error { + mn.expect <- exp + return <-mn.err } -func (m *mockNode) SaveData() { +func (mn *mockNode) SaveData() { } -func (m *mockNode) Stop() error { - m.stopOnce.Do(func() { close(m.stop) }) +func (mn *mockNode) Stop() error { + mn.stopOnce.Do(func() { close(mn.stop) }) return nil }