@polkadot/util

Variables

• BN_BILLION
• BN_EIGHT
• BN_FIVE
• BN_FOUR
• BN_HUNDRED
• BN_MAX_INTEGER
• BN_MILLION
• BN_NINE
• BN_ONE
• BN_QUINTILL
• BN_SEVEN
• BN_SIX
• BN_SQRT_MAX_INTEGER
• BN_TEN
• BN_THOUSAND
• BN_THREE
• BN_TWO
• BN_ZERO
• formatBalance
• hasBigInt
• hasBuffer
• hasCjs
• hasDirname
• hasEsm
• hasProcess
• hasWasm
• packageInfo

Functions

• arrayChunk()
• arrayFilter()
• arrayFlatten()
• arrayRange()
• arrayShuffle()
• arrayUnzip()
• arrayZip()
• assert()
• assertReturn()
• assertUnreachable()
• bnFromHex()
• bnMax()
• bnMin()
• bnSqrt()
• bnToBn()
• bnToHex()
• bnToU8a()
• bufferToU8a()
• compactAddLength()
• compactFromU8a()
• compactFromU8aLim()
• compactStripLength()
• compactToU8a()
• detectPackage()
• extractTime()
• floatToU8a()
• formatDate()
• formatDecimal()
• formatElapsed()
• formatNumber()
• hexAddPrefix()
• hexFixLength()
• hexHasPrefix()
• hexStripPrefix()
• hexToBigInt()
• hexToBn()
• hexToNumber()
• hexToString()
• hexToU8a()
• isArray()
• isAscii()
• isBigInt()
• isBn()
• isBoolean()
• isBuffer()
• isChildClass()
• isClass()
• isCodec()
• isCompact()
• isError()
• isFunction()
• isHex()
• isInstanceOf()
• isIp()
• isJsonObject()
• isNull()
• isNumber()
• isObject()
• isObservable()
• isPromise()
• isString()
• isTestChain()
• isToBigInt()
• isToBn()
• isU8a()
• isUndefined()
• isUtf8()
• isWasm()
• lazyMethod()
• lazyMethods()
• logger()
• loggerFormat()
• memoize()
• nextTick()
• nMax()
• nMin()
• nSqrt()
• nToBigInt()
• nToHex()
• nToU8a()
• numberToHex()
• numberToU8a()
• objectClear()
• objectCopy()
• objectEntries()
• objectKeys()
• objectProperties()
• objectProperty()
• objectSpread()
• objectValues()
• promisify()
• stringCamelCase()
• stringify()
• stringLowerFirst()
• stringPascalCase()
• stringShorten()
• stringToHex()
• stringToU8a()
• stringUpperFirst()
• u8aCmp()
• u8aConcat()
• u8aConcatStrict()
• u8aEmpty()
• u8aEq()
• u8aFixLength()
• u8aSorted()
• u8aToBigInt()
• u8aToBn()
• u8aToBuffer()
• u8aToFloat()
• u8aToHex()
• u8aToNumber()
• u8aToString()
• u8aToU8a()
• u8aUnwrapBytes()
• u8aWrapBytes()

variable BN_BILLION

const BN_BILLION: BN;

• BN_BILLION BN constant for 1,000,000,000.

variable BN_EIGHT

const BN_EIGHT: BN;

• BN_EIGHT BN constant for 8.

variable BN_FIVE

const BN_FIVE: BN;

• BN_FIVE BN constant for 5.

variable BN_FOUR

const BN_FOUR: BN;

• BN_FOUR BN constant for 4.

variable BN_HUNDRED

const BN_HUNDRED: BN;

• BN_HUNDRED BN constant for 100.

variable BN_MAX_INTEGER

const BN_MAX_INTEGER: BN;

• BN_MAX_INTEGER BN constant for MAX_SAFE_INTEGER

variable BN_MILLION

const BN_MILLION: BN;

• BN_MILLION BN constant for 1,000,000.

variable BN_NINE

const BN_NINE: BN;

• BN_NINE BN constant for 9.

variable BN_ONE

const BN_ONE: BN;

• BN_ONE BN constant for 1.

variable BN_QUINTILL

const BN_QUINTILL: BN;

• BN_QUINTILL BN constant for 1,000,000,000,000,000,000.

variable BN_SEVEN

const BN_SEVEN: BN;

• BN_SEVEN BN constant for 7.

variable BN_SIX

const BN_SIX: BN;

• BN_SIX BN constant for 6.

variable BN_SQRT_MAX_INTEGER

const BN_SQRT_MAX_INTEGER: BN;

• BN_SQRT_MAX_INTEGER BN constant for Math.sqrt(MAX_SAFE_INTEGER)

variable BN_TEN

const BN_TEN: BN;

• BN_TEN BN constant for 10.

variable BN_THOUSAND

const BN_THOUSAND: BN;

• BN_THOUSAND BN constant for 1,000.

variable BN_THREE

const BN_THREE: BN;

• BN_THREE BN constant for 3.

variable BN_TWO

const BN_TWO: BN;

• BN_TWO BN constant for 2.

variable BN_ZERO

const BN_ZERO: BN;

• BN_ZERO BN constant for 0.

variable formatBalance

const formatBalance: BalanceFormatter;

variable hasBigInt

const hasBigInt: boolean;

• true if the environment has proper BigInt support

variable hasBuffer

const hasBuffer: boolean;

• true if the environment has support for Buffer (typically Node.js)

variable hasCjs

const hasCjs: boolean;

• true if the environment is CJS

variable hasDirname

const hasDirname: boolean;

• true if the environment has __dirname available

variable hasEsm

const hasEsm: boolean;

• true if the environment is ESM

variable hasProcess

const hasProcess: boolean;

• true if the environment has process available (typically Node.js)

variable hasWasm

const hasWasm: boolean;

• true if the environment has WebAssembly available

variable packageInfo

const packageInfo: { name: string; path: string; type: string; version: string };

function arrayChunk

arrayChunk: <T>(array: T[], chunkSize: number) => T[][];

• arrayChunk Split T[] into T[][] based on the defind size Returns a set ao arrays based on the chunksize

  Example 1

  import { arrayChunk } from '@polkadot/util';
  
  arrayChunk([1, 2, 3, 4, 5]); // [[1, 2], [3, 4], [5]]

function arrayFilter

arrayFilter: <T = unknown>(
    array: readonly (T | null | undefined)[],
    allowNulls?: boolean
) => T[];

• arrayFilter Filters undefined and (optionally) null values from an array Returns a new array with all undefined values removed. Optionally, when allowNulls = false, it removes the null values as well

  Example 1

  import { arrayFilter } from '@polkadot/util';
  
  arrayFilter([0, void 0, true, null, false, '']); // [0, true, null, false, '']
  arrayFilter([0, void 0, true, null, false, ''], false); // [0, true, false, '']

function arrayFlatten

arrayFlatten: <T>(arrays: readonly T[][]) => T[];

• arrayFlatten Merge T[][] into T[] Returns a new array with all arrays merged into one

  Example 1

  import { arrayFlatten } from '@polkadot/util';
  
  arrayFlatten([[1, 2], [3, 4], [5]]); // [1, 2, 3, 4, 5]

function arrayRange

arrayRange: (size: number, startAt?: number) => number[];

• arrayRange Returns a range of numbers ith the size and the specified offset Returns a new array of numbers with the specific size. Optionally, when startAt, is provided, it generates the range to start at a specific value.

  Example 1

  import { arrayRange } from '@polkadot/util';
  
  arrayRange(5); // [0, 1, 2, 3, 4]
  arrayRange(3, 5); // [5, 6, 7]

function arrayShuffle

arrayShuffle: <T>(input: readonly T[]) => T[];

• arrayShuffle Shuffles the input array (unlike sort, this is not done in-place)

function arrayUnzip

arrayUnzip: <K, V>(entries: readonly [K, V][]) => [K[], V[]];

• arrayUnzip Splits a single [K, V][] into [K[], V[]]

function arrayZip

arrayZip: <K, V>(keys: readonly K[], values: readonly V[]) => [K, V][];

• arrayZip Combines 2 distinct key/value arrays into a single [K, V] array

function assert

assert: (condition: unknown, message: string | MessageFn) => asserts condition;

• assert Checks for a valid test, if not Error is thrown. Checks that test is a truthy value. If value is falsy (null, undefined, false, ...), it throws an Error with the supplied message. When test passes, true is returned.

  Example 1

  const { assert } from '@polkadot/util';
  
  assert(true, 'True should be true'); // passes
  assert(false, 'False should not be true'); // Error thrown
  assert(false, () => 'message'); // Error with 'message'

function assertReturn

assertReturn: <T>(value: T | undefined | null, message: string | MessageFn) => T;

• assertReturn Returns when the value is not undefined/null, otherwise throws assertion error

function assertUnreachable

assertUnreachable: (x: never) => never;

• assertUnreachable An assertion helper that ensures all codepaths are followed

function bnFromHex

bnFromHex: (value?: string | null, { isLe, isNegative }?: ToBnOptions) => BN;

• hexToBn Creates a BN.js object from a hex string. null inputs returns a BN(0) result. Hex input values return the actual value converted to a BN. Anything that is not a hex string (including the 0x prefix) throws an error.

  Parameter _value

  The value to convert

  Parameter _options

  Options to pass while converting

  Parameter

  _options.isLe Convert using Little Endian

  Parameter

  _options.isNegative Convert using two's complement

  Example 1

  import { hexToBn } from '@polkadot/util';
  
  hexToBn('0x123480001f'); // => BN(0x123480001f)

function bnMax

bnMax: (...items: BN[]) => BN;

• bnMax Finds and returns the highest value in an array of BNs.

  Example 1

  import BN from 'bn.js';
  import { bnMax } from '@polkadot/util';
  
  bnMax([new BN(1), new BN(3), new BN(2)]).toString(); // => '3'

function bnMin

bnMin: (...items: BN[]) => BN;

• bnMin Finds and returns the smallest value in an array of BNs.

  Example 1

  import BN from 'bn.js';
  import { bnMin } from '@polkadot/util';
  
  bnMin([new BN(1), new BN(3), new BN(2)]).toString(); // => '1'

function bnSqrt

bnSqrt: <ExtToBn extends ToBn>(
    value: ExtToBn | BN | bigint | string | number | null
) => BN;

• bnSqrt Calculates the integer square root of a BN

  Example 1

  import BN from 'bn.js';
  import { bnSqrt } from '@polkadot/util';
  
  bnSqrt(new BN(16)).toString(); // => '4'

function bnToBn

bnToBn: <ExtToBn extends ToBn | ToBigInt>(
    value?: HexString | ExtToBn | BN | bigint | string | number | null
) => BN;

• bnToBn Creates a BN value from a BN, bigint, string (base 10 or hex) or number input. null inputs returns a 0x0 result, BN values returns the value, numbers returns a BN representation.

  Example 1

  import BN from 'bn.js';
  import { bnToBn } from '@polkadot/util';
  
  bnToBn(0x1234); // => BN(0x1234)
  bnToBn(new BN(0x1234)); // => BN(0x1234)

function bnToHex

bnToHex: <ExtToBn extends ToBn>(
    value?: ExtToBn | BN | bigint | number | null,
    { bitLength, isLe, isNegative }?: NumberOptions
) => HexString;

• bnToHex Creates a hex value from a BN.js bignumber object. null inputs returns a 0x result, BN values return the actual value as a 0x prefixed hex value. Anything that is not a BN object throws an error. With bitLength set, it fixes the number to the specified length.

  Example 1

  import BN from 'bn.js';
  import { bnToHex } from '@polkadot/util';
  
  bnToHex(new BN(0x123456)); // => '0x123456'

function bnToU8a

bnToU8a: <ExtToBn extends ToBn>(
    value?: ExtToBn | BN | bigint | number | null,
    { bitLength, isLe, isNegative }?: NumberOptions
) => Uint8Array;

• bnToU8a Creates a Uint8Array object from a BN. null/undefined/NaN inputs returns an empty Uint8Array result. BN input values return the actual bytes value converted to a Uint8Array. Optionally convert using little-endian format if isLE is set.

  Example 1

  import { bnToU8a } from '@polkadot/util';
  
  bnToU8a(new BN(0x1234)); // => [0x12, 0x34]

function bufferToU8a

bufferToU8a: (buffer?: Buffer | number[] | null) => Uint8Array;

• bufferToU8a Creates a Uint8Array value from a Buffer object. null inputs returns an empty result, Buffer values return the actual value as a Uint8Array. Anything that is not a Buffer object throws an error.

  Example 1

  import { bufferToU8a } from '@polkadot/util';
  
  bufferToU8a(Buffer.from([1, 2, 3]));

function compactAddLength

compactAddLength: (input: Uint8Array) => Uint8Array;

• compactAddLength Adds a length prefix to the input value

  Example 1

  import { compactAddLength } from '@polkadot/util';
  
  console.log(compactAddLength(new Uint8Array([0xde, 0xad, 0xbe, 0xef]))); // Uint8Array([4 << 2, 0xde, 0xad, 0xbe, 0xef])

function compactFromU8a

compactFromU8a: (input: U8aLike) => [number, BN];

• compactFromU8a Retrives the offset and encoded length from a compact-prefixed value

  Example 1

  import { compactFromU8a } from '@polkadot/util';
  
  const [offset, length] = compactFromU8a(new Uint8Array([254, 255, 3, 0]));
  
  console.log('value offset=', offset, 'length=', length); // 4, 0xffff

function compactFromU8aLim

compactFromU8aLim: (u8a: Uint8Array) => [number, number];

• compactFromU8aLim A limited version of [[compactFromU8a]], accepting only Uint8Array inputs for values <= 48 bits

function compactStripLength

compactStripLength: (input: Uint8Array) => [number, Uint8Array];

• compactStripLength Removes the length prefix, returning both the total length (including the value + compact encoding) and the decoded value with the correct length

  Example 1

  import { compactStripLength } from '@polkadot/util';
  
  console.log(compactStripLength(new Uint8Array([2 << 2, 0xde, 0xad]))); // [2, Uint8Array[0xde, 0xad]]

function compactToU8a

compactToU8a: (value: BN | bigint | number) => Uint8Array;

• compactToU8a Encodes a number into a compact representation

  Example 1

  import { compactToU8a } from '@polkadot/util';
  
  console.log(compactToU8a(511, 32)); // Uint8Array([0b11111101, 0b00000111])

function detectPackage

detectPackage: (
    { name, path, type, version }: PackageJson,
    pathOrFn?: FnString | string | false | null,
    deps?: PackageJson[]
) => void;

• detectPackage Checks that a specific package is only imported once A @polkadot/* version detection utility, checking for one occurence of a package in addition to checking for ddependency versions.

function extractTime

extractTime: (milliseconds?: number) => Time;

• extractTime Convert a quantity of seconds to Time array representing accumulated {days, minutes, hours, seconds, milliseconds}

  Example 1

  import { extractTime } from '@polkadot/util';
  
  const { days, minutes, hours, seconds, milliseconds } = extractTime(6000); // 0, 0, 10, 0, 0

function floatToU8a

floatToU8a: (
    value?: string | AnyFloat,
    { bitLength, isLe }?: Options
) => Uint8Array;

• floatToU8a Converts a float into a U8a representation (While we don't use BE in SCALE we still allow for either representation, although, as elsewhere, isLe is default)

function formatDate

formatDate: (date: Date) => string;

• formatDate Formats a date in CCYY-MM-DD HH:MM:SS format

function formatDecimal

formatDecimal: (value: string, separator?: string) => string;

• formatDecimal Formats a number into string format with thousand separators

function formatElapsed

formatElapsed: <ExtToBn extends ToBn>(
    now?: Date | null,
    value?: bigint | BN | ExtToBn | Date | number | null
) => string;

• formatElapsed Formats an elapsed value into s, m, h or day segments

function formatNumber

formatNumber: <ExtToBn extends ToBn>(
    value?: ExtToBn | BN | bigint | number | null,
    { locale }?: Options
) => string;

• formatNumber Formats a number into string format with thousand separators

function hexAddPrefix

hexAddPrefix: (value?: string | null) => HexString;

• hexAddPrefix Adds the 0x prefix to string values. Returns a 0x prefixed string from the input value. If the input is already prefixed, it is returned unchanged.

  Example 1

  import { hexAddPrefix } from '@polkadot/util';
  
  console.log('With prefix', hexAddPrefix('0a0b12')); // => 0x0a0b12

function hexFixLength

hexFixLength: (
    value: string,
    bitLength?: number,
    withPadding?: boolean
) => HexString;

• hexFixLength Shifts a hex string to a specific bitLength Returns a 0x prefixed string with the specified number of bits contained in the return value. (If bitLength is -1, length checking is not done). Values with more bits are trimmed to the specified length. Input values with less bits are returned as-is by default. When withPadding is set, shorter values are padded with 0.

  Example 1

  import { hexFixLength } from '@polkadot/util';
  
  console.log('fixed', hexFixLength('0x12', 16)); // => 0x12
  console.log('fixed', hexFixLength('0x12', 16, true)); // => 0x0012
  console.log('fixed', hexFixLength('0x0012', 8)); // => 0x12

function hexHasPrefix

hexHasPrefix: (value?: string | null) => value is `0x${string}`;

• hexHasPrefix Tests for the existence of a 0x prefix. Checks for a valid hex input value and if the start matched 0x

  Example 1

  import { hexHasPrefix } from '@polkadot/util';
  
  console.log('has prefix', hexHasPrefix('0x1234')); // => true

function hexStripPrefix

hexStripPrefix: (value?: string | null) => string;

• hexStripPrefix Strips any leading 0x prefix. Tests for the existence of a 0x prefix, and returns the value without the prefix. Un-prefixed values are returned as-is.

  Example 1

  import { hexStripPrefix } from '@polkadot/util';
  
  console.log('stripped', hexStripPrefix('0x1234')); // => 1234

function hexToBigInt

hexToBigInt: (
    value?: string | null,
    { isLe, isNegative }?: ToBnOptions
) => bigint;

• hexToBigInt Creates a BigInt instance object from a hex string.

function hexToBn

hexToBn: (value?: string | null, { isLe, isNegative }?: ToBnOptions) => BN;

• hexToBn Creates a BN.js object from a hex string. null inputs returns a BN(0) result. Hex input values return the actual value converted to a BN. Anything that is not a hex string (including the 0x prefix) throws an error.

  Parameter _value

  The value to convert

  Parameter _options

  Options to pass while converting

  Parameter

  _options.isLe Convert using Little Endian

  Parameter

  _options.isNegative Convert using two's complement

  Example 1

  import { hexToBn } from '@polkadot/util';
  
  hexToBn('0x123480001f'); // => BN(0x123480001f)

function hexToNumber

hexToNumber: (value?: string | null) => number;

• hexToNumber Creates a Number value from a Buffer object. null inputs returns an NaN result, hex values return the actual value as a Number.

  Example 1

  import { hexToNumber } from '@polkadot/util';
  
  hexToNumber('0x1234'); // => 0x1234

function hexToString

hexToString: (_value?: string | null) => string;

• hexToU8a Creates a Uint8Array object from a hex string. Hex input values return the actual bytes value converted to a string. Anything that is not a hex string (including the 0x prefix) throws an error.

  Example 1

  import { hexToString } from '@polkadot/util';
  
  hexToU8a('0x68656c6c6f'); // hello

function hexToU8a

hexToU8a: (value?: HexString | string | null, bitLength?: number) => Uint8Array;

• hexToU8a Creates a Uint8Array object from a hex string. null inputs returns an empty Uint8Array result. Hex input values return the actual bytes value converted to a Uint8Array. Anything that is not a hex string (including the 0x prefix) throws an error.

  Example 1

  import { hexToU8a } from '@polkadot/util';
  
  hexToU8a('0x80001f'); // Uint8Array([0x80, 0x00, 0x1f])
  hexToU8a('0x80001f', 32); // Uint8Array([0x00, 0x80, 0x00, 0x1f])

function isArray

isArray: <T>(value?: unknown) => value is T[];

• isArray Tests for a Array instance.

function isAscii

isAscii: (value?: U8aLike | null) => boolean;

• isAscii Tests if the input is printable ASCII Checks to see if the input string or Uint8Array is printable ASCII, 32-127 + formatters

function isBigInt

isBigInt: (value: unknown) => value is bigint;

• isBigInt Tests for a BigInt object instance. Checks to see if the input object is an instance of BigInt

  Example 1

  import { isBigInt } from '@polkadot/util';
  
  console.log('isBigInt', isBigInt(123_456n)); // => true

function isBn

isBn: (value: unknown) => value is BN;

• isBn Tests for a BN object instance. Checks to see if the input object is an instance of BN (bn.js).

  Example 1

  import BN from 'bn.js';
  import { isBn } from '@polkadot/util';
  
  console.log('isBn', isBn(new BN(1))); // => true

function isBoolean

isBoolean: (value: unknown) => value is boolean;

• isBoolean Tests for a boolean value. Checks to see if the input value is a JavaScript boolean.

  Example 1

  import { isBoolean } from '@polkadot/util';
  
  isBoolean(false); // => true

function isBuffer

isBuffer: (value: unknown) => value is Buffer;

• isBuffer Tests for a Buffer object instance. Checks to see if the input object is an instance of Buffer.

  Example 1

  import { isBuffer } from '@polkadot/util';
  
  console.log('isBuffer', isBuffer(Buffer.from([]))); // => true

function isChildClass

isChildClass: <P extends Constructor<any>>(
    Parent: P,
    Child?: Constructor | null | unknown
) => Child is P;

• isChildClass Tests if the child extends the parent Class Checks to see if the child Class extends the parent Class

  Example 1

  import { isChildClass } from '@polkadot/util';
  
  console.log('isChildClass', isChildClass(BN, BN); // => true
  console.log('isChildClass', isChildClass(BN, Uint8Array); // => false

function isClass

isClass: <T extends Constructor<any>>(value?: unknown) => value is T;

• isClass Tests if the supplied agrument is a Class

function isCodec

isCodec: <T extends Codec = Codec>(value?: unknown) => value is T;

function isCompact

isCompact: <T>(value?: unknown) => value is Compact<T>;

• isCompact Tests for SCALE-Compact-like object instance.

function isError

isError: (value: unknown) => value is Error;

• isError Tests for a Error object instance. Checks to see if the input object is an instance of Error.

  Example 1

  import { isError } from '@polkadot/util';
  
  console.log('isError', isError(new Error('message'))); // => true

function isFunction

isFunction: (value: unknown) => value is Function;

• isFunction Tests for a function. Checks to see if the input value is a JavaScript function.

  Example 1

  import { isFunction } from '@polkadot/util';
  
  isFunction(() => false); // => true

function isHex

isHex: (
    value: unknown,
    bitLength?: number,
    ignoreLength?: boolean
) => value is `0x${string}`;

• isHex Tests for a hex string. Checks to see if the input value is a 0x prefixed hex string. Optionally (bitLength !== -1) checks to see if the bitLength is correct.

  Example 1

  import { isHex } from '@polkadot/util';
  
  isHex('0x1234'); // => true
  isHex('0x1234', 8); // => false

function isInstanceOf

isInstanceOf: (value: unknown, Clazz: Function) => boolean;

• isInstanceOf Tests for a instance of a class. Checks to see if the input value is an instance of the test class.

  Example 1

  import { isInstanceOf } from '@polkadot/util';
  
  console.log('isInstanceOf', isInstanceOf(new Array(0), Array)); // => true

function isIp

isIp: (value: string, type?: 'v4' | 'v6') => boolean;

• isIp Tests if the value is a valid IP address Checks to see if the value is a valid IP address. Optionally check for either v4/v6

  Example 1

  import { isIp } from '@polkadot/util';
  
  isIp('192.168.0.1')); // => true
  isIp('1:2:3:4:5:6:7:8'); // => true
  isIp('192.168.0.1', 'v6')); // => false
  isIp('1:2:3:4:5:6:7:8', 'v4'); // => false

function isJsonObject

isJsonObject: (value: unknown) => value is ObjectIndexed;

• isJsonObject Tests for a valid JSON object. Checks to see if the input value is a valid JSON object. It returns false if the input is JSON parsable, but not an Javascript object.

  Example 1

  import { isJsonObject } from '@polkadot/util';
  
  isJsonObject({}); // => true
  isJsonObject({
   "Test": "1234",
   "NestedTest": {
    "Test": "5678"
   }
  }); // => true
  isJsonObject(1234); // JSON parsable, but not an object =>  false
  isJsonObject(null); // JSON parsable, but not an object => false
  isJsonObject('not an object'); // => false

function isNull

isNull: (value?: unknown) => value is null;

• isNull Tests for a null values. Checks to see if the input value is null.

  Example 1

  import { isNull } from '@polkadot/util';
  
  console.log('isNull', isNull(null)); // => true

function isNumber

isNumber: (value: unknown) => value is number;

• isNumber Tests for a JavaScript number. Checks to see if the input value is a valid number.

  Example 1

  import { isNumber } from '@polkadot/util';
  
  console.log('isNumber', isNumber(1234)); // => true

function isObject

isObject: <T extends ObjectIndexed = ObjectIndexed>(
    value?: unknown
) => value is T;

• isObject Tests for an object. Checks to see if the input value is a JavaScript object.

  Example 1

  import { isObject } from '@polkadot/util';
  
  isObject({}); // => true
  isObject('something'); // => false

function isObservable

isObservable: (value?: unknown) => value is Observable;

• isBObservable Tests for a Observable object instance. Checks to see if the input object is an instance of BN (bn.js).

  Example 1

  import { isObservable } from '@polkadot/util';
  
  console.log('isObservable', isObservable(...));

function isPromise

isPromise: (value?: unknown) => value is Promise<unknown>;

function isString

isString: (value: unknown) => value is AnyString;

• isString Tests for a string. Checks to see if the input value is a JavaScript string.

  Example 1

  import { isString } from '@polkadot/util';
  
  console.log('isString', isString('test')); // => true

function isTestChain

isTestChain: (chain?: string | null) => boolean;

function isToBigInt

isToBigInt: (value?: unknown) => value is ToBigInt;

function isToBn

isToBn: (value?: unknown) => value is ToBn;

function isU8a

isU8a: (value?: unknown) => value is Uint8Array;

• isU8a Tests for a Uint8Array object instance. Checks to see if the input object is an instance of Uint8Array.

  Example 1

  import { isUint8Array } from '@polkadot/util';
  
  console.log('isU8a', isU8a([])); // => false

function isUndefined

isUndefined: (value?: unknown) => value is undefined;

• isUndefined Tests for a undefined values. Checks to see if the input value is undefined.

  Example 1

  import { isUndefined } from '@polkadot/util';
  
  console.log('isUndefined', isUndefined(void(0))); // => true

function isUtf8

isUtf8: (
    value?: HexString | number[] | Buffer | Uint8Array | string | null
) => boolean;

• isUtf8 Tests if the input is valid Utf8 Checks to see if the input string or Uint8Array is valid Utf8

function isWasm

isWasm: (value?: unknown) => value is Uint8Array;

• isWasm Tests if the input has a WASM header Checks to see if the input Uint8Array contains a valid WASM header

function lazyMethod

lazyMethod: <T, K, S>(
    result: Record<string, T> | AnyFn,
    item: K,
    creator: (item: K, index: number, self: S) => T,
    getName?: (item: K, index: number) => string,
    index?: number
) => void;

• lazyMethod Creates a lazy, on-demand getter for the specific value. Upon get the value will be evaluated.

function lazyMethods

lazyMethods: <T, K, S>(
    result: Record<string, T>,
    items: readonly K[],
    creator: (item: K, index: number, self: S) => T,
    getName?: (item: K, index: number) => string
) => Record<string, T>;

• lazyMethods Creates lazy, on-demand getters for the specific values.

function logger

logger: (_type: string) => Logger;

• Logger Creates a consistent log interface for messages Returns a Logger that has .log, .error, .warn and .debug (controlled with environment DEBUG=typeA,typeB) methods. Logging is done with a consistent prefix (type of logger, date) followed by the actual message using the underlying console.

  Example 1

  import { logger } from '@polkadot/util';
  
  const l = logger('test');

function loggerFormat

loggerFormat: (value: unknown) => unknown;

function memoize

memoize: <T, F extends (...args: any[]) => T>(
    fn: F,
    { getInstanceId }?: Options
) => Memoized<F>;

• memoize Memomize the function with a specific instanceId

function nextTick

nextTick: (onExec: () => unknown, onError?: (error: Error) => unknown) => void;

• nextTick Defer the operation to the queue for evaluation on the next tick

function nMax

nMax: (...items: bigint[]) => bigint;

• nMax Finds and returns the highest value in an array of bigint.

function nMin

nMin: (...items: bigint[]) => bigint;

• nMin Finds and returns the lowest value in an array of bigint.

function nSqrt

nSqrt: <ExtToBn extends ToBn | ToBigInt>(
    value: ExtToBn | BN | bigint | string | number | null
) => bigint;

• nSqrt Calculates the integer square root of a bigint

function nToBigInt

nToBigInt: <ExtToBn extends ToBn | ToBigInt>(
    value?: HexString | ExtToBn | BN | bigint | string | number | null
) => bigint;

• nToBigInt Creates a bigInt value from a BN, bigint, string (base 10 or hex) or number input.

function nToHex

nToHex: <ExtToBn extends ToBn | ToBigInt>(
    value?: ExtToBn | BN | bigint | number | null,
    { bitLength, isLe, isNegative }?: NumberOptions
) => HexString;

• nToHex Creates a hex value from a bigint object.

function nToU8a

nToU8a: <ExtToBn extends ToBn | ToBigInt>(
    value?: ExtToBn | BN | bigint | number | null,
    { bitLength, isLe, isNegative }?: NumberOptions
) => Uint8Array;

• nToU8a Creates a Uint8Array object from a bigint.

function numberToHex

numberToHex: (value?: number | null, bitLength?: number) => HexString;

• numberToHex Creates a hex value from a number. null/undefined/NaN inputs returns an empty 0x result. number input values return the actual bytes value converted to a hex. With bitLength set, it converts the number to the equivalent size.

  Example 1

  import { numberToHex } from '@polkadot/util';
  
  numberToHex(0x1234); // => '0x1234'
  numberToHex(0x1234, 32); // => 0x00001234

function numberToU8a

numberToU8a: (value?: number | null, bitLength?: number) => Uint8Array;

• numberToU8a Creates a Uint8Array object from a number. null/undefined/NaN inputs returns an empty Uint8Array result. number input values return the actual bytes value converted to a Uint8Array. With bitLength, it converts the value to the equivalent size.

  Example 1

  import { numberToU8a } from '@polkadot/util';
  
  numberToU8a(0x1234); // => [0x12, 0x34]

function objectClear

objectClear: <T>(value: Record<string, T>) => Record<string, T>;

• objectClear Removes all the keys from the input object

function objectCopy

objectCopy: <T extends object>(source: T) => T;

• objectCopy Creates a shallow clone of the input object

function objectEntries

objectEntries: <T extends object>(obj: T) => Entries<T>;

• objectEntries A version of Object.entries that is typed for TS

function objectKeys

objectKeys: <T extends object, K extends Extract<keyof T, string>>(
    value: T
) => K[];

• objectKeys A version of Object.keys that is typed for TS

function objectProperties

objectProperties: <S>(
    that: object,
    keys: string[],
    getter: (key: string, index: number, self: S) => unknown,
    getName?: (key: string, index: number) => string
) => void;

• objectProperties Assign get properties on the input object

function objectProperty

objectProperty: <S>(
    that: object,
    key: string,
    getter: (key: string, index: number, self: S) => unknown,
    getName?: (key: string, index: number) => string,
    index?: number
) => void;

• objectProperty Assign a get property on the input object

function objectSpread

objectSpread: <T extends object>(
    dest: object,
    ...sources: (object | undefined | null)[]
) => T;

• objectSpread Concats all sources into the destination

function objectValues

objectValues: <T extends object>(obj: T) => T[keyof T][];

• objectValues A version of Object.values that is typed for TS

function promisify

promisify: <R = any>(
    self: unknown,
    fn: (...params: any) => any,
    ...params: any[]
) => Promise<R>;

• promisify Wraps an async callback into a Promise Wraps the supplied async function fn that has a standard JS callback (error: Error, result: any) into a Promise, passing the supplied parameters. When error is set, the Promise is rejected, else the Promise resolves with the result value.

  Example 1

  const { promisify } from '@polkadot/util';
  
  await promisify(null, ((a, cb) => cb(null, a), true); // resolves with `true`
  await promisify(null, (cb) => cb(new Error('error!'))); // rejects with `error!`

function stringCamelCase

stringCamelCase: (value: AnyString) => string;

• stringCamelCase Convert a dash/dot/underscore/space separated Ascii string/String to camelCase

function stringify

stringify: (value: unknown, space?: string | number) => string;

• stringify Performs a JSON.stringify, with BigInt handling A wrapper for JSON.stringify that handles BigInt values transparently, converting them to string. No differences from the native JSON.stringify function otherwise.

function stringLowerFirst

stringLowerFirst: (value?: AnyString | null) => string;

• stringLowerFirst Lowercase the first letter of a string Lowercase the first letter of a string

  Example 1

  import { stringLowerFirst } from '@polkadot/util';
  
  stringLowerFirst('ABC'); // => 'aBC'