Function isUtf8 has a Cognitive Complexity of 127 (exceeds 5 allowed). Consider refactoring.

Open

export function isUtf8 (value?: number[] | Uint8Array | string | null): boolean {
  if (!value) {
    return isString(value);
  }

• Read up
  Read up

Function _formatBalance has a Cognitive Complexity of 33 (exceeds 5 allowed). Consider refactoring.

Open

function _formatBalance <ExtToBn extends ToBn> (input?: number | string | BN | bigint | ExtToBn, { decimals = defaultDecimals, forceUnit, locale = 'en', withAll = false, withSi = true, withSiFull = false, withUnit = true, withZero = true }: Options = {}): string {
  // we only work with string inputs here - convert anything
  // into the string-only value
  let text = bnToBn(input).toString();

• Read up
  Read up

Function isUtf8 has 99 lines of code (exceeds 25 allowed). Consider refactoring.

Open

export function isUtf8 (value?: number[] | Uint8Array | string | null): boolean {
  if (!value) {
    return isString(value);
  }

Function crypto_onetimeauth has a Cognitive Complexity of 27 (exceeds 5 allowed). Consider refactoring.

Open

function crypto_onetimeauth (out: Uint8Array, outpos: number, m: Uint8Array, mpos: number, n: number, k: Uint8Array): number {
  let i, j, u;
  const x = new Uint32Array(17), r = new Uint32Array(17), h = new Uint32Array(17), c = new Uint32Array(17), g = new Uint32Array(17);
  for (j = 0; j < 17; j++) r[j]=h[j]=0;
  for (j = 0; j < 16; j++) r[j]=k[j];

• Read up
  Read up

Function createPair has a Cognitive Complexity of 27 (exceeds 5 allowed). Consider refactoring.

Open

export function createPair ({ toSS58, type }: Setup, { publicKey, secretKey }: PairInfo, meta: KeyringPair$Meta = {}, encoded: Uint8Array | null = null, encTypes?: EncryptedJsonEncoding[]): KeyringPair {
  const decodePkcs8 = (passphrase?: string, userEncoded?: Uint8Array | null): void => {
    const decoded = decodePair(passphrase, userEncoded || encoded, encTypes);

    if (decoded.secretKey.length === 64) {

• Read up
  Read up

Function core has a Cognitive Complexity of 23 (exceeds 5 allowed). Consider refactoring.

Open

function core (out: Uint8Array, inp: Uint8Array, k: Uint8Array, c: Uint8Array, h: boolean): void {
  const w = new Uint32Array(16), x = new Uint32Array(16), y = new Uint32Array(16), t = new Uint32Array(4);
  let i, j, m;

  for (i = 0; i < 4; i++) {

• Read up
  Read up

Function bnToBn has a Cognitive Complexity of 21 (exceeds 5 allowed). Consider refactoring.

Open

export function bnToBn <ExtToBn extends ToBigInt | ToBn> (value?: ExtToBn | BN | bigint | string | number | null): BN {
  return value
    ? BN.isBN(value)
      ? value
      : isHex(value)

• Read up
  Read up

Function nToBigInt has a Cognitive Complexity of 21 (exceeds 5 allowed). Consider refactoring.

Open

export function nToBigInt <ExtToBn extends ToBigInt | ToBn> (value?: ExtToBn | BN | bigint | string | number | null): bigint {
  return typeof value === 'bigint'
    ? value
    : !value
      ? BigInt(0)

• Read up
  Read up

Function crypto_stream_salsa20_xor has a Cognitive Complexity of 19 (exceeds 5 allowed). Consider refactoring.

Open

function crypto_stream_salsa20_xor (c: Uint8Array, cpos: number, m: Uint8Array | null, mpos: number, b: number, n: Uint8Array, k: Uint8Array): number {
  const z = new Uint8Array(16), x = new Uint8Array(64);
  let u, i;
  if (!b) return 0;
  for (i = 0; i < 16; i++) z[i] = 0;

• Read up
  Read up

Function u8aToBigInt has a Cognitive Complexity of 17 (exceeds 5 allowed). Consider refactoring.

Open

export function u8aToBigInt (value: Uint8Array, { isLe = true, isNegative = false }: ToBnOptions = {}): bigint {
  // slice + reverse is expensive, however SCALE is LE by default so this is the path
  // we are most interested in (the BE is added for the sake of being comprehensive)
  if (!isLe) {
    value = value.slice().reverse();

• Read up
  Read up

Function crypto_onetimeauth has 46 lines of code (exceeds 25 allowed). Consider refactoring.

Open

function crypto_onetimeauth (out: Uint8Array, outpos: number, m: Uint8Array, mpos: number, n: number, k: Uint8Array): number {
  let i, j, u;
  const x = new Uint32Array(17), r = new Uint32Array(17), h = new Uint32Array(17), c = new Uint32Array(17), g = new Uint32Array(17);
  for (j = 0; j < 17; j++) r[j]=h[j]=0;
  for (j = 0; j < 16; j++) r[j]=k[j];

Function core has 33 lines of code (exceeds 25 allowed). Consider refactoring.

Open

function core (out: Uint8Array, inp: Uint8Array, k: Uint8Array, c: Uint8Array, h: boolean): void {
  const w = new Uint32Array(16), x = new Uint32Array(16), y = new Uint32Array(16), t = new Uint32Array(4);
  let i, j, m;

  for (i = 0; i < 4; i++) {

Function u8aEq has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.

Open

export function u8aEq (a: string | Uint8Array, b: string | Uint8Array): boolean {
  const u8aa = u8aToU8a(a);
  const u8ab = u8aToU8a(b);

  if (u8aa.length === u8ab.length) {

• Read up
  Read up

Function objectSpread has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.

Open

export function objectSpread <T extends object> (dest: object, ...sources: (object | undefined | null)[]): T {
  for (let i = 0, count = sources.length; i < count; i++) {
    const src = sources[i];

    if (src) {

• Read up
  Read up

Function init has 31 lines of code (exceeds 25 allowed). Consider refactoring.

Open

function init (seed: bigint, input: Uint8Array): State {
  const state = {
    seed,
    u8a: new Uint8Array(32),
    u8asize: 0,

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

Open

export function u8aCmp (a: string | Uint8Array, b: string | Uint8Array): number {
  const u8aa = u8aToU8a(a);
  const u8ab = u8aToU8a(b);
  let i = 0;

• Read up
  Read up

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

Open

export function xxhash64 (input: Uint8Array, initSeed: bigint | number): Uint8Array {
  const { seed, u8a, u8asize, v1, v2, v3, v4 } = init(BigInt(initSeed), input);
  let p = 0;
  let h64 = U64 & (BigInt(input.length) + (
    input.length >= 32

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

Open

export function mnemonicToEntropy (mnemonic: string, wordlist: string[] = DEFAULT_WORDLIST): Uint8Array {
  const words = normalize(mnemonic).split(' ');

  if (words.length % 3 !== 0) {
    throw new Error(INVALID_MNEMONIC);

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

Open

function crypto_stream_xor (c: Uint8Array, cpos: number, m: Uint8Array | null, mpos: number, d: number, n: Uint8Array, k: Uint8Array): number {

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

Open

function crypto_stream_salsa20_xor (c: Uint8Array, cpos: number, m: Uint8Array | null, mpos: number, b: number, n: Uint8Array, k: Uint8Array): number {