Merge remote-tracking branch 'upstream/main' into ux-feedback

.circleci/config.yml

@@ -1,40 +1,26 @@
 # Use the latest 2.1 version of CircleCI pipeline process engine. See: https://circleci.com/docs/2.0/configuration-reference
 version: 2.1
-orbs:
-  node: circleci/node@4.7.0
 jobs:
   test:
     docker:
-      - image: circleci/golang:1.15.8
+      - image: cimg/go:1.17.6
     steps:
       - checkout
+      - setup_remote_docker:
+          version: 20.10.7
+          docker_layer_caching: true
       - run:
-          name: Install go-ethereum and abigen
-          command: |
-            go get -u github.com/ethereum/go-ethereum@v1.10.6
-            go install github.com/ethereum/go-ethereum/cmd/abigen
-      - node/install:
-          install-yarn: false
-      - run: node --version
-      - node/install-packages:
-          override-ci-command: npm install
-      - run: npm run setup
-      - run:
-          name: Install Project Dependencies
-          command: go mod download
-      - run:
-          name: "Install Dependencies"
+          name: "Building docker image"
           command: |
-            go get github.com/mattn/goveralls
-            go get -u github.com/ory/go-acc
+            docker build --file Dockerfile.test -t razor-test .
       - run:
-          name: "Generate Coverage"
+          name: "Executing test cases"
           command: |
-            go-acc ./... --ignore pkg
+            docker run --rm -v $(pwd):/test --name go  razor-test go-acc ./... --ignore razor/accounts/mocks --ignore razor/cmd/mocks --ignore razor/utils/mocks --ignore pkg --output /test/coverage.txt
       - run:
           name: "Publish Coverage to Coveralls.io"
           command: |
-            goveralls -coverprofile=coverage.txt -service semaphore -repotoken $COVERALLS_TOKEN
+            docker run --rm -v $(pwd):/test --name go -e COVERALLS_TOKEN=$COVERALLS_TOKEN razor-test goveralls -coverprofile=/test/coverage.txt -service semaphore -repotoken $COVERALLS_TOKEN
       - persist_to_workspace:
           root: .
           paths:

.gitignore

@@ -7,6 +7,7 @@
 
 # Test binary, built with `go test -c`
 *.test
+!Dockerfile.test
 
 # Output of the go coverage tool, specifically when used with LiteIDE
 *.out

Dockerfile.test

@@ -0,0 +1,12 @@
+FROM node:16.2.0-alpine AS builder
+WORKDIR /app
+COPY package.json package.json 
+RUN npm install 
+
+FROM golang:1.17 as ethereum
+RUN apt update && apt install jq -y
+WORKDIR /app
+RUN go get -d github.com/ethereum/go-ethereum@v1.10.8 && go install github.com/ethereum/go-ethereum/cmd/abigen@v1.10.8 && go install github.com/mattn/goveralls@v0.0.11 && go install github.com/ory/go-acc@v0.2.7
+COPY --from=builder /app/node_modules node_modules
+COPY . .
+RUN make setup

README.md

@@ -217,7 +217,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
@@ -232,7 +232,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/addStake.go

@@ -2,13 +2,14 @@ package cmd
 
 import (
 	"context"
-	"github.com/spf13/pflag"
 	"razor/accounts"
 	"razor/core"
 	"razor/core/types"
 	"razor/pkg/bindings"
 	"razor/utils"
 
+	"github.com/spf13/pflag"
+
 	"github.com/ethereum/go-ethereum/common"
 
 	"github.com/spf13/cobra"

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