chore: Fix format and lint errors

Author: nvsriram

node/cmd/guardiand/admintemplate.go

@@ -1175,20 +1175,20 @@ func runCoreBridgeSetMessageFeeTemplate(cmd *cobra.Command, args []string) {
 }
 
 func runDelegatedGuardiansConfigTemplate(cmd *cobra.Command, args []string) {
-		if *delegatedGuardiansConfigId == "" {
-			log.Fatal("--config-id must be specified")
-		}
-		if *delegatedGuardiansConfigJson == "" {
-			log.Fatal("--config must be specified")
-		}
+	if *delegatedGuardiansConfigId == "" {
+		log.Fatal("--config-id must be specified")
+	}
+	if *delegatedGuardiansConfigJson == "" {
+		log.Fatal("--config must be specified")
+	}
 
-		// Parse config ID from string to uint32
-		configID, err := strconv.ParseUint(*delegatedGuardiansConfigId, 10, 32)
-		if err != nil {
-			log.Fatal("invalid config-id: ", err)
-		}
+	// Parse config ID from string to uint32
+	configID, err := strconv.ParseUint(*delegatedGuardiansConfigId, 10, 32)
+	if err != nil {
+		log.Fatal("invalid config-id: ", err)
+	}
 
-    seq, nonce := randSeqNonce()
+	seq, nonce := randSeqNonce()
 
 	m := &nodev1.InjectGovernanceVAARequest{
 		CurrentSetIndex: uint32(*templateGuardianIndex), // #nosec G115 -- Number of guardians will never overflow here

node/cmd/guardiand/adminverify.go

@@ -42,9 +42,6 @@ func runGovernanceVAAVerify(cmd *cobra.Command, args []string) {
 		}
 
 		digest := v.SigningDigest().Bytes()
-		if err != nil {
-			panic(err)
-		}
 
 		b, err := v.Marshal()
 		if err != nil {

node/pkg/adminrpc/adminserver_test.go

@@ -6,7 +6,7 @@ import (
 	"context"
 	"testing"
 	"time"
-	"fmt"
+
 	wh_common "github.com/certusone/wormhole/node/pkg/common"
 	"github.com/certusone/wormhole/node/pkg/db"
 	"github.com/certusone/wormhole/node/pkg/governor"
@@ -469,9 +469,6 @@ func TestDelegatedGuardiansConfigToVaa(t *testing.T) {
 	require.NotNil(t, v)
 
 	verifyGovernanceVAA(t, v, sequence, nonce)
-
-	fmt.Println(v.Payload)
-
 	assert.NotEmpty(t, v.Payload)
 }
 
@@ -505,4 +502,3 @@ func TestDelegatedGuardiansConfigToVaa_InvalidChainID(t *testing.T) {
 	require.Error(t, err)
 	assert.Contains(t, err.Error(), "invalid chain ID")
 }
-

node/pkg/node/node.go

@@ -61,7 +61,7 @@ const (
 	// TODO(delegated-guardian-sets): The buffer size is arbitrarily set and should be verified
 	// delegateObservationInboundBufferSize configures the size of delegateObsvC.
 	delegateObservationInboundBufferSize = 1000
-	
+
 	// delegateObservationOutboundBufferSize configures the size of delegateObsvSendC.
 	delegateObservationOutboundBufferSize = 1000
 )

node/pkg/p2p/p2p.go

@@ -92,6 +92,7 @@ var signedDelegateObservationPrefix = []byte("signed_delegate_observation|")
 // heartbeatMaxTimeDifference specifies the maximum time difference between the local clock and the timestamp in incoming heartbeat messages. Heartbeats that are this old or this much into the future will be dropped. This value should encompass clock skew and network delay.
 var heartbeatMaxTimeDifference = time.Minute * 15
 var observationRequestMaxTimeDifference = time.Minute * 15
+
 // TODO(delegated-guardian-sets): Remove if no freshness check required
 var delegateObservationMaxTimeDifference = time.Minute * 15
 
@@ -691,7 +692,7 @@ func Run(params *RunParams) func(ctx context.Context) error {
 					} else {
 						logger.Info("published signed observation request", zap.Any("signed_observation_request", sReq))
 					}
-				case msg:= <-params.delegateObsvSendC:
+				case msg := <-params.delegateObsvSendC:
 					logger.Debug("p2p: received delegate observation from channel",
 						zap.Uint32("emitter_chain", msg.EmitterChain),
 						zap.Uint64("sequence", msg.Sequence),
@@ -923,8 +924,8 @@ func Run(params *RunParams) func(ctx context.Context) error {
 							gs := params.gst.Get()
 							if gs == nil {
 								if logger.Level().Enabled(zapcore.DebugLevel) {
-									logger.Debug("dropping SignedDelegateObservation - no guardian set", 
-										zap.Any("value", d), 
+									logger.Debug("dropping SignedDelegateObservation - no guardian set",
+										zap.Any("value", d),
 										zap.String("from", envelope.GetFrom().String()),
 									)
 								}
@@ -1241,7 +1242,7 @@ func processSignedDelegateObservation(d *gossipv1.SignedDelegateObservation, gs
 	}
 
 	digest := signedDelegateObservationDigest(d.DelegateObservation)
-	
+
 	pubKey, err := ethcrypto.Ecrecover(digest.Bytes(), d.Signature)
 	if err != nil {
 		return nil, errors.New("failed to recover public key")

node/pkg/p2p/run_params.go

@@ -51,7 +51,7 @@ type (
 		gossipAttestationSendC chan []byte
 		gossipVaaSendC         chan []byte
 		obsvReqSendC           <-chan *gossipv1.ObservationRequest
-		delegateObsvSendC 	   <-chan *gossipv1.DelegateObservation
+		delegateObsvSendC      <-chan *gossipv1.DelegateObservation
 		acct                   *accountant.Accountant
 		gov                    *governor.ChainGovernor
 		components             *Components

node/pkg/p2p/watermark_test.go

@@ -29,8 +29,8 @@ type G struct {
 	batchObsvC             chan *node_common.MsgWithTimeStamp[gossipv1.SignedObservationBatch]
 	obsvReqC               chan *gossipv1.ObservationRequest
 	obsvReqSendC           chan *gossipv1.ObservationRequest
-	delegateObsvRecvC	   chan *gossipv1.DelegateObservation
-	delegateObsvSendC	   chan *gossipv1.DelegateObservation
+	delegateObsvRecvC      chan *gossipv1.DelegateObservation
+	delegateObsvSendC      chan *gossipv1.DelegateObservation
 	controlSendC           chan []byte
 	attestationSendC       chan []byte
 	vaaSendC               chan []byte

node/pkg/processor/observation.go

@@ -76,7 +76,7 @@ func signaturesToVaaFormat(signatures map[common.Address][]byte, gsKeys []common
 
 // handleDelegateMessagePublication converts the MessagePublication into a DelegateObservation and sends it to the delegateObsvSendC channel.
 // This should only be called by a delegated guardian for the chain.
-func (p* Processor) handleDelegateMessagePublication(k *node_common.MessagePublication) error {
+func (p *Processor) handleDelegateMessagePublication(k *node_common.MessagePublication) error {
 	p.logger.Info("handleDelegateMessagePublication: CALLED - converting message to delegate observation",
 		zap.String("msgID", k.MessageIDString()),
 		zap.Uint32("emitter_chain", uint32(k.EmitterChain)),
@@ -466,62 +466,66 @@ func (p *Processor) handleInboundSignedVAAWithQuorum(m *gossipv1.SignedVAAWithQu
 }
 
 // handleDelegateObservation processes a delegate observation
-func (p *Processor) handleDelegateObservation(ctx context.Context, m *gossipv1.DelegateObservation) {
-    if p.logger.Core().Enabled(zapcore.DebugLevel) {
-        p.logger.Debug("received delegate observation",
+func (p *Processor) handleDelegateObservation(ctx context.Context, m *gossipv1.DelegateObservation) error {
+	if p.logger.Core().Enabled(zapcore.DebugLevel) {
+		p.logger.Debug("received delegate observation",
 			// TODO(delegated-guardian-sets): Add additional relevant fields if necessary
-            zap.Uint32("emitter_chain", m.EmitterChain),
-            zap.Uint64("sequence", m.Sequence),
-            zap.String("txhash", hex.EncodeToString(m.TxHash)),
-            zap.String("txhash_b58", base58.Encode(m.TxHash)),
+			zap.Uint32("emitter_chain", m.EmitterChain),
+			zap.Uint64("sequence", m.Sequence),
+			zap.String("txhash", hex.EncodeToString(m.TxHash)),
+			zap.String("txhash_b58", base58.Encode(m.TxHash)),
 			zap.String("guardian_addr", hex.EncodeToString(m.GuardianAddr)),
-        )
-    }
+		)
+	}
+
+	c, err := vaa.ChainIDFromNumber(m.EmitterChain)
+	if err != nil {
+		p.logger.Warn("invalid delegate observation emitter chain", zap.Error(err))
+		return nil
+	}
 
-	c := vaa.ChainID(m.EmitterChain)
-	
 	cfg := p.dgc.GetChainConfig(c)
 	if cfg == nil {
 		p.logger.Debug("ignoring delegate observation for chain without delegate chain config",
 			zap.Stringer("emitter_chain", c),
 			zap.Uint64("sequence", m.Sequence),
 		)
-		return
+		return nil
 	}
 
-    _, ok := cfg.KeyIndex(p.ourAddr)
+	_, ok := cfg.KeyIndex(p.ourAddr)
 	if ok {
-		p.logger.Debug("ignoring delegate observation since we are a delegated guardian for this chain", 
+		p.logger.Debug("ignoring delegate observation since we are a delegated guardian for this chain",
 			zap.Stringer("emitter_chain", c),
-            zap.Uint64("sequence", m.Sequence),
+			zap.Uint64("sequence", m.Sequence),
 		)
-		return
+		return nil
 	}
 
 	addr := common.BytesToAddress(m.GuardianAddr)
 	_, ok = cfg.KeyIndex(addr)
 	if !ok {
-		p.logger.Debug("ignoring delegate observation from non-delegated guardian for this chain", 
+		p.logger.Debug("ignoring delegate observation from non-delegated guardian for this chain",
 			zap.Stringer("emitter_chain", c),
-            zap.Uint64("sequence", m.Sequence),
+			zap.Uint64("sequence", m.Sequence),
 			zap.String("guardian", addr.Hex()),
 		)
-		return
+		return nil
 	}
 
-	p.handleCanonicalDelegateObservation(ctx, cfg, m)
+	return p.handleCanonicalDelegateObservation(ctx, cfg, m)
 }
 
 // handleCanonicalDelegateObservation processes a delegate observation as a canonical guardian
 // This function assumes cfg corresponds to m.EmitterChain
 // TODO(delegated-guardian-sets): Should ^ be explicitly asserted?
-func (p *Processor) handleCanonicalDelegateObservation(ctx context.Context, cfg *DelegateGuardianChainConfig, m *gossipv1.DelegateObservation) {
+func (p *Processor) handleCanonicalDelegateObservation(ctx context.Context, cfg *DelegateGuardianChainConfig, m *gossipv1.DelegateObservation) error {
 	mp, err := delegateObservationToMessagePublication(m)
-    if err != nil {
-        p.logger.Warn("failed to convert delegate observation to message publication", zap.Error(err))
-        return
-    }
-	
+	if err != nil {
+		p.logger.Warn("failed to convert delegate observation to message publication", zap.Error(err))
+		return nil
+	}
+
 	hash := mp.CreateDigest()
 
 	// Get / create our state entry.
@@ -539,15 +543,16 @@ func (p *Processor) handleCanonicalDelegateObservation(ctx context.Context, cfg
 	s.observations[addr] = m
 
 	if !s.submitted {
-		p.checkForDelegateQuorum(ctx, mp, s, cfg)
+		return p.checkForDelegateQuorum(ctx, mp, s, cfg)
 	}
+	return nil
 }
 
-// checkForDelegateQuorum checks for quorum after a delegate observation has been added to the state. If quorum is met, it runs the converted 
+// checkForDelegateQuorum checks for quorum after a delegate observation has been added to the state. If quorum is met, it runs the converted
 // MessagePublication through the normal message pipeline.
 // This function assumes mp corresponds to s
 // TODO(delegated-guardian-sets): Should ^ be explicitly asserted?
-func (p *Processor) checkForDelegateQuorum(ctx context.Context, mp *node_common.MessagePublication, s *delegateState, dgs *DelegateGuardianChainConfig) {	
+func (p *Processor) checkForDelegateQuorum(ctx context.Context, mp *node_common.MessagePublication, s *delegateState, dgs *DelegateGuardianChainConfig) error {
 	// TODO(delegated-guardian-sets): Handle case for when delegate guardian set changes
 	// Check if we have more delegate observations than required for quorum.
 	if len(s.observations) < dgs.Quorum() {
@@ -556,14 +561,14 @@ func (p *Processor) checkForDelegateQuorum(ctx context.Context, mp *node_common.
 		if p.logger.Level().Enabled(zapcore.DebugLevel) {
 			p.logger.Debug("quorum not yet met",
 				zap.Stringer("emitter_chain", c),
-            	zap.Uint64("sequence", mp.Sequence),
+				zap.Uint64("sequence", mp.Sequence),
 			)
 		}
-		return
+		return nil
 	}
 
 	s.submitted = true
-	p.handleMessagePublication(ctx, mp)
+	return p.handleMessagePublication(ctx, mp)
 }
 
 // delegateObservationToMessagePublication converts a DelegateObservation into a MessagePublication that can be passed through the normal processor pipeline.
@@ -577,31 +582,35 @@ func delegateObservationToMessagePublication(d *gossipv1.DelegateObservation) (*
 		return nil, fmt.Errorf("delegate observation tx_hash too short: got %d; want at least %d", txIDLen, node_common.TxIDLenMin)
 	}
 
-    addr, err := vaa.BytesToAddress(d.EmitterAddress)
-	if err != nil {
-		return nil, fmt.Errorf("invalid delegate observation emitter address: %w", err)
+	if d.ConsistencyLevel > math.MaxUint8 {
+		return nil, fmt.Errorf("invalid delegate observation consistency : %d", d.ConsistencyLevel)
 	}
 
 	c, err := vaa.ChainIDFromNumber(d.EmitterChain)
 	if err != nil {
 		return nil, fmt.Errorf("invalid delegate observation emitter chain: %w", err)
 	}
 
-    mp := &node_common.MessagePublication{
-        TxID:            d.TxHash,
-        Timestamp:       time.Unix(int64(d.Timestamp), 0), // Timestamp is uint32 representing seconds since UNIX epoch so is safe to convert.
-        Nonce:           d.Nonce,
-        Sequence:        d.Sequence,
-        ConsistencyLevel: uint8(d.ConsistencyLevel),
-        EmitterChain:    c,
-        EmitterAddress:  addr,
-        Payload:         d.Payload,
-        IsReobservation: false,
-        Unreliable:      false,
-        // verificationState intentionally left at the default (NotVerified).
-    }
-
-    return mp, nil
+	addr, err := vaa.BytesToAddress(d.EmitterAddress)
+	if err != nil {
+		return nil, fmt.Errorf("invalid delegate observation emitter address: %w", err)
+	}
+
+	mp := &node_common.MessagePublication{
+		TxID:             d.TxHash,
+		Timestamp:        time.Unix(int64(d.Timestamp), 0), // Timestamp is uint32 representing seconds since UNIX epoch so is safe to convert.
+		Nonce:            d.Nonce,
+		Sequence:         d.Sequence,
+		ConsistencyLevel: uint8(d.ConsistencyLevel),
+		EmitterChain:     c,
+		EmitterAddress:   addr,
+		Payload:          d.Payload,
+		IsReobservation:  false,
+		Unreliable:       false,
+		// verificationState intentionally left at the default (NotVerified).
+	}
+
+	return mp, nil
 }
 
 // messagePublicationToDelegateObservation converts a MessagePublication into a DelegateObservation to be sent by a delegated guardian.

node/pkg/processor/processor.go

@@ -87,7 +87,6 @@ type (
 		signatures observationMap
 	}
 
-
 	// delegateState represents the local view of a given delegate observation
 	delegateState struct {
 		// First time this digest was seen.
@@ -104,7 +103,7 @@ type (
 
 	// delegateAggregationState represents the node's aggregation of delegate guardian signatures.
 	delegateAggregationState struct {
-		observations	delegateObservationMap
+		observations delegateObservationMap
 	}
 )
 
@@ -277,7 +276,7 @@ func NewProcessor(
 		gossipAttestationSendC: gossipAttestationSendC,
 		gossipVaaSendC:         gossipVaaSendC,
 		batchObsvC:             batchObsvC,
-		delegateObsvC: 			delegateObsvC,
+		delegateObsvC:          delegateObsvC,
 		obsvReqSendC:           obsvReqSendC,
 		delegateObsvSendC:      delegateObsvSendC,
 		signedInC:              signedInC,
@@ -299,7 +298,7 @@ func NewProcessor(
 		batchObsvPubC:  make(chan *gossipv1.Observation, batchObsvPubChanSize),
 		updatedVAAs:    make(map[string]*updateVaaEntry),
 		networkID:      networkID,
-		dgc: 			NewDelegateGuardianConfig(),
+		dgc:            NewDelegateGuardianConfig(),
 	}
 }
 
@@ -414,7 +413,9 @@ func (p *Processor) Run(ctx context.Context) error {
 		case m := <-p.signedInC:
 			p.handleInboundSignedVAAWithQuorum(m)
 		case m := <-p.delegateObsvC:
-			p.handleDelegateObservation(ctx, m)
+			if err := p.handleDelegateObservation(ctx, m); err != nil {
+				return err
+			}
 		case <-cleanup.C:
 			p.handleCleanup(ctx)
 		case <-pollTimer.C:

node/pkg/watchers/evm/config.go

@@ -13,16 +13,16 @@ import (
 )
 
 type WatcherConfig struct {
-	NetworkID              watchers.NetworkID // human readable name
-	ChainID                vaa.ChainID        // ChainID
-	Rpc                    string             // RPC URL
-	Contract               string             // hex representation of the contract address
-	GuardianSetUpdateChain bool               // if `true`, we will retrieve the GuardianSet from this chain and watch this chain for GuardianSet updates
-	DelegatedGuardiansContract string          // hex representation of the delegated guardians contract address
-	DelegatedGuardiansUpdateChain bool         // if `true`, we will retrieve the DelegatedGuardians config from this chain
-	CcqBackfillCache       bool
-	TxVerifierEnabled      bool
-	DgConfigC              chan<- *processor.DelegateGuardianConfig // Delegated guardian config channel, set by GuardianOptionWatchers
+	NetworkID                     watchers.NetworkID // human readable name
+	ChainID                       vaa.ChainID        // ChainID
+	Rpc                           string             // RPC URL
+	Contract                      string             // hex representation of the contract address
+	GuardianSetUpdateChain        bool               // if `true`, we will retrieve the GuardianSet from this chain and watch this chain for GuardianSet updates
+	DelegatedGuardiansContract    string             // hex representation of the delegated guardians contract address
+	DelegatedGuardiansUpdateChain bool               // if `true`, we will retrieve the DelegatedGuardians config from this chain
+	CcqBackfillCache              bool
+	TxVerifierEnabled             bool
+	DgConfigC                     chan<- *processor.DelegateGuardianConfig // Delegated guardian config channel, set by GuardianOptionWatchers
 }
 
 func (wc *WatcherConfig) GetNetworkID() watchers.NetworkID {