npm package: @scom/ton-crypto
Latest version: 0.1.3

# @scom/ton-crypto


## Secure random
```js
import { getSecureRandomBytes, getSecureRandomWords, getSecureRandomNumber, newSecureWords, newSecurePassphrase } from '@scom/ton-crypto';
const randomBytes = await getSecureRandomBytes(32); // 32 random bytes
const randomWords: Uint16Array = await getSecureRandomBytes(32); // 64 random bytes packaed into words
const randomNumber: number = await getSecureRandomNumber(0, 10); // Random number from 0 (inclusive) to 10 (exclusive)
const secureWords: string[] = await newSecureWords(12); // Random 12 words from BIP-13 wordlist
const securePassptrase: string = await newSecurePassphrase(10); // Random 10 words that connected by dashes to make it look like password
```

## SHA-256 and SHA-512
All methods accept strings or Buffers as arguments.

```js
import { sha256, sha512, pbkdf2_sha512, hmac_sha512, sha256_sync, sha512_sync } from '@scom/ton-crypto';
import { Buffer } from '@scom/scom-buffer';

// Async methods
const hash1 = await sha256('hello-world');
const hash2 = await sha512(Buffer.from('hello-world', 'utf-8'));

// Sync methods
const hash1Sync = await sha256_sync('hello-world');
const hash2Sync = await sha512_sync('hello-world');
```

## HMAC-SHA-512
```js
const hmac = await hmac_sha512('hmac-key', 'data');
```

## PBKDF2-SHA-512
```js
const key = await pbkdf2_sha512('password', 'salt', 10000, 64);
```

## TON mnemonics
TON uses BIP-39 styled english mnemonics with custom key deriviation and built-in checksums.

```js
import { mnemonicNew, mnemonicValidate, mnemonicToPrivateKey, mnemonicToWalletKey, mnemonicToSeed, mnemonicWordList, KeyPair, mnemonicToHDSeed } from '@scom/ton-crypto';
const password: string | null | undefined = null; // Optional password
const mnemonics: string[] = await mnemonicNew(24, password); // Generate new menemonics
const mnemonicsValid: boolean = await mnemonicValidate(mnemonics, password); // Validate mnemonics
const keypair1: KeyPair = await mnemonicToPrivateKey(mnemonics, password); // Generates KeyPair from mnemonics
const keypair2: KeyPair = await mnemonicToWalletKey(mnemonics, password); // Generates KeyPair from mnemonics (results are SEEMS TO BE same as above)
const mnemonicsSeed = await mnemonicToSeed(mnemonics, 'Seed text', password); // Generates 64 bytes of seed from mnemonics and seed text.
const mnemonicHDSeed = await mnemonicToHDSeed(mnemonics, password); // Generates 64 bytes of seed for HD Keys
const wordlist = mnemonicWordList; // BIP39 word list
```

## NaCL-compatible Ed25519 signing
Ed25519 is used by TON in contracts to check signatures.

```js
import { keyPairFromSeed, keyPairFromSecretKey, sign, signVerify, KeyPair } from '@scom/ton-crypto';

const data = Buffer.from('Hello wordl!');

// Create Keypair
const seed = await getSecureRandomBytes(32); // Seed is always 32 bytes
const keypair: KeyPair = keyPairFromSeed(seed); // Creates keypair from random seed
const keypair2: KeyPair = keyPairFromSecretKey(keypair.secret); // Creates keypair from secret key

// Sign
const signature = sign(data, keypair.secret); // Creates signature for arbitrary data (it is recommended to get hash from data first)

// Check
const valid: boolean = signVerify(data, signature, keypair.public);

```

## NaCL-compatible symmetrict encryption

```js
import { sealBox, openBox, getSecureRandomBytes } from '@scom/ton-crypto';

const data = Buffer.from('Hello wordl!');

// Encryption
const key = await getSecureRandomBytes(32); // Key is always 32 bytes and secret
const nonce = await getSecureRandomBytes(24); // Nonce is always 24 bytes and public
const sealed = sealBox(data, nonce, key); // Sealed box

// Decryption
const decrypted | null = openBox(sealed, nonce, key); // Decrypted with integrity check. null if failed.
```

## SLIP-10 Ed25519 HD Keys

Generates SLIP-10 compatible hierarchy of keys

```js
import { newMnemonics, mnemonicToHDSeed, deriveEd25519Path, KeyPair } from '@scom/ton-crypto';

// Generate HD seed
// You can just generate 64-128 random bytes, but this way you will be able to 
// create it from mnemonics that you already have for a wallet
const mnemonics: string[] = await newMnemonics();
const seed = await mnemonicToHDSeed(mnemonics);

// Derive secret key from path m/0'/1'/2'/3'
const derivedSeed = await deriveEd25519Path(seed, [0, 1, 2, 3]);

// Create key pair
const keyPair: KeyPair = keyPairFromSeed(derivedSeed);

```

## SLIP-21 Symmetric HD Keys

Generates SLIP-21 compatible hierarchy of keys for symmetric encryption.

```js
import { newMnemonics, mnemonicToHDSeed, deriveSymmetricPath, KeyPair } from '@scom/ton-crypto';

// Generate HD seed
// You can just generate 64-128 random bytes, but this way you will be able to 
// create it from mnemonics that you already have for a wallet
const mnemonics: string[] = await newMnemonics();
const seed = await mnemonicToHDSeed(mnemonics);

// Derive secret key from path m/0'/1'/2'/3'
const derivedKey = await deriveSymmetricPath(seed, ['ton-seed', 'some-key', 'some-key2']);

```