Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Call claimStakerReward only if there reward to claim #926

Merged
merged 3 commits into from
Sep 7, 2022
Merged

Call claimStakerReward only if there reward to claim #926

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
d62166e
Make contract call only if there is commission to claim
shyam-patel-kira Sep 5, 2022
b32e979
Add tests for claimCommission file
shyam-patel-kira Sep 5, 2022
fb68a4f
update check
shyam-patel-kira Sep 7, 2022
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
52 changes: 31 additions & 21 deletions cmd/claimCommission.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -3,6 +3,7 @@ package cmd

import (
"github.com/spf13/pflag"
"math/big"
"razor/core"
"razor/core/types"
"razor/logger"
Expand Down Expand Up @@ -38,28 +39,37 @@ func (*UtilsStruct) ClaimCommission(flagSet *pflag.FlagSet) {

razorUtils.CheckEthBalanceIsZero(client, address)

txnOpts := razorUtils.GetTxnOpts(types.TransactionOptions{
Client: client,
AccountAddress: address,
Password: password,
ChainId: core.ChainId,
Config: config,
ContractAddress: core.StakeManagerAddress,
MethodName: "claimStakerReward",
Parameters: []interface{}{},
ABI: bindings.StakeManagerABI,
})

log.Info("Claiming commission")

txn, err := stakeManagerUtils.ClaimStakeReward(client, txnOpts)
if err != nil {
log.Fatal("Error in claiming stake reward: ", err)
stakerId, err := razorUtils.GetStakerId(client, address)
utils.CheckError("Error in getting stakerId: ", err)
callOpts := razorUtils.GetOptions()

stakerInfo, err := stakeManagerUtils.StakerInfo(client, &callOpts, stakerId)
utils.CheckError("Error in getting stakerInfo: ", err)

if stakerInfo.StakerReward.Cmp(big.NewInt(0)) > 0 {
txnOpts := razorUtils.GetTxnOpts(types.TransactionOptions{
Client: client,
AccountAddress: address,
Password: password,
ChainId: core.ChainId,
Config: config,
ContractAddress: core.StakeManagerAddress,
MethodName: "claimStakerReward",
Parameters: []interface{}{},
ABI: bindings.StakeManagerABI,
})

log.Info("Claiming commission")

txn, err := stakeManagerUtils.ClaimStakeReward(client, txnOpts)
utils.CheckError("Error in claiming stake reward: ", err)

err = razorUtils.WaitForBlockCompletion(client, transactionUtils.Hash(txn).String())
utils.CheckError("Error in WaitForBlockCompletion for claimCommission: ", err)
} else {
log.Error("no commission to claim")
return
}

err = razorUtils.WaitForBlockCompletion(client, transactionUtils.Hash(txn).String())
utils.CheckError("Error in WaitForBlockCompletion for claimCommission: ", err)

}

func init() {
Expand Down
166 changes: 147 additions & 19 deletions cmd/claimCommission_test.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -20,19 +20,25 @@ import (
func TestUtilsStruct_ClaimCommission(t *testing.T) {
var client *ethclient.Client
var flagSet *pflag.FlagSet
var callOpts bind.CallOpts

privateKey, _ := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
txnOpts, _ := bind.NewKeyedTransactorWithChainID(privateKey, big.NewInt(31337))

type args struct {
config types.Configurations
configErr error
password string
address string
addressErr error
txn *Types.Transaction
err error
hash common.Hash
config types.Configurations
configErr error
password string
address string
addressErr error
stakerInfo types.Staker
stakerInfoErr error
stakerId uint32
stakerIdErr error
callOpts bind.CallOpts
txn *Types.Transaction
err error
hash common.Hash
}
tests := []struct {
name string
Expand All @@ -43,20 +49,37 @@ func TestUtilsStruct_ClaimCommission(t *testing.T) {
name: "Test 1: When ClaimStakeReward runs successfully",
args: args{
config: types.Configurations{},
password: "test",
address: "0x000000000000000000000000000000000000dead",
txn: &Types.Transaction{},
stakerId: 1,
callOpts: bind.CallOpts{
Pending: false,
From: common.HexToAddress("0x000000000000000000000000000000000000dead"),
BlockNumber: big.NewInt(1),
},
stakerInfo: types.Staker{
StakerReward: big.NewInt(100),
},
stakerInfoErr: nil,
password: "test",
address: "0x000000000000000000000000000000000000dead",
txn: &Types.Transaction{},
},
expectedFatal: false,
},
{
name: "Test 2: When ClaimStakeReward fails",
name: "Test 2: When there is an error in fetching staker id",
args: args{
config: types.Configurations{},
config: types.Configurations{},
stakerId: 0,
stakerIdErr: errors.New("error in getting staker id"),
stakerInfo: types.Staker{
StakerReward: big.NewInt(0),
},
callOpts: bind.CallOpts{
Pending: false,
From: common.HexToAddress("0x000000000000000000000000000000000000dead"),
BlockNumber: big.NewInt(1),
},
password: "test",
address: "0x000000000000000000000000000000000000dead",
txn: nil,
err: errors.New("error in claiming stake reward"),
},
expectedFatal: true,
},
Expand All @@ -66,9 +89,109 @@ func TestUtilsStruct_ClaimCommission(t *testing.T) {
config: types.Configurations{},
configErr: errors.New("error in fetching config"),
address: "0x000000000000000000000000000000000000dead",
stakerInfo: types.Staker{
StakerReward: big.NewInt(0),
},
callOpts: bind.CallOpts{
Pending: false,
From: common.HexToAddress("0x000000000000000000000000000000000000dead"),
BlockNumber: big.NewInt(1),
},
},

expectedFatal: true,
},
{
name: "Test 4: When there is an error in fetching stakerInfo",
args: args{
config: types.Configurations{},
stakerInfo: types.Staker{
Address: common.Address{},
TokenAddress: common.Address{},
Stake: nil,
StakerReward: big.NewInt(0),
},
stakerInfoErr: errors.New("error in fetching staker info"),
callOpts: bind.CallOpts{
Pending: false,
From: common.HexToAddress("0x000000000000000000000000000000000000dead"),
BlockNumber: big.NewInt(1),
},
stakerId: 1,
stakerIdErr: nil,
password: "test",
},
expectedFatal: true,
},
{
name: "Test 5: When there is an error in claiming stake reward",
args: args{
config: types.Configurations{},
stakerInfo: types.Staker{
Address: common.Address{},
TokenAddress: common.Address{},
Stake: nil,
StakerReward: big.NewInt(100),
},
stakerInfoErr: nil,
callOpts: bind.CallOpts{
Pending: false,
From: common.HexToAddress("0x000000000000000000000000000000000000dead"),
BlockNumber: big.NewInt(1),
},
stakerId: 1,
stakerIdErr: nil,
password: "test",
err: errors.New("error in claiming stake reward"),
},
expectedFatal: true,
},
{
name: "Test 6: When there is an error in mining block",
args: args{
config: types.Configurations{},
stakerInfo: types.Staker{
Address: common.Address{},
TokenAddress: common.Address{},
Stake: nil,
StakerReward: big.NewInt(100),
},
stakerInfoErr: nil,
callOpts: bind.CallOpts{
Pending: false,
From: common.HexToAddress("0x000000000000000000000000000000000000dead"),
BlockNumber: big.NewInt(1),
},
stakerId: 1,
stakerIdErr: nil,
password: "test",
err: errors.New("error in wait for blockCompletion for claim commission"),
},
expectedFatal: true,
},
{
name: "Test 7: When there is no commission to claim",
args: args{
config: types.Configurations{},
stakerInfo: types.Staker{
Address: common.Address{},
TokenAddress: common.Address{},
Stake: nil,
StakerReward: big.NewInt(0),
},
stakerInfoErr: nil,
callOpts: bind.CallOpts{
Pending: false,
From: common.HexToAddress("0x000000000000000000000000000000000000dead"),
BlockNumber: big.NewInt(1),
},
stakerId: 1,
stakerIdErr: nil,
password: "test",
err: errors.New("no commission to claim"),
},
expectedFatal: false,
},
}

defer func() { log.ExitFunc = nil }()
Expand All @@ -93,14 +216,19 @@ func TestUtilsStruct_ClaimCommission(t *testing.T) {
transactionUtils = transactionUtilsMock

utilsMock.On("AssignLogFile", mock.AnythingOfType("*pflag.FlagSet"))
flagSetUtilsMock.On("GetStringAddress", mock.AnythingOfType("*pflag.FlagSet")).Return(tt.args.address, tt.args.addressErr)
cmdUtilsMock.On("GetConfigData").Return(tt.args.config, tt.args.configErr)
utilsMock.On("GetStakerId", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("string")).Return(tt.args.stakerId, tt.args.stakerIdErr)
utilsMock.On("GetOptions").Return(callOpts)
utilsMock.On("AssignPassword").Return(tt.args.password)
utilsMock.On("ConnectToClient", mock.AnythingOfType("string")).Return(client)
utilsMock.On("CheckEthBalanceIsZero", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("string")).Return()
utilsMock.On("GetTxnOpts", mock.AnythingOfType("types.TransactionOptions")).Return(txnOpts)
stakeManagerUtilsMock.On("ClaimStakeReward", mock.AnythingOfType("*ethclient.Client"), mock.Anything).Return(tt.args.txn, tt.args.err)
utilsMock.On("WaitForBlockCompletion", mock.AnythingOfType("*ethclient.Client"), mock.Anything).Return(nil)

stakeManagerUtilsMock.On("StakerInfo", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("*bind.CallOpts"), mock.AnythingOfType("uint32")).Return(tt.args.stakerInfo, tt.args.stakerInfoErr)
stakeManagerUtilsMock.On("ClaimStakeReward", mock.AnythingOfType("*ethclient.Client"), mock.Anything).Return(tt.args.txn, tt.args.err)

flagSetUtilsMock.On("GetStringAddress", mock.AnythingOfType("*pflag.FlagSet")).Return(tt.args.address, tt.args.addressErr)
cmdUtilsMock.On("GetConfigData").Return(tt.args.config, tt.args.configErr)
transactionUtilsMock.On("Hash", mock.Anything).Return(tt.args.hash)

utils := &UtilsStruct{}
Expand Down