forks/go-ethereum
1
0
Fork 1
mirror of https://github.com/ethereum/go-ethereum.git synced 2026-07-15 17:30:44 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

common: remove unused variables (#1875)

Browse source
This commit is contained in:
wit liu 2025-12-19 14:39:23 +08:00 committed by GitHub
parent a83c43f240
commit b3d12e4fda
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
5 changed files with 26 additions and 37 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
XDCx/tradingstate/relayer_state.go
View file

@ -162,7 +162,7 @@ func AddTokenBalance(addr common.Address, value *big.Int, token common.Address,
// XDC native // XDC native
if token == common.XDCNativeAddressBinary { if token == common.XDCNativeAddressBinary {
balance := statedb.GetBalance(addr) balance := statedb.GetBalance(addr)
log.Debug("ApplyXDCXMatchedTransaction settle balance: ADD TOKEN XDC NATIVE BEFORE", "token", common.XDCNativeAddress, "address", addr, "balance", balance, "orderValue", value) log.Debug("ApplyXDCXMatchedTransaction settle balance: ADD TOKEN XDC NATIVE BEFORE", "token", common.XDCNativeAddressBinary, "address", addr, "balance", balance, "orderValue", value)
statedb.AddBalance(addr, value, tracing.BalanceChangeUnspecified) statedb.AddBalance(addr, value, tracing.BalanceChangeUnspecified)
balance = statedb.GetBalance(addr) balance = statedb.GetBalance(addr)
log.Debug("ApplyXDCXMatchedTransaction settle balance: ADD XDC NATIVE BALANCE AFTER", "token", token, "address", addr, "balance", balance, "orderValue", value) log.Debug("ApplyXDCXMatchedTransaction settle balance: ADD XDC NATIVE BALANCE AFTER", "token", token, "address", addr, "balance", balance, "orderValue", value)
@ -189,7 +189,7 @@ func SubTokenBalance(addr common.Address, value *big.Int, token common.Address,
// XDC native // XDC native
if token == common.XDCNativeAddressBinary { if token == common.XDCNativeAddressBinary {
balance := statedb.GetBalance(addr) balance := statedb.GetBalance(addr)
log.Debug("ApplyXDCXMatchedTransaction settle balance: SUB XDC NATIVE BALANCE BEFORE", "token", common.XDCNativeAddress, "address", addr, "balance", balance, "orderValue", value) log.Debug("ApplyXDCXMatchedTransaction settle balance: SUB XDC NATIVE BALANCE BEFORE", "token", common.XDCNativeAddressBinary, "address", addr, "balance", balance, "orderValue", value)
if balance.Cmp(value) < 0 { if balance.Cmp(value) < 0 {
return errors.Errorf("value %s in token %s not enough , have : %s , want : %s ", addr.String(), token.String(), balance, value) return errors.Errorf("value %s in token %s not enough , have : %s , want : %s ", addr.String(), token.String(), balance, value)
} }

16
XDCxlending/lendingstate/relayer.go
View file

@ -114,10 +114,10 @@ func AddTokenBalance(addr common.Address, value *big.Int, token common.Address,
// XDC native // XDC native
if token == common.XDCNativeAddressBinary { if token == common.XDCNativeAddressBinary {
balance := statedb.GetBalance(addr) balance := statedb.GetBalance(addr)
log.Debug("ApplyXDCXMatchedTransaction settle balance: ADD TOKEN XDC NATIVE BEFORE", "token", common.XDCNativeAddress, "address", addr, "balance", balance, "orderValue", value) log.Debug("ApplyXDCXMatchedTransaction settle balance: ADD TOKEN XDC NATIVE BEFORE", "token", common.XDCNativeAddressBinary, "address", addr, "balance", balance, "orderValue", value)
statedb.AddBalance(addr, value, tracing.BalanceChangeUnspecified) statedb.AddBalance(addr, value, tracing.BalanceChangeUnspecified)
balance = statedb.GetBalance(addr) balance = statedb.GetBalance(addr)
log.Debug("ApplyXDCXMatchedTransaction settle balance: ADD XDC NATIVE BALANCE AFTER", "token", common.XDCNativeAddress, "address", addr, "balance", balance, "orderValue", value) log.Debug("ApplyXDCXMatchedTransaction settle balance: ADD XDC NATIVE BALANCE AFTER", "token", common.XDCNativeAddressBinary, "address", addr, "balance", balance, "orderValue", value)
return nil return nil
} }
@ -141,13 +141,13 @@ func SubTokenBalance(addr common.Address, value *big.Int, token common.Address,
// XDC native // XDC native
if token == common.XDCNativeAddressBinary { if token == common.XDCNativeAddressBinary {
balance := statedb.GetBalance(addr) balance := statedb.GetBalance(addr)
log.Debug("ApplyXDCXMatchedTransaction settle balance: SUB XDC NATIVE BALANCE BEFORE", "token", common.XDCNativeAddress, "address", addr, "balance", balance, "orderValue", value) log.Debug("ApplyXDCXMatchedTransaction settle balance: SUB XDC NATIVE BALANCE BEFORE", "token", common.XDCNativeAddressBinary, "address", addr, "balance", balance, "orderValue", value)
if balance.Cmp(value) < 0 { if balance.Cmp(value) < 0 {
return errors.Errorf("value %s in token %s not enough , have : %s , want : %s ", addr.String(), common.XDCNativeAddress, balance, value) return errors.Errorf("value %s in token %s not enough , have : %s , want : %s ", addr.String(), common.XDCNativeAddressBinary, balance, value)
} }
statedb.SubBalance(addr, value, tracing.BalanceChangeUnspecified) statedb.SubBalance(addr, value, tracing.BalanceChangeUnspecified)
balance = statedb.GetBalance(addr) balance = statedb.GetBalance(addr)
log.Debug("ApplyXDCXMatchedTransaction settle balance: SUB XDC NATIVE BALANCE AFTER", "token", common.XDCNativeAddress, "address", addr, "balance", balance, "orderValue", value) log.Debug("ApplyXDCXMatchedTransaction settle balance: SUB XDC NATIVE BALANCE AFTER", "token", common.XDCNativeAddressBinary, "address", addr, "balance", balance, "orderValue", value)
return nil return nil
} }
@ -180,10 +180,10 @@ func CheckSubTokenBalance(addr common.Address, value *big.Int, token common.Addr
balance = statedb.GetBalance(addr) balance = statedb.GetBalance(addr)
} }
if balance.Cmp(value) < 0 { if balance.Cmp(value) < 0 {
return nil, errors.Errorf("value %s in token %s not enough , have : %s , want : %s ", addr.String(), common.XDCNativeAddress, balance, value) return nil, errors.Errorf("value %s in token %s not enough , have : %s , want : %s ", addr.String(), common.XDCNativeAddressBinary, balance, value)
} }
newBalance := new(big.Int).Sub(balance, value) newBalance := new(big.Int).Sub(balance, value)
log.Debug("CheckSubTokenBalance settle balance: SUB XDC NATIVE BALANCE ", "token", common.XDCNativeAddress, "address", addr, "balance", balance, "value", value, "newBalance", newBalance) log.Debug("CheckSubTokenBalance settle balance: SUB XDC NATIVE BALANCE ", "token", common.XDCNativeAddressBinary, "address", addr, "balance", balance, "value", value, "newBalance", newBalance)
return newBalance, nil return newBalance, nil
} }
// TRC tokens // TRC tokens
@ -217,7 +217,7 @@ func CheckAddTokenBalance(addr common.Address, value *big.Int, token common.Addr
balance = statedb.GetBalance(addr) balance = statedb.GetBalance(addr)
} }
newBalance := new(big.Int).Add(balance, value) newBalance := new(big.Int).Add(balance, value)
log.Debug("CheckAddTokenBalance settle balance: ADD XDC NATIVE BALANCE ", "token", common.XDCNativeAddress, "address", addr, "balance", balance, "value", value, "newBalance", newBalance) log.Debug("CheckAddTokenBalance settle balance: ADD XDC NATIVE BALANCE ", "token", common.XDCNativeAddressBinary, "address", addr, "balance", balance, "value", value, "newBalance", newBalance)
return newBalance, nil return newBalance, nil
} }
// TRC tokens // TRC tokens

10
XDCxlending/order_processor.go
View file

@ -859,7 +859,7 @@ func (l *Lending) LiquidationExpiredTrade(header *types.Header, chain consensus.
} }
err = lendingstate.SubTokenBalance(common.LendingLockAddressBinary, lendingTrade.CollateralLockedAmount, lendingTrade.CollateralToken, statedb) err = lendingstate.SubTokenBalance(common.LendingLockAddressBinary, lendingTrade.CollateralLockedAmount, lendingTrade.CollateralToken, statedb)
if err != nil { if err != nil {
log.Warn("LiquidationExpiredTrade SubTokenBalance", "err", err, "LendingLockAddress", common.LendingLockAddress, "lendingTrade.CollateralLockedAmount", *lendingTrade.CollateralLockedAmount, "lendingTrade.CollateralToken", lendingTrade.CollateralToken) log.Warn("LiquidationExpiredTrade SubTokenBalance", "err", err, "LendingLockAddress", common.LendingLockAddressBinary, "lendingTrade.CollateralLockedAmount", *lendingTrade.CollateralLockedAmount, "lendingTrade.CollateralToken", lendingTrade.CollateralToken)
} }
err = lendingstate.AddTokenBalance(lendingTrade.Investor, repayAmount, lendingTrade.CollateralToken, statedb) err = lendingstate.AddTokenBalance(lendingTrade.Investor, repayAmount, lendingTrade.CollateralToken, statedb)
if err != nil { if err != nil {
@ -902,7 +902,7 @@ func (l *Lending) LiquidationTrade(lendingStateDB *lendingstate.LendingStateDB,
} }
err := lendingstate.SubTokenBalance(common.LendingLockAddressBinary, lendingTrade.CollateralLockedAmount, lendingTrade.CollateralToken, statedb) err := lendingstate.SubTokenBalance(common.LendingLockAddressBinary, lendingTrade.CollateralLockedAmount, lendingTrade.CollateralToken, statedb)
if err != nil { if err != nil {
log.Warn("LiquidationTrade SubTokenBalance", "err", err, "LendingLockAddress", common.LendingLockAddress, "lendingTrade.CollateralLockedAmount", *lendingTrade.CollateralLockedAmount, "lendingTrade.CollateralToken", lendingTrade.CollateralToken) log.Warn("LiquidationTrade SubTokenBalance", "err", err, "LendingLockAddress", common.LendingLockAddressBinary, "lendingTrade.CollateralLockedAmount", *lendingTrade.CollateralLockedAmount, "lendingTrade.CollateralToken", lendingTrade.CollateralToken)
} }
err = lendingstate.AddTokenBalance(lendingTrade.Investor, lendingTrade.CollateralLockedAmount, lendingTrade.CollateralToken, statedb) err = lendingstate.AddTokenBalance(lendingTrade.Investor, lendingTrade.CollateralLockedAmount, lendingTrade.CollateralToken, statedb)
if err != nil { if err != nil {
@ -1137,7 +1137,7 @@ func (l *Lending) ProcessTopUpLendingTrade(lendingStateDB *lendingstate.LendingS
} }
err = lendingstate.AddTokenBalance(common.LendingLockAddressBinary, quantity, lendingTrade.CollateralToken, statedb) err = lendingstate.AddTokenBalance(common.LendingLockAddressBinary, quantity, lendingTrade.CollateralToken, statedb)
if err != nil { if err != nil {
log.Warn("ProcessTopUpLendingTrade AddTokenBalance", "err", err, "LendingLockAddress", common.LendingLockAddress, "quantity", *quantity, "lendingTrade.CollateralToken", lendingTrade.CollateralToken) log.Warn("ProcessTopUpLendingTrade AddTokenBalance", "err", err, "LendingLockAddress", common.LendingLockAddressBinary, "quantity", *quantity, "lendingTrade.CollateralToken", lendingTrade.CollateralToken)
} }
oldLockedAmount := lendingTrade.CollateralLockedAmount oldLockedAmount := lendingTrade.CollateralLockedAmount
newLockedAmount := new(big.Int).Add(quantity, oldLockedAmount) newLockedAmount := new(big.Int).Add(quantity, oldLockedAmount)
@ -1203,7 +1203,7 @@ func (l *Lending) ProcessRepayLendingTrade(header *types.Header, chain consensus
} }
err = lendingstate.SubTokenBalance(common.LendingLockAddressBinary, lendingTrade.CollateralLockedAmount, lendingTrade.CollateralToken, statedb) err = lendingstate.SubTokenBalance(common.LendingLockAddressBinary, lendingTrade.CollateralLockedAmount, lendingTrade.CollateralToken, statedb)
if err != nil { if err != nil {
log.Warn("ProcessRepayLendingTrade SubTokenBalance", "err", err, "LendingLockAddress", common.LendingLockAddress, "lendingTrade.CollateralLockedAmount", *lendingTrade.CollateralLockedAmount, "lendingTrade.CollateralToken", lendingTrade.CollateralToken) log.Warn("ProcessRepayLendingTrade SubTokenBalance", "err", err, "LendingLockAddress", common.LendingLockAddressBinary, "lendingTrade.CollateralLockedAmount", *lendingTrade.CollateralLockedAmount, "lendingTrade.CollateralToken", lendingTrade.CollateralToken)
} }
err = lendingstate.AddTokenBalance(lendingTrade.Borrower, lendingTrade.CollateralLockedAmount, lendingTrade.CollateralToken, statedb) err = lendingstate.AddTokenBalance(lendingTrade.Borrower, lendingTrade.CollateralLockedAmount, lendingTrade.CollateralToken, statedb)
if err != nil { if err != nil {
@ -1259,7 +1259,7 @@ func (l *Lending) ProcessRecallLendingTrade(lendingStateDB *lendingstate.Lending
} }
err = lendingstate.SubTokenBalance(common.LendingLockAddressBinary, recallAmount, lendingTrade.CollateralToken, statedb) err = lendingstate.SubTokenBalance(common.LendingLockAddressBinary, recallAmount, lendingTrade.CollateralToken, statedb)
if err != nil { if err != nil {
log.Warn("ProcessRecallLendingTrade SubTokenBalance", "err", err, "LendingLockAddress", common.LendingLockAddress, "recallAmount", *recallAmount, "lendingTrade.CollateralToken", lendingTrade.CollateralToken) log.Warn("ProcessRecallLendingTrade SubTokenBalance", "err", err, "LendingLockAddress", common.LendingLockAddressBinary, "recallAmount", *recallAmount, "lendingTrade.CollateralToken", lendingTrade.CollateralToken)
} }
lendingStateDB.UpdateLiquidationPrice(lendingBook, lendingTrade.TradeId, newLiquidationPrice) lendingStateDB.UpdateLiquidationPrice(lendingBook, lendingTrade.TradeId, newLiquidationPrice)

11
common/types.go
View file

@ -33,17 +33,6 @@ import (
const ( const (
HashLength = 32 HashLength = 32
AddressLength = 20 AddressLength = 20
BlockSigners = "xdc0000000000000000000000000000000000000089"
MasternodeVotingSMC = "xdc0000000000000000000000000000000000000088"
RandomizeSMC = "xdc0000000000000000000000000000000000000090"
FoudationAddr = "xdc0000000000000000000000000000000000000068"
TeamAddr = "xdc0000000000000000000000000000000000000099"
XDCXAddr = "xdc0000000000000000000000000000000000000091"
TradingStateAddr = "xdc0000000000000000000000000000000000000092"
XDCXLendingAddress = "xdc0000000000000000000000000000000000000093"
XDCXLendingFinalizedTradeAddress = "xdc0000000000000000000000000000000000000094"
XDCNativeAddress = "xdc0000000000000000000000000000000000000001"
LendingLockAddress = "xdc0000000000000000000000000000000000000011"
VoteMethod = "0x6dd7d8ea" VoteMethod = "0x6dd7d8ea"
UnvoteMethod = "0x02aa9be2" UnvoteMethod = "0x02aa9be2"
ProposeMethod = "0x01267951" ProposeMethod = "0x01267951"

22
common/types_test.go
View file

@ -340,17 +340,17 @@ var testCases = []struct {
bin Address bin Address
str string str string
}{ }{
{BlockSignersBinary, BlockSigners}, {BlockSignersBinary, "xdc0000000000000000000000000000000000000089"},
{MasternodeVotingSMCBinary, MasternodeVotingSMC}, {MasternodeVotingSMCBinary, "xdc0000000000000000000000000000000000000088"},
{RandomizeSMCBinary, RandomizeSMC}, {RandomizeSMCBinary, "xdc0000000000000000000000000000000000000090"},
{FoudationAddrBinary, FoudationAddr}, {FoudationAddrBinary, "xdc0000000000000000000000000000000000000068"},
{TeamAddrBinary, TeamAddr}, {TeamAddrBinary, "xdc0000000000000000000000000000000000000099"},
{XDCXAddrBinary, XDCXAddr}, {XDCXAddrBinary, "xdc0000000000000000000000000000000000000091"},
{TradingStateAddrBinary, TradingStateAddr}, {TradingStateAddrBinary, "xdc0000000000000000000000000000000000000092"},
{XDCXLendingAddressBinary, XDCXLendingAddress}, {XDCXLendingAddressBinary, "xdc0000000000000000000000000000000000000093"},
{XDCXLendingFinalizedTradeAddressBinary, XDCXLendingFinalizedTradeAddress}, {XDCXLendingFinalizedTradeAddressBinary, "xdc0000000000000000000000000000000000000094"},
{XDCNativeAddressBinary, XDCNativeAddress}, {XDCNativeAddressBinary, "xdc0000000000000000000000000000000000000001"},
{LendingLockAddressBinary, LendingLockAddress}, {LendingLockAddressBinary, "xdc0000000000000000000000000000000000000011"},
} }
func TestBinaryAddressToString(t *testing.T) { func TestBinaryAddressToString(t *testing.T) {