Merge pull request #535 from razor-network/v0.2.0-incentnet-prod

V0.2.0 incentnet prod

README.md

@@ -234,7 +234,7 @@ If you are a staker you can accept delegation from delegators and charge a commi
 razor cli
 
 ```
-$ ./razor setDelegation --address <address> --status <true_or_false>
+$ ./razor setDelegation --address <address> --status <true_or_false> --commission <commission_percent>
 ```
 
 docker
@@ -249,7 +249,7 @@ docker run -it --rm \
 Example:
 
 ```
-$ ./razor setDelegation --address 0x5a0b54d5dc17e0aadc383d2db43b0a0d3e029c4c --status true
+$ ./razor setDelegation --address 0x5a0b54d5dc17e0aadc383d2db43b0a0d3e029c4c --status true -c 20
 ```
 
 ### Update Commission

addresses.json

@@ -1,12 +1,12 @@
 {
-  "Governance": "0x9ef0Df1B4EcC16E5BCe526460B21bf3e1E558Ab5",
-  "BlockManager": "0xAa06FecAFA59Bf7a046bD98B43842DE01daf3Bc4",
-  "AssetManager": "0x179c83a6db2DC576F58529d4ba0F61cd0B7DEa3C",
-  "StakeManager": "0x806B15eB732Bf36c7b1028BD8f654D97A64e537F",
-  "RewardManager": "0x54b2a04F7c7e169D9F8C492A56e320c8e3587C39",
-  "VoteManager": "0x8DF29d11A07Fb9DC9f2B9098f33D9d6cfBcb8E90",
-  "Delegator": "0x781f879c2B89186391674147a9aEA227509d5bC5",
-  "RAZOR": "0x4C9c41252C1a6ccE9D1996Cc0953753CDA2d468f",
-  "StakedTokenFactory": "0xe5C029F4F433bb094bd276dAC382Ce543c77B668",
-  "RandomNoManager": "0x4164c4d37B88bc77d567f5F5Bc3b0d7c8034207E"
+  "Governance": "0x7b935BAA1Ff1f81F7996334bbd04aD87786821A2",
+  "BlockManager": "0x834FA3b094De9fC678144610d027DfB32380939b",
+  "AssetManager": "0xCadcC6785c98a9B387CAf15e27152c036BED7f9c",
+  "StakeManager": "0x075F5F9987a931a193392fd3bC1F8811E0E86d8F",
+  "RewardManager": "0xCfe850f08f3Bbdf518a46D8142A657eC3EcFdc18",
+  "VoteManager": "0x6D3829b81733F83Fc996c9c20736669b96508C7B",
+  "Delegator": "0xBc04568c7Fc9408C0e32Fdd3715D81258aE32634",
+  "RAZOR": "0xA792597Ec3C7C02CBf911A7131ceE46B3a002d97",
+  "StakedTokenFactory": "0xd10C19DD427ea6D1245E4637b843e84836b100C6",
+  "RandomNoManager": "0xb605E2E7134DD3B8BC1C06494bf34cb121ebAc29"
 }

cmd/confirm.go

@@ -8,13 +8,47 @@ import (
 )
 
 func (*UtilsStruct) ClaimBlockReward(options types.TransactionOptions) (common.Hash, error) {
-	log.Info("Claiming block reward...")
-	txnOpts := razorUtils.GetTxnOpts(options)
-	txn, err := blockManagerUtils.ClaimBlockReward(options.Client, txnOpts)
+	epoch, err := razorUtils.GetEpoch(options.Client)
 	if err != nil {
-		log.Error("Error in claiming block reward: ", err)
+		log.Error("Error in getting epoch: ", err)
 		return core.NilHash, err
 	}
-	log.Info("Txn Hash: ", transactionUtils.Hash(txn).Hex())
-	return transactionUtils.Hash(txn), nil
+
+	sortedProposedBlockIds, err := razorUtils.GetSortedProposedBlockIds(options.Client, epoch)
+	if err != nil {
+		log.Error("Error in getting sortedProposedBlockIds: ", err)
+		return core.NilHash, err
+	}
+
+	if sortedProposedBlockIds == nil {
+		log.Debug("No blocks proposed in this epoch")
+		return core.NilHash, nil
+	}
+
+	stakerID, err := razorUtils.GetStakerId(options.Client, options.AccountAddress)
+	if err != nil {
+		log.Error("Error in getting stakerId: ", err)
+		return core.NilHash, err
+	}
+
+	selectedProposedBlock, err := razorUtils.GetProposedBlock(options.Client, epoch, sortedProposedBlockIds[0])
+	if err != nil {
+		log.Error("Error in getting selectedProposedBlock: ", err)
+		return core.NilHash, err
+	}
+
+	if selectedProposedBlock.ProposerId == stakerID {
+		log.Info("Claiming block reward...")
+		txnOpts := razorUtils.GetTxnOpts(options)
+		txn, err := blockManagerUtils.ClaimBlockReward(options.Client, txnOpts)
+		if err != nil {
+			log.Error("Error in claiming block reward: ", err)
+			return core.NilHash, err
+		}
+		log.Info("Txn Hash: ", transactionUtils.Hash(txn).Hex())
+		return transactionUtils.Hash(txn), nil
+	}
+
+	log.Debug("Only selected block proposer can claim block reward")
+	return core.NilHash, nil
 }

cmd/confirm_test.go

@@ -10,6 +10,7 @@ import (
 	"razor/cmd/mocks"
 	"razor/core"
 	"razor/core/types"
+	"razor/pkg/bindings"
 	"testing"
 
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
@@ -24,10 +25,18 @@ func TestClaimBlockReward(t *testing.T) {
 	txnOpts, _ := bind.NewKeyedTransactorWithChainID(privateKey, big.NewInt(1))
 
 	type args struct {
-		txnOpts             *bind.TransactOpts
-		ClaimBlockRewardTxn *Types.Transaction
-		ClaimBlockRewardErr error
-		hash                common.Hash
+		epoch                     uint32
+		epochErr                  error
+		stakerId                  uint32
+		stakerIdErr               error
+		sortedProposedBlockIds    []uint32
+		sortedProposedBlockIdsErr error
+		selectedBlock             bindings.StructsBlock
+		selectedBlockErr          error
+		txnOpts                   *bind.TransactOpts
+		ClaimBlockRewardTxn       *Types.Transaction
+		ClaimBlockRewardErr       error
+		hash                      common.Hash
 	}
 	tests := []struct {
 		name    string
@@ -36,27 +45,97 @@ func TestClaimBlockReward(t *testing.T) {
 		wantErr error
 	}{
 		{
-			name: "Test1: When ClaimBlockReward function executes successfully",
+			name: "Test 1: When ClaimBlockReward function executes successfully",
 			args: args{
-				txnOpts:             txnOpts,
-				ClaimBlockRewardTxn: &Types.Transaction{},
-				ClaimBlockRewardErr: nil,
-				hash:                common.BigToHash(big.NewInt(1)),
+				epoch:                  5,
+				stakerId:               2,
+				sortedProposedBlockIds: []uint32{2, 1, 3},
+				selectedBlock:          bindings.StructsBlock{ProposerId: 2},
+				txnOpts:                txnOpts,
+				ClaimBlockRewardTxn:    &Types.Transaction{},
+				ClaimBlockRewardErr:    nil,
+				hash:                   common.BigToHash(big.NewInt(1)),
 			},
 			want:    common.BigToHash(big.NewInt(1)),
 			wantErr: nil,
 		},
 		{
-			name: "Test2: When ClaimBlockReward transaction fails",
+			name: "Test 2: When ClaimBlockReward transaction fails",
 			args: args{
-				txnOpts:             txnOpts,
-				ClaimBlockRewardTxn: &Types.Transaction{},
-				ClaimBlockRewardErr: errors.New("claimBlockReward error"),
-				hash:                common.BigToHash(big.NewInt(1)),
+				epoch:                  5,
+				stakerId:               2,
+				sortedProposedBlockIds: []uint32{2, 1, 3},
+				selectedBlock:          bindings.StructsBlock{ProposerId: 2},
+				txnOpts:                txnOpts,
+				ClaimBlockRewardTxn:    &Types.Transaction{},
+				ClaimBlockRewardErr:    errors.New("claimBlockReward error"),
+				hash:                   common.BigToHash(big.NewInt(1)),
 			},
 			want:    core.NilHash,
 			wantErr: errors.New("claimBlockReward error"),
 		},
+		{
+			name: "Test 3: When there is an error in getting epoch",
+			args: args{
+				epochErr: errors.New("epoch error"),
+			},
+			want:    core.NilHash,
+			wantErr: errors.New("epoch error"),
+		},
+		{
+			name: "Test 4: When there is an error in getting stakerId",
+			args: args{
+				sortedProposedBlockIds: []uint32{2, 1, 3},
+				epoch:                  5,
+				stakerIdErr:            errors.New("stakerId error"),
+			},
+			want:    core.NilHash,
+			wantErr: errors.New("stakerId error"),
+		},
+		{
+			name: "Test 5: When there is an error in getting sortedProposedBlockIds",
+			args: args{
+				epoch:                     5,
+				stakerId:                  2,
+				sortedProposedBlockIdsErr: errors.New("sortedProposedBlockIds error"),
+			},
+			want:    core.NilHash,
+			wantErr: errors.New("sortedProposedBlockIds error"),
+		},
+		{
+			name: "Test 6: When there is an error in getting proposedBlock",
+			args: args{
+				epoch:                  5,
+				stakerId:               2,
+				sortedProposedBlockIds: []uint32{2, 1, 3},
+				selectedBlockErr:       errors.New("block error"),
+			},
+			want:    core.NilHash,
+			wantErr: errors.New("block error"),
+		},
+		{
+			name: "Test 7: When stakerId != proposerId and ClaimBlockReward function executes successfully",
+			args: args{
+				epoch:                  5,
+				stakerId:               3,
+				sortedProposedBlockIds: []uint32{2, 1, 3},
+				selectedBlock:          bindings.StructsBlock{ProposerId: 2},
+				txnOpts:                txnOpts,
+				ClaimBlockRewardTxn:    &Types.Transaction{},
+				ClaimBlockRewardErr:    nil,
+				hash:                   common.BigToHash(big.NewInt(1)),
+			},
+			want:    core.NilHash,
+			wantErr: nil,
+		},
+		{
+			name: "Test 8: When sortedProposedBlockIds is nil",
+			args: args{
+				sortedProposedBlockIds: nil,
+			},
+			want:    core.NilHash,
+			wantErr: nil,
+		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
@@ -69,6 +148,10 @@ func TestClaimBlockReward(t *testing.T) {
 			blockManagerUtils = blockManagerMock
 			transactionUtils = transactionUtilsMock
 
+			utilsMock.On("GetEpoch", mock.AnythingOfType("*ethclient.Client")).Return(tt.args.epoch, tt.args.epochErr)
+			utilsMock.On("GetSortedProposedBlockIds", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("uint32")).Return(tt.args.sortedProposedBlockIds, tt.args.sortedProposedBlockIdsErr)
+			utilsMock.On("GetStakerId", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("string")).Return(tt.args.stakerId, tt.args.stakerIdErr)
+			utilsMock.On("GetProposedBlock", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("uint32"), mock.AnythingOfType("uint32")).Return(tt.args.selectedBlock, tt.args.selectedBlockErr)
 			utilsMock.On("GetTxnOpts", options).Return(tt.args.txnOpts)
 			blockManagerMock.On("ClaimBlockReward", mock.AnythingOfType("*ethclient.Client"), mock.AnythingOfType("*bind.TransactOpts")).Return(tt.args.ClaimBlockRewardTxn, tt.args.ClaimBlockRewardErr)
 			transactionUtilsMock.On("Hash", mock.AnythingOfType("*types.Transaction")).Return(tt.args.hash)

cmd/interface.go

@@ -3,17 +3,18 @@ package cmd
 import (
 	"context"
 	"crypto/ecdsa"
+	"math/big"
+	"razor/core/types"
+	"razor/pkg/bindings"
+	"time"
+
 	"github.com/ethereum/go-ethereum/accounts"
 	"github.com/ethereum/go-ethereum/accounts/abi"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
 	Types "github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/spf13/pflag"
-	"math/big"
-	"razor/core/types"
-	"razor/pkg/bindings"
-	"time"
 )
 
 //go:generate mockery --name UtilsInterface --output ./mocks/ --case=underscore

cmd/setDelegation.go

@@ -1,14 +1,15 @@
 package cmd
 
 import (
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/ethclient"
-	"github.com/spf13/pflag"
 	"razor/core"
 	"razor/core/types"
 	"razor/pkg/bindings"
 	"razor/utils"
 
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/ethclient"
+	"github.com/spf13/pflag"
+
 	"github.com/spf13/cobra"
 )
 
@@ -47,12 +48,16 @@ func (*UtilsStruct) ExecuteSetDelegation(flagSet *pflag.FlagSet) {
 	stakerId, err := razorUtils.GetStakerId(client, address)
 	utils.CheckError("StakerId error: ", err)
 
+	commission, err := flagSetUtils.GetUint8Commission(flagSet)
+	utils.CheckError("Error in fetching commission: ", err)
+
 	delegationInput := types.SetDelegationInput{
 		Address:      address,
 		Password:     password,
 		Status:       status,
 		StatusString: statusString,
 		StakerId:     stakerId,
+		Commission:   commission,
 	}
 
 	txn, err := cmdUtils.SetDelegation(client, config, delegationInput)
@@ -67,6 +72,17 @@ func (*UtilsStruct) SetDelegation(client *ethclient.Client, config types.Configu
 	if err != nil {
 		return core.NilHash, err
 	}
+	if delegationInput.Commission != 0 {
+		err = cmdUtils.UpdateCommission(config, client, types.UpdateCommissionInput{
+			StakerId:   delegationInput.StakerId,
+			Address:    delegationInput.Address,
+			Password:   delegationInput.Password,
+			Commission: delegationInput.Commission,
+		})
+		if err != nil {
+			return core.NilHash, err
+		}
+	}
 
 	txnOpts := types.TransactionOptions{
 		Client:          client,
@@ -106,14 +122,16 @@ func init() {
 	rootCmd.AddCommand(setDelegationCmd)
 
 	var (
-		Status   string
-		Address  string
-		Password string
+		Status     string
+		Address    string
+		Password   string
+		Commission uint8
 	)
 
 	setDelegationCmd.Flags().StringVarP(&Status, "status", "s", "true", "true for accepting delegation and false for not accepting")
 	setDelegationCmd.Flags().StringVarP(&Address, "address", "a", "", "your account address")
 	setDelegationCmd.Flags().StringVarP(&Password, "password", "", "", "password path to protect the keystore")
+	setDelegationCmd.Flags().Uint8VarP(&Commission, "commission", "c", 0, "commission")
 
 	addrErr := setDelegationCmd.MarkFlagRequired("address")
 	utils.CheckError("Address error: ", addrErr)