@polkadot/util-crypto

Variables

• cryptoIsReady
• packageInfo

Functions

• addressEq()
• addressToEvm()
• base32Decode()
• base32Encode()
• base32Validate()
• base58Decode()
• base58Encode()
• base58Validate()
• base64Decode()
• base64Encode()
• base64Pad()
• base64Trim()
• base64Validate()
• blake2AsHex()
• blake2AsU8a()
• checkAddress()
• checkAddressChecksum()
• createKeyDerived()
• createKeyMulti()
• cryptoWaitReady()
• decodeAddress()
• deriveAddress()
• ed25519DeriveHard()
• ed25519PairFromRandom()
• ed25519PairFromSecret()
• ed25519PairFromSeed()
• ed25519PairFromString()
• ed25519Sign()
• ed25519Verify()
• encodeAddress()
• encodeDerivedAddress()
• encodeMultiAddress()
• ethereumEncode()
• evmToAddress()
• hdEthereum()
• hdLedger()
• hdValidatePath()
• hmacSha256AsU8a()
• hmacSha512AsU8a()
• hmacShaAsU8a()
• isAddress()
• isBase32()
• isBase58()
• isBase64()
• isEthereumAddress()
• isEthereumChecksum()
• jsonDecrypt()
• jsonDecryptData()
• jsonEncrypt()
• jsonEncryptFormat()
• keccak256AsU8a()
• keccak512AsU8a()
• keccakAsHex()
• keccakAsU8a()
• keyExtractPath()
• keyExtractSuri()
• keyFromPath()
• keyHdkdEcdsa()
• keyHdkdEd25519()
• keyHdkdSr25519()
• mnemonicGenerate()
• mnemonicToEntropy()
• mnemonicToLegacySeed()
• mnemonicToMiniSecret()
• mnemonicValidate()
• naclDecrypt()
• naclEncrypt()
• pbkdf2Encode()
• randomAsHex()
• randomAsNumber()
• randomAsU8a()
• scryptEncode()
• scryptFromU8a()
• scryptToU8a()
• secp256k1Compress()
• secp256k1Expand()
• secp256k1PairFromSeed()
• secp256k1PrivateKeyTweakAdd()
• secp256k1Recover()
• secp256k1Sign()
• secp256k1Verify()
• setSS58Format()
• sha256AsU8a()
• sha512AsU8a()
• shaAsU8a()
• signatureVerify()
• sortAddresses()
• sr25519Agreement()
• sr25519DeriveHard()
• sr25519DerivePublic()
• sr25519DeriveSoft()
• sr25519PairFromSeed()
• sr25519Sign()
• sr25519Verify()
• sr25519VrfSign()
• sr25519VrfVerify()
• validateAddress()
• xxhashAsHex()
• xxhashAsU8a()

variable cryptoIsReady

const cryptoIsReady: any;

variable packageInfo

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

function addressEq

addressEq: (a: string | Uint8Array, b: string | Uint8Array) => boolean;

• addressEq Compares two addresses, either in ss58, Uint8Array or hex format. For the input values, return true is the underlying public keys do match.

  Example 1

  import { u8aEq } from '@polkadot/util';
  
  u8aEq(new Uint8Array([0x68, 0x65]), new Uint8Array([0x68, 0x65])); // true

function addressToEvm

addressToEvm: (
    address: string | Uint8Array,
    ignoreChecksum?: boolean
) => Uint8Array;

• addressToEvm Converts an SS58 address to its corresponding EVM address.

function base32Decode

base32Decode: (value: string, ipfsCompat?: boolean) => Uint8Array;

• base32Decode Delookup a base32 value. From the provided input, decode the base32 and return the result as an Uint8Array.

function base32Encode

base32Encode: (value: any, ipfsCompat?: boolean) => string;

• base32Encode Creates a base32 value. From the provided input, create the base32 and return the result as a string.

function base32Validate

base32Validate: (value?: unknown, ipfsCompat?: boolean) => value is string;

• base32Validate Validates a base32 value. Validates that the supplied value is valid base32, throwing exceptions if not

function base58Decode

base58Decode: (value: string, ipfsCompat?: boolean) => Uint8Array;

• base58Decode Decodes a base58 value. From the provided input, decode the base58 and return the result as an Uint8Array.

function base58Encode

base58Encode: (value: any, ipfsCompat?: boolean) => string;

• base58Encode Creates a base58 value. From the provided input, create the base58 and return the result as a string.

function base58Validate

base58Validate: (value?: unknown, ipfsCompat?: boolean) => value is string;

• base58Validate Validates a base58 value. Validates that the supplied value is valid base58, throwing exceptions if not

function base64Decode

base64Decode: (value: string, ipfsCompat?: boolean) => Uint8Array;

• base64Decode Decodes a base64 value. From the provided input, decode the base64 and return the result as an Uint8Array.

function base64Encode

base64Encode: (value: any, ipfsCompat?: boolean) => string;

• base64Encode Creates a base64 value. From the provided input, create the base64 and return the result as a string.

function base64Pad

base64Pad: (value: string) => string;

• base64Pad Adds padding characters for correct length

function base64Trim

base64Trim: (value: string) => string;

• base64Trim Trims padding characters

function base64Validate

base64Validate: (value?: unknown, ipfsCompat?: boolean) => value is string;

• base64Validate Validates a base64 value. Validates that the supplied value is valid base64

function blake2AsHex

blake2AsHex: (
    data: string | Uint8Array,
    bitLength?: 256 | 512 | 64 | 128 | 384 | undefined,
    key?: Uint8Array | null | undefined,
    onlyJs?: boolean | undefined
) => any;

• blake2AsHex Creates a blake2b hex from the input.

function blake2AsU8a

blake2AsU8a: (
    data: string | Uint8Array,
    bitLength?: 64 | 128 | 256 | 384 | 512,
    key?: Uint8Array | null,
    onlyJs?: boolean
) => Uint8Array;

• blake2AsU8a Creates a blake2b u8a from the input. From a Uint8Array input, create the blake2b and return the result as a u8a with the specified bitLength.

  Example 1

  import { blake2AsU8a } from '@polkadot/util-crypto';
  
  blake2AsU8a('abc'); // => [0xba, 0x80, 0xa5, 0x3f, 0x98, 0x1c, 0x4d, 0x0d]

function checkAddress

checkAddress: (address: string, prefix: Prefix) => [boolean, string | null];

• checkAddress Validates an ss58 address. From the provided input, validate that the address is a valid input.

function checkAddressChecksum

checkAddressChecksum: (decoded: Uint8Array) => [boolean, number, number, number];

function createKeyDerived

createKeyDerived: (
    who: string | Uint8Array,
    index: bigint | BN | number
) => Uint8Array;

function createKeyMulti

createKeyMulti: (
    who: (string | Uint8Array)[],
    threshold: bigint | BN | number
) => Uint8Array;

function cryptoWaitReady

cryptoWaitReady: () => Promise<boolean>;

function decodeAddress

decodeAddress: (
    encoded?: string | Uint8Array | null,
    ignoreChecksum?: boolean,
    ss58Format?: Prefix
) => Uint8Array;

function deriveAddress

deriveAddress: (
    who: string | Uint8Array,
    suri: string,
    ss58Format?: Prefix
) => string;

• deriveAddress Creates a sr25519 derived address from the supplied and path. Creates a sr25519 derived address based on the input address/publicKey and the uri supplied.

function ed25519DeriveHard

ed25519DeriveHard: (seed: Uint8Array, chainCode: Uint8Array) => Uint8Array;

function ed25519PairFromRandom

ed25519PairFromRandom: () => Keypair;

• ed25519PairFromRandom Creates a new public/secret keypair. Returns a new generate object containing a publicKey & secretKey.

  Example 1

  import { ed25519PairFromRandom } from '@polkadot/util-crypto';
  
  ed25519PairFromRandom(); // => { secretKey: [...], publicKey: [...] }

function ed25519PairFromSecret

ed25519PairFromSecret: (secretKey: Uint8Array) => Keypair;

• ed25519PairFromSecret Creates a new public/secret keypair from a secret. Returns a object containing a publicKey & secretKey generated from the supplied secret.

  Example 1

  import { ed25519PairFromSecret } from '@polkadot/util-crypto';
  
  ed25519PairFromSecret(...); // => { secretKey: [...], publicKey: [...] }

function ed25519PairFromSeed

ed25519PairFromSeed: (seed: Uint8Array, onlyJs?: boolean) => Keypair;

• ed25519PairFromSeed Creates a new public/secret keypair from a seed. Returns a object containing a publicKey & secretKey generated from the supplied seed.

  Example 1

  import { ed25519PairFromSeed } from '@polkadot/util-crypto';
  
  ed25519PairFromSeed(...); // => { secretKey: [...], publicKey: [...] }

function ed25519PairFromString

ed25519PairFromString: (value: string) => Keypair;

• ed25519PairFromString Creates a new public/secret keypair from a string. Returns a object containing a publicKey & secretKey generated from the supplied string. The string is hashed and the value used as the input seed.

  Example 1

  import { ed25519PairFromString } from '@polkadot/util-crypto';
  
  ed25519PairFromString('test'); // => { secretKey: [...], publicKey: [...] }

function ed25519Sign

ed25519Sign: (
    message: string | Uint8Array,
    { publicKey, secretKey }: Partial<Keypair>,
    onlyJs?: boolean
) => Uint8Array;

• ed25519Sign Signs a message using the supplied secretKey Returns message signature of message, using the secretKey.

  Example 1

  import { ed25519Sign } from '@polkadot/util-crypto';
  
  ed25519Sign([...], [...]); // => [...]

function ed25519Verify

ed25519Verify: (
    message: string | Uint8Array,
    signature: string | Uint8Array,
    publicKey: string | Uint8Array,
    onlyJs?: boolean
) => boolean;

• ed25519Sign Verifies the signature on the supplied message. Verifies the signature on message with the supplied publicKey. Returns true on sucess, false otherwise.

  Example 1

  import { ed25519Verify } from '@polkadot/util-crypto';
  
  ed25519Verify([...], [...], [...]); // => true/false

function encodeAddress

encodeAddress: (key: string | Uint8Array, ss58Format?: Prefix) => string;

function encodeDerivedAddress

encodeDerivedAddress: (
    who: string | Uint8Array,
    index: bigint | BN | number,
    ss58Format?: Prefix
) => string;

• encodeDerivedAddress Creates a derived address as used in Substrate utility. Creates a Substrate derived address based on the input address/publicKey and the index supplied.

function encodeMultiAddress

encodeMultiAddress: (
    who: (string | Uint8Array)[],
    threshold: bigint | BN | number,
    ss58Format?: Prefix
) => string;

• encodeMultiAddress Creates a multisig address. Creates a Substrate multisig address based on the input address and the required threshold.

function ethereumEncode

ethereumEncode: (addressOrPublic?: string | Uint8Array) => HexString;

function evmToAddress

evmToAddress: (
    evmAddress: string | Uint8Array,
    ss58Format?: Prefix,
    hashType?: HashType
) => string;

• evmToAddress Converts an EVM address to its corresponding SS58 address.

function hdEthereum

hdEthereum: (seed: Uint8Array, path?: string) => Keypair;

function hdLedger

hdLedger: (_mnemonic: string, path: string) => Keypair;

function hdValidatePath

hdValidatePath: (path: string) => boolean;

function hmacSha256AsU8a

hmacSha256AsU8a: (
    key: Uint8Array | string,
    data: Uint8Array,
    onlyJs?: boolean
) => Uint8Array;

• hmacSha256AsU8a creates a Hmac Sha256 Uint8Array from the key & data

function hmacSha512AsU8a

hmacSha512AsU8a: (
    key: Uint8Array | string,
    data: Uint8Array,
    onlyJs?: boolean
) => Uint8Array;

• hmacSha512AsU8a creates a Hmac Sha512 Uint8Array from the key & data

function hmacShaAsU8a

hmacShaAsU8a: (
    key: Uint8Array | string,
    data: Uint8Array,
    bitLength?: 256 | 512,
    onlyJs?: boolean
) => Uint8Array;

• hmacShaAsU8a creates a Hmac Sha (256/512) Uint8Array from the key & data

function isAddress

isAddress: (
    address?: string | null,
    ignoreChecksum?: boolean,
    ss58Format?: Prefix
) => address is string;

function isBase32

isBase32: (value?: unknown, ipfsCompat?: boolean) => value is string;

• isBase32 Checks if the input is in base32, returning true/false

function isBase58

isBase58: (value?: unknown, ipfsCompat?: boolean) => value is string;

• isBase58 Checks if the input is in base58, returning true/false

function isBase64

isBase64: (value?: unknown, ipfsCompat?: boolean) => value is string;

• isBase64 Checks if the input is in base64, returning true/false

function isEthereumAddress

isEthereumAddress: (address?: string) => boolean;

function isEthereumChecksum

isEthereumChecksum: (_address: string) => boolean;

function jsonDecrypt

jsonDecrypt: (
    { encoded, encoding }: EncryptedJson,
    passphrase?: string | null
) => Uint8Array;

function jsonDecryptData

jsonDecryptData: (
    encrypted?: Uint8Array | null,
    passphrase?: string | null,
    encType?: EncryptedJsonEncoding[]
) => Uint8Array;

function jsonEncrypt

jsonEncrypt: (
    data: Uint8Array,
    contentType: string[],
    passphrase?: string | null
) => EncryptedJson;

function jsonEncryptFormat

jsonEncryptFormat: (
    encoded: Uint8Array,
    contentType: string[],
    isEncrypted: boolean
) => EncryptedJson;

function keccak256AsU8a

keccak256AsU8a: (data: string | Uint8Array, onlyJs?: boolean) => Uint8Array;

• keccak256AsU8a Creates a keccak256 Uint8Array from the input.

function keccak512AsU8a

keccak512AsU8a: (data: string | Uint8Array, onlyJs?: boolean) => Uint8Array;

• keccak512AsU8a Creates a keccak512 Uint8Array from the input.

function keccakAsHex

keccakAsHex: (
    value: string | Uint8Array,
    bitLength?: 256 | 512 | undefined,
    onlyJs?: boolean | undefined
) => any;

• keccakAsHex Creates a keccak hex string from the input.

function keccakAsU8a

keccakAsU8a: (
    value: string | Uint8Array,
    bitLength?: 256 | 512,
    onlyJs?: boolean
) => Uint8Array;

• keccakAsU8a Creates a keccak Uint8Array from the input. From either a string or a Buffer input, create the keccak and return the result as a Uint8Array.

  Example 1

  import { keccakAsU8a } from '@polkadot/util-crypto';
  
  keccakAsU8a('123'); // => Uint8Array

function keyExtractPath

keyExtractPath: (derivePath: string) => ExtractResult;

• Extract derivation junctions from the supplied path

function keyExtractSuri

keyExtractSuri: (suri: string) => ExtractResult;

• Extracts the phrase, path and password from a SURI format for specifying secret keys <secret>/<soft-key>//<hard-key>///<password> (the ///password may be omitted, and /<soft-key> and //<hard-key> maybe repeated and mixed).

function keyFromPath

keyFromPath: (
    pair: Keypair,
    path: DeriveJunction[],
    type: KeypairType
) => Keypair;

function keyHdkdEcdsa

keyHdkdEcdsa: (
    keypair: import('../types.js').Keypair,
    junction: import('./DeriveJunction.js').DeriveJunction
) => import('../types.js').Keypair;

function keyHdkdEd25519

keyHdkdEd25519: (
    keypair: import('../types.js').Keypair,
    junction: import('./DeriveJunction.js').DeriveJunction
) => import('../types.js').Keypair;

function keyHdkdSr25519

keyHdkdSr25519: (
    keypair: Keypair,
    { chainCode, isSoft }: DeriveJunction
) => Keypair;

function mnemonicGenerate

mnemonicGenerate: (
    numWords?: 12 | 15 | 18 | 21 | 24,
    wordlist?: string[],
    onlyJs?: boolean
) => string;

• mnemonicGenerate Creates a valid mnemonic string using using [BIP39](https://github.com/bitcoin/bips/blob/master/bip-0039.mediawiki).

  Example 1

  import { mnemonicGenerate } from '@polkadot/util-crypto';
  
  const mnemonic = mnemonicGenerate(); // => string

function mnemonicToEntropy

mnemonicToEntropy: (
    mnemonic: string,
    wordlist?: string[],
    onlyJs?: boolean
) => Uint8Array;

function mnemonicToLegacySeed

mnemonicToLegacySeed: (
    mnemonic: string,
    password?: string,
    onlyJs?: boolean,
    byteLength?: 32 | 64
) => Uint8Array;

• mnemonicToLegacySeed Creates a valid Ethereum/Bitcoin-compatible seed from a mnemonic input

  Example 1

  import { mnemonicGenerate, mnemonicToLegacySeed, mnemonicValidate } from '@polkadot/util-crypto';
  
  const mnemonic = mnemonicGenerate(); // => string
  const isValidMnemonic = mnemonicValidate(mnemonic); // => boolean
  
  if (isValidMnemonic) {
    console.log(`Seed generated from mnemonic: ${mnemonicToLegacySeed(mnemonic)}`); => u8a
  }

function mnemonicToMiniSecret

mnemonicToMiniSecret: (
    mnemonic: string,
    password?: string,
    wordlist?: string[],
    onlyJs?: boolean
) => Uint8Array;

function mnemonicValidate

mnemonicValidate: (
    mnemonic: string,
    wordlist?: string[],
    onlyJs?: boolean
) => boolean;

• mnemonicValidate Validates a mnemonic input using [BIP39](https://github.com/bitcoin/bips/blob/master/bip-0039.mediawiki).

  Example 1

  import { mnemonicGenerate, mnemonicValidate } from '@polkadot/util-crypto';
  
  const mnemonic = mnemonicGenerate(); // => string
  const isValidMnemonic = mnemonicValidate(mnemonic); // => boolean

function naclDecrypt

naclDecrypt: (
    encrypted: Uint8Array,
    nonce: Uint8Array,
    secret: Uint8Array
) => Uint8Array | null;

• naclDecrypt Decrypts a message using the supplied secretKey and nonce Returns an decrypted message, using the secret and nonce.

  Example 1

  import { naclDecrypt } from '@polkadot/util-crypto';
  
  naclDecrypt([...], [...], [...]); // => [...]

function naclEncrypt

naclEncrypt: (
    message: Uint8Array,
    secret: Uint8Array,
    nonce?: Uint8Array
) => Encrypted;

• naclEncrypt Encrypts a message using the supplied secretKey and nonce Returns an encrypted message, using the secretKey and nonce. If the nonce was not supplied, a random value is generated.

  Example 1

  import { naclEncrypt } from '@polkadot/util-crypto';
  
  naclEncrypt([...], [...]); // => [...]

function pbkdf2Encode

pbkdf2Encode: (
    passphrase?: string | Uint8Array,
    salt?: Uint8Array,
    rounds?: number,
    onlyJs?: boolean
) => Result;

function randomAsHex

randomAsHex: (length?: number | undefined) => any;

• randomAsHex Creates a hex string filled with random bytes.

function randomAsNumber

randomAsNumber: () => number;

• randomAsNumber Creates a random number from random bytes. Returns a random number generated from the secure bytes.

  Example 1

  import { randomAsNumber } from '@polkadot/util-crypto';
  
  randomAsNumber(); // => <random number>

function randomAsU8a

randomAsU8a: (length?: number) => Uint8Array;

• randomAsU8a Creates a Uint8Array filled with random bytes. Returns a Uint8Array with the specified (optional) length filled with random bytes.

  Example 1

  import { randomAsU8a } from '@polkadot/util-crypto';
  
  randomAsU8a(); // => Uint8Array([...])

function scryptEncode

scryptEncode: (
    passphrase?: string | Uint8Array,
    salt?: Uint8Array,
    params?: ScryptParams,
    onlyJs?: boolean
) => Result;

function scryptFromU8a

scryptFromU8a: (data: Uint8Array) => Result;

function scryptToU8a

scryptToU8a: (salt: Uint8Array, { N, p, r }: ScryptParams) => Uint8Array;

function secp256k1Compress

secp256k1Compress: (publicKey: Uint8Array, onlyJs?: boolean) => Uint8Array;

function secp256k1Expand

secp256k1Expand: (publicKey: Uint8Array, onlyJs?: boolean) => Uint8Array;

function secp256k1PairFromSeed

secp256k1PairFromSeed: (seed: Uint8Array, onlyJs?: boolean) => Keypair;

• secp256k1PairFromSeed Returns a object containing a publicKey & secretKey generated from the supplied seed.

function secp256k1PrivateKeyTweakAdd

secp256k1PrivateKeyTweakAdd: (
    seckey: Uint8Array,
    tweak: Uint8Array,
    onlyBn?: boolean
) => Uint8Array;

function secp256k1Recover

secp256k1Recover: (
    msgHash: string | Uint8Array,
    signature: string | Uint8Array,
    recovery: number,
    hashType?: HashType,
    onlyJs?: boolean
) => Uint8Array;

• secp256k1Recover Recovers a publicKey from the supplied signature

function secp256k1Sign

secp256k1Sign: (
    message: Uint8Array | string,
    { secretKey }: Partial<Keypair>,
    hashType?: HashType,
    onlyJs?: boolean
) => Uint8Array;

• secp256k1Sign Returns message signature of message, using the supplied pair

function secp256k1Verify

secp256k1Verify: (
    msgHash: string | Uint8Array,
    signature: string | Uint8Array,
    address: string | Uint8Array,
    hashType?: HashType,
    onlyJs?: boolean
) => boolean;

• secp256k1Verify Verifies the signature of message, using the supplied pair

function setSS58Format

setSS58Format: (prefix: Prefix) => void;

• Sets the global SS58 format to use for address encoding

  Deprecated

  Use keyring.setSS58Format

function sha256AsU8a

sha256AsU8a: (data: string | Uint8Array, onlyJs?: boolean) => Uint8Array;

• sha256AsU8a Creates a sha256 Uint8Array from the input.

function sha512AsU8a

sha512AsU8a: (data: string | Uint8Array, onlyJs?: boolean) => Uint8Array;

• sha512AsU8a Creates a sha512 Uint8Array from the input.

function shaAsU8a

shaAsU8a: (
    value: string | Uint8Array,
    bitLength?: 256 | 512,
    onlyJs?: boolean
) => Uint8Array;

• shaAsU8a Creates a sha Uint8Array from the input.

function signatureVerify

signatureVerify: (
    message: string | Uint8Array,
    signature: string | Uint8Array,
    addressOrPublicKey: string | Uint8Array
) => VerifyResult;

function sortAddresses

sortAddresses: (
    addresses: (string | Uint8Array)[],
    ss58Format?: Prefix
) => string[];

function sr25519Agreement

sr25519Agreement: (
    secretKey: string | Uint8Array,
    publicKey: string | Uint8Array
) => Uint8Array;

• sr25519Agreement Key agreement between other's public key and self secret key

function sr25519DeriveHard

sr25519DeriveHard: (
    keypair: import('../types.js').Keypair,
    chainCode: Uint8Array
) => import('../types.js').Keypair;

function sr25519DerivePublic

sr25519DerivePublic: (
    publicKey: string | Uint8Array,
    chainCode: Uint8Array
) => Uint8Array;

function sr25519DeriveSoft

sr25519DeriveSoft: (
    keypair: import('../types.js').Keypair,
    chainCode: Uint8Array
) => import('../types.js').Keypair;

function sr25519PairFromSeed

sr25519PairFromSeed: (seed: string | Uint8Array) => Keypair;

• sr25519PairFromSeed Returns a object containing a publicKey & secretKey generated from the supplied seed.

function sr25519Sign

sr25519Sign: (
    message: string | Uint8Array,
    { publicKey, secretKey }: Partial<Keypair>
) => Uint8Array;

• sr25519Sign Returns message signature of message, using the supplied pair

function sr25519Verify

sr25519Verify: (
    message: string | Uint8Array,
    signature: string | Uint8Array,
    publicKey: string | Uint8Array
) => boolean;

• sr25519Verify Verifies the signature of message, using the supplied pair

function sr25519VrfSign

sr25519VrfSign: (
    message: string | Uint8Array,
    { secretKey }: Partial<Keypair>,
    context?: string | Uint8Array,
    extra?: string | Uint8Array
) => Uint8Array;

• sr25519VrfSign Sign with sr25519 vrf signing (deterministic)

function sr25519VrfVerify

sr25519VrfVerify: (
    message: string | Uint8Array,
    signOutput: string | Uint8Array,
    publicKey: string | Uint8Array,
    context?: string | Uint8Array,
    extra?: string | Uint8Array
) => boolean;

• sr25519VrfVerify Verify with sr25519 vrf verification

function validateAddress

validateAddress: (
    encoded?: string | null,
    ignoreChecksum?: boolean,
    ss58Format?: Prefix
) => encoded is string;

function xxhashAsHex

xxhashAsHex: (
    data: string | Uint8Array,
    bitLength?: 256 | 512 | 64 | 128 | 384 | 320 | 192 | 448 | undefined,
    onlyJs?: boolean | undefined
) => any;

• xxhashAsHex Creates a xxhash64 hex from the input.

function xxhashAsU8a

xxhashAsU8a: (
    data: string | Uint8Array,
    bitLength?: 64 | 128 | 192 | 256 | 320 | 384 | 448 | 512,
    onlyJs?: boolean
) => Uint8Array;

• xxhashAsU8a Creates a xxhash64 u8a from the input. From either a string, Uint8Array or a Buffer input, create the xxhash64 and return the result as a Uint8Array with the specified bitLength.

  Example 1

  import { xxhashAsU8a } from '@polkadot/util-crypto';
  
  xxhashAsU8a('abc'); // => 0x44bc2cf5ad770999