diff --git a/cmd/tellor/argTypes.go b/cmd/tellor/argTypes.go
index a1768cc9..491fe2fe 100755
--- a/cmd/tellor/argTypes.go
+++ b/cmd/tellor/argTypes.go
@@ -41,7 +41,7 @@ type ETHAddress struct {
 func (a *ETHAddress) Set(v string) error {
 	valid := common.IsHexAddress(v)
 	if !valid {
-		return errors.Errorf("%s is not a valid etherum address format", v)
+		return errors.Errorf("%s valid etherum address format", v)
 	}
 	a.addr = common.HexToAddress(v)
 	return nil
diff --git a/pkg/apiOracle/valueOracle.go b/pkg/apiOracle/valueOracle.go
index 546adea6..4a4d0223 100755
--- a/pkg/apiOracle/valueOracle.go
+++ b/pkg/apiOracle/valueOracle.go
@@ -110,14 +110,14 @@ func EnsureValueOracle() error {
 		if os.IsNotExist(err) {
 			exists = false
 		} else {
-			return errors.Errorf("file %s stat error: %v", historyPath, err)
+			return errors.Wrapf(err, "stats for file: %v", historyPath)
 		}
 	}
 
 	if exists {
 		byteValue, err := ioutil.ReadFile(historyPath)
 		if err != nil {
-			return errors.Errorf("failed to read psr file @ %s: %v", historyPath, err)
+			return errors.Wrapf(err, "failed to read psr file @: %v", historyPath)
 		}
 		err = json.Unmarshal(byteValue, &valueHistory)
 		if err != nil {
diff --git a/pkg/config/config.go b/pkg/config/config.go
index b335ef6f..4d7602db 100755
--- a/pkg/config/config.go
+++ b/pkg/config/config.go
@@ -132,7 +132,7 @@ const PrivateKeyEnvName = "ETH_PRIVATE_KEY"
 func ParseConfig(path string) error {
 	data, err := ioutil.ReadFile(path)
 	if err != nil {
-		return errors.Errorf("failed to open config file %s: %v", path, err)
+		return errors.Wrapf(err, "to open config file: %v", path)
 	}
 
 	return ParseConfigBytes(data)
@@ -141,7 +141,7 @@ func ParseConfig(path string) error {
 func ParseConfigBytes(data []byte) error {
 	err := json.Unmarshal(data, &config)
 	if err != nil {
-		return errors.Errorf("failed to parse json: %s", err.Error())
+		return errors.Wrap(err, "to parse json")
 	}
 	// Check if the env is already set, only try loading .env if its not there.
 	if config.PrivateKey == "" {
@@ -152,7 +152,7 @@ func ParseConfigBytes(data []byte) error {
 
 		config.PrivateKey = os.Getenv(PrivateKeyEnvName)
 		if config.PrivateKey == "" {
-			return errors.Errorf("missing ethereum wallet private key environment variable '%s'", PrivateKeyEnvName)
+			return errors.Wrapf(err, "missing ethereum wallet private key environment variable '%v'", PrivateKeyEnvName)
 		}
 	}
 
@@ -169,7 +169,7 @@ func ParseConfigBytes(data []byte) error {
 
 	err = validateConfig(&config)
 	if err != nil {
-		return errors.Errorf("validation failed: %s", err)
+		return errors.Wrap(err, "validation")
 	}
 	return nil
 }
@@ -177,7 +177,7 @@ func ParseConfigBytes(data []byte) error {
 func validateConfig(cfg *Config) error {
 	b, err := hex.DecodeString(cfg.PublicAddress)
 	if err != nil || len(b) != 20 {
-		return errors.Errorf("expecting 40 hex character public address, got \"%s\"", cfg.PublicAddress)
+		return errors.Wrapf(err, "expecting 40 hex character public address, got \"%s\"", cfg.PublicAddress)
 	}
 	if cfg.EnablePoolWorker {
 		if len(cfg.Worker) == 0 {
@@ -189,18 +189,18 @@ func validateConfig(cfg *Config) error {
 	} else {
 		b, err = hex.DecodeString(cfg.PrivateKey)
 		if err != nil || len(b) != 32 {
-			return errors.Errorf("expecting 64 hex character private key, got \"%s\"", cfg.PrivateKey)
+			return errors.Wrapf(err, "expecting 64 hex character private key, got \"%s\"", cfg.PrivateKey)
 		}
 		if len(cfg.ContractAddress) != 42 {
-			return errors.Errorf("expecting 40 hex character contract address, got \"%s\"", cfg.ContractAddress)
+			return errors.Wrapf(err, "expecting 40 hex character contract address, got \"%s\"", cfg.ContractAddress)
 		}
 		b, err = hex.DecodeString(cfg.ContractAddress[2:])
 		if err != nil || len(b) != 20 {
-			return errors.Errorf("expecting 40 hex character contract address, got \"%s\"", cfg.ContractAddress)
+			return errors.Wrapf(err, "expecting 40 hex character contract address, got \"%s\"", cfg.ContractAddress)
 		}
 
 		if cfg.GasMultiplier < 0 || cfg.GasMultiplier > 20 {
-			return errors.Errorf("gas multiplier out of range [0, 20] %f", cfg.GasMultiplier)
+			return errors.Wrapf(err, "gas multiplier out of range [0, 20] %f", cfg.GasMultiplier)
 		}
 	}
 
@@ -209,13 +209,13 @@ func validateConfig(cfg *Config) error {
 			continue
 		}
 		if gpuConfig.Count == 0 {
-			return errors.Errorf("gpu '%s' requires 'count' > 0", name)
+			return errors.Wrapf(err, "gpu '%s' requires 'count' > 0", name)
 		}
 		if gpuConfig.GroupSize == 0 {
-			return errors.Errorf("gpu '%s' requires 'groupSize' > 0", name)
+			return errors.Wrapf(err, "gpu '%s' requires 'groupSize' > 0", name)
 		}
 		if gpuConfig.Groups == 0 {
-			return errors.Errorf("gpu '%s' requires 'groups' > 0", name)
+			return errors.Wrapf(err, "gpu '%s' requires 'groups' > 0", name)
 		}
 	}
 
diff --git a/pkg/db/remoteDataProxy.go b/pkg/db/remoteDataProxy.go
index c6407140..62150798 100755
--- a/pkg/db/remoteDataProxy.go
+++ b/pkg/db/remoteDataProxy.go
@@ -215,7 +215,7 @@ func (i *remoteImpl) BatchGet(keys []string) (map[string][]byte, error) {
 		return nil, err
 	}
 	if len(remResp.errorMsg) > 0 {
-		return nil, errors.Errorf(remResp.errorMsg)
+		return nil, errors.Wrapf(err, remResp.errorMsg)
 	}
 	return remResp.dbVals, nil
 }
@@ -254,7 +254,7 @@ func (i *remoteImpl) BatchPut(keys []string, values [][]byte) (map[string][]byte
 		return nil, err
 	}
 	if len(remResp.errorMsg) > 0 {
-		return nil, errors.Errorf(remResp.errorMsg)
+		return nil, errors.Wrapf(err, remResp.errorMsg)
 	}
 	return remResp.dbVals, nil
 }
diff --git a/pkg/db/remoteRequest.go b/pkg/db/remoteRequest.go
index 231a88de..bcac29d7 100755
--- a/pkg/db/remoteRequest.go
+++ b/pkg/db/remoteRequest.go
@@ -72,7 +72,7 @@ func createRequest(dbKeys []string, values [][]byte, signer RequestSigner) (*req
 	}
 	if sig == nil {
 		log.Error("Signature was not generated")
-		return nil, errors.Errorf("Could not generate a signature for  hash: %v", hash)
+		return nil, errors.Wrapf(err, "Could not generate a signature for  hash: %v", hash)
 	}
 	return &requestPayload{dbKeys: dbKeys, dbValues: values, timestamp: t, sig: sig}, nil
 }
diff --git a/pkg/ops/disputeOps.go b/pkg/ops/disputeOps.go
index 5b3c56dd..212b67d0 100755
--- a/pkg/ops/disputeOps.go
+++ b/pkg/ops/disputeOps.go
@@ -42,13 +42,13 @@ func Dispute(requestId *big.Int, timestamp *big.Int, minerIndex *big.Int, ctx co
 
 	balance, err := instance.BalanceOf(nil, addr)
 	if err != nil {
-		return errors.Errorf("failed to fetch balance: %s", err.Error())
+		return errors.Wrap(err, "to fetch balance")
 	}
 	var asBytes32 [32]byte
 	copy(asBytes32[:], "0x8b75eb45d88e80f0e4ec77d23936268694c0e7ac2e0c9085c5c6bdfcfbc49239") // keccak256(disputeFee).
 	disputeCost, err := instance.GetUintVar(nil, asBytes32)
 	if err != nil {
-		return errors.Errorf("failed to get dispute cost: %s", err)
+		return errors.Wrap(err, "to get dispute cost")
 	}
 
 	if balance.Cmp(disputeCost) < 0 {
@@ -59,13 +59,13 @@ func Dispute(requestId *big.Int, timestamp *big.Int, minerIndex *big.Int, ctx co
 
 	auth, err := PrepareEthTransaction(ctx)
 	if err != nil {
-		return errors.Errorf("failed to prepare ethereum transaction: %s", err.Error())
+		return errors.Wrapf(err, "to prepare ethereum transaction")
 	}
 
 	instance2 := ctx.Value(tellorCommon.ContractsTellorContextKey).(*tellor.Tellor)
 	tx, err := instance2.BeginDispute(auth, requestId, timestamp, minerIndex)
 	if err != nil {
-		return errors.Errorf("failed to send dispute txn: %s", err.Error())
+		return errors.Wrap(err, "to send dispute txn")
 	}
 	fmt.Printf("dispute started with txn: %s\n", tx.Hash().Hex())
 	return nil
@@ -77,7 +77,7 @@ func Vote(_disputeId *big.Int, _supportsDispute bool, ctx context.Context) error
 	addr := ctx.Value(tellorCommon.PublicAddress).(common.Address)
 	voted, err := instanceGetter.DidVote(nil, _disputeId, addr)
 	if err != nil {
-		return errors.Errorf("failed to check if you've already voted: %v", err)
+		return errors.Wrapf(err, "to check if you've already voted")
 	}
 	if voted {
 		fmt.Printf("You have already voted on this dispute\n")
@@ -88,11 +88,11 @@ func Vote(_disputeId *big.Int, _supportsDispute bool, ctx context.Context) error
 
 	auth, err := PrepareEthTransaction(ctx)
 	if err != nil {
-		return errors.Errorf("failed to prepare ethereum transaction: %s", err.Error())
+		return errors.Wrapf(err, "to prepare ethereum transaction")
 	}
 	tx, err := instanceTellor.Vote(auth, _disputeId, _supportsDispute)
 	if err != nil {
-		return errors.Errorf("failed to submit vote transaction: %s", err.Error())
+		return errors.Wrapf(err, "to submit vote transaction")
 	}
 
 	fmt.Printf("Vote submitted with transaction %s\n", tx.Hash().Hex())
@@ -103,7 +103,7 @@ func getNonceSubmissions(ctx context.Context, valueBlock *big.Int, dispute *tell
 	instance := ctx.Value(tellorCommon.ContractsGetterContextKey).(*getter.TellorGetters)
 	tokenAbi, err := abi.JSON(strings.NewReader(tellor.TellorLibraryABI))
 	if err != nil {
-		return nil, errors.Errorf("failed to parse abi: %v", err)
+		return nil, errors.Wrap(err, "to parse abi")
 	}
 	contractAddress := ctx.Value(tellorCommon.ContractAddress).(common.Address)
 	client := ctx.Value(tellorCommon.ClientContextKey).(rpc.ETHClient)
@@ -113,12 +113,12 @@ func getNonceSubmissions(ctx context.Context, valueBlock *big.Int, dispute *tell
 
 	allVals, err := instance.GetSubmissionsByTimestamp(nil, dispute.RequestId, dispute.Timestamp)
 	if err != nil {
-		return nil, errors.Errorf("failed to get other submitted values for dispute: %v", err)
+		return nil, errors.Wrap(err, "to get other submitted values for dispute")
 	}
 
 	allAddrs, err := instance.GetMinersByRequestIdAndTimestamp(nil, dispute.RequestId, dispute.Timestamp)
 	if err != nil {
-		return nil, errors.Errorf("failed to get miner addresses for dispute: %v", err)
+		return nil, errors.Wrap(err, "to get miner addresses for dispute")
 	}
 
 	const blockStep = 100
@@ -137,18 +137,18 @@ func getNonceSubmissions(ctx context.Context, valueBlock *big.Int, dispute *tell
 
 		logs, err := client.FilterLogs(ctx, query)
 		if err != nil {
-			return nil, errors.Errorf("failed to get nonce logs: %v", err)
+			return nil, errors.Wrap(err, "to get nonce logs")
 		}
 
 		for _, l := range logs {
 			nonceSubmit := tellor.TellorLibraryNonceSubmitted{}
 			err := bar.UnpackLog(&nonceSubmit, "NonceSubmitted", l)
 			if err != nil {
-				return nil, errors.Errorf("failed to unpack into object: %v", err)
+				return nil, errors.Wrap(err, "to unpack into object")
 			}
 			header, err := client.HeaderByNumber(ctx, big.NewInt(int64(l.BlockNumber)))
 			if err != nil {
-				return nil, errors.Errorf("failed to get nonce block header: %v", err)
+				return nil, errors.Wrap(err, "to get nonce block header")
 			}
 			for i := 0; i < 5; i++ {
 				if nonceSubmit.Miner == allAddrs[i] {
@@ -177,7 +177,7 @@ func List(ctx context.Context, logger log.Logger) error {
 	cfg := config.GetConfig()
 	tokenAbi, err := abi.JSON(strings.NewReader(tellor.TellorDisputeABI))
 	if err != nil {
-		return errors.Errorf("failed to parse abi: %v", err)
+		return errors.Wrap(err, "to parse abi")
 	}
 	contractAddress := ctx.Value(tellorCommon.ContractAddress).(common.Address)
 	client := ctx.Value(tellorCommon.ClientContextKey).(rpc.ETHClient)
@@ -187,7 +187,7 @@ func List(ctx context.Context, logger log.Logger) error {
 
 	header, err := client.HeaderByNumber(ctx, nil)
 	if err != nil {
-		return errors.Errorf("failed to get latest eth block header: %v", err)
+		return errors.Wrap(err, "to get latest eth block header")
 	}
 
 	startBlock := big.NewInt(10e3 * 14)
@@ -202,7 +202,7 @@ func List(ctx context.Context, logger log.Logger) error {
 
 	logs, err := client.FilterLogs(ctx, query)
 	if err != nil {
-		return errors.Errorf("failed to filter eth logs: %v", err)
+		return errors.Wrap(err, "to filter eth logs")
 	}
 
 	instance := ctx.Value(tellorCommon.ContractsGetterContextKey).(*getter.TellorGetters)
@@ -213,11 +213,11 @@ func List(ctx context.Context, logger log.Logger) error {
 		dispute := tellor.TellorDisputeNewDispute{}
 		err := bar.UnpackLog(&dispute, "NewDispute", rawDispute)
 		if err != nil {
-			return errors.Errorf("failed to unpack dispute event from logs: %v", err)
+			return errors.Wrap(err, "to unpack dispute event from logs")
 		}
 		_, executed, votePassed, _, reportedAddr, reportingMiner, _, uintVars, currTally, err := instance.GetAllDisputeVars(nil, dispute.DisputeId)
 		if err != nil {
-			return errors.Errorf("failed to get dispute details: %v", err)
+			return errors.Wrap(err, "to get dispute details")
 		}
 
 		votingEnds := time.Unix(uintVars[3].Int64(), 0)
@@ -245,7 +245,7 @@ func List(ctx context.Context, logger log.Logger) error {
 
 		allSubmitted, err := getNonceSubmissions(ctx, uintVars[5], &dispute)
 		if err != nil {
-			return errors.Errorf("failed to get the values submitted by other miners for the disputed block: %v", err)
+			return errors.Wrapf(err, "to get the values submitted by other miners for the disputed block")
 		}
 		disputedValTime := allSubmitted[uintVars[6].Uint64()].Created
 
diff --git a/pkg/ops/miningManager.go b/pkg/ops/miningManager.go
index dc40ee4e..79f2c1b1 100755
--- a/pkg/ops/miningManager.go
+++ b/pkg/ops/miningManager.go
@@ -71,7 +71,7 @@ func CreateMiningManager(
 
 	group, err := pow.SetupMiningGroup(cfg)
 	if err != nil {
-		return nil, errors.Errorf("failed to setup miners: %s", err.Error())
+		return nil, errors.Wrap(err, "to setup miners")
 	}
 
 	client, err := rpc.NewClient(cfg.NodeURL)
diff --git a/pkg/ops/stakeOps.go b/pkg/ops/stakeOps.go
index d3539b4b..b76cc908 100755
--- a/pkg/ops/stakeOps.go
+++ b/pkg/ops/stakeOps.go
@@ -56,12 +56,12 @@ func Deposit(ctx context.Context, logger log.Logger) error {
 	publicAddress := ctx.Value(tellorCommon.PublicAddress).(common.Address)
 	balance, err := tmaster.BalanceOf(nil, publicAddress)
 	if err != nil {
-		return errors.Errorf("couldn't get TRB balance: %s", err.Error())
+		return errors.Wrap(err, "get TRB balance")
 	}
 
 	status, startTime, err := tmaster.GetStakerInfo(nil, publicAddress)
 	if err != nil {
-		return errors.Errorf("failed to get stake status: %s", err.Error())
+		return errors.Wrap(err, "to get stake status")
 	}
 
 	if status.Uint64() != 0 && status.Uint64() != 2 {
@@ -74,11 +74,11 @@ func Deposit(ctx context.Context, logger log.Logger) error {
 	copy(dat32[:], dat)
 	stakeAmt, err := tmaster.GetUintVar(nil, dat32)
 	if err != nil {
-		return errors.Errorf("fetching stake amount failed: %s", err.Error())
+		return errors.Wrap(err, "fetching stake amount")
 	}
 
 	if balance.Cmp(stakeAmt) < 0 {
-		return errors.Errorf("insufficient balance (%s), mining stake requires %s TRB",
+		return errors.Wrapf(err, "insufficient balance (%s), mining stake requires %s TRB",
 			util.FormatERC20Balance(balance),
 			util.FormatERC20Balance(stakeAmt))
 	}
@@ -86,12 +86,12 @@ func Deposit(ctx context.Context, logger log.Logger) error {
 	instance2 := ctx.Value(tellorCommon.ContractsTellorContextKey).(*tellor.Tellor)
 	auth, err := PrepareEthTransaction(ctx)
 	if err != nil {
-		return errors.Errorf("couldn't prepare ethereum transaction: %s", err.Error())
+		return errors.Wrap(err, "prepare ethereum transaction")
 	}
 
 	tx, err := instance2.DepositStake(auth)
 	if err != nil {
-		return errors.Errorf("contract failed: %s", err.Error())
+		return errors.Wrap(err, "contract failed")
 	}
 	level.Info(logger).Log("msg", "stake depositied", "txHash", tx.Hash().Hex())
 	return nil
@@ -103,7 +103,7 @@ func ShowStatus(ctx context.Context, logger log.Logger) error {
 	publicAddress := ctx.Value(tellorCommon.PublicAddress).(common.Address)
 	status, startTime, err := tmaster.GetStakerInfo(nil, publicAddress)
 	if err != nil {
-		return errors.Errorf("failed to get stake status: %s", err.Error())
+		return errors.Wrap(err, "to get stake status")
 	}
 
 	printStakeStatus(status, startTime)
@@ -116,7 +116,7 @@ func RequestStakingWithdraw(ctx context.Context, logger log.Logger) error {
 	publicAddress := ctx.Value(tellorCommon.PublicAddress).(common.Address)
 	status, startTime, err := tmaster.GetStakerInfo(nil, publicAddress)
 	if err != nil {
-		return errors.Errorf("failed to get stake status: %s", err.Error())
+		return errors.Wrap(err, "to get stake status")
 	}
 	if status.Uint64() != 1 {
 		printStakeStatus(status, startTime)
@@ -125,13 +125,13 @@ func RequestStakingWithdraw(ctx context.Context, logger log.Logger) error {
 
 	auth, err := PrepareEthTransaction(ctx)
 	if err != nil {
-		return errors.Errorf("failed to prepare ethereum transaction: %s", err.Error())
+		return errors.Wrap(err, "to prepare ethereum transaction")
 	}
 
 	instance2 := ctx.Value(tellorCommon.ContractsTellorContextKey).(*tellor.Tellor)
 	tx, err := instance2.RequestStakingWithdraw(auth)
 	if err != nil {
-		return errors.Errorf("contract failed: %s", err.Error())
+		return errors.Wrap(err, "contract")
 	}
 
 	level.Info(logger).Log("msg", "withdrawal request sent", "txHash", tx.Hash().Hex())
@@ -144,7 +144,7 @@ func WithdrawStake(ctx context.Context, logger log.Logger) error {
 	publicAddress := ctx.Value(tellorCommon.PublicAddress).(common.Address)
 	status, startTime, err := tmaster.GetStakerInfo(nil, publicAddress)
 	if err != nil {
-		return errors.Errorf("failed to get stake status: %s", err.Error())
+		return errors.Wrap(err, "to get stake status")
 	}
 	if status.Uint64() != 2 {
 
@@ -155,13 +155,13 @@ func WithdrawStake(ctx context.Context, logger log.Logger) error {
 
 	auth, err := PrepareEthTransaction(ctx)
 	if err != nil {
-		return errors.Errorf("failed to prepare ethereum transaction: %s", err.Error())
+		return errors.Wrap(err, "to prepare ethereum transaction")
 	}
 
 	instance2 := ctx.Value(tellorCommon.ContractsTellorContextKey).(*tellor.Tellor)
 	tx, err := instance2.WithdrawStake(auth)
 	if err != nil {
-		return errors.Errorf("contract failed: %s", err.Error())
+		return errors.Wrap(err, "contract")
 	}
 	level.Info(logger).Log("msg", "withdrew stake", "txHash", tx.Hash().Hex())
 	return nil
diff --git a/pkg/ops/transferOps.go b/pkg/ops/transferOps.go
index a7ceeafe..533a3960 100755
--- a/pkg/ops/transferOps.go
+++ b/pkg/ops/transferOps.go
@@ -30,17 +30,17 @@ func prepareTransfer(amt *big.Int, ctx context.Context) (*bind.TransactOpts, err
 
 	balance, err := instance.BalanceOf(nil, senderPubAddr)
 	if err != nil {
-		return nil, errors.Errorf("failed to get balance: %v", err)
+		return nil, errors.Wrap(err, "to get balance")
 	}
 	fmt.Println("My balance", util.FormatERC20Balance(balance))
 	if balance.Cmp(amt) < 0 {
-		return nil, errors.Errorf("insufficient balance (%s TRB), requested %s TRB",
+		return nil, errors.Wrapf(err, "insufficient balance (%s TRB), requested %s TRB",
 			util.FormatERC20Balance(balance),
 			util.FormatERC20Balance(amt))
 	}
 	auth, err := PrepareEthTransaction(ctx)
 	if err != nil {
-		return nil, errors.Errorf("failed to prepare ethereum transaction: %s", err.Error())
+		return nil, errors.Wrap(err, "to prepare ethereum transaction")
 	}
 	return auth, nil
 }
@@ -54,7 +54,7 @@ func Transfer(ctx context.Context, logger log.Logger, toAddress common.Address,
 	instance2 := ctx.Value(tellorCommon.ContractsTellorContextKey).(*tellor.Tellor)
 	tx, err := instance2.Transfer(auth, toAddress, amt)
 	if err != nil {
-		return errors.Errorf("contract failed: %s", err.Error())
+		return errors.Wrap(err, "contract")
 	}
 	level.Info(logger).Log("msg", "transferred", "amount", util.FormatERC20Balance(amt), "to", toAddress.String()[:12], "tx Hash", tx.Hash().Hex())
 	return nil
@@ -78,7 +78,7 @@ func Approve(ctx context.Context, logger log.Logger, _spender common.Address, am
 func Balance(ctx context.Context, client rpc.ETHClient, getterInstance *getter.TellorGetters, addr common.Address) error {
 	ethBalance, err := client.BalanceAt(context.Background(), addr, nil)
 	if err != nil {
-		return errors.Errorf("problem getting balance: %+v", err)
+		return errors.Wrap(err, "problem getting balance")
 	}
 	trbBalance, err := getterInstance.BalanceOf(nil, addr)
 	if err != nil {
diff --git a/pkg/ops/util.go b/pkg/ops/util.go
index 38b13aad..69671a0e 100755
--- a/pkg/ops/util.go
+++ b/pkg/ops/util.go
@@ -23,23 +23,23 @@ func PrepareEthTransaction(ctx context.Context) (*bind.TransactOpts, error) {
 
 	nonce, err := client.PendingNonceAt(ctx, publicAddress)
 	if err != nil {
-		return nil, errors.Errorf("problem getting pending nonce: %+v", err)
+		return nil, errors.Wrap(err, "getting pending nonce")
 	}
 
 	gasPrice, err := client.SuggestGasPrice(ctx)
 	if err != nil {
-		return nil, errors.Errorf("problem getting gas price: %+v", err)
+		return nil, errors.Wrap(err, "getting gas price")
 	}
 
 	ethBalance, err := client.BalanceAt(ctx, publicAddress, nil)
 	if err != nil {
-		return nil, errors.Errorf("problem getting balance: %+v", err)
+		return nil, errors.Wrap(err, "getting balance")
 	}
 
 	cost := new(big.Int)
 	cost.Mul(gasPrice, big.NewInt(700000))
 	if ethBalance.Cmp(cost) < 0 {
-		return nil, errors.Errorf("insufficient ethereum to send a transaction: %v < %v", ethBalance, cost)
+		return nil, errors.Wrapf(err, "insufficient ethereum to send a transaction: %v < %v", ethBalance, cost)
 	}
 
 	privateKey := ctx.Value(tellorCommon.PrivateKey).(*ecdsa.PrivateKey)
diff --git a/pkg/pow/gpuMiner.go b/pkg/pow/gpuMiner.go
index cab325e5..94812010 100755
--- a/pkg/pow/gpuMiner.go
+++ b/pkg/pow/gpuMiner.go
@@ -69,7 +69,7 @@ func GetOpenCLGPUs() ([]*cl.Device, error) {
 				gpuLog.Info("Found 0 GPUs on platform %s\n", platform.Name())
 				continue
 			}
-			return nil, errors.Errorf("failed to get devices for platform %s: %s", platform.Name(), err.Error())
+			return nil, errors.Wrapf(err, "failed to get devices for platform %s", platform.Name())
 		}
 		gpus = append(gpus, devices...)
 	}
@@ -97,22 +97,22 @@ func NewGpuMiner(device *cl.Device, config *config.GPUConfig, poolEnabled bool)
 	g.name = device.Name()
 	g.context, err = cl.CreateContext([]*cl.Device{device})
 	if err != nil {
-		return nil, errors.Errorf("CreateContext failed: %+v", err)
+		return nil, errors.Wrap(err, "CreateContext")
 	}
 	g.queue, err = g.context.CreateCommandQueue(device, 0)
 	if err != nil {
-		return nil, errors.Errorf("CreateCommandQueue failed: %+v", err)
+		return nil, errors.Wrap(err, "CreateCommandQueue")
 	}
 	program, err := g.context.CreateProgramWithSource([]string{GenKernelSource()})
 	if err != nil {
-		return nil, errors.Errorf("CreateProgramWithSource failed: %+v", err)
+		return nil, errors.Wrap(err, "CreateProgramWithSource")
 	}
 	if err := program.BuildProgram(nil, "-Werror"); err != nil {
-		return nil, errors.Errorf("BuildProgram failed: %+v", err)
+		return nil, errors.Wrap(err, "BuildProgram")
 	}
 	g.kernel, err = program.CreateKernel("tellor")
 	if err != nil {
-		return nil, errors.Errorf("CreateKernel failed: %+v", err)
+		return nil, errors.Wrap(err, "CreateKernel failed")
 	}
 	if poolEnabled {
 		g.prefix, err = g.context.CreateEmptyBuffer(cl.MemReadOnly, 64)
@@ -120,15 +120,15 @@ func NewGpuMiner(device *cl.Device, config *config.GPUConfig, poolEnabled bool)
 		g.prefix, err = g.context.CreateEmptyBuffer(cl.MemReadOnly, 56)
 	}
 	if err != nil {
-		return nil, errors.Errorf("CreateBuffer failed for prefix: %+v", err)
+		return nil, errors.Wrap(err, "CreateBuffer failed for prefix")
 	}
 	g.mulDivisor, err = g.context.CreateEmptyBuffer(cl.MemReadOnly, 128)
 	if err != nil {
-		return nil, errors.Errorf("CreateBuffer failed for mulDivisor: %+v", err)
+		return nil, errors.Wrap(err, "CreateBuffer failed for mulDivisor")
 	}
 	g.output, err = g.context.CreateEmptyBuffer(cl.MemWriteOnly, 16)
 	if err != nil {
-		return nil, errors.Errorf("CreateBuffer failed for output: %+v", err)
+		return nil, errors.Wrap(err, "CreateBuffer failed for output")
 	}
 	return &g, nil
 }
@@ -145,23 +145,23 @@ func (g *GpuMiner) CheckRange(hash *HashSettings, start uint64, n uint64) (strin
 
 	_, err := g.queue.EnqueueWriteBuffer(g.prefix, true, 0, len(hash.prefix), unsafe.Pointer(&hash.prefix[0]), nil)
 	if err != nil {
-		return "", 0, errors.Errorf("EnqueueWriteBuffer hashPrefix failed: %+v", err)
+		return "", 0, errors.Wrap(err, "EnqueueWriteBuffer hashPrefix")
 	}
 	_, err = g.queue.EnqueueWriteBuffer(g.mulDivisor, true, 0, len(mulDivisorBytes), unsafe.Pointer(&mulDivisorBytes[0]), nil)
 	if err != nil {
-		return "", 0, errors.Errorf("EnqueueWriteBuffer mulDivisor failed: %+v", err)
+		return "", 0, errors.Wrap(err, "EnqueueWriteBuffer mulDivisor")
 	}
 
 	done := uint64(0)
 	for done < n {
 		if err := g.kernel.SetArgs(g.prefix, g.mulDivisor, g.output, start, g.Count); err != nil {
-			return "", done, errors.Errorf("SetKernelArgs failed: %+v", err)
+			return "", done, errors.Wrap(err, "SetKernelArgs")
 		}
 
 		kernelStarted := time.Now()
 		_, err := g.queue.EnqueueNDRangeKernel(g.kernel, nil, []int{g.Groups * g.GroupSize}, []int{g.GroupSize}, nil)
 		if err != nil {
-			return "", done, errors.Errorf("EnqueueNDRangeKernel failed: %+v", err)
+			return "", done, errors.Wrap(err, "EnqueueNDRangeKernel")
 		}
 		// flush the q then sleep while we wait for the kernel to finish
 		g.queue.Flush()
@@ -174,7 +174,7 @@ func (g *GpuMiner) CheckRange(hash *HashSettings, start uint64, n uint64) (strin
 		results := make([]byte, 16)
 		_, err = g.queue.EnqueueReadBuffer(g.output, true, 0, len(results), unsafe.Pointer(&results[0]), nil)
 		if err != nil {
-			return "", done, errors.Errorf("EnqueueReadBuffer failed: %+v", err)
+			return "", done, errors.Wrap(err, "EnqueueReadBuffer ")
 		}
 		end := time.Now()
 		totalTime := end.Sub(kernelStarted)
diff --git a/pkg/pow/miningSetup.go b/pkg/pow/miningSetup.go
index 1fe13b14..fdceaec6 100755
--- a/pkg/pow/miningSetup.go
+++ b/pkg/pow/miningSetup.go
@@ -28,7 +28,7 @@ func SetupMiningGroup(cfg *config.Config) (*MiningGroup, error) {
 		}
 		thisMiner, err := NewGpuMiner(gpu, gpuConfig, cfg.EnablePoolWorker)
 		if err != nil {
-			return nil, errors.Errorf("error initializing GPU %s: %s", gpu.Name(), err.Error())
+			return nil, errors.Wrapf(err, "initializing GPU %s", gpu.Name())
 		}
 		hashers = append(hashers, thisMiner)
 		fmt.Printf("%-20s groupSize:%d groups:%d count:%d\n", thisMiner.Name(), thisMiner.GroupSize, thisMiner.Groups, thisMiner.Count)
diff --git a/pkg/pow/solutionHandler.go b/pkg/pow/solutionHandler.go
index b229cb18..3393d800 100755
--- a/pkg/pow/solutionHandler.go
+++ b/pkg/pow/solutionHandler.go
@@ -89,7 +89,7 @@ func (s *SolutionHandler) Submit(ctx context.Context, result *Result) (*types.Tr
 					}
 					continue
 				}
-				return nil, errors.Errorf("no value in database,  reg id: %v", challenge.RequestIDs[i].Uint64())
+				return nil, errors.Wrapf(err, "no value in database,  reg id: %v", challenge.RequestIDs[i].Uint64())
 			}
 		}
 		s.currentValues[i] = value
diff --git a/pkg/rpc/contractRPC.go b/pkg/rpc/contractRPC.go
index 611109bd..e987a158 100755
--- a/pkg/rpc/contractRPC.go
+++ b/pkg/rpc/contractRPC.go
@@ -100,7 +100,7 @@ func SubmitContractTxn(ctx context.Context, proxy db.DataServerProxy, ctxName st
 		cost = cost.Mul(gasPrice, big.NewInt(200000))
 		if balance.Cmp(cost) < 0 {
 			// FIXME: notify someone that we're out of funds!
-			finalError = errors.Errorf("Insufficient funds to send transaction: %v < %v", balance, cost)
+			finalError = errors.Wrapf(err, "Insufficient funds to send transaction: %v < %v", balance, cost)
 			continue
 		}
 
diff --git a/pkg/tracker/disputeChecker.go b/pkg/tracker/disputeChecker.go
index 9264ca37..03013b20 100755
--- a/pkg/tracker/disputeChecker.go
+++ b/pkg/tracker/disputeChecker.go
@@ -105,7 +105,7 @@ func (c *disputeChecker) Exec(ctx context.Context) error {
 
 	header, err := client.HeaderByNumber(ctx, nil)
 	if err != nil {
-		return errors.Errorf("failed to get latest eth block header: %v", err)
+		return errors.Wrap(err, "to get latest eth block header")
 	}
 	if c.lastCheckedBlock == 0 {
 		c.lastCheckedBlock = header.Number.Uint64()
@@ -120,7 +120,7 @@ func (c *disputeChecker) Exec(ctx context.Context) error {
 
 	tokenAbi, err := abi.JSON(strings.NewReader(tellor.TellorLibraryABI))
 	if err != nil {
-		return errors.Errorf("failed to parse abi: %v", err)
+		return errors.Wrap(err, "to parse abi")
 	}
 	contractAddress := ctx.Value(tellorCommon.ContractAddress).(common.Address)
 
@@ -137,20 +137,20 @@ func (c *disputeChecker) Exec(ctx context.Context) error {
 	}
 	logs, err := client.FilterLogs(ctx, query)
 	if err != nil {
-		return errors.Errorf("failed to filter eth logs: %v", err)
+		return errors.Wrap(err, "to filter eth logs")
 	}
 	blockTimes := make(map[uint64]time.Time)
 	for _, l := range logs {
 		nonceSubmit := tellor.TellorLibraryNonceSubmitted{}
 		err := bar.UnpackLog(&nonceSubmit, "NonceSubmitted", l)
 		if err != nil {
-			return errors.Errorf("failed to unpack into object: %v", err)
+			return errors.Wrap(err, "to unpack into object")
 		}
 		blockTime, ok := blockTimes[l.BlockNumber]
 		if !ok {
 			header, err := client.HeaderByNumber(ctx, big.NewInt(int64(l.BlockNumber)))
 			if err != nil {
-				return errors.Errorf("failed to get nonce block header: %v", err)
+				return errors.Wrap(err, "to get nonce block header")
 			}
 			blockTime = time.Unix(int64(header.Time), 0)
 			blockTimes[l.BlockNumber] = blockTime
diff --git a/pkg/tracker/index.go b/pkg/tracker/index.go
index b884283f..4a939356 100755
--- a/pkg/tracker/index.go
+++ b/pkg/tracker/index.go
@@ -42,12 +42,12 @@ func BuildIndexTrackers() ([]Tracker, error) {
 	indexPath := filepath.Join(cfg.ConfigFolder, "indexes.json")
 	byteValue, err := ioutil.ReadFile(indexPath)
 	if err != nil {
-		return nil, errors.Errorf("failed to read index file @ %s: %v", indexPath, err)
+		return nil, errors.Wrapf(err, "to read index file @ %s", indexPath)
 	}
 	var baseIndexes map[string][]string
 	err = json.Unmarshal(byteValue, &baseIndexes)
 	if err != nil {
-		return nil, errors.Errorf("failed to parse index file: %v", err)
+		return nil, errors.Wrap(err, "to parse index file")
 	}
 
 	indexes = make(map[string][]*IndexTracker)
@@ -80,7 +80,7 @@ func BuildIndexTrackers() ([]Tracker, error) {
 					source = &JSONapi{&FetchRequest{queryURL: pathStr, timeout: cfg.FetchTimeout.Duration}}
 					u, err := url.Parse(pathStr)
 					if err != nil {
-						return nil, errors.Errorf("invalid API URL: %s: %v", pathStr, err)
+						return nil, errors.Wrapf(err, "invalid API URL: %s", pathStr)
 					}
 					name = u.Host
 				} else {
@@ -126,7 +126,7 @@ func BuildIndexTrackers() ([]Tracker, error) {
 	//start the PSR system that will feed from these indexes
 	err = InitPSRs()
 	if err != nil {
-		return nil, errors.Errorf("failed to initialize PSRs: %v", err)
+		return nil, errors.Wrap(err, "failed to initialize PSRs")
 	}
 
 	return trackers, nil
diff --git a/pkg/tracker/retryFetcher.go b/pkg/tracker/retryFetcher.go
index 3ca219a7..83f015f2 100755
--- a/pkg/tracker/retryFetcher.go
+++ b/pkg/tracker/retryFetcher.go
@@ -58,7 +58,7 @@ func _recFetch(req *FetchRequest, expiration time.Time) ([]byte, error) {
 	data, err := ioutil.ReadAll(r.Body)
 	r.Body.Close()
 	if err != nil {
-		return nil, errors.Errorf("failed to read response body: %v", err)
+		return nil, errors.Wrap(err, "to read response body")
 	}
 
 	if r.StatusCode < 200 || r.StatusCode > 299 {
@@ -67,7 +67,7 @@ func _recFetch(req *FetchRequest, expiration time.Time) ([]byte, error) {
 		// this is a duplicated error that is unlikely to be triggered since expiration is updated above
 		now := clck.Now()
 		if now.After(expiration) {
-			return nil, errors.Errorf("giving up fetch request after request timeout: %d", r.StatusCode)
+			return nil, errors.Wrapf(err, "giving up fetch request after request timeout: %d", r.StatusCode)
 		}
 		//FIXME: should this be configured as fetch error sleep duration?
 		time.Sleep(500 * time.Millisecond)
diff --git a/pkg/tracker/runner.go b/pkg/tracker/runner.go
index dbad6ccd..0ab4225f 100755
--- a/pkg/tracker/runner.go
+++ b/pkg/tracker/runner.go
@@ -41,7 +41,7 @@ func (r *Runner) Start(ctx context.Context, exitCh chan int) error {
 			level.Info(r.logger).Log("msg", "starting tracker", "name", name)
 			t, err := createTracker(name, r.logger)
 			if err != nil {
-				return errors.Errorf("problem creating tracker. Name: %s, err: %s", name, err)
+				return errors.Wrapf(err, "creating tracker. Name: %s", name)
 			}
 			trackers = append(trackers, t...)
 		}
@@ -61,7 +61,7 @@ func (r *Runner) Start(ctx context.Context, exitCh chan int) error {
 		contractAddress := common.HexToAddress(cfg.ContractAddress)
 		masterInstance, err = tellor.NewTellor(contractAddress, r.client)
 		if err != nil {
-			return errors.Errorf("Problem creating tellor master instance: %s", err)
+			return errors.Wrap(err, "creating tellor master instance")
 		}
 		ctx = context.WithValue(ctx, tellorCommon.ContractsTellorContextKey, masterInstance)
 	}
diff --git a/pkg/tracker/valueGenerators.go b/pkg/tracker/valueGenerators.go
index 67f6bb75..61ebc96a 100755
--- a/pkg/tracker/valueGenerators.go
+++ b/pkg/tracker/valueGenerators.go
@@ -41,7 +41,7 @@ func InitPSRs() error {
 		for symbol := range reqs {
 			_, ok := indexes[symbol]
 			if !ok {
-				return errors.Errorf("PSR %d requires non-existent symbol %s", requestID, symbol)
+				errors.Errorf("PSR %d requires non-existent symbol %s", requestID, symbol)
 			}
 		}
 	}
diff --git a/pkg/util/httpRetriever.go b/pkg/util/httpRetriever.go
index 4b65cb0f..78a2e9fe 100755
--- a/pkg/util/httpRetriever.go
+++ b/pkg/util/httpRetriever.go
@@ -66,7 +66,7 @@ func _recReq(req *HTTPFetchRequest, expiration time.Time) ([]byte, error) {
 		// Log local non-timeout errors for now.
 		now := time.Now()
 		if now.After(expiration) {
-			return nil, errors.Errorf("Giving up fetch request after request timeout: %d", r.StatusCode)
+			return nil, errors.Wrapf(err, "Giving up fetch request after request timeout: %d", r.StatusCode)
 		}
 		// FIXME: should this be configured as fetch error sleep duration?
 		time.Sleep(500 * time.Millisecond)
diff --git a/pkg/util/logConfig.go b/pkg/util/logConfig.go
index 347b8a4c..6f26b0f3 100755
--- a/pkg/util/logConfig.go
+++ b/pkg/util/logConfig.go
@@ -32,10 +32,10 @@ func ParseLoggingConfig(file string) error {
 	if len(file) > 0 {
 		info, err := os.Stat(file)
 		if os.IsNotExist(err) {
-			return errors.Errorf("loggingConfigPath references an invalid file at: %s", file)
+			return errors.Wrapf(err, "loggingConfigPath references an invalid file at: %s", file)
 		}
 		if info.IsDir() {
-			return errors.Errorf("logging config file %s is a directory", file)
+			return errors.Wrapf(err, "logging config file %s is a directory", file)
 		}
 
 		configFile, err := os.Open(file)
diff --git a/scripts/opencl/opencl.go b/scripts/opencl/opencl.go
index deb2ce20..8aa02af3 100755
--- a/scripts/opencl/opencl.go
+++ b/scripts/opencl/opencl.go
@@ -36,7 +36,7 @@ func compileSources() (string, error) {
 	dir := filepath.Join(filepath.Dir(filename), sourceDir)
 	files, err := ioutil.ReadDir(dir)
 	if err != nil {
-		return "", errors.Errorf("couldn't read directory %s: %s", dir, err.Error())
+		return "", errors.Wrapf(err, "read directory: %s", dir)
 	}
 
 	contents := make(map[string][]byte)
@@ -44,20 +44,20 @@ func compileSources() (string, error) {
 		filepath := filepath.Join(dir, file.Name())
 		data, err := ioutil.ReadFile(filepath)
 		if err != nil {
-			return "", errors.Errorf("couldn't read file %s: %s", filepath, err.Error())
+			return "", errors.Wrapf(err, "read file: %s", filepath)
 		}
 		contents[file.Name()] = data
 	}
 	var out strings.Builder
 	if _, ok := contents[headerFile]; !ok {
-		return "", errors.Errorf("missing %s file", headerFile)
+		return "", errors.Wrapf(err, "missing %s file", headerFile)
 	}
 	out.Write(contents[headerFile])
 	delete(contents, headerFile)
 
 	mainSrc, ok := contents[kernelFile]
 	if !ok {
-		return "", errors.Errorf("missing %s file", kernelFile)
+		return "", errors.Wrapf(err, "missing %s file", kernelFile)
 	}
 	delete(contents, kernelFile)