refactor: removed fatal logs from GetTxnOpts()

cmd/addStake.go

@@ -105,7 +105,10 @@ func (*UtilsStruct) StakeCoins(rpcParameters rpc.RPCParameters, txnArgs types.Tr
 	txnArgs.MethodName = "stake"
 	txnArgs.Parameters = []interface{}{epoch, txnArgs.Amount}
 	txnArgs.ABI = bindings.StakeManagerMetaData.ABI
-	txnOpts := razorUtils.GetTxnOpts(rpcParameters, txnArgs)
+	txnOpts, err := razorUtils.GetTxnOpts(rpcParameters, txnArgs)
+	if err != nil {
+		return core.NilHash, err
+	}
 
 	client, err := rpcParameters.RPCManager.GetBestRPCClient()
 	if err != nil {

cmd/approve.go

@@ -25,7 +25,10 @@ func (*UtilsStruct) Approve(rpcParameters rpc.RPCParameters, txnArgs types.Trans
 		txnArgs.MethodName = "approve"
 		txnArgs.ABI = bindings.RAZORMetaData.ABI
 		txnArgs.Parameters = []interface{}{common.HexToAddress(core.StakeManagerAddress), txnArgs.Amount}
-		txnOpts := razorUtils.GetTxnOpts(rpcParameters, txnArgs)
+		txnOpts, err := razorUtils.GetTxnOpts(rpcParameters, txnArgs)
+		if err != nil {
+			return core.NilHash, err
+		}
 
 		client, err := rpcParameters.RPCManager.GetBestRPCClient()
 		if err != nil {

cmd/claimBounty.go

@@ -163,7 +163,10 @@ func (*UtilsStruct) ClaimBounty(rpcParameters rpc.RPCParameters, config types.Co
 		return core.NilHash, nil
 	}
 
-	txnOpts := razorUtils.GetTxnOpts(rpcParameters, txnArgs)
+	txnOpts, err := razorUtils.GetTxnOpts(rpcParameters, txnArgs)
+	if err != nil {
+		return core.NilHash, err
+	}
 	client, err := rpcParameters.RPCManager.GetBestRPCClient()
 	if err != nil {
 		return core.NilHash, err

cmd/claimCommission.go

@@ -38,7 +38,7 @@ func (*UtilsStruct) ClaimCommission(flagSet *pflag.FlagSet) {
 	log.Debugf("ClaimCommission: Staker Info: %+v", stakerInfo)
 
 	if stakerInfo.StakerReward.Cmp(big.NewInt(0)) > 0 {
-		txnOpts := razorUtils.GetTxnOpts(rpcParameters, types.TransactionOptions{
+		txnOpts, err := razorUtils.GetTxnOpts(rpcParameters, types.TransactionOptions{
 			ChainId:         core.ChainId,
 			Config:          config,
 			ContractAddress: core.StakeManagerAddress,
@@ -47,6 +47,7 @@ func (*UtilsStruct) ClaimCommission(flagSet *pflag.FlagSet) {
 			ABI:             bindings.StakeManagerMetaData.ABI,
 			Account:         account,
 		})
+		utils.CheckError("Error in getting txn options: ", err)
 
 		log.Info("Claiming commission...")
 

cmd/commit.go

@@ -151,7 +151,7 @@ func (*UtilsStruct) Commit(rpcParameters rpc.RPCParameters, config types.Configu
 		return core.NilHash, err
 	}
 
-	txnOpts := razorUtils.GetTxnOpts(rpcParameters, types.TransactionOptions{
+	txnOpts, err := razorUtils.GetTxnOpts(rpcParameters, types.TransactionOptions{
 		ChainId:         core.ChainId,
 		Config:          config,
 		ContractAddress: core.VoteManagerAddress,
@@ -160,6 +160,9 @@ func (*UtilsStruct) Commit(rpcParameters rpc.RPCParameters, config types.Configu
 		Parameters:      []interface{}{epoch, commitmentToSend},
 		Account:         account,
 	})
+	if err != nil {
+		return core.NilHash, err
+	}
 
 	log.Info("Commitment sent...")
 	client, err := rpcParameters.RPCManager.GetBestRPCClient()

cmd/confirm.go

@@ -46,7 +46,10 @@ func (*UtilsStruct) ClaimBlockReward(rpcParameters rpc.RPCParameters, options ty
 
 	if selectedProposedBlock.ProposerId == stakerID {
 		log.Info("Claiming block reward...")
-		txnOpts := razorUtils.GetTxnOpts(rpcParameters, options)
+		txnOpts, err := razorUtils.GetTxnOpts(rpcParameters, options)
+		if err != nil {
+			return core.NilHash, err
+		}
 
 		client, err := rpcParameters.RPCManager.GetBestRPCClient()
 		if err != nil {

cmd/createCollection.go

@@ -76,7 +76,7 @@ func (*UtilsStruct) CreateCollection(rpcParameters rpc.RPCParameters, config typ
 		log.Error("Error in fetching state")
 		return core.NilHash, err
 	}
-	txnOpts := razorUtils.GetTxnOpts(rpcParameters, types.TransactionOptions{
+	txnOpts, err := razorUtils.GetTxnOpts(rpcParameters, types.TransactionOptions{
 		ChainId:         core.ChainId,
 		Config:          config,
 		ContractAddress: core.CollectionManagerAddress,
@@ -85,6 +85,9 @@ func (*UtilsStruct) CreateCollection(rpcParameters rpc.RPCParameters, config typ
 		ABI:             bindings.CollectionManagerMetaData.ABI,
 		Account:         collectionInput.Account,
 	})
+	if err != nil {
+		return core.NilHash, err
+	}
 
 	client, err := rpcParameters.RPCManager.GetBestRPCClient()
 	if err != nil {

cmd/createJob.go

@@ -84,7 +84,10 @@ func (*UtilsStruct) CreateJob(rpcParameters rpc.RPCParameters, config types.Conf
 		Account:         jobInput.Account,
 	}
 
-	txnOpts := razorUtils.GetTxnOpts(rpcParameters, txnArgs)
+	txnOpts, err := razorUtils.GetTxnOpts(rpcParameters, txnArgs)
+	if err != nil {
+		return core.NilHash, err
+	}
 	log.Info("Creating Job...")
 
 	client, err := rpcParameters.RPCManager.GetBestRPCClient()

cmd/delegate.go

@@ -81,7 +81,10 @@ func (*UtilsStruct) Delegate(rpcParameters rpc.RPCParameters, txnArgs types.Tran
 	txnArgs.MethodName = "delegate"
 	txnArgs.ABI = bindings.StakeManagerMetaData.ABI
 	txnArgs.Parameters = []interface{}{stakerId, txnArgs.Amount}
-	delegationTxnOpts := razorUtils.GetTxnOpts(rpcParameters, txnArgs)
+	delegationTxnOpts, err := razorUtils.GetTxnOpts(rpcParameters, txnArgs)
+	if err != nil {
+		return core.NilHash, err
+	}
 	log.Info("Sending Delegate transaction...")
 
 	client, err := rpcParameters.RPCManager.GetBestRPCClient()

cmd/dispute.go

@@ -85,11 +85,15 @@ func (*UtilsStruct) HandleDispute(rpcParameters rpc.RPCParameters, config types.
 			log.Debug("Biggest Stake in proposed block: ", proposedBlock.BiggestStake)
 			log.Warn("PROPOSED BIGGEST STAKE DOES NOT MATCH WITH ACTUAL BIGGEST STAKE")
 			log.Info("Disputing BiggestStakeProposed...")
-			txnOpts := razorUtils.GetTxnOpts(rpcParameters, types.TransactionOptions{
+			txnOpts, err := razorUtils.GetTxnOpts(rpcParameters, types.TransactionOptions{
 				ChainId: core.ChainId,
 				Config:  config,
 				Account: account,
 			})
+			if err != nil {
+				log.Error(err)
+				continue
+			}
 
 			client, err := rpcParameters.RPCManager.GetBestRPCClient()
 			if err != nil {
@@ -277,7 +281,10 @@ func (*UtilsStruct) CheckDisputeForIds(rpcParameters rpc.RPCParameters, transact
 		transactionOpts.ABI = bindings.BlockManagerMetaData.ABI
 		transactionOpts.MethodName = "disputeOnOrderOfIds"
 		transactionOpts.Parameters = []interface{}{epoch, blockIndex, index0, index1}
-		txnOpts := razorUtils.GetTxnOpts(rpcParameters, transactionOpts)
+		txnOpts, err := razorUtils.GetTxnOpts(rpcParameters, transactionOpts)
+		if err != nil {
+			return nil, err
+		}
 
 		client, err := rpcParameters.RPCManager.GetBestRPCClient()
 		if err != nil {
@@ -295,7 +302,10 @@ func (*UtilsStruct) CheckDisputeForIds(rpcParameters rpc.RPCParameters, transact
 		transactionOpts.ABI = bindings.BlockManagerMetaData.ABI
 		transactionOpts.MethodName = "disputeCollectionIdShouldBePresent"
 		transactionOpts.Parameters = []interface{}{epoch, blockIndex, missingCollectionId}
-		txnOpts := razorUtils.GetTxnOpts(rpcParameters, transactionOpts)
+		txnOpts, err := razorUtils.GetTxnOpts(rpcParameters, transactionOpts)
+		if err != nil {
+			return nil, err
+		}
 		gasLimit := txnOpts.GasLimit
 		incrementedGasLimit, err := gasUtils.IncreaseGasLimitValue(rpcParameters, gasLimit, core.DisputeGasMultiplier)
 		if err != nil {
@@ -319,7 +329,10 @@ func (*UtilsStruct) CheckDisputeForIds(rpcParameters rpc.RPCParameters, transact
 		transactionOpts.ABI = bindings.BlockManagerMetaData.ABI
 		transactionOpts.MethodName = "disputeCollectionIdShouldBeAbsent"
 		transactionOpts.Parameters = []interface{}{epoch, blockIndex, presentCollectionId, big.NewInt(int64(positionOfPresentValue))}
-		txnOpts := razorUtils.GetTxnOpts(rpcParameters, transactionOpts)
+		txnOpts, err := razorUtils.GetTxnOpts(rpcParameters, transactionOpts)
+		if err != nil {
+			return nil, err
+		}
 		gasLimit := txnOpts.GasLimit
 		incrementedGasLimit, err := gasUtils.IncreaseGasLimitValue(rpcParameters, gasLimit, core.DisputeGasMultiplier)
 		if err != nil {
@@ -368,7 +381,10 @@ func (*UtilsStruct) Dispute(rpcParameters rpc.RPCParameters, config types.Config
 					end = end / 2
 				} else {
 					log.Error("Error in GiveSorted: ", err)
-					txnOpts := razorUtils.GetTxnOpts(rpcParameters, txnArgs)
+					txnOpts, err := razorUtils.GetTxnOpts(rpcParameters, txnArgs)
+					if err != nil {
+						return err
+					}
 					log.Debugf("Dispute: Calling CheckToDoResetDispute with arguments epoch = %d, sortedValues = %s", epoch, sortedValues)
 					cmdUtils.CheckToDoResetDispute(rpcParameters, txnOpts, epoch, sortedValues)
 					return err
@@ -397,7 +413,10 @@ func (*UtilsStruct) Dispute(rpcParameters rpc.RPCParameters, config types.Config
 	finalizeDisputeTxnArgs.MethodName = "finalizeDispute"
 	finalizeDisputeTxnArgs.ABI = bindings.BlockManagerMetaData.ABI
 	finalizeDisputeTxnArgs.Parameters = []interface{}{epoch, blockIndex, positionOfCollectionInBlock}
-	finalizeDisputeTxnOpts := razorUtils.GetTxnOpts(rpcParameters, finalizeDisputeTxnArgs)
+	finalizeDisputeTxnOpts, err := razorUtils.GetTxnOpts(rpcParameters, finalizeDisputeTxnArgs)
+	if err != nil {
+		return err
+	}
 
 	client, err := rpcParameters.RPCManager.GetBestRPCClient()
 	if err != nil {
@@ -437,7 +456,10 @@ func (*UtilsStruct) Dispute(rpcParameters rpc.RPCParameters, config types.Config
 	resetDisputeTxnArgs.MethodName = "resetDispute"
 	resetDisputeTxnArgs.ABI = bindings.BlockManagerMetaData.ABI
 	resetDisputeTxnArgs.Parameters = []interface{}{epoch}
-	resetDisputeTxnOpts := razorUtils.GetTxnOpts(rpcParameters, resetDisputeTxnArgs)
+	resetDisputeTxnOpts, err := razorUtils.GetTxnOpts(rpcParameters, resetDisputeTxnArgs)
+	if err != nil {
+		return err
+	}
 
 	cmdUtils.ResetDispute(rpcParameters, resetDisputeTxnOpts, epoch)
 
@@ -449,10 +471,14 @@ func GiveSorted(rpcParameters rpc.RPCParameters, txnArgs types.TransactionOption
 	if len(sortedValues) == 0 {
 		return errors.New("length of sortedValues is 0")
 	}
-	txnOpts := razorUtils.GetTxnOpts(rpcParameters, txnArgs)
+	txnOpts, err := razorUtils.GetTxnOpts(rpcParameters, txnArgs)
+	if err != nil {
+		log.Error("Error in getting txnOpts: ", err)
+		return err
+	}
 	disputesMapping, err := razorUtils.Disputes(rpcParameters, epoch, common.HexToAddress(txnArgs.Account.Address))
 	if err != nil {
-		log.Error("Error in getting disputes mapping: ", disputesMapping)
+		log.Error("Error in getting disputes mapping: ", err)
 		return err
 	}
 	log.Debugf("GiveSorted: Disputes mapping: %+v", disputesMapping)

cmd/initiateWithdraw.go

@@ -106,7 +106,10 @@ func (*UtilsStruct) HandleUnstakeLock(rpcParameters rpc.RPCParameters, account t
 		Parameters:      []interface{}{stakerId},
 		Account:         account,
 	}
-	txnOpts := razorUtils.GetTxnOpts(rpcParameters, txnArgs)
+	txnOpts, err := razorUtils.GetTxnOpts(rpcParameters, txnArgs)
+	if err != nil {
+		return core.NilHash, err
+	}
 
 	if big.NewInt(int64(epoch)).Cmp(unstakeLock.UnlockAfter) >= 0 && big.NewInt(int64(epoch)).Cmp(withdrawBefore) <= 0 {
 		log.Debug("Calling InitiateWithdraw() with arguments stakerId: ", stakerId)

cmd/modifyCollectionStatus.go

@@ -82,7 +82,10 @@ func (*UtilsStruct) ModifyCollectionStatus(rpcParameters rpc.RPCParameters, conf
 		Account:         modifyCollectionInput.Account,
 	}
 
-	txnOpts := razorUtils.GetTxnOpts(rpcParameters, txnArgs)
+	txnOpts, err := razorUtils.GetTxnOpts(rpcParameters, txnArgs)
+	if err != nil {
+		return core.NilHash, err
+	}
 	log.Infof("Changing active status of collection: %d from %t to %t", modifyCollectionInput.CollectionId, !modifyCollectionInput.Status, modifyCollectionInput.Status)
 	client, err := rpcParameters.RPCManager.GetBestRPCClient()
 	if err != nil {

cmd/propose.go

@@ -140,7 +140,7 @@ func (*UtilsStruct) Propose(rpcParameters rpc.RPCParameters, config types.Config
 	log.Debugf("Propose: Iteration: %d Biggest Staker Id: %d", iteration, biggestStakerId)
 	log.Info("Proposing block...")
 
-	txnOpts := razorUtils.GetTxnOpts(rpcParameters, types.TransactionOptions{
+	txnOpts, err := razorUtils.GetTxnOpts(rpcParameters, types.TransactionOptions{
 		ChainId:         core.ChainId,
 		Config:          config,
 		ContractAddress: core.BlockManagerAddress,
@@ -149,6 +149,9 @@ func (*UtilsStruct) Propose(rpcParameters rpc.RPCParameters, config types.Config
 		Parameters:      []interface{}{epoch, ids, medians, big.NewInt(int64(iteration)), biggestStakerId},
 		Account:         account,
 	})
+	if err != nil {
+		return err
+	}
 
 	client, err := rpcParameters.RPCManager.GetBestRPCClient()
 	if err != nil {

cmd/resetUnstakeLock.go

@@ -51,7 +51,7 @@ func (*UtilsStruct) ExecuteExtendLock(flagSet *pflag.FlagSet) {
 
 //This function is used to reset the lock once the withdraw lock period is over
 func (*UtilsStruct) ResetUnstakeLock(rpcParameters rpc.RPCParameters, config types.Configurations, extendLockInput types.ExtendLockInput) (common.Hash, error) {
-	txnOpts := razorUtils.GetTxnOpts(rpcParameters, types.TransactionOptions{
+	txnOpts, err := razorUtils.GetTxnOpts(rpcParameters, types.TransactionOptions{
 		ChainId:         core.ChainId,
 		Config:          config,
 		ContractAddress: core.StakeManagerAddress,
@@ -60,6 +60,9 @@ func (*UtilsStruct) ResetUnstakeLock(rpcParameters rpc.RPCParameters, config typ
 		ABI:             bindings.StakeManagerMetaData.ABI,
 		Account:         extendLockInput.Account,
 	})
+	if err != nil {
+		return core.NilHash, err
+	}
 
 	log.Info("Extending lock...")
 	client, err := rpcParameters.RPCManager.GetBestRPCClient()

cmd/reveal.go

@@ -55,7 +55,7 @@ func (*UtilsStruct) Reveal(rpcParameters rpc.RPCParameters, config types.Configu
 
 	log.Info("Revealing votes...")
 
-	txnOpts := razorUtils.GetTxnOpts(rpcParameters, types.TransactionOptions{
+	txnOpts, err := razorUtils.GetTxnOpts(rpcParameters, types.TransactionOptions{
 		ChainId:         core.ChainId,
 		Config:          config,
 		ContractAddress: core.VoteManagerAddress,

cmd/setDelegation.go

@@ -97,7 +97,11 @@ func (*UtilsStruct) SetDelegation(rpcParameters rpc.RPCParameters, config types.
 		return core.NilHash, nil
 	}
 	log.Infof("Setting delegation acceptance of Staker %d to %t", delegationInput.StakerId, delegationInput.Status)
-	setDelegationAcceptanceTxnOpts := razorUtils.GetTxnOpts(rpcParameters, txnOpts)
+	setDelegationAcceptanceTxnOpts, err := razorUtils.GetTxnOpts(rpcParameters, txnOpts)
+	if err != nil {
+		return core.NilHash, err
+	}
+
 	client, err := rpcParameters.RPCManager.GetBestRPCClient()
 	if err != nil {
 		return core.NilHash, err

cmd/transfer.go

@@ -80,7 +80,7 @@ func (*UtilsStruct) Transfer(rpcParameters rpc.RPCParameters, config types.Confi
 	log.Debug("Checking for sufficient balance...")
 	razorUtils.CheckAmountAndBalance(transferInput.ValueInWei, transferInput.Balance)
 
-	txnOpts := razorUtils.GetTxnOpts(rpcParameters, types.TransactionOptions{
+	txnOpts, err := razorUtils.GetTxnOpts(rpcParameters, types.TransactionOptions{
 		ChainId:         core.ChainId,
 		Config:          config,
 		ContractAddress: core.RAZORAddress,
@@ -89,6 +89,9 @@ func (*UtilsStruct) Transfer(rpcParameters rpc.RPCParameters, config types.Confi
 		ABI:             bindings.RAZORMetaData.ABI,
 		Account:         transferInput.Account,
 	})
+	if err != nil {
+		return core.NilHash, err
+	}
 	log.Infof("Transferring %g tokens from %s to %s", utils.GetAmountInDecimal(transferInput.ValueInWei), transferInput.Account.Address, transferInput.ToAddress)
 	client, err := rpcParameters.RPCManager.GetBestRPCClient()
 	if err != nil {

cmd/unlockWithdraw.go

@@ -84,7 +84,10 @@ func (*UtilsStruct) HandleWithdrawLock(rpcParameters rpc.RPCParameters, account
 			Parameters:      []interface{}{stakerId},
 			Account:         account,
 		}
-		txnOpts := razorUtils.GetTxnOpts(rpcParameters, txnArgs)
+		txnOpts, err := razorUtils.GetTxnOpts(rpcParameters, txnArgs)
+		if err != nil {
+			return core.NilHash, err
+		}
 		log.Debug("HandleWithdrawLock: Calling UnlockWithdraw() with arguments stakerId = ", stakerId)
 		return cmdUtils.UnlockWithdraw(rpcParameters, txnOpts, stakerId)
 	}

cmd/unstake.go

@@ -108,7 +108,10 @@ func (*UtilsStruct) Unstake(rpcParameters rpc.RPCParameters, config types.Config
 	}
 
 	txnArgs.Parameters = []interface{}{stakerId, txnArgs.Amount}
-	txnOpts := razorUtils.GetTxnOpts(rpcParameters, txnArgs)
+	txnOpts, err := razorUtils.GetTxnOpts(rpcParameters, txnArgs)
+	if err != nil {
+		return core.NilHash, err
+	}
 	log.Info("Unstaking coins")
 	client, err := rpcParameters.RPCManager.GetBestRPCClient()
 	if err != nil {
@@ -128,7 +131,10 @@ func (*UtilsStruct) Unstake(rpcParameters rpc.RPCParameters, config types.Config
 
 //This function approves the unstake
 func (*UtilsStruct) ApproveUnstake(rpcParameters rpc.RPCParameters, stakerTokenAddress common.Address, txnArgs types.TransactionOptions) (common.Hash, error) {
-	txnOpts := razorUtils.GetTxnOpts(rpcParameters, txnArgs)
+	txnOpts, err := razorUtils.GetTxnOpts(rpcParameters, txnArgs)
+	if err != nil {
+		return core.NilHash, err
+	}
 	client, err := rpcParameters.RPCManager.GetBestRPCClient()
 	if err != nil {
 		return core.NilHash, err

cmd/updateCollection.go

@@ -74,7 +74,7 @@ func (*UtilsStruct) UpdateCollection(rpcParameters rpc.RPCParameters, config typ
 		log.Error("Error in fetching state")
 		return core.NilHash, err
 	}
-	txnOpts := razorUtils.GetTxnOpts(rpcParameters, types.TransactionOptions{
+	txnOpts, err := razorUtils.GetTxnOpts(rpcParameters, types.TransactionOptions{
 		ChainId:         core.ChainId,
 		Config:          config,
 		ContractAddress: core.CollectionManagerAddress,
@@ -83,6 +83,9 @@ func (*UtilsStruct) UpdateCollection(rpcParameters rpc.RPCParameters, config typ
 		ABI:             bindings.CollectionManagerMetaData.ABI,
 		Account:         collectionInput.Account,
 	})
+	if err != nil {
+		return core.NilHash, err
+	}
 	log.Info("Updating collection...")
 	client, err := rpcParameters.RPCManager.GetBestRPCClient()
 	if err != nil {