From f6bf40dab6df055495ba13a0bd82a397f7ccda2b Mon Sep 17 00:00:00 2001 From: TimmyExogenous Date: Sun, 10 Nov 2024 22:50:06 +0800 Subject: [PATCH] 1. use `ZeroInt` and `LegacyZeroDec` to replace `NewInt(0)` and `LegacyNewDec(0)` 2. refine the command format and description of voting power snapshot --- app/ante/cosmos/min_price_test.go | 4 +- app/ante/evm/fees_test.go | 2 +- precompiles/assets/tx.go | 2 +- precompiles/avs/avs_test.go | 2 +- precompiles/avs/query_test.go | 10 +-- precompiles/avs/utils_test.go | 4 +- proto/exocore/operator/v1/tx.proto | 7 +- types/int.go | 2 +- x/avs/keeper/avs.go | 2 +- x/avs/keeper/impl_epoch_hook.go | 2 +- x/avs/keeper/submit_task_test.go | 2 +- x/avs/keeper/task_test.go | 2 +- x/delegation/keeper/delegation_op_test.go | 68 +++++++++---------- x/delegation/keeper/delegation_state.go | 8 +-- x/delegation/keeper/share.go | 6 +- x/delegation/keeper/share_test.go | 56 +++++++-------- .../update_native_restaking_balance_test.go | 4 +- x/delegation/types/expected_keepers.go | 2 +- x/exomint/keeper/impl_epochs_hooks_test.go | 2 +- x/exomint/types/params_test.go | 6 +- x/operator/client/cli/query.go | 25 ++++--- x/operator/keeper/abci.go | 8 +-- x/operator/keeper/operator_slash_state.go | 4 +- x/operator/keeper/opt_test.go | 4 +- x/operator/keeper/slash.go | 12 ++-- x/operator/keeper/slash_test.go | 2 +- x/operator/keeper/usd_value.go | 34 +++++----- x/operator/keeper/usd_value_test.go | 4 +- x/operator/types/genesis.go | 6 +- x/oracle/keeper/native_token.go | 2 +- x/reward/keeper/claim_reward_test.go | 2 +- x/slash/keeper/execute_slash_test.go | 4 +- 32 files changed, 154 insertions(+), 146 deletions(-) diff --git a/app/ante/cosmos/min_price_test.go b/app/ante/cosmos/min_price_test.go index 500596d66..438861f96 100644 --- a/app/ante/cosmos/min_price_test.go +++ b/app/ante/cosmos/min_price_test.go @@ -51,7 +51,7 @@ func (suite *AnteTestSuite) TestMinGasPriceDecorator() { err := suite.app.FeeMarketKeeper.SetParams(suite.ctx, params) suite.Require().NoError(err) - txBuilder := suite.CreateTestCosmosTxBuilder(sdkmath.NewInt(0), denom, &testMsg) + txBuilder := suite.CreateTestCosmosTxBuilder(sdkmath.ZeroInt(), denom, &testMsg) return txBuilder.GetTx() }, true, @@ -96,7 +96,7 @@ func (suite *AnteTestSuite) TestMinGasPriceDecorator() { err := suite.app.FeeMarketKeeper.SetParams(suite.ctx, params) suite.Require().NoError(err) - txBuilder := suite.CreateTestCosmosTxBuilder(sdkmath.NewInt(0), denom, &testMsg) + txBuilder := suite.CreateTestCosmosTxBuilder(sdkmath.ZeroInt(), denom, &testMsg) return txBuilder.GetTx() }, false, diff --git a/app/ante/evm/fees_test.go b/app/ante/evm/fees_test.go index 540f9a13c..cf998e47f 100644 --- a/app/ante/evm/fees_test.go +++ b/app/ante/evm/fees_test.go @@ -60,7 +60,7 @@ func (suite *AnteTestSuite) TestEthMinGasPriceDecorator() { ToAddress: "evmos1dx67l23hz9l0k9hcher8xz04uj7wf3yu26l2yn", Amount: sdk.Coins{sdk.Coin{Amount: sdkmath.NewInt(10), Denom: denom}}, } - txBuilder := suite.CreateTestCosmosTxBuilder(sdkmath.NewInt(0), denom, &testMsg) + txBuilder := suite.CreateTestCosmosTxBuilder(sdkmath.ZeroInt(), denom, &testMsg) return txBuilder.GetTx() }, false, diff --git a/precompiles/assets/tx.go b/precompiles/assets/tx.go index 622577837..d86075636 100644 --- a/precompiles/assets/tx.go +++ b/precompiles/assets/tx.go @@ -156,7 +156,7 @@ func (p Precompile) RegisterToken( stakingAsset := &assetstypes.StakingAssetInfo{ AssetBasicInfo: asset, - StakingTotalAmount: sdkmath.NewInt(0), + StakingTotalAmount: sdkmath.ZeroInt(), } if err := p.assetsKeeper.RegisterNewTokenAndSetTokenFeeder(ctx, &oInfo); err != nil { diff --git a/precompiles/avs/avs_test.go b/precompiles/avs/avs_test.go index e3b8cd227..939315d19 100644 --- a/precompiles/avs/avs_test.go +++ b/precompiles/avs/avs_test.go @@ -835,7 +835,7 @@ func (suite *AVSManagerPrecompileSuite) TestRunRegTaskInfo() { suite.Ctx, &assetstypes.StakingAssetInfo{ AssetBasicInfo: usdcClientChainAsset, - StakingTotalAmount: sdkmath.NewInt(0), + StakingTotalAmount: sdkmath.ZeroInt(), }, ) suite.NoError(err) diff --git a/precompiles/avs/query_test.go b/precompiles/avs/query_test.go index 8041aef3c..b712b0831 100644 --- a/precompiles/avs/query_test.go +++ b/precompiles/avs/query_test.go @@ -145,7 +145,7 @@ func (suite *AVSManagerPrecompileSuite) TestGetOptedInOperatorAccAddrs() { func (suite *AVSManagerPrecompileSuite) TestAVSUSDValue() { method := s.precompile.Methods[avsManagerPrecompile.MethodGetAVSUSDValue] - expectedUSDvalue := sdkmath.LegacyNewDec(0) + expectedUSDvalue := sdkmath.LegacyZeroDec() setUp := func() { suite.prepare() @@ -163,7 +163,7 @@ func (suite *AVSManagerPrecompileSuite) TestAVSUSDValue() { suite.Ctx, &assetstype.StakingAssetInfo{ AssetBasicInfo: usdcClientChainAsset, - StakingTotalAmount: sdkmath.NewInt(0), + StakingTotalAmount: sdkmath.ZeroInt(), }, ) suite.NoError(err) @@ -233,7 +233,7 @@ func (suite *AVSManagerPrecompileSuite) TestAVSUSDValue() { func (suite *AVSManagerPrecompileSuite) TestGetOperatorOptedUSDValue() { method := s.precompile.Methods[avsManagerPrecompile.MethodGetOperatorOptedUSDValue] - expectedUSDvalue := sdkmath.LegacyNewDec(0) + expectedUSDvalue := sdkmath.LegacyZeroDec() setUp := func() { suite.prepare() @@ -251,7 +251,7 @@ func (suite *AVSManagerPrecompileSuite) TestGetOperatorOptedUSDValue() { suite.Ctx, &assetstype.StakingAssetInfo{ AssetBasicInfo: usdcClientChainAsset, - StakingTotalAmount: sdkmath.NewInt(0), + StakingTotalAmount: sdkmath.ZeroInt(), }, ) suite.NoError(err) @@ -509,7 +509,7 @@ func (suite *AVSManagerPrecompileSuite) TestGetTaskInfo() { TaskResponsePeriod: 10, StartingEpoch: 5, TaskStatisticalPeriod: 60, - TaskTotalPower: sdk.Dec(sdkmath.NewInt(0)), + TaskTotalPower: sdk.Dec(sdkmath.ZeroInt()), } err := suite.App.AVSManagerKeeper.SetTaskInfo(suite.Ctx, info) suite.NoError(err) diff --git a/precompiles/avs/utils_test.go b/precompiles/avs/utils_test.go index 5f52298d8..161316d81 100644 --- a/precompiles/avs/utils_test.go +++ b/precompiles/avs/utils_test.go @@ -202,8 +202,8 @@ func (suite *AVSManagerPrecompileSuite) TestOptOut() { OptedInHeight: uint64(optInHeight), OptedOutHeight: uint64(suite.Ctx.BlockHeight()), }, - AVSTotalShare: sdkmath.LegacyNewDec(0), - AVSOperatorShare: sdkmath.LegacyNewDec(0), + AVSTotalShare: sdkmath.LegacyZeroDec(), + AVSOperatorShare: sdkmath.LegacyZeroDec(), AssetState: nil, OperatorShare: sdkmath.LegacyDec{}, StakerShare: sdkmath.LegacyDec{}, diff --git a/proto/exocore/operator/v1/tx.proto b/proto/exocore/operator/v1/tx.proto index ef444aff8..dfdf83a1a 100644 --- a/proto/exocore/operator/v1/tx.proto +++ b/proto/exocore/operator/v1/tx.proto @@ -65,7 +65,10 @@ message OperatorVotingPower { ]; } -// VotingPowerSnapshot is used to record the historical voting power for AVSs +// VotingPowerSnapshot records historical voting power for AVSs at specific epochs +// or after slashing events.These snapshots are created at the end of each epoch and +// when slashing occurs, enabling historical queries of operator voting power at +// specific points in time. message VotingPowerSnapshot { // total_voting_power is the total voting power of specified AVS string total_voting_power = 1 @@ -78,7 +81,7 @@ message VotingPowerSnapshot { // for the specified AVS repeated OperatorVotingPower operator_voting_powers = 2; // last_changed_height is used to indicate the height of most recent change when - // the voting_power_set is nil, which can help to fall back to the correct epoch height. + // the operator_voting_powers is nil, which can help to fall back to the correct epoch height. int64 last_changed_height = 3; // epoch_identifier record the epoch info string epoch_identifier = 4; diff --git a/types/int.go b/types/int.go index 4a736d3ef..1b1f78b0c 100644 --- a/types/int.go +++ b/types/int.go @@ -24,7 +24,7 @@ func SafeInt64(value uint64) (int64, error) { // SafeNewIntFromBigInt constructs Int from big.Int, return error if more than 256bits func SafeNewIntFromBigInt(i *big.Int) (sdkmath.Int, error) { if !IsValidInt256(i) { - return sdkmath.NewInt(0), fmt.Errorf("big int out of bound: %s", i) + return sdkmath.ZeroInt(), fmt.Errorf("big int out of bound: %s", i) } return sdkmath.NewIntFromBigInt(i), nil } diff --git a/x/avs/keeper/avs.go b/x/avs/keeper/avs.go index 9730521a7..4862b9af3 100644 --- a/x/avs/keeper/avs.go +++ b/x/avs/keeper/avs.go @@ -58,7 +58,7 @@ func (k *Keeper) GetAVSSlashContract(ctx sdk.Context, avsAddr string) (string, e func (k *Keeper) GetAVSMinimumSelfDelegation(ctx sdk.Context, avsAddr string) (sdkmath.LegacyDec, error) { avsInfo, err := k.GetAVSInfo(ctx, avsAddr) if err != nil { - return sdkmath.LegacyNewDec(0), errorsmod.Wrap(err, fmt.Sprintf("GetAVSMinimumSelfDelegation: key is %s", avsAddr)) + return sdkmath.LegacyZeroDec(), errorsmod.Wrap(err, fmt.Sprintf("GetAVSMinimumSelfDelegation: key is %s", avsAddr)) } // #nosec G115 return sdkmath.LegacyNewDec(int64(avsInfo.Info.MinSelfDelegation)), nil diff --git a/x/avs/keeper/impl_epoch_hook.go b/x/avs/keeper/impl_epoch_hook.go index 73d619b86..986d2d4f7 100644 --- a/x/avs/keeper/impl_epoch_hook.go +++ b/x/avs/keeper/impl_epoch_hook.go @@ -41,7 +41,7 @@ func (wrapper EpochsHooksWrapper) AfterEpochEnd( var taskAddr string var avsAddr string var operatorPowers []*types.OperatorActivePowerInfo - operatorPowerTotal := sdkmath.LegacyNewDec(0) + operatorPowerTotal := sdkmath.LegacyZeroDec() for _, res := range value { // Find signed operators if res.BlsSignature != nil { diff --git a/x/avs/keeper/submit_task_test.go b/x/avs/keeper/submit_task_test.go index 7abda46b9..bdcb3550e 100644 --- a/x/avs/keeper/submit_task_test.go +++ b/x/avs/keeper/submit_task_test.go @@ -138,7 +138,7 @@ func (suite *AVSTestSuite) prepareTaskInfo() { StartingEpoch: uint64(epoch.CurrentEpoch + 1), ActualThreshold: 0, OptInOperators: operatorList, - TaskTotalPower: sdk.Dec(sdkmath.NewInt(0)), + TaskTotalPower: sdk.Dec(sdkmath.ZeroInt()), } err = suite.App.AVSManagerKeeper.SetTaskInfo(suite.Ctx, info) suite.NoError(err) diff --git a/x/avs/keeper/task_test.go b/x/avs/keeper/task_test.go index 5d6216a8f..018972648 100644 --- a/x/avs/keeper/task_test.go +++ b/x/avs/keeper/task_test.go @@ -18,7 +18,7 @@ func (suite *AVSTestSuite) TestTaskInfo() { TaskResponsePeriod: 10000, TaskChallengePeriod: 5000, ThresholdPercentage: 60, - TaskTotalPower: sdk.Dec(sdkmath.NewInt(0)), + TaskTotalPower: sdk.Dec(sdkmath.ZeroInt()), } err := suite.App.AVSManagerKeeper.SetTaskInfo(suite.Ctx, info) suite.NoError(err) diff --git a/x/delegation/keeper/delegation_op_test.go b/x/delegation/keeper/delegation_op_test.go index c0f94cc31..c8ab2befd 100644 --- a/x/delegation/keeper/delegation_op_test.go +++ b/x/delegation/keeper/delegation_op_test.go @@ -119,23 +119,23 @@ func (suite *DelegationTestSuite) TestDelegateTo() { suite.Equal(types.StakerAssetInfo{ TotalDepositAmount: suite.depositAmount, WithdrawableAmount: suite.depositAmount.Sub(delegationParams.OpAmount), - PendingUndelegationAmount: sdkmath.NewInt(0), + PendingUndelegationAmount: sdkmath.ZeroInt(), }, *restakerState) operatorState, err := suite.App.AssetsKeeper.GetOperatorSpecifiedAssetInfo(suite.Ctx, opAccAddr, assetID) suite.NoError(err) suite.Equal(types.OperatorAssetInfo{ TotalAmount: delegationParams.OpAmount, - PendingUndelegationAmount: sdkmath.NewInt(0), + PendingUndelegationAmount: sdkmath.ZeroInt(), TotalShare: sdkmath.LegacyNewDecFromBigInt(delegationParams.OpAmount.BigInt()), - OperatorShare: sdkmath.LegacyNewDec(0), + OperatorShare: sdkmath.LegacyZeroDec(), }, *operatorState) specifiedDelegationAmount, err := suite.App.DelegationKeeper.GetSingleDelegationInfo(suite.Ctx, stakerID, assetID, opAccAddr.String()) suite.NoError(err) suite.Equal(delegationtype.DelegationAmounts{ UndelegatableShare: sdkmath.LegacyNewDecFromBigInt(delegationParams.OpAmount.BigInt()), - WaitUndelegationAmount: sdkmath.NewInt(0), + WaitUndelegationAmount: sdkmath.ZeroInt(), }, *specifiedDelegationAmount) totalDelegationAmount, err := suite.App.DelegationKeeper.TotalDelegatedAmountForStakerAsset(suite.Ctx, stakerID, assetID) @@ -163,22 +163,22 @@ func (suite *DelegationTestSuite) TestDelegateTo() { suite.Equal(types.StakerAssetInfo{ TotalDepositAmount: balance.Amount.Add(delegationParams.OpAmount), WithdrawableAmount: balance.Amount, - PendingUndelegationAmount: sdkmath.NewInt(0), + PendingUndelegationAmount: sdkmath.ZeroInt(), }, *restakerState) operatorState, err = suite.App.AssetsKeeper.GetOperatorSpecifiedAssetInfo(suite.Ctx, opAccAddr, assetID) suite.NoError(err) suite.Equal(types.OperatorAssetInfo{ TotalAmount: delegationParams.OpAmount, - PendingUndelegationAmount: sdkmath.NewInt(0), + PendingUndelegationAmount: sdkmath.ZeroInt(), TotalShare: sdkmath.LegacyNewDecFromBigInt(delegationParams.OpAmount.BigInt()), - OperatorShare: sdkmath.LegacyNewDec(0), + OperatorShare: sdkmath.LegacyZeroDec(), }, *operatorState) specifiedDelegationAmount, err = suite.App.DelegationKeeper.GetSingleDelegationInfo(suite.Ctx, stakerID, assetID, opAccAddr.String()) suite.NoError(err) suite.Equal(delegationtype.DelegationAmounts{ UndelegatableShare: sdkmath.LegacyNewDecFromBigInt(delegationParams.OpAmount.BigInt()), - WaitUndelegationAmount: sdkmath.NewInt(0), + WaitUndelegationAmount: sdkmath.ZeroInt(), }, *specifiedDelegationAmount) totalDelegationAmount, err = suite.App.DelegationKeeper.TotalDelegatedAmountForStakerAsset(suite.Ctx, stakerID, assetID) @@ -208,22 +208,22 @@ func (suite *DelegationTestSuite) TestUndelegateFrom() { operatorState, err := suite.App.AssetsKeeper.GetOperatorSpecifiedAssetInfo(suite.Ctx, delegationEvent.OperatorAddress, assetID) suite.NoError(err) suite.Equal(types.OperatorAssetInfo{ - TotalAmount: sdkmath.NewInt(0), + TotalAmount: sdkmath.ZeroInt(), PendingUndelegationAmount: delegationEvent.OpAmount, - TotalShare: sdkmath.LegacyNewDec(0), - OperatorShare: sdkmath.LegacyNewDec(0), + TotalShare: sdkmath.LegacyZeroDec(), + OperatorShare: sdkmath.LegacyZeroDec(), }, *operatorState) specifiedDelegationAmount, err := suite.App.DelegationKeeper.GetSingleDelegationInfo(suite.Ctx, stakerID, assetID, delegationEvent.OperatorAddress.String()) suite.NoError(err) suite.Equal(delegationtype.DelegationAmounts{ WaitUndelegationAmount: delegationEvent.OpAmount, - UndelegatableShare: sdkmath.LegacyNewDec(0), + UndelegatableShare: sdkmath.LegacyZeroDec(), }, *specifiedDelegationAmount) totalDelegationAmount, err := suite.App.DelegationKeeper.TotalDelegatedAmountForStakerAsset(suite.Ctx, stakerID, assetID) suite.NoError(err) - suite.Equal(sdkmath.NewInt(0), totalDelegationAmount) + suite.Equal(sdkmath.ZeroInt(), totalDelegationAmount) records, err := suite.App.DelegationKeeper.GetStakerUndelegationRecords(suite.Ctx, stakerID, assetID) suite.NoError(err) @@ -267,22 +267,22 @@ func (suite *DelegationTestSuite) TestUndelegateFrom() { operatorState, err = suite.App.AssetsKeeper.GetOperatorSpecifiedAssetInfo(suite.Ctx, delegationEvent.OperatorAddress, assetID) suite.NoError(err) suite.Equal(types.OperatorAssetInfo{ - TotalAmount: sdkmath.NewInt(0), + TotalAmount: sdkmath.ZeroInt(), PendingUndelegationAmount: delegationEvent.OpAmount, - TotalShare: sdkmath.LegacyNewDec(0), - OperatorShare: sdkmath.LegacyNewDec(0), + TotalShare: sdkmath.LegacyZeroDec(), + OperatorShare: sdkmath.LegacyZeroDec(), }, *operatorState) specifiedDelegationAmount, err = suite.App.DelegationKeeper.GetSingleDelegationInfo(suite.Ctx, stakerID, assetID, delegationEvent.OperatorAddress.String()) suite.NoError(err) suite.Equal(delegationtype.DelegationAmounts{ WaitUndelegationAmount: delegationEvent.OpAmount, - UndelegatableShare: sdkmath.LegacyNewDec(0), + UndelegatableShare: sdkmath.LegacyZeroDec(), }, *specifiedDelegationAmount) totalDelegationAmount, err = suite.App.DelegationKeeper.TotalDelegatedAmountForStakerAsset(suite.Ctx, stakerID, assetID) suite.NoError(err) - suite.Equal(sdkmath.NewInt(0), totalDelegationAmount) + suite.Equal(sdkmath.ZeroInt(), totalDelegationAmount) records, err = suite.App.DelegationKeeper.GetStakerUndelegationRecords(suite.Ctx, stakerID, assetID) suite.NoError(err) @@ -351,28 +351,28 @@ func (suite *DelegationTestSuite) TestCompleteUndelegation() { suite.Equal(types.StakerAssetInfo{ TotalDepositAmount: suite.depositAmount, WithdrawableAmount: suite.depositAmount, - PendingUndelegationAmount: sdkmath.NewInt(0), + PendingUndelegationAmount: sdkmath.ZeroInt(), }, *restakerState) operatorState, err := suite.App.AssetsKeeper.GetOperatorSpecifiedAssetInfo(suite.Ctx, delegationEvent.OperatorAddress, assetID) suite.NoError(err) suite.Equal(types.OperatorAssetInfo{ - TotalAmount: sdkmath.NewInt(0), - PendingUndelegationAmount: sdkmath.NewInt(0), - TotalShare: sdkmath.LegacyNewDec(0), - OperatorShare: sdkmath.LegacyNewDec(0), + TotalAmount: sdkmath.ZeroInt(), + PendingUndelegationAmount: sdkmath.ZeroInt(), + TotalShare: sdkmath.LegacyZeroDec(), + OperatorShare: sdkmath.LegacyZeroDec(), }, *operatorState) specifiedDelegationAmount, err := suite.App.DelegationKeeper.GetSingleDelegationInfo(suite.Ctx, stakerID, assetID, delegationEvent.OperatorAddress.String()) suite.NoError(err) suite.Equal(delegationtype.DelegationAmounts{ - UndelegatableShare: sdkmath.LegacyNewDec(0), - WaitUndelegationAmount: sdkmath.NewInt(0), + UndelegatableShare: sdkmath.LegacyZeroDec(), + WaitUndelegationAmount: sdkmath.ZeroInt(), }, *specifiedDelegationAmount) totalDelegationAmount, err := suite.App.DelegationKeeper.TotalDelegatedAmountForStakerAsset(suite.Ctx, stakerID, assetID) suite.NoError(err) - suite.Equal(sdkmath.NewInt(0), totalDelegationAmount) + suite.Equal(sdkmath.ZeroInt(), totalDelegationAmount) records, err := suite.App.DelegationKeeper.GetStakerUndelegationRecords(suite.Ctx, stakerID, assetID) suite.NoError(err) @@ -419,28 +419,28 @@ func (suite *DelegationTestSuite) TestCompleteUndelegation() { suite.Equal(types.StakerAssetInfo{ TotalDepositAmount: balance.Amount, WithdrawableAmount: balance.Amount, - PendingUndelegationAmount: sdkmath.NewInt(0), + PendingUndelegationAmount: sdkmath.ZeroInt(), }, *restakerState) operatorState, err = suite.App.AssetsKeeper.GetOperatorSpecifiedAssetInfo(suite.Ctx, delegationEvent.OperatorAddress, assetID) suite.NoError(err) suite.Equal(types.OperatorAssetInfo{ - TotalAmount: sdkmath.NewInt(0), - PendingUndelegationAmount: sdkmath.NewInt(0), - TotalShare: sdkmath.LegacyNewDec(0), - OperatorShare: sdkmath.LegacyNewDec(0), + TotalAmount: sdkmath.ZeroInt(), + PendingUndelegationAmount: sdkmath.ZeroInt(), + TotalShare: sdkmath.LegacyZeroDec(), + OperatorShare: sdkmath.LegacyZeroDec(), }, *operatorState) specifiedDelegationAmount, err = suite.App.DelegationKeeper.GetSingleDelegationInfo(suite.Ctx, stakerID, assetID, delegationEvent.OperatorAddress.String()) suite.NoError(err) suite.Equal(delegationtype.DelegationAmounts{ - UndelegatableShare: sdkmath.LegacyNewDec(0), - WaitUndelegationAmount: sdkmath.NewInt(0), + UndelegatableShare: sdkmath.LegacyZeroDec(), + WaitUndelegationAmount: sdkmath.ZeroInt(), }, *specifiedDelegationAmount) totalDelegationAmount, err = suite.App.DelegationKeeper.TotalDelegatedAmountForStakerAsset(suite.Ctx, stakerID, assetID) suite.NoError(err) - suite.Equal(sdkmath.NewInt(0), totalDelegationAmount) + suite.Equal(sdkmath.ZeroInt(), totalDelegationAmount) records, err = suite.App.DelegationKeeper.GetStakerUndelegationRecords(suite.Ctx, stakerID, assetID) suite.NoError(err) diff --git a/x/delegation/keeper/delegation_state.go b/x/delegation/keeper/delegation_state.go index 340d585dd..ce04b35c9 100644 --- a/x/delegation/keeper/delegation_state.go +++ b/x/delegation/keeper/delegation_state.go @@ -77,7 +77,7 @@ func (k Keeper) IterateDelegationsForStaker(ctx sdk.Context, stakerID string, op // TotalDelegatedAmountForStakerAsset query the total delegation amount of the specified staker and asset. // It needs to be calculated from the share and amount of the asset pool. func (k Keeper) TotalDelegatedAmountForStakerAsset(ctx sdk.Context, stakerID string, assetID string) (amount sdkmath.Int, err error) { - amount = sdkmath.NewInt(0) + amount = sdkmath.ZeroInt() opFunc := func(keys *delegationtype.SingleDelegationInfoReq, amounts *delegationtype.DelegationAmounts) (bool, error) { if amounts.UndelegatableShare.IsZero() { return false, nil @@ -143,8 +143,8 @@ func (k Keeper) UpdateDelegationState(ctx sdk.Context, stakerID, assetID, opAddr } singleStateKey := assetstype.GetJoinedStoreKey(stakerID, assetID, opAddr) delegationState := delegationtype.DelegationAmounts{ - WaitUndelegationAmount: sdkmath.NewInt(0), - UndelegatableShare: sdkmath.LegacyNewDec(0), + WaitUndelegationAmount: sdkmath.ZeroInt(), + UndelegatableShare: sdkmath.LegacyZeroDec(), } value := store.Get(singleStateKey) @@ -305,7 +305,7 @@ func (k *Keeper) SetStakerShareToZero(ctx sdk.Context, operator, assetID string, if value != nil { delegationState := delegationtype.DelegationAmounts{} k.cdc.MustUnmarshal(value, &delegationState) - delegationState.UndelegatableShare = sdkmath.LegacyNewDec(0) + delegationState.UndelegatableShare = sdkmath.LegacyZeroDec() bz := k.cdc.MustMarshal(&delegationState) store.Set(singleStateKey, bz) } diff --git a/x/delegation/keeper/share.go b/x/delegation/keeper/share.go index d0cc7c64a..3e3c64905 100644 --- a/x/delegation/keeper/share.go +++ b/x/delegation/keeper/share.go @@ -18,14 +18,14 @@ import ( // caused by the bankers rounding. func TokensFromShares(stakerShare, totalShare sdkmath.LegacyDec, totalAmount sdkmath.Int) (sdkmath.Int, error) { if stakerShare.GT(totalShare) { - return sdkmath.NewInt(0), errorsmod.Wrapf(delegationtypes.ErrInsufficientShares, "the stakerShare is:%v the totalShare is:%v", stakerShare, totalShare) + return sdkmath.ZeroInt(), errorsmod.Wrapf(delegationtypes.ErrInsufficientShares, "the stakerShare is:%v the totalShare is:%v", stakerShare, totalShare) } if totalShare.IsZero() { if totalAmount.IsZero() { // this can happen if everyone exits. - return sdkmath.NewInt(0), nil + return sdkmath.ZeroInt(), nil } - return sdkmath.NewInt(0), delegationtypes.ErrDivisorIsZero + return sdkmath.ZeroInt(), delegationtypes.ErrDivisorIsZero } return (stakerShare.MulInt(totalAmount)).Quo(totalShare).TruncateInt(), nil } diff --git a/x/delegation/keeper/share_test.go b/x/delegation/keeper/share_test.go index 5f9034d21..2e87a7657 100644 --- a/x/delegation/keeper/share_test.go +++ b/x/delegation/keeper/share_test.go @@ -23,23 +23,23 @@ func (suite *DelegationTestSuite) TestTokensFromShares() { totalAmount: sdkmath.NewInt(50), stakerShare: sdkmath.LegacyNewDec(51), innerError: delegationtypes.ErrInsufficientShares, - stakerAmount: sdkmath.NewInt(0), + stakerAmount: sdkmath.ZeroInt(), }, { - totalShare: sdkmath.LegacyNewDec(0), + totalShare: sdkmath.LegacyZeroDec(), totalAmount: sdkmath.NewInt(50), - stakerShare: sdkmath.LegacyNewDec(0), + stakerShare: sdkmath.LegacyZeroDec(), innerError: delegationtypes.ErrDivisorIsZero, - stakerAmount: sdkmath.NewInt(0), + stakerAmount: sdkmath.ZeroInt(), }, // the share will be equal to the amount if there isn't a slash event { totalShare: sdkmath.LegacyNewDec(50), totalAmount: sdkmath.NewInt(50), - stakerShare: sdkmath.LegacyNewDec(0), + stakerShare: sdkmath.LegacyZeroDec(), innerError: nil, - stakerAmount: sdkmath.NewInt(0), + stakerAmount: sdkmath.ZeroInt(), }, { totalShare: sdkmath.LegacyNewDec(50), @@ -60,9 +60,9 @@ func (suite *DelegationTestSuite) TestTokensFromShares() { { totalShare: sdkmath.LegacyNewDec(70), totalAmount: sdkmath.NewInt(50), - stakerShare: sdkmath.LegacyNewDec(0), + stakerShare: sdkmath.LegacyZeroDec(), innerError: nil, - stakerAmount: sdkmath.NewInt(0), + stakerAmount: sdkmath.ZeroInt(), }, { totalShare: sdkmath.LegacyNewDec(70), @@ -81,10 +81,10 @@ func (suite *DelegationTestSuite) TestTokensFromShares() { // all exit { - totalShare: sdkmath.LegacyNewDec(0), - stakerShare: sdkmath.LegacyNewDec(0), - totalAmount: sdkmath.NewInt(0), - stakerAmount: sdkmath.NewInt(0), + totalShare: sdkmath.LegacyZeroDec(), + stakerShare: sdkmath.LegacyZeroDec(), + totalAmount: sdkmath.ZeroInt(), + stakerAmount: sdkmath.ZeroInt(), innerError: nil, }, } @@ -114,19 +114,19 @@ func (suite *DelegationTestSuite) TestSharesFromTokens() { // error cases { totalShare: sdkmath.LegacyNewDec(50), - totalAmount: sdkmath.NewInt(0), - stakerAmount: sdkmath.NewInt(0), + totalAmount: sdkmath.ZeroInt(), + stakerAmount: sdkmath.ZeroInt(), innerError: delegationtypes.ErrDivisorIsZero, - stakerShare: sdkmath.LegacyNewDec(0), + stakerShare: sdkmath.LegacyZeroDec(), }, // the share will be equal to the amount if there isn't a slash event { totalShare: sdkmath.LegacyNewDec(50), totalAmount: sdkmath.NewInt(50), - stakerAmount: sdkmath.NewInt(0), + stakerAmount: sdkmath.ZeroInt(), innerError: nil, - stakerShare: sdkmath.LegacyNewDec(0), + stakerShare: sdkmath.LegacyZeroDec(), }, { totalShare: sdkmath.LegacyNewDec(50), @@ -154,9 +154,9 @@ func (suite *DelegationTestSuite) TestSharesFromTokens() { { totalShare: sdkmath.LegacyNewDec(70), totalAmount: sdkmath.NewInt(50), - stakerAmount: sdkmath.NewInt(0), + stakerAmount: sdkmath.ZeroInt(), innerError: nil, - stakerShare: sdkmath.LegacyNewDec(0), + stakerShare: sdkmath.LegacyZeroDec(), }, { totalShare: sdkmath.LegacyNewDec(70), @@ -175,11 +175,11 @@ func (suite *DelegationTestSuite) TestSharesFromTokens() { // all exit { - totalShare: sdkmath.LegacyNewDec(0), - totalAmount: sdkmath.NewInt(0), - stakerAmount: sdkmath.NewInt(0), + totalShare: sdkmath.LegacyZeroDec(), + totalAmount: sdkmath.ZeroInt(), + stakerAmount: sdkmath.ZeroInt(), innerError: nil, - stakerShare: sdkmath.LegacyNewDec(0), + stakerShare: sdkmath.LegacyZeroDec(), }, } @@ -204,8 +204,8 @@ func (suite *DelegationTestSuite) TestCalculateShare() { // test the case that the asset amount of operator is zero err = suite.App.AssetsKeeper.UpdateOperatorAssetState(suite.Ctx, suite.opAccAddr, assetID, assetstype.DeltaOperatorSingleAsset{ - TotalAmount: sdkmath.NewInt(0), - TotalShare: sdkmath.LegacyNewDec(0), + TotalAmount: sdkmath.ZeroInt(), + TotalShare: sdkmath.LegacyZeroDec(), }) suite.NoError(err) share, err = suite.App.DelegationKeeper.CalculateShare(suite.Ctx, suite.opAccAddr, assetID, assetAmount) @@ -229,7 +229,7 @@ func (suite *DelegationTestSuite) TestValidateUndelegationAmount() { suite.prepareDelegation(suite.delegationAmount, suite.opAccAddr) stakerID, assetID := assetstype.GetStakerIDAndAssetID(suite.clientChainLzID, suite.Address[:], suite.assetAddr[:]) - undelegationAmount := sdkmath.NewInt(0) + undelegationAmount := sdkmath.ZeroInt() _, err := suite.App.DelegationKeeper.ValidateUndelegationAmount(suite.Ctx, suite.opAccAddr, stakerID, assetID, undelegationAmount) suite.Error(err, delegationtypes.ErrAmountIsNotPositive) @@ -249,7 +249,7 @@ func (suite *DelegationTestSuite) TestCalculateSlashShare() { suite.prepareDeposit(suite.depositAmount) suite.prepareDelegation(suite.delegationAmount, suite.opAccAddr) stakerID, assetID := assetstype.GetStakerIDAndAssetID(suite.clientChainLzID, suite.Address[:], suite.assetAddr[:]) - slashAmount := sdkmath.NewInt(0) + slashAmount := sdkmath.ZeroInt() _, err := suite.App.DelegationKeeper.CalculateSlashShare(suite.Ctx, suite.opAccAddr, stakerID, assetID, slashAmount) suite.Error(err, delegationtypes.ErrAmountIsNotPositive) @@ -327,7 +327,7 @@ func (suite *DelegationTestSuite) TestRemoveShare() { suite.Equal(removeShare.TruncateInt(), removeToken) delegationInfo, err = suite.App.DelegationKeeper.GetSingleDelegationInfo(suite.Ctx, stakerID, assetID, suite.opAccAddr.String()) suite.NoError(err) - suite.Equal(sdkmath.LegacyNewDec(0), delegationInfo.UndelegatableShare) + suite.Equal(sdkmath.LegacyZeroDec(), delegationInfo.UndelegatableShare) suite.Equal(removeShare.TruncateInt(), delegationInfo.WaitUndelegationAmount) stakerAssetInfo, err := suite.App.AssetsKeeper.GetStakerSpecifiedAssetInfo(suite.Ctx, stakerID, assetID) suite.NoError(err) diff --git a/x/delegation/keeper/update_native_restaking_balance_test.go b/x/delegation/keeper/update_native_restaking_balance_test.go index 7a2bf81c9..b646d9527 100644 --- a/x/delegation/keeper/update_native_restaking_balance_test.go +++ b/x/delegation/keeper/update_native_restaking_balance_test.go @@ -43,7 +43,7 @@ func (suite *DelegationTestSuite) TestUpdateNSTBalance() { suite.NoError(err) expectAssetInfo := assettypes.StakerAssetInfo{ TotalDepositAmount: depositAmount.Sub(actualSlashAmount), - WithdrawableAmount: sdkmath.NewInt(0), + WithdrawableAmount: sdkmath.ZeroInt(), // it will be decreased when the undelegation is completed. PendingUndelegationAmount: undelegateAmountFromDefaultOperator, } @@ -52,7 +52,7 @@ func (suite *DelegationTestSuite) TestUpdateNSTBalance() { // check the undelegation state after slashing records, err := suite.App.DelegationKeeper.GetStakerUndelegationRecords(suite.Ctx, stakerID, assetID) suite.NoError(err) - suite.Equal(sdkmath.NewInt(0), records[0].ActualCompletedAmount) + suite.Equal(sdkmath.ZeroInt(), records[0].ActualCompletedAmount) // check the delegated share for two operators delegationForDefaultOperator, err := suite.App.DelegationKeeper.GetSingleDelegationInfo(suite.Ctx, stakerID, assetID, suite.opAccAddr.String()) diff --git a/x/delegation/types/expected_keepers.go b/x/delegation/types/expected_keepers.go index 8fd5fb42b..27dacad0c 100644 --- a/x/delegation/types/expected_keepers.go +++ b/x/delegation/types/expected_keepers.go @@ -23,7 +23,7 @@ func (VirtualSlashKeeper) IsOperatorFrozen(_ sdk.Context, _ sdk.AccAddress) bool } func (VirtualSlashKeeper) OperatorAssetSlashedProportion(_ sdk.Context, _ sdk.AccAddress, _ string, _, _ uint64) sdkmath.LegacyDec { - return sdkmath.LegacyNewDec(0) + return sdkmath.LegacyZeroDec() } // DelegationHooks are event hooks triggered by the delegation module diff --git a/x/exomint/keeper/impl_epochs_hooks_test.go b/x/exomint/keeper/impl_epochs_hooks_test.go index 7a33dbb01..ebff588a1 100644 --- a/x/exomint/keeper/impl_epochs_hooks_test.go +++ b/x/exomint/keeper/impl_epochs_hooks_test.go @@ -23,7 +23,7 @@ func (suite *KeeperTestSuite) TestEpochHooks() { suite.Ctx, feeCollector, params.MintDenom, - ).Amount.Equal(sdkmath.NewInt(0)), + ).Amount.Equal(sdkmath.ZeroInt()), ) // now go to one day diff --git a/x/exomint/types/params_test.go b/x/exomint/types/params_test.go index a875d2861..d1adee2df 100644 --- a/x/exomint/types/params_test.go +++ b/x/exomint/types/params_test.go @@ -59,7 +59,7 @@ func TestValidate(t *testing.T) { name: "zero reward", params: types.Params{ MintDenom: "aevmos", - EpochReward: sdkmath.NewInt(0), + EpochReward: sdkmath.ZeroInt(), EpochIdentifier: "day", }, expResult: true, @@ -150,11 +150,11 @@ func TestOverrideIfRequired(t *testing.T) { next: types.DefaultParams(), over: types.NewParams( types.DefaultMintDenom, - sdkmath.NewInt(0), // 0 is not overridden + sdkmath.ZeroInt(), // 0 is not overridden types.DefaultEpochIdentifier, ), malleate: func(next *types.Params) { - next.EpochReward = sdkmath.NewInt(0) + next.EpochReward = sdkmath.ZeroInt() }, }, { diff --git a/x/operator/client/cli/query.go b/x/operator/client/cli/query.go index d5c956fc1..4cfa3c168 100644 --- a/x/operator/client/cli/query.go +++ b/x/operator/client/cli/query.go @@ -463,10 +463,11 @@ func GetOptInfo() *cobra.Command { func QuerySnapshotHelper() *cobra.Command { cmd := &cobra.Command{ - Use: "QuerySnapshotHelper ", - Short: "Get the voting power snapshot helper for the avs", - Long: "Get the voting power snapshot helper for the avs", - Args: cobra.ExactArgs(1), + Use: "query-snapshot-helper ", + Short: "Get the voting power snapshot helper for the avs", + Long: "Get the voting power snapshot helper for the avs", + Example: "exocored query operator query-snapshot-helper 0xaa089ba103f765fcea44808bd3d4073523254c57", + Args: cobra.ExactArgs(1), RunE: func(cmd *cobra.Command, args []string) error { if !common.IsHexAddress(args[0]) { return xerrors.Errorf("invalid avs address,err:%s", types.ErrInvalidAddr) @@ -493,10 +494,12 @@ func QuerySnapshotHelper() *cobra.Command { func QueryAllSnapshot() *cobra.Command { cmd := &cobra.Command{ - Use: "QueryAllSnapshot ", + Use: "query-all-snapshot ", Short: "Get the all voting power snapshots for the avs", - Long: "Get the all voting power snapshots for the avs", - Args: cobra.ExactArgs(1), + Long: "Get all voting power snapshots for the AVS. " + + "The number of stored snapshots should be the unbonding duration plus one.", + Example: "exocored query operator query-all-snapshot 0xaa089ba103f765fcea44808bd3d4073523254c57", + Args: cobra.ExactArgs(1), RunE: func(cmd *cobra.Command, args []string) error { if !common.IsHexAddress(args[0]) { return xerrors.Errorf("invalid avs address,err:%s", types.ErrInvalidAddr) @@ -528,10 +531,12 @@ func QueryAllSnapshot() *cobra.Command { func QuerySpecifiedSnapshot() *cobra.Command { cmd := &cobra.Command{ - Use: "QuerySpecifiedSnapshot ", + Use: "query-specified-snapshot ", Short: "Get the AVS voting power snapshot at specified height", - Long: "Get the AVS voting power snapshot at specified height", - Args: cobra.ExactArgs(2), + Long: "Get the AVS voting power snapshot at specified height" + + "The number of stored snapshots should be the unbonding duration plus one.", + Example: "exocored query operator query-specified-snapshot 0xaa089ba103f765fcea44808bd3d4073523254c57 3", + Args: cobra.ExactArgs(2), RunE: func(cmd *cobra.Command, args []string) error { if !common.IsHexAddress(args[0]) { return xerrors.Errorf("invalid avs address,err:%s", types.ErrInvalidAddr) diff --git a/x/operator/keeper/abci.go b/x/operator/keeper/abci.go index 83aa50a59..e7aa81108 100644 --- a/x/operator/keeper/abci.go +++ b/x/operator/keeper/abci.go @@ -58,7 +58,7 @@ func (k *Keeper) UpdateVotingPower(ctx sdk.Context, avsAddr, epochIdentifier str // update the voting power of operators and AVS isSnapshotChanged := false votingPowerSet := make([]*operatortypes.OperatorVotingPower, 0) - avsVotingPower := sdkmath.LegacyNewDec(0) + avsVotingPower := sdkmath.LegacyZeroDec() hasOptedOperator := false opFunc := func(operator string, optedUSDValues *operatortypes.OperatorOptedUSDValue) error { if !hasOptedOperator { @@ -67,9 +67,9 @@ func (k *Keeper) UpdateVotingPower(ctx sdk.Context, avsAddr, epochIdentifier str // clear the old voting power for the operator lastOptedUSDValue := *optedUSDValues *optedUSDValues = operatortypes.OperatorOptedUSDValue{ - TotalUSDValue: sdkmath.LegacyNewDec(0), - SelfUSDValue: sdkmath.LegacyNewDec(0), - ActiveUSDValue: sdkmath.LegacyNewDec(0), + TotalUSDValue: sdkmath.LegacyZeroDec(), + SelfUSDValue: sdkmath.LegacyZeroDec(), + ActiveUSDValue: sdkmath.LegacyZeroDec(), } stakingInfo, err := k.CalculateUSDValueForOperator(ctx, false, operator, assets, decimals, prices) if err != nil { diff --git a/x/operator/keeper/operator_slash_state.go b/x/operator/keeper/operator_slash_state.go index 72296f7c7..467a1702b 100644 --- a/x/operator/keeper/operator_slash_state.go +++ b/x/operator/keeper/operator_slash_state.go @@ -107,7 +107,7 @@ func (k *Keeper) UpdateSlashAssetsState(ctx sdk.Context, assetID, stakerOrOperat } key = assetstype.GetJoinedStoreKey(hexutil.EncodeUint64(processedHeight), assetID, stakerOrOperator) - slashAmount := assetstype.ValueField{Amount: sdkmath.NewInt(0)} + slashAmount := assetstype.ValueField{Amount: sdkmath.ZeroInt()} value := store.Get(key) if value != nil { k.cdc.MustUnmarshal(value, &slashAmount) @@ -121,7 +121,7 @@ func (k *Keeper) UpdateSlashAssetsState(ctx sdk.Context, assetID, stakerOrOperat store.Set(key, bz) key = assetstype.GetJoinedStoreKey(hexutil.EncodeUint64(processedHeight), assetID) - totalSlashAmount := assetstype.ValueField{Amount: sdkmath.NewInt(0)} + totalSlashAmount := assetstype.ValueField{Amount: sdkmath.ZeroInt()} value = store.Get(key) if value != nil { k.cdc.MustUnmarshal(value, &totalSlashAmount) diff --git a/x/operator/keeper/opt_test.go b/x/operator/keeper/opt_test.go index af37a0c33..ec79e0305 100644 --- a/x/operator/keeper/opt_test.go +++ b/x/operator/keeper/opt_test.go @@ -194,8 +194,8 @@ func (suite *OperatorTestSuite) TestOptOut() { OptedInHeight: uint64(optInHeight), OptedOutHeight: uint64(suite.Ctx.BlockHeight()), }, - AVSTotalShare: sdkmath.LegacyNewDec(0), - AVSOperatorShare: sdkmath.LegacyNewDec(0), + AVSTotalShare: sdkmath.LegacyZeroDec(), + AVSOperatorShare: sdkmath.LegacyZeroDec(), AssetState: nil, OperatorShare: sdkmath.LegacyDec{}, StakerShare: sdkmath.LegacyDec{}, diff --git a/x/operator/keeper/slash.go b/x/operator/keeper/slash.go index 850d173b2..ab6188f06 100644 --- a/x/operator/keeper/slash.go +++ b/x/operator/keeper/slash.go @@ -31,7 +31,7 @@ func SlashFromUndelegation(undelegation *delegationtype.UndelegationRecord, slas // reduce the actual_completed_amount in the record if slashAmount.GTE(undelegation.ActualCompletedAmount) { slashAmount = undelegation.ActualCompletedAmount - undelegation.ActualCompletedAmount = sdkmath.NewInt(0) + undelegation.ActualCompletedAmount = sdkmath.ZeroInt() } else { undelegation.ActualCompletedAmount = undelegation.ActualCompletedAmount.Sub(slashAmount) } @@ -131,8 +131,8 @@ func (k *Keeper) SlashAssets(ctx sdk.Context, snapshotHeight int64, parameter *t if err != nil { return err } - state.TotalShare = sdkmath.LegacyNewDec(0) - state.OperatorShare = sdkmath.LegacyNewDec(0) + state.TotalShare = sdkmath.LegacyZeroDec() + state.OperatorShare = sdkmath.LegacyZeroDec() } state.TotalAmount = remainingAmount executionInfo.SlashAssetsPool = append(executionInfo.SlashAssetsPool, types.SlashFromAssetsPool{ @@ -226,7 +226,7 @@ func (k Keeper) SlashWithInfractionReason( isAvs, avsAddr := k.avsKeeper.IsAVSByChainID(ctx, chainID) if !isAvs { k.Logger(ctx).Error("the chainID is not supported by AVS", "chainID", chainID) - return sdkmath.NewInt(0) + return sdkmath.ZeroInt() } slashID := GetSlashIDForDogfood(infraction, infractionHeight) slashParam := &types.SlashInputInfo{ @@ -242,11 +242,11 @@ func (k Keeper) SlashWithInfractionReason( err := k.Slash(ctx, slashParam) if err != nil { k.Logger(ctx).Error("error when executing slash", "error", err, "avsAddr", avsAddr) - return sdkmath.NewInt(0) + return sdkmath.ZeroInt() } // todo: The returned value should be the amount of burned Exo if we considering a slash from the reward // Now it doesn't slash from the reward, so just return 0 - return sdkmath.NewInt(0) + return sdkmath.ZeroInt() } // IsOperatorJailedForChainID returns whether an operator is jailed for a specific chainID. diff --git a/x/operator/keeper/slash_test.go b/x/operator/keeper/slash_test.go index 1eebc9ea5..cc66f7ee8 100644 --- a/x/operator/keeper/slash_test.go +++ b/x/operator/keeper/slash_test.go @@ -65,7 +65,7 @@ func (suite *OperatorTestSuite) TestSlashWithInfractionReason() { slashFactor := suite.App.SlashingKeeper.SlashFractionDowntime(suite.Ctx) slashType := stakingtypes.Infraction_INFRACTION_DOWNTIME exoSlashValue := suite.App.OperatorKeeper.SlashWithInfractionReason(suite.Ctx, suite.operatorAddr, infractionHeight, power, slashFactor, slashType) - suite.Equal(sdkmath.NewInt(0), exoSlashValue) + suite.Equal(sdkmath.ZeroInt(), exoSlashValue) // verify the state after the slash slashID := keeper.GetSlashIDForDogfood(slashType, infractionHeight) diff --git a/x/operator/keeper/usd_value.go b/x/operator/keeper/usd_value.go index 15dd3c9ea..20c551479 100644 --- a/x/operator/keeper/usd_value.go +++ b/x/operator/keeper/usd_value.go @@ -31,9 +31,9 @@ func (k *Keeper) UpdateOperatorUSDValue(ctx sdk.Context, avsAddr, operatorAddr s key = assetstype.GetJoinedStoreKey(strings.ToLower(avsAddr), operatorAddr) usdInfo := operatortypes.OperatorOptedUSDValue{ - SelfUSDValue: sdkmath.LegacyNewDec(0), - TotalUSDValue: sdkmath.LegacyNewDec(0), - ActiveUSDValue: sdkmath.LegacyNewDec(0), + SelfUSDValue: sdkmath.LegacyZeroDec(), + TotalUSDValue: sdkmath.LegacyZeroDec(), + ActiveUSDValue: sdkmath.LegacyZeroDec(), } value := store.Get(key) if value != nil { @@ -68,9 +68,9 @@ func (k *Keeper) InitOperatorUSDValue(ctx sdk.Context, avsAddr, operatorAddr str return errorsmod.Wrap(operatortypes.ErrKeyAlreadyExist, fmt.Sprintf("avsAddr operatorAddr is: %s, %s", avsAddr, operatorAddr)) } initValue := operatortypes.OperatorOptedUSDValue{ - SelfUSDValue: sdkmath.LegacyNewDec(0), - TotalUSDValue: sdkmath.LegacyNewDec(0), - ActiveUSDValue: sdkmath.LegacyNewDec(0), + SelfUSDValue: sdkmath.LegacyZeroDec(), + TotalUSDValue: sdkmath.LegacyZeroDec(), + ActiveUSDValue: sdkmath.LegacyZeroDec(), } bz := k.cdc.MustMarshal(&initValue) store.Set(key, bz) @@ -115,9 +115,9 @@ func (k *Keeper) GetOperatorOptedUSDValue(ctx sdk.Context, avsAddr, operatorAddr // return zero if the operator has opted-out of the AVS if !k.IsOptedIn(ctx, operatorAddr, avsAddr) { return operatortypes.OperatorOptedUSDValue{ - SelfUSDValue: sdkmath.LegacyNewDec(0), - TotalUSDValue: sdkmath.LegacyNewDec(0), - ActiveUSDValue: sdkmath.LegacyNewDec(0), + SelfUSDValue: sdkmath.LegacyZeroDec(), + TotalUSDValue: sdkmath.LegacyZeroDec(), + ActiveUSDValue: sdkmath.LegacyZeroDec(), }, nil } @@ -149,7 +149,7 @@ func (k *Keeper) UpdateAVSUSDValue(ctx sdk.Context, avsAddr string, opAmount sdk } store := prefix.NewStore(ctx.KVStore(k.storeKey), operatortypes.KeyPrefixUSDValueForAVS) key := []byte(strings.ToLower(avsAddr)) - totalValue := operatortypes.DecValueField{Amount: sdkmath.LegacyNewDec(0)} + totalValue := operatortypes.DecValueField{Amount: sdkmath.LegacyZeroDec()} value := store.Get(key) if value != nil { k.cdc.MustUnmarshal(value, &totalValue) @@ -366,9 +366,9 @@ func (k *Keeper) CalculateUSDValueForOperator( ) (operatortypes.OperatorStakingInfo, error) { var err error ret := operatortypes.OperatorStakingInfo{ - Staking: sdkmath.LegacyNewDec(0), - SelfStaking: sdkmath.LegacyNewDec(0), - StakingAndWaitUnbonding: sdkmath.LegacyNewDec(0), + Staking: sdkmath.LegacyZeroDec(), + SelfStaking: sdkmath.LegacyZeroDec(), + StakingAndWaitUnbonding: sdkmath.LegacyZeroDec(), } // iterate all assets owned by the operator to calculate its voting power opFuncToIterateAssets := func(assetID string, state *assetstype.OperatorAssetInfo) error { @@ -463,14 +463,14 @@ func (k Keeper) GetOrCalculateOperatorUSDValues( func (k *Keeper) CalculateUSDValueForStaker(ctx sdk.Context, stakerID, avsAddr string, operator sdk.AccAddress) (sdkmath.LegacyDec, error) { if !k.IsActive(ctx, operator, avsAddr) { - return sdkmath.LegacyNewDec(0), nil + return sdkmath.LegacyZeroDec(), nil } optedUSDValues, err := k.GetOperatorOptedUSDValue(ctx, avsAddr, operator.String()) if err != nil { return sdkmath.LegacyDec{}, err } if optedUSDValues.ActiveUSDValue.IsZero() { - return sdkmath.LegacyNewDec(0), err + return sdkmath.LegacyZeroDec(), err } // calculate the active voting power for staker @@ -479,7 +479,7 @@ func (k *Keeper) CalculateUSDValueForStaker(ctx sdk.Context, stakerID, avsAddr s return sdkmath.LegacyDec{}, err } if assets == nil { - return sdkmath.LegacyNewDec(0), nil + return sdkmath.LegacyZeroDec(), nil } prices, err := k.oracleKeeper.GetMultipleAssetsPrices(ctx, assets) // we don't ignore the error regarding the price round not found here, because it's used to @@ -490,7 +490,7 @@ func (k *Keeper) CalculateUSDValueForStaker(ctx sdk.Context, stakerID, avsAddr s if prices == nil { return sdkmath.LegacyDec{}, errorsmod.Wrap(operatortypes.ErrValueIsNilOrZero, "CalculateUSDValueForStaker prices map is nil") } - totalUSDValue := sdkmath.LegacyNewDec(0) + totalUSDValue := sdkmath.LegacyZeroDec() opFunc := func(keys *delegationtype.SingleDelegationInfoReq, amounts *delegationtype.DelegationAmounts) (bool, error) { // Return true to stop iteration, false to continue iterating if keys.OperatorAddr == operator.String() { diff --git a/x/operator/keeper/usd_value_test.go b/x/operator/keeper/usd_value_test.go index b3808ca15..9790379f6 100644 --- a/x/operator/keeper/usd_value_test.go +++ b/x/operator/keeper/usd_value_test.go @@ -59,7 +59,7 @@ func (suite *OperatorTestSuite) TestCalculatedUSDValueOverflow() { amount = sdkmath.NewInt(1) assetDecimal = uint32(assetstype.MaxDecimal) usdValue = operatorKeeper.CalculateUSDValue(amount, price, assetDecimal, priceDecimal) - expectedValue = sdkmath.LegacyNewDec(0) + expectedValue = sdkmath.LegacyZeroDec() suite.Equal(expectedValue.String(), usdValue.String()) price = sdkmath.NewInt(1) @@ -89,7 +89,7 @@ func (suite *OperatorTestSuite) TestAVSUSDValue() { suite.Ctx, &assetstype.StakingAssetInfo{ AssetBasicInfo: usdcClientChainAsset, - StakingTotalAmount: sdkmath.NewInt(0), + StakingTotalAmount: sdkmath.ZeroInt(), }, ) suite.NoError(err) diff --git a/x/operator/types/genesis.go b/x/operator/types/genesis.go index 9da5ae127..8a1aa311b 100644 --- a/x/operator/types/genesis.go +++ b/x/operator/types/genesis.go @@ -364,7 +364,7 @@ func (gs GenesisState) ValidateSlashStates(operators, avs map[string]struct{}) e slash, ) } - if slash.Info.SlashProportion.IsNil() || slash.Info.SlashProportion.LTE(sdkmath.LegacyNewDec(0)) { + if slash.Info.SlashProportion.IsNil() || slash.Info.SlashProportion.LTE(sdkmath.LegacyZeroDec()) { return errorsmod.Wrapf( ErrInvalidGenesisData, "invalid slash proportion, it's nil, zero, or negative: %+v", @@ -390,7 +390,7 @@ func (gs GenesisState) ValidateSlashStates(operators, avs map[string]struct{}) e } // validate the slashing record regarding undelegation SlashFromUndelegationVal := func(_ int, slashFromUndelegation SlashFromUndelegation) error { - if slashFromUndelegation.Amount.IsNil() || slashFromUndelegation.Amount.LTE(sdkmath.NewInt(0)) { + if slashFromUndelegation.Amount.IsNil() || slashFromUndelegation.Amount.LTE(sdkmath.ZeroInt()) { return errorsmod.Wrapf( ErrInvalidGenesisData, "invalid slashing amount from the undelegation, it's nil, zero, or negative: %+v", @@ -409,7 +409,7 @@ func (gs GenesisState) ValidateSlashStates(operators, avs map[string]struct{}) e } // validate the slashing record regarding assets pool SlashFromAssetsPoolVal := func(_ int, slashFromAssetsPool SlashFromAssetsPool) error { - if slashFromAssetsPool.Amount.IsNil() || slashFromAssetsPool.Amount.LTE(sdkmath.NewInt(0)) { + if slashFromAssetsPool.Amount.IsNil() || slashFromAssetsPool.Amount.LTE(sdkmath.ZeroInt()) { return errorsmod.Wrapf( ErrInvalidGenesisData, "invalid slashing amount from the assets pool, it's nil, zero, or negative: %+v", diff --git a/x/oracle/keeper/native_token.go b/x/oracle/keeper/native_token.go index a2b5a8151..52e5d3b81 100644 --- a/x/oracle/keeper/native_token.go +++ b/x/oracle/keeper/native_token.go @@ -313,7 +313,7 @@ func (k Keeper) UpdateNSTByBalanceChange(ctx sdk.Context, assetID string, rawDat func (k Keeper) getDecimal(ctx sdk.Context, assetID string) (int, sdkmath.Int, error) { decimalMap, err := k.assetsKeeper.GetAssetsDecimal(ctx, map[string]interface{}{assetID: nil}) if err != nil { - return 0, sdkmath.NewInt(0), err + return 0, sdkmath.ZeroInt(), err } decimal := decimalMap[assetID] return int(decimal), sdkmath.NewIntWithDecimal(1, int(decimal)), nil diff --git a/x/reward/keeper/claim_reward_test.go b/x/reward/keeper/claim_reward_test.go index 04b7a9098..e3efed965 100644 --- a/x/reward/keeper/claim_reward_test.go +++ b/x/reward/keeper/claim_reward_test.go @@ -40,7 +40,7 @@ func (suite *RewardTestSuite) TestClaimWithdrawRequest() { // suite.Equal(types.StakerAssetInfo{ // TotalDepositAmount: sdkmath.NewInt(10), // WithdrawableAmount: sdkmath.NewInt(10), - // PendingUndelegationAmount: sdkmath.NewInt(0), + // PendingUndelegationAmount: sdkmath.ZeroInt(), // }, *info) // assetInfo, err := suite.App.AssetsKeeper.GetStakingAssetInfo(suite.Ctx, assetID) diff --git a/x/slash/keeper/execute_slash_test.go b/x/slash/keeper/execute_slash_test.go index c2f1cb086..d0a76f9fa 100644 --- a/x/slash/keeper/execute_slash_test.go +++ b/x/slash/keeper/execute_slash_test.go @@ -37,7 +37,7 @@ func (suite *SlashTestSuite) TestSlash() { suite.Equal(types.StakerAssetInfo{ TotalDepositAmount: depositEvent.OpAmount, WithdrawableAmount: depositEvent.OpAmount, - PendingUndelegationAmount: sdkmath.NewInt(0), + PendingUndelegationAmount: sdkmath.ZeroInt(), }, *info) // test the normal case @@ -52,7 +52,7 @@ func (suite *SlashTestSuite) TestSlash() { suite.Equal(types.StakerAssetInfo{ TotalDepositAmount: sdkmath.NewInt(10), WithdrawableAmount: sdkmath.NewInt(10), - PendingUndelegationAmount: sdkmath.NewInt(0), + PendingUndelegationAmount: sdkmath.ZeroInt(), }, *info) assetInfo, err := suite.App.AssetsKeeper.GetStakingAssetInfo(suite.Ctx, assetID)