aergoio/aergo

Method AergoRPCService.GetReceipts has 65 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (rpc *AergoRPCService) GetReceipts(ctx context.Context, in *types.ReceiptsParams) (*types.ReceiptsPaged, error) {
    if err := rpc.checkAuth(ctx, ReadBlockChain); err != nil {
        return nil, err
    }

Method SQLiteDriver.Open has 65 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (d *SQLiteDriver) Open(dsn string) (driver.Conn, error) {
    if C.sqlite3_threadsafe() == 0 {
        return nil, errors.New("sqlite library was not compiled for thread-safe operation")
    }

Function CheckFeeDelegation has 65 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func CheckFeeDelegation(contractAddress []byte, bs *state.BlockState, bi *types.BlockHeaderInfo, cdb ChainAccessor,
    contractState *statedb.ContractState, payload, txHash, sender, amount []byte) (err error) {
    var ci types.CallInfo

    err = getCallInfo(&ci, payload, contractAddress)

Function luaECVerify has 65 lines of code (exceeds 50 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())
    }

Method ChainService.addBlockInternal has 17 return statements (exceeds 4 allowed).

Open

func (cs *ChainService) addBlockInternal(newBlock *types.Block, usedBState *state.BlockState, peerID types.PeerID) (err error, cache bool) {
    if !cs.VerifyTimestamp(newBlock) {
        return &ErrBlock{
            err: errBlockTimestamp,
            block: &types.BlockInfo{

Function luaSendAmount has 17 return statements (exceeds 4 allowed).

Open

func luaSendAmount(L *LState, service C.int, contractId *C.char, amount *C.char) *C.char {

    ctx := contexts[service]
    if ctx == nil {
        return C.CString("[Contract.LuaSendAmount] contract state not found")

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

Open

func (rpc *AergoRPCService) BroadcastToListBlockMetadataStream(meta *types.BlockMetadata) {
    var err error
    rpc.blockMetadataStreamLock.RLock()
    defer rpc.blockMetadataStreamLock.RUnlock()

• Read up
  Read up

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

Open

func (rpc *AergoRPCService) BroadcastToListBlockStream(block *types.Block) {
    var err error
    rpc.blockStreamLock.RLock()
    defer rpc.blockStreamLock.RUnlock()
    for _, stream := range rpc.blockStream {

• Read up
  Read up

Method WalDB.convertFromRaft has 64 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (wal *WalDB) convertFromRaft(entries []raftpb.Entry) ([]*consensus.WalEntry, []*types.Block, []*raftpb.ConfChange) {
    lenEnts := len(entries)
    if lenEnts == 0 {
        return nil, nil, nil
    }

Method Web3APIv1.ListEvents has 64 lines of code (exceeds 50 allowed). Consider refactoring.

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 ExecuteNameTx has 64 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func ExecuteNameTx(bs *state.BlockState, scs *statedb.ContractState, txBody *types.TxBody,
    sender, receiver *state.AccountState, blockInfo *types.BlockHeaderInfo) ([]*types.Event, error) {

    ci, err := ValidateNameTx(txBody, sender, scs)
    if err != nil {

Function Execute has 64 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func Execute(execCtx context.Context, bs *state.BlockState, cdb ChainAccessor, tx *types.Tx, sender, receiver *state.AccountState, bi *types.BlockHeaderInfo, executionMode int, isFeeDelegation bool) (rv string, events []*types.Event, usedFee *big.Int, err error) {

    var (
        txBody     = tx.GetBody()
        txType     = txBody.GetType()

Method blockRequestHandler.handleBlkReq has 63 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (bh *blockRequestHandler) handleBlkReq(msg p2pcommon.Message, data *types.GetBlockRequest) {
    defer bh.release()
    remotePeer := bh.peer

    requestID := msg.ID()

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

Open

func (r *Receipt) unmarshalStoreBinary(data []byte) ([]byte, error) {
    evData, evCount := r.unmarshalBody(data)

    r.Events = make([]*Event, evCount)
    var err error

• Read up
  Read up

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

Open

func (r *Receipt) unmarshalStoreBinaryV2(data []byte) ([]byte, error) {
    evData, evCount := r.unmarshalBodyV2(data)

    r.Events = make([]*Event, evCount)
    var err error

• Read up
  Read up

Method SQLiteConn.RegisterAggregator has 16 return statements (exceeds 4 allowed).

Open

func (c *SQLiteConn) RegisterAggregator(name string, impl interface{}, pure bool) error {
    var ai aggInfo
    ai.constructor = reflect.ValueOf(impl)
    t := ai.constructor.Type()
    if t.Kind() != reflect.Func {

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

Open

            if ctx.traceFile != nil {
                _, _ = ctx.traceFile.WriteString(fmt.Sprintf("[GOVERNANCE]aid(%s)\n", aid.String()))
                _, _ = ctx.traceFile.WriteString(fmt.Sprintf("snapshot set %d\n", seq))
                _, _ = ctx.traceFile.WriteString(fmt.Sprintf("unstaking : %s\n", amountBig.String()))
                _, _ = ctx.traceFile.WriteString(fmt.Sprintf("After sender: %s receiver: %s\n",

• Read up
  Read up

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

Open

            if ctx.traceFile != nil {
                _, _ = ctx.traceFile.WriteString(fmt.Sprintf("[GOVERNANCE]aid(%s)\n", aid.String()))
                _, _ = ctx.traceFile.WriteString(fmt.Sprintf("snapshot set %d\n", seq))
                _, _ = ctx.traceFile.WriteString(fmt.Sprintf("staking : %s\n", amountBig.String()))
                _, _ = ctx.traceFile.WriteString(fmt.Sprintf("After sender: %s receiver: %s\n",

• Read up
  Read up

Function execVote has 62 lines of code (exceeds 50 allowed). Consider refactoring.

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 AergoRPCService.getChainInfo has 61 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (rpc *AergoRPCService) getChainInfo(ctx context.Context) (*types.ChainInfo, error) {
    chainInfo := &types.ChainInfo{}

    if genesisInfo := rpc.actorHelper.GetChainAccessor().GetGenesisInfo(); genesisInfo != nil {
        ca := rpc.actorHelper.GetChainAccessor()