aergoio/aergo

Method V030Handshaker.receiveRemoteStatus has 8 return statements (exceeds 4 allowed).

Open

func (h *V030Handshaker) receiveRemoteStatus(ctx context.Context) (*types.Status, error) {
    // and wait to response status
    data, err := h.msgRW.ReadMsg()
    if err != nil {
        h.sendGoAway("malformed message")

Method V200Handshaker.checkRemoteStatus has 8 return statements (exceeds 4 allowed).

Open

func (h *V200Handshaker) checkRemoteStatus(remotePeerStatus *types.Status) error {
    // check if chainID is same or not
    remoteChainID := types.NewChainID()
    err := remoteChainID.Read(remotePeerStatus.ChainID)
    if err != nil {

Method AergoRPCService.GetConfChangeProgress has 8 return statements (exceeds 4 allowed).

Open

func (rpc *AergoRPCService) GetConfChangeProgress(ctx context.Context, in *types.SingleBytes) (*types.ConfChangeProgress, error) {
    var (
        progress *types.ConfChangeProgress
        err      error
    )

Method baseWireHandshaker.readWireHSRequest has 8 return statements (exceeds 4 allowed).

Open

func (h *baseWireHandshaker) readWireHSRequest(rd io.Reader) (header p2pcommon.HSHeadReq, err error) {
    buf := make([]byte, p2pcommon.HSMagicLength)
    readn, err := p2putil.ReadToLen(rd, buf[:p2pcommon.HSMagicLength])
    if err != nil {
        return

Method Cluster.validateChangeMembership has 8 return statements (exceeds 4 allowed).

Open

func (cl *Cluster) validateChangeMembership(cc *raftpb.ConfChange, member *consensus.Member, needlock bool) error {
    if member == nil {
        return ErrCCMemberIsNil
    }

Method InboundWireHandshaker.handleInboundPeer has 8 return statements (exceeds 4 allowed).

Open

func (h *InboundWireHandshaker) handleInboundPeer(ctx context.Context, rwc io.ReadWriteCloser) (*p2pcommon.HandshakeResult, error) {
    // wait initial hs message
    hsReq, err := h.readWireHSRequest(rwc)
    select {
    case <-ctx.Done():

Method reorganizer.gather has 8 return statements (exceeds 4 allowed).

Open

func (reorg *reorganizer) gather() error {
    //find branch root block , gather rollforward Target block
    var err error
    cdb := reorg.cs.cdb

Method Web3APIv1.ListEvents has 8 return statements (exceeds 4 allowed).

Open

func (api *Web3APIv1) ListEvents() (handler http.Handler, ok bool) {
    values, err := url.ParseQuery(api.request.URL.RawQuery)
    if err != nil {
        return commonResponseHandler(&types.Empty{}, err), true
    }

Function sendTX has 8 return statements (exceeds 4 allowed).

Open

func sendTX(cmd *cobra.Command, tx *types.Tx, account []byte) string {
    if rootConfig.KeyStorePath != "" {
        var err error
        if pw == "" {
            pw, err = getPasswd(cmd, false)

Function execVote has 8 return statements (exceeds 4 allowed).

Open

func execVote(cmd *cobra.Command, args []string) {
    account, err := types.DecodeAddress(address)
    if err != nil {
        cmd.Printf("Failed: %s\n", err.Error())
        return

Method blockExecutor.execute has 8 return statements (exceeds 4 allowed).

Open

func (e *blockExecutor) execute() error {
    // Receipt must be committed unconditionally.
    if !e.commitOnly {
        defer contract.CloseDatabase()
        logger.Trace().Int("txCount", len(e.txs)).Msg("executing txs")

Method PeerMapService.handleQuery has 8 return statements (exceeds 4 allowed).

Open

func (pms *PeerMapService) handleQuery(conn p2pcommon.RemoteConn, container p2pcommon.Message, query *types.MapQuery) (*types.MapResponse, error) {
    if query.Status == nil {
        return nil, fmt.Errorf("malformed query %v", query)
    }
    receivedMeta := p2pcommon.NewMetaFromStatus(query.Status)

Method ChainStateDB.SetGenesis has 8 return statements (exceeds 4 allowed).

Open

func (sdb *ChainStateDB) SetGenesis(genesis *types.Genesis, bpInit func(*statedb.StateDB, *types.Genesis) error) error {
    block := genesis.Block()
    stateDB := sdb.OpenNewStateDB(sdb.GetRoot())

    // create state of genesis block

Method BlockFetcher.searchCandidateTask has 8 return statements (exceeds 4 allowed).

Open

func (bf *BlockFetcher) searchCandidateTask() (*FetchTask, error) {
    getNewHashSet := func() (*HashSet, error) {
        if bf.curHashSet == nil { //blocking
            logger.Info().Msg("BlockFetcher waiting first hashset")

Function ValidateNameTx has 8 return statements (exceeds 4 allowed).

Open

func ValidateNameTx(tx *types.TxBody, sender *state.AccountState, scs *statedb.ContractState) (*types.CallInfo, error) {
    if sender != nil && sender.Balance().Cmp(tx.GetAmountBigInt()) < 0 {
        return nil, types.ErrInsufficientBalance
    }

Method SQLiteConn.RegisterFunc has 8 return statements (exceeds 4 allowed).

Open

func (c *SQLiteConn) RegisterFunc(name string, impl interface{}, pure bool) error {
    var fi functionInfo
    fi.f = reflect.ValueOf(impl)
    t := fi.f.Type()
    if t.Kind() != reflect.Func {

Method transaction.ValidateWithSenderState has 8 return statements (exceeds 4 allowed).

Open

func (tx *transaction) ValidateWithSenderState(senderState *State, gasPrice *big.Int, version int32) error {
    if (senderState.GetNonce() + 1) > tx.GetBody().GetNonce() {
        return ErrTxNonceTooLow
    }
    amount := tx.GetBody().GetAmountBigInt()

Function Create has 8 return statements (exceeds 4 allowed).

Open

func Create(
    contractState *statedb.ContractState,
    code, contractAddress []byte,
    ctx *vmContext,
) (string, []*types.Event, *big.Int, error) {

Function refreshAllVote has 8 return statements (exceeds 4 allowed).

Open

func refreshAllVote(context *SystemContext) error {
    var (
        scs          = context.scs
        account      = context.Sender.ID()
        staked       = context.Staked

Similar blocks of code found in 2 locations. Consider refactoring.

Open

        } else {
            for i := start; i >= end; i-- {
                foundBlock, futureErr := extractBlockFromFuture(rpc.hub.RequestFuture(message.ChainSvc,
                    &message.GetBlockByNo{BlockNo: i}, defaultActorTimeout, "rpc.(*AergoRPCService).ListBlockHeaders#2"))
                if nil != futureErr {

• Read up
  Read up