@noble/ed25519 Documentation

You can install the library using npm or add it via Deno using JSR.

npm install @noble/ed25519

deno add jsr:@noble/ed25519

To use synchronous methods (e.g., ed.keygen(), ed.sign()), you must manually provide a hash function from @noble/hashes. This allows the library to avoid a hard dependency on a specific hash implementation.

1. Install @noble/hashes.
2. Assign sha512 to ed.hashes.sha512.

import * as ed from '@noble/ed25519';
import { sha512 } from '@noble/hashes/sha2.js';

ed.hashes.sha512 = sha512;

// Sync methods are now available:
const { secretKey, publicKey } = ed.keygen();
const msg = new TextEncoder().encode('hello noble');
const sig = ed.sign(msg, secretKey);
const isValid = ed.verify(sig, msg, publicKey);

React Native lacks a secure getRandomValues implementation and requires a manual assignment of the SHA512 hash function. You must install a React Native-specific polyfill for randomness.

import 'react-native-get-random-values';
import * as ed from '@noble/ed25519';
import { sha512 } from '@noble/hashes/sha2.js';

ed.hashes.sha512 = sha512;
ed.hashes.sha512Async = (m: Uint8Array) => Promise.resolve(sha512(m));

Use the asynchronous API to generate a secret key, derive a public key, sign a message, and verify the signature. This is the recommended way to use the library in modern environments.

import * as ed from '@noble/ed25519';
(async () => {
  const secretKey = ed.utils.randomSecretKey();
  const message = Uint8Array.from([0xab, 0xbc, 0xcd, 0xde]);
  const pubKey = await ed.getPublicKeyAsync(secretKey); // Sync methods are also present
  const signature = await ed.signAsync(message, secretKey);
  const isValid = await ed.verifyAsync(signature, message, pubKey);
})();

The synchronous methods (keygen, sign, verify) require a SHA-512 implementation to be manually provided via the hashes.sha512 property. If you are in an environment where you want to use the synchronous API, you must assign a function that takes a Bytes array and returns a Bytes array to ed.hashes.sha512 before calling those methods.

Example using @noble/hashes:

import * as ed from '@noble/ed25519';
import { sha512 } from '@noble/hashes/sha2.js';

// Must be done before calling synchronous keygen, sign, or verify
ed.hashes.sha512 = sha512;

const { secretKey, publicKey } = ed.keygen();

By default, the library only provides asynchronous methods to remain dependency-free. This is the standard way to use the library for key generation, signing, and verification.

import * as ed from '@noble/ed25519';

(async () => {
  const { secretKey, publicKey } = await ed.keygenAsync();
  const message = new TextEncoder().encode('hello noble');
  const signature = await ed.signAsync(message, secretKey);
  const isValid = await ed.verifyAsync(signature, message, publicKey);
})();

import * as ed from '@noble/ed25519';
(async () => {
  const { secretKey, publicKey } = await ed.keygenAsync();
  // const publicKey = await ed.getPublicKeyAsync(secretKey);
  const message = new TextEncoder().encode('hello noble');
  const signature = await ed.signAsync(message, secretKey);
  const isValid = await ed.verifyAsync(signature, message, publicKey);
})();

Generates a 32-byte public key from a 32-byte private key.

Additional Utilities:

• ed.Point.fromBytes(publicKey): Converts bytes into a Point object.
• ed.Point.fromHex(hex): Converts hex string into a Point object (uses RFC 8032 decompression 5.1.3).
• ed.utils.getExtendedPublicKey(secretKey): Returns the full SHA512 hash of the seed.

import * as ed from '@noble/ed25519';
import { sha512 } from '@noble/hashes/sha2.js';
ed.hashes.sha512 = sha512;

(async () => {
  const { secretKey: secretKeyA } = ed.keygen();
  const pubKey = ed.getPublicKey(secretKeyA);
  const pubKeyA = await ed.getPublicKeyAsync(secretKeyA);
  const pubKeyPoint = ed.Point.fromBytes(pubKey);
  const pubKeyExtended = ed.utils.getExtendedPublicKey(secretKeyA);
})();

Generates a deterministic EdDSA signature. The message is hashed by ed25519 internally.

Note: For prehashed ed25519ph, use noble-curves instead.

import * as ed from '@noble/ed25519';
import { sha512 } from '@noble/hashes/sha2.js';
ed.hashes.sha512 = sha512;

(async () => {
  const { secretKey, publicKey } = ed.keygen();
  const message = new TextEncoder().encode('hello noble');
  const signature = ed.sign(message, secretKey);
  const signatureA = await ed.signAsync(message, secretKey);
})();

Generates a new Ed25519 key pair. Returns an object containing secretKey and publicKey as Uint8Arrays.

import * as ed from '@noble/ed25519';
import { sha512 } from '@noble/hashes/sha2.js';
ed.hashes.sha512 = sha512;

(async () => {
  const keys = ed.keygen();
  const { secretKey, publicKey } = keys;
  const keysA = await ed.keygenAsync();
})();