Audited pure JS library containing all Ethereum-related cryptographic primitives
Audited pure JS library containing all Ethereum-related cryptographic primitives
Audited pure JS library containing all Ethereum-related cryptographic primitives. Implemented with 6 noble & scure dependencies.
Check out Changelog / Upgrading and an article about the library: A safer, smaller, and faster Ethereum cryptography stack.
npm install ethereum-cryptographyWe explicitly support major browsers and Node.js on x86 and arm64. Other major runtimes and platforms are supported on a best-effort basis.
Refer to engines field of package.json for runtime support information for each version.
Tests are being ran with Webpack, Rollup, Parcel and Browserify.
This package has no single entry-point, but submodule for each cryptographic primitive. The reason for this is that importing everything from a single file will lead to huge bundles when using this package for the web. This could be avoided through tree-shaking, but the possibility of it not working properly on one of the supported bundlers is too high.
All functionality of the module is simple re-export of 6 audited noble & scure libraries:
ethereum-cryptography pins versions of the libraries to ensure good
protection against supply chain attacks. Ideally, your app would also
pin version of ethereum-cryptography. That means, no ^3.1.0 - use 3.1.0 instead.
…import { pbkdf2, pbkdf2Sync } from "ethereum-cryptography/pbkdf2.js";
import { scrypt, scryptSync } from "ethereum-cryptography/scrypt.js";
import { utf8ToBytes } from "ethereum-cryptography/utils.js";
// Pass Uint8Array, or convert strings to Uint8Array
const pass = utf8ToBytes("password");
const salt = utf8ToBytes("salt");
const iters = 131072;
const outLength = 32;
console.log(await pbkdf2(pass, salt, iters, outLength, "sha256"));
const N = 262144;
const r = 8;
const p = 1;
const outLengths = 32;
console.log(await scrypt(pass, salt, N, r, p, outLengths));The pbkdf2 submodule has two functions implementing the PBKDF2 key
derivation algorithm in synchronous and asynchronous ways. This algorithm is
very slow, and using the synchronous version in the browser is not recommended,
as it will block its main thread and hang your UI. The KDF supports sha256 and sha512 digests.
The scrypt submodule has two functions implementing the Scrypt key
derivation algorithm in synchronous and asynchronous ways. This algorithm is
very slow, and using the synchronous version in the browser is not recommended,
as it will block its main thread and hang your UI.
Encoding passwords is a frequent source of errors. Please read notes before using these submodules.
import { getRandomBytesSync } from "ethereum-cryptography/random.js";
console.log(getRandomBytesSync(32));The random submodule has functions to generate cryptographically strong
pseudo-random data in synchronous and asynchronous ways. Backed by crypto.getRandomValues in browser and by crypto.randomBytes in node.js. If backends are somehow not available, the module would throw an error and won't work, as keeping them working would be insecure.
import { secp256k1 } from "ethereum-cryptography/secp256k1.js";
// You pass either a hex string, or Uint8Array
const privateKey =
"6b911fd37cdf5c81d4c0adb1ab7fa822ed253ab0ad9aa18d77257c88b29b718e";
const messageHash =
"a33321f98e4ff1c283c76998f14f57447545d339b3db534c6d886decb4209f28";
const publicKey = secp256k1.getPublicKey(privateKey);
const signature = secp256k1.sign(messageHash, privateKey);
const isSigned = secp256k1.verify(signature, messageHash, publicKey);Elliptic curve operations on the curve secp256k1. Check out noble-curves docs for more info.
secp256k1 private keys need to be cryptographically secure random numbers with certain characteristics. If this is not the case, the security of secp256k1 is compromised.
import { bn } from "ethereum-cryptography/bls.js";
console.log(bn254.G1, bn254.G2, bn254.pairing);For example usage, check out the implementation of bn254 EVM precompiles.
…For example usage, check out the implementation of BLS EVM precompiles.
…import { HDKey } from "ethereum-cryptography/hdkey.js";
const hdkey1 = HDKey.fromMasterSeed(seed);
const hdkey2 = HDKey.fromExtendedKey(base58key);
const hdkey3 = HDKey.fromJSON({ xpriv: string });
// props
[hdkey1.depth, hdkey1.index, hdkey1.chainCode];
console.log(hdkey2.privateKey, hdkey2.publicKey);
console.log(hdkey3.derive("m/0/2147483647'/1"));
const sig = hdkey3.sign(hash);
hdkey3.verify(hash, sig);Hierarchical deterministic (HD) wallets that conform to BIP32.
…The bip39 submodule provides functions to generate, validate and use seed
recovery phrases according to BIP39.
Wordlists for different languages are not imported by default, as that would increase bundle sizes too much. Instead, you should import and use them explicitly.
import { modPow, modInvert } from "ethereum-cryptography/math.js";
modPow(123n, 456n, 789n);
modInvert(22n, 5n);import { hexToBytes, toHex, utf8ToBytes } from "ethereum-cryptography/utils.js";import {
createPrivateKeySync,
ecdsaSign,
} from "ethereum-cryptography/secp256k1-compat";
const msgHash = Uint8Array.from(
"82ff40c0a986c6a5cfad4ddf4c3aa6996f1a7837f9c398e17e5de5cbd5a12b28",
"hex"
);
const privateKey = createPrivateKeySync();
console.log(Uint8Array.from(ecdsaSign(msgHash, privateKey).signature));Warning: use secp256k1 instead. This module is only for users who upgraded
from ethereum-cryptography v0.1. It could be removed in the future.
The API of secp256k1-compat is the same as secp256k1-node:
…Using this library with Rollup requires the following plugins:
These can be used by setting your plugins array like this:
plugins: [
commonjs(),
resolve({
browser: true,
preferBuiltins: false,
}),
];AES is not supposed to be used directly with a password. Doing that will compromise your users' security.
The key parameters in this submodule are meant to be strong cryptographic
keys. If you want to obtain such a key from a password, please use a
key derivation function
like pbkdf2 or scrypt.
This submodule works with different block cipher modes of operation. If you are using this module in a new application, we recommend using the default.
While this module may work with any mode supported by OpenSSL, we only test it
with aes-128-ctr, aes-128-cbc, and aes-256-cbc. If you use another module
a warning will be printed in the console.
We only recommend using aes-128-cbc and aes-256-cbc to decrypt already
encrypted data.
Some operation modes require the plaintext message to be a multiple of 16. If
that isn't the case, your message has to be padded.
By default, this module automatically pads your messages according to PKCS#7. Note that this padding scheme always adds at least 1 byte of padding. If you are unsure what anything of this means, we strongly recommend you to use the defaults.
If you need to encrypt without padding or want to use another padding scheme,
you can disable PKCS#7 padding by passing false as the last argument and
handling padding yourself. Note that if you do this and your operation mode
requires padding, encrypt will throw if your plaintext message isn't a
multiple of 16.
This option is only present to enable the decryption of already encrypted data. To encrypt new data, we recommend using the default.
The iv parameter of the encrypt function must be unique, or the security
of the encryption algorithm can be compromised.
You can generate a new iv using the random module.
Note that to decrypt a value, you have to provide the same iv used to encrypt
it.
Sensitive information can be leaked via error messages when using this module. To avoid this, you should make sure that the errors you return don't contain the exact reason for the error. Instead, errors must report general encryption/decryption failures.
Note that implementing this can mean catching all errors that can be thrown when calling on of this module's functions, and just throwing a new generic exception.
bls, bn, math
change async AES to non-native sync,
improve typescript compatibility, new dependency noble-ciphersNo open issues yet, or sync has not completed.