Sign upLogin

aergoio/aergo

View on GitHub
Star

Showing 1,051 of 1,052 total issues

Method Core.initGenesis has a Cognitive Complexity of 25 (exceeds 20 allowed). Consider refactoring.
Open

func (core *Core) initGenesis(genesis *types.Genesis, mainnet bool, testmode bool) (*types.Block, error) {

    gen := core.cdb.GetGenesisInfo()
    if gen == nil {
        logger.Info().Msg("generating genesis block..")
Severity: Minor
Found in chain/chainservice.go - About 1 hr to fix

Cognitive Complexity

Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

A method's cognitive complexity is based on a few simple rules:

  • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
  • Code is considered more complex for each "break in the linear flow of the code"
  • Code is considered more complex when "flow breaking structures are nested"

Further reading

Function refreshAllVote has a Cognitive Complexity of 25 (exceeds 20 allowed). Consider refactoring.
Open

func refreshAllVote(context *SystemContext) error {
    var (
        scs          = context.scs
        account      = context.Sender.ID()
        staked       = context.Staked
Severity: Minor
Found in contract/system/vote.go - About 1 hr to fix

Cognitive Complexity

Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

A method's cognitive complexity is based on a few simple rules:

  • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
  • Code is considered more complex for each "break in the linear flow of the code"
  • Code is considered more complex when "flow breaking structures are nested"

Further reading

Method PolarisConnectSvc.initSvc has a Cognitive Complexity of 25 (exceeds 20 allowed). Consider refactoring.
Open

func (pcs *PolarisConnectSvc) initSvc(cfg *config.P2PConfig) {
    pcs.PrivateChain = !pcs.ntc.GenesisChainID().PublicNet
    if cfg.NPUsePolaris {
        // private network does not use public polaris
        if !pcs.PrivateChain {
Severity: Minor
Found in cmd/polaris/client/polarisconnect.go - About 1 hr to fix

Cognitive Complexity

Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

A method's cognitive complexity is based on a few simple rules:

  • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
  • Code is considered more complex for each "break in the linear flow of the code"
  • Code is considered more complex when "flow breaking structures are nested"

Further reading

Function runDeployCmd has 11 return statements (exceeds 4 allowed).
Open

func runDeployCmd(cmd *cobra.Command, args []string) error {
    var err error
    var code []byte
    var deployArgs []byte
Severity: Major
Found in cmd/aergocli/cmd/contract.go - About 1 hr to fix

    Function Call has a Cognitive Complexity of 25 (exceeds 20 allowed). Consider refactoring.
    Open

    func Call(
    contractState *statedb.ContractState,
    payload, contractAddress []byte,
    ctx *vmContext,
) (string, []*types.Event, *big.Int, error) {
    Severity: Minor
    Found in contract/vm.go - About 1 hr to fix

    Cognitive Complexity

    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

    A method's cognitive complexity is based on a few simple rules:

    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
    • Code is considered more complex for each "break in the linear flow of the code"
    • Code is considered more complex when "flow breaking structures are nested"

    Further reading

    Function contractFrame has 11 return statements (exceeds 4 allowed).
    Open

    func contractFrame(l luaTxContract, bs *state.BlockState, cdb contract.ChainAccessor, receiptTx db.Transaction,
    run func(s, c *state.AccountState, id types.AccountID, cs *statedb.ContractState) (string, []*types.Event, *big.Int, error)) error {

    creatorId := types.ToAccountID(l.sender())
    creatorState, err := state.GetAccountState(l.sender(), bs.StateDB)
    Severity: Major
    Found in contract/vm_dummy/vm_dummy.go - About 1 hr to fix

      Function luaECVerify has a Cognitive Complexity of 25 (exceeds 20 allowed). Consider refactoring.
      Open

      func luaECVerify(L *LState, service C.int, msg *C.char, sig *C.char, addr *C.char) (C.int, *C.char) {
    bMsg, err := decodeHex(C.GoString(msg))
    if err != nil {
        return -1, C.CString("[Contract.LuaEcVerify] invalid message format: " + err.Error())
    }
      Severity: Minor
      Found in contract/vm_callback.go - About 1 hr to fix

      Cognitive Complexity

      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

      A method's cognitive complexity is based on a few simple rules:

      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
      • Code is considered more complex for each "break in the linear flow of the code"
      • Code is considered more complex when "flow breaking structures are nested"

      Further reading

      Function luaECVerify has 11 return statements (exceeds 4 allowed).
      Open

      func luaECVerify(L *LState, service C.int, msg *C.char, sig *C.char, addr *C.char) (C.int, *C.char) {
    bMsg, err := decodeHex(C.GoString(msg))
    if err != nil {
        return -1, C.CString("[Contract.LuaEcVerify] invalid message format: " + err.Error())
    }
      Severity: Major
      Found in contract/vm_callback.go - About 1 hr to fix

        Function luaCallContract has a Cognitive Complexity of 25 (exceeds 20 allowed). Consider refactoring.
        Open

        func luaCallContract(L *LState, service C.int, contractId *C.char, fname *C.char, args *C.char,
    amount *C.char, gas uint64) (C.int, *C.char) {
    fnameStr := C.GoString(fname)
    argsStr := C.GoString(args)
        Severity: Minor
        Found in contract/vm_callback.go - About 1 hr to fix

        Cognitive Complexity

        Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

        A method's cognitive complexity is based on a few simple rules:

        • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
        • Code is considered more complex for each "break in the linear flow of the code"
        • Code is considered more complex when "flow breaking structures are nested"

        Further reading

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

        func (r *Receipt) MarshalMerkleBinaryV2() ([]byte, error) {
    var b bytes.Buffer

    err := r.marshalBodyV2(&b, true)
    if err != nil {
        Severity: Major
        Found in types/receipt.go and 1 other location - About 1 hr to fix
        types/receipt.go on lines 287..304

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 135.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

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

        func (r *Receipt) MarshalMerkleBinary() ([]byte, error) {
    var b bytes.Buffer

    err := r.marshalBody(&b, true)
    if err != nil {
        Severity: Major
        Found in types/receipt.go and 1 other location - About 1 hr to fix
        types/receipt.go on lines 306..323

        Duplicated Code

        Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

        Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

        When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

        Tuning

        This issue has a mass of 135.

        We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

        The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

        If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

        See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

        Refactorings

        Further Reading

        Method BlockFactory.generateBlock has 52 lines of code (exceeds 50 allowed). Consider refactoring.
        Open

        func (bf *BlockFactory) generateBlock(work *Work) (*types.Block, *state.BlockState, error) {
    var (
        bestBlock *types.Block
        err       error
    )
        Severity: Minor
        Found in consensus/impl/raftv2/blockfactory.go - About 1 hr to fix

          Method MemPool.dumpTxsToFile has 52 lines of code (exceeds 50 allowed). Consider refactoring.
          Open

          func (mp *MemPool) dumpTxsToFile() {
    if !mp.isRunning() {
        return
    }
    mp.Info().Msg("start mempool dump")
          Severity: Minor
          Found in mempool/mempool.go - About 1 hr to fix

            Method SQLiteStmt.bind has 52 lines of code (exceeds 50 allowed). Consider refactoring.
            Open

            func (s *SQLiteStmt) bind(args []namedValue) error {
    rv := C.sqlite3_reset(s.s)
    if rv != C.SQLITE_ROW && rv != C.SQLITE_OK && rv != C.SQLITE_DONE {
        return s.c.lastError()
    }
            Severity: Minor
            Found in contract/sqlite3.go - About 1 hr to fix

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

              func subTotal(scs *statedb.ContractState, amount *big.Int) error {
    data, err := scs.GetData(dbkey.SystemStakingTotal())
    if err != nil {
        return err
    }
              Severity: Major
              Found in contract/system/staking.go and 1 other location - About 1 hr to fix
              contract/system/staking.go on lines 158..165

              Duplicated Code

              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

              Tuning

              This issue has a mass of 134.

              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

              Refactorings

              Further Reading

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

              func addTotal(scs *statedb.ContractState, amount *big.Int) error {
    data, err := scs.GetData(dbkey.SystemStakingTotal())
    if err != nil {
        return err
    }
              Severity: Major
              Found in contract/system/staking.go and 1 other location - About 1 hr to fix
              contract/system/staking.go on lines 167..174

              Duplicated Code

              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

              Tuning

              This issue has a mass of 134.

              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

              Refactorings

              Further Reading

              Method MemPool.setStateDB has 51 lines of code (exceeds 50 allowed). Consider refactoring.
              Open

              func (mp *MemPool) setStateDB(block *types.Block) (bool, bool) {
    if mp.testConfig {
        return true, false
    }
              Severity: Minor
              Found in mempool/mempool.go - About 1 hr to fix

                Function luaGetDB has 51 lines of code (exceeds 50 allowed). Consider refactoring.
                Open

                func luaGetDB(L *LState, service C.int, key unsafe.Pointer, keyLen C.int, blkno *C.char) (*C.char, *C.char) {
    ctx := contexts[service]
    if ctx == nil {
        return nil, C.CString("[System.LuaGetDB] contract state not found")
    }
                Severity: Minor
                Found in contract/vm_callback.go - About 1 hr to fix

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

                  func (bh *getHashByNoResponseHandler) Handle(msg p2pcommon.Message, msgBody p2pcommon.MessageBody) {
    data := msgBody.(*types.GetHashByNoResponse)
    p2putil.DebugLogReceiveResponse(bh.logger, bh.protocol, msg.ID().String(), msg.OriginalID().String(), bh.peer, data)

    // locate request data and remove it if found
                  Severity: Major
                  Found in p2p/subproto/blockhash.go and 1 other location - About 1 hr to fix
                  p2p/subproto/block.go on lines 259..265

                  Duplicated Code

                  Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                  Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                  When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                  Tuning

                  This issue has a mass of 132.

                  We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                  The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                  If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                  See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                  Refactorings

                  Further Reading

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

                  func (bh *getAncestorResponseHandler) Handle(msg p2pcommon.Message, msgBody p2pcommon.MessageBody) {
    data := msgBody.(*types.GetAncestorResponse)
    p2putil.DebugLogReceiveResponse(bh.logger, bh.protocol, msg.ID().String(), msg.OriginalID().String(), bh.peer, data)

    // locate request data and remove it if found
                  Severity: Major
                  Found in p2p/subproto/block.go and 1 other location - About 1 hr to fix
                  p2p/subproto/blockhash.go on lines 190..196

                  Duplicated Code

                  Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                  Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                  When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                  Tuning

                  This issue has a mass of 132.

                  We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                  The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                  If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                  See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                  Refactorings

                  Further Reading

                  Severity
                  Category
                  Status
                  Source
                  Language