waves_lib 0.1.0

data/js/node_modules/@waves/ts-lib-crypto/README.md

@@ -0,0 +1,492 @@
+# ts-lib-crypto [![npm version](https://badge.fury.io/js/%40waves%2Fts-lib-crypto.svg)](https://www.npmjs.com/package/@waves/ts-lib-crypto)
+
+The waves protocol is a set of rules named consensus by which nodes reach an agreement on the network, and format which nodes use to communicate with each other. It based on several well described hash and crypto algorithms and has predefined set of entries to operate on network. This library contains all algorithm implementations like signature verification and protocol entries like address used in waves protocol. Also it contains utility methods and format converters to help 3rd party developers.
+
+## Agenda
+- **[Installation](#installation)**
+- **[Import styles](#import-styles)**
+- **[Inputs](#inputs)**
+- **[Outputs](#outputs)**
+ - **[Seed generation](#seed-generation)**
+	 - [randomSeed](#randomseed)
+	 - [seedWordsList](#seedwordslist)
+ - **[Keys and address](#keys-and-address)**
+	 - [publicKey](#publickey)
+	 - [privateKey](#privatekey)
+	 - [keyPair](#keypair)
+	 - [address](#address)
+ - **[Signatures](#signatures)**
+	 - [signBytes](#signbytes)
+	 - [verifySignature](#verifySignature)
+- **[Hashing](#hashing)**
+	 - [blake2b](#blake2b)
+	 - [keccak](#keccak)
+	 - [sha256](#sha256)
+ - **[Random](#random)**
+	 - [randomBytes](#randomBytes)
+	 - [random](#random)
+ - **[Base encoding\decoding](#base-encodingdecoding)**
+	 - [base16](#base-encodingdecoding)
+	 - [base58](#base-encodingdecoding)
+	 - [base64](#base-encodingdecoding)
+ - **[Messaging](#messaging)**
+	 - [sharedKey](#sharedKey)
+	 - [messageEncrypt](#messageEncrypt)
+	 - [messageDecrypt](#messageDecrypt)
+ - **[Encryption](#encryption)**
+	 - [aesEncrypt](#aesEncrypt)
+	 - [aesDecrypt](#aesDecrypt)
+- **[Seed encryption](#Seed-encryption)**
+ - **[Utils](#utils)**
+	 - [split](#split)
+	 - [concat](#concat)
+	 - [stringToBytes](#stringtobytes)
+	 - [bytesToString](#bytestostring)
+- **[Constants](#constants)**
+- **[Interface](#interface)**
+- **[More examples](#more-examples)**
+## Installation
+```
+npm install @waves/ts-lib-crypto
+```
+## Import styles
+The is several ways of doing things when using **ts-lib-crypto**.
+You can import functions strait-forward:
+```ts
+import { address } from  '@waves/ts-lib-crypto'
+address('my secret seed') // 3PAP3wkgbGjdd1FuBLn9ajXvo6edBMCa115
+```
+Or you can use a crypto constructor function:
+```ts
+import { crypto } from  '@waves/ts-lib-crypto'
+const { address } = crypto()
+address('my secret seed') // 3PAP3wkgbGjdd1FuBLn9ajXvo6edBMCa115
+```
+The second approach gives you more flexibility, using this approach you are able to embed the **seed** and use all seed-dependant functions without **seed** parameter:
+```ts
+import { crypto } from  '@waves/ts-lib-crypto'
+const { address } = crypto({seed: 'my secret seed'})
+address() // 3PAP3wkgbGjdd1FuBLn9ajXvo6edBMCa115
+```
+
+## Inputs 
+**ts-lib-crypto** is even more flexible. Any function argument that represents binary data or seed could be passed in several ways. Let's take a look on the following example:
+```ts
+import { address } from  '@waves/ts-lib-crypto'
+const  seedString  =  'uncle push human bus echo drastic garden joke sand warfare sentence fossil title color combine'
+const  seedBytesAsArray  = [117, 110, 99, 108, 101, 32, 112, 117, 115, 104, 32, 104, 117, 109, 97, 110, 32, 98, 117, 115, 32, 101, 99, 104, 111, 32, 100, 114, 97, 115, 116, 105, 99, 32, 103, 97, 114, 100, 101, 110, 32, 106, 111, 107, 101, 32, 115, 97, 110, 100, 32, 119, 97, 114, 102, 97, 114, 101, 32, 115, 101, 110, 116, 101, 110, 99, 101, 32, 102, 111, 115, 115, 105, 108, 32, 116, 105, 116, 108, 101, 32, 99, 111, 108, 111, 114, 32, 99, 111, 109, 98, 105, 110, 101]
+const  seedBytesAsUintArray  =  Uint8Array.from(seedBytesAsArray)
+address(seedString) // 3P9KR33QyXwfTXv8kKtNGZYtgKk3RXSUk36
+address(seedBytesAsArray) // 3P9KR33QyXwfTXv8kKtNGZYtgKk3RXSUk36
+address(seedBytesAsUintArray) // 3P9KR33QyXwfTXv8kKtNGZYtgKk3RXSUk36
+```
+As you can see **seed** parameter is treated the same way for **number[]** or **Uint8Array**.
+When you pass binary data is could be represented as  **number[]** or **Uint8Array** or even **base58**:
+```ts
+import { address, randomSeed, sha256 } from '@waves/ts-lib-crypto'
+const seed = randomSeed() // uncle push human bus echo drastic garden joke sand warfare sentence fossil title color combine
+const addressBase58 = address(seed) // 3P9KR33QyXwfTXv8kKtNGZYtgKk3RXSUk36
+sha256(addressBase58) // DMPenguwWdLdZ7tesiZY6grw7mjKU2Dob1cn9Uq9TKfp
+```
+Here we got **sha256** hash from address bytes represented as **base58** *(3P9KR33QyXwfTXv8kKtNGZYtgKk3RXSUk36)*. 
+Be aware that **sha256** value is not based on "*3P9KR33QyXwfTXv8kKtNGZYtgKk3RXSUk36*" string itself, this value was treated as a **binary data** and **base58Decode** was applied.
+
+## Outputs
+As you've noticed from the previous section *address()* output is **base58** string like:
+```ts
+// 3PAP3wkgbGjdd1FuBLn9ajXvo6edBMCa115
+```
+ By default functions from the following list output **base58** string as a result,
+ no matter what import-style you choose:
+```
+keyPair
+publicKey
+privateKey
+address
+sharedKey
+signBytes
+```
+
+If you prefer **binary** output, you can alter this behaviour and make those functions to return **UInt8Array** instead.
+
+When using inline import style:
+```ts
+// You can use [/bytes] module when importing functions to set output to UInt8Array
+import { address } from  '@waves/ts-lib-crypto/bytes'
+address('uncle push human bus echo drastic garden joke sand warfare sentence fossil title color combine')
+// => Uint8Array [1,87,55,118,79,89,6,115,207,200,130,220,32,33,101,69,108,108,53,48,167,127,203,18,143,121]
+```
+When using crypto constructor function:
+```ts
+import { crypto } from  '@waves/ts-lib-crypto'
+const { address } = crypto({ output: 'Bytes' })
+address('uncle push human bus echo drastic garden joke sand warfare sentence fossil title color combine')
+// => Uint8Array [1,87,55,118,79,89,6,115,207,200,130,220,32,33,101,69,108,108,53,48,167,127,203,18,143,121]
+```
+
+## Seed generation
+
+The seed is a set of words or bytes that private and public keys are generated from. The usual Waves seed looks like:
+```
+uncle push human bus echo drastic garden joke sand warfare sentence fossil title color combine
+```
+There are couple ways to generate seed: 
+```ts
+const handWrittenSeedString = 'uncle push human bus echo drastic garden joke sand warfare sentence fossil title color combine'
+const handWrittenSeedBytes = [117, 110, 99, 108, 101, 32, 112, 117, 115, 104, 32, 104, 117, 109, 97, 110, 32, 98, 117, 115, 32, 101, 99, 104, 111, 32, 100, 114, 97, 115, 116, 105, 99, 32, 103, 97, 114, 100, 101, 110, 32, 106, 111, 107, 101, 32, 115, 97, 110, 100, 32, 119, 97, 114, 102, 97, 114, 101, 32, 115, 101, 110, 116, 101, 110, 99, 101, 32, 102, 111, 115, 115, 105, 108, 32, 116, 105, 116, 108, 101, 32, 99, 111, 108, 111, 114, 32, 99, 111, 109, 98, 105, 110, 101]
+```
+Or if you need seed with nonce:
+```ts
+import { seedWithNonce, randomSeed, address } from '@waves/ts-lib-crypto'
+
+const nonce = 1
+const seedphrase = randomSeed() // uncle push human bus echo drastic garden joke sand warfare sentence fossil title color combine
+const seed = seedWithNonce(seedphrase, nonce)
+
+//Now you can use seed as usual
+address(seed)
+```
+Seed could be any **string** or **number[]** or **Uint8Array** or **ISeedWithNonce**.
+
+There is also a way to generate seed-phrase using **ts-lib-crypto** described in the next section.
+
+### randomSeed
+```ts
+import { randomSeed } from '@waves/ts-lib-crypto'
+
+randomSeed() //uncle push human bus echo drastic garden joke sand warfare sentence fossil title color combine
+```
+You can also specify seed-phrase size:
+```ts
+randomSeed(3) //uncle push human
+```
+The default seed size is 15 words.
+
+### seedWordsList
+If you want to get all the valid seed words that official waves-client generates seed-phrase from, use **seedWordsList** the 2048 word array.
+```ts
+import { seedWordsList } from '@waves/ts-lib-crypto'
+console.log(seedWordsList) // [ 'abandon','ability','able', ... 2045 more items ]
+```
+## Keys and address
+
+### publicKey
+You could get public key either from raw seed-phrase or seed with nonce:
+```ts
+import { publicKey, seedWithNonce } from '@waves/ts-lib-crypto'
+const seed = 'uncle push human bus echo drastic garden joke sand warfare sentence fossil title color combine'
+publicKey(seed) // 4KxUVD9NtyRJjU3BCvPgJSttoJX7cb3DMdDTNucLN121
+publicKey(seedWithNonce(seed, 0)) // 4KxUVD9NtyRJjU3BCvPgJSttoJX7cb3DMdDTNucLN121
+```
+Or even from private key, it's usefull in some cases:
+```ts
+import { publicKey, privateKey, seedWithNonce } from '@waves/ts-lib-crypto'
+const seed = 'uncle push human bus echo drastic garden joke sand warfare sentence fossil title color combine'
+const pk = privateKey(seed)
+publicKey({ privateKey: pk }) // 4KxUVD9NtyRJjU3BCvPgJSttoJX7cb3DMdDTNucLN121
+```
+
+### privateKey
+Same with private key:
+```ts
+import { privateKey, seedWithNonce } from '@waves/ts-lib-crypto'
+const  seed = 'uncle push human bus echo drastic garden joke sand warfare sentence fossil title color combine'
+privateKey(seed)
+privateKey(seedWithNonce(seed, 99))
+```
+### keyPair
+You could also obtain a keyPair:
+```ts
+import { keyPair } from '@waves/ts-lib-crypto'
+const  seed = 'uncle push human bus echo drastic garden joke sand warfare sentence fossil title color combine'
+keyPair(seed)
+// => { 
+//      publicKey:  '4KxUVD9NtyRJjU3BCvPgJSttoJX7cb3DMdDTNucLN121',
+//      privateKey: '6zFSymZAoaua3gtJPbAUwM584tRETdKYdEG9BeEnZaGW'
+//    }
+```
+### address
+You can create an address for *Mainnet*:
+```ts
+import { address } from '@waves/ts-lib-crypto'
+const  seed = 'uncle push human bus echo drastic garden joke sand warfare sentence fossil title color combine'
+address(seed) // 3P9KR33QyXwfTXv8kKtNGZYtgKk3RXSUk36
+```
+or *Testnet*:
+```ts
+address(seed, 'T') // 3MwJc5iX7QQGq5ciVFdNK7B5KSEGbUCVxDw
+```
+alternatively You could use **TEST_NET_CHAIN_ID** constant instead of **T** literal like this:
+```ts
+import { address, TEST_NET_CHAIN_ID } from '@waves/ts-lib-crypto'
+const  seed = 'uncle push human bus echo drastic garden joke sand warfare sentence fossil title color combine'
+address(seed, TEST_NET_CHAIN_ID) // 3MwJc5iX7QQGq5ciVFdNK7B5KSEGbUCVxDw
+```
+There are several more useful constants, you can check them in [\[constants\]](/#constants) section.
+## Signatures
+#### signBytes
+To sign arbitrary bytes or usually transaction bytes you should use the **signBytes** function.
+Here is sign with seed example:
+```ts
+import { signBytes } from '@waves/ts-lib-crypto'
+const bytes = [117, 110, 99, 108, 101]
+const seed = 'uncle push human bus echo drastic garden joke sand warfare sentence fossil title color combine'
+signBytes(seed, bytes) // 5ZpULwrnUYoxQZcw26km6tgGbj1y23ywYB4A9bLCpax6PUdrhkCmmoLBP6C1G5yiMJ7drqN9jNxPym6f8vrPsWnm
+```
+Also you can use private key to sign bytes:
+```ts
+import { signBytes, privateKey } from '@waves/ts-lib-crypto'
+const bytes = [117, 110, 99, 108, 101]
+const seed = 'uncle push human bus echo drastic garden joke sand warfare sentence fossil title color combine'
+const key = privateKey(seed)
+signBytes({ privateKey: key }, bytes)
+```
+Remember that you can use **base58** strings when it's about binary data, so you can represent bytes as **base58** too:
+```ts
+signBytes({ privateKey:  key }, 'Fk1sjwdPSwZ4bPwvpCGPH6')
+```
+You can learn more about it in the [outputs](#outputs) section.
+#### verifySignature
+Verifying signature is a way to proof what particular bytes was signed with a particular private key or seed which correspond to public key that we are checking against:
+```ts
+import { signBytes, verifySignature, keyPair } from '@waves/ts-lib-crypto'
+//Signature roundtrip
+const bytes = [117, 110, 99, 108, 101]
+const seed = 'uncle push human bus echo drastic garden joke sand warfare sentence fossil title color combine'
+const keys = keyPair(seed)
+const signature = signBytes(keys, bytes)
+verifySignature(keys.publicKey, bytes, signature) // true
+```
+## Hashing
+There are three hashing algorithms available in **ts-lib-crypto**.
+#### blake2b
+```ts
+import { blake2b } from '@waves/ts-lib-crypto'
+const bytesArray = [117, 110, 99, 108, 101]
+const bytesUint = Uint8Array.from([117, 110, 99, 108, 101])
+const bytesBase58 = 'EFRr9cp'
+blake2b(bytesArray)  // 9DqBU9wZAR85PyrUSJpwaU9DggM8veyMxRMvFe1q6atu
+blake2b(bytesUint)   // 9DqBU9wZAR85PyrUSJpwaU9DggM8veyMxRMvFe1q6atu
+blake2b(bytesBase58) // 9DqBU9wZAR85PyrUSJpwaU9DggM8veyMxRMvFe1q6atu
+
+```
+#### keccak
+```ts
+import { keccak } from '@waves/ts-lib-crypto'
+const bytesArray = [117, 110, 99, 108, 101]
+const bytesUint = Uint8Array.from([117, 110, 99, 108, 101])
+const bytesBase58 = 'EFRr9cp'
+keccak(bytesArray)  // 5cqz9N2PPjDkSBSwga8AttKzQEHfn8aQ95rcZZmabLA7
+keccak(bytesUint)   // 5cqz9N2PPjDkSBSwga8AttKzQEHfn8aQ95rcZZmabLA7
+keccak(bytesBase58) // 5cqz9N2PPjDkSBSwga8AttKzQEHfn8aQ95rcZZmabLA7
+```
+#### sha256
+```ts
+import { sha256 } from '@waves/ts-lib-crypto'
+const bytesArray = [117, 110, 99, 108, 101]
+const bytesUint = Uint8Array.from([117, 110, 99, 108, 101])
+const bytesBase58 = 'EFRr9cp'
+sha256(bytesArray)  // 4JPydqbhxhZF7kpuGA2tJWkXDmevJYfig45gqdV1UF9E
+sha256(bytesUint)   // 4JPydqbhxhZF7kpuGA2tJWkXDmevJYfig45gqdV1UF9E
+sha256(bytesBase58) // 4JPydqbhxhZF7kpuGA2tJWkXDmevJYfig45gqdV1UF9E
+```
+## Random
+There is several ways to get random values in **ts-lib-crypto**.
+To get an **Uint8Array** of random values simply use:
+#### randomBytes
+```ts
+import { randomBytes } from '@waves/ts-lib-crypto'
+randomBytes(3) // Uint8Array [ 120, 46, 179 ]             
+```
+If you want more control over the values format you could use:
+#### random
+```ts
+import { random } from '@waves/ts-lib-crypto'
+
+const length = 3     
+random(length, 'Array8')       // [ 19, 172, 130 ]   
+random(length, 'Array16')      // [ 61736, 48261, 38395 ] 
+random(length, 'Array32')      // [ 406628961, 307686833, 2604847943 ]       
+random(length, 'Buffer')       // <Buffer db ff fb>       
+random(length, 'Uint8Array')   // Uint8Array [ 137, 85, 212 ]   
+random(length, 'Uint16Array')  // Uint16Array [ 35881, 51653, 55967 ]  
+random(length, 'Uint32Array')  // Uint32Array [ 698646076, 2957331816, 2073997581 ]    
+```
+## Base encoding\decoding
+
+
+```ts
+import { base16Encode, base16Decode, base58Encode, base58Decode, base64Encode, base64Decode, randomBytes } from '@waves/ts-lib-crypto'
+
+const bytes = randomBytes(32)
+
+// Base16 same as Hex
+const base16String = base16Encode(bytes) // 2059ec5d9ed640b75722ec6a2ff76890e523ea4624887549db761d678ba8f899
+const bytesFromBase16 = base16Decode(base16String)
+
+// Base58
+const base58String = base58Encode(bytes) // 3BHaM9Q5HhUobQ5oZAqjdkE9HRpmqMx4XLq3GXTMD5tU
+const bytesFromBase58 = base58Decode(base58String)
+
+// Base64
+const base64String = base64Encode(bytes) // IFnsXZ7WQLdXIuxqL/dokOUj6kYkiHVJ23YdZ4uo+Jk=
+const bytesFromBase64 = base64Decode(base64String)
+```
+## Messaging
+These methods implement waves messaging protocol 
+- sharedKey 
+- messageDecrypt
+- messageEncrypt
+```typescript
+import { sharedKey, messageEncrypt, messageDecrypt, keyPair } from '@waves/ts-lib-crypto'
+
+const bobKeyPair = keyPair('Bob')
+const aliceKeyPair = keyPair('Alice')
+const msg = 'hello world'
+
+// Alice derives shared key and encrypts message
+const sharedKeyA = sharedKey(aliceKeyPair.privateKey, bobKeyPair.publicKey, 'waves') 
+const encrypted = messageEncrypt(sharedKeyA, msg)
+
+// Bob decrypts message derives shared key and decrypts message
+const sharedKeyB = sharedKey(aliceKeyPair.privateKey, bobKeyPair.publicKey, 'waves') 
+const decrypted = messageDecrypt(sharedKeyB, encrypted)
+```
+## Encryption
+This is low level functionality where you have to generate key and iv yourself 
+#### aesEncrypt
+Encrypt bytes using AES algorithm. 
+```typescript
+import { aesEncrypt, randomBytes } from '@waves/ts-lib-crypto'
+
+const data = Uint8Arraty.from([1,2,3])
+const mode =  'CBC' // Possible modes are 'CBC' | 'CFB' | 'CTR' | 'OFB' | 'ECB' | 'GCM'
+
+const key = randomBytes(32)
+const iv = randomBytes(32)
+
+const encrypted = aesEncrypt(data, key, mode, iv)
+
+```
+#### aesDecrypt
+Decrypt bytes using AES algorithm
+```typescript
+const decrypted = aesDecrypt(encrypted, key, mode, iv)
+```
+
+## Seed encryption
+These functions implements seed encryption protocol used in DexClient and WavesKeeper
+```typescript
+import { encryptSeed, decryptSeed } from '@waves/ts-lib-crypto'
+
+const seed = 'some secret seed phrase i use'
+const encrypted = encryptSeed(seed, 'secure password')
+const decrypted = decryptSeed(encryptSeed, 'secure password')
+
+```
+## Utils
+Utility functions designed to help 3rd party developers working with js binary types like Uint8Array and Buffer.
+#### split
+You can use split for splitting bytes to sub arrays.
+```ts
+import { split, randomBytes } from '@waves/ts-lib-crypto'
+const bytes = randomBytes(2 + 3 + 4 + 10)
+split(bytes, 2, 3, 4)
+// [ 
+//   Uint8Array [195, 206],
+//   Uint8Array [ 10, 208, 171 ],
+//   Uint8Array [ 36, 18, 254, 205 ],
+//   Uint8Array [ 244, 232, 55, 11, 113, 47, 80, 194, 170, 216 ]
+// ]
+```
+Alternatively, you can use array deconstruction syntax:
+```ts
+const [a, b, c, rest] = split(bytes, 2, 3, 4)
+// a = Uint8Array [195, 206],
+// b = Uint8Array [ 10, 208, 171 ],
+// c = Uint8Array [ 36, 18, 254, 205 ],
+// rest = Uint8Array [ 244, 232, 55, 11, 113, 47, 80, 194, 170, 216 ]
+```
+#### concat
+Concat is the opposite and pretty self-explanatory:
+```ts
+import { concat, randomBytes } from '@waves/ts-lib-crypto'
+const bytesA = randomBytes(2)
+const bytesB = randomBytes(2)
+concat(bytesA, bytesB) // Uint8Array [ 36, 18, 254, 205 ]
+```
+#### stringToBytes
+```ts
+import { stringToBytes } from '@waves/ts-lib-crypto'
+stringToBytes('Waves!') // Uint8Array [ 87, 97, 118, 101, 115, 33 ]
+```
+#### bytesToString
+```ts
+import { bytesToString } from '@waves/ts-lib-crypto'
+bytesToString([ 87, 97, 118, 101, 115, 33 ]) // Waves!
+```
+## Constants
+There is several useful constants declared at **ts-lib-crypto**:
+```ts
+const PUBLIC_KEY_LENGTH = 32
+const PRIVATE_KEY_LENGTH = 32
+const SIGNATURE_LENGTH = 64
+const ADDRESS_LENGTH = 26
+
+const MAIN_NET_CHAIN_ID = 87 // W
+const TEST_NET_CHAIN_ID = 84 // T
+```
+## Interface 
+The full **IWavesCrypto** interface can be found on the [project`s github](https://github.com/wavesplatform/ts-lib-crypto) in [interface.ts](https://github.com/wavesplatform/ts-lib-crypto/blob/master/src/crypto/interface.ts).
+```ts
+  //Seeds, keys and addresses
+  seedWithNonce: (seed: TSeed, nonce: number) => INonceSeed
+  keyPair: (seed: TSeed) => TKeyPair<TBytesOrBase58>
+  publicKey: (seed: TSeed) => TBytesOrBase58
+  privateKey: (seed: TSeed) => TBytesOrBase58
+  address: (seedOrPublicKey: TSeed | TPublicKey<TBinaryIn>, chainId?: TChainId) => TBytesOrBase58
+
+  //Signature
+  signBytes: (seedOrPrivateKey: TSeed | TPrivateKey<TBinaryIn>, bytes: TBinaryIn, random?: TBinaryIn) => TDesiredOut
+  //Hashing 
+  blake2b: (input: TBinaryIn) => TBytes
+  keccak: (input: TBinaryIn) => TBytes
+  sha256: (input: TBinaryIn) => TBytes
+
+  //Base encoding\decoding
+  base64Encode: (input: TBinaryIn) => TBase64
+  base64Decode: (input: TBase64) => TBytes //throws (invalid input)
+  base58Encode: (input: TBinaryIn) => TBase58
+  base58Decode: (input: TBase58) => TBytes //throws (invalid input)
+  base16Encode: (input: TBinaryIn) => TBase16
+  base16Decode: (input: TBase16) => TBytes //throws (invalid input)
+
+  //Utils
+  stringToBytes: (input: string) => TBytes
+  bytesToString: (input: TBinaryIn) => string
+  split: (binary: TBinaryIn, ...sizes: number[]) => TBytes[]
+  concat: (...binaries: TBinaryIn[]) => TBytes
+
+  //Random
+  random<T extends keyof TRandomTypesMap>(count: number, type: T): TRandomTypesMap[T]
+  randomBytes: (size: number) => TBytes
+  randomSeed: (wordsCount?: number) => string
+
+  //Verification
+  verifySignature: (publicKey: TBinaryIn, bytes: TBinaryIn, signature: TBinaryIn) => boolean
+  verifyPublicKey: (publicKey: TBinaryIn) => boolean
+  verifyAddress: (address: TBinaryIn, optional?: { chainId?: TChainId, publicKey?: TBinaryIn }) => boolean
+
+  //Messaging
+  sharedKey: (privateKeyFrom: TBinaryIn, publicKeyTo: TBinaryIn, prefix: TRawStringIn) => TBytesOrBase58
+  messageDecrypt: (sharedKey: TBinaryIn, encryptedMessage: TBinaryIn) => string
+  messageEncrypt: (sharedKey: TBinaryIn, message: TRawStringIn) => TBytes
+
+  //Encryption
+  aesEncrypt: (data: TRawStringIn, secret: TBinaryIn, mode?: AESMode, iv?: TBinaryIn) => TBytes
+  aesDecrypt: (encryptedData: TBinaryIn, secret: TBinaryIn, mode?: AESMode, iv?: TBinaryIn) => TBytes
+```
+## More examples
+Every example used in this document and many more can be found on the [project`s github](https://github.com/wavesplatform/ts-lib-crypto) inside [examples](https://github.com/wavesplatform/ts-lib-crypto/tree/master/examples) folder.
+
+

data/js/node_modules/@waves/ts-lib-crypto/bytes.d.ts

@@ -0,0 +1,10 @@
+export { seedWordsList } from './crypto/seed-words-list';
+export { ChaidId } from './extensions/chain-id';
+export { Seed } from './extensions/seed';
+export { isPrivateKey, isPublicKey } from './crypto/util';
+export { crypto } from './crypto/crypto';
+export * from './crypto/interface';
+export declare const signBytes: (seedOrPrivateKey: string | Uint8Array | number[] | import("./crypto/interface").TRawStringInDiscriminator | import("./crypto/interface").INonceSeed | import("./crypto/interface").TPrivateKey<import("./crypto/interface").TBinaryIn>, bytes: import("./crypto/interface").TBinaryIn, random?: string | Uint8Array | number[] | undefined) => Uint8Array, keyPair: (seed: import("./crypto/interface").TSeed) => import("./crypto/interface").TKeyPair<Uint8Array>, buildAddress: (publicKeyBytes: Uint8Array, chainId: string | number) => Uint8Array, publicKey: (seedOrPrivateKey: string | Uint8Array | number[] | import("./crypto/interface").TRawStringInDiscriminator | import("./crypto/interface").INonceSeed | import("./crypto/interface").TPrivateKey<import("./crypto/interface").TBinaryIn>) => Uint8Array, privateKey: (seed: import("./crypto/interface").TSeed) => Uint8Array, address: (seedOrPublicKey: string | Uint8Array | number[] | import("./crypto/interface").TRawStringInDiscriminator | import("./crypto/interface").INonceSeed | import("./crypto/interface").TPublicKey<import("./crypto/interface").TBinaryIn>, chainId?: string | number | undefined) => Uint8Array, blake2b: (input: import("./crypto/interface").TBinaryIn) => Uint8Array, keccak: (input: import("./crypto/interface").TBinaryIn) => Uint8Array, sha256: (input: import("./crypto/interface").TBinaryIn) => Uint8Array, sharedKey: (privateKeyFrom: import("./crypto/interface").TBinaryIn, publicKeyTo: import("./crypto/interface").TBinaryIn, prefix: import("./crypto/interface").TRawStringIn) => Uint8Array, seedWithNonce: (seed: import("./crypto/interface").TSeed, nonce: number) => import("./crypto/interface").INonceSeed, base64Encode: (input: import("./crypto/interface").TBinaryIn) => string, base64Decode: (input: string) => Uint8Array, base58Encode: (input: import("./crypto/interface").TBinaryIn) => string, base58Decode: (input: string) => Uint8Array, base16Encode: (input: import("./crypto/interface").TBinaryIn) => string, base16Decode: (input: string) => Uint8Array, stringToBytes: (input: string, encoding?: "utf8" | "raw" | undefined) => Uint8Array, bytesToString: (input: import("./crypto/interface").TBinaryIn, encoding?: "utf8" | "raw" | undefined) => string, random: <T extends "Array8" | "Array16" | "Array32" | "Buffer" | "Uint8Array" | "Uint16Array" | "Uint32Array">(count: number, type: T) => import("./crypto/interface").TRandomTypesMap[T], randomSeed: (wordsCount?: number | undefined) => string, randomBytes: (size: number) => Uint8Array, verifySignature: (publicKey: import("./crypto/interface").TBinaryIn, bytes: import("./crypto/interface").TBinaryIn, signature: import("./crypto/interface").TBinaryIn) => boolean, verifyPublicKey: (publicKey: import("./crypto/interface").TBinaryIn) => boolean, verifyAddress: (address: import("./crypto/interface").TBinaryIn, optional?: {
+    chainId?: string | number | undefined;
+    publicKey?: string | Uint8Array | number[] | undefined;
+} | undefined) => boolean, messageDecrypt: (sharedKey: import("./crypto/interface").TBinaryIn, encryptedMessage: import("./crypto/interface").TBinaryIn) => string, messageEncrypt: (sharedKey: import("./crypto/interface").TBinaryIn, message: string) => Uint8Array, aesDecrypt: (encryptedData: import("./crypto/interface").TBinaryIn, encryptionKey: import("./crypto/interface").TBinaryIn, mode?: "CBC" | "CFB" | "CTR" | "OFB" | "ECB" | "GCM" | undefined, iv?: string | Uint8Array | number[] | undefined) => Uint8Array, aesEncrypt: (data: import("./crypto/interface").TBinaryIn, encryptionKey: import("./crypto/interface").TBinaryIn, mode?: "CBC" | "CFB" | "CTR" | "OFB" | "ECB" | "GCM" | undefined, iv?: string | Uint8Array | number[] | undefined) => Uint8Array, encryptSeed: (seed: string, password: string, encryptionRounds?: number | undefined) => string, decryptSeed: (encryptedSeed: string, password: string, encryptionRounds?: number | undefined) => string, rsaKeyPair: (bits?: number | undefined, e?: number | undefined) => Promise<import("./crypto/interface").TRSAKeyPair>, rsaKeyPairSync: (bits?: number | undefined, e?: number | undefined) => import("./crypto/interface").TRSAKeyPair, rsaSign: (rsaPrivateKey: Uint8Array, message: Uint8Array, digest?: "MD5" | "SHA1" | "SHA224" | "SHA256" | "SHA384" | "SHA512" | "SHA3-224" | "SHA3-256" | "SHA3-384" | "SHA3-512" | undefined) => Uint8Array, rsaVerify: (rsaPublicKey: Uint8Array, message: Uint8Array, signature: Uint8Array, digest?: "MD5" | "SHA1" | "SHA224" | "SHA256" | "SHA384" | "SHA512" | "SHA3-224" | "SHA3-256" | "SHA3-384" | "SHA3-512" | undefined) => boolean, merkleVerify: (rootHash: Uint8Array, merkleProof: Uint8Array, leafData: Uint8Array) => boolean, split: (binary: import("./crypto/interface").TBinaryIn, ...sizes: number[]) => Uint8Array[], concat: (...binaries: import("./crypto/interface").TBinaryIn[]) => Uint8Array;

data/js/node_modules/@waves/ts-lib-crypto/bytes.js

@@ -0,0 +1,21 @@
+"use strict";
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+var crypto_1 = require("./crypto/crypto");
+var seed_words_list_1 = require("./crypto/seed-words-list");
+exports.seedWordsList = seed_words_list_1.seedWordsList;
+var chain_id_1 = require("./extensions/chain-id");
+exports.ChaidId = chain_id_1.ChaidId;
+var seed_1 = require("./extensions/seed");
+exports.Seed = seed_1.Seed;
+var util_1 = require("./crypto/util");
+exports.isPrivateKey = util_1.isPrivateKey;
+exports.isPublicKey = util_1.isPublicKey;
+var crypto_2 = require("./crypto/crypto");
+exports.crypto = crypto_2.crypto;
+__export(require("./crypto/interface"));
+exports.signBytes = (_a = crypto_1.crypto({ output: 'Bytes' }), _a.signBytes), exports.keyPair = _a.keyPair, exports.buildAddress = _a.buildAddress, exports.publicKey = _a.publicKey, exports.privateKey = _a.privateKey, exports.address = _a.address, exports.blake2b = _a.blake2b, exports.keccak = _a.keccak, exports.sha256 = _a.sha256, exports.sharedKey = _a.sharedKey, exports.seedWithNonce = _a.seedWithNonce, exports.base64Encode = _a.base64Encode, exports.base64Decode = _a.base64Decode, exports.base58Encode = _a.base58Encode, exports.base58Decode = _a.base58Decode, exports.base16Encode = _a.base16Encode, exports.base16Decode = _a.base16Decode, exports.stringToBytes = _a.stringToBytes, exports.bytesToString = _a.bytesToString, exports.random = _a.random, exports.randomSeed = _a.randomSeed, exports.randomBytes = _a.randomBytes, exports.verifySignature = _a.verifySignature, exports.verifyPublicKey = _a.verifyPublicKey, exports.verifyAddress = _a.verifyAddress, exports.messageDecrypt = _a.messageDecrypt, exports.messageEncrypt = _a.messageEncrypt, exports.aesDecrypt = _a.aesDecrypt, exports.aesEncrypt = _a.aesEncrypt, exports.encryptSeed = _a.encryptSeed, exports.decryptSeed = _a.decryptSeed, exports.rsaKeyPair = _a.rsaKeyPair, exports.rsaKeyPairSync = _a.rsaKeyPairSync, exports.rsaSign = _a.rsaSign, exports.rsaVerify = _a.rsaVerify, exports.merkleVerify = _a.merkleVerify, exports.split = _a.split, exports.concat = _a.concat;
+//# sourceMappingURL=bytes.js.map

data/js/node_modules/@waves/ts-lib-crypto/bytes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bytes.js","sourceRoot":"","sources":["../src/bytes.ts"],"names":[],"mappings":";;;;;;AAAA,0CAAwC;AACxC,4DAAwD;AAA/C,0CAAA,aAAa,CAAA;AACtB,kDAA+C;AAAtC,6BAAA,OAAO,CAAA;AAChB,0CAAwC;AAA/B,sBAAA,IAAI,CAAA;AACb,sCAAyD;AAAhD,8BAAA,YAAY,CAAA;AAAE,6BAAA,WAAW,CAAA;AAClC,0CAAwC;AAA/B,0BAAA,MAAM,CAAA;AACf,wCAAkC;AAEhC,QAAA,SAAS,IADE,KAuCT,eAAM,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,iBArC7B,QAAA,OAAO,eACP,QAAA,YAAY,oBACZ,QAAA,SAAS,iBACT,QAAA,UAAU,kBACV,QAAA,OAAO,eACP,QAAA,OAAO,eACP,QAAA,MAAM,cACN,QAAA,MAAM,cACN,QAAA,SAAS,iBACT,QAAA,aAAa,qBACb,QAAA,YAAY,oBACZ,QAAA,YAAY,oBACZ,QAAA,YAAY,oBACZ,QAAA,YAAY,oBACZ,QAAA,YAAY,oBACZ,QAAA,YAAY,oBACZ,QAAA,aAAa,qBACb,QAAA,aAAa,qBACb,QAAA,MAAM,cACN,QAAA,UAAU,kBACV,QAAA,WAAW,mBACX,QAAA,eAAe,uBACf,QAAA,eAAe,uBACf,QAAA,aAAa,qBACb,QAAA,cAAc,sBACd,QAAA,cAAc,sBACd,QAAA,UAAU,kBACV,QAAA,UAAU,kBACV,QAAA,WAAW,mBACX,QAAA,WAAW,mBACX,QAAA,UAAU,kBACV,QAAA,cAAc,sBACd,QAAA,OAAO,eACP,QAAA,SAAS,iBACT,QAAA,YAAY,oBACZ,QAAA,KAAK,aACL,QAAA,MAAM,aACuB"}

data/js/node_modules/@waves/ts-lib-crypto/conversions/base-xx.d.ts

@@ -0,0 +1,7 @@
+import { TBinaryIn } from '../crypto/interface';
+export declare const base64Decode: (input: string) => Uint8Array;
+export declare const base64Encode: (input: TBinaryIn) => string;
+export declare const base58Decode: (input: string) => Uint8Array;
+export declare const base58Encode: (input: TBinaryIn) => string;
+export declare const base16Decode: (input: string) => Uint8Array;
+export declare const base16Encode: (input: TBinaryIn) => string;

data/js/node_modules/@waves/ts-lib-crypto/conversions/base-xx.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+//@ts-ignore
+var util_1 = require("node-forge/lib/util");
+var base58_1 = __importDefault(require("../libs/base58"));
+var param_1 = require("./param");
+var string_bytes_1 = require("./string-bytes");
+exports.base64Decode = function (input) {
+    return string_bytes_1.stringToBytes(util_1.decode64(input), 'raw');
+};
+exports.base64Encode = function (input) {
+    return util_1.encode64(string_bytes_1.bytesToString(param_1._fromIn(input), 'raw'));
+};
+exports.base58Decode = function (input) {
+    return base58_1.default.decode(input);
+};
+exports.base58Encode = function (input) {
+    return base58_1.default.encode(param_1._fromIn(input));
+};
+exports.base16Decode = function (input) {
+    return string_bytes_1.stringToBytes(util_1.hexToBytes(input), 'raw');
+};
+exports.base16Encode = function (input) { return util_1.bytesToHex(string_bytes_1.bytesToString(param_1._fromIn(input), 'raw')); };
+//# sourceMappingURL=base-xx.js.map

data/js/node_modules/@waves/ts-lib-crypto/conversions/base-xx.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-xx.js","sourceRoot":"","sources":["../../src/conversions/base-xx.ts"],"names":[],"mappings":";;;;;AAAA,YAAY;AACZ,4CAAgF;AAEhF,0DAAmC;AACnC,iCAAiC;AACjC,+CAA6D;AAEhD,QAAA,YAAY,GAAG,UAAC,KAAc;IACzC,OAAA,4BAAa,CAAC,eAAQ,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC;AAArC,CAAqC,CAAA;AAE1B,QAAA,YAAY,GAAG,UAAC,KAAgB;IAC3C,OAAA,eAAQ,CAAC,4BAAa,CAAC,eAAO,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,CAAC;AAA9C,CAA8C,CAAA;AAEnC,QAAA,YAAY,GAAG,UAAC,KAAc;IACzC,OAAA,gBAAM,CAAC,MAAM,CAAC,KAAK,CAAC;AAApB,CAAoB,CAAA;AAET,QAAA,YAAY,GAAG,UAAC,KAAgB;IAC3C,OAAA,gBAAM,CAAC,MAAM,CAAC,eAAO,CAAC,KAAK,CAAC,CAAC;AAA7B,CAA6B,CAAA;AAElB,QAAA,YAAY,GAAG,UAAC,KAAc;IACzC,OAAA,4BAAa,CAAC,iBAAU,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC;AAAvC,CAAuC,CAAA;AAE5B,QAAA,YAAY,GAAG,UAAC,KAAgB,IAAc,OAAA,iBAAU,CACnE,4BAAa,CAAC,eAAO,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,CACrC,EAF0D,CAE1D,CAAA"}

data/js/node_modules/@waves/ts-lib-crypto/conversions/param.d.ts

@@ -0,0 +1,3 @@
+import { TBinaryIn, TRawStringIn } from '../crypto/interface';
+export declare const _fromIn: (inValue: TBinaryIn) => Uint8Array;
+export declare const _fromRawIn: (inValue: TRawStringIn) => Uint8Array;

data/js/node_modules/@waves/ts-lib-crypto/conversions/param.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var base_xx_1 = require("./base-xx");
+var string_bytes_1 = require("./string-bytes");
+var isString = function (val) { return typeof val === 'string' || val instanceof String; };
+var isUint8Array = function (val) { return val instanceof Uint8Array; };
+var isTRawStringInDiscriminator = function (_) { return false; };
+exports._fromIn = function (inValue) {
+    if (isString(inValue))
+        return base_xx_1.base58Decode(inValue);
+    if (isUint8Array(inValue))
+        return inValue;
+    return Uint8Array.from(inValue);
+};
+exports._fromRawIn = function (inValue) {
+    if (isTRawStringInDiscriminator(inValue))
+        throw new Error('');
+    if (isString(inValue))
+        return string_bytes_1.stringToBytes(inValue);
+    if (isUint8Array(inValue))
+        return inValue;
+    return Uint8Array.from(inValue);
+};
+//# sourceMappingURL=param.js.map

data/js/node_modules/@waves/ts-lib-crypto/conversions/param.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"param.js","sourceRoot":"","sources":["../../src/conversions/param.ts"],"names":[],"mappings":";;AACA,qCAAwC;AACxC,+CAA8C;AAE9C,IAAM,QAAQ,GAAG,UAAC,GAAQ,IAAoB,OAAA,OAAO,GAAG,KAAK,QAAQ,IAAI,GAAG,YAAY,MAAM,EAAhD,CAAgD,CAAA;AAC9F,IAAM,YAAY,GAAG,UAAC,GAAQ,IAAwB,OAAA,GAAG,YAAY,UAAU,EAAzB,CAAyB,CAAA;AAE/E,IAAM,2BAA2B,GAAG,UAAC,CAAe,IAAqC,OAAA,KAAK,EAAL,CAAK,CAAA;AAEjF,QAAA,OAAO,GAAG,UAAC,OAAkB;IACxC,IAAI,QAAQ,CAAC,OAAO,CAAC;QACnB,OAAO,sBAAY,CAAC,OAAO,CAAC,CAAA;IAE9B,IAAI,YAAY,CAAC,OAAO,CAAC;QACvB,OAAO,OAAO,CAAA;IAEhB,OAAO,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;AACjC,CAAC,CAAA;AAEY,QAAA,UAAU,GAAG,UAAC,OAAqB;IAC9C,IAAI,2BAA2B,CAAC,OAAO,CAAC;QACtC,MAAM,IAAI,KAAK,CAAC,EAAE,CAAC,CAAA;IAErB,IAAI,QAAQ,CAAC,OAAO,CAAC;QACnB,OAAO,4BAAa,CAAC,OAAO,CAAC,CAAA;IAE/B,IAAI,YAAY,CAAC,OAAO,CAAC;QACvB,OAAO,OAAO,CAAA;IAEhB,OAAO,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;AACjC,CAAC,CAAA"}

data/js/node_modules/@waves/ts-lib-crypto/conversions/string-bytes.d.ts

@@ -0,0 +1,11 @@
+import { TBinaryIn } from '../crypto/interface';
+export declare const stringToBytes: (str: string, encoding?: "utf8" | "raw") => Uint8Array;
+export declare const bytesToString: (bytes: TBinaryIn, encoding?: "utf8" | "raw") => string;
+/**
+ * Converts each character to byte
+ */
+export declare const binaryStringToBytes: (str: string) => Uint8Array;
+/**
+ * Reads each byte as individual character
+ */
+export declare const bytesToBinaryString: (bytes: TBinaryIn) => string;