Function decapsulateCircuitRelayAddr has 5 return statements (exceeds 4 allowed).

Open

func decapsulateCircuitRelayAddr(ctx context.Context, addr ma.Multiaddr) (ma.Multiaddr, error) {
    _, err := addr.ValueForProtocol(ma.P_CIRCUIT)
    if err != nil {
        return nil, errors.New("not a circuit relay address")
    }

Method MembershipFetcher.getEvents has 5 return statements (exceeds 4 allowed).

Open

func (mf *MembershipFetcher) getEvents(ctx context.Context, fromBlock uint64, toBlock uint64) ([]*contracts.RLNMemberRegistered, error) {
    evts, err := mf.fetchEvents(ctx, fromBlock, toBlock)
    if err != nil {
        if tooMuchDataRequestedError(err) { // divide the range and try again
            mid := (fromBlock + toBlock) / 2

Method WakuRelay.upsertTopic has 5 return statements (exceeds 4 allowed).

Open

func (w *WakuRelay) upsertTopic(topic string) (*pubsub.Topic, error) {
    topicData, ok := w.topics[topic]
    if !ok { // Joins topic if node hasn't joined yet
        err := w.pubsub.RegisterTopicValidator(topic, w.topicValidator(topic))
        if err != nil {

Function Start has 5 return statements (exceeds 4 allowed).

Open

func Start(instance *WakuInstance) error {
    if err := validateInstance(instance, MustBeStopped); err != nil {
        return err
    }

Method WakuFilterLightNode.IncorrectSubscribe has a Cognitive Complexity of 22 (exceeds 20 allowed). Consider refactoring.

Open

func (wf *WakuFilterLightNode) IncorrectSubscribe(ctx context.Context, contentFilter protocol.ContentFilter, opts ...FilterSubscribeOption) ([]*subscription.SubscriptionDetails, error) {
    wf.RLock()
    defer wf.RUnlock()
    if err := wf.ErrOnNotRunning(); err != nil {
        return nil, err

• Read up
  Read up

Function encryptSymmetric has 5 return statements (exceeds 4 allowed).

Open

func encryptSymmetric(rawPayload []byte, key []byte) ([]byte, error) {
    if !validateDataIntegrity(key, aesKeyLength) {
        return nil, errors.New("invalid key provided for symmetric encryption, size: " + strconv.Itoa(len(key)))
    }
    block, err := aes.NewCipher(key)

Method WakuRelay.subscribeToPubsubTopic has 5 return statements (exceeds 4 allowed).

Open

func (w *WakuRelay) subscribeToPubsubTopic(topic string) (*pubsubTopicSubscriptionDetails, error) {
    w.topicsMutex.Lock()
    defer w.topicsMutex.Unlock()
    w.log.Info("subscribing to underlying pubsubTopic", zap.String("pubsubTopic", topic))

Method WakuLightPush.handleOpts has 5 return statements (exceeds 4 allowed).

Open

func (wakuLP *WakuLightPush) handleOpts(ctx context.Context, message *wpb.WakuMessage, opts ...RequestOption) (*lightPushRequestParameters, error) {
    params := new(lightPushRequestParameters)
    params.host = wakuLP.h
    params.log = wakuLP.log
    params.pm = wakuLP.pm

Method WakuStore.Request has a Cognitive Complexity of 22 (exceeds 20 allowed). Consider refactoring.

Open

func (s *WakuStore) Request(ctx context.Context, criteria Criteria, opts ...RequestOption) (Result, error) {
    params := new(Parameters)

    optList := DefaultOptions()
    optList = append(optList, opts...)

• Read up
  Read up

Method WakuStore.Resume has 5 return statements (exceeds 4 allowed).

Open

func (store *WakuStore) Resume(ctx context.Context, pubsubTopic string, peerList []peer.ID) (int, error) {
    if !store.started {
        return 0, errors.New("can't resume: store has not started")
    }

Method WakuFilterLightNode.unsubscribeAll has a Cognitive Complexity of 22 (exceeds 20 allowed). Consider refactoring.

Open

func (wf *WakuFilterLightNode) unsubscribeAll(ctx context.Context, opts ...FilterSubscribeOption) (*WakuFilterPushResult, error) {
    params, err := wf.getUnsubscribeParameters(opts...)
    if err != nil {
        return nil, err
    }

• Read up
  Read up

Method PushRpc.ValidateRequest has 5 return statements (exceeds 4 allowed).

Open

func (x *PushRpc) ValidateRequest() error {
    if x.RequestId == "" {
        return errMissingRequestID
    }

Method WakuPeerExchange.handleResponse has 5 return statements (exceeds 4 allowed).

Open

func (wakuPX *WakuPeerExchange) handleResponse(ctx context.Context, response *pb.PeerExchangeResponse, params *PeerExchangeRequestParameters) error {
    var discoveredPeers []struct {
        addrInfo peer.AddrInfo
        enr      *enode.Node
    }

Method WakuMetadata.Request has 5 return statements (exceeds 4 allowed).

Open

func (wakuM *WakuMetadata) Request(ctx context.Context, peerID peer.ID) (*pb.WakuMetadataResponse, error) {
    logger := wakuM.log.With(logging.HostID("peer", peerID))

    stream, err := wakuM.h.NewStream(ctx, peerID, MetadataID_v1)
    if err != nil {

Function decryptSymmetric has 5 return statements (exceeds 4 allowed).

Open

func decryptSymmetric(payload []byte, key []byte) ([]byte, error) {
    // symmetric messages are expected to contain the 12-byte nonce at the end of the payload
    if len(payload) < aesNonceLength {
        return nil, errors.New("missing salt or invalid payload in symmetric message")
    }

Method WakuFilterLightNode.handleFilterSubscribeOptions has 5 return statements (exceeds 4 allowed).

Open

func (wf *WakuFilterLightNode) handleFilterSubscribeOptions(ctx context.Context, contentFilter protocol.ContentFilter, opts []FilterSubscribeOption) (*FilterSubscribeParameters, map[string][]string, error) {
    params := new(FilterSubscribeParameters)
    params.log = wf.log
    params.host = wf.h
    params.pm = wf.pm

Function FilterSubscribe has 5 return statements (exceeds 4 allowed).

Open

func FilterSubscribe(instance *WakuInstance, filterJSON string, peerID string, ms int) (string, error) {
    cf, err := toContentFilter(filterJSON)
    if err != nil {
        return "", err
    }

Function handleRelayTopics has 5 return statements (exceeds 4 allowed).

Open

func handleRelayTopics(ctx context.Context, wg *sync.WaitGroup, wakuNode *node.WakuNode, pubSubTopicMap map[string][]string) error {
    for nodeTopic, cTopics := range pubSubTopicMap {
        nodeTopic := nodeTopic
        _, err := wakuNode.Relay().Subscribe(ctx, wprotocol.NewContentFilter(nodeTopic, cTopics...), relay.WithoutConsumer())
        if err != nil {

Function TestSubscriptionsNotify has 5 return statements (exceeds 4 allowed).

Open

func TestSubscriptionsNotify(t *testing.T) {
    fmap := NewSubscriptionMap(utils.Logger())
    p1 := createPeerID(t)
    p2 := createPeerID(t)
    var subscriptions = []*SubscriptionDetails{

Method PushRpc.ValidateResponse has 5 return statements (exceeds 4 allowed).

Open

func (x *PushRpc) ValidateResponse(requestID string) error {
    if x.RequestId == REQUESTID_RATE_LIMITED {
        return nil
    }
    if x.RequestId == "" {