Function generateForMeta has 28 lines of code (exceeds 25 allowed). Consider refactoring.

Open

function generateForMeta (meta: Metadata, dest: string, isStrict: boolean): void {
  writeFile(dest, (): string => {
    const imports = createImports({});
    const { lookup, pallets } = meta.asLatest;
    const modules = pallets

Function generateLookupDefs has 28 lines of code (exceeds 25 allowed). Consider refactoring.

Open

function generateLookupDefs (registry: Registry, filtered: [PortableType, TypeDef][], destDir: string, subPath?: string): void {
  writeFile(path.join(destDir, `${subPath || 'definitions'}.ts`), (): string => {
    const all = filtered.map(([{ id, type: { params, path } }, typeDef]) => {
      const typeLookup = registry.createLookupType(id);
      const def = expandDefToString(typeDef, subPath ? 2 : 4);

Function splitAlternatives has 28 lines of code (exceeds 25 allowed). Consider refactoring.

Open

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

Function refCountDelay has 28 lines of code (exceeds 25 allowed). Consider refactoring.

Open

export function refCountDelay <T> (delay = 1750): MonoTypeOperatorFunction<T> {
  return (source: Observable<T>): Observable<T> => {
    // state: 0 = disconnected, 1 = disconnecting, 2 = connecting, 3 = connected
    let [state, refCount, connection, scheduler] = [0, 0, Subscription.EMPTY, Subscription.EMPTY];

Function getWsData has 28 lines of code (exceeds 25 allowed). Consider refactoring.

Open

async function getWsData <T> (endpoint: string, method: 'rpc_methods' | 'state_getMetadata' | 'state_getRuntimeVersion'): Promise<T> {
  return new Promise((resolve, reject): void => {
    const tracker = promiseTracker<T>(resolve, reject);

    try {

Function testTypes has 28 lines of code (exceeds 25 allowed). Consider refactoring.

Open

function testTypes (type: string, typeNames: string[]): void {
  describe(`${type}`, (): void => {
    describe(`${type}:: default creation`, (): void => {
      typeNames.forEach((name): void => {
        it(`creates an empty ${name}`, (): void => {

Function mainPromise has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

Open

async function mainPromise (): Promise<void> {
  const { chain, endpoint } = yargs(hideBin(process.argv)).strict().options({
    chain: {
      description: 'The chain name to use for the output (defaults to "Substrate")',
      type: 'string'

• Read up
  Read up

Function getAuthorDetailsWithAt has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

Open

function getAuthorDetailsWithAt (header: Header, queryAt: QueryableStorage<'rxjs'>): Observable<[Header, Vec<AccountId> | null, AccountId | null]> {
  const validators = queryAt.session?.validators
    ? queryAt.session.validators()
    : of(null);

• Read up
  Read up

Function addStorage has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

Open

function addStorage (runtimeDesc: string, { lookup, pallets, registry }: MetadataLatest): string {
  const { substrate } = getSubstrateStorage(registry);
  const moduleSections = pallets
    .sort(sortByName)
    .filter((moduleMetadata) => !moduleMetadata.storage.isNone)

• Read up
  Read up

Function addRuntime has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

Open

function addRuntime (_runtimeDesc: string, apis?: ApiDef[]): string {
  return renderPage({
    description: 'The following section contains known runtime calls that may be available on specific runtimes (depending on configuration and available pallets). These call directly into the WASM runtime for queries and operations.',
    sections: Object
      .keys(definitions)

• Read up
  Read up

Function decodeValue has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

Open

function decodeValue (registry: Registry, key: string, value: unknown): unknown {
  return key === 'ss58Format'
    ? createValue(registry, 'Option<u32>', value, false)
    : key === 'tokenDecimals'
      ? createValue(registry, 'Option<Vec<u32>>' as 'Vec<u32>', value)

• Read up
  Read up

Function findSiType has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

Open

function findSiType (registry: Registry, type: string): PortableType | undefined {
  let portable = findSiPrimitive(registry, type);

  // some types are either Sequence or Arrays, cater for these
  // specifically (these all come from the base substrate known keys)

• Read up
  Read up

Function getFakeClient has 27 lines of code (exceeds 25 allowed). Consider refactoring.

Open

function getFakeClient () {
  const chains: MockChain[] = [];
  let addChainInterceptor: Promise<void> = Promise.resolve();
  let addWellKnownChainInterceptor: Promise<void> = Promise.resolve();

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 || [];

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

Open

export function account (instanceId: string, api: DeriveApi): (address: AccountIndex | AccountId | Address | string) => Observable<DeriveBalancesAccount> {
  const balanceInstances = api.registry.getModuleInstances(api.runtimeVersion.specName, 'balances');
  const nonDefaultBalances = balanceInstances && balanceInstances[0] !== 'balances';

  return memo(instanceId, (address: AccountIndex | AccountId | Address | string): Observable<DeriveBalancesAccount> =>

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

Open

export function _ownExposures (instanceId: string, api: DeriveApi): (accountId: Uint8Array | string, eras: EraIndex[], withActive: boolean, page: u32 | AnyNumber) => Observable<DeriveOwnExposure[]> {
  return memo(instanceId, (accountId: Uint8Array | string, eras: EraIndex[], _withActive: boolean, page: u32 | AnyNumber): Observable<DeriveOwnExposure[]> => {
    const emptyStakingExposure = api.registry.createType<SpStakingExposure>('Exposure');
    // The reason we don't explicitly make the actual types is for compatibility. If the chain doesn't have the noted type it will fail
    // on construction. Therefore we just make an empty option.

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];

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 _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