@polkadot/util-crypto
- Version 13.0.2
- Published
- 1.14 MB
- 10 dependencies
- Apache-2.0 license
Install
npm i @polkadot/util-crypto
yarn add @polkadot/util-crypto
pnpm add @polkadot/util-crypto
Overview
A collection of useful crypto utilities for @polkadot
Index
Variables
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()
Variables
variable cryptoIsReady
const cryptoIsReady: any;
variable packageInfo
const packageInfo: { name: string; path: string; type: string; version: string };
Functions
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 | undefined) => 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 | undefined) => 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 | undefined) => 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 | undefined) => 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 | undefined) => 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 | undefined) => 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 | undefined) => 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 | undefined) => 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 | undefined) => 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) => `0x${string}`;
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 specifiedbitLength
.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 thesecretKey
.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
onmessage
with the suppliedpublicKey
. Returnstrue
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 | undefined) => value is string;
isBase32 Checks if the input is in base32, returning true/false
function isBase58
isBase58: (value?: unknown, ipfsCompat?: boolean | undefined) => value is string;
isBase58 Checks if the input is in base58, returning true/false
function isBase64
isBase64: (value?: unknown, ipfsCompat?: boolean | undefined) => 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 | undefined) => Uint8Array;
keccak256AsU8a Creates a keccak256 Uint8Array from the input.
function keccak512AsU8a
keccak512AsU8a: ( data: string | Uint8Array, onlyJs?: boolean | undefined) => Uint8Array;
keccak512AsU8a Creates a keccak512 Uint8Array from the input.
function keccakAsHex
keccakAsHex: ( value: string | Uint8Array, bitLength?: 256 | 512 | undefined, onlyJs?: boolean | undefined) => `0x${string}`;
keccakAsHex Creates a keccak hex string from the input.
function keccakAsU8a
keccakAsU8a: ( value: string | Uint8Array, bitLength?: 256 | 512 | undefined, onlyJs?: boolean | undefined) => Uint8Array;
keccakAsU8a Creates a keccak Uint8Array from the input. From either a
string
or aBuffer
input, create the keccak and return the result as aUint8Array
.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(); // => stringconst isValidMnemonic = mnemonicValidate(mnemonic); // => booleanif (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(); // => stringconst 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
andnonce
.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
andnonce
. If thenonce
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) => `0x${string}`;
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 | undefined) => Uint8Array;
sha256AsU8a Creates a sha256 Uint8Array from the input.
function sha512AsU8a
sha512AsU8a: ( data: string | Uint8Array, onlyJs?: boolean | undefined) => Uint8Array;
sha512AsU8a Creates a sha512 Uint8Array from the input.
function shaAsU8a
shaAsU8a: ( value: string | Uint8Array, bitLength?: 256 | 512 | undefined, onlyJs?: boolean | undefined) => 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) => `0x${string}`;
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 aBuffer
input, create the xxhash64 and return the result as aUint8Array
with the specifiedbitLength
.Example 1
import { xxhashAsU8a } from '@polkadot/util-crypto';xxhashAsU8a('abc'); // => 0x44bc2cf5ad770999
Package Files (82)
- address/addressToEvm.d.ts
- address/check.d.ts
- address/checksum.d.ts
- address/decode.d.ts
- address/derive.d.ts
- address/encode.d.ts
- address/encodeDerived.d.ts
- address/encodeMulti.d.ts
- address/eq.d.ts
- address/evmToAddress.d.ts
- address/is.d.ts
- address/keyDerived.d.ts
- address/keyMulti.d.ts
- address/setSS58Format.d.ts
- address/sort.d.ts
- address/validate.d.ts
- base32/bs32.d.ts
- base58/bs58.d.ts
- base64/bs64.d.ts
- base64/pad.d.ts
- base64/trim.d.ts
- blake2/asU8a.d.ts
- crypto.d.ts
- ed25519/deriveHard.d.ts
- ed25519/pair/fromRandom.d.ts
- ed25519/pair/fromSecret.d.ts
- ed25519/pair/fromSeed.d.ts
- ed25519/pair/fromString.d.ts
- ed25519/sign.d.ts
- ed25519/verify.d.ts
- ethereum/encode.d.ts
- ethereum/isAddress.d.ts
- ethereum/isChecksum.d.ts
- hd/ethereum/index.d.ts
- hd/ledger/index.d.ts
- hd/validatePath.d.ts
- hmac/shaAsU8a.d.ts
- index.d.ts
- json/decrypt.d.ts
- json/decryptData.d.ts
- json/encrypt.d.ts
- json/encryptFormat.d.ts
- keccak/asU8a.d.ts
- key/extractPath.d.ts
- key/extractSuri.d.ts
- key/fromPath.d.ts
- key/hdkdEcdsa.d.ts
- key/hdkdEd25519.d.ts
- key/hdkdSr25519.d.ts
- mnemonic/generate.d.ts
- mnemonic/toEntropy.d.ts
- mnemonic/toLegacySeed.d.ts
- mnemonic/toMiniSecret.d.ts
- mnemonic/validate.d.ts
- nacl/decrypt.d.ts
- nacl/encrypt.d.ts
- packageInfo.d.ts
- pbkdf2/encode.d.ts
- random/asNumber.d.ts
- random/asU8a.d.ts
- scrypt/encode.d.ts
- scrypt/fromU8a.d.ts
- scrypt/toU8a.d.ts
- secp256k1/compress.d.ts
- secp256k1/expand.d.ts
- secp256k1/pair/fromSeed.d.ts
- secp256k1/recover.d.ts
- secp256k1/sign.d.ts
- secp256k1/tweakAdd.d.ts
- secp256k1/verify.d.ts
- sha/asU8a.d.ts
- signature/verify.d.ts
- sr25519/agreement.d.ts
- sr25519/deriveHard.d.ts
- sr25519/derivePublic.d.ts
- sr25519/deriveSoft.d.ts
- sr25519/pair/fromSeed.d.ts
- sr25519/sign.d.ts
- sr25519/verify.d.ts
- sr25519/vrfSign.d.ts
- sr25519/vrfVerify.d.ts
- xxhash/asU8a.d.ts
Dependencies (10)
Dev Dependencies (0)
No dev dependencies.
Peer Dependencies (1)
Badge
To add a badge like this oneto your package's README, use the codes available below.
You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@polkadot/util-crypto
.
- Markdown[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@polkadot/util-crypto)
- HTML<a href="https://www.jsdocs.io/package/@polkadot/util-crypto"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>
- Updated .
Package analyzed in 5034 ms. - Missing or incorrect documentation? Open an issue for this package.