lendingitem.go

package lendingstate

import (
	"fmt"
	"math/big"
	"strconv"
	"time"

	"github.com/XinFinOrg/XDPoSChain/common"
	"github.com/XinFinOrg/XDPoSChain/core/state"
	"github.com/XinFinOrg/XDPoSChain/core/types"
	"github.com/XinFinOrg/XDPoSChain/crypto/sha3"
	"github.com/globalsign/mgo/bson"
)

const (
	Investing                  = "INVEST"
	Borrowing                  = "BORROW"
	TopUp                      = "TOPUP"
	Repay                      = "REPAY"
	Recall                     = "RECALL"
	LendingStatusNew           = "NEW"
	LendingStatusOpen          = "OPEN"
	LendingStatusReject        = "REJECTED"
	LendingStatusFilled        = "FILLED"
	LendingStatusPartialFilled = "PARTIAL_FILLED"
	LendingStatusCancelled     = "CANCELLED"
	Market                     = "MO"
	Limit                      = "LO"
	/*
		Based on all structs that were used to encode into extraData, we can see the liquidationData is likely be the one with max length in payload.
		A assumptions was made that each numeric value (RecallAmount, LiquidationAmount, CollateralPrice) is up to 30 digits long and the Reason field is 20 characters long, the estimated maximum size of the ExtraData JSON string in the ProcessLiquidationData function would be approximately 185 bytes.
		Hence the value of 200 has been chosen to safeguard the block/tx in XDC in terms of sizes.

	*/
	MaxLendingExtraDataSize = 200
)

var ValidInputLendingStatus = map[string]bool{
	LendingStatusNew:       true,
	LendingStatusCancelled: true,
}

var ValidInputLendingType = map[string]bool{
	Market: true,
	Limit:  true,
	Repay:  true,
	TopUp:  true,
	Recall: true,
}

// Signature struct
type Signature struct {
	V byte        `bson:"v" json:"v"`
	R common.Hash `bson:"r" json:"r"`
	S common.Hash `bson:"s" json:"s"`
}

type SignatureRecord struct {
	V byte   `bson:"v" json:"v"`
	R string `bson:"r" json:"r"`
	S string `bson:"s" json:"s"`
}

type LendingItem struct {
	Quantity        *big.Int       `bson:"quantity" json:"quantity"`
	Interest        *big.Int       `bson:"interest" json:"interest"`
	Side            string         `bson:"side" json:"side"` // INVESTING/BORROWING
	Type            string         `bson:"type" json:"type"` // LIMIT/MARKET
	LendingToken    common.Address `bson:"lendingToken" json:"lendingToken"`
	CollateralToken common.Address `bson:"collateralToken" json:"collateralToken"`
	AutoTopUp       bool           `bson:"autoTopUp" json:"autoTopUp"`
	FilledAmount    *big.Int       `bson:"filledAmount" json:"filledAmount"`
	Status          string         `bson:"status" json:"status"`
	Relayer         common.Address `bson:"relayer" json:"relayer"`
	Term            uint64         `bson:"term" json:"term"`
	UserAddress     common.Address `bson:"userAddress" json:"userAddress"`
	Signature       *Signature     `bson:"signature" json:"signature"`
	Hash            common.Hash    `bson:"hash" json:"hash"`
	TxHash          common.Hash    `bson:"txHash" json:"txHash"`
	Nonce           *big.Int       `bson:"nonce" json:"nonce"`
	CreatedAt       time.Time      `bson:"createdAt" json:"createdAt"`
	UpdatedAt       time.Time      `bson:"updatedAt" json:"updatedAt"`
	LendingId       uint64         `bson:"lendingId" json:"lendingId"`
	LendingTradeId  uint64         `bson:"tradeId" json:"tradeId"`
	ExtraData       string         `bson:"extraData" json:"extraData"`
}

type LendingItemBSON struct {
	Quantity        string           `bson:"quantity" json:"quantity"`
	Interest        string           `bson:"interest" json:"interest"`
	Side            string           `bson:"side" json:"side"` // INVESTING/BORROWING
	Type            string           `bson:"type" json:"type"` // LIMIT/MARKET
	LendingToken    string           `bson:"lendingToken" json:"lendingToken"`
	CollateralToken string           `bson:"collateralToken" json:"collateralToken"`
	AutoTopUp       bool             `bson:"autoTopUp" json:"autoTopUp"`
	FilledAmount    string           `bson:"filledAmount" json:"filledAmount"`
	Status          string           `bson:"status" json:"status"`
	Relayer         string           `bson:"relayer" json:"relayer"`
	Term            string           `bson:"term" json:"term"`
	UserAddress     string           `bson:"userAddress" json:"userAddress"`
	Signature       *SignatureRecord `bson:"signature" json:"signature"`
	Hash            string           `bson:"hash" json:"hash"`
	TxHash          string           `bson:"txHash" json:"txHash"`
	Nonce           string           `bson:"nonce" json:"nonce"`
	CreatedAt       time.Time        `bson:"createdAt" json:"createdAt"`
	UpdatedAt       time.Time        `bson:"updatedAt" json:"updatedAt"`
	LendingId       string           `bson:"lendingId" json:"lendingId"`
	LendingTradeId  string           `bson:"tradeId" json:"tradeId"`
	ExtraData       string           `bson:"extraData" json:"extraData"`
}

func (l *LendingItem) GetBSON() (interface{}, error) {
	lr := LendingItemBSON{
		Quantity:        l.Quantity.String(),
		Interest:        l.Interest.String(),
		Side:            l.Side,
		Type:            l.Type,
		LendingToken:    l.LendingToken.Hex(),
		CollateralToken: l.CollateralToken.Hex(),
		AutoTopUp:       l.AutoTopUp,
		Status:          l.Status,
		Relayer:         l.Relayer.Hex(),
		Term:            strconv.FormatUint(l.Term, 10),
		UserAddress:     l.UserAddress.Hex(),
		Hash:            l.Hash.Hex(),
		TxHash:          l.TxHash.Hex(),
		Nonce:           l.Nonce.String(),
		CreatedAt:       l.CreatedAt,
		UpdatedAt:       l.UpdatedAt,
		LendingId:       strconv.FormatUint(l.LendingId, 10),
		LendingTradeId:  strconv.FormatUint(l.LendingTradeId, 10),
		ExtraData:       l.ExtraData,
	}

	if l.FilledAmount != nil {
		lr.FilledAmount = l.FilledAmount.String()
	}

	if l.Signature != nil {
		lr.Signature = &SignatureRecord{
			V: l.Signature.V,
			R: l.Signature.R.Hex(),
			S: l.Signature.S.Hex(),
		}
	}

	return lr, nil
}

func (l *LendingItem) SetBSON(raw bson.Raw) error {
	decoded := new(LendingItemBSON)

	err := raw.Unmarshal(decoded)
	if err != nil {
		return err
	}
	if decoded.Quantity != "" {
		l.Quantity = ToBigInt(decoded.Quantity)
	}
	l.Interest = ToBigInt(decoded.Interest)
	l.Side = decoded.Side
	l.Type = decoded.Type
	l.LendingToken = common.HexToAddress(decoded.LendingToken)
	l.CollateralToken = common.HexToAddress(decoded.CollateralToken)
	l.AutoTopUp = decoded.AutoTopUp
	l.FilledAmount = ToBigInt(decoded.FilledAmount)
	l.Status = decoded.Status
	l.Relayer = common.HexToAddress(decoded.Relayer)
	term, err := strconv.ParseInt(decoded.Term, 10, 64)
	if err != nil {
		return fmt.Errorf("failed to parse lendingItem.term. Err: %v", err)
	}
	l.Term = uint64(term)
	l.UserAddress = common.HexToAddress(decoded.UserAddress)

	if decoded.Signature != nil {
		l.Signature = &Signature{
			V: byte(decoded.Signature.V),
			R: common.HexToHash(decoded.Signature.R),
			S: common.HexToHash(decoded.Signature.S),
		}
	}

	l.Hash = common.HexToHash(decoded.Hash)
	l.TxHash = common.HexToHash(decoded.TxHash)
	l.Nonce = ToBigInt(decoded.Nonce)

	l.CreatedAt = decoded.CreatedAt
	l.UpdatedAt = decoded.UpdatedAt
	lendingId, err := strconv.ParseInt(decoded.LendingId, 10, 64)
	if err != nil {
		return err
	}
	l.LendingId = uint64(lendingId)
	lendingTradeId, err := strconv.ParseInt(decoded.LendingTradeId, 10, 64)
	if err != nil {
		return err
	}
	l.LendingTradeId = uint64(lendingTradeId)
	l.ExtraData = decoded.ExtraData
	return nil
}

func (l *LendingItem) VerifyLendingItem(state *state.StateDB) error {
	if err := l.VerifyLendingStatus(); err != nil {
		return err
	}
	if valid, _ := IsValidPair(state, l.Relayer, l.LendingToken, l.Term); valid == false {
		return fmt.Errorf("invalid pair . LendToken %s . Term: %v", l.LendingToken.Hex(), l.Term)
	}
	if l.Status == LendingStatusNew {
		if err := l.VerifyLendingType(); err != nil {
			return err
		}
		if l.Type != Repay {
			if err := l.VerifyLendingQuantity(); err != nil {
				return err
			}
		}
		if l.Type == Limit || l.Type == Market {
			if err := l.VerifyLendingSide(); err != nil {
				return err
			}
			if l.Side == Borrowing {
				if err := l.VerifyCollateral(state); err != nil {
					return err
				}
			}
		}
		if l.Type == Limit {
			if err := l.VerifyLendingInterest(); err != nil {
				return err
			}
		}
	}
	if !IsValidRelayer(state, l.Relayer) {
		return fmt.Errorf("VerifyLendingItem: invalid relayer. address: %s", l.Relayer.Hex())
	}
	if err := l.VerifyLendingSignature(); err != nil {
		return err
	}
	if err := l.VerifyLendingExtraData(); err != nil {
		return err
	}
	return nil
}

func (l *LendingItem) VerifyLendingSide() error {
	if l.Side != Borrowing && l.Side != Investing {
		return fmt.Errorf("VerifyLendingSide: invalid side . Side: %s", l.Side)
	}
	return nil
}

func (l *LendingItem) VerifyCollateral(state *state.StateDB) error {
	if l.CollateralToken.IsZero() || l.CollateralToken == l.LendingToken {
		return fmt.Errorf("invalid collateral %s", l.CollateralToken.Hex())
	}
	validCollateral := false
	collateralList := GetCollaterals(state, l.Relayer, l.LendingToken, l.Term)
	for _, collateral := range collateralList {
		if l.CollateralToken.String() == collateral.String() {
			validCollateral = true
			break
		}
	}
	if !validCollateral {
		return fmt.Errorf("invalid collateral %s", l.CollateralToken.Hex())
	}
	return nil
}

func (l *LendingItem) VerifyLendingInterest() error {
	if l.Interest == nil || l.Interest.Sign() <= 0 {
		return fmt.Errorf("VerifyLendingInterest: invalid interest. Interest: %v", l.Interest)
	}
	return nil
}

func (l *LendingItem) VerifyLendingQuantity() error {
	if l.Quantity == nil || l.Quantity.Sign() <= 0 {
		return fmt.Errorf("VerifyLendingQuantity: invalid quantity. Quantity: %v", l.Quantity)
	}
	return nil
}

func (l *LendingItem) VerifyLendingType() error {
	if valid, ok := ValidInputLendingType[l.Type]; !ok && !valid {
		return fmt.Errorf("VerifyLendingType: invalid lending type. Type: %s", l.Type)
	}
	return nil
}

func (l *LendingItem) VerifyLendingExtraData() error {
	if len(l.ExtraData) > MaxLendingExtraDataSize {
		return fmt.Errorf("VerifyLendingExtraData: invalid lending extraData size. Size: %v", len(l.ExtraData))
	}
	return nil
}

func (l *LendingItem) VerifyLendingStatus() error {
	if valid, ok := ValidInputLendingStatus[l.Status]; !ok && !valid {
		return fmt.Errorf("VerifyLendingStatus: invalid lending status. Status: %s", l.Status)
	}
	return nil
}

func (l *LendingItem) ComputeHash() common.Hash {
	sha := sha3.NewKeccak256()
	if l.Status == LendingStatusNew {
		sha.Write(l.Relayer.Bytes())
		sha.Write(l.UserAddress.Bytes())
		sha.Write(l.LendingToken.Bytes())
		sha.Write(l.CollateralToken.Bytes())
		sha.Write([]byte(strconv.FormatInt(int64(l.Term), 10)))
		sha.Write(common.BigToHash(l.Quantity).Bytes())
		if l.Type == Limit {
			if l.Interest != nil {
				sha.Write(common.BigToHash(l.Interest).Bytes())
			}
		}
		sha.Write(common.BigToHash(l.EncodedSide()).Bytes())
		sha.Write([]byte(l.Status))
		sha.Write([]byte(l.Type))
		sha.Write(common.BigToHash(l.Nonce).Bytes())
	} else if l.Status == LendingStatusCancelled {
		sha.Write(l.Hash.Bytes())
		sha.Write(common.BigToHash(l.Nonce).Bytes())
		sha.Write(l.UserAddress.Bytes())
		sha.Write(common.BigToHash(big.NewInt(int64(l.LendingId))).Bytes())
		sha.Write([]byte(l.Status))
		sha.Write(l.Relayer.Bytes())
		sha.Write(l.LendingToken.Bytes())
		sha.Write(l.CollateralToken.Bytes())
	} else {
		return common.Hash{}
	}

	return common.BytesToHash(sha.Sum(nil))
}

func (l *LendingItem) EncodedSide() *big.Int {
	if l.Side == Borrowing {
		return big.NewInt(0)
	}
	return big.NewInt(1)
}

// verify signatures
func (l *LendingItem) VerifyLendingSignature() error {
	V := big.NewInt(int64(l.Signature.V))
	R := l.Signature.R.Big()
	S := l.Signature.S.Big()

	//(nonce uint64, quantity *big.Int, interest, duration uint64, relayerAddress, userAddress, lendingToken, collateralToken common.Address, status, side, typeLending string, hash common.Hash, id uint64
	tx := types.NewLendingTransaction(l.Nonce.Uint64(), l.Quantity, l.Interest.Uint64(), l.Term, l.Relayer, l.UserAddress,
		l.LendingToken, l.CollateralToken, l.AutoTopUp, l.Status, l.Side, l.Type, l.Hash, l.LendingId, l.LendingTradeId, l.ExtraData)
	tx.ImportSignature(V, R, S)
	from, _ := types.LendingSender(types.LendingTxSigner{}, tx)
	if from != tx.UserAddress() {
		return fmt.Errorf("verify lending item: invalid signature")
	}
	return nil
}

func VerifyBalance(isXDCXLendingFork bool, statedb *state.StateDB, lendingStateDb *LendingStateDB,
	orderType, side, status string, userAddress, relayer, lendingToken, collateralToken common.Address,
	quantity, lendingTokenDecimal, collateralTokenDecimal, lendTokenXDCPrice, collateralPrice *big.Int,
	term uint64, lendingId uint64, lendingTradeId uint64) error {
	borrowingFeeRate := GetFee(statedb, relayer)
	switch orderType {
	case TopUp:
		lendingBook := GetLendingOrderBookHash(lendingToken, term)
		lendingTrade := lendingStateDb.GetLendingTrade(lendingBook, common.Uint64ToHash(lendingTradeId))
		if lendingTrade == EmptyLendingTrade {
			return fmt.Errorf("VerifyBalance: process deposit for emptyLendingTrade is not allowed. lendingTradeId: %v", lendingTradeId)
		}
		tokenBalance := GetTokenBalance(lendingTrade.Borrower, lendingTrade.CollateralToken, statedb)
		if tokenBalance.Cmp(quantity) < 0 {
			return fmt.Errorf("VerifyBalance: not enough balance to process deposit for lendingTrade."+
				"lendingTradeId: %v. Token: %s. ExpectedBalance: %s. ActualBalance: %s",
				lendingTradeId, lendingTrade.CollateralToken.Hex(), quantity.String(), tokenBalance.String())
		}
	case Repay:
		lendingBook := GetLendingOrderBookHash(lendingToken, term)
		lendingTrade := lendingStateDb.GetLendingTrade(lendingBook, common.Uint64ToHash(lendingTradeId))
		if lendingTrade == EmptyLendingTrade {
			return fmt.Errorf("VerifyBalance: process payment for emptyLendingTrade is not allowed. lendingTradeId: %v", lendingTradeId)
		}
		tokenBalance := GetTokenBalance(lendingTrade.Borrower, lendingTrade.LendingToken, statedb)
		paymentBalance := CalculateTotalRepayValue(uint64(time.Now().Unix()), lendingTrade.LiquidationTime, lendingTrade.Term, lendingTrade.Interest, lendingTrade.Amount)

		if tokenBalance.Cmp(paymentBalance) < 0 {
			return fmt.Errorf("VerifyBalance: not enough balance to process payment for lendingTrade."+
				"lendingTradeId: %v. Token: %s. ExpectedBalance: %s. ActualBalance: %s",
				lendingTradeId, lendingTrade.LendingToken.Hex(), paymentBalance.String(), tokenBalance.String())

		}
	case Market, Limit:
		switch side {
		case Investing:
			switch status {
			case LendingStatusNew:
				// make sure that investor have enough lendingToken
				if balance := GetTokenBalance(userAddress, lendingToken, statedb); balance.Cmp(quantity) < 0 {
					return fmt.Errorf("VerifyBalance: investor doesn't have enough lendingToken. User: %s. Token: %s. Expected: %v. Have: %v", userAddress.Hex(), lendingToken.Hex(), quantity, balance)
				}
				// check quantity: reject if it's too small
				if lendTokenXDCPrice != nil && lendTokenXDCPrice.Sign() > 0 {
					defaultFee := new(big.Int).Mul(quantity, new(big.Int).SetUint64(DefaultFeeRate))
					defaultFee = new(big.Int).Div(defaultFee, common.XDCXBaseFee)
					defaultFeeInXDC := common.Big0
					if lendingToken.String() != common.XDCNativeAddress {
						defaultFeeInXDC = new(big.Int).Mul(defaultFee, lendTokenXDCPrice)
						defaultFeeInXDC = new(big.Int).Div(defaultFeeInXDC, lendingTokenDecimal)
					} else {
						defaultFeeInXDC = defaultFee
					}
					if defaultFeeInXDC.Cmp(common.RelayerLendingFee) <= 0 {
						return ErrQuantityTradeTooSmall
					}

				}

			case LendingStatusCancelled:
				// in case of cancel, investor need to pay cancel fee in lendingToken
				// make sure actualBalance >= cancel fee
				lendingBook := GetLendingOrderBookHash(lendingToken, term)
				item := lendingStateDb.GetLendingOrder(lendingBook, common.BigToHash(new(big.Int).SetUint64(lendingId)))
				cancelFee := big.NewInt(0)
				cancelFee = new(big.Int).Mul(item.Quantity, borrowingFeeRate)
				cancelFee = new(big.Int).Div(cancelFee, common.XDCXBaseCancelFee)

				actualBalance := GetTokenBalance(userAddress, lendingToken, statedb)
				if actualBalance.Cmp(cancelFee) < 0 {
					return fmt.Errorf("VerifyBalance: investor doesn't have enough lendingToken to pay cancel fee. LendingToken: %s . ExpectedBalance: %s . ActualBalance: %s",
						lendingToken.Hex(), cancelFee.String(), actualBalance.String())
				}
			default:
				return fmt.Errorf("VerifyBalance: invalid status of investing lendingitem. Status: %s", status)
			}
			return nil
		case Borrowing:
			switch status {
			case LendingStatusNew:
				depositRate, _, _ := GetCollateralDetail(statedb, collateralToken)
				settleBalanceResult, err := GetSettleBalance(isXDCXLendingFork, Borrowing, lendTokenXDCPrice, collateralPrice, depositRate, borrowingFeeRate, lendingToken, collateralToken, lendingTokenDecimal, collateralTokenDecimal, quantity)
				if err != nil {
					return err
				}
				expectedBalance := settleBalanceResult.CollateralLockedAmount
				actualBalance := GetTokenBalance(userAddress, collateralToken, statedb)
				if actualBalance.Cmp(expectedBalance) < 0 {
					return fmt.Errorf("VerifyBalance: borrower doesn't have enough collateral token.  User: %s. CollateralToken: %s . ExpectedBalance: %s . ActualBalance: %s",
						userAddress.Hex(), collateralToken.Hex(), expectedBalance.String(), actualBalance.String())
				}
			case LendingStatusCancelled:
				lendingBook := GetLendingOrderBookHash(lendingToken, term)
				item := lendingStateDb.GetLendingOrder(lendingBook, common.BigToHash(new(big.Int).SetUint64(lendingId)))
				cancelFee := big.NewInt(0)
				// Fee ==  quantityToLend/base lend token decimal *price*borrowFee/LendingCancelFee
				cancelFee = new(big.Int).Div(item.Quantity, collateralPrice)
				cancelFee = new(big.Int).Mul(cancelFee, borrowingFeeRate)
				cancelFee = new(big.Int).Div(cancelFee, common.XDCXBaseCancelFee)
				actualBalance := GetTokenBalance(userAddress, collateralToken, statedb)
				if actualBalance.Cmp(cancelFee) < 0 {
					return fmt.Errorf("VerifyBalance: borrower doesn't have enough collateralToken to pay cancel fee. User: %s. CollateralToken: %s . ExpectedBalance: %s . ActualBalance: %s",
						userAddress.Hex(), lendingToken.Hex(), cancelFee.String(), actualBalance.String())
				}
			default:
				return fmt.Errorf("VerifyBalance: invalid status of borrowing lendingitem. Status: %s", status)
			}
			return nil
		default:
			return fmt.Errorf("VerifyBalance: unknown lending side")
		}
	default:
		return fmt.Errorf("VerifyBalance: unknown lending type")
	}
	return nil
}