Reformat files with golines

schmir · schmir · commit 6d69a8c64b6b · 2023-10-05T16:47:04.000+02:00
diff --git a/rolling-shutter/app/app.go b/rolling-shutter/app/app.go
@@ -522,7 +522,10 @@ func (app *ShutterApp) handlePolyEvalMsg(msg *shmsg.PolyEval, sender common.Addr
 	}
 }
 
-func (app *ShutterApp) handlePolyCommitmentMsg(msg *shmsg.PolyCommitment, sender common.Address) abcitypes.ResponseDeliverTx {
+func (app *ShutterApp) handlePolyCommitmentMsg(
+	msg *shmsg.PolyCommitment,
+	sender common.Address,
+) abcitypes.ResponseDeliverTx {
 	appMsg, err := ParsePolyCommitmentMsg(msg, sender)
 	if err != nil {
 		msg := fmt.Sprintf("Error: Failed to parse PolyCommitment message: %+v", err)
@@ -717,7 +720,8 @@ func (app *ShutterApp) EndBlock(req abcitypes.RequestEndBlock) abcitypes.Respons
 				}.MakeABCIEvent())
 			}
 		}
-		if config.Started && !config.ValidatorsUpdated && app.countCheckedInKeypers(config.Keypers) >= numRequiredTransitionValidators(config) {
+		if config.Started && !config.ValidatorsUpdated &&
+			app.countCheckedInKeypers(config.Keypers) >= numRequiredTransitionValidators(config) {
 			config.ValidatorsUpdated = true
 		}
 	}
diff --git a/rolling-shutter/app/dkg.go b/rolling-shutter/app/dkg.go
@@ -40,7 +40,11 @@ func (dkg *DKGInstance) RegisterPolyEvalMsg(msg PolyEval) error {
 		}
 		_, ok := dkg.PolyEvalsSeen[SenderReceiverPair{sender, receiver}]
 		if ok {
-			return errors.Errorf("polynomial evaluation from keyper %s for receiver %s already present", sender.Hex(), receiver.Hex())
+			return errors.Errorf(
+				"polynomial evaluation from keyper %s for receiver %s already present",
+				sender.Hex(),
+				receiver.Hex(),
+			)
 		}
 	}
 
diff --git a/rolling-shutter/app/messages.go b/rolling-shutter/app/messages.go
@@ -28,7 +28,11 @@ func validateAddress(address []byte) (common.Address, error) {
 // ParsePolyEvalMsg converts a shmsg.PolyEvalMsg to an app.PolyEvalMsg.
 func ParsePolyEvalMsg(msg *shmsg.PolyEval, sender common.Address) (*PolyEval, error) {
 	if len(msg.Receivers) != len(msg.EncryptedEvals) {
-		return nil, errors.Errorf("number of receivers %d does not match number of evals %d", len(msg.Receivers), len(msg.EncryptedEvals))
+		return nil, errors.Errorf(
+			"number of receivers %d does not match number of evals %d",
+			len(msg.Receivers),
+			len(msg.EncryptedEvals),
+		)
 	}
 
 	receivers := []common.Address{}
@@ -95,7 +99,11 @@ func ParseAccusationMsg(msg *shmsg.Accusation, sender common.Address) (*Accusati
 // ParseApologyMsg converts a shmsg.ApologyMsg to an app.ApologyMsg.
 func ParseApologyMsg(msg *shmsg.Apology, sender common.Address) (*Apology, error) {
 	if len(msg.Accusers) != len(msg.PolyEvals) {
-		return nil, errors.Errorf("number of accusers %d and apology evals %d not equal", len(msg.Accusers), len(msg.PolyEvals))
+		return nil, errors.Errorf(
+			"number of accusers %d and apology evals %d not equal",
+			len(msg.Accusers),
+			len(msg.PolyEvals),
+		)
 	}
 
 	accusers := []common.Address{}
diff --git a/rolling-shutter/cmd/chain/init.go b/rolling-shutter/cmd/chain/init.go
@@ -211,7 +211,10 @@ func initFilesWithConfig(tendermintConfig *cfg.Config, config *Config, appState
 		if err != nil {
 			return errors.Wrapf(err, "Could not write to %s", validatorPubKeyPath)
 		}
-		log.Info().Str("path", validatorPubKeyPath).Str("validatorPublicKey", validatorPublicKeyHex).Msg("Saved private validator publickey")
+		log.Info().
+			Str("path", validatorPubKeyPath).
+			Str("validatorPublicKey", validatorPublicKeyHex).
+			Msg("Saved private validator publickey")
 
 		// genesis file
 		genFile := tendermintConfig.GenesisFile()
diff --git a/rolling-shutter/collator/batcher/batcher_test.go b/rolling-shutter/collator/batcher/batcher_test.go
@@ -97,7 +97,13 @@ func TestConfirmTransactionsIntegration(t *testing.T) {
 	assert.NilError(t, err)
 	assert.Equal(t, 5, len(txs), "should have exactly one tx: %+v", txs)
 	for nonce := 0; nonce < 5; nonce++ {
-		assert.Equal(t, cltrdb.TxstatusCommitted, txs[nonce].Status, "expected tx to have status committed: %+v", txs[nonce])
+		assert.Equal(
+			t,
+			cltrdb.TxstatusCommitted,
+			txs[nonce].Status,
+			"expected tx to have status committed: %+v",
+			txs[nonce],
+		)
 	}
 }
 
diff --git a/rolling-shutter/keyper/epochkghandler/eonpublickey.go b/rolling-shutter/keyper/epochkghandler/eonpublickey.go
@@ -25,7 +25,11 @@ func (*EonPublicKeyHandler) MessagePrototypes() []p2pmsg.Message {
 func (handler *EonPublicKeyHandler) ValidateMessage(_ context.Context, msg p2pmsg.Message) (bool, error) {
 	key := msg.(*p2pmsg.EonPublicKey)
 	if key.GetInstanceID() != handler.config.GetInstanceID() {
-		return false, errors.Errorf("instance ID mismatch (want=%d, have=%d)", handler.config.GetInstanceID(), key.GetInstanceID())
+		return false, errors.Errorf(
+			"instance ID mismatch (want=%d, have=%d)",
+			handler.config.GetInstanceID(),
+			key.GetInstanceID(),
+		)
 	}
 	return true, nil
 }
diff --git a/rolling-shutter/keyper/epochkghandler/key.go b/rolling-shutter/keyper/epochkghandler/key.go
@@ -33,7 +33,11 @@ func (*DecryptionKeyHandler) MessagePrototypes() []p2pmsg.Message {
 func (handler *DecryptionKeyHandler) ValidateMessage(ctx context.Context, msg p2pmsg.Message) (bool, error) {
 	key := msg.(*p2pmsg.DecryptionKey)
 	if key.GetInstanceID() != handler.config.GetInstanceID() {
-		return false, errors.Errorf("instance ID mismatch (want=%d, have=%d)", handler.config.GetInstanceID(), key.GetInstanceID())
+		return false, errors.Errorf(
+			"instance ID mismatch (want=%d, have=%d)",
+			handler.config.GetInstanceID(),
+			key.GetInstanceID(),
+		)
 	}
 	if _, err := epochid.BytesToEpochID(key.EpochID); err != nil {
 		return false, errors.Wrapf(err, "invalid epoch id")
diff --git a/rolling-shutter/keyper/epochkghandler/keyshare.go b/rolling-shutter/keyper/epochkghandler/keyshare.go
@@ -36,7 +36,11 @@ func (*DecryptionKeyShareHandler) MessagePrototypes() []p2pmsg.Message {
 func (handler *DecryptionKeyShareHandler) ValidateMessage(ctx context.Context, msg p2pmsg.Message) (bool, error) {
 	keyShare := msg.(*p2pmsg.DecryptionKeyShares)
 	if keyShare.GetInstanceID() != handler.config.GetInstanceID() {
-		return false, errors.Errorf("instance ID mismatch (want=%d, have=%d)", handler.config.GetInstanceID(), keyShare.GetInstanceID())
+		return false, errors.Errorf(
+			"instance ID mismatch (want=%d, have=%d)",
+			handler.config.GetInstanceID(),
+			keyShare.GetInstanceID(),
+		)
 	}
 	if keyShare.Eon > math.MaxInt64 {
 		return false, errors.Errorf("eon %d overflows int64", keyShare.Eon)
@@ -78,7 +82,10 @@ func (handler *DecryptionKeyShareHandler) ValidateMessage(ctx context.Context, m
 	return true, nil
 }
 
-func (handler *DecryptionKeyShareHandler) HandleMessage(ctx context.Context, m p2pmsg.Message) ([]p2pmsg.Message, error) {
+func (handler *DecryptionKeyShareHandler) HandleMessage(
+	ctx context.Context,
+	m p2pmsg.Message,
+) ([]p2pmsg.Message, error) {
 	metricsEpochKGDecryptionKeySharesReceived.Inc()
 	msg := m.(*p2pmsg.DecryptionKeyShares)
 	// Insert the share into the db. We assume that it's valid as it already passed the libp2p
diff --git a/rolling-shutter/keyper/epochkghandler/trigger.go b/rolling-shutter/keyper/epochkghandler/trigger.go
@@ -33,7 +33,11 @@ func (*DecryptionTriggerHandler) MessagePrototypes() []p2pmsg.Message {
 func (handler *DecryptionTriggerHandler) ValidateMessage(ctx context.Context, msg p2pmsg.Message) (bool, error) {
 	trigger := msg.(*p2pmsg.DecryptionTrigger)
 	if trigger.GetInstanceID() != handler.config.GetInstanceID() {
-		return false, errors.Errorf("instance ID mismatch (want=%d, have=%d)", handler.config.GetInstanceID(), trigger.GetInstanceID())
+		return false, errors.Errorf(
+			"instance ID mismatch (want=%d, have=%d)",
+			handler.config.GetInstanceID(),
+			trigger.GetInstanceID(),
+		)
 	}
 	if _, err := epochid.BytesToEpochID(trigger.EpochID); err != nil {
 		return false, errors.Wrapf(err, "invalid epoch id")
@@ -53,20 +57,31 @@ func (handler *DecryptionTriggerHandler) ValidateMessage(ctx context.Context, ms
 
 	collator, err := shdb.DecodeAddress(chainCollator.Collator)
 	if err != nil {
-		return false, errors.Wrapf(err, "error while converting collator from string to address: %s", chainCollator.Collator)
+		return false, errors.Wrapf(
+			err,
+			"error while converting collator from string to address: %s",
+			chainCollator.Collator,
+		)
 	}
 
 	signatureValid, err := p2pmsg.VerifySignature(trigger, collator)
 	if err != nil {
-		return false, errors.Wrapf(err, "error while verifying decryption trigger signature for epoch: %x", trigger.EpochID)
+		return false, errors.Wrapf(
+			err,
+			"error while verifying decryption trigger signature for epoch: %x",
+			trigger.EpochID,
+		)
 	}
 	if !signatureValid {
 		return false, errors.Errorf("decryption trigger signature invalid for epoch: %x", trigger.EpochID)
 	}
 	return signatureValid, nil
 }
 
-func (handler *DecryptionTriggerHandler) HandleMessage(ctx context.Context, m p2pmsg.Message) ([]p2pmsg.Message, error) {
+func (handler *DecryptionTriggerHandler) HandleMessage(
+	ctx context.Context,
+	m p2pmsg.Message,
+) ([]p2pmsg.Message, error) {
 	msg, ok := m.(*p2pmsg.DecryptionTrigger)
 	if !ok {
 		return nil, errors.New("Message type assertion mismatch")
diff --git a/rolling-shutter/keyper/keyper.go b/rolling-shutter/keyper/keyper.go
@@ -267,7 +267,8 @@ func (kpr *keyper) handleOnChainKeyperSetChanges(
 	}
 	// We *MUST* check if the l1BlockNumber is smaller than the activationBlockNumber since both are uint64 and therefore subtraction can never result in negative numbers.
 	// This means that if we missed the activationBlockNumber we will never submit the config.
-	if l1BlockNumber < activationBlockNumber && activationBlockNumber-l1BlockNumber > kpr.config.Shuttermint.DKGStartBlockDelta {
+	if l1BlockNumber < activationBlockNumber &&
+		activationBlockNumber-l1BlockNumber > kpr.config.Shuttermint.DKGStartBlockDelta {
 		log.Info().Interface("keyper-set", keyperSet).
 			Uint64("l1-block-number", l1BlockNumber).
 			Uint64("dkg-start-delta", kpr.config.Shuttermint.DKGStartBlockDelta).
diff --git a/rolling-shutter/medley/eventsyncer/eventsyncer.go b/rolling-shutter/medley/eventsyncer/eventsyncer.go
@@ -73,7 +73,13 @@ type EventSyncer struct {
 // New creates a new event syncer. It will look for events starting at a certain block number and
 // log index. The types of events to filter for are specified as a set of EventTypes. The finality
 // offset is the number of blocks we trail behind the current block to be safe from reorgs.
-func New(client *ethclient.Client, finalityOffset uint64, events []*EventType, fromBlock uint64, fromLogIndex uint64) *EventSyncer {
+func New(
+	client *ethclient.Client,
+	finalityOffset uint64,
+	events []*EventType,
+	fromBlock uint64,
+	fromLogIndex uint64,
+) *EventSyncer {
 	return &EventSyncer{
 		Client:         client,
 		FinalityOffset: finalityOffset,
@@ -219,7 +225,12 @@ func (s *EventSyncer) syncAllInRange(ctx context.Context, fromBlock uint64, toBl
 }
 
 // syncSingleInRange returns the events matching the given type in the given block range.
-func (s *EventSyncer) syncSingleInRange(ctx context.Context, event *EventType, fromBlock uint64, toBlock uint64) ([]logChannelItem, error) {
+func (s *EventSyncer) syncSingleInRange(
+	ctx context.Context,
+	event *EventType,
+	fromBlock uint64,
+	toBlock uint64,
+) ([]logChannelItem, error) {
 	topic := event.ABI.Events[event.Name].ID
 	query := ethereum.FilterQuery{
 		BlockHash: nil,
diff --git a/rolling-shutter/medley/revert.go b/rolling-shutter/medley/revert.go
@@ -15,7 +15,13 @@ import (
 // Adapted from https://ethereum.stackexchange.com/a/80766
 
 // GetRevertReason returns the reason for a failed transaction.
-func GetRevertReason(ctx context.Context, b ethereum.ContractCaller, from common.Address, tx *types.Transaction, blockNum *big.Int) error {
+func GetRevertReason(
+	ctx context.Context,
+	b ethereum.ContractCaller,
+	from common.Address,
+	tx *types.Transaction,
+	blockNum *big.Int,
+) error {
 	msg := ethereum.CallMsg{
 		From:     from,
 		To:       tx.To(),
diff --git a/rolling-shutter/medley/testkeygen/keygenerator.go b/rolling-shutter/medley/testkeygen/keygenerator.go
@@ -59,7 +59,10 @@ func (tkg *TestKeyGenerator) EonKeysForEpoch(epochID epochid.EpochID) *EonKeys {
 	return res
 }
 
-func (tkg *TestKeyGenerator) EonPublicKeyShare(epochID epochid.EpochID, keyperIndex uint64) *shcrypto.EonPublicKeyShare {
+func (tkg *TestKeyGenerator) EonPublicKeyShare(
+	epochID epochid.EpochID,
+	keyperIndex uint64,
+) *shcrypto.EonPublicKeyShare {
 	tkg.t.Helper()
 	return tkg.EonKeysForEpoch(epochID).keyperShares[keyperIndex].eonPublicKeyShare
 }
@@ -69,12 +72,18 @@ func (tkg *TestKeyGenerator) EonPublicKey(epochID epochid.EpochID) *shcrypto.Eon
 	return tkg.EonKeysForEpoch(epochID).publicKey
 }
 
-func (tkg *TestKeyGenerator) EonSecretKeyShare(epochID epochid.EpochID, keyperIndex uint64) *shcrypto.EonSecretKeyShare {
+func (tkg *TestKeyGenerator) EonSecretKeyShare(
+	epochID epochid.EpochID,
+	keyperIndex uint64,
+) *shcrypto.EonSecretKeyShare {
 	tkg.t.Helper()
 	return tkg.EonKeysForEpoch(epochID).keyperShares[keyperIndex].eonSecretKeyShare
 }
 
-func (tkg *TestKeyGenerator) EpochSecretKeyShare(epochID epochid.EpochID, keyperIndex uint64) *shcrypto.EpochSecretKeyShare {
+func (tkg *TestKeyGenerator) EpochSecretKeyShare(
+	epochID epochid.EpochID,
+	keyperIndex uint64,
+) *shcrypto.EpochSecretKeyShare {
 	tkg.t.Helper()
 	return tkg.EonKeysForEpoch(epochID).keyperShares[keyperIndex].ComputeEpochSecretKeyShare(epochID)
 }
diff --git a/rolling-shutter/medley/txbatch/txbatch.go b/rolling-shutter/medley/txbatch/txbatch.go
@@ -54,7 +54,13 @@ func (txbatch *TXBatch) WaitMined(ctx context.Context) ([]*types.Receipt, error)
 		}
 		res = append(res, receipt)
 		if receipt.Status != 1 {
-			err = medley.GetRevertReason(ctx, txbatch.Ethclient, crypto.PubkeyToAddress(txbatch.key.PublicKey), tx, receipt.BlockNumber)
+			err = medley.GetRevertReason(
+				ctx,
+				txbatch.Ethclient,
+				crypto.PubkeyToAddress(txbatch.key.PublicKey),
+				tx,
+				receipt.BlockNumber,
+			)
 			fmt.Print("\n")
 			log.Info().Err(err).Str("hash", tx.Hash().Hex()).Int("index", i).
 				Msg("transaction reverted")
@@ -71,7 +77,11 @@ func (txbatch *TXBatch) WaitMined(ctx context.Context) ([]*types.Receipt, error)
 }
 
 // InitTransactOpts initializes the transact options struct.
-func InitTransactOpts(ctx context.Context, client *ethclient.Client, key *ecdsa.PrivateKey) (*bind.TransactOpts, error) {
+func InitTransactOpts(
+	ctx context.Context,
+	client *ethclient.Client,
+	key *ecdsa.PrivateKey,
+) (*bind.TransactOpts, error) {
 	chainID, err := client.ChainID(ctx)
 	if err != nil {
 		return nil, err
diff --git a/rolling-shutter/mocksequencer/rpc/service_admin.go b/rolling-shutter/mocksequencer/rpc/service_admin.go
@@ -29,7 +29,11 @@ func (s *AdminService) Name() string {
 func (s *AdminService) AddCollator(address string, l1BlockNumber uint64) (int, error) {
 	var err error
 	defer func() {
-		log.Info().Err(err).Str("address", address).Uint64("l1-blocknumber", l1BlockNumber).Msg("admin method AddCollator called")
+		log.Info().
+			Err(err).
+			Str("address", address).
+			Uint64("l1-blocknumber", l1BlockNumber).
+			Msg("admin method AddCollator called")
 	}()
 
 	collator, err := encoding.StringToAddress(address)
diff --git a/rolling-shutter/mocksequencer/rpc/service_eth.go b/rolling-shutter/mocksequencer/rpc/service_eth.go
@@ -57,7 +57,10 @@ func (s *EthService) Name() string {
 	return "eth"
 }
 
-func (s *EthService) GetTransactionCount(address common.Address, blockNrOrHash ethrpc.BlockNumberOrHash) (*hexutil.Uint64, error) {
+func (s *EthService) GetTransactionCount(
+	address common.Address,
+	blockNrOrHash ethrpc.BlockNumberOrHash,
+) (*hexutil.Uint64, error) {
 	s.processor.Mux.RLock()
 	defer s.processor.Mux.RUnlock()
 	block, err := s.processor.GetBlock(blockNrOrHash)
@@ -86,7 +89,11 @@ func (s *EthService) ChainId() *hexutil.Big {
 	return (*hexutil.Big)(s.processor.ChainID())
 }
 
-func (s *EthService) GetBlockByNumber(_ context.Context, blockNumber ethrpc.BlockNumber, _ bool) (map[string]interface{}, error) {
+func (s *EthService) GetBlockByNumber(
+	_ context.Context,
+	blockNumber ethrpc.BlockNumber,
+	_ bool,
+) (map[string]interface{}, error) {
 	var result map[string]interface{}
 	s.processor.Mux.RLock()
 	defer s.processor.Mux.RUnlock()
diff --git a/rolling-shutter/mocksequencer/sequencer.go b/rolling-shutter/mocksequencer/sequencer.go
@@ -116,7 +116,12 @@ func (b *BlockData) GetNonce(a common.Address) uint64 {
 	return nonce
 }
 
-func CreateNextBlockData(baseFee *big.Int, gasLimit uint64, feeBeneficiary common.Address, previous *BlockData) *BlockData {
+func CreateNextBlockData(
+	baseFee *big.Int,
+	gasLimit uint64,
+	feeBeneficiary common.Address,
+	previous *BlockData,
+) *BlockData {
 	gasPool := core.GasPool(gasLimit)
 	bd := &BlockData{
 		mux:            sync.Mutex{},
@@ -404,7 +409,11 @@ func (proc *Sequencer) ProcessEncryptedTx(
 	}
 
 	shutterTxStr, _ := tx.MarshalJSON()
-	log.Ctx(ctx).Info().Str("signer", sender.Hex()).RawJSON("transaction", shutterTxStr).Msg("received shutter transaction")
+	log.Ctx(ctx).
+		Info().
+		Str("signer", sender.Hex()).
+		RawJSON("transaction", shutterTxStr).
+		Msg("received shutter transaction")
 
 	if tx.L1BlockNumber() != batchL1BlockNumber {
 		return errors.New("l1-block-number mismatch")
diff --git a/rolling-shutter/p2p/message.go b/rolling-shutter/p2p/message.go
@@ -20,7 +20,10 @@ func UnmarshalPubsubMessage(msg *pubsub.Message) (p2pmsg.Message, *p2pmsg.TraceC
 
 	err = unmshl.Validate()
 	if err != nil {
-		return nil, traceContext, errors.Wrap(err, fmt.Sprintf("verification failed <%s>", reflect.TypeOf(unmshl).String()))
+		return nil, traceContext, errors.Wrap(
+			err,
+			fmt.Sprintf("verification failed <%s>", reflect.TypeOf(unmshl).String()),
+		)
 	}
 	return unmshl, traceContext, nil
 }
diff --git a/rolling-shutter/p2pmsg/messages_test.go b/rolling-shutter/p2pmsg/messages_test.go
@@ -13,7 +13,11 @@ import (
 	"github.com/shutter-network/rolling-shutter/rolling-shutter/trace"
 )
 
-func marshalUnmarshalMessage[M Message](t *testing.T, message M, traceContext *TraceContext) (M, *TraceContext) { //nolint:thelper
+func marshalUnmarshalMessage[M Message]( //nolint:thelper
+	t *testing.T,
+	message M,
+	traceContext *TraceContext,
+) (M, *TraceContext) {
 	var (
 		err        error
 		ok         bool
diff --git a/rolling-shutter/snapshot/handler.go b/rolling-shutter/snapshot/handler.go
diff --git a/rolling-shutter/snapshotkeyper/snapshotkeyper.go b/rolling-shutter/snapshotkeyper/snapshotkeyper.go

Original file line number	Diff line number	Diff line change
`@@ -522,7 +522,10 @@ func (app ShutterApp) handlePolyEvalMsg(msg shmsg.PolyEval, sender common.Addr`
`522`	`522`	`}`
`523`	`523`	`}`
`524`	`524`
`525`		`-func (app ShutterApp) handlePolyCommitmentMsg(msg shmsg.PolyCommitment, sender common.Address) abcitypes.ResponseDeliverTx {`
	`525`	`+func (app *ShutterApp) handlePolyCommitmentMsg(`
	`526`	`+ msg *shmsg.PolyCommitment,`
	`527`	`+ sender common.Address,`
	`528`	`+) abcitypes.ResponseDeliverTx {`
`526`	`529`	`appMsg, err := ParsePolyCommitmentMsg(msg, sender)`
`527`	`530`	`if err != nil {`
`528`	`531`	`msg := fmt.Sprintf("Error: Failed to parse PolyCommitment message: %+v", err)`
`@@ -717,7 +720,8 @@ func (app *ShutterApp) EndBlock(req abcitypes.RequestEndBlock) abcitypes.Respons`
`717`	`720`	`}.MakeABCIEvent())`
`718`	`721`	`}`
`719`	`722`	`}`
`720`		`- if config.Started && !config.ValidatorsUpdated && app.countCheckedInKeypers(config.Keypers) >= numRequiredTransitionValidators(config) {`
	`723`	`+ if config.Started && !config.ValidatorsUpdated &&`
	`724`	`+ app.countCheckedInKeypers(config.Keypers) >= numRequiredTransitionValidators(config) {`
`721`	`725`	`config.ValidatorsUpdated = true`
`722`	`726`	`}`
`723`	`727`	`}`
Original file line number	Diff line number	Diff line change
`@@ -40,7 +40,11 @@ func (dkg *DKGInstance) RegisterPolyEvalMsg(msg PolyEval) error {`
`40`	`40`	`}`
`41`	`41`	`_, ok := dkg.PolyEvalsSeen[SenderReceiverPair{sender, receiver}]`
`42`	`42`	`if ok {`
`43`		`- return errors.Errorf("polynomial evaluation from keyper %s for receiver %s already present", sender.Hex(), receiver.Hex())`
	`43`	`+ return errors.Errorf(`
	`44`	`+ "polynomial evaluation from keyper %s for receiver %s already present",`
	`45`	`+ sender.Hex(),`
	`46`	`+ receiver.Hex(),`
	`47`	`+ )`
`44`	`48`	`}`
`45`	`49`	`}`
`46`	`50`
Original file line number	Diff line number	Diff line change
`@@ -97,7 +97,13 @@ func TestConfirmTransactionsIntegration(t *testing.T) {`
`97`	`97`	`assert.NilError(t, err)`
`98`	`98`	`assert.Equal(t, 5, len(txs), "should have exactly one tx: %+v", txs)`
`99`	`99`	`for nonce := 0; nonce < 5; nonce++ {`
`100`		`- assert.Equal(t, cltrdb.TxstatusCommitted, txs[nonce].Status, "expected tx to have status committed: %+v", txs[nonce])`
	`100`	`+ assert.Equal(`
	`101`	`+ t,`
	`102`	`+ cltrdb.TxstatusCommitted,`
	`103`	`+ txs[nonce].Status,`
	`104`	`+ "expected tx to have status committed: %+v",`
	`105`	`+ txs[nonce],`
	`106`	`+ )`
`101`	`107`	`}`
`102`	`108`	`}`
`103`	`109`
Original file line number	Diff line number	Diff line change
`@@ -25,7 +25,11 @@ func (*EonPublicKeyHandler) MessagePrototypes() []p2pmsg.Message {`
`25`	`25`	`func (handler *EonPublicKeyHandler) ValidateMessage(_ context.Context, msg p2pmsg.Message) (bool, error) {`
`26`	`26`	`key := msg.(*p2pmsg.EonPublicKey)`
`27`	`27`	`if key.GetInstanceID() != handler.config.GetInstanceID() {`
`28`		`- return false, errors.Errorf("instance ID mismatch (want=%d, have=%d)", handler.config.GetInstanceID(), key.GetInstanceID())`
	`28`	`+ return false, errors.Errorf(`
	`29`	`+ "instance ID mismatch (want=%d, have=%d)",`
	`30`	`+ handler.config.GetInstanceID(),`
	`31`	`+ key.GetInstanceID(),`
	`32`	`+ )`
`29`	`33`	`}`
`30`	`34`	`return true, nil`
`31`	`35`	`}`