Wrap some more errors

shuttermint/keyper/observe/mainchain.go

@@ -149,12 +149,12 @@ func (mainchain *MainChain) ConfigForBatchIndex(batchIndex uint64) (contract.Bat
 func (mainchain *MainChain) syncConfigs(cc *contract.Caller, opts *bind.CallOpts) error {
 	numConfigs, err := cc.ConfigContract.NumConfigs(opts)
 	if err != nil {
-		return err
+		return errors.Wrap(err, "failed to get number of configs from contract")
 	}
 	for configIndex := uint64(len(mainchain.BatchConfigs)); configIndex < numConfigs; configIndex++ {
 		config, err := cc.ConfigContract.GetConfigByIndex(opts, configIndex)
 		if err != nil {
-			return err
+			return errors.Wrap(err, "failed to get config by index from contract")
 		}
 		mainchain.BatchConfigs = append(mainchain.BatchConfigs, config)
 	}
@@ -164,15 +164,15 @@ func (mainchain *MainChain) syncConfigs(cc *contract.Caller, opts *bind.CallOpts
 func (mainchain *MainChain) syncBatches(cc *contract.Caller, filter *bind.FilterOpts) error {
 	it, err := cc.BatcherContract.FilterTransactionAdded(filter)
 	if err != nil {
-		return err
+		return errors.Wrap(err, "failed to filter for added transaction events")
 	}
 
 	events := []*contract.BatcherContractTransactionAdded{}
 	for it.Next() {
 		events = append(events, it.Event)
 	}
 	if it.Error() != nil {
-		return it.Error()
+		return errors.Wrap(it.Error(), "failed to iterate added transaction events")
 	}
 
 	for _, event := range events {
@@ -208,7 +208,7 @@ func (mainchain *MainChain) syncExecutionState(cc *contract.Caller, opts *bind.C
 
 	numExecutionHalfSteps, err := cc.ExecutorContract.NumExecutionHalfSteps(opts)
 	if err != nil {
-		return err
+		return errors.Wrap(err, "failed to get number of execution half steps from contract")
 	}
 
 	receipts := []contract.CipherExecutionReceipt{}
@@ -220,7 +220,7 @@ func (mainchain *MainChain) syncExecutionState(cc *contract.Caller, opts *bind.C
 
 		receipt, err := cc.ExecutorContract.CipherExecutionReceipts(opts, i)
 		if err != nil {
-			return err
+			return errors.Wrap(err, "failed to get cipher execution receipt from contract")
 		}
 		receipts = append(receipts, receipt)
 	}
@@ -236,15 +236,15 @@ func (mainchain *MainChain) syncExecutionState(cc *contract.Caller, opts *bind.C
 func (mainchain *MainChain) syncDeposits(cc *contract.Caller, filter *bind.FilterOpts) error {
 	eventIt, err := cc.DepositContract.FilterDepositChanged(filter, []common.Address{})
 	if err != nil {
-		return err
+		return errors.Wrap(err, "failed to filter for deposit changed events")
 	}
 
 	events := []*contract.DepositContractDepositChanged{}
 	for eventIt.Next() {
 		events = append(events, eventIt.Event)
 	}
 	if eventIt.Error() != nil {
-		return eventIt.Error()
+		return errors.Wrap(eventIt.Error(), "failed to iterate deposit changed events")
 	}
 
 	for _, ev := range events {
@@ -262,11 +262,11 @@ func (mainchain *MainChain) syncDeposits(cc *contract.Caller, filter *bind.Filte
 func (mainchain *MainChain) syncSlashings(cc *contract.Caller, filter *bind.FilterOpts) error {
 	accusedIt, err := cc.KeyperSlasher.FilterAccused(filter, []uint64{}, []common.Address{}, []common.Address{})
 	if err != nil {
-		return err
+		return errors.Wrap(err, "failed to filter accused events")
 	}
 	appealedIt, err := cc.KeyperSlasher.FilterAppealed(filter, []uint64{}, []common.Address{})
 	if err != nil {
-		return err
+		return errors.Wrap(err, "failed to filter appealed events")
 	}
 	// We don't filter for slashed events. Each slashing also results in a DepositChanged event in
 	// the deposit contract which we already sync.
@@ -276,15 +276,15 @@ func (mainchain *MainChain) syncSlashings(cc *contract.Caller, filter *bind.Filt
 		accusedEvents = append(accusedEvents, accusedIt.Event)
 	}
 	if accusedIt.Error() != nil {
-		return accusedIt.Error()
+		return errors.Wrap(accusedIt.Error(), "failed to iterate accused events")
 	}
 
 	appealedEvents := []*contract.KeyperSlasherAppealed{}
 	for appealedIt.Next() {
 		appealedEvents = append(appealedEvents, appealedIt.Event)
 	}
 	if appealedIt.Error() != nil {
-		return appealedIt.Error()
+		return errors.Wrap(appealedIt.Error(), "failed to iterate appealed events")
 	}
 
 	for _, ev := range accusedEvents {
@@ -341,12 +341,12 @@ func (mainchain *MainChain) SyncToHead(
 
 	syncProgress, err := cc.Ethclient.SyncProgress(ctx)
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to get sync progress")
+		return nil, errors.Wrap(err, "failed to get main chain sync progress")
 	}
 
 	latestBlockHeader, err := cc.Ethclient.HeaderByNumber(ctx, nil)
 	if err != nil {
-		return nil, err
+		return nil, errors.Wrap(err, "failed to get latest block header of main chain")
 	}
 
 	latestBlockNumber := latestBlockHeader.Number.Uint64()

shuttermint/keyper/observe/shutter.go

@@ -49,7 +49,7 @@ func (epk *EncryptionPublicKey) GobEncode() ([]byte, error) {
 func (epk *EncryptionPublicKey) GobDecode(data []byte) error {
 	pubkey, err := ethcrypto.UnmarshalPubkey(data)
 	if err != nil {
-		return err
+		return pkgErrors.Wrap(err, "failed to unmarshal encryption public key")
 	}
 	*epk = *(*EncryptionPublicKey)(ecies.ImportECDSAPublic(pubkey))
 	return nil
@@ -259,7 +259,7 @@ func (shutter *Shutter) fetchAndApplyEvents(ctx context.Context, shmcl client.Cl
 	for {
 		res, err := shmcl.TxSearch(ctx, query, false, &page, &perPage, "")
 		if err != nil {
-			return err
+			return pkgErrors.Wrap(err, "failed to fetch shuttermint txs")
 		}
 		total += len(res.Txs)
 		for _, tx := range res.Txs {
@@ -324,7 +324,7 @@ func (shutter *Shutter) Clone() *Shutter {
 func (shutter *Shutter) GetLastCommittedHeight(ctx context.Context, shmcl client.Client) (int64, error) {
 	latestBlock, err := shmcl.Block(ctx, nil)
 	if err != nil {
-		return 0, err
+		return 0, pkgErrors.Wrap(err, "failed to get last committed height of shuttermint chain")
 	}
 	if latestBlock.Block == nil || latestBlock.Block.LastCommit == nil {
 		return 0, pkgErrors.Errorf("empty blockchain: %+v", latestBlock)