mirror of
https://github.com/ethereum/go-ethereum.git
synced 2026-06-26 16:36:17 +00:00
806 lines
24 KiB
Go
806 lines
24 KiB
Go
// Copyright 2014 The go-ethereum Authors
|
|
// This file is part of the go-ethereum library.
|
|
//
|
|
// The go-ethereum library is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Lesser General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// The go-ethereum library is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU Lesser General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Lesser General Public License
|
|
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
package lendingstate
|
|
|
|
import (
|
|
"fmt"
|
|
"io"
|
|
"math/big"
|
|
|
|
"github.com/XinFinOrg/XDPoSChain/common"
|
|
"github.com/XinFinOrg/XDPoSChain/core/types"
|
|
"github.com/XinFinOrg/XDPoSChain/log"
|
|
"github.com/XinFinOrg/XDPoSChain/rlp"
|
|
)
|
|
|
|
type lendingExchangeState struct {
|
|
lendingBook common.Hash
|
|
data lendingObject
|
|
db *LendingStateDB
|
|
|
|
// DB error.
|
|
// State objects are used by the consensus core and VM which are
|
|
// unable to deal with database-level errors. Any error that occurs
|
|
// during a database read is memoized here and will eventually be returned
|
|
// by LendingStateDB.Commit.
|
|
dbErr error
|
|
|
|
investingTrie Trie
|
|
borrowingTrie Trie
|
|
lendingItemTrie Trie
|
|
lendingTradeTrie Trie
|
|
liquidationTimeTrie Trie
|
|
|
|
liquidationTimeStates map[common.Hash]*liquidationTimeState
|
|
liquidationTimestatesDirty map[common.Hash]struct{}
|
|
|
|
investingStates map[common.Hash]*itemListState
|
|
investingStatesDirty map[common.Hash]struct{}
|
|
|
|
borrowingStates map[common.Hash]*itemListState
|
|
borrowingStatesDirty map[common.Hash]struct{}
|
|
|
|
lendingItemStates map[common.Hash]*lendingItemState
|
|
lendingItemStatesDirty map[common.Hash]struct{}
|
|
|
|
lendingTradeStates map[common.Hash]*lendingTradeState
|
|
lendingTradeStatesDirty map[common.Hash]struct{}
|
|
|
|
onDirty func(hash common.Hash) // Callback method to mark a state object newly dirty
|
|
}
|
|
|
|
// empty returns whether the tradeId is considered empty.
|
|
func (s *lendingExchangeState) empty() bool {
|
|
if s.data.Nonce != 0 {
|
|
return false
|
|
}
|
|
if s.data.TradeNonce != 0 {
|
|
return false
|
|
}
|
|
if !s.data.InvestingRoot.IsZero() {
|
|
return false
|
|
}
|
|
if !s.data.BorrowingRoot.IsZero() {
|
|
return false
|
|
}
|
|
if !s.data.LendingItemRoot.IsZero() {
|
|
return false
|
|
}
|
|
if !s.data.LendingTradeRoot.IsZero() {
|
|
return false
|
|
}
|
|
if !s.data.LiquidationTimeRoot.IsZero() {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
func newStateExchanges(db *LendingStateDB, hash common.Hash, data lendingObject, onDirty func(addr common.Hash)) *lendingExchangeState {
|
|
return &lendingExchangeState{
|
|
db: db,
|
|
lendingBook: hash,
|
|
data: data,
|
|
investingStates: make(map[common.Hash]*itemListState),
|
|
borrowingStates: make(map[common.Hash]*itemListState),
|
|
lendingItemStates: make(map[common.Hash]*lendingItemState),
|
|
lendingTradeStates: make(map[common.Hash]*lendingTradeState),
|
|
liquidationTimeStates: make(map[common.Hash]*liquidationTimeState),
|
|
investingStatesDirty: make(map[common.Hash]struct{}),
|
|
borrowingStatesDirty: make(map[common.Hash]struct{}),
|
|
lendingItemStatesDirty: make(map[common.Hash]struct{}),
|
|
lendingTradeStatesDirty: make(map[common.Hash]struct{}),
|
|
liquidationTimestatesDirty: make(map[common.Hash]struct{}),
|
|
onDirty: onDirty,
|
|
}
|
|
}
|
|
|
|
// EncodeRLP implements rlp.Encoder.
|
|
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 (le *lendingExchangeState) setError(err error) {
|
|
if le.dbErr == nil {
|
|
le.dbErr = err
|
|
}
|
|
}
|
|
|
|
/**
|
|
Get Trie
|
|
*/
|
|
|
|
func (le *lendingExchangeState) getLendingItemTrie(db Database) Trie {
|
|
if le.lendingItemTrie == nil {
|
|
var err error
|
|
le.lendingItemTrie, err = db.OpenStorageTrie(le.lendingBook, le.data.LendingItemRoot)
|
|
if err != nil {
|
|
le.lendingItemTrie, _ = db.OpenStorageTrie(le.lendingBook, types.EmptyRootHash)
|
|
le.setError(fmt.Errorf("can't create Lendings trie: %v", err))
|
|
}
|
|
}
|
|
return le.lendingItemTrie
|
|
}
|
|
|
|
func (le *lendingExchangeState) getLendingTradeTrie(db Database) Trie {
|
|
if le.lendingTradeTrie == nil {
|
|
var err error
|
|
le.lendingTradeTrie, err = db.OpenStorageTrie(le.lendingBook, le.data.LendingTradeRoot)
|
|
if err != nil {
|
|
le.lendingTradeTrie, _ = db.OpenStorageTrie(le.lendingBook, types.EmptyRootHash)
|
|
le.setError(fmt.Errorf("can't create Lendings trie: %v", err))
|
|
}
|
|
}
|
|
return le.lendingTradeTrie
|
|
}
|
|
|
|
func (le *lendingExchangeState) getInvestingTrie(db Database) Trie {
|
|
if le.investingTrie == nil {
|
|
var err error
|
|
le.investingTrie, err = db.OpenStorageTrie(le.lendingBook, le.data.InvestingRoot)
|
|
if err != nil {
|
|
le.investingTrie, _ = db.OpenStorageTrie(le.lendingBook, types.EmptyRootHash)
|
|
le.setError(fmt.Errorf("can't create Lendings trie: %v", err))
|
|
}
|
|
}
|
|
return le.investingTrie
|
|
}
|
|
|
|
func (le *lendingExchangeState) getBorrowingTrie(db Database) Trie {
|
|
if le.borrowingTrie == nil {
|
|
var err error
|
|
le.borrowingTrie, err = db.OpenStorageTrie(le.lendingBook, le.data.BorrowingRoot)
|
|
if err != nil {
|
|
le.borrowingTrie, _ = db.OpenStorageTrie(le.lendingBook, types.EmptyRootHash)
|
|
le.setError(fmt.Errorf("can't create bids trie: %v", err))
|
|
}
|
|
}
|
|
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, types.EmptyRootHash)
|
|
le.setError(fmt.Errorf("can't create bids trie: %v", err))
|
|
}
|
|
}
|
|
return le.liquidationTimeTrie
|
|
}
|
|
|
|
/*
|
|
*
|
|
|
|
Get State
|
|
*/
|
|
func (le *lendingExchangeState) getBorrowingOrderList(db Database, rate common.Hash) (stateOrderList *itemListState) {
|
|
// Prefer 'live' objects.
|
|
if obj := le.borrowingStates[rate]; obj != nil {
|
|
return obj
|
|
}
|
|
|
|
// Load the object from the database.
|
|
enc, err := le.getBorrowingTrie(db).TryGet(rate[:])
|
|
if len(enc) == 0 {
|
|
le.setError(err)
|
|
return nil
|
|
}
|
|
var data itemList
|
|
if err := rlp.DecodeBytes(enc, &data); err != nil {
|
|
log.Error("Failed to decode state order list object", "rate", rate, "err", err)
|
|
return nil
|
|
}
|
|
// Insert into the live set.
|
|
obj := newItemListState(le.lendingBook, rate, data, le.MarkBorrowingDirty)
|
|
le.borrowingStates[rate] = obj
|
|
return obj
|
|
}
|
|
|
|
func (le *lendingExchangeState) getInvestingOrderList(db Database, rate common.Hash) (stateOrderList *itemListState) {
|
|
// Prefer 'live' objects.
|
|
if obj := le.investingStates[rate]; obj != nil {
|
|
return obj
|
|
}
|
|
|
|
// Load the object from the database.
|
|
enc, err := le.getInvestingTrie(db).TryGet(rate[:])
|
|
if len(enc) == 0 {
|
|
le.setError(err)
|
|
return nil
|
|
}
|
|
var data itemList
|
|
if err := rlp.DecodeBytes(enc, &data); err != nil {
|
|
log.Error("Failed to decode state order list object", "rate", rate, "err", err)
|
|
return nil
|
|
}
|
|
// Insert into the live set.
|
|
obj := newItemListState(le.lendingBook, rate, data, le.MarkInvestingDirty)
|
|
le.investingStates[rate] = obj
|
|
return obj
|
|
}
|
|
|
|
func (le *lendingExchangeState) getLiquidationTimeOrderList(db Database, time common.Hash) (stateObject *liquidationTimeState) {
|
|
// Prefer 'live' objects.
|
|
if obj := le.liquidationTimeStates[time]; obj != nil {
|
|
return obj
|
|
}
|
|
|
|
// Load the object from the database.
|
|
enc, err := le.getLiquidationTimeTrie(db).TryGet(time[:])
|
|
if len(enc) == 0 {
|
|
le.setError(err)
|
|
return nil
|
|
}
|
|
var data itemList
|
|
if err := rlp.DecodeBytes(enc, &data); err != nil {
|
|
log.Error("Failed to decode state liquidation time", "time", time, "err", err)
|
|
return nil
|
|
}
|
|
// Insert into the live set.
|
|
obj := newLiquidationTimeState(le.lendingBook, time, data, le.MarkLiquidationTimeDirty)
|
|
le.liquidationTimeStates[time] = obj
|
|
return obj
|
|
}
|
|
|
|
func (le *lendingExchangeState) getLendingItem(db Database, lendingId common.Hash) (stateObject *lendingItemState) {
|
|
// Prefer 'live' objects.
|
|
if obj := le.lendingItemStates[lendingId]; obj != nil {
|
|
return obj
|
|
}
|
|
|
|
// Load the object from the database.
|
|
enc, err := le.getLendingItemTrie(db).TryGet(lendingId[:])
|
|
if len(enc) == 0 {
|
|
le.setError(err)
|
|
return nil
|
|
}
|
|
var data LendingItem
|
|
if err := rlp.DecodeBytes(enc, &data); err != nil {
|
|
log.Error("Failed to decode state lending item", "tradeId", lendingId, "err", err)
|
|
return nil
|
|
}
|
|
// Insert into the live set.
|
|
obj := newLendinItemState(le.lendingBook, lendingId, data, le.MarkLendingItemDirty)
|
|
le.lendingItemStates[lendingId] = obj
|
|
return obj
|
|
}
|
|
|
|
func (le *lendingExchangeState) getLendingTrade(db Database, tradeId common.Hash) (stateObject *lendingTradeState) {
|
|
// Prefer 'live' objects.
|
|
if obj := le.lendingTradeStates[tradeId]; obj != nil {
|
|
return obj
|
|
}
|
|
|
|
// Load the object from the database.
|
|
enc, err := le.getLendingTradeTrie(db).TryGet(tradeId[:])
|
|
if len(enc) == 0 {
|
|
le.setError(err)
|
|
return nil
|
|
}
|
|
var data LendingTrade
|
|
if err := rlp.DecodeBytes(enc, &data); err != nil {
|
|
log.Error("Failed to decode state lending trade", "tradeId", tradeId, "err", err)
|
|
return nil
|
|
}
|
|
// Insert into the live set.
|
|
obj := newLendingTradeState(le.lendingBook, tradeId, data, le.MarkLendingTradeDirty)
|
|
le.lendingTradeStates[tradeId] = obj
|
|
return obj
|
|
}
|
|
|
|
/*
|
|
*
|
|
|
|
Update Trie
|
|
*/
|
|
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() {
|
|
le.setError(tr.TryDelete(lendingId[:]))
|
|
continue
|
|
}
|
|
// Encoding []byte cannot fail, ok to ignore the error.
|
|
v, _ := rlp.EncodeToBytes(lendingItem)
|
|
le.setError(tr.TryUpdate(lendingId[:], v))
|
|
}
|
|
}
|
|
return tr
|
|
}
|
|
|
|
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() {
|
|
le.setError(tr.TryDelete(tradeId[:]))
|
|
continue
|
|
}
|
|
// Encoding []byte cannot fail, ok to ignore the error.
|
|
v, _ := rlp.EncodeToBytes(lendingTradeItem)
|
|
le.setError(tr.TryUpdate(tradeId[:], v))
|
|
}
|
|
}
|
|
return tr
|
|
}
|
|
|
|
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() {
|
|
le.setError(tr.TryDelete(rate[:]))
|
|
continue
|
|
}
|
|
err := orderList.updateRoot(db)
|
|
if err != nil {
|
|
log.Warn("updateBorrowingTrie updateRoot", "err", err, "rate", rate, "orderList", *orderList)
|
|
}
|
|
// Encoding []byte cannot fail, ok to ignore the error.
|
|
v, _ := rlp.EncodeToBytes(orderList)
|
|
le.setError(tr.TryUpdate(rate[:], v))
|
|
}
|
|
}
|
|
return tr
|
|
}
|
|
|
|
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() {
|
|
le.setError(tr.TryDelete(rate[:]))
|
|
continue
|
|
}
|
|
err := orderList.updateRoot(db)
|
|
if err != nil {
|
|
log.Warn("updateInvestingTrie updateRoot", "err", err, "rate", rate, "orderList", *orderList)
|
|
}
|
|
// Encoding []byte cannot fail, ok to ignore the error.
|
|
v, _ := rlp.EncodeToBytes(orderList)
|
|
le.setError(tr.TryUpdate(rate[:], v))
|
|
}
|
|
}
|
|
return tr
|
|
}
|
|
|
|
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() {
|
|
le.setError(tr.TryDelete(time[:]))
|
|
continue
|
|
}
|
|
err := itemList.updateRoot(db)
|
|
if err != nil {
|
|
log.Warn("updateLiquidationTimeTrie updateRoot", "err", err, "time", time, "itemList", *itemList)
|
|
}
|
|
// Encoding []byte cannot fail, ok to ignore the error.
|
|
v, _ := rlp.EncodeToBytes(itemList)
|
|
le.setError(tr.TryUpdate(time[:], v))
|
|
}
|
|
}
|
|
return tr
|
|
}
|
|
|
|
/**
|
|
Update Root
|
|
*/
|
|
|
|
func (le *lendingExchangeState) updateOrderRoot(db Database) {
|
|
le.updateLendingTimeTrie(db)
|
|
le.data.LendingItemRoot = le.lendingItemTrie.Hash()
|
|
}
|
|
|
|
func (le *lendingExchangeState) updateInvestingRoot(db Database) error {
|
|
le.updateInvestingTrie(db)
|
|
if le.dbErr != nil {
|
|
return le.dbErr
|
|
}
|
|
le.data.InvestingRoot = le.investingTrie.Hash()
|
|
return nil
|
|
}
|
|
|
|
func (le *lendingExchangeState) updateBorrowingRoot(db Database) {
|
|
le.updateBorrowingTrie(db)
|
|
le.data.BorrowingRoot = le.borrowingTrie.Hash()
|
|
}
|
|
|
|
func (le *lendingExchangeState) updateLiquidationTimeRoot(db Database) {
|
|
le.updateLiquidationTimeTrie(db)
|
|
le.data.LiquidationTimeRoot = le.liquidationTimeTrie.Hash()
|
|
}
|
|
|
|
func (le *lendingExchangeState) updateLendingTradeRoot(db Database) {
|
|
le.updateLendingTradeTrie(db)
|
|
le.data.LendingTradeRoot = le.lendingTradeTrie.Hash()
|
|
}
|
|
|
|
/**
|
|
Commit Trie
|
|
*/
|
|
|
|
func (le *lendingExchangeState) CommitLendingItemTrie(db Database) error {
|
|
le.updateLendingTimeTrie(db)
|
|
if le.dbErr != nil {
|
|
return le.dbErr
|
|
}
|
|
root, err := le.lendingItemTrie.Commit(nil)
|
|
if err == nil {
|
|
le.data.LendingItemRoot = root
|
|
}
|
|
return err
|
|
}
|
|
|
|
func (le *lendingExchangeState) CommitLendingTradeTrie(db Database) error {
|
|
le.updateLendingTradeTrie(db)
|
|
if le.dbErr != nil {
|
|
return le.dbErr
|
|
}
|
|
root, err := le.lendingTradeTrie.Commit(nil)
|
|
if err == nil {
|
|
le.data.LendingTradeRoot = root
|
|
}
|
|
return err
|
|
}
|
|
|
|
func (le *lendingExchangeState) CommitInvestingTrie(db Database) error {
|
|
le.updateInvestingTrie(db)
|
|
if le.dbErr != nil {
|
|
return le.dbErr
|
|
}
|
|
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
|
|
}
|
|
if orderList.Root != EmptyRoot {
|
|
db.TrieDB().Reference(orderList.Root, parent)
|
|
}
|
|
return nil
|
|
})
|
|
if err == nil {
|
|
le.data.InvestingRoot = root
|
|
}
|
|
return err
|
|
}
|
|
|
|
func (le *lendingExchangeState) CommitBorrowingTrie(db Database) error {
|
|
le.updateBorrowingTrie(db)
|
|
if le.dbErr != nil {
|
|
return le.dbErr
|
|
}
|
|
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
|
|
}
|
|
if orderList.Root != EmptyRoot {
|
|
db.TrieDB().Reference(orderList.Root, parent)
|
|
}
|
|
return nil
|
|
})
|
|
if err == nil {
|
|
le.data.BorrowingRoot = root
|
|
}
|
|
return err
|
|
}
|
|
|
|
func (le *lendingExchangeState) CommitLiquidationTimeTrie(db Database) error {
|
|
le.updateLiquidationTimeTrie(db)
|
|
if le.dbErr != nil {
|
|
return le.dbErr
|
|
}
|
|
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
|
|
}
|
|
if orderList.Root != EmptyRoot {
|
|
db.TrieDB().Reference(orderList.Root, parent)
|
|
}
|
|
return nil
|
|
})
|
|
if err == nil {
|
|
le.data.LiquidationTimeRoot = root
|
|
}
|
|
return err
|
|
}
|
|
|
|
/*
|
|
*
|
|
|
|
Get Trie Data
|
|
*/
|
|
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", le.lendingBook.Hex())
|
|
return EmptyHash
|
|
}
|
|
if len(encKey) == 0 || len(encValue) == 0 {
|
|
log.Debug("Not found get best investing rate", "encKey", encKey, "encValue", encValue)
|
|
return EmptyHash
|
|
}
|
|
// Insert into the live set.
|
|
interest := common.BytesToHash(encKey)
|
|
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(le.lendingBook, interest, data, le.MarkInvestingDirty)
|
|
le.investingStates[interest] = obj
|
|
}
|
|
return interest
|
|
}
|
|
|
|
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", le.lendingBook.Hex())
|
|
return EmptyHash
|
|
}
|
|
if len(encKey) == 0 || len(encValue) == 0 {
|
|
log.Debug("Not found get best bid trie", "encKey", encKey, "encValue", encValue)
|
|
return EmptyHash
|
|
}
|
|
// Insert into the live set.
|
|
interest := common.BytesToHash(encKey)
|
|
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(le.lendingBook, interest, data, le.MarkBorrowingDirty)
|
|
le.borrowingStates[interest] = obj
|
|
}
|
|
return interest
|
|
}
|
|
|
|
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", le.lendingBook.Hex())
|
|
return EmptyHash, nil
|
|
}
|
|
if len(encKey) == 0 || len(encValue) == 0 {
|
|
log.Debug("Not found get liquidation time trie", "encKey", encKey, "encValue", encValue)
|
|
return EmptyHash, nil
|
|
}
|
|
price := common.BytesToHash(encKey)
|
|
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(le.lendingBook, price, data, le.MarkLiquidationTimeDirty)
|
|
le.liquidationTimeStates[price] = obj
|
|
}
|
|
if obj.empty() {
|
|
return EmptyHash, nil
|
|
}
|
|
return price, obj
|
|
}
|
|
|
|
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 le.borrowingTrie != nil {
|
|
stateExchanges.borrowingTrie = db.db.CopyTrie(le.borrowingTrie)
|
|
}
|
|
if le.lendingItemTrie != nil {
|
|
stateExchanges.lendingItemTrie = db.db.CopyTrie(le.lendingItemTrie)
|
|
}
|
|
for key, value := range le.borrowingStates {
|
|
stateExchanges.borrowingStates[key] = value.deepCopy(db, le.MarkBorrowingDirty)
|
|
}
|
|
for key := range le.borrowingStatesDirty {
|
|
stateExchanges.borrowingStatesDirty[key] = struct{}{}
|
|
}
|
|
for key, value := range le.investingStates {
|
|
stateExchanges.investingStates[key] = value.deepCopy(db, le.MarkInvestingDirty)
|
|
}
|
|
for key := range le.investingStatesDirty {
|
|
stateExchanges.investingStatesDirty[key] = struct{}{}
|
|
}
|
|
for key, value := range le.lendingItemStates {
|
|
stateExchanges.lendingItemStates[key] = value.deepCopy(le.MarkLendingItemDirty)
|
|
}
|
|
for orderId := range le.lendingItemStatesDirty {
|
|
stateExchanges.lendingItemStatesDirty[orderId] = struct{}{}
|
|
}
|
|
for key, value := range le.lendingTradeStates {
|
|
stateExchanges.lendingTradeStates[key] = value.deepCopy(le.MarkLendingTradeDirty)
|
|
}
|
|
for orderId := range le.lendingTradeStatesDirty {
|
|
stateExchanges.lendingTradeStatesDirty[orderId] = struct{}{}
|
|
}
|
|
for time, orderList := range le.liquidationTimeStates {
|
|
stateExchanges.liquidationTimeStates[time] = orderList.deepCopy(db, le.MarkLiquidationTimeDirty)
|
|
}
|
|
for time := range le.liquidationTimestatesDirty {
|
|
stateExchanges.liquidationTimestatesDirty[time] = struct{}{}
|
|
}
|
|
return stateExchanges
|
|
}
|
|
|
|
// Returns the address of the contract/tradeId
|
|
func (le *lendingExchangeState) Hash() common.Hash {
|
|
return le.lendingBook
|
|
}
|
|
|
|
func (le *lendingExchangeState) setNonce(nonce uint64) {
|
|
le.data.Nonce = nonce
|
|
if le.onDirty != nil {
|
|
le.onDirty(le.Hash())
|
|
le.onDirty = nil
|
|
}
|
|
}
|
|
|
|
func (le *lendingExchangeState) Nonce() uint64 {
|
|
return le.data.Nonce
|
|
}
|
|
|
|
func (le *lendingExchangeState) setTradeNonce(nonce uint64) {
|
|
le.data.TradeNonce = nonce
|
|
if le.onDirty != nil {
|
|
le.onDirty(le.Hash())
|
|
le.onDirty = nil
|
|
}
|
|
}
|
|
|
|
func (le *lendingExchangeState) TradeNonce() uint64 {
|
|
return le.data.TradeNonce
|
|
}
|
|
|
|
func (le *lendingExchangeState) removeInvestingOrderList(db Database, stateOrderList *itemListState) {
|
|
le.setError(le.investingTrie.TryDelete(stateOrderList.key[:]))
|
|
}
|
|
|
|
func (le *lendingExchangeState) removeBorrowingOrderList(db Database, stateOrderList *itemListState) {
|
|
le.setError(le.borrowingTrie.TryDelete(stateOrderList.key[:]))
|
|
}
|
|
|
|
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))
|
|
}
|
|
le.setError(le.getInvestingTrie(db).TryUpdate(price[:], data))
|
|
if le.onDirty != nil {
|
|
le.onDirty(le.Hash())
|
|
le.onDirty = nil
|
|
}
|
|
return newobj
|
|
}
|
|
|
|
func (le *lendingExchangeState) MarkBorrowingDirty(price common.Hash) {
|
|
le.borrowingStatesDirty[price] = struct{}{}
|
|
if le.onDirty != nil {
|
|
le.onDirty(le.Hash())
|
|
le.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 (le *lendingExchangeState) MarkLendingItemDirty(lending common.Hash) {
|
|
le.lendingItemStatesDirty[lending] = struct{}{}
|
|
if le.onDirty != nil {
|
|
le.onDirty(le.Hash())
|
|
le.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 (le *lendingExchangeState) MarkLiquidationTimeDirty(orderId common.Hash) {
|
|
le.liquidationTimestatesDirty[orderId] = struct{}{}
|
|
if le.onDirty != nil {
|
|
le.onDirty(le.Hash())
|
|
le.onDirty = nil
|
|
}
|
|
}
|
|
|
|
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))
|
|
}
|
|
le.setError(le.getBorrowingTrie(db).TryUpdate(price[:], data))
|
|
if le.onDirty != nil {
|
|
le.onDirty(le.Hash())
|
|
le.onDirty = nil
|
|
}
|
|
return newobj
|
|
}
|
|
|
|
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))
|
|
le.lendingItemStates[orderIdHash] = newobj
|
|
le.lendingItemStatesDirty[orderIdHash] = struct{}{}
|
|
if le.onDirty != nil {
|
|
le.onDirty(le.lendingBook)
|
|
le.onDirty = nil
|
|
}
|
|
return newobj
|
|
}
|
|
|
|
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))
|
|
}
|
|
le.setError(le.getLiquidationTimeTrie(db).TryUpdate(time[:], data))
|
|
if le.onDirty != nil {
|
|
le.onDirty(le.lendingBook)
|
|
le.onDirty = nil
|
|
}
|
|
return newobj
|
|
}
|
|
|
|
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
|
|
}
|