Function modules has 26 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    const modules = callKeys.map((section) => {
      const calls = definitions[section];

      const allMethods = Object.keys(calls).sort().map((methodName) => {
        const def = calls[methodName];

Function calcVesting has 26 lines of code (exceeds 25 allowed). Consider refactoring.

Open

function calcVesting (bestNumber: BlockNumber, shared: DeriveBalancesAllAccountData, _vesting: PalletVestingVestingInfo[] | null): DeriveBalancesAllVesting {
  // Calculate the vesting balances,
  //  - offset = balance locked at startingBlock
  //  - perBlock is the unlock amount
  const vesting = _vesting || [];

Consider simplifying this complex logical expression.

Open

      if (type === 'Bytes') {
        portable = registry.lookup.types.find((t) =>
          (
            t.type.def.isSequence &&
            t.type.def.asSequence.type.eq(u8.id)

Function getWSErrorString has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.

Open

export function getWSErrorString (code: number): string {
  if (code >= 0 && code <= 999) {
    return '(Unused)';
  } else if (code >= 1016) {
    if (code <= 1999) {

• Read up
  Read up

Function calcShared has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.

Open

function calcShared (api: DeriveApi, bestNumber: BlockNumber, data: DeriveBalancesAccountData, locks: (PalletBalancesBalanceLock | BalanceLockTo212)[]): DeriveBalancesAllAccountData {
  const { allLocked, lockedBalance, lockedBreakdown, vestingLocked } = calcLocked(api, bestNumber, locks);
  let transferable = null;

  if (data?.frameSystemAccountInfo?.frozen) {

• Read up
  Read up

Function typeSplit has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.

Open

export function typeSplit (type: string): string[] {
  const result: string[] = [];

  // these are the depths of the various tokens: <, [, {, (
  let c = 0;

• Read up
  Read up

Function createValue has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.

Open

function createValue (registry: Registry, type: string, value: unknown, asArray = true): Option<Codec> {
  // We detect codec here as well - when found, generally this is constructed from itself
  if (value && isFunction((value as Option<Codec>).unwrapOrDefault)) {
    return value as Option<Codec>;
  }

• Read up
  Read up

Function _decodeFixedVec has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.

Open

function _decodeFixedVec (value: TypeDef, type: string, _: string, count: number): TypeDef {
  const max = type.length - 1;
  let index = -1;
  let inner = 0;

• Read up
  Read up

Function generateCallTypes has 6 arguments (exceeds 4 allowed). Consider refactoring.

Open

export function generateCallTypes (registry: Registry, meta: Metadata, dest: string, extraTypes: ExtraTypes, isStrict: boolean, customLookupDefinitions?: Definitions): void {

Avoid deeply nested control flow statements.

Open

          if (ver) {
            const methods = Object.entries(ver.methods);
            const mcount = methods.length;

            if (mcount) {

Function getModules has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

function getModules (api: DeriveApi): [string, string | null] {
  const [council] = api.registry.getModuleInstances(api.runtimeVersion.specName, 'council') || ['council'];
  const elections = api.query['phragmenElection']
    ? 'phragmenElection'
    : api.query['electionsPhragmen']

• Read up
  Read up

Function splitAlternatives has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

function splitAlternatives (type: string): string[] {
  const alternatives = [];
  let beginOfAlternative = 1;
  let level = 0;

• Read up
  Read up

Function filterEvents has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

export function filterEvents (txHash: H256, { block: { extrinsics, header } }: SignedBlock, allEvents: EventRecord[], status: ExtrinsicStatus): { events?: EventRecord[], txIndex?: number, blockNumber?: BlockNumber } {
  // extrinsics to hashes
  for (const [txIndex, x] of extrinsics.entries()) {
    if (x.hash.eq(txHash)) {
      return {

• Read up
  Read up

Function dualParamsNotation has 6 arguments (exceeds 4 allowed). Consider refactoring.

Open

function dualParamsNotation (registry: Registry, wrapper: string, typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, withShortcut: boolean): string {

Function extractStorageArgs has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

export function extractStorageArgs (registry: Registry, creator: StorageEntry, _args: unknown[]): [StorageEntry, unknown[]] {
  const args = _args.filter((a) => !isUndefined(a));

  if (creator.meta.type.isPlain) {
    if (args.length !== 0) {

• Read up
  Read up

Function generateForMeta has 6 arguments (exceeds 4 allowed). Consider refactoring.

Open

function generateForMeta (registry: Registry, meta: Metadata, dest: string, extraTypes: ExtraTypes, isStrict: boolean, customLookupDefinitions?: Definitions): void {

Avoid deeply nested control flow statements.

Open

                  if (!skipInspectType) {
                    it(`output ${type} is known`, (): void => {
                      expect(() => inspectType(type)).not.toThrow();
                    });
                  }

Function singleParamNotation has 6 arguments (exceeds 4 allowed). Consider refactoring.

Open

function singleParamNotation (registry: Registry, wrapper: string, typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, withShortcut: boolean): string {

Function tsResultGetter has 6 arguments (exceeds 4 allowed). Consider refactoring.

Open

function tsResultGetter (registry: Registry, definitions: Record<string, ModuleTypes>, resultName = '', getter: 'Ok' | 'Err', def: TypeDef, imports: TypeImports): string {

Function entrySignature has 6 arguments (exceeds 4 allowed). Consider refactoring.

Open

function entrySignature (lookup: PortableRegistry, allDefs: Record<string, ModuleTypes>, registry: Registry, section: string, storageEntry: StorageEntryMetadataLatest, imports: TypeImports): [boolean, string, string, string] {