Fantom-foundation/go-lachesis

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

Open

func (_Contract *ContractCaller) RewardsStash(opts *bind.CallOpts, arg0 common.Address, arg1 *big.Int) (*big.Int, error) {
    var (
        ret0 = new(*big.Int)
    )
    out := ret0

• Read up
  Read up

Function ForEachRandFork has 7 arguments (exceeds 4 allowed). Consider refactoring.

Open

    nodes []idx.StakerID,
    cheatersArr []idx.StakerID,
    eventCount int,
    parentCount int,
    forksCount int,

Method Emitter.isMyTxTurn has 7 arguments (exceeds 4 allowed). Consider refactoring.

Open

func (em *Emitter) isMyTxTurn(txHash common.Hash, sender common.Address, accountNonce uint64, now time.Time, validatorsArr []idx.StakerID, validatorsArrStakes []pos.Stake, me idx.StakerID) bool {

Method Checker.Validate has 8 return statements (exceeds 4 allowed).

Open

func (v *Checker) Validate(e *inter.Event, parents []*inter.EventHeaderData) error {
    if len(e.Parents) != len(parents) {
        panic("parentscheck: expected event's parents as an argument")
    }

Method PublicTransactionPoolAPI.SignTransaction has 8 return statements (exceeds 4 allowed).

Open

func (s *PublicTransactionPoolAPI) SignTransaction(ctx context.Context, args SendTxArgs) (*SignTransactionResult, error) {
    if args.Gas == nil {
        return nil, fmt.Errorf("gas not specified")
    }
    if args.GasPrice == nil {

Method PublicSfcAPI.addStakerMetricFields has 8 return statements (exceeds 4 allowed).

Open

func (s *PublicSfcAPI) addStakerMetricFields(ctx context.Context, res map[string]interface{}, stakerID idx.StakerID) (map[string]interface{}, error) {
    blocks, period, err := s.b.GetDowntime(ctx, idx.StakerID(stakerID))
    if err != nil {
        return nil, err
    }

Method PublicTransactionPoolAPI.Resend has 8 return statements (exceeds 4 allowed).

Open

func (s *PublicTransactionPoolAPI) Resend(ctx context.Context, sendArgs SendTxArgs, gasPrice *hexutil.Big, gasLimit *hexutil.Uint64) (common.Hash, error) {
    if sendArgs.Nonce == nil {
        return common.Hash{}, fmt.Errorf("missing transaction nonce in transaction spec")
    }
    if err := sendArgs.setDefaults(ctx, s.b); err != nil {

Method peer.readStatus has 8 return statements (exceeds 4 allowed).

Open

func (p *peer) readStatus(network uint64, status *ethStatusData, genesis common.Hash) (err error) {
    msg, err := p.rw.ReadMsg()
    if err != nil {
        return err
    }

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

Open

func lachesisOperaMigrationMain(ctx *cli.Context) error {
    if args := ctx.Args(); len(args) > 0 {
        return fmt.Errorf("invalid command: %q", args[0])
    }

Method row.Position has 8 return statements (exceeds 4 allowed).

Open

func (r *row) Position(i int) position {
    // if left
    if i < r.Self {
        if i < r.First {
            return none

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

Open

func importFile(srv *gossip.Service, check bool, fn string) error {
    // Watch for Ctrl-C while the import is running.
    // If a signal is received, the import will stop.
    interrupt := make(chan os.Signal, 1)
    signal.Notify(interrupt, syscall.SIGINT, syscall.SIGTERM)

Method Emitter.isSynced has 8 return statements (exceeds 4 allowed).

Open

func (em *Emitter) isSynced() (bool, string, time.Duration) {
    if em.intervals.SelfForkProtection == 0 {
        return true, "", 0 // protection disabled
    }
    if em.world.PeersNum() == 0 {

Identical blocks of code found in 5 locations. Consider refactoring.

Open

func NewContract(address common.Address, backend bind.ContractBackend) (*Contract, error) {
    contract, err := bindContract(address, backend, backend, backend)
    if err != nil {
        return nil, err
    }

• Read up
  Read up

Identical blocks of code found in 5 locations. Consider refactoring.

Open

func NewContract(address common.Address, backend bind.ContractBackend) (*Contract, error) {
    contract, err := bindContract(address, backend, backend, backend)
    if err != nil {
        return nil, err
    }

• Read up
  Read up

Identical blocks of code found in 5 locations. Consider refactoring.

Open

func NewContract(address common.Address, backend bind.ContractBackend) (*Contract, error) {
    contract, err := bindContract(address, backend, backend, backend)
    if err != nil {
        return nil, err
    }

• Read up
  Read up

Identical blocks of code found in 5 locations. Consider refactoring.

Open

func NewContract(address common.Address, backend bind.ContractBackend) (*Contract, error) {
    contract, err := bindContract(address, backend, backend, backend)
    if err != nil {
        return nil, err
    }

• Read up
  Read up

Identical blocks of code found in 5 locations. Consider refactoring.

Open

func NewContract(address common.Address, backend bind.ContractBackend) (*Contract, error) {
    contract, err := bindContract(address, backend, backend, backend)
    if err != nil {
        return nil, err
    }

• Read up
  Read up

Identical blocks of code found in 5 locations. Consider refactoring.

Open

func bindContract(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
    parsed, err := abi.JSON(strings.NewReader(ContractABI))
    if err != nil {
        return nil, err
    }

• Read up
  Read up

Identical blocks of code found in 5 locations. Consider refactoring.

Open

func bindContract(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
    parsed, err := abi.JSON(strings.NewReader(ContractABI))
    if err != nil {
        return nil, err
    }

• Read up
  Read up

Identical blocks of code found in 5 locations. Consider refactoring.

Open

func bindContract(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
    parsed, err := abi.JSON(strings.NewReader(ContractABI))
    if err != nil {
        return nil, err
    }

• Read up
  Read up