merge master

.gitignore

@@ -3,8 +3,11 @@ debug/
 release/
 x64/
 artifacts/
+docs/website/public
 .vscode/
+res/libsodium.a
 res/libsodium/libsodium*
+res/libsodium.a
 src/ui_*.h
 *.autosave
 src/precompiled.h.cpp
@@ -27,4 +30,4 @@ workspace.code-workspace
 .DS_Store
 *.mak
 *.plist
-zcashd
+zcashd

.travis.yml

@@ -11,15 +11,17 @@ matrix:
 before_install:
  - sudo add-apt-repository ppa:beineri/opt-qt591-trusty -y
  - sudo apt-get update -qq
- - sudo apt-get install qt59base
+ - sudo apt-get install qt59base qt59websockets 
  - source /opt/qt59/bin/qt59-env.sh
 
 script:
  - qmake -v
  - clang++ -v
  - g++-8 -v
- - qmake zec-qt-wallet.pro CONFIG+=release -spec linux-g++
- - make CC=gcc-8 CXX=g++-8 -j2
- - make distclean
  - qmake zec-qt-wallet.pro CONFIG+=release -spec linux-clang
  - make CC=clang CXX=clang++ -j2
+ - make distclean
+ - qmake zec-qt-wallet.pro CONFIG+=release -spec linux-g++
+ - res/libsodium/buildlibsodium.sh
+ - make CC=gcc-8 CXX=g++-8 -j2
+ 

README.md

@@ -10,14 +10,14 @@ Head over to the releases page and grab the latest installers or binary. https:/
 
 If you are on Debian/Ubuntu, please download the `.deb` package and install it.
 ```
-sudo dpkg -i linux-deb-zec-qt-wallet-v0.5.7.deb
+sudo dpkg -i linux-deb-zec-qt-wallet-v0.6.1.deb
 sudo apt install -f
 ```
 
 Or you can download and run the binaries directly.
 ```
-tar -xvf zec-qt-wallet-v0.5.7.tar.gz
-./zec-qt-wallet-v0.5.7/zec-qt-wallet
+tar -xvf zec-qt-wallet-v0.6.1.tar.gz
+./zec-qt-wallet-v0.6.1/zec-qt-wallet
 ```
 
 ### Windows

application.qrc

@@ -15,5 +15,6 @@
         <file>res/zec_qt_wallet_es.qm</file>
         <file>res/zec_qt_wallet_fr.qm</file>
         <file>res/zec_qt_wallet_pt.qm</file>
+        <file>res/zec_qt_wallet_it.qm</file>
     </qresource>
 </RCC>

public_key.asc

@@ -0,0 +1,52 @@
+-----BEGIN PGP PUBLIC KEY BLOCK-----
+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+=lY99
+-----END PGP PUBLIC KEY BLOCK-----

res/SIGNATURES_README

@@ -0,0 +1,13 @@
+This directory contains the hashes and signatures for zec-qt-wallet
+
+Verify the hashes by running:
+sha256sum -c sha256sum-vX.Y.Z.txt
+
+Verify signatures:
+1. First, import the public key (Available on github 
+   at https://github.com/ZcashFoundation/zec-qt-wallet/blob/master/public_key.asc)
+gpg --import public_key.asc
+
+2. Verify signature 
+gpg --verify <filename.sig> <downloaded-filename-to-verify>
+

res/libsodium/buildlibsodium.sh

@@ -0,0 +1,32 @@
+#!/bin/bash
+
+# First thing to do is see if libsodium.a exists in the res folder. If it does, then there's nothing to do
+if [ -f res/libsodium.a ]; then
+    exit 0
+fi
+
+echo "Building libsodium"
+
+# Go into the lib sodium directory
+cd res/libsodium
+if [ ! -f libsodium-1.0.16.tar.gz ]; then
+    wget https://download.libsodium.org/libsodium/releases/libsodium-1.0.16.tar.gz
+fi
+
+if [ ! -d libsodium-1.0.16 ]; then
+    tar xf libsodium-1.0.16.tar.gz
+fi
+
+# Now build it
+cd libsodium-1.0.16
+LIBS="" ./configure
+make clean
+if [[ "$OSTYPE" == "darwin"* ]]; then
+    make CFLAGS="-mmacosx-version-min=10.11" CPPFLAGS="-mmacosx-version-min=10.11" -j4
+else
+    make -j4
+fi
+cd ..
+
+# copy the library to the parents's res/ folder
+cp libsodium-1.0.16/src/libsodium/.libs/libsodium.a ../

src/3rdparty/sodium.h

@@ -0,0 +1,70 @@
+
+#ifndef sodium_H
+#define sodium_H
+
+#include "sodium/version.h"
+
+#include "sodium/core.h"
+#include "sodium/crypto_aead_aes256gcm.h"
+#include "sodium/crypto_aead_chacha20poly1305.h"
+#include "sodium/crypto_aead_xchacha20poly1305.h"
+#include "sodium/crypto_auth.h"
+#include "sodium/crypto_auth_hmacsha256.h"
+#include "sodium/crypto_auth_hmacsha512.h"
+#include "sodium/crypto_auth_hmacsha512256.h"
+#include "sodium/crypto_box.h"
+#include "sodium/crypto_box_curve25519xsalsa20poly1305.h"
+#include "sodium/crypto_core_hsalsa20.h"
+#include "sodium/crypto_core_hchacha20.h"
+#include "sodium/crypto_core_salsa20.h"
+#include "sodium/crypto_core_salsa2012.h"
+#include "sodium/crypto_core_salsa208.h"
+#include "sodium/crypto_generichash.h"
+#include "sodium/crypto_generichash_blake2b.h"
+#include "sodium/crypto_hash.h"
+#include "sodium/crypto_hash_sha256.h"
+#include "sodium/crypto_hash_sha512.h"
+#include "sodium/crypto_kdf.h"
+#include "sodium/crypto_kdf_blake2b.h"
+#include "sodium/crypto_kx.h"
+#include "sodium/crypto_onetimeauth.h"
+#include "sodium/crypto_onetimeauth_poly1305.h"
+#include "sodium/crypto_pwhash.h"
+#include "sodium/crypto_pwhash_argon2i.h"
+#include "sodium/crypto_scalarmult.h"
+#include "sodium/crypto_scalarmult_curve25519.h"
+#include "sodium/crypto_secretbox.h"
+#include "sodium/crypto_secretbox_xsalsa20poly1305.h"
+#include "sodium/crypto_secretstream_xchacha20poly1305.h"
+#include "sodium/crypto_shorthash.h"
+#include "sodium/crypto_shorthash_siphash24.h"
+#include "sodium/crypto_sign.h"
+#include "sodium/crypto_sign_ed25519.h"
+#include "sodium/crypto_stream.h"
+#include "sodium/crypto_stream_chacha20.h"
+#include "sodium/crypto_stream_salsa20.h"
+#include "sodium/crypto_stream_xsalsa20.h"
+#include "sodium/crypto_verify_16.h"
+#include "sodium/crypto_verify_32.h"
+#include "sodium/crypto_verify_64.h"
+#include "sodium/randombytes.h"
+#ifdef __native_client__
+# include "sodium/randombytes_nativeclient.h"
+#endif
+#include "sodium/randombytes_salsa20_random.h"
+#include "sodium/randombytes_sysrandom.h"
+#include "sodium/runtime.h"
+#include "sodium/utils.h"
+
+#ifndef SODIUM_LIBRARY_MINIMAL
+# include "sodium/crypto_box_curve25519xchacha20poly1305.h"
+# include "sodium/crypto_core_ed25519.h"
+# include "sodium/crypto_scalarmult_ed25519.h"
+# include "sodium/crypto_secretbox_xchacha20poly1305.h"
+# include "sodium/crypto_pwhash_scryptsalsa208sha256.h"
+# include "sodium/crypto_stream_salsa2012.h"
+# include "sodium/crypto_stream_salsa208.h"
+# include "sodium/crypto_stream_xchacha20.h"
+#endif
+
+#endif

src/3rdparty/sodium/core.h

@@ -0,0 +1,28 @@
+
+#ifndef sodium_core_H
+#define sodium_core_H
+
+#include "export.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+SODIUM_EXPORT
+int sodium_init(void)
+            __attribute__ ((warn_unused_result));
+
+/* ---- */
+
+SODIUM_EXPORT
+int sodium_set_misuse_handler(void (*handler)(void));
+
+SODIUM_EXPORT
+void sodium_misuse(void)
+            __attribute__ ((noreturn));
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/3rdparty/sodium/crypto_aead_aes256gcm.h

@@ -0,0 +1,171 @@
+#ifndef crypto_aead_aes256gcm_H
+#define crypto_aead_aes256gcm_H
+
+/*
+ * WARNING: Despite being the most popular AEAD construction due to its
+ * use in TLS, safely using AES-GCM in a different context is tricky.
+ *
+ * No more than ~ 350 GB of input data should be encrypted with a given key.
+ * This is for ~ 16 KB messages -- Actual figures vary according to
+ * message sizes.
+ *
+ * In addition, nonces are short and repeated nonces would totally destroy
+ * the security of this scheme.
+ *
+ * Nonces should thus come from atomic counters, which can be difficult to
+ * set up in a distributed environment.
+ *
+ * Unless you absolutely need AES-GCM, use crypto_aead_xchacha20poly1305_ietf_*()
+ * instead. It doesn't have any of these limitations.
+ * Or, if you don't need to authenticate additional data, just stick to
+ * crypto_secretbox().
+ */
+
+#include <stddef.h>
+#include "export.h"
+
+#ifdef __cplusplus
+# ifdef __GNUC__
+#  pragma GCC diagnostic ignored "-Wlong-long"
+# endif
+extern "C" {
+#endif
+
+SODIUM_EXPORT
+int crypto_aead_aes256gcm_is_available(void);
+
+#define crypto_aead_aes256gcm_KEYBYTES  32U
+SODIUM_EXPORT
+size_t crypto_aead_aes256gcm_keybytes(void);
+
+#define crypto_aead_aes256gcm_NSECBYTES 0U
+SODIUM_EXPORT
+size_t crypto_aead_aes256gcm_nsecbytes(void);
+
+#define crypto_aead_aes256gcm_NPUBBYTES 12U
+SODIUM_EXPORT
+size_t crypto_aead_aes256gcm_npubbytes(void);
+
+#define crypto_aead_aes256gcm_ABYTES    16U
+SODIUM_EXPORT
+size_t crypto_aead_aes256gcm_abytes(void);
+
+#define crypto_aead_aes256gcm_MESSAGEBYTES_MAX \
+    SODIUM_MIN(SODIUM_SIZE_MAX - crypto_aead_aes256gcm_ABYTES, \
+               (16ULL * ((1ULL << 32) - 2ULL)) - crypto_aead_aes256gcm_ABYTES)
+SODIUM_EXPORT
+size_t crypto_aead_aes256gcm_messagebytes_max(void);
+
+typedef CRYPTO_ALIGN(16) unsigned char crypto_aead_aes256gcm_state[512];
+
+SODIUM_EXPORT
+size_t crypto_aead_aes256gcm_statebytes(void);
+
+SODIUM_EXPORT
+int crypto_aead_aes256gcm_encrypt(unsigned char *c,
+                                  unsigned long long *clen_p,
+                                  const unsigned char *m,
+                                  unsigned long long mlen,
+                                  const unsigned char *ad,
+                                  unsigned long long adlen,
+                                  const unsigned char *nsec,
+                                  const unsigned char *npub,
+                                  const unsigned char *k);
+
+SODIUM_EXPORT
+int crypto_aead_aes256gcm_decrypt(unsigned char *m,
+                                  unsigned long long *mlen_p,
+                                  unsigned char *nsec,
+                                  const unsigned char *c,
+                                  unsigned long long clen,
+                                  const unsigned char *ad,
+                                  unsigned long long adlen,
+                                  const unsigned char *npub,
+                                  const unsigned char *k)
+            __attribute__ ((warn_unused_result));
+
+SODIUM_EXPORT
+int crypto_aead_aes256gcm_encrypt_detached(unsigned char *c,
+                                           unsigned char *mac,
+                                           unsigned long long *maclen_p,
+                                           const unsigned char *m,
+                                           unsigned long long mlen,
+                                           const unsigned char *ad,
+                                           unsigned long long adlen,
+                                           const unsigned char *nsec,
+                                           const unsigned char *npub,
+                                           const unsigned char *k);
+
+SODIUM_EXPORT
+int crypto_aead_aes256gcm_decrypt_detached(unsigned char *m,
+                                           unsigned char *nsec,
+                                           const unsigned char *c,
+                                           unsigned long long clen,
+                                           const unsigned char *mac,
+                                           const unsigned char *ad,
+                                           unsigned long long adlen,
+                                           const unsigned char *npub,
+                                           const unsigned char *k)
+        __attribute__ ((warn_unused_result));
+
+/* -- Precomputation interface -- */
+
+SODIUM_EXPORT
+int crypto_aead_aes256gcm_beforenm(crypto_aead_aes256gcm_state *ctx_,
+                                   const unsigned char *k);
+
+SODIUM_EXPORT
+int crypto_aead_aes256gcm_encrypt_afternm(unsigned char *c,
+                                          unsigned long long *clen_p,
+                                          const unsigned char *m,
+                                          unsigned long long mlen,
+                                          const unsigned char *ad,
+                                          unsigned long long adlen,
+                                          const unsigned char *nsec,
+                                          const unsigned char *npub,
+                                          const crypto_aead_aes256gcm_state *ctx_);
+
+SODIUM_EXPORT
+int crypto_aead_aes256gcm_decrypt_afternm(unsigned char *m,
+                                          unsigned long long *mlen_p,
+                                          unsigned char *nsec,
+                                          const unsigned char *c,
+                                          unsigned long long clen,
+                                          const unsigned char *ad,
+                                          unsigned long long adlen,
+                                          const unsigned char *npub,
+                                          const crypto_aead_aes256gcm_state *ctx_)
+            __attribute__ ((warn_unused_result));
+
+SODIUM_EXPORT
+int crypto_aead_aes256gcm_encrypt_detached_afternm(unsigned char *c,
+                                                   unsigned char *mac,
+                                                   unsigned long long *maclen_p,
+                                                   const unsigned char *m,
+                                                   unsigned long long mlen,
+                                                   const unsigned char *ad,
+                                                   unsigned long long adlen,
+                                                   const unsigned char *nsec,
+                                                   const unsigned char *npub,
+                                                   const crypto_aead_aes256gcm_state *ctx_);
+
+SODIUM_EXPORT
+int crypto_aead_aes256gcm_decrypt_detached_afternm(unsigned char *m,
+                                                   unsigned char *nsec,
+                                                   const unsigned char *c,
+                                                   unsigned long long clen,
+                                                   const unsigned char *mac,
+                                                   const unsigned char *ad,
+                                                   unsigned long long adlen,
+                                                   const unsigned char *npub,
+                                                   const crypto_aead_aes256gcm_state *ctx_)
+        __attribute__ ((warn_unused_result));
+
+SODIUM_EXPORT
+void crypto_aead_aes256gcm_keygen(unsigned char k[crypto_aead_aes256gcm_KEYBYTES]);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/3rdparty/sodium/crypto_aead_chacha20poly1305.h

@@ -0,0 +1,174 @@
+#ifndef crypto_aead_chacha20poly1305_H
+#define crypto_aead_chacha20poly1305_H
+
+#include <stddef.h>
+#include "export.h"
+
+#ifdef __cplusplus
+# ifdef __GNUC__
+#  pragma GCC diagnostic ignored "-Wlong-long"
+# endif
+extern "C" {
+#endif
+
+/* -- IETF ChaCha20-Poly1305 construction with a 96-bit nonce and a 32-bit internal counter -- */
+
+#define crypto_aead_chacha20poly1305_ietf_KEYBYTES 32U
+SODIUM_EXPORT
+size_t crypto_aead_chacha20poly1305_ietf_keybytes(void);
+
+#define crypto_aead_chacha20poly1305_ietf_NSECBYTES 0U
+SODIUM_EXPORT
+size_t crypto_aead_chacha20poly1305_ietf_nsecbytes(void);
+
+#define crypto_aead_chacha20poly1305_ietf_NPUBBYTES 12U
+
+SODIUM_EXPORT
+size_t crypto_aead_chacha20poly1305_ietf_npubbytes(void);
+
+#define crypto_aead_chacha20poly1305_ietf_ABYTES 16U
+SODIUM_EXPORT
+size_t crypto_aead_chacha20poly1305_ietf_abytes(void);
+
+#define crypto_aead_chacha20poly1305_ietf_MESSAGEBYTES_MAX \
+    SODIUM_MIN(SODIUM_SIZE_MAX - crypto_aead_chacha20poly1305_ietf_ABYTES, \
+               (64ULL * (1ULL << 32) - 64ULL) - crypto_aead_chacha20poly1305_ietf_ABYTES)
+SODIUM_EXPORT
+size_t crypto_aead_chacha20poly1305_ietf_messagebytes_max(void);
+
+SODIUM_EXPORT
+int crypto_aead_chacha20poly1305_ietf_encrypt(unsigned char *c,
+                                              unsigned long long *clen_p,
+                                              const unsigned char *m,
+                                              unsigned long long mlen,
+                                              const unsigned char *ad,
+                                              unsigned long long adlen,
+                                              const unsigned char *nsec,
+                                              const unsigned char *npub,
+                                              const unsigned char *k);
+
+SODIUM_EXPORT
+int crypto_aead_chacha20poly1305_ietf_decrypt(unsigned char *m,
+                                              unsigned long long *mlen_p,
+                                              unsigned char *nsec,
+                                              const unsigned char *c,
+                                              unsigned long long clen,
+                                              const unsigned char *ad,
+                                              unsigned long long adlen,
+                                              const unsigned char *npub,
+                                              const unsigned char *k)
+            __attribute__ ((warn_unused_result));
+
+SODIUM_EXPORT
+int crypto_aead_chacha20poly1305_ietf_encrypt_detached(unsigned char *c,
+                                                       unsigned char *mac,
+                                                       unsigned long long *maclen_p,
+                                                       const unsigned char *m,
+                                                       unsigned long long mlen,
+                                                       const unsigned char *ad,
+                                                       unsigned long long adlen,
+                                                       const unsigned char *nsec,
+                                                       const unsigned char *npub,
+                                                       const unsigned char *k);
+
+SODIUM_EXPORT
+int crypto_aead_chacha20poly1305_ietf_decrypt_detached(unsigned char *m,
+                                                       unsigned char *nsec,
+                                                       const unsigned char *c,
+                                                       unsigned long long clen,
+                                                       const unsigned char *mac,
+                                                       const unsigned char *ad,
+                                                       unsigned long long adlen,
+                                                       const unsigned char *npub,
+                                                       const unsigned char *k)
+        __attribute__ ((warn_unused_result));
+
+SODIUM_EXPORT
+void crypto_aead_chacha20poly1305_ietf_keygen(unsigned char k[crypto_aead_chacha20poly1305_ietf_KEYBYTES]);
+
+/* -- Original ChaCha20-Poly1305 construction with a 64-bit nonce and a 64-bit internal counter -- */
+
+#define crypto_aead_chacha20poly1305_KEYBYTES 32U
+SODIUM_EXPORT
+size_t crypto_aead_chacha20poly1305_keybytes(void);
+
+#define crypto_aead_chacha20poly1305_NSECBYTES 0U
+SODIUM_EXPORT
+size_t crypto_aead_chacha20poly1305_nsecbytes(void);
+
+#define crypto_aead_chacha20poly1305_NPUBBYTES 8U
+SODIUM_EXPORT
+size_t crypto_aead_chacha20poly1305_npubbytes(void);
+
+#define crypto_aead_chacha20poly1305_ABYTES 16U
+SODIUM_EXPORT
+size_t crypto_aead_chacha20poly1305_abytes(void);
+
+#define crypto_aead_chacha20poly1305_MESSAGEBYTES_MAX \
+    (SODIUM_SIZE_MAX - crypto_aead_chacha20poly1305_ABYTES)
+SODIUM_EXPORT
+size_t crypto_aead_chacha20poly1305_messagebytes_max(void);
+
+SODIUM_EXPORT
+int crypto_aead_chacha20poly1305_encrypt(unsigned char *c,
+                                         unsigned long long *clen_p,
+                                         const unsigned char *m,
+                                         unsigned long long mlen,
+                                         const unsigned char *ad,
+                                         unsigned long long adlen,
+                                         const unsigned char *nsec,
+                                         const unsigned char *npub,
+                                         const unsigned char *k);
+
+SODIUM_EXPORT
+int crypto_aead_chacha20poly1305_decrypt(unsigned char *m,
+                                         unsigned long long *mlen_p,
+                                         unsigned char *nsec,
+                                         const unsigned char *c,
+                                         unsigned long long clen,
+                                         const unsigned char *ad,
+                                         unsigned long long adlen,
+                                         const unsigned char *npub,
+                                         const unsigned char *k)
+            __attribute__ ((warn_unused_result));
+
+SODIUM_EXPORT
+int crypto_aead_chacha20poly1305_encrypt_detached(unsigned char *c,
+                                                  unsigned char *mac,
+                                                  unsigned long long *maclen_p,
+                                                  const unsigned char *m,
+                                                  unsigned long long mlen,
+                                                  const unsigned char *ad,
+                                                  unsigned long long adlen,
+                                                  const unsigned char *nsec,
+                                                  const unsigned char *npub,
+                                                  const unsigned char *k);
+
+SODIUM_EXPORT
+int crypto_aead_chacha20poly1305_decrypt_detached(unsigned char *m,
+                                                  unsigned char *nsec,
+                                                  const unsigned char *c,
+                                                  unsigned long long clen,
+                                                  const unsigned char *mac,
+                                                  const unsigned char *ad,
+                                                  unsigned long long adlen,
+                                                  const unsigned char *npub,
+                                                  const unsigned char *k)
+        __attribute__ ((warn_unused_result));
+
+SODIUM_EXPORT
+void crypto_aead_chacha20poly1305_keygen(unsigned char k[crypto_aead_chacha20poly1305_KEYBYTES]);
+
+/* Aliases */
+
+#define crypto_aead_chacha20poly1305_IETF_KEYBYTES         crypto_aead_chacha20poly1305_ietf_KEYBYTES
+#define crypto_aead_chacha20poly1305_IETF_NSECBYTES        crypto_aead_chacha20poly1305_ietf_NSECBYTES
+#define crypto_aead_chacha20poly1305_IETF_NPUBBYTES        crypto_aead_chacha20poly1305_ietf_NPUBBYTES
+#define crypto_aead_chacha20poly1305_IETF_ABYTES           crypto_aead_chacha20poly1305_ietf_ABYTES
+#define crypto_aead_chacha20poly1305_IETF_MESSAGEBYTES_MAX crypto_aead_chacha20poly1305_ietf_MESSAGEBYTES_MAX
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/3rdparty/sodium/crypto_aead_xchacha20poly1305.h

@@ -0,0 +1,97 @@
+#ifndef crypto_aead_xchacha20poly1305_H
+#define crypto_aead_xchacha20poly1305_H
+
+#include <stddef.h>
+#include "export.h"
+
+#ifdef __cplusplus
+# ifdef __GNUC__
+#  pragma GCC diagnostic ignored "-Wlong-long"
+# endif
+extern "C" {
+#endif
+
+#define crypto_aead_xchacha20poly1305_ietf_KEYBYTES 32U
+SODIUM_EXPORT
+size_t crypto_aead_xchacha20poly1305_ietf_keybytes(void);
+
+#define crypto_aead_xchacha20poly1305_ietf_NSECBYTES 0U
+SODIUM_EXPORT
+size_t crypto_aead_xchacha20poly1305_ietf_nsecbytes(void);
+
+#define crypto_aead_xchacha20poly1305_ietf_NPUBBYTES 24U
+SODIUM_EXPORT
+size_t crypto_aead_xchacha20poly1305_ietf_npubbytes(void);
+
+#define crypto_aead_xchacha20poly1305_ietf_ABYTES 16U
+SODIUM_EXPORT
+size_t crypto_aead_xchacha20poly1305_ietf_abytes(void);
+
+#define crypto_aead_xchacha20poly1305_ietf_MESSAGEBYTES_MAX \
+    (SODIUM_SIZE_MAX - crypto_aead_xchacha20poly1305_ietf_ABYTES)
+SODIUM_EXPORT
+size_t crypto_aead_xchacha20poly1305_ietf_messagebytes_max(void);
+
+SODIUM_EXPORT
+int crypto_aead_xchacha20poly1305_ietf_encrypt(unsigned char *c,
+                                               unsigned long long *clen_p,
+                                               const unsigned char *m,
+                                               unsigned long long mlen,
+                                               const unsigned char *ad,
+                                               unsigned long long adlen,
+                                               const unsigned char *nsec,
+                                               const unsigned char *npub,
+                                               const unsigned char *k);
+
+SODIUM_EXPORT
+int crypto_aead_xchacha20poly1305_ietf_decrypt(unsigned char *m,
+                                               unsigned long long *mlen_p,
+                                               unsigned char *nsec,
+                                               const unsigned char *c,
+                                               unsigned long long clen,
+                                               const unsigned char *ad,
+                                               unsigned long long adlen,
+                                               const unsigned char *npub,
+                                               const unsigned char *k)
+            __attribute__ ((warn_unused_result));
+
+SODIUM_EXPORT
+int crypto_aead_xchacha20poly1305_ietf_encrypt_detached(unsigned char *c,
+                                                        unsigned char *mac,
+                                                        unsigned long long *maclen_p,
+                                                        const unsigned char *m,
+                                                        unsigned long long mlen,
+                                                        const unsigned char *ad,
+                                                        unsigned long long adlen,
+                                                        const unsigned char *nsec,
+                                                        const unsigned char *npub,
+                                                        const unsigned char *k);
+
+SODIUM_EXPORT
+int crypto_aead_xchacha20poly1305_ietf_decrypt_detached(unsigned char *m,
+                                                        unsigned char *nsec,
+                                                        const unsigned char *c,
+                                                        unsigned long long clen,
+                                                        const unsigned char *mac,
+                                                        const unsigned char *ad,
+                                                        unsigned long long adlen,
+                                                        const unsigned char *npub,
+                                                        const unsigned char *k)
+        __attribute__ ((warn_unused_result));
+
+SODIUM_EXPORT
+void crypto_aead_xchacha20poly1305_ietf_keygen(unsigned char k[crypto_aead_xchacha20poly1305_ietf_KEYBYTES]);
+
+/* Aliases */
+
+#define crypto_aead_xchacha20poly1305_IETF_KEYBYTES         crypto_aead_xchacha20poly1305_ietf_KEYBYTES
+#define crypto_aead_xchacha20poly1305_IETF_NSECBYTES        crypto_aead_xchacha20poly1305_ietf_NSECBYTES
+#define crypto_aead_xchacha20poly1305_IETF_NPUBBYTES        crypto_aead_xchacha20poly1305_ietf_NPUBBYTES
+#define crypto_aead_xchacha20poly1305_IETF_ABYTES           crypto_aead_xchacha20poly1305_ietf_ABYTES
+#define crypto_aead_xchacha20poly1305_IETF_MESSAGEBYTES_MAX crypto_aead_xchacha20poly1305_ietf_MESSAGEBYTES_MAX
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/3rdparty/sodium/crypto_auth.h

@@ -0,0 +1,44 @@
+#ifndef crypto_auth_H
+#define crypto_auth_H
+
+#include <stddef.h>
+
+#include "crypto_auth_hmacsha512256.h"
+#include "export.h"
+
+#ifdef __cplusplus
+# ifdef __GNUC__
+#  pragma GCC diagnostic ignored "-Wlong-long"
+# endif
+extern "C" {
+#endif
+
+#define crypto_auth_BYTES crypto_auth_hmacsha512256_BYTES
+SODIUM_EXPORT
+size_t  crypto_auth_bytes(void);
+
+#define crypto_auth_KEYBYTES crypto_auth_hmacsha512256_KEYBYTES
+SODIUM_EXPORT
+size_t  crypto_auth_keybytes(void);
+
+#define crypto_auth_PRIMITIVE "hmacsha512256"
+SODIUM_EXPORT
+const char *crypto_auth_primitive(void);
+
+SODIUM_EXPORT
+int crypto_auth(unsigned char *out, const unsigned char *in,
+                unsigned long long inlen, const unsigned char *k);
+
+SODIUM_EXPORT
+int crypto_auth_verify(const unsigned char *h, const unsigned char *in,
+                       unsigned long long inlen, const unsigned char *k)
+            __attribute__ ((warn_unused_result));
+
+SODIUM_EXPORT
+void crypto_auth_keygen(unsigned char k[crypto_auth_KEYBYTES]);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/3rdparty/sodium/crypto_auth_hmacsha256.h

@@ -0,0 +1,68 @@
+#ifndef crypto_auth_hmacsha256_H
+#define crypto_auth_hmacsha256_H
+
+#include <stddef.h>
+#include "crypto_hash_sha256.h"
+#include "export.h"
+
+#ifdef __cplusplus
+# ifdef __GNUC__
+#  pragma GCC diagnostic ignored "-Wlong-long"
+# endif
+extern "C" {
+#endif
+
+#define crypto_auth_hmacsha256_BYTES 32U
+SODIUM_EXPORT
+size_t crypto_auth_hmacsha256_bytes(void);
+
+#define crypto_auth_hmacsha256_KEYBYTES 32U
+SODIUM_EXPORT
+size_t crypto_auth_hmacsha256_keybytes(void);
+
+SODIUM_EXPORT
+int crypto_auth_hmacsha256(unsigned char *out,
+                           const unsigned char *in,
+                           unsigned long long inlen,
+                           const unsigned char *k);
+
+SODIUM_EXPORT
+int crypto_auth_hmacsha256_verify(const unsigned char *h,
+                                  const unsigned char *in,
+                                  unsigned long long inlen,
+                                  const unsigned char *k)
+            __attribute__ ((warn_unused_result));
+
+/* ------------------------------------------------------------------------- */
+
+typedef struct crypto_auth_hmacsha256_state {
+    crypto_hash_sha256_state ictx;
+    crypto_hash_sha256_state octx;
+} crypto_auth_hmacsha256_state;
+
+SODIUM_EXPORT
+size_t crypto_auth_hmacsha256_statebytes(void);
+
+SODIUM_EXPORT
+int crypto_auth_hmacsha256_init(crypto_auth_hmacsha256_state *state,
+                                const unsigned char *key,
+                                size_t keylen);
+
+SODIUM_EXPORT
+int crypto_auth_hmacsha256_update(crypto_auth_hmacsha256_state *state,
+                                  const unsigned char *in,
+                                  unsigned long long inlen);
+
+SODIUM_EXPORT
+int crypto_auth_hmacsha256_final(crypto_auth_hmacsha256_state *state,
+                                 unsigned char *out);
+
+
+SODIUM_EXPORT
+void crypto_auth_hmacsha256_keygen(unsigned char k[crypto_auth_hmacsha256_KEYBYTES]);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/3rdparty/sodium/crypto_auth_hmacsha512.h

@@ -0,0 +1,67 @@
+#ifndef crypto_auth_hmacsha512_H
+#define crypto_auth_hmacsha512_H
+
+#include <stddef.h>
+#include "crypto_hash_sha512.h"
+#include "export.h"
+
+#ifdef __cplusplus
+# ifdef __GNUC__
+#  pragma GCC diagnostic ignored "-Wlong-long"
+# endif
+extern "C" {
+#endif
+
+#define crypto_auth_hmacsha512_BYTES 64U
+SODIUM_EXPORT
+size_t crypto_auth_hmacsha512_bytes(void);
+
+#define crypto_auth_hmacsha512_KEYBYTES 32U
+SODIUM_EXPORT
+size_t crypto_auth_hmacsha512_keybytes(void);
+
+SODIUM_EXPORT
+int crypto_auth_hmacsha512(unsigned char *out,
+                           const unsigned char *in,
+                           unsigned long long inlen,
+                           const unsigned char *k);
+
+SODIUM_EXPORT
+int crypto_auth_hmacsha512_verify(const unsigned char *h,
+                                  const unsigned char *in,
+                                  unsigned long long inlen,
+                                  const unsigned char *k)
+            __attribute__ ((warn_unused_result));
+
+/* ------------------------------------------------------------------------- */
+
+typedef struct crypto_auth_hmacsha512_state {
+    crypto_hash_sha512_state ictx;
+    crypto_hash_sha512_state octx;
+} crypto_auth_hmacsha512_state;
+
+SODIUM_EXPORT
+size_t crypto_auth_hmacsha512_statebytes(void);
+
+SODIUM_EXPORT
+int crypto_auth_hmacsha512_init(crypto_auth_hmacsha512_state *state,
+                                const unsigned char *key,
+                                size_t keylen);
+
+SODIUM_EXPORT
+int crypto_auth_hmacsha512_update(crypto_auth_hmacsha512_state *state,
+                                  const unsigned char *in,
+                                  unsigned long long inlen);
+
+SODIUM_EXPORT
+int crypto_auth_hmacsha512_final(crypto_auth_hmacsha512_state *state,
+                                 unsigned char *out);
+
+SODIUM_EXPORT
+void crypto_auth_hmacsha512_keygen(unsigned char k[crypto_auth_hmacsha512_KEYBYTES]);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/3rdparty/sodium/crypto_auth_hmacsha512256.h

@@ -0,0 +1,62 @@
+#ifndef crypto_auth_hmacsha512256_H
+#define crypto_auth_hmacsha512256_H
+
+#include <stddef.h>
+#include "crypto_auth_hmacsha512.h"
+#include "export.h"
+
+#ifdef __cplusplus
+# ifdef __GNUC__
+#  pragma GCC diagnostic ignored "-Wlong-long"
+# endif
+extern "C" {
+#endif
+
+#define crypto_auth_hmacsha512256_BYTES 32U
+SODIUM_EXPORT
+size_t crypto_auth_hmacsha512256_bytes(void);
+
+#define crypto_auth_hmacsha512256_KEYBYTES 32U
+SODIUM_EXPORT
+size_t crypto_auth_hmacsha512256_keybytes(void);
+
+SODIUM_EXPORT
+int crypto_auth_hmacsha512256(unsigned char *out, const unsigned char *in,
+                              unsigned long long inlen,const unsigned char *k);
+
+SODIUM_EXPORT
+int crypto_auth_hmacsha512256_verify(const unsigned char *h,
+                                     const unsigned char *in,
+                                     unsigned long long inlen,
+                                     const unsigned char *k)
+            __attribute__ ((warn_unused_result));
+
+/* ------------------------------------------------------------------------- */
+
+typedef crypto_auth_hmacsha512_state crypto_auth_hmacsha512256_state;
+
+SODIUM_EXPORT
+size_t crypto_auth_hmacsha512256_statebytes(void);
+
+SODIUM_EXPORT
+int crypto_auth_hmacsha512256_init(crypto_auth_hmacsha512256_state *state,
+                                   const unsigned char *key,
+                                   size_t keylen);
+
+SODIUM_EXPORT
+int crypto_auth_hmacsha512256_update(crypto_auth_hmacsha512256_state *state,
+                                     const unsigned char *in,
+                                     unsigned long long inlen);
+
+SODIUM_EXPORT
+int crypto_auth_hmacsha512256_final(crypto_auth_hmacsha512256_state *state,
+                                    unsigned char *out);
+
+SODIUM_EXPORT
+void crypto_auth_hmacsha512256_keygen(unsigned char k[crypto_auth_hmacsha512256_KEYBYTES]);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/3rdparty/sodium/crypto_box.h

@@ -0,0 +1,173 @@
+#ifndef crypto_box_H
+#define crypto_box_H
+
+/*
+ * THREAD SAFETY: crypto_box_keypair() is thread-safe,
+ * provided that sodium_init() was called before.
+ *
+ * Other functions are always thread-safe.
+ */
+
+#include <stddef.h>
+
+#include "crypto_box_curve25519xsalsa20poly1305.h"
+#include "export.h"
+
+#ifdef __cplusplus
+# ifdef __GNUC__
+#  pragma GCC diagnostic ignored "-Wlong-long"
+# endif
+extern "C" {
+#endif
+
+#define crypto_box_SEEDBYTES crypto_box_curve25519xsalsa20poly1305_SEEDBYTES
+SODIUM_EXPORT
+size_t  crypto_box_seedbytes(void);
+
+#define crypto_box_PUBLICKEYBYTES crypto_box_curve25519xsalsa20poly1305_PUBLICKEYBYTES
+SODIUM_EXPORT
+size_t  crypto_box_publickeybytes(void);
+
+#define crypto_box_SECRETKEYBYTES crypto_box_curve25519xsalsa20poly1305_SECRETKEYBYTES
+SODIUM_EXPORT
+size_t  crypto_box_secretkeybytes(void);
+
+#define crypto_box_NONCEBYTES crypto_box_curve25519xsalsa20poly1305_NONCEBYTES
+SODIUM_EXPORT
+size_t  crypto_box_noncebytes(void);
+
+#define crypto_box_MACBYTES crypto_box_curve25519xsalsa20poly1305_MACBYTES
+SODIUM_EXPORT
+size_t  crypto_box_macbytes(void);
+
+#define crypto_box_MESSAGEBYTES_MAX crypto_box_curve25519xsalsa20poly1305_MESSAGEBYTES_MAX
+SODIUM_EXPORT
+size_t  crypto_box_messagebytes_max(void);
+
+#define crypto_box_PRIMITIVE "curve25519xsalsa20poly1305"
+SODIUM_EXPORT
+const char *crypto_box_primitive(void);
+
+SODIUM_EXPORT
+int crypto_box_seed_keypair(unsigned char *pk, unsigned char *sk,
+                            const unsigned char *seed);
+
+SODIUM_EXPORT
+int crypto_box_keypair(unsigned char *pk, unsigned char *sk);
+
+SODIUM_EXPORT
+int crypto_box_easy(unsigned char *c, const unsigned char *m,
+                    unsigned long long mlen, const unsigned char *n,
+                    const unsigned char *pk, const unsigned char *sk)
+            __attribute__ ((warn_unused_result));
+
+SODIUM_EXPORT
+int crypto_box_open_easy(unsigned char *m, const unsigned char *c,
+                         unsigned long long clen, const unsigned char *n,
+                         const unsigned char *pk, const unsigned char *sk)
+            __attribute__ ((warn_unused_result));
+
+SODIUM_EXPORT
+int crypto_box_detached(unsigned char *c, unsigned char *mac,
+                        const unsigned char *m, unsigned long long mlen,
+                        const unsigned char *n, const unsigned char *pk,
+                        const unsigned char *sk)
+            __attribute__ ((warn_unused_result));
+
+SODIUM_EXPORT
+int crypto_box_open_detached(unsigned char *m, const unsigned char *c,
+                             const unsigned char *mac,
+                             unsigned long long clen,
+                             const unsigned char *n,
+                             const unsigned char *pk,
+                             const unsigned char *sk)
+            __attribute__ ((warn_unused_result));
+
+/* -- Precomputation interface -- */
+
+#define crypto_box_BEFORENMBYTES crypto_box_curve25519xsalsa20poly1305_BEFORENMBYTES
+SODIUM_EXPORT
+size_t  crypto_box_beforenmbytes(void);
+
+SODIUM_EXPORT
+int crypto_box_beforenm(unsigned char *k, const unsigned char *pk,
+                        const unsigned char *sk)
+            __attribute__ ((warn_unused_result));
+
+SODIUM_EXPORT
+int crypto_box_easy_afternm(unsigned char *c, const unsigned char *m,
+                            unsigned long long mlen, const unsigned char *n,
+                            const unsigned char *k);
+
+SODIUM_EXPORT
+int crypto_box_open_easy_afternm(unsigned char *m, const unsigned char *c,
+                                 unsigned long long clen, const unsigned char *n,
+                                 const unsigned char *k)
+            __attribute__ ((warn_unused_result));
+
+SODIUM_EXPORT
+int crypto_box_detached_afternm(unsigned char *c, unsigned char *mac,
+                                const unsigned char *m, unsigned long long mlen,
+                                const unsigned char *n, const unsigned char *k);
+
+SODIUM_EXPORT
+int crypto_box_open_detached_afternm(unsigned char *m, const unsigned char *c,
+                                     const unsigned char *mac,
+                                     unsigned long long clen, const unsigned char *n,
+                                     const unsigned char *k)
+            __attribute__ ((warn_unused_result));
+
+/* -- Ephemeral SK interface -- */
+
+#define crypto_box_SEALBYTES (crypto_box_PUBLICKEYBYTES + crypto_box_MACBYTES)
+SODIUM_EXPORT
+size_t crypto_box_sealbytes(void);
+
+SODIUM_EXPORT
+int crypto_box_seal(unsigned char *c, const unsigned char *m,
+                    unsigned long long mlen, const unsigned char *pk);
+
+SODIUM_EXPORT
+int crypto_box_seal_open(unsigned char *m, const unsigned char *c,
+                         unsigned long long clen,
+                         const unsigned char *pk, const unsigned char *sk)
+            __attribute__ ((warn_unused_result));
+
+/* -- NaCl compatibility interface ; Requires padding -- */
+
+#define crypto_box_ZEROBYTES crypto_box_curve25519xsalsa20poly1305_ZEROBYTES
+SODIUM_EXPORT
+size_t  crypto_box_zerobytes(void);
+
+#define crypto_box_BOXZEROBYTES crypto_box_curve25519xsalsa20poly1305_BOXZEROBYTES
+SODIUM_EXPORT
+size_t  crypto_box_boxzerobytes(void);
+
+SODIUM_EXPORT
+int crypto_box(unsigned char *c, const unsigned char *m,
+               unsigned long long mlen, const unsigned char *n,
+               const unsigned char *pk, const unsigned char *sk)
+            __attribute__ ((warn_unused_result));
+
+SODIUM_EXPORT
+int crypto_box_open(unsigned char *m, const unsigned char *c,
+                    unsigned long long clen, const unsigned char *n,
+                    const unsigned char *pk, const unsigned char *sk)
+            __attribute__ ((warn_unused_result));
+
+SODIUM_EXPORT
+int crypto_box_afternm(unsigned char *c, const unsigned char *m,
+                       unsigned long long mlen, const unsigned char *n,
+                       const unsigned char *k);
+
+SODIUM_EXPORT
+int crypto_box_open_afternm(unsigned char *m, const unsigned char *c,
+                            unsigned long long clen, const unsigned char *n,
+                            const unsigned char *k)
+            __attribute__ ((warn_unused_result));
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/3rdparty/sodium/crypto_box_curve25519xchacha20poly1305.h

@@ -0,0 +1,159 @@
+
+#ifndef crypto_box_curve25519xchacha20poly1305_H
+#define crypto_box_curve25519xchacha20poly1305_H
+
+#include <stddef.h>
+#include "crypto_stream_xchacha20.h"
+#include "export.h"
+
+#ifdef __cplusplus
+# ifdef __GNUC__
+#  pragma GCC diagnostic ignored "-Wlong-long"
+# endif
+extern "C" {
+#endif
+
+#define crypto_box_curve25519xchacha20poly1305_SEEDBYTES 32U
+SODIUM_EXPORT
+size_t crypto_box_curve25519xchacha20poly1305_seedbytes(void);
+
+#define crypto_box_curve25519xchacha20poly1305_PUBLICKEYBYTES 32U
+SODIUM_EXPORT
+size_t crypto_box_curve25519xchacha20poly1305_publickeybytes(void);
+
+#define crypto_box_curve25519xchacha20poly1305_SECRETKEYBYTES 32U
+SODIUM_EXPORT
+size_t crypto_box_curve25519xchacha20poly1305_secretkeybytes(void);
+
+#define crypto_box_curve25519xchacha20poly1305_BEFORENMBYTES 32U
+SODIUM_EXPORT
+size_t crypto_box_curve25519xchacha20poly1305_beforenmbytes(void);
+
+#define crypto_box_curve25519xchacha20poly1305_NONCEBYTES 24U
+SODIUM_EXPORT
+size_t crypto_box_curve25519xchacha20poly1305_noncebytes(void);
+
+#define crypto_box_curve25519xchacha20poly1305_MACBYTES 16U
+SODIUM_EXPORT
+size_t crypto_box_curve25519xchacha20poly1305_macbytes(void);
+
+#define crypto_box_curve25519xchacha20poly1305_MESSAGEBYTES_MAX \
+    (crypto_stream_xchacha20_MESSAGEBYTES_MAX - crypto_box_curve25519xchacha20poly1305_MACBYTES)
+SODIUM_EXPORT
+size_t crypto_box_curve25519xchacha20poly1305_messagebytes_max(void);
+
+SODIUM_EXPORT
+int crypto_box_curve25519xchacha20poly1305_seed_keypair(unsigned char *pk,
+                                                        unsigned char *sk,
+                                                        const unsigned char *seed);
+
+SODIUM_EXPORT
+int crypto_box_curve25519xchacha20poly1305_keypair(unsigned char *pk,
+                                                   unsigned char *sk);
+
+SODIUM_EXPORT
+int crypto_box_curve25519xchacha20poly1305_easy(unsigned char *c,
+                                                const unsigned char *m,
+                                                unsigned long long mlen,
+                                                const unsigned char *n,
+                                                const unsigned char *pk,
+                                                const unsigned char *sk)
+            __attribute__ ((warn_unused_result));
+
+SODIUM_EXPORT
+int crypto_box_curve25519xchacha20poly1305_open_easy(unsigned char *m,
+                                                     const unsigned char *c,
+                                                     unsigned long long clen,
+                                                     const unsigned char *n,
+                                                     const unsigned char *pk,
+                                                     const unsigned char *sk)
+            __attribute__ ((warn_unused_result));
+
+SODIUM_EXPORT
+int crypto_box_curve25519xchacha20poly1305_detached(unsigned char *c,
+                                                    unsigned char *mac,
+                                                    const unsigned char *m,
+                                                    unsigned long long mlen,
+                                                    const unsigned char *n,
+                                                    const unsigned char *pk,
+                                                    const unsigned char *sk)
+            __attribute__ ((warn_unused_result));
+
+SODIUM_EXPORT
+int crypto_box_curve25519xchacha20poly1305_open_detached(unsigned char *m,
+                                                         const unsigned char *c,
+                                                         const unsigned char *mac,
+                                                         unsigned long long clen,
+                                                         const unsigned char *n,
+                                                         const unsigned char *pk,
+                                                         const unsigned char *sk)
+            __attribute__ ((warn_unused_result));
+
+/* -- Precomputation interface -- */
+
+SODIUM_EXPORT
+int crypto_box_curve25519xchacha20poly1305_beforenm(unsigned char *k,
+                                                    const unsigned char *pk,
+                                                    const unsigned char *sk)
+            __attribute__ ((warn_unused_result));
+
+SODIUM_EXPORT
+int crypto_box_curve25519xchacha20poly1305_easy_afternm(unsigned char *c,
+                                                        const unsigned char *m,
+                                                        unsigned long long mlen,
+                                                        const unsigned char *n,
+                                                        const unsigned char *k);
+
+SODIUM_EXPORT
+int crypto_box_curve25519xchacha20poly1305_open_easy_afternm(unsigned char *m,
+                                                             const unsigned char *c,
+                                                             unsigned long long clen,
+                                                             const unsigned char *n,
+                                                             const unsigned char *k)
+            __attribute__ ((warn_unused_result));
+
+SODIUM_EXPORT
+int crypto_box_curve25519xchacha20poly1305_detached_afternm(unsigned char *c,
+                                                            unsigned char *mac,
+                                                            const unsigned char *m,
+                                                            unsigned long long mlen,
+                                                            const unsigned char *n,
+                                                            const unsigned char *k);
+
+SODIUM_EXPORT
+int crypto_box_curve25519xchacha20poly1305_open_detached_afternm(unsigned char *m,
+                                                                 const unsigned char *c,
+                                                                 const unsigned char *mac,
+                                                                 unsigned long long clen,
+                                                                 const unsigned char *n,
+                                                                 const unsigned char *k)
+            __attribute__ ((warn_unused_result));
+
+/* -- Ephemeral SK interface -- */
+
+#define crypto_box_curve25519xchacha20poly1305_SEALBYTES \
+    (crypto_box_curve25519xchacha20poly1305_PUBLICKEYBYTES + \
+     crypto_box_curve25519xchacha20poly1305_MACBYTES)
+
+SODIUM_EXPORT
+size_t crypto_box_curve25519xchacha20poly1305_sealbytes(void);
+
+SODIUM_EXPORT
+int crypto_box_curve25519xchacha20poly1305_seal(unsigned char *c,
+                                                const unsigned char *m,
+                                                unsigned long long mlen,
+                                                const unsigned char *pk);
+
+SODIUM_EXPORT
+int crypto_box_curve25519xchacha20poly1305_seal_open(unsigned char *m,
+                                                     const unsigned char *c,
+                                                     unsigned long long clen,
+                                                     const unsigned char *pk,
+                                                     const unsigned char *sk)
+            __attribute__ ((warn_unused_result));
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/3rdparty/sodium/crypto_box_curve25519xsalsa20poly1305.h

@@ -0,0 +1,109 @@
+#ifndef crypto_box_curve25519xsalsa20poly1305_H
+#define crypto_box_curve25519xsalsa20poly1305_H
+
+#include <stddef.h>
+#include "crypto_stream_xsalsa20.h"
+#include "export.h"
+
+#ifdef __cplusplus
+# ifdef __GNUC__
+#  pragma GCC diagnostic ignored "-Wlong-long"
+# endif
+extern "C" {
+#endif
+
+#define crypto_box_curve25519xsalsa20poly1305_SEEDBYTES 32U
+SODIUM_EXPORT
+size_t crypto_box_curve25519xsalsa20poly1305_seedbytes(void);
+
+#define crypto_box_curve25519xsalsa20poly1305_PUBLICKEYBYTES 32U
+SODIUM_EXPORT
+size_t crypto_box_curve25519xsalsa20poly1305_publickeybytes(void);
+
+#define crypto_box_curve25519xsalsa20poly1305_SECRETKEYBYTES 32U
+SODIUM_EXPORT
+size_t crypto_box_curve25519xsalsa20poly1305_secretkeybytes(void);
+
+#define crypto_box_curve25519xsalsa20poly1305_BEFORENMBYTES 32U
+SODIUM_EXPORT
+size_t crypto_box_curve25519xsalsa20poly1305_beforenmbytes(void);
+
+#define crypto_box_curve25519xsalsa20poly1305_NONCEBYTES 24U
+SODIUM_EXPORT
+size_t crypto_box_curve25519xsalsa20poly1305_noncebytes(void);
+
+#define crypto_box_curve25519xsalsa20poly1305_MACBYTES 16U
+SODIUM_EXPORT
+size_t crypto_box_curve25519xsalsa20poly1305_macbytes(void);
+
+/* Only for the libsodium API - The NaCl compatibility API would require BOXZEROBYTES extra bytes */
+#define crypto_box_curve25519xsalsa20poly1305_MESSAGEBYTES_MAX \
+    (crypto_stream_xsalsa20_MESSAGEBYTES_MAX - crypto_box_curve25519xsalsa20poly1305_MACBYTES)
+SODIUM_EXPORT
+size_t crypto_box_curve25519xsalsa20poly1305_messagebytes_max(void);
+
+SODIUM_EXPORT
+int crypto_box_curve25519xsalsa20poly1305_seed_keypair(unsigned char *pk,
+                                                       unsigned char *sk,
+                                                       const unsigned char *seed);
+
+SODIUM_EXPORT
+int crypto_box_curve25519xsalsa20poly1305_keypair(unsigned char *pk,
+                                                  unsigned char *sk);
+
+SODIUM_EXPORT
+int crypto_box_curve25519xsalsa20poly1305_beforenm(unsigned char *k,
+                                                   const unsigned char *pk,
+                                                   const unsigned char *sk)
+            __attribute__ ((warn_unused_result));
+
+/* -- NaCl compatibility interface ; Requires padding -- */
+
+#define crypto_box_curve25519xsalsa20poly1305_BOXZEROBYTES 16U
+SODIUM_EXPORT
+size_t crypto_box_curve25519xsalsa20poly1305_boxzerobytes(void);
+
+#define crypto_box_curve25519xsalsa20poly1305_ZEROBYTES \
+    (crypto_box_curve25519xsalsa20poly1305_BOXZEROBYTES + \
+     crypto_box_curve25519xsalsa20poly1305_MACBYTES)
+SODIUM_EXPORT
+size_t crypto_box_curve25519xsalsa20poly1305_zerobytes(void);
+
+SODIUM_EXPORT
+int crypto_box_curve25519xsalsa20poly1305(unsigned char *c,
+                                          const unsigned char *m,
+                                          unsigned long long mlen,
+                                          const unsigned char *n,
+                                          const unsigned char *pk,
+                                          const unsigned char *sk)
+            __attribute__ ((warn_unused_result));
+
+SODIUM_EXPORT
+int crypto_box_curve25519xsalsa20poly1305_open(unsigned char *m,
+                                               const unsigned char *c,
+                                               unsigned long long clen,
+                                               const unsigned char *n,
+                                               const unsigned char *pk,
+                                               const unsigned char *sk)
+            __attribute__ ((warn_unused_result));
+
+SODIUM_EXPORT
+int crypto_box_curve25519xsalsa20poly1305_afternm(unsigned char *c,
+                                                  const unsigned char *m,
+                                                  unsigned long long mlen,
+                                                  const unsigned char *n,
+                                                  const unsigned char *k);
+
+SODIUM_EXPORT
+int crypto_box_curve25519xsalsa20poly1305_open_afternm(unsigned char *m,
+                                                       const unsigned char *c,
+                                                       unsigned long long clen,
+                                                       const unsigned char *n,
+                                                       const unsigned char *k)
+            __attribute__ ((warn_unused_result));
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/3rdparty/sodium/crypto_core_ed25519.h

@@ -0,0 +1,37 @@
+#ifndef crypto_core_ed25519_H
+#define crypto_core_ed25519_H
+
+#include <stddef.h>
+#include "export.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define crypto_core_ed25519_BYTES 32
+SODIUM_EXPORT
+size_t crypto_core_ed25519_bytes(void);
+
+#define crypto_core_ed25519_UNIFORMBYTES 32
+SODIUM_EXPORT
+size_t crypto_core_ed25519_uniformbytes(void);
+
+SODIUM_EXPORT
+int crypto_core_ed25519_is_valid_point(const unsigned char *p);
+
+SODIUM_EXPORT
+int crypto_core_ed25519_add(unsigned char *r,
+                            const unsigned char *p, const unsigned char *q);
+
+SODIUM_EXPORT
+int crypto_core_ed25519_sub(unsigned char *r,
+                            const unsigned char *p, const unsigned char *q);
+
+SODIUM_EXPORT
+int crypto_core_ed25519_from_uniform(unsigned char *p, const unsigned char *r);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/3rdparty/sodium/crypto_core_hchacha20.h

@@ -0,0 +1,35 @@
+#ifndef crypto_core_hchacha20_H
+#define crypto_core_hchacha20_H
+
+#include <stddef.h>
+#include "export.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define crypto_core_hchacha20_OUTPUTBYTES 32U
+SODIUM_EXPORT
+size_t crypto_core_hchacha20_outputbytes(void);
+
+#define crypto_core_hchacha20_INPUTBYTES 16U
+SODIUM_EXPORT
+size_t crypto_core_hchacha20_inputbytes(void);
+
+#define crypto_core_hchacha20_KEYBYTES 32U
+SODIUM_EXPORT
+size_t crypto_core_hchacha20_keybytes(void);
+
+#define crypto_core_hchacha20_CONSTBYTES 16U
+SODIUM_EXPORT
+size_t crypto_core_hchacha20_constbytes(void);
+
+SODIUM_EXPORT
+int crypto_core_hchacha20(unsigned char *out, const unsigned char *in,
+                          const unsigned char *k, const unsigned char *c);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/3rdparty/sodium/crypto_core_hsalsa20.h

@@ -0,0 +1,35 @@
+#ifndef crypto_core_hsalsa20_H
+#define crypto_core_hsalsa20_H
+
+#include <stddef.h>
+#include "export.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define crypto_core_hsalsa20_OUTPUTBYTES 32U
+SODIUM_EXPORT
+size_t crypto_core_hsalsa20_outputbytes(void);
+
+#define crypto_core_hsalsa20_INPUTBYTES 16U
+SODIUM_EXPORT
+size_t crypto_core_hsalsa20_inputbytes(void);
+
+#define crypto_core_hsalsa20_KEYBYTES 32U
+SODIUM_EXPORT
+size_t crypto_core_hsalsa20_keybytes(void);
+
+#define crypto_core_hsalsa20_CONSTBYTES 16U
+SODIUM_EXPORT
+size_t crypto_core_hsalsa20_constbytes(void);
+
+SODIUM_EXPORT
+int crypto_core_hsalsa20(unsigned char *out, const unsigned char *in,
+                         const unsigned char *k, const unsigned char *c);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/3rdparty/sodium/crypto_core_salsa20.h

@@ -0,0 +1,35 @@
+#ifndef crypto_core_salsa20_H
+#define crypto_core_salsa20_H
+
+#include <stddef.h>
+#include "export.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define crypto_core_salsa20_OUTPUTBYTES 64U
+SODIUM_EXPORT
+size_t crypto_core_salsa20_outputbytes(void);
+
+#define crypto_core_salsa20_INPUTBYTES 16U
+SODIUM_EXPORT
+size_t crypto_core_salsa20_inputbytes(void);
+
+#define crypto_core_salsa20_KEYBYTES 32U
+SODIUM_EXPORT
+size_t crypto_core_salsa20_keybytes(void);
+
+#define crypto_core_salsa20_CONSTBYTES 16U
+SODIUM_EXPORT
+size_t crypto_core_salsa20_constbytes(void);
+
+SODIUM_EXPORT
+int crypto_core_salsa20(unsigned char *out, const unsigned char *in,
+                        const unsigned char *k, const unsigned char *c);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/3rdparty/sodium/crypto_core_salsa2012.h

@@ -0,0 +1,35 @@
+#ifndef crypto_core_salsa2012_H
+#define crypto_core_salsa2012_H
+
+#include <stddef.h>
+#include "export.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define crypto_core_salsa2012_OUTPUTBYTES 64U
+SODIUM_EXPORT
+size_t crypto_core_salsa2012_outputbytes(void);
+
+#define crypto_core_salsa2012_INPUTBYTES 16U
+SODIUM_EXPORT
+size_t crypto_core_salsa2012_inputbytes(void);
+
+#define crypto_core_salsa2012_KEYBYTES 32U
+SODIUM_EXPORT
+size_t crypto_core_salsa2012_keybytes(void);
+
+#define crypto_core_salsa2012_CONSTBYTES 16U
+SODIUM_EXPORT
+size_t crypto_core_salsa2012_constbytes(void);
+
+SODIUM_EXPORT
+int crypto_core_salsa2012(unsigned char *out, const unsigned char *in,
+                          const unsigned char *k, const unsigned char *c);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/3rdparty/sodium/crypto_core_salsa208.h

@@ -0,0 +1,39 @@
+#ifndef crypto_core_salsa208_H
+#define crypto_core_salsa208_H
+
+#include <stddef.h>
+#include "export.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define crypto_core_salsa208_OUTPUTBYTES 64U
+SODIUM_EXPORT
+size_t crypto_core_salsa208_outputbytes(void)
+            __attribute__ ((deprecated));
+
+#define crypto_core_salsa208_INPUTBYTES 16U
+SODIUM_EXPORT
+size_t crypto_core_salsa208_inputbytes(void)
+            __attribute__ ((deprecated));
+
+#define crypto_core_salsa208_KEYBYTES 32U
+SODIUM_EXPORT
+size_t crypto_core_salsa208_keybytes(void)
+            __attribute__ ((deprecated));
+
+#define crypto_core_salsa208_CONSTBYTES 16U
+SODIUM_EXPORT
+size_t crypto_core_salsa208_constbytes(void)
+            __attribute__ ((deprecated));
+
+SODIUM_EXPORT
+int crypto_core_salsa208(unsigned char *out, const unsigned char *in,
+                         const unsigned char *k, const unsigned char *c);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/3rdparty/sodium/crypto_generichash.h

@@ -0,0 +1,75 @@
+#ifndef crypto_generichash_H
+#define crypto_generichash_H
+
+#include <stddef.h>
+
+#include "crypto_generichash_blake2b.h"
+#include "export.h"
+
+#ifdef __cplusplus
+# ifdef __GNUC__
+#  pragma GCC diagnostic ignored "-Wlong-long"
+# endif
+extern "C" {
+#endif
+
+#define crypto_generichash_BYTES_MIN crypto_generichash_blake2b_BYTES_MIN
+SODIUM_EXPORT
+size_t  crypto_generichash_bytes_min(void);
+
+#define crypto_generichash_BYTES_MAX crypto_generichash_blake2b_BYTES_MAX
+SODIUM_EXPORT
+size_t  crypto_generichash_bytes_max(void);
+
+#define crypto_generichash_BYTES crypto_generichash_blake2b_BYTES
+SODIUM_EXPORT
+size_t  crypto_generichash_bytes(void);
+
+#define crypto_generichash_KEYBYTES_MIN crypto_generichash_blake2b_KEYBYTES_MIN
+SODIUM_EXPORT
+size_t  crypto_generichash_keybytes_min(void);
+
+#define crypto_generichash_KEYBYTES_MAX crypto_generichash_blake2b_KEYBYTES_MAX
+SODIUM_EXPORT
+size_t  crypto_generichash_keybytes_max(void);
+
+#define crypto_generichash_KEYBYTES crypto_generichash_blake2b_KEYBYTES
+SODIUM_EXPORT
+size_t  crypto_generichash_keybytes(void);
+
+#define crypto_generichash_PRIMITIVE "blake2b"
+SODIUM_EXPORT
+const char *crypto_generichash_primitive(void);
+
+typedef crypto_generichash_blake2b_state crypto_generichash_state;
+
+SODIUM_EXPORT
+size_t  crypto_generichash_statebytes(void);
+
+SODIUM_EXPORT
+int crypto_generichash(unsigned char *out, size_t outlen,
+                       const unsigned char *in, unsigned long long inlen,
+                       const unsigned char *key, size_t keylen);
+
+SODIUM_EXPORT
+int crypto_generichash_init(crypto_generichash_state *state,
+                            const unsigned char *key,
+                            const size_t keylen, const size_t outlen);
+
+SODIUM_EXPORT
+int crypto_generichash_update(crypto_generichash_state *state,
+                              const unsigned char *in,
+                              unsigned long long inlen);
+
+SODIUM_EXPORT
+int crypto_generichash_final(crypto_generichash_state *state,
+                             unsigned char *out, const size_t outlen);
+
+SODIUM_EXPORT
+void crypto_generichash_keygen(unsigned char k[crypto_generichash_KEYBYTES]);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/3rdparty/sodium/crypto_generichash_blake2b.h

@@ -0,0 +1,117 @@
+#ifndef crypto_generichash_blake2b_H
+#define crypto_generichash_blake2b_H
+
+#include <stddef.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+#include "export.h"
+
+#ifdef __cplusplus
+# ifdef __GNUC__
+#  pragma GCC diagnostic ignored "-Wlong-long"
+# endif
+extern "C" {
+#endif
+
+#if defined(__IBMC__) || defined(__SUNPRO_C) || defined(__SUNPRO_CC)
+# pragma pack(1)
+#else
+# pragma pack(push, 1)
+#endif
+
+typedef struct CRYPTO_ALIGN(64) crypto_generichash_blake2b_state {
+    uint64_t h[8];
+    uint64_t t[2];
+    uint64_t f[2];
+    uint8_t  buf[2 * 128];
+    size_t   buflen;
+    uint8_t  last_node;
+} crypto_generichash_blake2b_state;
+
+#if defined(__IBMC__) || defined(__SUNPRO_C) || defined(__SUNPRO_CC)
+# pragma pack()
+#else
+# pragma pack(pop)
+#endif
+
+#define crypto_generichash_blake2b_BYTES_MIN     16U
+SODIUM_EXPORT
+size_t crypto_generichash_blake2b_bytes_min(void);
+
+#define crypto_generichash_blake2b_BYTES_MAX     64U
+SODIUM_EXPORT
+size_t crypto_generichash_blake2b_bytes_max(void);
+
+#define crypto_generichash_blake2b_BYTES         32U
+SODIUM_EXPORT
+size_t crypto_generichash_blake2b_bytes(void);
+
+#define crypto_generichash_blake2b_KEYBYTES_MIN  16U
+SODIUM_EXPORT
+size_t crypto_generichash_blake2b_keybytes_min(void);
+
+#define crypto_generichash_blake2b_KEYBYTES_MAX  64U
+SODIUM_EXPORT
+size_t crypto_generichash_blake2b_keybytes_max(void);
+
+#define crypto_generichash_blake2b_KEYBYTES      32U
+SODIUM_EXPORT
+size_t crypto_generichash_blake2b_keybytes(void);
+
+#define crypto_generichash_blake2b_SALTBYTES     16U
+SODIUM_EXPORT
+size_t crypto_generichash_blake2b_saltbytes(void);
+
+#define crypto_generichash_blake2b_PERSONALBYTES 16U
+SODIUM_EXPORT
+size_t crypto_generichash_blake2b_personalbytes(void);
+
+SODIUM_EXPORT
+size_t crypto_generichash_blake2b_statebytes(void);
+
+SODIUM_EXPORT
+int crypto_generichash_blake2b(unsigned char *out, size_t outlen,
+                               const unsigned char *in,
+                               unsigned long long inlen,
+                               const unsigned char *key, size_t keylen);
+
+SODIUM_EXPORT
+int crypto_generichash_blake2b_salt_personal(unsigned char *out, size_t outlen,
+                                             const unsigned char *in,
+                                             unsigned long long inlen,
+                                             const unsigned char *key,
+                                             size_t keylen,
+                                             const unsigned char *salt,
+                                             const unsigned char *personal);
+
+SODIUM_EXPORT
+int crypto_generichash_blake2b_init(crypto_generichash_blake2b_state *state,
+                                    const unsigned char *key,
+                                    const size_t keylen, const size_t outlen);
+
+SODIUM_EXPORT
+int crypto_generichash_blake2b_init_salt_personal(crypto_generichash_blake2b_state *state,
+                                                  const unsigned char *key,
+                                                  const size_t keylen, const size_t outlen,
+                                                  const unsigned char *salt,
+                                                  const unsigned char *personal);
+
+SODIUM_EXPORT
+int crypto_generichash_blake2b_update(crypto_generichash_blake2b_state *state,
+                                      const unsigned char *in,
+                                      unsigned long long inlen);
+
+SODIUM_EXPORT
+int crypto_generichash_blake2b_final(crypto_generichash_blake2b_state *state,
+                                     unsigned char *out,
+                                     const size_t outlen);
+
+SODIUM_EXPORT
+void crypto_generichash_blake2b_keygen(unsigned char k[crypto_generichash_blake2b_KEYBYTES]);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/3rdparty/sodium/crypto_hash.h

@@ -0,0 +1,40 @@
+#ifndef crypto_hash_H
+#define crypto_hash_H
+
+/*
+ * WARNING: Unless you absolutely need to use SHA512 for interoperatibility,
+ * purposes, you might want to consider crypto_generichash() instead.
+ * Unlike SHA512, crypto_generichash() is not vulnerable to length
+ * extension attacks.
+ */
+
+#include <stddef.h>
+
+#include "crypto_hash_sha512.h"
+#include "export.h"
+
+#ifdef __cplusplus
+# ifdef __GNUC__
+#  pragma GCC diagnostic ignored "-Wlong-long"
+# endif
+extern "C" {
+#endif
+
+#define crypto_hash_BYTES crypto_hash_sha512_BYTES
+SODIUM_EXPORT
+size_t crypto_hash_bytes(void);
+
+SODIUM_EXPORT
+int crypto_hash(unsigned char *out, const unsigned char *in,
+                unsigned long long inlen);
+
+#define crypto_hash_PRIMITIVE "sha512"
+SODIUM_EXPORT
+const char *crypto_hash_primitive(void)
+            __attribute__ ((warn_unused_result));
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/3rdparty/sodium/crypto_hash_sha256.h

@@ -0,0 +1,57 @@
+#ifndef crypto_hash_sha256_H
+#define crypto_hash_sha256_H
+
+/*
+ * WARNING: Unless you absolutely need to use SHA256 for interoperatibility,
+ * purposes, you might want to consider crypto_generichash() instead.
+ * Unlike SHA256, crypto_generichash() is not vulnerable to length
+ * extension attacks.
+ */
+
+#include <stddef.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+#include "export.h"
+
+#ifdef __cplusplus
+# ifdef __GNUC__
+#  pragma GCC diagnostic ignored "-Wlong-long"
+# endif
+extern "C" {
+#endif
+
+typedef struct crypto_hash_sha256_state {
+    uint32_t state[8];
+    uint64_t count;
+    uint8_t  buf[64];
+} crypto_hash_sha256_state;
+
+SODIUM_EXPORT
+size_t crypto_hash_sha256_statebytes(void);
+
+#define crypto_hash_sha256_BYTES 32U
+SODIUM_EXPORT
+size_t crypto_hash_sha256_bytes(void);
+
+SODIUM_EXPORT
+int crypto_hash_sha256(unsigned char *out, const unsigned char *in,
+                       unsigned long long inlen);
+
+SODIUM_EXPORT
+int crypto_hash_sha256_init(crypto_hash_sha256_state *state);
+
+SODIUM_EXPORT
+int crypto_hash_sha256_update(crypto_hash_sha256_state *state,
+                              const unsigned char *in,
+                              unsigned long long inlen);
+
+SODIUM_EXPORT
+int crypto_hash_sha256_final(crypto_hash_sha256_state *state,
+                             unsigned char *out);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/3rdparty/sodium/crypto_hash_sha512.h

@@ -0,0 +1,57 @@
+#ifndef crypto_hash_sha512_H
+#define crypto_hash_sha512_H
+
+/*
+ * WARNING: Unless you absolutely need to use SHA512 for interoperatibility,
+ * purposes, you might want to consider crypto_generichash() instead.
+ * Unlike SHA512, crypto_generichash() is not vulnerable to length
+ * extension attacks.
+ */
+
+#include <stddef.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+#include "export.h"
+
+#ifdef __cplusplus
+# ifdef __GNUC__
+#  pragma GCC diagnostic ignored "-Wlong-long"
+# endif
+extern "C" {
+#endif
+
+typedef struct crypto_hash_sha512_state {
+    uint64_t state[8];
+    uint64_t count[2];
+    uint8_t  buf[128];
+} crypto_hash_sha512_state;
+
+SODIUM_EXPORT
+size_t crypto_hash_sha512_statebytes(void);
+
+#define crypto_hash_sha512_BYTES 64U
+SODIUM_EXPORT
+size_t crypto_hash_sha512_bytes(void);
+
+SODIUM_EXPORT
+int crypto_hash_sha512(unsigned char *out, const unsigned char *in,
+                       unsigned long long inlen);
+
+SODIUM_EXPORT
+int crypto_hash_sha512_init(crypto_hash_sha512_state *state);
+
+SODIUM_EXPORT
+int crypto_hash_sha512_update(crypto_hash_sha512_state *state,
+                              const unsigned char *in,
+                              unsigned long long inlen);
+
+SODIUM_EXPORT
+int crypto_hash_sha512_final(crypto_hash_sha512_state *state,
+                             unsigned char *out);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/3rdparty/sodium/crypto_kdf.h

@@ -0,0 +1,51 @@
+#ifndef crypto_kdf_H
+#define crypto_kdf_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include "crypto_kdf_blake2b.h"
+#include "export.h"
+
+#ifdef __cplusplus
+# ifdef __GNUC__
+#  pragma GCC diagnostic ignored "-Wlong-long"
+# endif
+extern "C" {
+#endif
+
+#define crypto_kdf_BYTES_MIN crypto_kdf_blake2b_BYTES_MIN
+SODIUM_EXPORT
+size_t crypto_kdf_bytes_min(void);
+
+#define crypto_kdf_BYTES_MAX crypto_kdf_blake2b_BYTES_MAX
+SODIUM_EXPORT
+size_t crypto_kdf_bytes_max(void);
+
+#define crypto_kdf_CONTEXTBYTES crypto_kdf_blake2b_CONTEXTBYTES
+SODIUM_EXPORT
+size_t crypto_kdf_contextbytes(void);
+
+#define crypto_kdf_KEYBYTES crypto_kdf_blake2b_KEYBYTES
+SODIUM_EXPORT
+size_t crypto_kdf_keybytes(void);
+
+#define crypto_kdf_PRIMITIVE "blake2b"
+SODIUM_EXPORT
+const char *crypto_kdf_primitive(void)
+            __attribute__ ((warn_unused_result));
+
+SODIUM_EXPORT
+int crypto_kdf_derive_from_key(unsigned char *subkey, size_t subkey_len,
+                               uint64_t subkey_id,
+                               const char ctx[crypto_kdf_CONTEXTBYTES],
+                               const unsigned char key[crypto_kdf_KEYBYTES]);
+
+SODIUM_EXPORT
+void crypto_kdf_keygen(unsigned char k[crypto_kdf_KEYBYTES]);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/3rdparty/sodium/crypto_kdf_blake2b.h

@@ -0,0 +1,42 @@
+#ifndef crypto_kdf_blake2b_H
+#define crypto_kdf_blake2b_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include "crypto_kdf_blake2b.h"
+#include "export.h"
+
+#ifdef __cplusplus
+# ifdef __GNUC__
+#  pragma GCC diagnostic ignored "-Wlong-long"
+# endif
+extern "C" {
+#endif
+
+#define crypto_kdf_blake2b_BYTES_MIN 16
+SODIUM_EXPORT
+size_t crypto_kdf_blake2b_bytes_min(void);
+
+#define crypto_kdf_blake2b_BYTES_MAX 64
+SODIUM_EXPORT
+size_t crypto_kdf_blake2b_bytes_max(void);
+
+#define crypto_kdf_blake2b_CONTEXTBYTES 8
+SODIUM_EXPORT
+size_t crypto_kdf_blake2b_contextbytes(void);
+
+#define crypto_kdf_blake2b_KEYBYTES 32
+SODIUM_EXPORT
+size_t crypto_kdf_blake2b_keybytes(void);
+
+SODIUM_EXPORT
+int crypto_kdf_blake2b_derive_from_key(unsigned char *subkey, size_t subkey_len,
+                                       uint64_t subkey_id,
+                                       const char ctx[crypto_kdf_blake2b_CONTEXTBYTES],
+                                       const unsigned char key[crypto_kdf_blake2b_KEYBYTES]);
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/3rdparty/sodium/crypto_kx.h

@@ -0,0 +1,64 @@
+#ifndef crypto_kx_H
+#define crypto_kx_H
+
+#include <stddef.h>
+
+#include "export.h"
+
+#ifdef __cplusplus
+# ifdef __GNUC__
+#  pragma GCC diagnostic ignored "-Wlong-long"
+# endif
+extern "C" {
+#endif
+
+#define crypto_kx_PUBLICKEYBYTES 32
+SODIUM_EXPORT
+size_t crypto_kx_publickeybytes(void);
+
+#define crypto_kx_SECRETKEYBYTES 32
+SODIUM_EXPORT
+size_t crypto_kx_secretkeybytes(void);
+
+#define crypto_kx_SEEDBYTES 32
+SODIUM_EXPORT
+size_t crypto_kx_seedbytes(void);
+
+#define crypto_kx_SESSIONKEYBYTES 32
+SODIUM_EXPORT
+size_t crypto_kx_sessionkeybytes(void);
+
+#define crypto_kx_PRIMITIVE "x25519blake2b"
+SODIUM_EXPORT
+const char *crypto_kx_primitive(void);
+
+SODIUM_EXPORT
+int crypto_kx_seed_keypair(unsigned char pk[crypto_kx_PUBLICKEYBYTES],
+                           unsigned char sk[crypto_kx_SECRETKEYBYTES],
+                           const unsigned char seed[crypto_kx_SEEDBYTES]);
+
+SODIUM_EXPORT
+int crypto_kx_keypair(unsigned char pk[crypto_kx_PUBLICKEYBYTES],
+                      unsigned char sk[crypto_kx_SECRETKEYBYTES]);
+
+SODIUM_EXPORT
+int crypto_kx_client_session_keys(unsigned char rx[crypto_kx_SESSIONKEYBYTES],
+                                  unsigned char tx[crypto_kx_SESSIONKEYBYTES],
+                                  const unsigned char client_pk[crypto_kx_PUBLICKEYBYTES],
+                                  const unsigned char client_sk[crypto_kx_SECRETKEYBYTES],
+                                  const unsigned char server_pk[crypto_kx_PUBLICKEYBYTES])
+            __attribute__ ((warn_unused_result));
+
+SODIUM_EXPORT
+int crypto_kx_server_session_keys(unsigned char rx[crypto_kx_SESSIONKEYBYTES],
+                                  unsigned char tx[crypto_kx_SESSIONKEYBYTES],
+                                  const unsigned char server_pk[crypto_kx_PUBLICKEYBYTES],
+                                  const unsigned char server_sk[crypto_kx_SECRETKEYBYTES],
+                                  const unsigned char client_pk[crypto_kx_PUBLICKEYBYTES])
+            __attribute__ ((warn_unused_result));
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/3rdparty/sodium/crypto_onetimeauth.h

@@ -0,0 +1,62 @@
+#ifndef crypto_onetimeauth_H
+#define crypto_onetimeauth_H
+
+#include <stddef.h>
+
+#include "crypto_onetimeauth_poly1305.h"
+#include "export.h"
+
+#ifdef __cplusplus
+# ifdef __GNUC__
+#  pragma GCC diagnostic ignored "-Wlong-long"
+# endif
+extern "C" {
+#endif
+
+typedef crypto_onetimeauth_poly1305_state crypto_onetimeauth_state;
+
+SODIUM_EXPORT
+size_t  crypto_onetimeauth_statebytes(void);
+
+#define crypto_onetimeauth_BYTES crypto_onetimeauth_poly1305_BYTES
+SODIUM_EXPORT
+size_t  crypto_onetimeauth_bytes(void);
+
+#define crypto_onetimeauth_KEYBYTES crypto_onetimeauth_poly1305_KEYBYTES
+SODIUM_EXPORT
+size_t  crypto_onetimeauth_keybytes(void);
+
+#define crypto_onetimeauth_PRIMITIVE "poly1305"
+SODIUM_EXPORT
+const char *crypto_onetimeauth_primitive(void);
+
+SODIUM_EXPORT
+int crypto_onetimeauth(unsigned char *out, const unsigned char *in,
+                       unsigned long long inlen, const unsigned char *k);
+
+SODIUM_EXPORT
+int crypto_onetimeauth_verify(const unsigned char *h, const unsigned char *in,
+                              unsigned long long inlen, const unsigned char *k)
+            __attribute__ ((warn_unused_result));
+
+SODIUM_EXPORT
+int crypto_onetimeauth_init(crypto_onetimeauth_state *state,
+                            const unsigned char *key);
+
+SODIUM_EXPORT
+int crypto_onetimeauth_update(crypto_onetimeauth_state *state,
+                              const unsigned char *in,
+                              unsigned long long inlen);
+
+SODIUM_EXPORT
+int crypto_onetimeauth_final(crypto_onetimeauth_state *state,
+                             unsigned char *out);
+
+SODIUM_EXPORT
+void crypto_onetimeauth_keygen(unsigned char k[crypto_onetimeauth_KEYBYTES]);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/3rdparty/sodium/crypto_onetimeauth_poly1305.h

@@ -0,0 +1,67 @@
+#ifndef crypto_onetimeauth_poly1305_H
+#define crypto_onetimeauth_poly1305_H
+
+#ifdef __cplusplus
+# ifdef __GNUC__
+#  pragma GCC diagnostic ignored "-Wlong-long"
+# endif
+extern "C" {
+#endif
+
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <sys/types.h>
+
+#include "export.h"
+
+typedef struct CRYPTO_ALIGN(16) crypto_onetimeauth_poly1305_state {
+    unsigned char opaque[256];
+} crypto_onetimeauth_poly1305_state;
+
+SODIUM_EXPORT
+size_t crypto_onetimeauth_poly1305_statebytes(void);
+
+#define crypto_onetimeauth_poly1305_BYTES 16U
+SODIUM_EXPORT
+size_t crypto_onetimeauth_poly1305_bytes(void);
+
+#define crypto_onetimeauth_poly1305_KEYBYTES 32U
+SODIUM_EXPORT
+size_t crypto_onetimeauth_poly1305_keybytes(void);
+
+SODIUM_EXPORT
+int crypto_onetimeauth_poly1305(unsigned char *out,
+                                const unsigned char *in,
+                                unsigned long long inlen,
+                                const unsigned char *k);
+
+SODIUM_EXPORT
+int crypto_onetimeauth_poly1305_verify(const unsigned char *h,
+                                       const unsigned char *in,
+                                       unsigned long long inlen,
+                                       const unsigned char *k)
+            __attribute__ ((warn_unused_result));
+
+SODIUM_EXPORT
+int crypto_onetimeauth_poly1305_init(crypto_onetimeauth_poly1305_state *state,
+                                     const unsigned char *key);
+
+SODIUM_EXPORT
+int crypto_onetimeauth_poly1305_update(crypto_onetimeauth_poly1305_state *state,
+                                       const unsigned char *in,
+                                       unsigned long long inlen);
+
+SODIUM_EXPORT
+int crypto_onetimeauth_poly1305_final(crypto_onetimeauth_poly1305_state *state,
+                                      unsigned char *out);
+
+SODIUM_EXPORT
+void crypto_onetimeauth_poly1305_keygen(unsigned char k[crypto_onetimeauth_poly1305_KEYBYTES]);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/3rdparty/sodium/crypto_pwhash.h

@@ -0,0 +1,147 @@
+#ifndef crypto_pwhash_H
+#define crypto_pwhash_H
+
+#include <stddef.h>
+
+#include "crypto_pwhash_argon2i.h"
+#include "crypto_pwhash_argon2id.h"
+#include "export.h"
+
+#ifdef __cplusplus
+# ifdef __GNUC__
+#  pragma GCC diagnostic ignored "-Wlong-long"
+# endif
+extern "C" {
+#endif
+
+#define crypto_pwhash_ALG_ARGON2I13 crypto_pwhash_argon2i_ALG_ARGON2I13
+SODIUM_EXPORT
+int crypto_pwhash_alg_argon2i13(void);
+
+#define crypto_pwhash_ALG_ARGON2ID13 crypto_pwhash_argon2id_ALG_ARGON2ID13
+SODIUM_EXPORT
+int crypto_pwhash_alg_argon2id13(void);
+
+#define crypto_pwhash_ALG_DEFAULT crypto_pwhash_ALG_ARGON2ID13
+SODIUM_EXPORT
+int crypto_pwhash_alg_default(void);
+
+#define crypto_pwhash_BYTES_MIN crypto_pwhash_argon2id_BYTES_MIN
+SODIUM_EXPORT
+size_t crypto_pwhash_bytes_min(void);
+
+#define crypto_pwhash_BYTES_MAX crypto_pwhash_argon2id_BYTES_MAX
+SODIUM_EXPORT
+size_t crypto_pwhash_bytes_max(void);
+
+#define crypto_pwhash_PASSWD_MIN crypto_pwhash_argon2id_PASSWD_MIN
+SODIUM_EXPORT
+size_t crypto_pwhash_passwd_min(void);
+
+#define crypto_pwhash_PASSWD_MAX crypto_pwhash_argon2id_PASSWD_MAX
+SODIUM_EXPORT
+size_t crypto_pwhash_passwd_max(void);
+
+#define crypto_pwhash_SALTBYTES crypto_pwhash_argon2id_SALTBYTES
+SODIUM_EXPORT
+size_t crypto_pwhash_saltbytes(void);
+
+#define crypto_pwhash_STRBYTES crypto_pwhash_argon2id_STRBYTES
+SODIUM_EXPORT
+size_t crypto_pwhash_strbytes(void);
+
+#define crypto_pwhash_STRPREFIX crypto_pwhash_argon2id_STRPREFIX
+SODIUM_EXPORT
+const char *crypto_pwhash_strprefix(void);
+
+#define crypto_pwhash_OPSLIMIT_MIN crypto_pwhash_argon2id_OPSLIMIT_MIN
+SODIUM_EXPORT
+size_t crypto_pwhash_opslimit_min(void);
+
+#define crypto_pwhash_OPSLIMIT_MAX crypto_pwhash_argon2id_OPSLIMIT_MAX
+SODIUM_EXPORT
+size_t crypto_pwhash_opslimit_max(void);
+
+#define crypto_pwhash_MEMLIMIT_MIN crypto_pwhash_argon2id_MEMLIMIT_MIN
+SODIUM_EXPORT
+size_t crypto_pwhash_memlimit_min(void);
+
+#define crypto_pwhash_MEMLIMIT_MAX crypto_pwhash_argon2id_MEMLIMIT_MAX
+SODIUM_EXPORT
+size_t crypto_pwhash_memlimit_max(void);
+
+#define crypto_pwhash_OPSLIMIT_INTERACTIVE crypto_pwhash_argon2id_OPSLIMIT_INTERACTIVE
+SODIUM_EXPORT
+size_t crypto_pwhash_opslimit_interactive(void);
+
+#define crypto_pwhash_MEMLIMIT_INTERACTIVE crypto_pwhash_argon2id_MEMLIMIT_INTERACTIVE
+SODIUM_EXPORT
+size_t crypto_pwhash_memlimit_interactive(void);
+
+#define crypto_pwhash_OPSLIMIT_MODERATE crypto_pwhash_argon2id_OPSLIMIT_MODERATE
+SODIUM_EXPORT
+size_t crypto_pwhash_opslimit_moderate(void);
+
+#define crypto_pwhash_MEMLIMIT_MODERATE crypto_pwhash_argon2id_MEMLIMIT_MODERATE
+SODIUM_EXPORT
+size_t crypto_pwhash_memlimit_moderate(void);
+
+#define crypto_pwhash_OPSLIMIT_SENSITIVE crypto_pwhash_argon2id_OPSLIMIT_SENSITIVE
+SODIUM_EXPORT
+size_t crypto_pwhash_opslimit_sensitive(void);
+
+#define crypto_pwhash_MEMLIMIT_SENSITIVE crypto_pwhash_argon2id_MEMLIMIT_SENSITIVE
+SODIUM_EXPORT
+size_t crypto_pwhash_memlimit_sensitive(void);
+
+/*
+ * With this function, do not forget to store all parameters, including the
+ * algorithm identifier in order to produce deterministic output.
+ * The crypto_pwhash_* definitions, including crypto_pwhash_ALG_DEFAULT,
+ * may change.
+ */
+SODIUM_EXPORT
+int crypto_pwhash(unsigned char * const out, unsigned long long outlen,
+                  const char * const passwd, unsigned long long passwdlen,
+                  const unsigned char * const salt,
+                  unsigned long long opslimit, size_t memlimit, int alg)
+            __attribute__ ((warn_unused_result));
+
+/*
+ * The output string already includes all the required parameters, including
+ * the algorithm identifier. The string is all that has to be stored in
+ * order to verify a password.
+ */
+SODIUM_EXPORT
+int crypto_pwhash_str(char out[crypto_pwhash_STRBYTES],
+                      const char * const passwd, unsigned long long passwdlen,
+                      unsigned long long opslimit, size_t memlimit)
+            __attribute__ ((warn_unused_result));
+
+SODIUM_EXPORT
+int crypto_pwhash_str_alg(char out[crypto_pwhash_STRBYTES],
+                          const char * const passwd, unsigned long long passwdlen,
+                          unsigned long long opslimit, size_t memlimit, int alg)
+            __attribute__ ((warn_unused_result));
+
+SODIUM_EXPORT
+int crypto_pwhash_str_verify(const char str[crypto_pwhash_STRBYTES],
+                             const char * const passwd,
+                             unsigned long long passwdlen)
+            __attribute__ ((warn_unused_result));
+
+SODIUM_EXPORT
+int crypto_pwhash_str_needs_rehash(const char str[crypto_pwhash_STRBYTES],
+                                   unsigned long long opslimit, size_t memlimit)
+            __attribute__ ((warn_unused_result));
+
+#define crypto_pwhash_PRIMITIVE "argon2i"
+SODIUM_EXPORT
+const char *crypto_pwhash_primitive(void)
+            __attribute__ ((warn_unused_result));
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/3rdparty/sodium/crypto_pwhash_argon2i.h

@@ -0,0 +1,122 @@
+#ifndef crypto_pwhash_argon2i_H
+#define crypto_pwhash_argon2i_H
+
+#include <limits.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#include "export.h"
+
+#ifdef __cplusplus
+# ifdef __GNUC__
+#  pragma GCC diagnostic ignored "-Wlong-long"
+# endif
+extern "C" {
+#endif
+
+#define crypto_pwhash_argon2i_ALG_ARGON2I13 1
+SODIUM_EXPORT
+int crypto_pwhash_argon2i_alg_argon2i13(void);
+
+#define crypto_pwhash_argon2i_BYTES_MIN 16U
+SODIUM_EXPORT
+size_t crypto_pwhash_argon2i_bytes_min(void);
+
+#define crypto_pwhash_argon2i_BYTES_MAX SODIUM_MIN(SODIUM_SIZE_MAX, 4294967295U)
+SODIUM_EXPORT
+size_t crypto_pwhash_argon2i_bytes_max(void);
+
+#define crypto_pwhash_argon2i_PASSWD_MIN 0U
+SODIUM_EXPORT
+size_t crypto_pwhash_argon2i_passwd_min(void);
+
+#define crypto_pwhash_argon2i_PASSWD_MAX 4294967295U
+SODIUM_EXPORT
+size_t crypto_pwhash_argon2i_passwd_max(void);
+
+#define crypto_pwhash_argon2i_SALTBYTES 16U
+SODIUM_EXPORT
+size_t crypto_pwhash_argon2i_saltbytes(void);
+
+#define crypto_pwhash_argon2i_STRBYTES 128U
+SODIUM_EXPORT
+size_t crypto_pwhash_argon2i_strbytes(void);
+
+#define crypto_pwhash_argon2i_STRPREFIX "$argon2i$"
+SODIUM_EXPORT
+const char *crypto_pwhash_argon2i_strprefix(void);
+
+#define crypto_pwhash_argon2i_OPSLIMIT_MIN 3U
+SODIUM_EXPORT
+size_t crypto_pwhash_argon2i_opslimit_min(void);
+
+#define crypto_pwhash_argon2i_OPSLIMIT_MAX 4294967295U
+SODIUM_EXPORT
+size_t crypto_pwhash_argon2i_opslimit_max(void);
+
+#define crypto_pwhash_argon2i_MEMLIMIT_MIN 8192U
+SODIUM_EXPORT
+size_t crypto_pwhash_argon2i_memlimit_min(void);
+
+#define crypto_pwhash_argon2i_MEMLIMIT_MAX \
+    ((SIZE_MAX >= 4398046510080U) ? 4398046510080U : (SIZE_MAX >= 2147483648U) ? 2147483648U : 32768U)
+SODIUM_EXPORT
+size_t crypto_pwhash_argon2i_memlimit_max(void);
+
+#define crypto_pwhash_argon2i_OPSLIMIT_INTERACTIVE 4U
+SODIUM_EXPORT
+size_t crypto_pwhash_argon2i_opslimit_interactive(void);
+
+#define crypto_pwhash_argon2i_MEMLIMIT_INTERACTIVE 33554432U
+SODIUM_EXPORT
+size_t crypto_pwhash_argon2i_memlimit_interactive(void);
+
+#define crypto_pwhash_argon2i_OPSLIMIT_MODERATE 6U
+SODIUM_EXPORT
+size_t crypto_pwhash_argon2i_opslimit_moderate(void);
+
+#define crypto_pwhash_argon2i_MEMLIMIT_MODERATE 134217728U
+SODIUM_EXPORT
+size_t crypto_pwhash_argon2i_memlimit_moderate(void);
+
+#define crypto_pwhash_argon2i_OPSLIMIT_SENSITIVE 8U
+SODIUM_EXPORT
+size_t crypto_pwhash_argon2i_opslimit_sensitive(void);
+
+#define crypto_pwhash_argon2i_MEMLIMIT_SENSITIVE 536870912U
+SODIUM_EXPORT
+size_t crypto_pwhash_argon2i_memlimit_sensitive(void);
+
+SODIUM_EXPORT
+int crypto_pwhash_argon2i(unsigned char * const out,
+                          unsigned long long outlen,
+                          const char * const passwd,
+                          unsigned long long passwdlen,
+                          const unsigned char * const salt,
+                          unsigned long long opslimit, size_t memlimit,
+                          int alg)
+            __attribute__ ((warn_unused_result));
+
+SODIUM_EXPORT
+int crypto_pwhash_argon2i_str(char out[crypto_pwhash_argon2i_STRBYTES],
+                              const char * const passwd,
+                              unsigned long long passwdlen,
+                              unsigned long long opslimit, size_t memlimit)
+            __attribute__ ((warn_unused_result));
+
+SODIUM_EXPORT
+int crypto_pwhash_argon2i_str_verify(const char str[crypto_pwhash_argon2i_STRBYTES],
+                                     const char * const passwd,
+                                     unsigned long long passwdlen)
+            __attribute__ ((warn_unused_result));
+
+SODIUM_EXPORT
+int crypto_pwhash_argon2i_str_needs_rehash(const char str[crypto_pwhash_argon2i_STRBYTES],
+                                           unsigned long long opslimit, size_t memlimit)
+            __attribute__ ((warn_unused_result));
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/3rdparty/sodium/crypto_pwhash_argon2id.h

@@ -0,0 +1,122 @@
+#ifndef crypto_pwhash_argon2id_H
+#define crypto_pwhash_argon2id_H
+
+#include <limits.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#include "export.h"
+
+#ifdef __cplusplus
+# ifdef __GNUC__
+#  pragma GCC diagnostic ignored "-Wlong-long"
+# endif
+extern "C" {
+#endif
+
+#define crypto_pwhash_argon2id_ALG_ARGON2ID13 2
+SODIUM_EXPORT
+int crypto_pwhash_argon2id_alg_argon2id13(void);
+
+#define crypto_pwhash_argon2id_BYTES_MIN 16U
+SODIUM_EXPORT
+size_t crypto_pwhash_argon2id_bytes_min(void);
+
+#define crypto_pwhash_argon2id_BYTES_MAX SODIUM_MIN(SODIUM_SIZE_MAX, 4294967295U)
+SODIUM_EXPORT
+size_t crypto_pwhash_argon2id_bytes_max(void);
+
+#define crypto_pwhash_argon2id_PASSWD_MIN 0U
+SODIUM_EXPORT
+size_t crypto_pwhash_argon2id_passwd_min(void);
+
+#define crypto_pwhash_argon2id_PASSWD_MAX 4294967295U
+SODIUM_EXPORT
+size_t crypto_pwhash_argon2id_passwd_max(void);
+
+#define crypto_pwhash_argon2id_SALTBYTES 16U
+SODIUM_EXPORT
+size_t crypto_pwhash_argon2id_saltbytes(void);
+
+#define crypto_pwhash_argon2id_STRBYTES 128U
+SODIUM_EXPORT
+size_t crypto_pwhash_argon2id_strbytes(void);
+
+#define crypto_pwhash_argon2id_STRPREFIX "$argon2id$"
+SODIUM_EXPORT
+const char *crypto_pwhash_argon2id_strprefix(void);
+
+#define crypto_pwhash_argon2id_OPSLIMIT_MIN 1U
+SODIUM_EXPORT
+size_t crypto_pwhash_argon2id_opslimit_min(void);
+
+#define crypto_pwhash_argon2id_OPSLIMIT_MAX 4294967295U
+SODIUM_EXPORT
+size_t crypto_pwhash_argon2id_opslimit_max(void);
+
+#define crypto_pwhash_argon2id_MEMLIMIT_MIN 8192U
+SODIUM_EXPORT
+size_t crypto_pwhash_argon2id_memlimit_min(void);
+
+#define crypto_pwhash_argon2id_MEMLIMIT_MAX \
+    ((SIZE_MAX >= 4398046510080U) ? 4398046510080U : (SIZE_MAX >= 2147483648U) ? 2147483648U : 32768U)
+SODIUM_EXPORT
+size_t crypto_pwhash_argon2id_memlimit_max(void);
+
+#define crypto_pwhash_argon2id_OPSLIMIT_INTERACTIVE 2U
+SODIUM_EXPORT
+size_t crypto_pwhash_argon2id_opslimit_interactive(void);
+
+#define crypto_pwhash_argon2id_MEMLIMIT_INTERACTIVE 67108864U
+SODIUM_EXPORT
+size_t crypto_pwhash_argon2id_memlimit_interactive(void);
+
+#define crypto_pwhash_argon2id_OPSLIMIT_MODERATE 3U
+SODIUM_EXPORT
+size_t crypto_pwhash_argon2id_opslimit_moderate(void);
+
+#define crypto_pwhash_argon2id_MEMLIMIT_MODERATE 268435456U
+SODIUM_EXPORT
+size_t crypto_pwhash_argon2id_memlimit_moderate(void);
+
+#define crypto_pwhash_argon2id_OPSLIMIT_SENSITIVE 4U
+SODIUM_EXPORT
+size_t crypto_pwhash_argon2id_opslimit_sensitive(void);
+
+#define crypto_pwhash_argon2id_MEMLIMIT_SENSITIVE 1073741824U
+SODIUM_EXPORT
+size_t crypto_pwhash_argon2id_memlimit_sensitive(void);
+
+SODIUM_EXPORT
+int crypto_pwhash_argon2id(unsigned char * const out,
+                           unsigned long long outlen,
+                           const char * const passwd,
+                           unsigned long long passwdlen,
+                           const unsigned char * const salt,
+                           unsigned long long opslimit, size_t memlimit,
+                           int alg)
+            __attribute__ ((warn_unused_result));
+
+SODIUM_EXPORT
+int crypto_pwhash_argon2id_str(char out[crypto_pwhash_argon2id_STRBYTES],
+                               const char * const passwd,
+                               unsigned long long passwdlen,
+                               unsigned long long opslimit, size_t memlimit)
+            __attribute__ ((warn_unused_result));
+
+SODIUM_EXPORT
+int crypto_pwhash_argon2id_str_verify(const char str[crypto_pwhash_argon2id_STRBYTES],
+                                      const char * const passwd,
+                                      unsigned long long passwdlen)
+            __attribute__ ((warn_unused_result));
+
+SODIUM_EXPORT
+int crypto_pwhash_argon2id_str_needs_rehash(const char str[crypto_pwhash_argon2id_STRBYTES],
+                                            unsigned long long opslimit, size_t memlimit)
+            __attribute__ ((warn_unused_result));
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/3rdparty/sodium/crypto_pwhash_scryptsalsa208sha256.h

@@ -0,0 +1,120 @@
+#ifndef crypto_pwhash_scryptsalsa208sha256_H
+#define crypto_pwhash_scryptsalsa208sha256_H
+
+#include <limits.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#include "export.h"
+
+#ifdef __cplusplus
+# ifdef __GNUC__
+#  pragma GCC diagnostic ignored "-Wlong-long"
+# endif
+extern "C" {
+#endif
+
+#define crypto_pwhash_scryptsalsa208sha256_BYTES_MIN 16U
+SODIUM_EXPORT
+size_t crypto_pwhash_scryptsalsa208sha256_bytes_min(void);
+
+#define crypto_pwhash_scryptsalsa208sha256_BYTES_MAX \
+    SODIUM_MIN(SODIUM_SIZE_MAX, 0x1fffffffe0ULL)
+SODIUM_EXPORT
+size_t crypto_pwhash_scryptsalsa208sha256_bytes_max(void);
+
+#define crypto_pwhash_scryptsalsa208sha256_PASSWD_MIN 0U
+SODIUM_EXPORT
+size_t crypto_pwhash_scryptsalsa208sha256_passwd_min(void);
+
+#define crypto_pwhash_scryptsalsa208sha256_PASSWD_MAX SODIUM_SIZE_MAX
+SODIUM_EXPORT
+size_t crypto_pwhash_scryptsalsa208sha256_passwd_max(void);
+
+#define crypto_pwhash_scryptsalsa208sha256_SALTBYTES 32U
+SODIUM_EXPORT
+size_t crypto_pwhash_scryptsalsa208sha256_saltbytes(void);
+
+#define crypto_pwhash_scryptsalsa208sha256_STRBYTES 102U
+SODIUM_EXPORT
+size_t crypto_pwhash_scryptsalsa208sha256_strbytes(void);
+
+#define crypto_pwhash_scryptsalsa208sha256_STRPREFIX "$7$"
+SODIUM_EXPORT
+const char *crypto_pwhash_scryptsalsa208sha256_strprefix(void);
+
+#define crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MIN 32768U
+SODIUM_EXPORT
+size_t crypto_pwhash_scryptsalsa208sha256_opslimit_min(void);
+
+#define crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MAX 4294967295U
+SODIUM_EXPORT
+size_t crypto_pwhash_scryptsalsa208sha256_opslimit_max(void);
+
+#define crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MIN 16777216U
+SODIUM_EXPORT
+size_t crypto_pwhash_scryptsalsa208sha256_memlimit_min(void);
+
+#define crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MAX \
+    SODIUM_MIN(SIZE_MAX, 68719476736ULL)
+SODIUM_EXPORT
+size_t crypto_pwhash_scryptsalsa208sha256_memlimit_max(void);
+
+#define crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_INTERACTIVE 524288U
+SODIUM_EXPORT
+size_t crypto_pwhash_scryptsalsa208sha256_opslimit_interactive(void);
+
+#define crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_INTERACTIVE 16777216U
+SODIUM_EXPORT
+size_t crypto_pwhash_scryptsalsa208sha256_memlimit_interactive(void);
+
+#define crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_SENSITIVE 33554432U
+SODIUM_EXPORT
+size_t crypto_pwhash_scryptsalsa208sha256_opslimit_sensitive(void);
+
+#define crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_SENSITIVE 1073741824U
+SODIUM_EXPORT
+size_t crypto_pwhash_scryptsalsa208sha256_memlimit_sensitive(void);
+
+SODIUM_EXPORT
+int crypto_pwhash_scryptsalsa208sha256(unsigned char * const out,
+                                       unsigned long long outlen,
+                                       const char * const passwd,
+                                       unsigned long long passwdlen,
+                                       const unsigned char * const salt,
+                                       unsigned long long opslimit,
+                                       size_t memlimit)
+            __attribute__ ((warn_unused_result));
+
+SODIUM_EXPORT
+int crypto_pwhash_scryptsalsa208sha256_str(char out[crypto_pwhash_scryptsalsa208sha256_STRBYTES],
+                                           const char * const passwd,
+                                           unsigned long long passwdlen,
+                                           unsigned long long opslimit,
+                                           size_t memlimit)
+            __attribute__ ((warn_unused_result));
+
+SODIUM_EXPORT
+int crypto_pwhash_scryptsalsa208sha256_str_verify(const char str[crypto_pwhash_scryptsalsa208sha256_STRBYTES],
+                                                  const char * const passwd,
+                                                  unsigned long long passwdlen)
+            __attribute__ ((warn_unused_result));
+
+SODIUM_EXPORT
+int crypto_pwhash_scryptsalsa208sha256_ll(const uint8_t * passwd, size_t passwdlen,
+                                          const uint8_t * salt, size_t saltlen,
+                                          uint64_t N, uint32_t r, uint32_t p,
+                                          uint8_t * buf, size_t buflen)
+            __attribute__ ((warn_unused_result));
+
+SODIUM_EXPORT
+int crypto_pwhash_scryptsalsa208sha256_str_needs_rehash(const char str[crypto_pwhash_scryptsalsa208sha256_STRBYTES],
+                                                        unsigned long long opslimit,
+                                                        size_t memlimit)
+            __attribute__ ((warn_unused_result));
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/3rdparty/sodium/crypto_scalarmult.h

@@ -0,0 +1,45 @@
+#ifndef crypto_scalarmult_H
+#define crypto_scalarmult_H
+
+#include <stddef.h>
+
+#include "crypto_scalarmult_curve25519.h"
+#include "export.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define crypto_scalarmult_BYTES crypto_scalarmult_curve25519_BYTES
+SODIUM_EXPORT
+size_t  crypto_scalarmult_bytes(void);
+
+#define crypto_scalarmult_SCALARBYTES crypto_scalarmult_curve25519_SCALARBYTES
+SODIUM_EXPORT
+size_t  crypto_scalarmult_scalarbytes(void);
+
+#define crypto_scalarmult_PRIMITIVE "curve25519"
+SODIUM_EXPORT
+const char *crypto_scalarmult_primitive(void);
+
+SODIUM_EXPORT
+int crypto_scalarmult_base(unsigned char *q, const unsigned char *n);
+
+/*
+ * NOTE: Do not use the result of this function directly.
+ *
+ * Hash the result with the public keys in order to compute a shared
+ * secret key: H(q || client_pk || server_pk)
+ *
+ * Or unless this is not an option, use the crypto_kx() API instead.
+ */
+SODIUM_EXPORT
+int crypto_scalarmult(unsigned char *q, const unsigned char *n,
+                      const unsigned char *p)
+            __attribute__ ((warn_unused_result));
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/3rdparty/sodium/crypto_scalarmult_curve25519.h

@@ -0,0 +1,40 @@
+#ifndef crypto_scalarmult_curve25519_H
+#define crypto_scalarmult_curve25519_H
+
+#include <stddef.h>
+
+#include "export.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define crypto_scalarmult_curve25519_BYTES 32U
+SODIUM_EXPORT
+size_t crypto_scalarmult_curve25519_bytes(void);
+
+#define crypto_scalarmult_curve25519_SCALARBYTES 32U
+SODIUM_EXPORT
+size_t crypto_scalarmult_curve25519_scalarbytes(void);
+
+/*
+ * NOTE: Do not use the result of this function directly.
+ *
+ * Hash the result with the public keys in order to compute a shared
+ * secret key: H(q || client_pk || server_pk)
+ *
+ * Or unless this is not an option, use the crypto_kx() API instead.
+ */
+SODIUM_EXPORT
+int crypto_scalarmult_curve25519(unsigned char *q, const unsigned char *n,
+                                 const unsigned char *p)
+            __attribute__ ((warn_unused_result));
+
+SODIUM_EXPORT
+int crypto_scalarmult_curve25519_base(unsigned char *q, const unsigned char *n);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/3rdparty/sodium/crypto_scalarmult_ed25519.h

@@ -0,0 +1,41 @@
+
+#ifndef crypto_scalarmult_ed25519_H
+#define crypto_scalarmult_ed25519_H
+
+#include <stddef.h>
+
+#include "export.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define crypto_scalarmult_ed25519_BYTES 32U
+SODIUM_EXPORT
+size_t crypto_scalarmult_ed25519_bytes(void);
+
+#define crypto_scalarmult_ed25519_SCALARBYTES 32U
+SODIUM_EXPORT
+size_t crypto_scalarmult_ed25519_scalarbytes(void);
+
+/*
+ * NOTE: Do not use the result of this function directly.
+ *
+ * Hash the result with the public keys in order to compute a shared
+ * secret key: H(q || client_pk || server_pk)
+ *
+ * Or unless this is not an option, use the crypto_kx() API instead.
+ */
+SODIUM_EXPORT
+int crypto_scalarmult_ed25519(unsigned char *q, const unsigned char *n,
+                              const unsigned char *p)
+            __attribute__ ((warn_unused_result));
+
+SODIUM_EXPORT
+int crypto_scalarmult_ed25519_base(unsigned char *q, const unsigned char *n);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/3rdparty/sodium/crypto_secretbox.h

@@ -0,0 +1,91 @@
+#ifndef crypto_secretbox_H
+#define crypto_secretbox_H
+
+#include <stddef.h>
+
+#include "crypto_secretbox_xsalsa20poly1305.h"
+#include "export.h"
+
+#ifdef __cplusplus
+# ifdef __GNUC__
+#  pragma GCC diagnostic ignored "-Wlong-long"
+# endif
+extern "C" {
+#endif
+
+#define crypto_secretbox_KEYBYTES crypto_secretbox_xsalsa20poly1305_KEYBYTES
+SODIUM_EXPORT
+size_t  crypto_secretbox_keybytes(void);
+
+#define crypto_secretbox_NONCEBYTES crypto_secretbox_xsalsa20poly1305_NONCEBYTES
+SODIUM_EXPORT
+size_t  crypto_secretbox_noncebytes(void);
+
+#define crypto_secretbox_MACBYTES crypto_secretbox_xsalsa20poly1305_MACBYTES
+SODIUM_EXPORT
+size_t  crypto_secretbox_macbytes(void);
+
+#define crypto_secretbox_PRIMITIVE "xsalsa20poly1305"
+SODIUM_EXPORT
+const char *crypto_secretbox_primitive(void);
+
+#define crypto_secretbox_MESSAGEBYTES_MAX crypto_secretbox_xsalsa20poly1305_MESSAGEBYTES_MAX
+SODIUM_EXPORT
+size_t crypto_secretbox_messagebytes_max(void);
+
+SODIUM_EXPORT
+int crypto_secretbox_easy(unsigned char *c, const unsigned char *m,
+                          unsigned long long mlen, const unsigned char *n,
+                          const unsigned char *k);
+
+SODIUM_EXPORT
+int crypto_secretbox_open_easy(unsigned char *m, const unsigned char *c,
+                               unsigned long long clen, const unsigned char *n,
+                               const unsigned char *k)
+            __attribute__ ((warn_unused_result));
+
+SODIUM_EXPORT
+int crypto_secretbox_detached(unsigned char *c, unsigned char *mac,
+                              const unsigned char *m,
+                              unsigned long long mlen,
+                              const unsigned char *n,
+                              const unsigned char *k);
+
+SODIUM_EXPORT
+int crypto_secretbox_open_detached(unsigned char *m,
+                                   const unsigned char *c,
+                                   const unsigned char *mac,
+                                   unsigned long long clen,
+                                   const unsigned char *n,
+                                   const unsigned char *k)
+            __attribute__ ((warn_unused_result));
+
+SODIUM_EXPORT
+void crypto_secretbox_keygen(unsigned char k[crypto_secretbox_KEYBYTES]);
+
+/* -- NaCl compatibility interface ; Requires padding -- */
+
+#define crypto_secretbox_ZEROBYTES crypto_secretbox_xsalsa20poly1305_ZEROBYTES
+SODIUM_EXPORT
+size_t  crypto_secretbox_zerobytes(void);
+
+#define crypto_secretbox_BOXZEROBYTES crypto_secretbox_xsalsa20poly1305_BOXZEROBYTES
+SODIUM_EXPORT
+size_t  crypto_secretbox_boxzerobytes(void);
+
+SODIUM_EXPORT
+int crypto_secretbox(unsigned char *c, const unsigned char *m,
+                     unsigned long long mlen, const unsigned char *n,
+                     const unsigned char *k);
+
+SODIUM_EXPORT
+int crypto_secretbox_open(unsigned char *m, const unsigned char *c,
+                          unsigned long long clen, const unsigned char *n,
+                          const unsigned char *k)
+            __attribute__ ((warn_unused_result));
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/3rdparty/sodium/crypto_secretbox_xchacha20poly1305.h

@@ -0,0 +1,68 @@
+#ifndef crypto_secretbox_xchacha20poly1305_H
+#define crypto_secretbox_xchacha20poly1305_H
+
+#include <stddef.h>
+#include "crypto_stream_xchacha20.h"
+#include "export.h"
+
+#ifdef __cplusplus
+# ifdef __GNUC__
+#  pragma GCC diagnostic ignored "-Wlong-long"
+# endif
+extern "C" {
+#endif
+
+#define crypto_secretbox_xchacha20poly1305_KEYBYTES 32U
+SODIUM_EXPORT
+size_t crypto_secretbox_xchacha20poly1305_keybytes(void);
+
+#define crypto_secretbox_xchacha20poly1305_NONCEBYTES 24U
+SODIUM_EXPORT
+size_t crypto_secretbox_xchacha20poly1305_noncebytes(void);
+
+#define crypto_secretbox_xchacha20poly1305_MACBYTES 16U
+SODIUM_EXPORT
+size_t crypto_secretbox_xchacha20poly1305_macbytes(void);
+
+#define crypto_secretbox_xchacha20poly1305_MESSAGEBYTES_MAX \
+    (crypto_stream_xchacha20_MESSAGEBYTES_MAX - crypto_secretbox_xchacha20poly1305_MACBYTES)
+SODIUM_EXPORT
+size_t crypto_secretbox_xchacha20poly1305_messagebytes_max(void);
+
+SODIUM_EXPORT
+int crypto_secretbox_xchacha20poly1305_easy(unsigned char *c,
+                                            const unsigned char *m,
+                                            unsigned long long mlen,
+                                            const unsigned char *n,
+                                            const unsigned char *k);
+
+SODIUM_EXPORT
+int crypto_secretbox_xchacha20poly1305_open_easy(unsigned char *m,
+                                                 const unsigned char *c,
+                                                 unsigned long long clen,
+                                                 const unsigned char *n,
+                                                 const unsigned char *k)
+            __attribute__ ((warn_unused_result));
+
+SODIUM_EXPORT
+int crypto_secretbox_xchacha20poly1305_detached(unsigned char *c,
+                                                unsigned char *mac,
+                                                const unsigned char *m,
+                                                unsigned long long mlen,
+                                                const unsigned char *n,
+                                                const unsigned char *k);
+
+SODIUM_EXPORT
+int crypto_secretbox_xchacha20poly1305_open_detached(unsigned char *m,
+                                                     const unsigned char *c,
+                                                     const unsigned char *mac,
+                                                     unsigned long long clen,
+                                                     const unsigned char *n,
+                                                     const unsigned char *k)
+            __attribute__ ((warn_unused_result));
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/3rdparty/sodium/crypto_secretbox_xsalsa20poly1305.h

@@ -0,0 +1,67 @@
+#ifndef crypto_secretbox_xsalsa20poly1305_H
+#define crypto_secretbox_xsalsa20poly1305_H
+
+#include <stddef.h>
+#include "crypto_stream_xsalsa20.h"
+#include "export.h"
+
+#ifdef __cplusplus
+# ifdef __GNUC__
+#  pragma GCC diagnostic ignored "-Wlong-long"
+# endif
+extern "C" {
+#endif
+
+#define crypto_secretbox_xsalsa20poly1305_KEYBYTES 32U
+SODIUM_EXPORT
+size_t crypto_secretbox_xsalsa20poly1305_keybytes(void);
+
+#define crypto_secretbox_xsalsa20poly1305_NONCEBYTES 24U
+SODIUM_EXPORT
+size_t crypto_secretbox_xsalsa20poly1305_noncebytes(void);
+
+#define crypto_secretbox_xsalsa20poly1305_MACBYTES 16U
+SODIUM_EXPORT
+size_t crypto_secretbox_xsalsa20poly1305_macbytes(void);
+
+/* Only for the libsodium API - The NaCl compatibility API would require BOXZEROBYTES extra bytes */
+#define crypto_secretbox_xsalsa20poly1305_MESSAGEBYTES_MAX \
+    (crypto_stream_xsalsa20_MESSAGEBYTES_MAX - crypto_secretbox_xsalsa20poly1305_MACBYTES)
+SODIUM_EXPORT
+size_t crypto_secretbox_xsalsa20poly1305_messagebytes_max(void);
+
+SODIUM_EXPORT
+int crypto_secretbox_xsalsa20poly1305(unsigned char *c,
+                                      const unsigned char *m,
+                                      unsigned long long mlen,
+                                      const unsigned char *n,
+                                      const unsigned char *k);
+
+SODIUM_EXPORT
+int crypto_secretbox_xsalsa20poly1305_open(unsigned char *m,
+                                           const unsigned char *c,
+                                           unsigned long long clen,
+                                           const unsigned char *n,
+                                           const unsigned char *k)
+            __attribute__ ((warn_unused_result));
+
+SODIUM_EXPORT
+void crypto_secretbox_xsalsa20poly1305_keygen(unsigned char k[crypto_secretbox_xsalsa20poly1305_KEYBYTES]);
+
+/* -- NaCl compatibility interface ; Requires padding -- */
+
+#define crypto_secretbox_xsalsa20poly1305_BOXZEROBYTES 16U
+SODIUM_EXPORT
+size_t crypto_secretbox_xsalsa20poly1305_boxzerobytes(void);
+
+#define crypto_secretbox_xsalsa20poly1305_ZEROBYTES \
+    (crypto_secretbox_xsalsa20poly1305_BOXZEROBYTES + \
+     crypto_secretbox_xsalsa20poly1305_MACBYTES)
+SODIUM_EXPORT
+size_t crypto_secretbox_xsalsa20poly1305_zerobytes(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/3rdparty/sodium/crypto_secretstream_xchacha20poly1305.h

@@ -0,0 +1,102 @@
+#ifndef crypto_secretstream_xchacha20poly1305_H
+#define crypto_secretstream_xchacha20poly1305_H
+
+#include <stddef.h>
+
+#include "crypto_aead_xchacha20poly1305.h"
+#include "crypto_stream_chacha20.h"
+#include "export.h"
+
+#ifdef __cplusplus
+# ifdef __GNUC__
+#  pragma GCC diagnostic ignored "-Wlong-long"
+# endif
+extern "C" {
+#endif
+
+#define crypto_secretstream_xchacha20poly1305_ABYTES \
+    (1U + crypto_aead_xchacha20poly1305_ietf_ABYTES)
+SODIUM_EXPORT
+size_t crypto_secretstream_xchacha20poly1305_abytes(void);
+
+#define crypto_secretstream_xchacha20poly1305_HEADERBYTES \
+    crypto_aead_xchacha20poly1305_ietf_NPUBBYTES
+SODIUM_EXPORT
+size_t crypto_secretstream_xchacha20poly1305_headerbytes(void);
+
+#define crypto_secretstream_xchacha20poly1305_KEYBYTES \
+    crypto_aead_xchacha20poly1305_ietf_KEYBYTES
+SODIUM_EXPORT
+size_t crypto_secretstream_xchacha20poly1305_keybytes(void);
+
+#define crypto_secretstream_xchacha20poly1305_MESSAGEBYTES_MAX \
+    SODIUM_MIN(SODIUM_SIZE_MAX, ((1ULL << 32) - 2ULL) * 64ULL)
+SODIUM_EXPORT
+size_t crypto_secretstream_xchacha20poly1305_messagebytes_max(void);
+
+#define crypto_secretstream_xchacha20poly1305_TAG_MESSAGE 0x00
+SODIUM_EXPORT
+unsigned char crypto_secretstream_xchacha20poly1305_tag_message(void);
+
+#define crypto_secretstream_xchacha20poly1305_TAG_PUSH    0x01
+SODIUM_EXPORT
+unsigned char crypto_secretstream_xchacha20poly1305_tag_push(void);
+
+#define crypto_secretstream_xchacha20poly1305_TAG_REKEY   0x02
+SODIUM_EXPORT
+unsigned char crypto_secretstream_xchacha20poly1305_tag_rekey(void);
+
+#define crypto_secretstream_xchacha20poly1305_TAG_FINAL \
+    (crypto_secretstream_xchacha20poly1305_TAG_PUSH | \
+     crypto_secretstream_xchacha20poly1305_TAG_REKEY)
+SODIUM_EXPORT
+unsigned char crypto_secretstream_xchacha20poly1305_tag_final(void);
+
+typedef struct crypto_secretstream_xchacha20poly1305_state {
+    unsigned char k[crypto_stream_chacha20_ietf_KEYBYTES];
+    unsigned char nonce[crypto_stream_chacha20_ietf_NONCEBYTES];
+    unsigned char _pad[8];
+} crypto_secretstream_xchacha20poly1305_state;
+
+SODIUM_EXPORT
+size_t crypto_secretstream_xchacha20poly1305_statebytes(void);
+
+SODIUM_EXPORT
+void crypto_secretstream_xchacha20poly1305_keygen
+   (unsigned char k[crypto_secretstream_xchacha20poly1305_KEYBYTES]);
+
+SODIUM_EXPORT
+int crypto_secretstream_xchacha20poly1305_init_push
+   (crypto_secretstream_xchacha20poly1305_state *state,
+    unsigned char header[crypto_secretstream_xchacha20poly1305_HEADERBYTES],
+    const unsigned char k[crypto_secretstream_xchacha20poly1305_KEYBYTES]);
+
+SODIUM_EXPORT
+int crypto_secretstream_xchacha20poly1305_push
+   (crypto_secretstream_xchacha20poly1305_state *state,
+    unsigned char *c, unsigned long long *clen_p,
+    const unsigned char *m, unsigned long long mlen,
+    const unsigned char *ad, unsigned long long adlen, unsigned char tag);
+
+SODIUM_EXPORT
+int crypto_secretstream_xchacha20poly1305_init_pull
+   (crypto_secretstream_xchacha20poly1305_state *state,
+    const unsigned char header[crypto_secretstream_xchacha20poly1305_HEADERBYTES],
+    const unsigned char k[crypto_secretstream_xchacha20poly1305_KEYBYTES]);
+
+SODIUM_EXPORT
+int crypto_secretstream_xchacha20poly1305_pull
+   (crypto_secretstream_xchacha20poly1305_state *state,
+    unsigned char *m, unsigned long long *mlen_p, unsigned char *tag_p,
+    const unsigned char *c, unsigned long long clen,
+    const unsigned char *ad, unsigned long long adlen);
+
+SODIUM_EXPORT
+void crypto_secretstream_xchacha20poly1305_rekey
+    (crypto_secretstream_xchacha20poly1305_state *state);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/3rdparty/sodium/crypto_shorthash.h

@@ -0,0 +1,39 @@
+#ifndef crypto_shorthash_H
+#define crypto_shorthash_H
+
+#include <stddef.h>
+
+#include "crypto_shorthash_siphash24.h"
+#include "export.h"
+
+#ifdef __cplusplus
+# ifdef __GNUC__
+#  pragma GCC diagnostic ignored "-Wlong-long"
+# endif
+extern "C" {
+#endif
+
+#define crypto_shorthash_BYTES crypto_shorthash_siphash24_BYTES
+SODIUM_EXPORT
+size_t  crypto_shorthash_bytes(void);
+
+#define crypto_shorthash_KEYBYTES crypto_shorthash_siphash24_KEYBYTES
+SODIUM_EXPORT
+size_t  crypto_shorthash_keybytes(void);
+
+#define crypto_shorthash_PRIMITIVE "siphash24"
+SODIUM_EXPORT
+const char *crypto_shorthash_primitive(void);
+
+SODIUM_EXPORT
+int crypto_shorthash(unsigned char *out, const unsigned char *in,
+                     unsigned long long inlen, const unsigned char *k);
+
+SODIUM_EXPORT
+void crypto_shorthash_keygen(unsigned char k[crypto_shorthash_KEYBYTES]);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/3rdparty/sodium/crypto_shorthash_siphash24.h

@@ -0,0 +1,48 @@
+#ifndef crypto_shorthash_siphash24_H
+#define crypto_shorthash_siphash24_H
+
+#include <stddef.h>
+#include "export.h"
+
+#ifdef __cplusplus
+# ifdef __GNUC__
+#  pragma GCC diagnostic ignored "-Wlong-long"
+# endif
+extern "C" {
+#endif
+
+/* -- 64-bit output -- */
+
+#define crypto_shorthash_siphash24_BYTES 8U
+SODIUM_EXPORT
+size_t crypto_shorthash_siphash24_bytes(void);
+
+#define crypto_shorthash_siphash24_KEYBYTES 16U
+SODIUM_EXPORT
+size_t crypto_shorthash_siphash24_keybytes(void);
+
+SODIUM_EXPORT
+int crypto_shorthash_siphash24(unsigned char *out, const unsigned char *in,
+                               unsigned long long inlen, const unsigned char *k);
+
+#ifndef SODIUM_LIBRARY_MINIMAL
+/* -- 128-bit output -- */
+
+#define crypto_shorthash_siphashx24_BYTES 16U
+SODIUM_EXPORT
+size_t crypto_shorthash_siphashx24_bytes(void);
+
+#define crypto_shorthash_siphashx24_KEYBYTES 16U
+SODIUM_EXPORT
+size_t crypto_shorthash_siphashx24_keybytes(void);
+
+SODIUM_EXPORT
+int crypto_shorthash_siphashx24(unsigned char *out, const unsigned char *in,
+                                unsigned long long inlen, const unsigned char *k);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/3rdparty/sodium/crypto_sign.h

@@ -0,0 +1,103 @@
+#ifndef crypto_sign_H
+#define crypto_sign_H
+
+/*
+ * THREAD SAFETY: crypto_sign_keypair() is thread-safe,
+ * provided that sodium_init() was called before.
+ *
+ * Other functions, including crypto_sign_seed_keypair() are always thread-safe.
+ */
+
+#include <stddef.h>
+
+#include "crypto_sign_ed25519.h"
+#include "export.h"
+
+#ifdef __cplusplus
+# ifdef __GNUC__
+#  pragma GCC diagnostic ignored "-Wlong-long"
+# endif
+extern "C" {
+#endif
+
+typedef crypto_sign_ed25519ph_state crypto_sign_state;
+
+SODIUM_EXPORT
+size_t  crypto_sign_statebytes(void);
+
+#define crypto_sign_BYTES crypto_sign_ed25519_BYTES
+SODIUM_EXPORT
+size_t  crypto_sign_bytes(void);
+
+#define crypto_sign_SEEDBYTES crypto_sign_ed25519_SEEDBYTES
+SODIUM_EXPORT
+size_t  crypto_sign_seedbytes(void);
+
+#define crypto_sign_PUBLICKEYBYTES crypto_sign_ed25519_PUBLICKEYBYTES
+SODIUM_EXPORT
+size_t  crypto_sign_publickeybytes(void);
+
+#define crypto_sign_SECRETKEYBYTES crypto_sign_ed25519_SECRETKEYBYTES
+SODIUM_EXPORT
+size_t  crypto_sign_secretkeybytes(void);
+
+#define crypto_sign_MESSAGEBYTES_MAX crypto_sign_ed25519_MESSAGEBYTES_MAX
+SODIUM_EXPORT
+size_t  crypto_sign_messagebytes_max(void);
+
+#define crypto_sign_PRIMITIVE "ed25519"
+SODIUM_EXPORT
+const char *crypto_sign_primitive(void);
+
+SODIUM_EXPORT
+int crypto_sign_seed_keypair(unsigned char *pk, unsigned char *sk,
+                             const unsigned char *seed);
+
+SODIUM_EXPORT
+int crypto_sign_keypair(unsigned char *pk, unsigned char *sk);
+
+SODIUM_EXPORT
+int crypto_sign(unsigned char *sm, unsigned long long *smlen_p,
+                const unsigned char *m, unsigned long long mlen,
+                const unsigned char *sk);
+
+SODIUM_EXPORT
+int crypto_sign_open(unsigned char *m, unsigned long long *mlen_p,
+                     const unsigned char *sm, unsigned long long smlen,
+                     const unsigned char *pk)
+            __attribute__ ((warn_unused_result));
+
+SODIUM_EXPORT
+int crypto_sign_detached(unsigned char *sig, unsigned long long *siglen_p,
+                         const unsigned char *m, unsigned long long mlen,
+                         const unsigned char *sk);
+
+SODIUM_EXPORT
+int crypto_sign_verify_detached(const unsigned char *sig,
+                                const unsigned char *m,
+                                unsigned long long mlen,
+                                const unsigned char *pk)
+            __attribute__ ((warn_unused_result));
+
+SODIUM_EXPORT
+int crypto_sign_init(crypto_sign_state *state);
+
+SODIUM_EXPORT
+int crypto_sign_update(crypto_sign_state *state,
+                       const unsigned char *m, unsigned long long mlen);
+
+SODIUM_EXPORT
+int crypto_sign_final_create(crypto_sign_state *state, unsigned char *sig,
+                             unsigned long long *siglen_p,
+                             const unsigned char *sk);
+
+SODIUM_EXPORT
+int crypto_sign_final_verify(crypto_sign_state *state, unsigned char *sig,
+                             const unsigned char *pk)
+            __attribute__ ((warn_unused_result));
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/3rdparty/sodium/crypto_sign_ed25519.h

@@ -0,0 +1,114 @@
+#ifndef crypto_sign_ed25519_H
+#define crypto_sign_ed25519_H
+
+#include <stddef.h>
+#include "crypto_hash_sha512.h"
+#include "export.h"
+
+#ifdef __cplusplus
+# ifdef __GNUC__
+#  pragma GCC diagnostic ignored "-Wlong-long"
+# endif
+extern "C" {
+#endif
+
+typedef struct crypto_sign_ed25519ph_state {
+    crypto_hash_sha512_state hs;
+} crypto_sign_ed25519ph_state;
+
+SODIUM_EXPORT
+size_t crypto_sign_ed25519ph_statebytes(void);
+
+#define crypto_sign_ed25519_BYTES 64U
+SODIUM_EXPORT
+size_t crypto_sign_ed25519_bytes(void);
+
+#define crypto_sign_ed25519_SEEDBYTES 32U
+SODIUM_EXPORT
+size_t crypto_sign_ed25519_seedbytes(void);
+
+#define crypto_sign_ed25519_PUBLICKEYBYTES 32U
+SODIUM_EXPORT
+size_t crypto_sign_ed25519_publickeybytes(void);
+
+#define crypto_sign_ed25519_SECRETKEYBYTES (32U + 32U)
+SODIUM_EXPORT
+size_t crypto_sign_ed25519_secretkeybytes(void);
+
+#define crypto_sign_ed25519_MESSAGEBYTES_MAX (SODIUM_SIZE_MAX - crypto_sign_ed25519_BYTES)
+SODIUM_EXPORT
+size_t crypto_sign_ed25519_messagebytes_max(void);
+
+SODIUM_EXPORT
+int crypto_sign_ed25519(unsigned char *sm, unsigned long long *smlen_p,
+                        const unsigned char *m, unsigned long long mlen,
+                        const unsigned char *sk);
+
+SODIUM_EXPORT
+int crypto_sign_ed25519_open(unsigned char *m, unsigned long long *mlen_p,
+                             const unsigned char *sm, unsigned long long smlen,
+                             const unsigned char *pk)
+            __attribute__ ((warn_unused_result));
+
+SODIUM_EXPORT
+int crypto_sign_ed25519_detached(unsigned char *sig,
+                                 unsigned long long *siglen_p,
+                                 const unsigned char *m,
+                                 unsigned long long mlen,
+                                 const unsigned char *sk);
+
+SODIUM_EXPORT
+int crypto_sign_ed25519_verify_detached(const unsigned char *sig,
+                                        const unsigned char *m,
+                                        unsigned long long mlen,
+                                        const unsigned char *pk)
+            __attribute__ ((warn_unused_result));
+
+SODIUM_EXPORT
+int crypto_sign_ed25519_keypair(unsigned char *pk, unsigned char *sk);
+
+SODIUM_EXPORT
+int crypto_sign_ed25519_seed_keypair(unsigned char *pk, unsigned char *sk,
+                                     const unsigned char *seed);
+
+SODIUM_EXPORT
+int crypto_sign_ed25519_pk_to_curve25519(unsigned char *curve25519_pk,
+                                         const unsigned char *ed25519_pk)
+            __attribute__ ((warn_unused_result));
+
+SODIUM_EXPORT
+int crypto_sign_ed25519_sk_to_curve25519(unsigned char *curve25519_sk,
+                                         const unsigned char *ed25519_sk);
+
+SODIUM_EXPORT
+int crypto_sign_ed25519_sk_to_seed(unsigned char *seed,
+                                   const unsigned char *sk);
+
+SODIUM_EXPORT
+int crypto_sign_ed25519_sk_to_pk(unsigned char *pk, const unsigned char *sk);
+
+SODIUM_EXPORT
+int crypto_sign_ed25519ph_init(crypto_sign_ed25519ph_state *state);
+
+SODIUM_EXPORT
+int crypto_sign_ed25519ph_update(crypto_sign_ed25519ph_state *state,
+                                 const unsigned char *m,
+                                 unsigned long long mlen);
+
+SODIUM_EXPORT
+int crypto_sign_ed25519ph_final_create(crypto_sign_ed25519ph_state *state,
+                                       unsigned char *sig,
+                                       unsigned long long *siglen_p,
+                                       const unsigned char *sk);
+
+SODIUM_EXPORT
+int crypto_sign_ed25519ph_final_verify(crypto_sign_ed25519ph_state *state,
+                                       unsigned char *sig,
+                                       const unsigned char *pk)
+            __attribute__ ((warn_unused_result));
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/3rdparty/sodium/crypto_sign_edwards25519sha512batch.h

@@ -0,0 +1,55 @@
+#ifndef crypto_sign_edwards25519sha512batch_H
+#define crypto_sign_edwards25519sha512batch_H
+
+/*
+ * WARNING: This construction was a prototype, which should not be used
+ * any more in new projects.
+ *
+ * crypto_sign_edwards25519sha512batch is provided for applications
+ * initially built with NaCl, but as recommended by the author of this
+ * construction, new applications should use ed25519 instead.
+ *
+ * In Sodium, you should use the high-level crypto_sign_*() functions instead.
+ */
+
+#include <stddef.h>
+#include "export.h"
+
+#ifdef __cplusplus
+# ifdef __GNUC__
+#  pragma GCC diagnostic ignored "-Wlong-long"
+# endif
+extern "C" {
+#endif
+
+#define crypto_sign_edwards25519sha512batch_BYTES 64U
+#define crypto_sign_edwards25519sha512batch_PUBLICKEYBYTES 32U
+#define crypto_sign_edwards25519sha512batch_SECRETKEYBYTES (32U + 32U)
+#define crypto_sign_edwards25519sha512batch_MESSAGEBYTES_MAX (SODIUM_SIZE_MAX - crypto_sign_edwards25519sha512batch_BYTES)
+
+SODIUM_EXPORT
+int crypto_sign_edwards25519sha512batch(unsigned char *sm,
+                                        unsigned long long *smlen_p,
+                                        const unsigned char *m,
+                                        unsigned long long mlen,
+                                        const unsigned char *sk)
+       __attribute__ ((deprecated));
+
+SODIUM_EXPORT
+int crypto_sign_edwards25519sha512batch_open(unsigned char *m,
+                                             unsigned long long *mlen_p,
+                                             const unsigned char *sm,
+                                             unsigned long long smlen,
+                                             const unsigned char *pk)
+       __attribute__ ((deprecated));
+
+SODIUM_EXPORT
+int crypto_sign_edwards25519sha512batch_keypair(unsigned char *pk,
+                                                unsigned char *sk)
+       __attribute__ ((deprecated));
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/3rdparty/sodium/crypto_stream.h

@@ -0,0 +1,56 @@
+#ifndef crypto_stream_H
+#define crypto_stream_H
+
+/*
+ *  WARNING: This is just a stream cipher. It is NOT authenticated encryption.
+ *  While it provides some protection against eavesdropping, it does NOT
+ *  provide any security against active attacks.
+ *  Unless you know what you're doing, what you are looking for is probably
+ *  the crypto_box functions.
+ */
+
+#include <stddef.h>
+
+#include "crypto_stream_xsalsa20.h"
+#include "export.h"
+
+#ifdef __cplusplus
+# ifdef __GNUC__
+#  pragma GCC diagnostic ignored "-Wlong-long"
+# endif
+extern "C" {
+#endif
+
+#define crypto_stream_KEYBYTES crypto_stream_xsalsa20_KEYBYTES
+SODIUM_EXPORT
+size_t  crypto_stream_keybytes(void);
+
+#define crypto_stream_NONCEBYTES crypto_stream_xsalsa20_NONCEBYTES
+SODIUM_EXPORT
+size_t  crypto_stream_noncebytes(void);
+
+#define crypto_stream_MESSAGEBYTES_MAX crypto_stream_xsalsa20_MESSAGEBYTES_MAX
+SODIUM_EXPORT
+size_t  crypto_stream_messagebytes_max(void);
+
+#define crypto_stream_PRIMITIVE "xsalsa20"
+SODIUM_EXPORT
+const char *crypto_stream_primitive(void);
+
+SODIUM_EXPORT
+int crypto_stream(unsigned char *c, unsigned long long clen,
+                  const unsigned char *n, const unsigned char *k);
+
+SODIUM_EXPORT
+int crypto_stream_xor(unsigned char *c, const unsigned char *m,
+                      unsigned long long mlen, const unsigned char *n,
+                      const unsigned char *k);
+
+SODIUM_EXPORT
+void crypto_stream_keygen(unsigned char k[crypto_stream_KEYBYTES]);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/3rdparty/sodium/crypto_stream_chacha20.h

@@ -0,0 +1,98 @@
+#ifndef crypto_stream_chacha20_H
+#define crypto_stream_chacha20_H
+
+/*
+ *  WARNING: This is just a stream cipher. It is NOT authenticated encryption.
+ *  While it provides some protection against eavesdropping, it does NOT
+ *  provide any security against active attacks.
+ *  Unless you know what you're doing, what you are looking for is probably
+ *  the crypto_box functions.
+ */
+
+#include <stddef.h>
+#include <stdint.h>
+#include "export.h"
+
+#ifdef __cplusplus
+# ifdef __GNUC__
+#  pragma GCC diagnostic ignored "-Wlong-long"
+# endif
+extern "C" {
+#endif
+
+#define crypto_stream_chacha20_KEYBYTES 32U
+SODIUM_EXPORT
+size_t crypto_stream_chacha20_keybytes(void);
+
+#define crypto_stream_chacha20_NONCEBYTES 8U
+SODIUM_EXPORT
+size_t crypto_stream_chacha20_noncebytes(void);
+
+#define crypto_stream_chacha20_MESSAGEBYTES_MAX SODIUM_SIZE_MAX
+SODIUM_EXPORT
+size_t crypto_stream_chacha20_messagebytes_max(void);
+
+/* ChaCha20 with a 64-bit nonce and a 64-bit counter, as originally designed */
+
+SODIUM_EXPORT
+int crypto_stream_chacha20(unsigned char *c, unsigned long long clen,
+                           const unsigned char *n, const unsigned char *k);
+
+SODIUM_EXPORT
+int crypto_stream_chacha20_xor(unsigned char *c, const unsigned char *m,
+                               unsigned long long mlen, const unsigned char *n,
+                               const unsigned char *k);
+
+SODIUM_EXPORT
+int crypto_stream_chacha20_xor_ic(unsigned char *c, const unsigned char *m,
+                                  unsigned long long mlen,
+                                  const unsigned char *n, uint64_t ic,
+                                  const unsigned char *k);
+
+SODIUM_EXPORT
+void crypto_stream_chacha20_keygen(unsigned char k[crypto_stream_chacha20_KEYBYTES]);
+
+/* ChaCha20 with a 96-bit nonce and a 32-bit counter (IETF) */
+
+#define crypto_stream_chacha20_ietf_KEYBYTES 32U
+SODIUM_EXPORT
+size_t crypto_stream_chacha20_ietf_keybytes(void);
+
+#define crypto_stream_chacha20_ietf_NONCEBYTES 12U
+SODIUM_EXPORT
+size_t crypto_stream_chacha20_ietf_noncebytes(void);
+
+#define crypto_stream_chacha20_ietf_MESSAGEBYTES_MAX \
+    SODIUM_MIN(SODIUM_SIZE_MAX, 64ULL * (1ULL << 32))
+SODIUM_EXPORT
+size_t crypto_stream_chacha20_ietf_messagebytes_max(void);
+
+SODIUM_EXPORT
+int crypto_stream_chacha20_ietf(unsigned char *c, unsigned long long clen,
+                                const unsigned char *n, const unsigned char *k);
+
+SODIUM_EXPORT
+int crypto_stream_chacha20_ietf_xor(unsigned char *c, const unsigned char *m,
+                                    unsigned long long mlen, const unsigned char *n,
+                                    const unsigned char *k);
+
+SODIUM_EXPORT
+int crypto_stream_chacha20_ietf_xor_ic(unsigned char *c, const unsigned char *m,
+                                       unsigned long long mlen,
+                                       const unsigned char *n, uint32_t ic,
+                                       const unsigned char *k);
+
+SODIUM_EXPORT
+void crypto_stream_chacha20_ietf_keygen(unsigned char k[crypto_stream_chacha20_ietf_KEYBYTES]);
+
+/* Aliases */
+
+#define crypto_stream_chacha20_IETF_KEYBYTES crypto_stream_chacha20_ietf_KEYBYTES
+#define crypto_stream_chacha20_IETF_NONCEBYTES crypto_stream_chacha20_ietf_NONCEBYTES
+#define crypto_stream_chacha20_IETF_MESSAGEBYTES_MAX crypto_stream_chacha20_ietf_MESSAGEBYTES_MAX
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/3rdparty/sodium/crypto_stream_salsa20.h

@@ -0,0 +1,57 @@
+#ifndef crypto_stream_salsa20_H
+#define crypto_stream_salsa20_H
+
+/*
+ *  WARNING: This is just a stream cipher. It is NOT authenticated encryption.
+ *  While it provides some protection against eavesdropping, it does NOT
+ *  provide any security against active attacks.
+ *  Unless you know what you're doing, what you are looking for is probably
+ *  the crypto_box functions.
+ */
+
+#include <stddef.h>
+#include <stdint.h>
+#include "export.h"
+
+#ifdef __cplusplus
+# ifdef __GNUC__
+#  pragma GCC diagnostic ignored "-Wlong-long"
+# endif
+extern "C" {
+#endif
+
+#define crypto_stream_salsa20_KEYBYTES 32U
+SODIUM_EXPORT
+size_t crypto_stream_salsa20_keybytes(void);
+
+#define crypto_stream_salsa20_NONCEBYTES 8U
+SODIUM_EXPORT
+size_t crypto_stream_salsa20_noncebytes(void);
+
+#define crypto_stream_salsa20_MESSAGEBYTES_MAX SODIUM_SIZE_MAX
+SODIUM_EXPORT
+size_t crypto_stream_salsa20_messagebytes_max(void);
+
+SODIUM_EXPORT
+int crypto_stream_salsa20(unsigned char *c, unsigned long long clen,
+                          const unsigned char *n, const unsigned char *k);
+
+SODIUM_EXPORT
+int crypto_stream_salsa20_xor(unsigned char *c, const unsigned char *m,
+                              unsigned long long mlen, const unsigned char *n,
+                              const unsigned char *k);
+
+SODIUM_EXPORT
+int crypto_stream_salsa20_xor_ic(unsigned char *c, const unsigned char *m,
+                                 unsigned long long mlen,
+                                 const unsigned char *n, uint64_t ic,
+                                 const unsigned char *k);
+
+SODIUM_EXPORT
+void crypto_stream_salsa20_keygen(unsigned char k[crypto_stream_salsa20_KEYBYTES]);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/3rdparty/sodium/crypto_stream_salsa2012.h

@@ -0,0 +1,50 @@
+#ifndef crypto_stream_salsa2012_H
+#define crypto_stream_salsa2012_H
+
+/*
+ *  WARNING: This is just a stream cipher. It is NOT authenticated encryption.
+ *  While it provides some protection against eavesdropping, it does NOT
+ *  provide any security against active attacks.
+ *  Unless you know what you're doing, what you are looking for is probably
+ *  the crypto_box functions.
+ */
+
+#include <stddef.h>
+#include "export.h"
+
+#ifdef __cplusplus
+# ifdef __GNUC__
+#  pragma GCC diagnostic ignored "-Wlong-long"
+# endif
+extern "C" {
+#endif
+
+#define crypto_stream_salsa2012_KEYBYTES 32U
+SODIUM_EXPORT
+size_t crypto_stream_salsa2012_keybytes(void);
+
+#define crypto_stream_salsa2012_NONCEBYTES 8U
+SODIUM_EXPORT
+size_t crypto_stream_salsa2012_noncebytes(void);
+
+#define crypto_stream_salsa2012_MESSAGEBYTES_MAX SODIUM_SIZE_MAX
+SODIUM_EXPORT
+size_t crypto_stream_salsa2012_messagebytes_max(void);
+
+SODIUM_EXPORT
+int crypto_stream_salsa2012(unsigned char *c, unsigned long long clen,
+                            const unsigned char *n, const unsigned char *k);
+
+SODIUM_EXPORT
+int crypto_stream_salsa2012_xor(unsigned char *c, const unsigned char *m,
+                                unsigned long long mlen, const unsigned char *n,
+                                const unsigned char *k);
+
+SODIUM_EXPORT
+void crypto_stream_salsa2012_keygen(unsigned char k[crypto_stream_salsa2012_KEYBYTES]);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/3rdparty/sodium/crypto_stream_salsa208.h

@@ -0,0 +1,56 @@
+#ifndef crypto_stream_salsa208_H
+#define crypto_stream_salsa208_H
+
+/*
+ *  WARNING: This is just a stream cipher. It is NOT authenticated encryption.
+ *  While it provides some protection against eavesdropping, it does NOT
+ *  provide any security against active attacks.
+ *  Unless you know what you're doing, what you are looking for is probably
+ *  the crypto_box functions.
+ */
+
+#include <stddef.h>
+#include "export.h"
+
+#ifdef __cplusplus
+# ifdef __GNUC__
+#  pragma GCC diagnostic ignored "-Wlong-long"
+# endif
+extern "C" {
+#endif
+
+#define crypto_stream_salsa208_KEYBYTES 32U
+SODIUM_EXPORT
+size_t crypto_stream_salsa208_keybytes(void)
+            __attribute__ ((deprecated));
+
+#define crypto_stream_salsa208_NONCEBYTES 8U
+SODIUM_EXPORT
+size_t crypto_stream_salsa208_noncebytes(void)
+            __attribute__ ((deprecated));
+
+#define crypto_stream_salsa208_MESSAGEBYTES_MAX SODIUM_SIZE_MAX
+    SODIUM_EXPORT
+size_t crypto_stream_salsa208_messagebytes_max(void)
+            __attribute__ ((deprecated));
+
+SODIUM_EXPORT
+int crypto_stream_salsa208(unsigned char *c, unsigned long long clen,
+                           const unsigned char *n, const unsigned char *k)
+            __attribute__ ((deprecated));
+
+SODIUM_EXPORT
+int crypto_stream_salsa208_xor(unsigned char *c, const unsigned char *m,
+                               unsigned long long mlen, const unsigned char *n,
+                               const unsigned char *k)
+            __attribute__ ((deprecated));
+
+SODIUM_EXPORT
+void crypto_stream_salsa208_keygen(unsigned char k[crypto_stream_salsa208_KEYBYTES])
+            __attribute__ ((deprecated));
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/3rdparty/sodium/crypto_stream_xchacha20.h

@@ -0,0 +1,57 @@
+#ifndef crypto_stream_xchacha20_H
+#define crypto_stream_xchacha20_H
+
+/*
+ *  WARNING: This is just a stream cipher. It is NOT authenticated encryption.
+ *  While it provides some protection against eavesdropping, it does NOT
+ *  provide any security against active attacks.
+ *  Unless you know what you're doing, what you are looking for is probably
+ *  the crypto_box functions.
+ */
+
+#include <stddef.h>
+#include <stdint.h>
+#include "export.h"
+
+#ifdef __cplusplus
+# ifdef __GNUC__
+#  pragma GCC diagnostic ignored "-Wlong-long"
+# endif
+extern "C" {
+#endif
+
+#define crypto_stream_xchacha20_KEYBYTES 32U
+SODIUM_EXPORT
+size_t crypto_stream_xchacha20_keybytes(void);
+
+#define crypto_stream_xchacha20_NONCEBYTES 24U
+SODIUM_EXPORT
+size_t crypto_stream_xchacha20_noncebytes(void);
+
+#define crypto_stream_xchacha20_MESSAGEBYTES_MAX SODIUM_SIZE_MAX
+SODIUM_EXPORT
+size_t crypto_stream_xchacha20_messagebytes_max(void);
+
+SODIUM_EXPORT
+int crypto_stream_xchacha20(unsigned char *c, unsigned long long clen,
+                            const unsigned char *n, const unsigned char *k);
+
+SODIUM_EXPORT
+int crypto_stream_xchacha20_xor(unsigned char *c, const unsigned char *m,
+                                unsigned long long mlen, const unsigned char *n,
+                                const unsigned char *k);
+
+SODIUM_EXPORT
+int crypto_stream_xchacha20_xor_ic(unsigned char *c, const unsigned char *m,
+                                   unsigned long long mlen,
+                                   const unsigned char *n, uint64_t ic,
+                                   const unsigned char *k);
+
+SODIUM_EXPORT
+void crypto_stream_xchacha20_keygen(unsigned char k[crypto_stream_xchacha20_KEYBYTES]);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/3rdparty/sodium/crypto_stream_xsalsa20.h

@@ -0,0 +1,57 @@
+#ifndef crypto_stream_xsalsa20_H
+#define crypto_stream_xsalsa20_H
+
+/*
+ *  WARNING: This is just a stream cipher. It is NOT authenticated encryption.
+ *  While it provides some protection against eavesdropping, it does NOT
+ *  provide any security against active attacks.
+ *  Unless you know what you're doing, what you are looking for is probably
+ *  the crypto_box functions.
+ */
+
+#include <stddef.h>
+#include <stdint.h>
+#include "export.h"
+
+#ifdef __cplusplus
+# ifdef __GNUC__
+#  pragma GCC diagnostic ignored "-Wlong-long"
+# endif
+extern "C" {
+#endif
+
+#define crypto_stream_xsalsa20_KEYBYTES 32U
+SODIUM_EXPORT
+size_t crypto_stream_xsalsa20_keybytes(void);
+
+#define crypto_stream_xsalsa20_NONCEBYTES 24U
+SODIUM_EXPORT
+size_t crypto_stream_xsalsa20_noncebytes(void);
+
+#define crypto_stream_xsalsa20_MESSAGEBYTES_MAX SODIUM_SIZE_MAX
+SODIUM_EXPORT
+size_t crypto_stream_xsalsa20_messagebytes_max(void);
+
+SODIUM_EXPORT
+int crypto_stream_xsalsa20(unsigned char *c, unsigned long long clen,
+                           const unsigned char *n, const unsigned char *k);
+
+SODIUM_EXPORT
+int crypto_stream_xsalsa20_xor(unsigned char *c, const unsigned char *m,
+                               unsigned long long mlen, const unsigned char *n,
+                               const unsigned char *k);
+
+SODIUM_EXPORT
+int crypto_stream_xsalsa20_xor_ic(unsigned char *c, const unsigned char *m,
+                                  unsigned long long mlen,
+                                  const unsigned char *n, uint64_t ic,
+                                  const unsigned char *k);
+
+SODIUM_EXPORT
+void crypto_stream_xsalsa20_keygen(unsigned char k[crypto_stream_xsalsa20_KEYBYTES]);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/3rdparty/sodium/crypto_verify_16.h

@@ -0,0 +1,23 @@
+#ifndef crypto_verify_16_H
+#define crypto_verify_16_H
+
+#include <stddef.h>
+#include "export.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define crypto_verify_16_BYTES 16U
+SODIUM_EXPORT
+size_t crypto_verify_16_bytes(void);
+
+SODIUM_EXPORT
+int crypto_verify_16(const unsigned char *x, const unsigned char *y)
+            __attribute__ ((warn_unused_result));
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/3rdparty/sodium/crypto_verify_32.h

@@ -0,0 +1,23 @@
+#ifndef crypto_verify_32_H
+#define crypto_verify_32_H
+
+#include <stddef.h>
+#include "export.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define crypto_verify_32_BYTES 32U
+SODIUM_EXPORT
+size_t crypto_verify_32_bytes(void);
+
+SODIUM_EXPORT
+int crypto_verify_32(const unsigned char *x, const unsigned char *y)
+            __attribute__ ((warn_unused_result));
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/3rdparty/sodium/crypto_verify_64.h

@@ -0,0 +1,23 @@
+#ifndef crypto_verify_64_H
+#define crypto_verify_64_H
+
+#include <stddef.h>
+#include "export.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define crypto_verify_64_BYTES 64U
+SODIUM_EXPORT
+size_t crypto_verify_64_bytes(void);
+
+SODIUM_EXPORT
+int crypto_verify_64(const unsigned char *x, const unsigned char *y)
+            __attribute__ ((warn_unused_result));
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/3rdparty/sodium/export.h

@@ -0,0 +1,53 @@
+
+#ifndef sodium_export_H
+#define sodium_export_H
+
+#ifndef __GNUC__
+# ifdef __attribute__
+#  undef __attribute__
+# endif
+# define __attribute__(a)
+#endif
+
+#ifdef SODIUM_STATIC
+# define SODIUM_EXPORT
+# define SODIUM_EXPORT_WEAK
+#else
+# if defined(_MSC_VER)
+#  ifdef SODIUM_DLL_EXPORT
+#   define SODIUM_EXPORT __declspec(dllexport)
+#  else
+#   define SODIUM_EXPORT __declspec(dllimport)
+#  endif
+# else
+#  if defined(__SUNPRO_C)
+#   ifndef __GNU_C__
+#    define SODIUM_EXPORT __attribute__ (visibility(__global))
+#   else
+#    define SODIUM_EXPORT __attribute__ __global
+#   endif
+#  elif defined(_MSG_VER)
+#   define SODIUM_EXPORT extern __declspec(dllexport)
+#  else
+#   define SODIUM_EXPORT __attribute__ ((visibility ("default")))
+#  endif
+# endif
+# if defined(__ELF__) && !defined(SODIUM_DISABLE_WEAK_FUNCTIONS)
+#  define SODIUM_EXPORT_WEAK SODIUM_EXPORT __attribute__((weak))
+# else
+#  define SODIUM_EXPORT_WEAK SODIUM_EXPORT
+# endif
+#endif
+
+#ifndef CRYPTO_ALIGN
+# if defined(__INTEL_COMPILER) || defined(_MSC_VER)
+#  define CRYPTO_ALIGN(x) __declspec(align(x))
+# else
+#  define CRYPTO_ALIGN(x) __attribute__ ((aligned(x)))
+# endif
+#endif
+
+#define SODIUM_MIN(A, B) ((A) < (B) ? (A) : (B))
+#define SODIUM_SIZE_MAX SODIUM_MIN(UINT64_MAX, SIZE_MAX)
+
+#endif

src/3rdparty/sodium/private/common.h

@@ -0,0 +1,246 @@
+#ifndef common_H
+#define common_H 1
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define COMPILER_ASSERT(X) (void) sizeof(char[(X) ? 1 : -1])
+
+#ifdef HAVE_TI_MODE
+# if defined(__SIZEOF_INT128__)
+typedef unsigned __int128 uint128_t;
+# else
+typedef unsigned uint128_t __attribute__((mode(TI)));
+# endif
+#endif
+
+#define ROTL32(X, B) rotl32((X), (B))
+static inline uint32_t
+rotl32(const uint32_t x, const int b)
+{
+    return (x << b) | (x >> (32 - b));
+}
+
+#define ROTL64(X, B) rotl64((X), (B))
+static inline uint64_t
+rotl64(const uint64_t x, const int b)
+{
+    return (x << b) | (x >> (64 - b));
+}
+
+#define ROTR32(X, B) rotr32((X), (B))
+static inline uint32_t
+rotr32(const uint32_t x, const int b)
+{
+    return (x >> b) | (x << (32 - b));
+}
+
+#define ROTR64(X, B) rotr64((X), (B))
+static inline uint64_t
+rotr64(const uint64_t x, const int b)
+{
+    return (x >> b) | (x << (64 - b));
+}
+
+#define LOAD64_LE(SRC) load64_le(SRC)
+static inline uint64_t
+load64_le(const uint8_t src[8])
+{
+#ifdef NATIVE_LITTLE_ENDIAN
+    uint64_t w;
+    memcpy(&w, src, sizeof w);
+    return w;
+#else
+    uint64_t w = (uint64_t) src[0];
+    w |= (uint64_t) src[1] <<  8;
+    w |= (uint64_t) src[2] << 16;
+    w |= (uint64_t) src[3] << 24;
+    w |= (uint64_t) src[4] << 32;
+    w |= (uint64_t) src[5] << 40;
+    w |= (uint64_t) src[6] << 48;
+    w |= (uint64_t) src[7] << 56;
+    return w;
+#endif
+}
+
+#define STORE64_LE(DST, W) store64_le((DST), (W))
+static inline void
+store64_le(uint8_t dst[8], uint64_t w)
+{
+#ifdef NATIVE_LITTLE_ENDIAN
+    memcpy(dst, &w, sizeof w);
+#else
+    dst[0] = (uint8_t) w; w >>= 8;
+    dst[1] = (uint8_t) w; w >>= 8;
+    dst[2] = (uint8_t) w; w >>= 8;
+    dst[3] = (uint8_t) w; w >>= 8;
+    dst[4] = (uint8_t) w; w >>= 8;
+    dst[5] = (uint8_t) w; w >>= 8;
+    dst[6] = (uint8_t) w; w >>= 8;
+    dst[7] = (uint8_t) w;
+#endif
+}
+
+#define LOAD32_LE(SRC) load32_le(SRC)
+static inline uint32_t
+load32_le(const uint8_t src[4])
+{
+#ifdef NATIVE_LITTLE_ENDIAN
+    uint32_t w;
+    memcpy(&w, src, sizeof w);
+    return w;
+#else
+    uint32_t w = (uint32_t) src[0];
+    w |= (uint32_t) src[1] <<  8;
+    w |= (uint32_t) src[2] << 16;
+    w |= (uint32_t) src[3] << 24;
+    return w;
+#endif
+}
+
+#define STORE32_LE(DST, W) store32_le((DST), (W))
+static inline void
+store32_le(uint8_t dst[4], uint32_t w)
+{
+#ifdef NATIVE_LITTLE_ENDIAN
+    memcpy(dst, &w, sizeof w);
+#else
+    dst[0] = (uint8_t) w; w >>= 8;
+    dst[1] = (uint8_t) w; w >>= 8;
+    dst[2] = (uint8_t) w; w >>= 8;
+    dst[3] = (uint8_t) w;
+#endif
+}
+
+/* ----- */
+
+#define LOAD64_BE(SRC) load64_be(SRC)
+static inline uint64_t
+load64_be(const uint8_t src[8])
+{
+#ifdef NATIVE_BIG_ENDIAN
+    uint64_t w;
+    memcpy(&w, src, sizeof w);
+    return w;
+#else
+    uint64_t w = (uint64_t) src[7];
+    w |= (uint64_t) src[6] <<  8;
+    w |= (uint64_t) src[5] << 16;
+    w |= (uint64_t) src[4] << 24;
+    w |= (uint64_t) src[3] << 32;
+    w |= (uint64_t) src[2] << 40;
+    w |= (uint64_t) src[1] << 48;
+    w |= (uint64_t) src[0] << 56;
+    return w;
+#endif
+}
+
+#define STORE64_BE(DST, W) store64_be((DST), (W))
+static inline void
+store64_be(uint8_t dst[8], uint64_t w)
+{
+#ifdef NATIVE_BIG_ENDIAN
+    memcpy(dst, &w, sizeof w);
+#else
+    dst[7] = (uint8_t) w; w >>= 8;
+    dst[6] = (uint8_t) w; w >>= 8;
+    dst[5] = (uint8_t) w; w >>= 8;
+    dst[4] = (uint8_t) w; w >>= 8;
+    dst[3] = (uint8_t) w; w >>= 8;
+    dst[2] = (uint8_t) w; w >>= 8;
+    dst[1] = (uint8_t) w; w >>= 8;
+    dst[0] = (uint8_t) w;
+#endif
+}
+
+#define LOAD32_BE(SRC) load32_be(SRC)
+static inline uint32_t
+load32_be(const uint8_t src[4])
+{
+#ifdef NATIVE_BIG_ENDIAN
+    uint32_t w;
+    memcpy(&w, src, sizeof w);
+    return w;
+#else
+    uint32_t w = (uint32_t) src[3];
+    w |= (uint32_t) src[2] <<  8;
+    w |= (uint32_t) src[1] << 16;
+    w |= (uint32_t) src[0] << 24;
+    return w;
+#endif
+}
+
+#define STORE32_BE(DST, W) store32_be((DST), (W))
+static inline void
+store32_be(uint8_t dst[4], uint32_t w)
+{
+#ifdef NATIVE_BIG_ENDIAN
+    memcpy(dst, &w, sizeof w);
+#else
+    dst[3] = (uint8_t) w; w >>= 8;
+    dst[2] = (uint8_t) w; w >>= 8;
+    dst[1] = (uint8_t) w; w >>= 8;
+    dst[0] = (uint8_t) w;
+#endif
+}
+
+#define XOR_BUF(OUT, IN, N) xor_buf((OUT), (IN), (N))
+static inline void
+xor_buf(unsigned char *out, const unsigned char *in, size_t n)
+{
+    size_t i;
+
+    for (i = 0; i < n; i++) {
+        out[i] ^= in[i];
+    }
+}
+
+#ifndef __GNUC__
+# ifdef __attribute__
+#  undef __attribute__
+# endif
+# define __attribute__(a)
+#endif
+
+#ifndef CRYPTO_ALIGN
+# if defined(__INTEL_COMPILER) || defined(_MSC_VER)
+#  define CRYPTO_ALIGN(x) __declspec(align(x))
+# else
+#  define CRYPTO_ALIGN(x) __attribute__ ((aligned(x)))
+# endif
+#endif
+
+#if defined(_MSC_VER) && \
+    (defined(_M_X64) || defined(_M_AMD64) || defined(_M_IX86))
+
+# include <intrin.h>
+
+# define HAVE_INTRIN_H    1
+# define HAVE_MMINTRIN_H  1
+# define HAVE_EMMINTRIN_H 1
+# define HAVE_PMMINTRIN_H 1
+# define HAVE_TMMINTRIN_H 1
+# define HAVE_SMMINTRIN_H 1
+# define HAVE_AVXINTRIN_H 1
+# if _MSC_VER >= 1600
+#  define HAVE_WMMINTRIN_H 1
+# endif
+# if _MSC_VER >= 1700 && defined(_M_X64)
+#  define HAVE_AVX2INTRIN_H 1
+# endif
+#elif defined(HAVE_INTRIN_H)
+# include <intrin.h>
+#endif
+
+#ifdef HAVE_LIBCTGRIND
+extern void ct_poison  (const void *, size_t);
+extern void ct_unpoison(const void *, size_t);
+# define POISON(X, L)   ct_poison((X), (L))
+# define UNPOISON(X, L) ct_unpoison((X), (L))
+#else
+# define POISON(X, L)   (void) 0
+# define UNPOISON(X, L) (void) 0
+#endif
+
+#endif

src/3rdparty/sodium/private/ed25519_ref10.h

@@ -0,0 +1,125 @@
+#ifndef ed25519_ref10_H
+#define ed25519_ref10_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+/*
+ fe means field element.
+ Here the field is \Z/(2^255-19).
+ */
+
+#ifdef HAVE_TI_MODE
+typedef uint64_t fe25519[5];
+#else
+typedef int32_t fe25519[10];
+#endif
+
+void fe25519_invert(fe25519 out, const fe25519 z);
+void fe25519_frombytes(fe25519 h, const unsigned char *s);
+void fe25519_tobytes(unsigned char *s, const fe25519 h);
+
+#ifdef HAVE_TI_MODE
+# include "ed25519_ref10_fe_51.h"
+#else
+# include "ed25519_ref10_fe_25_5.h"
+#endif
+
+
+/*
+ ge means group element.
+
+ Here the group is the set of pairs (x,y) of field elements
+ satisfying -x^2 + y^2 = 1 + d x^2y^2
+ where d = -121665/121666.
+
+ Representations:
+ ge25519_p2 (projective): (X:Y:Z) satisfying x=X/Z, y=Y/Z
+ ge25519_p3 (extended): (X:Y:Z:T) satisfying x=X/Z, y=Y/Z, XY=ZT
+ ge25519_p1p1 (completed): ((X:Z),(Y:T)) satisfying x=X/Z, y=Y/T
+ ge25519_precomp (Duif): (y+x,y-x,2dxy)
+ */
+
+typedef struct {
+    fe25519 X;
+    fe25519 Y;
+    fe25519 Z;
+} ge25519_p2;
+
+typedef struct {
+    fe25519 X;
+    fe25519 Y;
+    fe25519 Z;
+    fe25519 T;
+} ge25519_p3;
+
+typedef struct {
+    fe25519 X;
+    fe25519 Y;
+    fe25519 Z;
+    fe25519 T;
+} ge25519_p1p1;
+
+typedef struct {
+    fe25519 yplusx;
+    fe25519 yminusx;
+    fe25519 xy2d;
+} ge25519_precomp;
+
+typedef struct {
+    fe25519 YplusX;
+    fe25519 YminusX;
+    fe25519 Z;
+    fe25519 T2d;
+} ge25519_cached;
+
+void ge25519_tobytes(unsigned char *s, const ge25519_p2 *h);
+
+void ge25519_p3_tobytes(unsigned char *s, const ge25519_p3 *h);
+
+int ge25519_frombytes(ge25519_p3 *h, const unsigned char *s);
+
+int ge25519_frombytes_negate_vartime(ge25519_p3 *h, const unsigned char *s);
+
+void ge25519_p3_to_cached(ge25519_cached *r, const ge25519_p3 *p);
+
+void ge25519_p1p1_to_p2(ge25519_p2 *r, const ge25519_p1p1 *p);
+
+void ge25519_p1p1_to_p3(ge25519_p3 *r, const ge25519_p1p1 *p);
+
+void ge25519_add(ge25519_p1p1 *r, const ge25519_p3 *p, const ge25519_cached *q);
+
+void ge25519_sub(ge25519_p1p1 *r, const ge25519_p3 *p, const ge25519_cached *q);
+
+void ge25519_scalarmult_base(ge25519_p3 *h, const unsigned char *a);
+
+void ge25519_double_scalarmult_vartime(ge25519_p2 *r, const unsigned char *a,
+                                       const ge25519_p3 *A,
+                                       const unsigned char *b);
+
+void ge25519_scalarmult(ge25519_p3 *h, const unsigned char *a,
+                        const ge25519_p3 *p);
+
+int ge25519_is_canonical(const unsigned char *s);
+
+int ge25519_is_on_curve(const ge25519_p3 *p);
+
+int ge25519_is_on_main_subgroup(const ge25519_p3 *p);
+
+int ge25519_has_small_order(const unsigned char s[32]);
+
+void ge25519_from_uniform(unsigned char s[32], const unsigned char r[32]);
+
+/*
+ The set of scalars is \Z/l
+ where l = 2^252 + 27742317777372353535851937790883648493.
+ */
+
+void sc25519_reduce(unsigned char *s);
+
+void sc25519_muladd(unsigned char *s, const unsigned char *a,
+                    const unsigned char *b, const unsigned char *c);
+
+int sc25519_is_canonical(const unsigned char *s);
+
+#endif

src/3rdparty/sodium/private/ed25519_ref10_fe_51.h

@@ -0,0 +1,518 @@
+#include <string.h>
+
+#include "private/common.h"
+#include "utils.h"
+
+/*
+ h = 0
+ */
+
+static inline void
+fe25519_0(fe25519 h)
+{
+    memset(&h[0], 0, 5 * sizeof h[0]);
+}
+
+/*
+ h = 1
+ */
+
+static inline void
+fe25519_1(fe25519 h)
+{
+    h[0] = 1;
+    memset(&h[1], 0, 4 * sizeof h[0]);
+}
+
+/*
+ h = f + g
+ Can overlap h with f or g.
+ */
+
+static inline void
+fe25519_add(fe25519 h, const fe25519 f, const fe25519 g)
+{
+    uint64_t h0 = f[0] + g[0];
+    uint64_t h1 = f[1] + g[1];
+    uint64_t h2 = f[2] + g[2];
+    uint64_t h3 = f[3] + g[3];
+    uint64_t h4 = f[4] + g[4];
+
+    h[0] = h0;
+    h[1] = h1;
+    h[2] = h2;
+    h[3] = h3;
+    h[4] = h4;
+}
+
+/*
+ h = f - g
+ */
+
+static void
+fe25519_sub(fe25519 h, const fe25519 f, const fe25519 g)
+{
+    const uint64_t mask = 0x7ffffffffffffULL;
+    uint64_t h0, h1, h2, h3, h4;
+
+    h0 = g[0];
+    h1 = g[1];
+    h2 = g[2];
+    h3 = g[3];
+    h4 = g[4];
+
+    h1 += h0 >> 51;
+    h0 &= mask;
+    h2 += h1 >> 51;
+    h1 &= mask;
+    h3 += h2 >> 51;
+    h2 &= mask;
+    h4 += h3 >> 51;
+    h3 &= mask;
+    h0 += 19ULL * (h4 >> 51);
+    h4 &= mask;
+
+    h0 = (f[0] + 0xfffffffffffdaULL) - h0;
+    h1 = (f[1] + 0xffffffffffffeULL) - h1;
+    h2 = (f[2] + 0xffffffffffffeULL) - h2;
+    h3 = (f[3] + 0xffffffffffffeULL) - h3;
+    h4 = (f[4] + 0xffffffffffffeULL) - h4;
+
+    h[0] = h0;
+    h[1] = h1;
+    h[2] = h2;
+    h[3] = h3;
+    h[4] = h4;
+}
+
+/*
+ h = -f
+ */
+
+static inline void
+fe25519_neg(fe25519 h, const fe25519 f)
+{
+    fe25519 zero;
+
+    fe25519_0(zero);
+    fe25519_sub(h, zero, f);
+}
+
+/*
+ Replace (f,g) with (g,g) if b == 1;
+ replace (f,g) with (f,g) if b == 0.
+ *
+ Preconditions: b in {0,1}.
+ */
+
+static void
+fe25519_cmov(fe25519 f, const fe25519 g, unsigned int b)
+{
+    const uint64_t mask = (uint64_t) (-(int64_t) b);
+
+    uint64_t f0 = f[0];
+    uint64_t f1 = f[1];
+    uint64_t f2 = f[2];
+    uint64_t f3 = f[3];
+    uint64_t f4 = f[4];
+
+    uint64_t x0 = f0 ^ g[0];
+    uint64_t x1 = f1 ^ g[1];
+    uint64_t x2 = f2 ^ g[2];
+    uint64_t x3 = f3 ^ g[3];
+    uint64_t x4 = f4 ^ g[4];
+
+    x0 &= mask;
+    x1 &= mask;
+    x2 &= mask;
+    x3 &= mask;
+    x4 &= mask;
+
+    f[0] = f0 ^ x0;
+    f[1] = f1 ^ x1;
+    f[2] = f2 ^ x2;
+    f[3] = f3 ^ x3;
+    f[4] = f4 ^ x4;
+}
+
+/*
+Replace (f,g) with (g,f) if b == 1;
+replace (f,g) with (f,g) if b == 0.
+
+Preconditions: b in {0,1}.
+*/
+
+static void
+fe25519_cswap(fe25519 f, fe25519 g, unsigned int b)
+{
+    const uint64_t mask = (uint64_t) (-(int64_t) b);
+
+    uint64_t f0 = f[0];
+    uint64_t f1 = f[1];
+    uint64_t f2 = f[2];
+    uint64_t f3 = f[3];
+    uint64_t f4 = f[4];
+
+    uint64_t g0 = g[0];
+    uint64_t g1 = g[1];
+    uint64_t g2 = g[2];
+    uint64_t g3 = g[3];
+    uint64_t g4 = g[4];
+
+    uint64_t x0 = f0 ^ g0;
+    uint64_t x1 = f1 ^ g1;
+    uint64_t x2 = f2 ^ g2;
+    uint64_t x3 = f3 ^ g3;
+    uint64_t x4 = f4 ^ g4;
+
+    x0 &= mask;
+    x1 &= mask;
+    x2 &= mask;
+    x3 &= mask;
+    x4 &= mask;
+
+    f[0] = f0 ^ x0;
+    f[1] = f1 ^ x1;
+    f[2] = f2 ^ x2;
+    f[3] = f3 ^ x3;
+    f[4] = f4 ^ x4;
+
+    g[0] = g0 ^ x0;
+    g[1] = g1 ^ x1;
+    g[2] = g2 ^ x2;
+    g[3] = g3 ^ x3;
+    g[4] = g4 ^ x4;
+}
+
+/*
+ h = f
+ */
+
+static inline void
+fe25519_copy(fe25519 h, const fe25519 f)
+{
+    uint64_t f0 = f[0];
+    uint64_t f1 = f[1];
+    uint64_t f2 = f[2];
+    uint64_t f3 = f[3];
+    uint64_t f4 = f[4];
+
+    h[0] = f0;
+    h[1] = f1;
+    h[2] = f2;
+    h[3] = f3;
+    h[4] = f4;
+}
+
+/*
+ return 1 if f is in {1,3,5,...,q-2}
+ return 0 if f is in {0,2,4,...,q-1}
+ */
+
+static inline int
+fe25519_isnegative(const fe25519 f)
+{
+    unsigned char s[32];
+
+    fe25519_tobytes(s, f);
+
+    return s[0] & 1;
+}
+
+/*
+ return 1 if f == 0
+ return 0 if f != 0
+ */
+
+static inline int
+fe25519_iszero(const fe25519 f)
+{
+    unsigned char s[32];
+
+    fe25519_tobytes(s, f);
+
+    return sodium_is_zero(s, 32);
+}
+
+/*
+ h = f * g
+ Can overlap h with f or g.
+ */
+
+static void
+fe25519_mul(fe25519 h, const fe25519 f, const fe25519 g)
+{
+    const uint64_t mask = 0x7ffffffffffffULL;
+    uint128_t r0, r1, r2, r3, r4, carry;
+    uint64_t  f0, f1, f2, f3, f4;
+    uint64_t  f1_19, f2_19, f3_19, f4_19;
+    uint64_t  g0, g1, g2, g3, g4;
+    uint64_t  r00, r01, r02, r03, r04;
+
+    f0 = f[0];
+    f1 = f[1];
+    f2 = f[2];
+    f3 = f[3];
+    f4 = f[4];
+
+    g0 = g[0];
+    g1 = g[1];
+    g2 = g[2];
+    g3 = g[3];
+    g4 = g[4];
+
+    f1_19 = 19ULL * f1;
+    f2_19 = 19ULL * f2;
+    f3_19 = 19ULL * f3;
+    f4_19 = 19ULL * f4;
+
+    r0  = ((uint128_t) f0   ) * ((uint128_t) g0);
+    r0 += ((uint128_t) f1_19) * ((uint128_t) g4);
+    r0 += ((uint128_t) f2_19) * ((uint128_t) g3);
+    r0 += ((uint128_t) f3_19) * ((uint128_t) g2);
+    r0 += ((uint128_t) f4_19) * ((uint128_t) g1);
+
+    r1  = ((uint128_t) f0   ) * ((uint128_t) g1);
+    r1 += ((uint128_t) f1   ) * ((uint128_t) g0);
+    r1 += ((uint128_t) f2_19) * ((uint128_t) g4);
+    r1 += ((uint128_t) f3_19) * ((uint128_t) g3);
+    r1 += ((uint128_t) f4_19) * ((uint128_t) g2);
+
+    r2  = ((uint128_t) f0   ) * ((uint128_t) g2);
+    r2 += ((uint128_t) f1   ) * ((uint128_t) g1);
+    r2 += ((uint128_t) f2   ) * ((uint128_t) g0);
+    r2 += ((uint128_t) f3_19) * ((uint128_t) g4);
+    r2 += ((uint128_t) f4_19) * ((uint128_t) g3);
+
+    r3  = ((uint128_t) f0   ) * ((uint128_t) g3);
+    r3 += ((uint128_t) f1   ) * ((uint128_t) g2);
+    r3 += ((uint128_t) f2   ) * ((uint128_t) g1);
+    r3 += ((uint128_t) f3   ) * ((uint128_t) g0);
+    r3 += ((uint128_t) f4_19) * ((uint128_t) g4);
+
+    r4  = ((uint128_t) f0   ) * ((uint128_t) g4);
+    r4 += ((uint128_t) f1   ) * ((uint128_t) g3);
+    r4 += ((uint128_t) f2   ) * ((uint128_t) g2);
+    r4 += ((uint128_t) f3   ) * ((uint128_t) g1);
+    r4 += ((uint128_t) f4   ) * ((uint128_t) g0);
+
+    r00    = ((uint64_t) r0) & mask;
+    carry  = r0 >> 51;
+    r1    += carry;
+    r01    = ((uint64_t) r1) & mask;
+    carry  = r1 >> 51;
+    r2    += carry;
+    r02    = ((uint64_t) r2) & mask;
+    carry  = r2 >> 51;
+    r3    += carry;
+    r03    = ((uint64_t) r3) & mask;
+    carry  = r3 >> 51;
+    r4    += carry;
+    r04    = ((uint64_t) r4) & mask;
+    carry  = r4 >> 51;
+    r00   += 19ULL * (uint64_t) carry;
+    carry  = r00 >> 51;
+    r00   &= mask;
+    r01   += (uint64_t) carry;
+    carry  = r01 >> 51;
+    r01   &= mask;
+    r02   += (uint64_t) carry;
+
+    h[0] = r00;
+    h[1] = r01;
+    h[2] = r02;
+    h[3] = r03;
+    h[4] = r04;
+}
+
+/*
+ h = f * f
+ Can overlap h with f.
+ */
+
+static void
+fe25519_sq(fe25519 h, const fe25519 f)
+{
+    const uint64_t mask = 0x7ffffffffffffULL;
+    uint128_t r0, r1, r2, r3, r4, carry;
+    uint64_t  f0, f1, f2, f3, f4;
+    uint64_t  f0_2, f1_2, f1_38, f2_38, f3_38, f3_19, f4_19;
+    uint64_t  r00, r01, r02, r03, r04;
+
+    f0 = f[0];
+    f1 = f[1];
+    f2 = f[2];
+    f3 = f[3];
+    f4 = f[4];
+
+    f0_2 = f0 << 1;
+    f1_2 = f1 << 1;
+
+    f1_38 = 38ULL * f1;
+    f2_38 = 38ULL * f2;
+    f3_38 = 38ULL * f3;
+
+    f3_19 = 19ULL * f3;
+    f4_19 = 19ULL * f4;
+
+    r0  = ((uint128_t) f0   ) * ((uint128_t) f0);
+    r0 += ((uint128_t) f1_38) * ((uint128_t) f4);
+    r0 += ((uint128_t) f2_38) * ((uint128_t) f3);
+
+    r1  = ((uint128_t) f0_2 ) * ((uint128_t) f1);
+    r1 += ((uint128_t) f2_38) * ((uint128_t) f4);
+    r1 += ((uint128_t) f3_19) * ((uint128_t) f3);
+
+    r2  = ((uint128_t) f0_2 ) * ((uint128_t) f2);
+    r2 += ((uint128_t) f1   ) * ((uint128_t) f1);
+    r2 += ((uint128_t) f3_38) * ((uint128_t) f4);
+
+    r3  = ((uint128_t) f0_2 ) * ((uint128_t) f3);
+    r3 += ((uint128_t) f1_2 ) * ((uint128_t) f2);
+    r3 += ((uint128_t) f4_19) * ((uint128_t) f4);
+
+    r4  = ((uint128_t) f0_2 ) * ((uint128_t) f4);
+    r4 += ((uint128_t) f1_2 ) * ((uint128_t) f3);
+    r4 += ((uint128_t) f2   ) * ((uint128_t) f2);
+
+    r00    = ((uint64_t) r0) & mask;
+    carry  = r0 >> 51;
+    r1    += carry;
+    r01    = ((uint64_t) r1) & mask;
+    carry  = r1 >> 51;
+    r2    += carry;
+    r02    = ((uint64_t) r2) & mask;
+    carry  = r2 >> 51;
+    r3    += carry;
+    r03    = ((uint64_t) r3) & mask;
+    carry  = r3 >> 51;
+    r4    += carry;
+    r04    = ((uint64_t) r4) & mask;
+    carry  = r4 >> 51;
+    r00   += 19ULL * (uint64_t) carry;
+    carry  = r00 >> 51;
+    r00   &= mask;
+    r01   += (uint64_t) carry;
+    carry  = r01 >> 51;
+    r01   &= mask;
+    r02   += (uint64_t) carry;
+
+    h[0] = r00;
+    h[1] = r01;
+    h[2] = r02;
+    h[3] = r03;
+    h[4] = r04;
+}
+
+/*
+ h = 2 * f * f
+ Can overlap h with f.
+*/
+
+static void
+fe25519_sq2(fe25519 h, const fe25519 f)
+{
+    const uint64_t mask = 0x7ffffffffffffULL;
+    uint128_t r0, r1, r2, r3, r4, carry;
+    uint64_t  f0, f1, f2, f3, f4;
+    uint64_t  f0_2, f1_2, f1_38, f2_38, f3_38, f3_19, f4_19;
+    uint64_t  r00, r01, r02, r03, r04;
+
+    f0 = f[0];
+    f1 = f[1];
+    f2 = f[2];
+    f3 = f[3];
+    f4 = f[4];
+
+    f0_2 = f0 << 1;
+    f1_2 = f1 << 1;
+
+    f1_38 = 38ULL * f1;
+    f2_38 = 38ULL * f2;
+    f3_38 = 38ULL * f3;
+
+    f3_19 = 19ULL * f3;
+    f4_19 = 19ULL * f4;
+
+    r0  = ((uint128_t) f0   ) * ((uint128_t) f0);
+    r0 += ((uint128_t) f1_38) * ((uint128_t) f4);
+    r0 += ((uint128_t) f2_38) * ((uint128_t) f3);
+
+    r1  = ((uint128_t) f0_2 ) * ((uint128_t) f1);
+    r1 += ((uint128_t) f2_38) * ((uint128_t) f4);
+    r1 += ((uint128_t) f3_19) * ((uint128_t) f3);
+
+    r2  = ((uint128_t) f0_2 ) * ((uint128_t) f2);
+    r2 += ((uint128_t) f1   ) * ((uint128_t) f1);
+    r2 += ((uint128_t) f3_38) * ((uint128_t) f4);
+
+    r3  = ((uint128_t) f0_2 ) * ((uint128_t) f3);
+    r3 += ((uint128_t) f1_2 ) * ((uint128_t) f2);
+    r3 += ((uint128_t) f4_19) * ((uint128_t) f4);
+
+    r4  = ((uint128_t) f0_2 ) * ((uint128_t) f4);
+    r4 += ((uint128_t) f1_2 ) * ((uint128_t) f3);
+    r4 += ((uint128_t) f2   ) * ((uint128_t) f2);
+
+    r0 <<= 1;
+    r1 <<= 1;
+    r2 <<= 1;
+    r3 <<= 1;
+    r4 <<= 1;
+
+    r00    = ((uint64_t) r0) & mask;
+    carry  = r0 >> 51;
+    r1    += carry;
+    r01    = ((uint64_t) r1) & mask;
+    carry  = r1 >> 51;
+    r2    += carry;
+    r02    = ((uint64_t) r2) & mask;
+    carry  = r2 >> 51;
+    r3    += carry;
+    r03    = ((uint64_t) r3) & mask;
+    carry  = r3 >> 51;
+    r4    += carry;
+    r04    = ((uint64_t) r4) & mask;
+    carry  = r4 >> 51;
+    r00   += 19ULL * (uint64_t) carry;
+    carry  = r00 >> 51;
+    r00   &= mask;
+    r01   += (uint64_t) carry;
+    carry  = r01 >> 51;
+    r01   &= mask;
+    r02   += (uint64_t) carry;
+
+    h[0] = r00;
+    h[1] = r01;
+    h[2] = r02;
+    h[3] = r03;
+    h[4] = r04;
+}
+
+static void
+fe25519_scalar_product(fe25519 h, const fe25519 f, uint32_t n)
+{
+    const uint64_t mask = 0x7ffffffffffffULL;
+    uint128_t a;
+    uint128_t sn = (uint128_t) n;
+    uint64_t  h0, h1, h2, h3, h4;
+
+    a  = f[0] * sn;
+    h0 = ((uint64_t) a) & mask;
+    a  = f[1] * sn + ((uint64_t) (a >> 51));
+    h1 = ((uint64_t) a) & mask;
+    a  = f[2] * sn + ((uint64_t) (a >> 51));
+    h2 = ((uint64_t) a) & mask;
+    a  = f[3] * sn + ((uint64_t) (a >> 51));
+    h3 = ((uint64_t) a) & mask;
+    a  = f[4] * sn + ((uint64_t) (a >> 51));
+    h4 = ((uint64_t) a) & mask;
+
+    h0 += (a >> 51) * 19ULL;
+
+    h[0] = h0;
+    h[1] = h1;
+    h[2] = h2;
+    h[3] = h3;
+    h[4] = h4;
+}

src/3rdparty/sodium/private/implementations.h

@@ -0,0 +1,11 @@
+#ifndef implementations_H
+#define implementations_H
+
+int _crypto_generichash_blake2b_pick_best_implementation(void);
+int _crypto_onetimeauth_poly1305_pick_best_implementation(void);
+int _crypto_pwhash_argon2_pick_best_implementation(void);
+int _crypto_scalarmult_curve25519_pick_best_implementation(void);
+int _crypto_stream_chacha20_pick_best_implementation(void);
+int _crypto_stream_salsa20_pick_best_implementation(void);
+
+#endif

src/3rdparty/sodium/private/mutex.h

@@ -0,0 +1,7 @@
+#ifndef mutex_H
+#define mutex_H 1
+
+extern int sodium_crit_enter(void);
+extern int sodium_crit_leave(void);
+
+#endif

src/3rdparty/sodium/private/sse2_64_32.h

@@ -0,0 +1,50 @@
+#ifndef sse2_64_32_H
+#define sse2_64_32_H 1
+
+#include "common.h"
+
+#ifdef HAVE_INTRIN_H
+# include <intrin.h>
+#endif
+
+#if defined(HAVE_EMMINTRIN_H) && \
+    !(defined(__amd64) || defined(__amd64__) || defined(__x86_64__) || \
+      defined(_M_X64) || defined(_M_AMD64))
+
+# include <emmintrin.h>
+# include <stdint.h>
+
+# ifndef _mm_set_epi64x
+#  define _mm_set_epi64x(Q0, Q1) sodium__mm_set_epi64x((Q0), (Q1))
+static inline __m128i
+sodium__mm_set_epi64x(int64_t q1, int64_t q0)
+{
+    union { int64_t as64; int32_t as32[2]; } x0, x1;
+    x0.as64 = q0; x1.as64 = q1;
+    return _mm_set_epi32(x1.as32[1], x1.as32[0], x0.as32[1], x0.as32[0]);
+}
+# endif
+
+# ifndef _mm_set1_epi64x
+#  define _mm_set1_epi64x(Q) sodium__mm_set1_epi64x(Q)
+static inline __m128i
+sodium__mm_set1_epi64x(int64_t q)
+{
+    return _mm_set_epi64x(q, q);
+}
+# endif
+
+# ifndef _mm_cvtsi64_si128
+#  define _mm_cvtsi64_si128(Q) sodium__mm_cvtsi64_si128(Q)
+static inline __m128i
+sodium__mm_cvtsi64_si128(int64_t q)
+{
+    union { int64_t as64; int32_t as32[2]; } x;
+    x.as64 = q;
+    return _mm_setr_epi32(x.as32[0], x.as32[1], 0, 0);
+}
+# endif
+
+#endif
+
+#endif

src/3rdparty/sodium/randombytes.h

@@ -0,0 +1,68 @@
+
+#ifndef randombytes_H
+#define randombytes_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <sys/types.h>
+
+#include "export.h"
+
+#ifdef __cplusplus
+# ifdef __GNUC__
+#  pragma GCC diagnostic ignored "-Wlong-long"
+# endif
+extern "C" {
+#endif
+
+typedef struct randombytes_implementation {
+    const char *(*implementation_name)(void); /* required */
+    uint32_t    (*random)(void);              /* required */
+    void        (*stir)(void);                /* optional */
+    uint32_t    (*uniform)(const uint32_t upper_bound); /* optional, a default implementation will be used if NULL */
+    void        (*buf)(void * const buf, const size_t size); /* required */
+    int         (*close)(void);               /* optional */
+} randombytes_implementation;
+
+#define randombytes_BYTES_MAX SODIUM_MIN(SODIUM_SIZE_MAX, 0xffffffffUL)
+
+#define randombytes_SEEDBYTES 32U
+SODIUM_EXPORT
+size_t randombytes_seedbytes(void);
+
+SODIUM_EXPORT
+void randombytes_buf(void * const buf, const size_t size);
+
+SODIUM_EXPORT
+void randombytes_buf_deterministic(void * const buf, const size_t size,
+                                   const unsigned char seed[randombytes_SEEDBYTES]);
+
+SODIUM_EXPORT
+uint32_t randombytes_random(void);
+
+SODIUM_EXPORT
+uint32_t randombytes_uniform(const uint32_t upper_bound);
+
+SODIUM_EXPORT
+void randombytes_stir(void);
+
+SODIUM_EXPORT
+int randombytes_close(void);
+
+SODIUM_EXPORT
+int randombytes_set_implementation(randombytes_implementation *impl);
+
+SODIUM_EXPORT
+const char *randombytes_implementation_name(void);
+
+/* -- NaCl compatibility interface -- */
+
+SODIUM_EXPORT
+void randombytes(unsigned char * const buf, const unsigned long long buf_len);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/3rdparty/sodium/randombytes_nativeclient.h

@@ -0,0 +1,23 @@
+
+#ifndef randombytes_nativeclient_H
+#define randombytes_nativeclient_H
+
+#ifdef __native_client__
+
+# include "export.h"
+# include "randombytes.h"
+
+# ifdef __cplusplus
+extern "C" {
+# endif
+
+SODIUM_EXPORT
+extern struct randombytes_implementation randombytes_nativeclient_implementation;
+
+# ifdef __cplusplus
+}
+# endif
+
+#endif
+
+#endif

src/3rdparty/sodium/randombytes_salsa20_random.h

@@ -0,0 +1,19 @@
+
+#ifndef randombytes_salsa20_random_H
+#define randombytes_salsa20_random_H
+
+#include "export.h"
+#include "randombytes.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+SODIUM_EXPORT
+extern struct randombytes_implementation randombytes_salsa20_implementation;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/3rdparty/sodium/randombytes_sysrandom.h

@@ -0,0 +1,19 @@
+
+#ifndef randombytes_sysrandom_H
+#define randombytes_sysrandom_H
+
+#include "export.h"
+#include "randombytes.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+SODIUM_EXPORT
+extern struct randombytes_implementation randombytes_sysrandom_implementation;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/3rdparty/sodium/runtime.h

@@ -0,0 +1,52 @@
+
+#ifndef sodium_runtime_H
+#define sodium_runtime_H
+
+#include "export.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+SODIUM_EXPORT_WEAK
+int sodium_runtime_has_neon(void);
+
+SODIUM_EXPORT_WEAK
+int sodium_runtime_has_sse2(void);
+
+SODIUM_EXPORT_WEAK
+int sodium_runtime_has_sse3(void);
+
+SODIUM_EXPORT_WEAK
+int sodium_runtime_has_ssse3(void);
+
+SODIUM_EXPORT_WEAK
+int sodium_runtime_has_sse41(void);
+
+SODIUM_EXPORT_WEAK
+int sodium_runtime_has_avx(void);
+
+SODIUM_EXPORT_WEAK
+int sodium_runtime_has_avx2(void);
+
+SODIUM_EXPORT_WEAK
+int sodium_runtime_has_avx512f(void);
+
+SODIUM_EXPORT_WEAK
+int sodium_runtime_has_pclmul(void);
+
+SODIUM_EXPORT_WEAK
+int sodium_runtime_has_aesni(void);
+
+SODIUM_EXPORT_WEAK
+int sodium_runtime_has_rdrand(void);
+
+/* ------------------------------------------------------------------------- */
+
+int _sodium_runtime_get_cpu_features(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/3rdparty/sodium/utils.h

@@ -0,0 +1,170 @@
+
+#ifndef sodium_utils_H
+#define sodium_utils_H
+
+#include <stddef.h>
+
+#include "export.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef SODIUM_C99
+# if defined(__cplusplus) || !defined(__STDC_VERSION__) || __STDC_VERSION__ < 199901L
+#  define SODIUM_C99(X)
+# else
+#  define SODIUM_C99(X) X
+# endif
+#endif
+
+SODIUM_EXPORT
+void sodium_memzero(void * const pnt, const size_t len);
+
+SODIUM_EXPORT
+void sodium_stackzero(const size_t len);
+
+/*
+ * WARNING: sodium_memcmp() must be used to verify if two secret keys
+ * are equal, in constant time.
+ * It returns 0 if the keys are equal, and -1 if they differ.
+ * This function is not designed for lexicographical comparisons.
+ */
+SODIUM_EXPORT
+int sodium_memcmp(const void * const b1_, const void * const b2_, size_t len)
+            __attribute__ ((warn_unused_result));
+
+/*
+ * sodium_compare() returns -1 if b1_ < b2_, 1 if b1_ > b2_ and 0 if b1_ == b2_
+ * It is suitable for lexicographical comparisons, or to compare nonces
+ * and counters stored in little-endian format.
+ * However, it is slower than sodium_memcmp().
+ */
+SODIUM_EXPORT
+int sodium_compare(const unsigned char *b1_, const unsigned char *b2_,
+                   size_t len)
+            __attribute__ ((warn_unused_result));
+
+SODIUM_EXPORT
+int sodium_is_zero(const unsigned char *n, const size_t nlen);
+
+SODIUM_EXPORT
+void sodium_increment(unsigned char *n, const size_t nlen);
+
+SODIUM_EXPORT
+void sodium_add(unsigned char *a, const unsigned char *b, const size_t len);
+
+SODIUM_EXPORT
+char *sodium_bin2hex(char * const hex, const size_t hex_maxlen,
+                     const unsigned char * const bin, const size_t bin_len);
+
+SODIUM_EXPORT
+int sodium_hex2bin(unsigned char * const bin, const size_t bin_maxlen,
+                   const char * const hex, const size_t hex_len,
+                   const char * const ignore, size_t * const bin_len,
+                   const char ** const hex_end);
+
+#define sodium_base64_VARIANT_ORIGINAL            1
+#define sodium_base64_VARIANT_ORIGINAL_NO_PADDING 3
+#define sodium_base64_VARIANT_URLSAFE             5
+#define sodium_base64_VARIANT_URLSAFE_NO_PADDING  7
+
+/*
+ * Computes the required length to encode BIN_LEN bytes as a base64 string
+ * using the given variant. The computed length includes a trailing \0.
+ */
+#define sodium_base64_ENCODED_LEN(BIN_LEN, VARIANT) \
+    (((BIN_LEN) / 3U) * 4U + \
+    ((((BIN_LEN) - ((BIN_LEN) / 3U) * 3U) | (((BIN_LEN) - ((BIN_LEN) / 3U) * 3U) >> 1)) & 1U) * \
+     (4U - (~((((VARIANT) & 2U) >> 1) - 1U) & (3U - ((BIN_LEN) - ((BIN_LEN) / 3U) * 3U)))) + 1U)
+
+SODIUM_EXPORT
+size_t sodium_base64_encoded_len(const size_t bin_len, const int variant);
+
+SODIUM_EXPORT
+char *sodium_bin2base64(char * const b64, const size_t b64_maxlen,
+                        const unsigned char * const bin, const size_t bin_len,
+                        const int variant);
+
+SODIUM_EXPORT
+int sodium_base642bin(unsigned char * const bin, const size_t bin_maxlen,
+                      const char * const b64, const size_t b64_len,
+                      const char * const ignore, size_t * const bin_len,
+                      const char ** const b64_end, const int variant);
+
+SODIUM_EXPORT
+int sodium_mlock(void * const addr, const size_t len);
+
+SODIUM_EXPORT
+int sodium_munlock(void * const addr, const size_t len);
+
+/* WARNING: sodium_malloc() and sodium_allocarray() are not general-purpose
+ * allocation functions.
+ *
+ * They return a pointer to a region filled with 0xd0 bytes, immediately
+ * followed by a guard page.
+ * As a result, accessing a single byte after the requested allocation size
+ * will intentionally trigger a segmentation fault.
+ *
+ * A canary and an additional guard page placed before the beginning of the
+ * region may also kill the process if a buffer underflow is detected.
+ *
+ * The memory layout is:
+ * [unprotected region size (read only)][guard page (no access)][unprotected pages (read/write)][guard page (no access)]
+ * With the layout of the unprotected pages being:
+ * [optional padding][16-bytes canary][user region]
+ *
+ * However:
+ * - These functions are significantly slower than standard functions
+ * - Each allocation requires 3 or 4 additional pages
+ * - The returned address will not be aligned if the allocation size is not
+ *   a multiple of the required alignment. For this reason, these functions
+ *   are designed to store data, such as secret keys and messages.
+ *
+ * sodium_malloc() can be used to allocate any libsodium data structure.
+ *
+ * The crypto_generichash_state structure is packed and its length is
+ * either 357 or 361 bytes. For this reason, when using sodium_malloc() to
+ * allocate a crypto_generichash_state structure, padding must be added in
+ * order to ensure proper alignment. crypto_generichash_statebytes()
+ * returns the rounded up structure size, and should be prefered to sizeof():
+ * state = sodium_malloc(crypto_generichash_statebytes());
+ */
+
+SODIUM_EXPORT
+void *sodium_malloc(const size_t size)
+            __attribute__ ((malloc));
+
+SODIUM_EXPORT
+void *sodium_allocarray(size_t count, size_t size)
+            __attribute__ ((malloc));
+
+SODIUM_EXPORT
+void sodium_free(void *ptr);
+
+SODIUM_EXPORT
+int sodium_mprotect_noaccess(void *ptr);
+
+SODIUM_EXPORT
+int sodium_mprotect_readonly(void *ptr);
+
+SODIUM_EXPORT
+int sodium_mprotect_readwrite(void *ptr);
+
+SODIUM_EXPORT
+int sodium_pad(size_t *padded_buflen_p, unsigned char *buf,
+               size_t unpadded_buflen, size_t blocksize, size_t max_buflen);
+
+SODIUM_EXPORT
+int sodium_unpad(size_t *unpadded_buflen_p, const unsigned char *buf,
+                 size_t padded_buflen, size_t blocksize);
+
+/* -------- */
+
+int _sodium_alloc_init(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/3rdparty/sodium/version.h

@@ -0,0 +1,33 @@
+
+#ifndef sodium_version_H
+#define sodium_version_H
+
+#include "export.h"
+
+#define SODIUM_VERSION_STRING "1.0.16"
+
+#define SODIUM_LIBRARY_VERSION_MAJOR 10
+#define SODIUM_LIBRARY_VERSION_MINOR 1
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+SODIUM_EXPORT
+const char *sodium_version_string(void);
+
+SODIUM_EXPORT
+int         sodium_library_version_major(void);
+
+SODIUM_EXPORT
+int         sodium_library_version_minor(void);
+
+SODIUM_EXPORT
+int         sodium_library_minimal(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/3rdparty/sodium/version.h.in

@@ -0,0 +1,33 @@
+
+#ifndef sodium_version_H
+#define sodium_version_H
+
+#include "export.h"
+
+#define SODIUM_VERSION_STRING "@VERSION@"
+
+#define SODIUM_LIBRARY_VERSION_MAJOR @SODIUM_LIBRARY_VERSION_MAJOR@
+#define SODIUM_LIBRARY_VERSION_MINOR @SODIUM_LIBRARY_VERSION_MINOR@
+@SODIUM_LIBRARY_MINIMAL_DEF@
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+SODIUM_EXPORT
+const char *sodium_version_string(void);
+
+SODIUM_EXPORT
+int         sodium_library_version_major(void);
+
+SODIUM_EXPORT
+int         sodium_library_version_minor(void);
+
+SODIUM_EXPORT
+int         sodium_library_minimal(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/addressbook.cpp

@@ -3,6 +3,7 @@
 #include "ui_mainwindow.h"
 #include "settings.h"
 #include "mainwindow.h"
+#include "rpc.h"
 
 
 AddressBookModel::AddressBookModel(QTableView *parent)
@@ -110,7 +111,7 @@ void AddressBook::open(MainWindow* parent, QLineEdit* target) {
     } 
 
     // Connect the dialog's closing to updating the label address completor
-    QObject::connect(&d, &QDialog::finished, [=] (auto) { parent->updateLabelsAutoComplete(); });
+    QObject::connect(&d, &QDialog::finished, [=] (auto) { parent->updateLabels(); });
 
     // If there is a target then make it the addr for the "Add to" button
     if (target != nullptr && Settings::isValidAddress(target->text())) {
@@ -221,6 +222,9 @@ void AddressBook::open(MainWindow* parent, QLineEdit* target) {
             fnSetTargetLabelAddr(target, item.first, item.second);
         }
     };
+
+    // Refresh after the dialog is closed to update the labels everywhere.
+    parent->getRPC()->refresh(true);
 }
 
 //=============
@@ -254,9 +258,6 @@ void AddressBook::readFromStorage() {
 }
 
 void AddressBook::writeToStorage() {
-    if (allLabels.isEmpty())
-        return;
-
     QFile file(AddressBook::writeableFile());
     file.open(QIODevice::ReadWrite | QIODevice::Truncate);
     QDataStream out(&file);   // we will serialize the data into the file

src/balancestablemodel.cpp

@@ -23,7 +23,8 @@ void BalancesTableModel::setNewData(const QMap<QString, double>* balances,
     delete modeldata;
     modeldata = new QList<std::tuple<QString, double>>();
     std::for_each(balances->keyBegin(), balances->keyEnd(), [=] (auto keyIt) {
-        modeldata->push_back(std::make_tuple(keyIt, balances->value(keyIt)));
+        if (balances->value(keyIt) > 0)
+            modeldata->push_back(std::make_tuple(keyIt, balances->value(keyIt)));
     });
 
     // And then update the data

src/connection.cpp

@@ -2,6 +2,7 @@
 #include "mainwindow.h"
 #include "settings.h"
 #include "ui_connection.h"
+#include "ui_createzcashconfdialog.h"
 #include "rpc.h"
 
 #include "precompiled.h"
@@ -26,7 +27,8 @@ ConnectionLoader::~ConnectionLoader() {
 
 void ConnectionLoader::loadConnection() {
     QTimer::singleShot(1, [=]() { this->doAutoConnect(); });
-    d->exec();
+    if (!Settings::getInstance()->isHeadless())
+        d->exec();
 }
 
 void ConnectionLoader::doAutoConnect(bool tryEzcashdStart) {
@@ -128,9 +130,47 @@ void ConnectionLoader::createZcashConf() {
     main->logger->write("createZcashConf");
 
     auto confLocation = zcashConfWritableLocation();
-    main->logger->write("Creating file " + confLocation);
-
     QFileInfo fi(confLocation);
+
+    QDialog d(main);
+    Ui_createZcashConf ui;
+    ui.setupUi(&d);
+
+    QPixmap logo(":/img/res/zcashdlogo.gif");
+    ui.lblTopIcon->setBasePixmap(logo.scaled(256, 256, Qt::KeepAspectRatio, Qt::SmoothTransformation));
+    ui.btnPickDir->setEnabled(false);
+
+    ui.grpAdvanced->setVisible(false);
+    QObject::connect(ui.btnAdvancedConfig, &QPushButton::toggled, [=](bool isVisible) {
+        ui.grpAdvanced->setVisible(isVisible);
+        ui.btnAdvancedConfig->setText(isVisible ? QObject::tr("Hide Advanced Config") : QObject::tr("Show Advanced Config"));
+    });
+
+    QObject::connect(ui.chkCustomDatadir, &QCheckBox::stateChanged, [=](int chked) {
+        if (chked == Qt::Checked) {
+            ui.btnPickDir->setEnabled(true);
+        }
+        else {
+            ui.btnPickDir->setEnabled(false);
+        }
+    });
+
+    QObject::connect(ui.btnPickDir, &QPushButton::clicked, [=]() {
+        auto datadir = QFileDialog::getExistingDirectory(main, QObject::tr("Choose data directory"), ui.lblDirName->text(), QFileDialog::ShowDirsOnly);
+        if (!datadir.isEmpty()) {
+            ui.lblDirName->setText(QDir::toNativeSeparators(datadir));
+        }
+    });
+
+    // Show the dialog
+    QString datadir = "";
+    bool useTor = false;
+    if (d.exec() == QDialog::Accepted) {
+        datadir = ui.lblDirName->text();
+        useTor = ui.chkUseTor->isChecked();
+    }
+
+    main->logger->write("Creating file " + confLocation);
     QDir().mkdir(fi.dir().absolutePath());
 
     QFile file(confLocation);
@@ -145,6 +185,13 @@ void ConnectionLoader::createZcashConf() {
     out << "addnode=mainnet.z.cash\n";
     out << "rpcuser=zec-qt-wallet\n";
     out << "rpcpassword=" % randomPassword() << "\n";
+    if (!datadir.isEmpty()) {
+        out << "datadir=" % datadir % "\n";
+    }
+    if (useTor) {
+        out << "proxy=127.0.0.1:9050\n";
+    }
+
     file.close();
 
     // Now that zcash.conf exists, try to autoconnect again
@@ -396,6 +443,7 @@ void ConnectionLoader::refreshZcashdState(Connection* connection, std::function<
         [=] (auto) {
             // Success, hide the dialog if it was shown. 
             d->hide();
+            main->logger->write("zcashd is online.");
             this->doRPCSetConnection(connection);
         },
         [=] (auto reply, auto res) {            
@@ -435,6 +483,8 @@ void ConnectionLoader::refreshZcashdState(Connection* connection, std::function<
 void ConnectionLoader::showInformation(QString info, QString detail) {
     connD->status->setText(info);
     connD->statusDetail->setText(detail);
+    
+    main->logger->write(info + ":" + detail);
 }
 
 /**

src/createzcashconfdialog.ui

@@ -0,0 +1,212 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>createZcashConf</class>
+ <widget class="QDialog" name="createZcashConf">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>508</width>
+    <height>352</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Configure zcash.conf</string>
+  </property>
+  <layout class="QGridLayout" name="gridLayout">
+   <item row="0" column="1">
+    <widget class="FilledIconLabel" name="lblTopIcon">
+     <property name="sizePolicy">
+      <sizepolicy hsizetype="Preferred" vsizetype="MinimumExpanding">
+       <horstretch>0</horstretch>
+       <verstretch>0</verstretch>
+      </sizepolicy>
+     </property>
+     <property name="styleSheet">
+      <string notr="true">background: #fff;</string>
+     </property>
+     <property name="text">
+      <string notr="true"/>
+     </property>
+     <property name="scaledContents">
+      <bool>true</bool>
+     </property>
+    </widget>
+   </item>
+   <item row="1" column="1">
+    <widget class="Line" name="line">
+     <property name="orientation">
+      <enum>Qt::Horizontal</enum>
+     </property>
+    </widget>
+   </item>
+   <item row="6" column="1">
+    <widget class="QDialogButtonBox" name="buttonBox">
+     <property name="orientation">
+      <enum>Qt::Horizontal</enum>
+     </property>
+     <property name="standardButtons">
+      <set>QDialogButtonBox::Ok</set>
+     </property>
+     <property name="centerButtons">
+      <bool>true</bool>
+     </property>
+    </widget>
+   </item>
+   <item row="3" column="1">
+    <layout class="QHBoxLayout" name="horizontalLayout_3">
+     <item>
+      <widget class="QPushButton" name="btnAdvancedConfig">
+       <property name="text">
+        <string>Show Advanced Configuration</string>
+       </property>
+       <property name="checkable">
+        <bool>true</bool>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <spacer name="horizontalSpacer_2">
+       <property name="orientation">
+        <enum>Qt::Horizontal</enum>
+       </property>
+       <property name="sizeHint" stdset="0">
+        <size>
+         <width>40</width>
+         <height>20</height>
+        </size>
+       </property>
+      </spacer>
+     </item>
+    </layout>
+   </item>
+   <item row="2" column="1">
+    <widget class="QLabel" name="label">
+     <property name="text">
+      <string>Your zcash node will be configured for you automatically</string>
+     </property>
+     <property name="alignment">
+      <set>Qt::AlignLeading|Qt::AlignLeft|Qt::AlignVCenter</set>
+     </property>
+    </widget>
+   </item>
+   <item row="4" column="1">
+    <widget class="QGroupBox" name="grpAdvanced">
+     <property name="title">
+      <string/>
+     </property>
+     <layout class="QGridLayout" name="gridLayout_2">
+      <item row="0" column="0">
+       <widget class="QCheckBox" name="chkCustomDatadir">
+        <property name="text">
+         <string>Use custom datadir</string>
+        </property>
+       </widget>
+      </item>
+      <item row="1" column="0">
+       <widget class="QLabel" name="label_2">
+        <property name="text">
+         <string>Please choose a directory to store your wallet.dat and blockchain</string>
+        </property>
+       </widget>
+      </item>
+      <item row="2" column="0">
+       <layout class="QHBoxLayout" name="horizontalLayout">
+        <item>
+         <widget class="QPushButton" name="btnPickDir">
+          <property name="text">
+           <string>Choose directory</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QLabel" name="lblDirName">
+          <property name="text">
+           <string notr="true"/>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <spacer name="horizontalSpacer">
+          <property name="orientation">
+           <enum>Qt::Horizontal</enum>
+          </property>
+          <property name="sizeHint" stdset="0">
+           <size>
+            <width>40</width>
+            <height>20</height>
+           </size>
+          </property>
+         </spacer>
+        </item>
+       </layout>
+      </item>
+      <item row="3" column="0">
+       <widget class="QLabel" name="label_4">
+        <property name="text">
+         <string notr="true"/>
+        </property>
+       </widget>
+      </item>
+      <item row="4" column="0">
+       <widget class="QCheckBox" name="chkUseTor">
+        <property name="text">
+         <string>Connect over Tor</string>
+        </property>
+       </widget>
+      </item>
+      <item row="5" column="0">
+       <widget class="QLabel" name="label_5">
+        <property name="text">
+         <string>Please note that you'll need to already have a Tor service configured on port 9050</string>
+        </property>
+       </widget>
+      </item>
+     </layout>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <customwidgets>
+  <customwidget>
+   <class>FilledIconLabel</class>
+   <extends>QLabel</extends>
+   <header>fillediconlabel.h</header>
+  </customwidget>
+ </customwidgets>
+ <resources/>
+ <connections>
+  <connection>
+   <sender>buttonBox</sender>
+   <signal>accepted()</signal>
+   <receiver>createZcashConf</receiver>
+   <slot>accept()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>248</x>
+     <y>254</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>157</x>
+     <y>274</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>buttonBox</sender>
+   <signal>rejected()</signal>
+   <receiver>createZcashConf</receiver>
+   <slot>reject()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>316</x>
+     <y>260</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>286</x>
+     <y>274</y>
+    </hint>
+   </hints>
+  </connection>
+ </connections>
+</ui>

src/logger.cpp

@@ -2,11 +2,13 @@
 
 Logger::Logger(QObject *parent, QString fileName) : QObject(parent) {
     m_showDate = true;
+
     if (!fileName.isEmpty()) {
         file = new QFile;
         file->setFileName(fileName);
         file->open(QIODevice::Append | QIODevice::Text);
     }
+    
     write("=========Startup==========");
 }
 
@@ -14,7 +16,7 @@ void Logger::write(const QString &value) {
     if (!file)
         return;
         
-    QString text = value;// + "";
+    QString text = value;
     text = QDateTime::currentDateTime().toString("dd.MM.yyyy hh:mm:ss ") + text;
     QTextStream out(file);
     out.setCodec("UTF-8");

src/main.cpp

@@ -1,55 +1,271 @@
 #include "mainwindow.h"
+#include "rpc.h"
 #include "settings.h"
 #include "turnstile.h"
 
 #include "version.h"
 
-int main(int argc, char *argv[])
+class SignalHandler 
 {
-    QCoreApplication::setAttribute(Qt::AA_UseHighDpiPixmaps);
-    QCoreApplication::setAttribute(Qt::AA_EnableHighDpiScaling);
+public:
+    SignalHandler(int mask = DEFAULT_SIGNALS);
+    virtual ~SignalHandler();
 
-    QApplication a(argc, argv);
+    enum SIGNALS
+    {
+        SIG_UNHANDLED   = 0,    // Physical signal not supported by this class
+        SIG_NOOP        = 1,    // The application is requested to do a no-op (only a target that platform-specific signals map to when they can't be raised anyway)
+        SIG_INT         = 2,    // Control+C (should terminate but consider that it's a normal way to do so; can delay a bit)
+        SIG_TERM        = 4,    // Control+Break (should terminate now without regarding the consquences)
+        SIG_CLOSE       = 8,    // Container window closed (should perform normal termination, like Ctrl^C) [Windows only; on Linux it maps to SIG_TERM]
+        SIG_RELOAD      = 16,   // Reload the configuration [Linux only, physical signal is SIGHUP; on Windows it maps to SIG_NOOP]
+        DEFAULT_SIGNALS = SIG_INT | SIG_TERM | SIG_CLOSE,
+    };
+    static const int numSignals = 6;
 
-    QCoreApplication::setOrganizationName("zec-qt-wallet-org");
-    QCoreApplication::setApplicationName("zec-qt-wallet");
+    virtual bool handleSignal(int signal) = 0;
 
-    QString locale = QLocale::system().name();
-    locale.truncate(locale.lastIndexOf('_'));   // Get the language code
-    qDebug() << "Loading locale " << locale;
-    
-    QTranslator translator;
-    translator.load(QString(":/translations/res/zec_qt_wallet_") + locale);
-    a.installTranslator(&translator);
+private:
+    int _mask;
+};
 
-    QIcon icon(":/icons/res/icon.ico");
-    QApplication::setWindowIcon(icon);
+#include <assert.h>
 
-    #ifdef Q_OS_LINUX
-        QFontDatabase::addApplicationFont(":/fonts/res/Ubuntu-R.ttf");
-        qApp->setFont(QFont("Ubuntu", 11, QFont::Normal, false));
-    #endif
+#ifndef _WIN32
+
+#include <signal.h>
 
-    // QRandomGenerator generates a secure random number, which we use to seed.
-#if (QT_VERSION >= QT_VERSION_CHECK(5, 10, 0))
-    unsigned int seed = QRandomGenerator::securelySeeded().generate();
 #else
-    // This will be used only during debugging for compatibility reasons 
-    unsigned int seed = std::time(0);
-#endif
-    std::srand(seed);
 
-    Settings::init();
+#endif //!_WIN32
+
+// There can be only ONE SignalHandler per process
+SignalHandler* g_handler(NULL);
+
+#ifdef _WIN32
 
-    if (argc >= 2 && QString::fromStdString(argv[1]) == "--no-embedded") {
-        Settings::getInstance()->setUseEmbedded(false);
-    } else {
-        Settings::getInstance()->setUseEmbedded(true);
+#else //_WIN32
+
+void POSIX_handleFunc(int);
+int POSIX_physicalToLogical(int);
+int POSIX_logicalToPhysical(int);
+
+#endif //_WIN32
+
+SignalHandler::SignalHandler(int mask) : _mask(mask)
+{
+    assert(g_handler == NULL);
+    g_handler = this;
+
+#ifdef _WIN32
+    
+#endif //_WIN32
+
+    for (int i=0;i<numSignals;i++)
+    {
+        int logical = 0x1 << i;
+        if (_mask & logical)
+        {
+#ifdef _WIN32
+            
+#else
+            int sig = POSIX_logicalToPhysical(logical);
+            bool failed = signal(sig, POSIX_handleFunc) == SIG_ERR;
+            assert(!failed);
+            (void)failed; // Silence the warning in non _DEBUG; TODO: something better
+
+#endif //_WIN32
+        }
     }
 
-    MainWindow w;
-    w.setWindowTitle("zec-qt-wallet v" + QString(APP_VERSION));
-    w.show();
+}
+
+SignalHandler::~SignalHandler()
+{
+#ifdef _WIN32
     
-    return QApplication::exec();
+#else
+    for (int i=0;i<numSignals;i++)
+    {
+        int logical = 0x1 << i;
+        if (_mask & logical)
+        {
+            signal(POSIX_logicalToPhysical(logical), SIG_DFL);
+        }
+    }
+#endif //_WIN32
+}
+
+
+#ifdef _WIN32
+
+#else
+int POSIX_logicalToPhysical(int signal)
+{
+    switch (signal)
+    {
+    case SignalHandler::SIG_INT: return SIGINT;
+    case SignalHandler::SIG_TERM: return SIGTERM;
+    // In case the client asks for a SIG_CLOSE handler, accept and
+    // bind it to a SIGTERM. Anyway the signal will never be raised
+    case SignalHandler::SIG_CLOSE: return SIGTERM;
+    case SignalHandler::SIG_RELOAD: return SIGHUP;
+    default: 
+        return -1; // SIG_ERR = -1
+    }
 }
+#endif //_WIN32
+
+
+#ifdef _WIN32
+#else
+int POSIX_physicalToLogical(int signal)
+{
+    switch (signal)
+    {
+    case SIGINT: return SignalHandler::SIG_INT;
+    case SIGTERM: return SignalHandler::SIG_TERM;
+    case SIGHUP: return SignalHandler::SIG_RELOAD;
+    default:
+        return SignalHandler::SIG_UNHANDLED;
+    }
+}
+#endif //_WIN32
+
+#ifdef _WIN32
+#else
+void POSIX_handleFunc(int signal)
+{
+    if (g_handler)
+    {
+        int signo = POSIX_physicalToLogical(signal);
+        g_handler->handleSignal(signo);
+    }
+}
+#endif //_WIN32
+
+class Application : public SignalHandler
+{
+public:
+    Application() : SignalHandler(SignalHandler::SIG_INT), w(nullptr) {}
+
+    ~Application() { delete w; }
+
+    int main(int argc, char *argv[]) {
+        QCoreApplication::setAttribute(Qt::AA_UseHighDpiPixmaps);
+        QCoreApplication::setAttribute(Qt::AA_EnableHighDpiScaling);
+
+        QApplication a(argc, argv);
+
+        QCoreApplication::setOrganizationName("zec-qt-wallet-org");
+        QCoreApplication::setApplicationName("zec-qt-wallet");
+
+        QString locale = QLocale::system().name();
+        locale.truncate(locale.lastIndexOf('_'));   // Get the language code
+        qDebug() << "Loading locale " << locale;
+        
+        QTranslator translator;
+        translator.load(QString(":/translations/res/zec_qt_wallet_") + locale);
+        a.installTranslator(&translator);
+
+        QIcon icon(":/icons/res/icon.ico");
+        QApplication::setWindowIcon(icon);
+
+        #ifdef Q_OS_LINUX
+            QFontDatabase::addApplicationFont(":/fonts/res/Ubuntu-R.ttf");
+            qApp->setFont(QFont("Ubuntu", 11, QFont::Normal, false));
+        #endif
+
+        // QRandomGenerator generates a secure random number, which we use to seed.
+    #if (QT_VERSION >= QT_VERSION_CHECK(5, 10, 0))
+        unsigned int seed = QRandomGenerator::securelySeeded().generate();
+    #else
+        // This will be used only during debugging for compatibility reasons 
+        unsigned int seed = std::time(0);
+    #endif
+        std::srand(seed);
+
+        Settings::init();
+
+        // Set up libsodium
+        if (sodium_init() < 0) {
+            /* panic! the library couldn't be initialized, it is not safe to use */
+            qDebug() << "libsodium is not initialized!";
+            exit(0);
+        }
+
+        // Command line parser
+        QCommandLineParser parser;
+        parser.setApplicationDescription("Shielded desktop wallet and embedded full node for Zcash");
+        parser.addHelpOption();
+
+        // A boolean option for running it headless
+        QCommandLineOption headlessOption(QStringList() << "headless", "Running it via GUI.");
+        parser.addOption(headlessOption);
+
+        QCommandLineOption noembeddedOption(QStringList() << "no-embedded", "Disable embedded zcashd");
+        parser.addOption(noembeddedOption);
+
+        parser.process(a);
+        if (parser.isSet(noembeddedOption)) {
+            Settings::getInstance()->setUseEmbedded(false);
+        } else {
+            Settings::getInstance()->setUseEmbedded(true);
+        }
+
+        w = new MainWindow();
+        w->setWindowTitle("zec-qt-wallet v" + QString(APP_VERSION));
+
+        if (parser.isSet(headlessOption)) {
+            Settings::getInstance()->setHeadless(true);
+            a.setQuitOnLastWindowClosed(false);    
+        } else {
+            Settings::getInstance()->setHeadless(false);
+            w->show();
+        }
+
+        return QApplication::exec();
+    }
+
+    void DispatchToMainThread(std::function<void()> callback)
+    {
+        // any thread
+        QTimer* timer = new QTimer();
+        timer->moveToThread(qApp->thread());
+        timer->setSingleShot(true);
+        QObject::connect(timer, &QTimer::timeout, [=]()
+        {
+            // main thread
+            callback();
+            timer->deleteLater();
+        });
+        QMetaObject::invokeMethod(timer, "start", Qt::QueuedConnection, Q_ARG(int, 0));
+    }
+
+    bool handleSignal(int signal)
+    {
+        std::cout << std::endl << "Interrupted with signal " << signal << std::endl;
+        
+        if (w && w->getRPC()) {            
+            // Blocking call to closeEvent on the UI thread.
+            DispatchToMainThread([=] { 
+                w->doClose(); 
+                QApplication::quit();
+            });
+        } else {
+            QApplication::quit();
+        }
+        
+        return true;
+    }
+
+private:
+    MainWindow* w;
+};
+
+int main(int argc, char* argv[])
+{
+    Application app;
+    return app.main(argc, argv);
+}
+

src/mainwindow.cpp

@@ -1,6 +1,7 @@
 #include "mainwindow.h"
 #include "addressbook.h"
 #include "ui_mainwindow.h"
+#include "ui_mobileappconnector.h"
 #include "ui_addressbook.h"
 #include "ui_zboard.h"
 #include "ui_privkey.h"
@@ -15,6 +16,7 @@
 #include "turnstile.h"
 #include "senttxstore.h"
 #include "connection.h"
+#include "websockets.h"
 
 using json = nlohmann::json;
 
@@ -43,7 +45,7 @@ MainWindow::MainWindow(QWidget *parent) :
         rpc->checkForUpdate(false);
     });
 
-    // Pay zcash URI
+    // Pay Zcash URI
     QObject::connect(ui->actionPay_URI, &QAction::triggered, this, &MainWindow::payZcashURI);
 
     // Import Private Key
@@ -61,6 +63,14 @@ MainWindow::MainWindow(QWidget *parent) :
     // z-Board.net
     QObject::connect(ui->actionz_board_net, &QAction::triggered, this, &MainWindow::postToZBoard);
 
+    // Connect mobile app
+    QObject::connect(ui->actionConnect_Mobile_App, &QAction::triggered, this, [=] () {
+        if (rpc->getConnection() == nullptr)
+            return;
+
+        AppDataServer::getInstance()->connectAppDialog(this);
+    });
+
     // Address Book
     QObject::connect(ui->action_Address_Book, &QAction::triggered, this, &MainWindow::addressBook);
 
@@ -94,8 +104,47 @@ MainWindow::MainWindow(QWidget *parent) :
     rpc = new RPC(this);
 
     restoreSavedStates();
+
+    if (AppDataServer::getInstance()->isAppConnected()) {
+        auto ads = AppDataServer::getInstance();
+
+        QString wormholecode = "";
+        if (ads->getAllowInternetConnection())
+            wormholecode = ads->getWormholeCode(ads->getSecretHex());
+
+        createWebsocket(wormholecode);
+    }
 }
  
+void MainWindow::createWebsocket(QString wormholecode) {
+    qDebug() << "Listening for app connections on port 8237";
+    // Create the websocket server, for listening to direct connections
+    wsserver = new WSServer(8237, false, this);
+
+    if (!wormholecode.isEmpty()) {
+        // Connect to the wormhole service
+        wormhole = new WormholeClient(this, wormholecode);
+    }
+}
+
+void MainWindow::stopWebsocket() {
+    delete wsserver;
+    wsserver = nullptr;
+
+    delete wormhole;
+    wormhole = nullptr;
+
+    qDebug() << "Websockets for app connections shut down";
+}
+
+bool MainWindow::isWebsocketListening() {
+    return wsserver != nullptr;
+}
+
+void MainWindow::replaceWormholeClient(WormholeClient* newClient) {
+    delete wormhole;
+    wormhole = newClient;
+}
 
 void MainWindow::restoreSavedStates() {
     QSettings s;
@@ -105,6 +154,10 @@ void MainWindow::restoreSavedStates() {
     ui->transactionsTable->horizontalHeader()->restoreState(s.value("tratablegeometry").toByteArray());
 }
 
+void MainWindow::doClose() {
+    closeEvent(nullptr);
+}
+
 void MainWindow::closeEvent(QCloseEvent* event) {
     QSettings s;
 
@@ -112,11 +165,14 @@ void MainWindow::closeEvent(QCloseEvent* event) {
     s.setValue("baltablegeometry", ui->balancesTable->horizontalHeader()->saveState());
     s.setValue("tratablegeometry", ui->transactionsTable->horizontalHeader()->saveState());
 
+    s.sync();
+
     // Let the RPC know to shut down any running service.
     rpc->shutdownZcashd();
 
     // Bubble up
-    QMainWindow::closeEvent(event);
+    if (event)
+        QMainWindow::closeEvent(event);
 }
 
 void MainWindow::turnstileProgress() {
@@ -239,12 +295,18 @@ void MainWindow::turnstileDoMigration(QString fromAddr) {
 
     auto fnUpdateSproutBalance = [=] (QString addr) {
         double bal = 0;
+
+        // The currentText contains the balance as well, so strip that.
+        if (addr.contains("(")) {
+            addr = addr.left(addr.indexOf("("));
+        }
+
         if (addr.startsWith("All")) {
             bal = fnGetAllSproutBalance();
         } else {
             bal = rpc->getAllBalances()->value(addr);
         }
-
+        
         auto balTxt = Settings::getZECUSDDisplayFormat(bal);
         
         if (bal < Turnstile::minMigrationAmount) {
@@ -518,6 +580,7 @@ void MainWindow::donate() {
     ui->tabWidget->setCurrentIndex(1);
 }
 
+
 void MainWindow::postToZBoard() {
     QDialog d(this);
     Ui_zboard zb;
@@ -620,7 +683,7 @@ void MainWindow::postToZBoard() {
         rpc->executeTransaction(tx, [=] (QString opid) {
             ui->statusBar->showMessage(tr("Computing Tx: ") % opid);
         },
-        [=] (QString opid, QString txid) { 
+        [=] (QString /*opid*/, QString txid) { 
             ui->statusBar->showMessage(Settings::txidStatusMessage + " " + txid);
         },
         [=] (QString opid, QString errStr) {
@@ -642,10 +705,6 @@ void MainWindow::doImport(QList<QString>* keys) {
 
     if (keys->isEmpty()) {
         delete keys;
-
-        QMessageBox::information(this,
-            "Imported", tr("The keys were imported. It may take several minutes to rescan the blockchain. Until then, functionality may be limited"),
-            QMessageBox::Ok);
         ui->statusBar->showMessage(tr("Private key import rescan finished"));
         return;
     }
@@ -716,7 +775,7 @@ void MainWindow::payZcashURI() {
 
             if (kv[0].toLower() == "amt" || kv[0].toLower() == "amount") {
                 amount = kv[1].toDouble(); 
-            } else if (kv[0].toLower() == "memo") {
+            } else if (kv[0].toLower() == "memo" || kv[0].toLower() == "message" || kv[0].toLower() == "msg") {
                 memo = kv[1];
                 // Test if this is hex
 
@@ -778,7 +837,12 @@ void MainWindow::importPrivKey() {
         });
 
         // Start the import. The function takes ownership of keys
-        doImport(keys);
+        QTimer::singleShot(1, [=]() {doImport(keys);});
+
+        // Show the dialog that keys will be imported. 
+        QMessageBox::information(this,
+            "Imported", tr("The keys were imported. It may take several minutes to rescan the blockchain. Until then, functionality may be limited"),
+            QMessageBox::Ok);
     }
 }
 
@@ -814,7 +878,7 @@ void MainWindow::backupWalletDat() {
 
     if (Settings::getInstance()->isTestnet()) {
         zcashdir.cd("testnet3");
-        backupDefaultName = "tesetnet-" + backupDefaultName;
+        backupDefaultName = "testnet-" + backupDefaultName;
     }
     
     QFile wallet(zcashdir.filePath("wallet.dat"));
@@ -1020,12 +1084,15 @@ void MainWindow::setupTransactionsTab() {
         QString memo = txModel->getMemo(index.row());
 
         if (!memo.isEmpty()) {
-            QMessageBox::information(this, tr("Memo"), memo, QMessageBox::Ok);
+            QMessageBox mb(QMessageBox::Information, tr("Memo"), memo, QMessageBox::Ok, this);
+            mb.setTextInteractionFlags(Qt::TextSelectableByMouse | Qt::TextSelectableByKeyboard);
+            mb.exec();
         }
     });
 
     // Set up context menu on transactions tab
     ui->transactionsTable->setContextMenuPolicy(Qt::CustomContextMenu);
+
     // Table right click
     QObject::connect(ui->transactionsTable, &QTableView::customContextMenuRequested, [=] (QPoint pos) {
         QModelIndex index = ui->transactionsTable->indexAt(pos);
@@ -1063,11 +1130,13 @@ void MainWindow::setupTransactionsTab() {
 
         if (!memo.isEmpty()) {
             menu.addAction(tr("View Memo"), [=] () {
-                QMessageBox::information(this, tr("Memo"), memo, QMessageBox::Ok);
+                QMessageBox mb(QMessageBox::Information, tr("Memo"), memo, QMessageBox::Ok, this);
+                mb.setTextInteractionFlags(Qt::TextSelectableByMouse | Qt::TextSelectableByKeyboard);
+                mb.exec();
             });
         }
 
-        // If memo contains a reply to addess, add a "Reply to" menu item
+        // If memo contains a reply to address, add a "Reply to" menu item
         if (!memo.isEmpty()) {
             int lastPost     = memo.trimmed().lastIndexOf(QRegExp("[\r\n]+"));
             QString lastWord = memo.right(memo.length() - lastPost - 1);
@@ -1159,33 +1228,27 @@ void MainWindow::setupRecieveTab() {
         });
     };
 
-    auto fnUpdateTAddrCombo = [=] (bool checked) {
-        if (checked) {
-            auto utxos = this->rpc->getUTXOs();
-            ui->listRecieveAddresses->clear();
-
-            std::for_each(utxos->begin(), utxos->end(), [=](auto& utxo) {
-                auto addr = utxo.address;
-                if (addr.startsWith("t") && ui->listRecieveAddresses->findText(addr) < 0) {
-                    auto bal = rpc->getAllBalances()->value(addr);
-                    ui->listRecieveAddresses->addItem(addr, bal);
-                }
-            });
-        }
-    };
-
     // Connect t-addr radio button
     QObject::connect(ui->rdioTAddr, &QRadioButton::toggled, [=] (bool checked) { 
         // Whenever the t-address is selected, we generate a new address, because we don't
         // want to reuse t-addrs
         if (checked && this->rpc->getUTXOs() != nullptr) { 
-            fnUpdateTAddrCombo(checked);
+            updateTAddrCombo(checked);
             addNewTAddr();
         } 
     });
 
     // zAddr toggle button, one for sprout and one for sapling
-    QObject::connect(ui->rdioZAddr,  &QRadioButton::toggled, addZAddrsToComboList(false));
+    QObject::connect(ui->rdioZAddr, &QRadioButton::toggled, [=](bool checked) {
+        ui->btnRecieveNewAddr->setEnabled(!checked);
+        if (checked) {
+            ui->btnRecieveNewAddr->setToolTip(tr("Creation of new Sprout addresses is deprecated"));
+        }
+        else {
+            ui->btnRecieveNewAddr->setToolTip("");
+        }
+        addZAddrsToComboList(false)(checked);
+    });
     QObject::connect(ui->rdioZSAddr, &QRadioButton::toggled, addZAddrsToComboList(true));
 
     // Explicitly get new address button.
@@ -1218,7 +1281,7 @@ void MainWindow::setupRecieveTab() {
             if (Settings::getInstance()->isSaplingActive()) {
                 ui->rdioZSAddr->setVisible(true);    
                 ui->rdioZSAddr->setChecked(true);
-                ui->rdioZAddr->setText("z-Addr(Sprout)");
+                ui->rdioZAddr->setText("z-Addr(Legacy Sprout)");
             } else {
                 ui->rdioZSAddr->setVisible(false);    
                 ui->rdioZAddr->setChecked(true);
@@ -1245,7 +1308,6 @@ void MainWindow::setupRecieveTab() {
             ui->rcvBal->clear();
             ui->txtRecieve->clear();
             ui->qrcodeDisplay->clear();
-            ui->lblUsed->clear();
             return;
         }
 
@@ -1260,16 +1322,16 @@ void MainWindow::setupRecieveTab() {
         ui->rcvLabel->setText(label);
         ui->rcvBal->setText(Settings::getZECUSDDisplayFormat(rpc->getAllBalances()->value(addr)));
         ui->txtRecieve->setPlainText(addr);       
-        ui->qrcodeDisplay->setAddress(addr);
+        ui->qrcodeDisplay->setQrcodeString(addr);
         if (rpc->getUsedAddresses()->value(addr, false)) {
-            ui->lblUsed->setText(tr("Address has been previously used"));
+            ui->rcvBal->setToolTip(tr("Address has been previously used"));
         } else {
-            ui->lblUsed->setText(tr("Address is unused"));
+            ui->rcvBal->setToolTip(tr("Address is unused"));
         }
         
     });    
 
-    // Recieve tab add/update label
+    // Receive tab add/update label
     QObject::connect(ui->rcvUpdateLabel, &QPushButton::clicked, [=]() {
         QString addr = ui->listRecieveAddresses->currentText();
         if (addr.isEmpty())
@@ -1296,13 +1358,8 @@ void MainWindow::setupRecieveTab() {
             AddressBook::getInstance()->addAddressLabel(label, addr);
         }
 
-        // Update the UI
-        if (ui->rdioTAddr->isChecked()) {
-            fnUpdateTAddrCombo(true);
-        }
-        else {
-            addZAddrsToComboList(ui->rdioZSAddr->isChecked())(true);
-        }
+        // Update labels everywhere on the UI
+        updateLabels();
 
         // Show the user feedback
         if (!info.isEmpty()) {
@@ -1320,6 +1377,38 @@ void MainWindow::setupRecieveTab() {
     });
 }
 
+void MainWindow::updateTAddrCombo(bool checked) {
+    if (checked) {
+        auto utxos = this->rpc->getUTXOs();
+        ui->listRecieveAddresses->clear();
+
+        std::for_each(utxos->begin(), utxos->end(), [=](auto& utxo) {
+            auto addr = utxo.address;
+            if (addr.startsWith("t") && ui->listRecieveAddresses->findText(addr) < 0) {
+                auto bal = rpc->getAllBalances()->value(addr);
+                ui->listRecieveAddresses->addItem(addr, bal);
+            }
+        });
+    }
+};
+
+// Updates the labels everywhere on the UI. Call this after the labels have been updated
+void MainWindow::updateLabels() {
+    // Update the Receive tab
+    if (ui->rdioTAddr->isChecked()) {
+        updateTAddrCombo(true);
+    }
+    else {
+        addZAddrsToComboList(ui->rdioZSAddr->isChecked())(true);
+    }
+
+    // Update the Send Tab
+    updateFromCombo();
+
+    // Update the autocomplete
+    updateLabelsAutoComplete();
+}
+
 MainWindow::~MainWindow()
 {
     delete ui;
@@ -1330,4 +1419,7 @@ MainWindow::~MainWindow()
 
     delete loadingMovie;
     delete logger;
+
+    delete wsserver;
+    delete wormhole;
 }

src/mainwindow.h

@@ -9,6 +9,8 @@
 // Forward declare to break circular dependency.
 class RPC;
 class Settings;
+class WSServer;
+class WormholeClient;
 
 using json = nlohmann::json;
 
@@ -42,8 +44,18 @@ public:
     void updateLabelsAutoComplete();
     RPC* getRPC() { return rpc; }
 
+    QString doSendTxValidations(Tx tx);
     void setDefaultPayFrom();
 
+    void replaceWormholeClient(WormholeClient* newClient);
+    bool isWebsocketListening();
+    void createWebsocket(QString wormholecode);
+    void stopWebsocket();
+
+    void updateLabels();
+    void updateTAddrCombo(bool checked);
+    void updateFromCombo();
+
     Ui::MainWindow*     ui;
 
     QLabel*             statusLabel;
@@ -52,6 +64,9 @@ public:
     QWidget*            zcashdtab;
 
     Logger*      logger;
+
+    void doClose();
+
 private:    
     void closeEvent(QCloseEvent* event);
 
@@ -89,9 +104,7 @@ private:
 
     void memoButtonClicked(int number, bool includeReplyTo = false);
     void setMemoEnabled(int number, bool enabled);
-
-    QString doSendTxValidations(Tx tx);
-
+    
     void donate();
     void addressBook();
     void payZcashURI();
@@ -106,6 +119,9 @@ private:
 
     void restoreSavedStates();
 
+    WSServer*       wsserver = nullptr;
+    WormholeClient* wormhole = nullptr;
+
     RPC*         rpc  = nullptr;
     QCompleter*  labelCompleter = nullptr;
 

src/mainwindow.ui

@@ -531,7 +531,7 @@
          </widget>
         </item>
         <item>
-         <layout class="QHBoxLayout" name="horizontalLayout_17">
+         <layout class="QHBoxLayout" name="layoutSendRecurring">
           <item>
            <widget class="QCheckBox" name="chkRecurring">
             <property name="text">
@@ -680,7 +680,7 @@
                <item>
                 <widget class="QRadioButton" name="rdioZSAddr">
                  <property name="text">
-                  <string>z-Addr(Sapling)</string>
+                  <string>z-Addr</string>
                  </property>
                 </widget>
                </item>
@@ -700,7 +700,7 @@
                <item>
                 <widget class="QRadioButton" name="rdioZAddr">
                  <property name="text">
-                  <string>z-Addr(Sprout)</string>
+                  <string>z-Addr(Legacy Sprout)</string>
                  </property>
                 </widget>
                </item>
@@ -790,17 +790,7 @@
                   </property>
                  </widget>
                 </item>
-                <item row="0" column="0">
-                 <widget class="QLabel" name="label_10">
-                  <property name="text">
-                   <string>Address</string>
-                  </property>
-                  <property name="alignment">
-                   <set>Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop</set>
-                  </property>
-                 </widget>
-                </item>
-                <item row="4" column="1" colspan="2">
+                <item row="3" column="1" colspan="2">
                  <layout class="QHBoxLayout" name="horizontalLayout_16">
                   <item>
                    <widget class="QPushButton" name="exportKey">
@@ -824,17 +814,13 @@
                   </item>
                  </layout>
                 </item>
-                <item row="3" column="0">
-                 <widget class="QLabel" name="label_15">
+                <item row="0" column="0">
+                 <widget class="QLabel" name="label_10">
                   <property name="text">
-                   <string>Address used</string>
+                   <string>Address</string>
                   </property>
-                 </widget>
-                </item>
-                <item row="3" column="1" colspan="2">
-                 <widget class="QLabel" name="lblUsed">
-                  <property name="text">
-                   <string notr="true"/>
+                  <property name="alignment">
+                   <set>Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop</set>
                   </property>
                  </widget>
                 </item>
@@ -1043,7 +1029,7 @@
      <x>0</x>
      <y>0</y>
      <width>968</width>
-     <height>22</height>
+     <height>19</height>
     </rect>
    </property>
    <widget class="QMenu" name="menuFile">
@@ -1072,8 +1058,10 @@
     <property name="title">
      <string>&amp;Apps</string>
     </property>
-    <addaction name="actionTurnstile_Migration"/>
+    <addaction name="actionConnect_Mobile_App"/>
+    <addaction name="separator"/>
     <addaction name="actionz_board_net"/>
+    <addaction name="actionTurnstile_Migration"/>
    </widget>
    <widget class="QMenu" name="menu_Edit">
     <property name="title">
@@ -1165,6 +1153,14 @@
     <string>Pay zcash &amp;URI...</string>
    </property>
   </action>
+  <action name="actionConnect_Mobile_App">
+   <property name="text">
+    <string>Connect mobile &amp;app</string>
+   </property>
+   <property name="shortcut">
+    <string>Ctrl+M</string>
+   </property>
+  </action>
  </widget>
  <layoutdefault spacing="6" margin="11"/>
  <customwidgets>
@@ -1173,16 +1169,16 @@
    <extends>QLabel</extends>
    <header>qrcodelabel.h</header>
   </customwidget>
-  <customwidget>
-   <class>FilledIconLabel</class>
-   <extends>QLabel</extends>
-   <header>fillediconlabel.h</header>
-  </customwidget>
   <customwidget>
    <class>AddressCombo</class>
    <extends>QComboBox</extends>
    <header>addresscombo.h</header>
   </customwidget>
+  <customwidget>
+   <class>FilledIconLabel</class>
+   <extends>QLabel</extends>
+   <header>fillediconlabel.h</header>
+  </customwidget>
  </customwidgets>
  <tabstops>
   <tabstop>tabWidget</tabstop>

src/mobileappconnector.cpp

@@ -0,0 +1,14 @@
+#include "mobileappconnector.h"
+#include "ui_mobileappconnector.h"
+
+MobileAppConnector::MobileAppConnector(QWidget *parent) :
+    QDialog(parent),
+    ui(new Ui::MobileAppConnector)
+{
+    ui->setupUi(this);
+}
+
+MobileAppConnector::~MobileAppConnector()
+{
+    delete ui;
+}

src/mobileappconnector.h

@@ -0,0 +1,22 @@
+#ifndef MOBILEAPPCONNECTOR_H
+#define MOBILEAPPCONNECTOR_H
+
+#include <QDialog>
+
+namespace Ui {
+class MobileAppConnector;
+}
+
+class MobileAppConnector : public QDialog
+{
+    Q_OBJECT
+
+public:
+    explicit MobileAppConnector(QWidget *parent = nullptr);
+    ~MobileAppConnector();
+
+private:
+    Ui::MobileAppConnector *ui;
+};
+
+#endif // MOBILEAPPCONNECTOR_H

src/mobileappconnector.ui

@@ -0,0 +1,214 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>MobileAppConnector</class>
+ <widget class="QDialog" name="MobileAppConnector">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>800</width>
+    <height>530</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Connect Mobile App</string>
+  </property>
+  <layout class="QGridLayout" name="gridLayout">
+   <item row="4" column="1" colspan="2">
+    <widget class="QDialogButtonBox" name="buttonBox">
+     <property name="orientation">
+      <enum>Qt::Horizontal</enum>
+     </property>
+     <property name="standardButtons">
+      <set>QDialogButtonBox::Close</set>
+     </property>
+    </widget>
+   </item>
+   <item row="0" column="0" colspan="3">
+    <widget class="QLabel" name="label">
+     <property name="sizePolicy">
+      <sizepolicy hsizetype="Preferred" vsizetype="Minimum">
+       <horstretch>0</horstretch>
+       <verstretch>0</verstretch>
+      </sizepolicy>
+     </property>
+     <property name="text">
+      <string>Scan this QRCode from your ZecQT Wallet companion app to connect your phone</string>
+     </property>
+    </widget>
+   </item>
+   <item row="1" column="0" colspan="2">
+    <widget class="QGroupBox" name="groupBox_2">
+     <property name="title">
+      <string>QR Code</string>
+     </property>
+     <layout class="QGridLayout" name="gridLayout_3">
+      <item row="1" column="0">
+       <widget class="QLabel" name="label_2">
+        <property name="text">
+         <string>Connection String</string>
+        </property>
+       </widget>
+      </item>
+      <item row="2" column="0">
+       <widget class="QLineEdit" name="txtConnStr">
+        <property name="font">
+         <font>
+          <pointsize>9</pointsize>
+         </font>
+        </property>
+        <property name="readOnly">
+         <bool>true</bool>
+        </property>
+       </widget>
+      </item>
+      <item row="0" column="0">
+       <widget class="QRCodeLabel" name="qrcode">
+        <property name="sizePolicy">
+         <sizepolicy hsizetype="Preferred" vsizetype="MinimumExpanding">
+          <horstretch>0</horstretch>
+          <verstretch>0</verstretch>
+         </sizepolicy>
+        </property>
+        <property name="styleSheet">
+         <string notr="true">background-color: #fff</string>
+        </property>
+        <property name="text">
+         <string/>
+        </property>
+       </widget>
+      </item>
+      <item row="3" column="0">
+       <widget class="QCheckBox" name="chkInternetConn">
+        <property name="text">
+         <string>Allow connections over the internet via zec-qt-wallet wormhole</string>
+        </property>
+       </widget>
+      </item>
+     </layout>
+    </widget>
+   </item>
+   <item row="1" column="2" rowspan="2">
+    <widget class="QGroupBox" name="groupBox">
+     <property name="title">
+      <string>ZecQT Wallet Companion App</string>
+     </property>
+     <layout class="QGridLayout" name="gridLayout_2">
+      <item row="5" column="0">
+       <widget class="QPushButton" name="btnDisconnect">
+        <property name="sizePolicy">
+         <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
+          <horstretch>0</horstretch>
+          <verstretch>0</verstretch>
+         </sizepolicy>
+        </property>
+        <property name="text">
+         <string>Disconnect</string>
+        </property>
+       </widget>
+      </item>
+      <item row="6" column="0">
+       <spacer name="verticalSpacer">
+        <property name="orientation">
+         <enum>Qt::Vertical</enum>
+        </property>
+        <property name="sizeHint" stdset="0">
+         <size>
+          <width>20</width>
+          <height>40</height>
+         </size>
+        </property>
+       </spacer>
+      </item>
+      <item row="2" column="0">
+       <widget class="QLabel" name="lblLastSeen">
+        <property name="text">
+         <string>TextLabel</string>
+        </property>
+        <property name="alignment">
+         <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+        </property>
+       </widget>
+      </item>
+      <item row="1" column="0">
+       <widget class="QLabel" name="label_3">
+        <property name="text">
+         <string>Last seen:</string>
+        </property>
+       </widget>
+      </item>
+      <item row="0" column="0">
+       <widget class="QLabel" name="lblRemoteName">
+        <property name="text">
+         <string notr="true">TextLabel</string>
+        </property>
+        <property name="alignment">
+         <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+        </property>
+       </widget>
+      </item>
+      <item row="3" column="0">
+       <widget class="QLabel" name="label_4">
+        <property name="text">
+         <string>Connection type:</string>
+        </property>
+       </widget>
+      </item>
+      <item row="4" column="0">
+       <widget class="QLabel" name="lblConnectionType">
+        <property name="text">
+         <string>TextLabel</string>
+        </property>
+        <property name="alignment">
+         <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+        </property>
+       </widget>
+      </item>
+     </layout>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <customwidgets>
+  <customwidget>
+   <class>QRCodeLabel</class>
+   <extends>QLabel</extends>
+   <header>qrcodelabel.h</header>
+  </customwidget>
+ </customwidgets>
+ <resources/>
+ <connections>
+  <connection>
+   <sender>buttonBox</sender>
+   <signal>accepted()</signal>
+   <receiver>MobileAppConnector</receiver>
+   <slot>accept()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>248</x>
+     <y>254</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>157</x>
+     <y>274</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>buttonBox</sender>
+   <signal>rejected()</signal>
+   <receiver>MobileAppConnector</receiver>
+   <slot>reject()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>316</x>
+     <y>260</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>286</x>
+     <y>274</y>
+    </hint>
+   </hints>
+  </connection>
+ </connections>
+</ui>

src/precompiled.h

@@ -55,6 +55,7 @@
 #include <QtNetwork/QNetworkRequest>
 #include <QtNetwork/QNetworkAccessManager>
 #include <QtNetwork/QNetworkReply>
+#include <QtWebSockets/QtWebSockets>
 #include <QJsonDocument>
 #include <QJsonArray>
 #include <QJsonObject>
@@ -67,6 +68,9 @@
 #include "3rdparty/json/json.hpp"
 #include "3rdparty/qrcode/QrCode.hpp"
 
+#define SODIUM_STATIC
+#include "3rdparty/sodium.h"
+
 #define QT6_VIRTUAL
 
 #endif

src/qrcodelabel.cpp

@@ -15,7 +15,7 @@ QSize QRCodeLabel::sizeHint() const
 
 void QRCodeLabel::resizeEvent(QResizeEvent*)
 {
-    if(!address.isEmpty())
+    if(!str.isEmpty())
         QLabel::setPixmap(scaledPixmap());
 }
 
@@ -24,7 +24,7 @@ QPixmap QRCodeLabel::scaledPixmap() const {
     pm.fill(Qt::white);
     QPainter painter(&pm);
     
-    qrcodegen::QrCode qr = qrcodegen::QrCode::encodeText(address.toUtf8().constData(), qrcodegen::QrCode::Ecc::LOW);
+    qrcodegen::QrCode qr = qrcodegen::QrCode::encodeText(str.toUtf8().constData(), qrcodegen::QrCode::Ecc::LOW);
     const int    s      = qr.getSize()>0?qr.getSize():1;
     const double w      = pm.width();
     const double h      = pm.height();
@@ -51,7 +51,7 @@ QPixmap QRCodeLabel::scaledPixmap() const {
     return pm;
 }
 
-void QRCodeLabel::setAddress(QString addr) {
-    address = addr;
+void QRCodeLabel::setQrcodeString(QString stra) {
+    str = stra;
     QLabel::setPixmap(scaledPixmap());
 }

src/qrcodelabel.h

@@ -10,13 +10,13 @@ public:
     explicit        QRCodeLabel(QWidget *parent = nullptr);
     virtual QSize   sizeHint() const;
     
-    void            setAddress(QString address);
+    void            setQrcodeString(QString address);
     QPixmap         scaledPixmap() const;
 public slots:    
     void resizeEvent(QResizeEvent *);
 
 private:
-    QString address;
+    QString str;
 };
 
 

src/rpc.cpp

@@ -5,6 +5,7 @@
 #include "senttxstore.h"
 #include "turnstile.h"
 #include "version.h"
+#include "websockets.h"
 
 using json = nlohmann::json;
 
@@ -65,6 +66,7 @@ RPC::~RPC() {
     delete allBalances;
     delete usedAddresses;
     delete zaddresses;
+    delete taddresses;
 
     delete conn;
 }
@@ -86,13 +88,25 @@ void RPC::setConnection(Connection* c) {
     ui->statusBar->showMessage("Ready!");
 
     refreshZECPrice();
-    checkForUpdate();
+    // Commented for Android beta. 
+    // checkForUpdate();
 
     // Force update, because this might be coming from a settings update
     // where we need to immediately refresh
     refresh(true);
 }
 
+void RPC::getTAddresses(const std::function<void(json)>& cb) {
+    json payload = {
+        {"jsonrpc", "1.0"},
+        {"id", "someid"},
+        {"method", "getaddressesbyaccount"},
+        {"params", {""}}
+    };
+
+    conn->doRPCWithDefaultErrorHandling(payload, cb);
+}
+
 void RPC::getZAddresses(const std::function<void(json)>& cb) {
     json payload = {
         {"jsonrpc", "1.0"},
@@ -530,6 +544,7 @@ void RPC::getInfoThenRefresh(bool force) {
 
         static int    lastBlock = 0;
         int curBlock  = reply["blocks"].get<json::number_integer_t>();
+        int version = reply["version"].get<json::number_integer_t>();
 
         if ( force || (curBlock != lastBlock) ) {
             // Something changed, so refresh everything.
@@ -598,7 +613,7 @@ void RPC::getInfoThenRefresh(bool force) {
                         // as the progress instead of verification progress.
                         progress = (double)blockNumber / (double)estimatedheight;
                     }
-                    txt = txt %  " ( " % QString::number(progress * 100, 'f', 0) % "% )";
+                    txt = txt %  " ( " % QString::number(progress * 100, 'f', 2) % "% )";
                     ui->blockheight->setText(txt);
                     ui->heightLabel->setText(QObject::tr("Downloading blocks"));
                 } else {
@@ -613,7 +628,7 @@ void RPC::getInfoThenRefresh(bool force) {
                 " (" %
                 (Settings::getInstance()->isTestnet() ? QObject::tr("testnet:") : "") %
                 QString::number(blockNumber) %
-                (isSyncing ? ("/" % QString::number(progress*100, 'f', 0) % "%") : QString()) %
+                (isSyncing ? ("/" % QString::number(progress*100, 'f', 2) % "%") : QString()) %
                 ")";
             main->statusLabel->setText(statusText);   
 
@@ -625,6 +640,7 @@ void RPC::getInfoThenRefresh(bool force) {
             else {
                 tooltip = QObject::tr("zcashd has no peer connections");
             }
+            tooltip = tooltip % "(v " % QString::number(version) % ")";
 
             if (!zecPrice.isEmpty()) {
                 tooltip = "1 ZEC = " % zecPrice % "\n" % tooltip;
@@ -667,6 +683,22 @@ void RPC::refreshAddresses() {
         refreshSentZTrans();
         refreshReceivedZTrans(*zaddresses);
     });
+
+    delete taddresses;
+    taddresses = new QList<QString>();
+    getTAddresses([=] (json reply) {
+        for (auto& it : reply.get<json::array_t>()) {   
+            auto addr = QString::fromStdString(it.get<json::string_t>());
+            if (Settings::isTAddress(addr))
+                taddresses->push_back(addr);
+        }
+
+        // If there are no t Addresses, create one
+        newTaddr([=] (json reply) {
+            // What if taddress gets deleted before this executes?
+            taddresses->append(QString::fromStdString(reply.get<json::string_t>()));
+        });
+    });
 }
 
 // Function to create the data model and update the views, used below.
@@ -676,21 +708,8 @@ void RPC::updateUI(bool anyUnconfirmed) {
     // Update balances model data, which will update the table too
     balancesTableModel->setNewData(allBalances, utxos);
 
-    // Add all the addresses into the inputs combo box
-    auto lastFromAddr = ui->inputsCombo->currentText();
-
-    ui->inputsCombo->clear();
-    auto i = allBalances->constBegin();
-    while (i != allBalances->constEnd()) {
-         ui->inputsCombo->addItem(i.key(), i.value());
-        if (i.key() == lastFromAddr) ui->inputsCombo->setCurrentText(i.key());
-
-        ++i;
-    }
-
-    if (lastFromAddr.isEmpty()) {
-        main->setDefaultPayFrom();
-    }
+    // Update from address
+    main->updateFromCombo();
 };
 
 // Function to process reply of the listunspent and z_listunspent API calls, used below.
@@ -719,17 +738,25 @@ void RPC::refreshBalances() {
 
     // 1. Get the Balances
     getBalance([=] (json reply) {    
-        auto balT = QString::fromStdString(reply["transparent"]).toDouble();
-        auto balZ = QString::fromStdString(reply["private"]).toDouble();
-        auto tot  = QString::fromStdString(reply["total"]).toDouble();
+        auto balT      = QString::fromStdString(reply["transparent"]).toDouble();
+        auto balZ      = QString::fromStdString(reply["private"]).toDouble();
+        auto balTotal  = QString::fromStdString(reply["total"]).toDouble();
+
+        AppDataModel::getInstance()->setBalances(balT, balZ);
 
         ui->balSheilded   ->setText(Settings::getZECDisplayFormat(balZ));
         ui->balTransparent->setText(Settings::getZECDisplayFormat(balT));
-        ui->balTotal      ->setText(Settings::getZECDisplayFormat(tot));
+        ui->balTotal      ->setText(Settings::getZECDisplayFormat(balTotal));
 
+<<<<<<< HEAD
         ui->balSheilded   ->setToolTip(Settings::getUSDFromZecAmount(balZ));
         ui->balTransparent->setToolTip(Settings::getUSDFromZecAmount(balT));
         ui->balTotal      ->setToolTip(Settings::getUSDFromZecAmount(tot));
+=======
+        ui->balSheilded   ->setToolTip(Settings::getUSDFormat(balZ));
+        ui->balTransparent->setToolTip(Settings::getUSDFormat(balT));
+        ui->balTotal      ->setToolTip(Settings::getUSDFormat(balTotal));
+>>>>>>> master
     });
 
     // 2. Get the UTXOs
@@ -963,8 +990,14 @@ void RPC::checkForUpdate(bool silent) {
                 }
 
                 auto currentVersion = QVersionNumber::fromString(APP_VERSION);
+                
+                // Get the max version that the user has hidden updates for
+                QSettings s;
+                auto maxHiddenVersion = QVersionNumber::fromString(s.value("update/lastversion", "0.0.0").toString());
+
                 qDebug() << "Version check: Current " << currentVersion << ", Available " << maxVersion;
-                if (maxVersion > currentVersion) {
+
+                if (maxVersion > currentVersion && maxVersion > maxHiddenVersion) {
                     auto ans = QMessageBox::information(main, QObject::tr("Update Available"), 
                         QObject::tr("A new release v%1 is available! You have v%2.\n\nWould you like to visit the releases page?")
                             .arg(maxVersion.toString())
@@ -972,6 +1005,9 @@ void RPC::checkForUpdate(bool silent) {
                         QMessageBox::Yes, QMessageBox::Cancel);
                     if (ans == QMessageBox::Yes) {
                         QDesktopServices::openUrl(QUrl("https://github.com/ZcashFoundation/zec-qt-wallet/releases"));
+                    } else {
+                        // If the user selects cancel, don't bother them again for this version
+                        s.setValue("update/lastversion", maxVersion.toString());
                     }
                 } else {
                     if (!silent) {
@@ -979,7 +1015,7 @@ void RPC::checkForUpdate(bool silent) {
                             QObject::tr("You already have the latest release v%1")
                                 .arg(currentVersion.toString()));
                     }
-                }
+                } 
             }
         }
         catch (...) {
@@ -1045,7 +1081,7 @@ void RPC::refreshZECPrice() {
 
 void RPC::shutdownZcashd() {
     // Shutdown embedded zcashd if it was started
-    if (ezcashd == nullptr || conn == nullptr) {
+    if (ezcashd == nullptr || ezcashd->processId() == 0 || conn == nullptr) {
         // No zcashd running internally, just return
         return;
     }
@@ -1086,8 +1122,18 @@ void RPC::shutdownZcashd() {
     });
     waiter.start(1000);
 
-    // Wait for the zcash process to exit.     
-    d.exec(); 
+    // Wait for the zcash process to exit.
+    if (!Settings::getInstance()->isHeadless()) {
+        d.exec(); 
+    } else {
+        while (waiter.isActive()) {
+            QCoreApplication::processEvents();
+#ifdef _WIN32
+#else
+            std::this_thread::sleep_for(std::chrono::seconds(1));
+#endif            
+        }
+    }
 }
 
 
@@ -1156,3 +1202,10 @@ QString RPC::getDefaultSaplingAddress() {
 
     return QString();
 }
+
+QString RPC::getDefaultTAddress() {
+    if (getAllTAddresses()->length() > 0)
+        return getAllTAddresses()->at(0);
+    else 
+        return QString();
+}

src/rpc.h

@@ -57,10 +57,13 @@ public:
     void fillTxJsonParams(json& params, Tx tx);
     void sendZTransaction(json params, const std::function<void(json)>& cb, const std::function<void(QString)>& err);
     void watchTxStatus();
+
+    const QMap<QString, WatchedTx> getWatchingTxns() { return watchingOps; }
     void addNewTxToWatch(const QString& newOpid, WatchedTx wtx); 
 
     const TxTableModel*               getTransactionsModel() { return transactionsTableModel; }
     const QList<QString>*             getAllZAddresses()     { return zaddresses; }
+    const QList<QString>*             getAllTAddresses()     { return taddresses; }
     const QList<UnspentOutput>*       getUTXOs()             { return utxos; }
     const QMap<QString, double>*      getAllBalances()       { return allBalances; }
     const QMap<QString, bool>*        getUsedAddresses()     { return usedAddresses; }
@@ -77,6 +80,7 @@ public:
     void noConnection();
 
     QString getDefaultSaplingAddress();
+    QString getDefaultTAddress();
 
     void getAllPrivKeys(const std::function<void(QList<QPair<QString, QString>>)>);
 
@@ -101,6 +105,7 @@ private:
     void getZUnspent            (const std::function<void(json)>& cb);
     void getTransactions        (const std::function<void(json)>& cb);
     void getZAddresses          (const std::function<void(json)>& cb);
+    void getTAddresses          (const std::function<void(json)>& cb);
 
     Connection*                 conn                        = nullptr;
     QProcess*                   ezcashd                     = nullptr;
@@ -109,6 +114,7 @@ private:
     QMap<QString, double>*      allBalances                 = nullptr;
     QMap<QString, bool>*        usedAddresses               = nullptr;
     QList<QString>*             zaddresses                  = nullptr;
+    QList<QString>*             taddresses                  = nullptr;
     
     QMap<QString, WatchedTx>    watchingOps;
 

src/scripts/control

@@ -3,7 +3,6 @@ Version: RELEASE_VERSION
 Section: base
 Priority: optional
 Architecture: amd64
-Depends: openssl (>= 1.0.0)
 Maintainer: Aditya Kulkarni <zcash@adityapk.com>
 Description: zec-qt-wallet is a full node and UI wallet for Zcash.
  zec-qt-wallet is a full node and UI wallet for Zcash. It comes with 

src/scripts/desktopentry

@@ -6,7 +6,7 @@ Exec=/usr/local/bin/zec-qt-wallet
 Icon=zec-qt-wallet.xpm
 Type=Application
 StartupNotify=true
-StartupWMClass=Code
+StartupWMClass=zecqtwallet
 Categories=Utility;
 MimeType=text/plain;inode/directory;
 Keywords=zec-qt-wallet;

src/scripts/dounifiedbuild.ps1

@@ -61,11 +61,17 @@ ssh $winserver "New-Item zqwbuild -itemtype directory" | Out-Null
 # Same while copying the built msi. A straight scp pull from windows to here doesn't work,
 # so we ssh to windows, and then scp push the file to here.
 $myhostname = (hostname) | Out-String -NoNewline
-Remove-Item -Path /tmp/zqwbuild -Recurse -ErrorAction Ignore | Out-Null
-New-Item    -Path /tmp/zqwbuild -itemtype directory          | Out-Null
-Copy-Item src     /tmp/zqwbuild/ -Recurse
-Copy-Item res     /tmp/zqwbuild/ -Recurse
-Copy-Item release /tmp/zqwbuild/ -Recurse
+# Powershell seems not to be able to remove this directory for some reason!
+# Remove-Item -Path /tmp/zqwbuild -Recurse -ErrorAction Ignore | Out-Null
+bash "rm -rf /tmp/zqwbuild" 2>&1 | Out-Null
+New-Item    -Path /tmp/zqwbuild -itemtype directory -Force | Out-Null
+Copy-Item src     /tmp/zqwbuild/ -Recurse -Force 
+Copy-Item res     /tmp/zqwbuild/ -Recurse -Force
+Copy-Item release /tmp/zqwbuild/ -Recurse -Force
+
+# Remove some unnecessary stuff from the tmp directory to speed up copying
+Remove-Item -Recurse -ErrorAction Ignore /tmp/zqwbuild/res/libsodium
+
 ssh $winserver "scp -r ${myhostname}:/tmp/zqwbuild/* zqwbuild/"
 ssh $winserver "cd zqwbuild ; src/scripts/mkwininstaller.ps1 -version $version" >/dev/null
 if (!$?) {
@@ -87,3 +93,7 @@ if (! (Test-Path ./artifacts/linux-binaries-zec-qt-wallet-v$version.tar.gz) -or
         exit 1;
     }
 Write-Host "[OK]"
+
+Write-Host -NoNewline "Signing Binaries......."
+bash src/scripts/signbinaries.sh --version $version
+Write-Host "[OK]"

src/scripts/mkrelease.sh

@@ -66,6 +66,7 @@ echo "[OK]"
 
 echo -n "Building..............."
 rm -rf bin/zec-qt-wallet* > /dev/null
+make clean > /dev/null
 make -j$(nproc) > /dev/null
 echo "[OK]"
 

src/scripts/signbinaries.sh

@@ -0,0 +1,49 @@
+#!/bin/bash
+
+# Accept the variables as command line arguments as well
+POSITIONAL=()
+while [[ $# -gt 0 ]]
+do
+key="$1"
+
+case $key in
+    -v|--version)
+    APP_VERSION="$2"
+    shift # past argument
+    shift # past value
+    ;;
+    *)    # unknown option
+    POSITIONAL+=("$1") # save it in an array for later
+    shift # past argument
+    ;;
+esac
+done
+set -- "${POSITIONAL[@]}" # restore positional parameters
+
+if [ -z $APP_VERSION ]; then echo "APP_VERSION is not set"; exit 1; fi
+
+# Store the hash and signatures here
+rm -rf release/signatures
+mkdir -p release/signatures 
+
+cd artifacts
+
+# Remove previous signatures/hashes
+rm -f sha256sum-v$APP_VERSION.txt
+rm -f signatures-v$APP_VERSION.tar.gz
+
+# sha256sum the binaries
+gsha256sum *$APP_VERSION* > sha256sum-v$APP_VERSION.txt
+
+for i in $( ls *zec-qt-wallet-v$APP_VERSION* sha256sum-v$APP_VERSION* ); do
+  echo "Signing" $i
+  gpg --batch --output ../release/signatures/$i.sig --detach-sig $i 
+done
+
+mv sha256sum-v$APP_VERSION.txt ../release/signatures/
+cp ../res/SIGNATURES_README ../release/signatures/README
+
+cd ../release/signatures
+tar -czf signatures-v$APP_VERSION.tar.gz *
+mv signatures-v$APP_VERSION.tar.gz ../../artifacts
+

src/sendtab.cpp

@@ -12,8 +12,7 @@ using json = nlohmann::json;
 
 void MainWindow::setupSendTab() {
     // Create the validator for send to/amount fields
-    auto amtValidator = new QDoubleValidator(0, 21000000, 8, ui->Amount1);
-    amtValidator->setNotation(QDoubleValidator::StandardNotation);
+    auto amtValidator = new QRegExpValidator(QRegExp("[0-9]{0,8}\\.?[0-9]{0,8}"));    
     ui->Amount1->setValidator(amtValidator);
 
     // Send button
@@ -74,8 +73,7 @@ void MainWindow::setupSendTab() {
         }
     });
     //Fees validator
-    auto feesValidator = new QDoubleValidator(0, 1, 8, ui->Amount1);
-    feesValidator->setNotation(QDoubleValidator::StandardNotation);
+    auto feesValidator = new QRegExpValidator(QRegExp("[0-9]{0,8}\\.?[0-9]{0,8}")); 
     ui->minerFeeAmt->setValidator(feesValidator);
 
     // Font for the first Memo label
@@ -101,6 +99,11 @@ void MainWindow::setupSendTab() {
     // Recurring schedule button
     QObject::connect(ui->btnRecurSchedule, &QPushButton::clicked, this, &MainWindow::editSchedule);
 
+    // Hide the recurring section for now
+    ui->chkRecurring->setVisible(false);
+    ui->lblRecurDesc->setVisible(false);
+    ui->btnRecurSchedule->setVisible(false);
+
     // Set the default state for the whole page
     clearSendForm();
 }
@@ -173,6 +176,31 @@ void MainWindow::setDefaultPayFrom() {
     }
 };
 
+void MainWindow::updateFromCombo() {
+    if (!rpc || !rpc->getAllBalances())
+        return;
+
+    auto lastFromAddr = ui->inputsCombo->currentText();
+
+    ui->inputsCombo->clear();
+    auto i = rpc->getAllBalances()->constBegin();
+
+    // Add all the addresses into the inputs combo box
+    while (i != rpc->getAllBalances()->constEnd()) {
+        ui->inputsCombo->addItem(i.key(), i.value());
+        if (i.key() == lastFromAddr) ui->inputsCombo->setCurrentText(i.key());
+
+        ++i;
+    }
+
+    if (lastFromAddr.isEmpty()) {
+        setDefaultPayFrom();
+    }
+    else {
+        ui->inputsCombo->setCurrentText(lastFromAddr);
+    }
+}
+
 void MainWindow::inputComboTextChanged(int index) {
     auto addr   = ui->inputsCombo->itemText(index);
     auto bal    = rpc->getAllBalances()->value(addr);
@@ -231,8 +259,9 @@ void MainWindow::addAddressSection() {
     Amount1->setPlaceholderText(tr("Amount"));    
     Amount1->setObjectName(QString("Amount") % QString::number(itemNumber));   
     Amount1->setBaseSize(QSize(200, 0));
+    Amount1->setAlignment(Qt::AlignRight);    
     // Create the validator for send to/amount fields
-    auto amtValidator = new QDoubleValidator(0, 21000000, 8, Amount1);
+    auto amtValidator = new QRegExpValidator(QRegExp("[0-9]{0,8}\\.?[0-9]{0,8}")); 
     Amount1->setValidator(amtValidator);
     QObject::connect(Amount1, &QLineEdit::textChanged, [=] (auto text) {
         this->amountChanged(itemNumber, text);

src/senttxstore.cpp

@@ -84,12 +84,22 @@ void SentTxStore::addToSentTx(Tx tx, QString txid) {
         totalAmount += i.amount;
     }
 
+    QString toAddresses;
+    if (tx.toAddrs.length() == 1) {
+        toAddresses = tx.toAddrs[0].addr;
+    } else {
+        // Concatenate all the toAddresses
+        for (auto a : tx.toAddrs) {
+            toAddresses += a.addr % "(" % Settings::getZECDisplayFormat(a.amount) % ")  ";
+        }
+    }
+
     auto list = jsonDoc.array();
     QJsonObject txItem;
     txItem["type"]      = "sent";
     txItem["from"]      = tx.fromAddr;
     txItem["datetime"]  = QDateTime::currentMSecsSinceEpoch() / (qint64)1000;
-    txItem["address"]   = QString();    // The sent address is blank, to be consistent with t-Addr sent behaviour
+    txItem["address"]   = toAddresses;
     txItem["txid"]      = txid;
     txItem["amount"]    = -totalAmount;
     txItem["fee"]       = -tx.fee;

src/settings.h

@@ -34,6 +34,9 @@ public:
     void    setUseEmbedded(bool r) { _useEmbedded = r; }
     bool    useEmbedded() { return _useEmbedded; }
 
+    void    setHeadless(bool h) { _headless = h; }
+    bool    isHeadless() { return _headless; }
+
     int     getBlockNumber();
     void    setBlockNumber(int number);
             
@@ -78,6 +81,8 @@ public:
     static double  getMinerFee();
     static double  getZboardAmount();
     static QString getZboardAddr();
+
+    static int     getMaxMobileAppTxns() { return 30; }
     
     static bool    isValidAddress(QString addr);
 
@@ -103,8 +108,10 @@ private:
     bool    _isSyncing        = false;
     int     _blockNumber      = 0;
     bool    _useEmbedded      = false;
+    bool    _headless         = false;
     int     _peerConnections  = 0;
-    double zecPrice = 0.0;
+    
+    double  zecPrice          = 0.0;
 };
 
 #endif // SETTINGS_H

src/turnstile.cpp

@@ -320,8 +320,10 @@ void Turnstile::executeMigrationStep() {
             return;
         }
 
+        // Sometimes, we check too quickly, and the unspent UTXO is not updated yet, so we'll
+        // double check to see if there is enough balance. 
         if (!rpc->getAllBalances()->keys().contains(nextStep->intTAddr)) {
-            qDebug() << QString("The intermediate t-address doesn't have balance, even though it is confirmed");
+            //qDebug() << QString("The intermediate t-address doesn't have balance, even though it seems to be confirmed");
             return;
         }
 
@@ -354,8 +356,9 @@ void Turnstile::doSendTx(Tx tx, std::function<void(void)> cb) {
     rpc->executeTransaction(tx, [=] (QString opid) {
             mainwindow->ui->statusBar->showMessage(QObject::tr("Computing Tx: ") % opid);
         },
-        [=] (QString opid, QString txid) { 
+        [=] (QString /*opid*/, QString txid) { 
             mainwindow->ui->statusBar->showMessage(Settings::txidStatusMessage + " " + txid);
+            cb();
         },
         [=] (QString opid, QString errStr) {
             mainwindow->ui->statusBar->showMessage(QObject::tr(" Tx ") % opid % QObject::tr(" failed"), 15 * 1000);

src/txtablemodel.cpp

@@ -186,14 +186,30 @@ void TxTableModel::updateAllData() {
      return QVariant();
  }
 
-QString TxTableModel::getTxId(int row) {
+QString TxTableModel::getTxId(int row) const {
     return modeldata->at(row).txid;
 }
 
-QString TxTableModel::getMemo(int row) {
+QString TxTableModel::getMemo(int row) const {
     return modeldata->at(row).memo;
 }
 
-QString TxTableModel::getAddr(int row) {
+qint64 TxTableModel::getConfirmations(int row) const {
+    return modeldata->at(row).confirmations;
+}
+
+QString TxTableModel::getAddr(int row) const {
     return modeldata->at(row).address.trimmed();
+}
+
+qint64 TxTableModel::getDate(int row) const {
+    return modeldata->at(row).datetime;
+}
+
+QString TxTableModel::getType(int row) const {
+    return modeldata->at(row).type;
+}
+
+QString TxTableModel::getAmt(int row) const {
+    return Settings::getDecimalString(modeldata->at(row).amount);
 }

src/txtablemodel.h

@@ -15,9 +15,13 @@ public:
     void addZSentData(const QList<TransactionItem>& data);
     void addZRecvData(const QList<TransactionItem>& data);     
 
-    QString  getTxId(int row);
-    QString  getMemo(int row);
-    QString  getAddr(int row);
+    QString  getTxId(int row) const;
+    QString  getMemo(int row) const;
+    QString  getAddr(int row) const;
+    qint64   getDate(int row) const;
+    QString  getType(int row) const;
+    qint64   getConfirmations(int row) const;
+    QString  getAmt (int row) const;
 
     bool     exportToCsv(QString fileName) const;
 

src/version.h

@@ -1 +1 @@
-#define APP_VERSION "0.5.7"
+#define APP_VERSION "0.6.1"

src/websockets.cpp

@@ -0,0 +1,803 @@
+#include "websockets.h"
+
+#include "rpc.h"
+#include "settings.h"
+#include "ui_mobileappconnector.h"
+#include "version.h"
+
+WSServer::WSServer(quint16 port, bool debug, QObject *parent) :
+    QObject(parent),
+    m_pWebSocketServer(new QWebSocketServer(QStringLiteral("Direct Connection Server"),
+                                            QWebSocketServer::NonSecureMode, this)),
+    m_debug(debug)
+{
+    m_mainWindow = (MainWindow *) parent;
+    if (m_pWebSocketServer->listen(QHostAddress::AnyIPv4, port)) {
+        if (m_debug)
+            qDebug() << "Echoserver listening on port" << port;
+        connect(m_pWebSocketServer, &QWebSocketServer::newConnection,
+                this, &WSServer::onNewConnection);
+        connect(m_pWebSocketServer, &QWebSocketServer::closed, this, &WSServer::closed);
+    }
+}
+
+WSServer::~WSServer()
+{
+    qDebug() << "Closing websocket";
+    m_pWebSocketServer->close();
+    qDeleteAll(m_clients.begin(), m_clients.end());
+}
+
+void WSServer::onNewConnection()
+{
+    QWebSocket *pSocket = m_pWebSocketServer->nextPendingConnection();
+
+    connect(pSocket, &QWebSocket::textMessageReceived, this, &WSServer::processTextMessage);
+    connect(pSocket, &QWebSocket::binaryMessageReceived, this, &WSServer::processBinaryMessage);
+    connect(pSocket, &QWebSocket::disconnected, this, &WSServer::socketDisconnected);
+
+    m_clients << pSocket;
+}
+
+void WSServer::processTextMessage(QString message)
+{
+    QWebSocket *pClient = qobject_cast<QWebSocket *>(sender());
+    if (m_debug)
+        qDebug() << "Message received:" << message;
+
+    if (pClient) {
+        AppDataServer::getInstance()->processMessage(message, m_mainWindow, pClient, AppConnectionType::DIRECT);
+    }
+}
+
+void WSServer::processBinaryMessage(QByteArray message)
+{
+    //QWebSocket *pClient = qobject_cast<QWebSocket *>(sender());
+    if (m_debug)
+        qDebug() << "Binary Message received:" << message;
+
+}
+
+void WSServer::socketDisconnected()
+{
+    QWebSocket *pClient = qobject_cast<QWebSocket *>(sender());
+    if (m_debug)
+        qDebug() << "socketDisconnected:" << pClient;
+    if (pClient) {
+        m_clients.removeAll(pClient);
+        pClient->deleteLater();
+    }
+}
+
+//===============================
+// WormholeClient
+//===============================
+WormholeClient::WormholeClient(MainWindow* p, QString wormholeCode) {
+    this->parent = p;
+    this->code = wormholeCode;
+    connect();
+}
+
+WormholeClient::~WormholeClient() {
+    shuttingDown = true;
+
+    if (m_webSocket->isValid()) {
+        m_webSocket->close();
+    }
+
+    if (timer)
+        timer->stop();
+        
+    delete timer;
+}
+
+void WormholeClient::connect() {
+    delete m_webSocket;
+    m_webSocket = new QWebSocket();
+
+    QObject::connect(m_webSocket, &QWebSocket::connected, this, &WormholeClient::onConnected);
+    QObject::connect(m_webSocket, &QWebSocket::disconnected, this, &WormholeClient::closed);
+
+    m_webSocket->open(QUrl("wss://wormhole.zecqtwallet.com:443"));
+    //m_webSocket->open(QUrl("ws://127.0.0.1:7070"));
+}
+
+void WormholeClient::retryConnect() {    
+    QTimer::singleShot(5 * 1000 * pow(2, retryCount), [=]() {
+        if (retryCount < 10) {
+            qDebug() << "Retrying websocket connection";
+            this->retryCount++;
+            connect();
+        }
+        else {
+            qDebug() << "Retry count exceeded, will not attempt retry any more";
+        }
+    });
+}
+
+// Called when the websocket is closed. If this was closed without our explicitly closing it, 
+// then we need to try and reconnect
+void WormholeClient::closed() {
+    if (!shuttingDown) {
+       retryConnect();
+    }
+}
+
+void WormholeClient::onConnected()
+{
+    qDebug() << "WebSocket connected";
+    retryCount = 0;
+
+    QObject::connect(m_webSocket, &QWebSocket::textMessageReceived,
+                        this, &WormholeClient::onTextMessageReceived);
+
+    auto payload = QJsonDocument( QJsonObject {
+        {"register", code}
+    }).toJson();
+
+    m_webSocket->sendTextMessage(payload);
+
+    // On connected, we'll also create a timer to ping it every 4 minutes, since the websocket 
+    // will timeout after 5 minutes
+    timer = new QTimer(parent);
+    QObject::connect(timer, &QTimer::timeout, [=]() {
+        if (!shuttingDown && m_webSocket->isValid()) {
+            auto payload = QJsonDocument(QJsonObject {
+                {"ping", "ping"}
+            }).toJson();
+            m_webSocket->sendTextMessage(payload);
+        }
+    });
+    timer->start(4 * 60 * 1000); // 4 minutes
+}
+
+void WormholeClient::onTextMessageReceived(QString message)
+{
+    AppDataServer::getInstance()->processMessage(message, parent, m_webSocket, AppConnectionType::INTERNET);
+}
+
+
+// ==============================
+// AppDataServer
+// ==============================
+AppDataServer* AppDataServer::instance = nullptr; 
+
+QString AppDataServer::getWormholeCode(QString secretHex) {
+    unsigned char* secret = new unsigned char[crypto_secretbox_KEYBYTES];
+    sodium_hex2bin(secret, crypto_secretbox_KEYBYTES, secretHex.toStdString().c_str(), crypto_secretbox_KEYBYTES*2, 
+        NULL, NULL, NULL);
+
+    unsigned char* out1 = new unsigned char[crypto_hash_sha256_BYTES];
+    crypto_hash_sha256(out1, secret, crypto_secretbox_KEYBYTES);
+
+    unsigned char* out2 = new unsigned char[crypto_hash_sha256_BYTES];
+    crypto_hash_sha256(out2, out1, crypto_hash_sha256_BYTES);
+
+    char* wmcode = new char[crypto_hash_sha256_BYTES*2 + 1];
+    sodium_bin2hex(wmcode, crypto_hash_sha256_BYTES*2 + 1, out2, crypto_hash_sha256_BYTES);    
+
+    QString wmcodehex(wmcode);
+
+    delete[] wmcode;
+    delete[] out2;
+    delete[] out1;
+    delete[] secret;
+
+    return wmcodehex;
+}
+
+QString AppDataServer::getSecretHex() {
+    QSettings s;
+
+    return s.value("mobileapp/secret", "").toString();
+}
+
+void AppDataServer::saveNewSecret(QString secretHex) {
+    QSettings().setValue("mobileapp/secret", secretHex);
+
+    if (secretHex.isEmpty())
+        setAllowInternetConnection(false);
+}
+
+bool AppDataServer::getAllowInternetConnection() {
+    return QSettings().value("mobileapp/allowinternet", false).toBool();
+}
+
+void AppDataServer::setAllowInternetConnection(bool allow) {
+    QSettings().setValue("mobileapp/allowinternet", allow);
+}
+
+void AppDataServer::saveLastConnectedOver(AppConnectionType type) {
+    QSettings().setValue("mobileapp/lastconnectedover", type);
+}
+
+AppConnectionType AppDataServer::getLastConnectionType() {
+    return (AppConnectionType) QSettings().value("mobileapp/lastconnectedover", AppConnectionType::DIRECT).toInt();
+}
+
+void AppDataServer::saveLastSeenTime() {
+    QSettings().setValue("mobileapp/lastseentime", QDateTime::currentSecsSinceEpoch());
+}
+
+QDateTime  AppDataServer::getLastSeenTime() {
+    return QDateTime::fromSecsSinceEpoch(QSettings().value("mobileapp/lastseentime", 0).toLongLong());
+}
+
+void AppDataServer::setConnectedName(QString name) {
+    QSettings().setValue("mobileapp/connectedname", name);
+}
+
+QString AppDataServer::getConnectedName() {
+    return QSettings().value("mobileapp/connectedname", "").toString();
+}
+
+bool AppDataServer::isAppConnected() {
+    return !getConnectedName().isEmpty() && 
+        getLastSeenTime().daysTo(QDateTime::currentDateTime()) < 14;
+}
+
+void AppDataServer::connectAppDialog(MainWindow* parent) {
+    QDialog d(parent);
+    ui = new Ui_MobileAppConnector();
+    ui->setupUi(&d);
+    Settings::saveRestore(&d);
+
+    updateUIWithNewQRCode(parent);
+    updateConnectedUI();
+
+    QObject::connect(ui->btnDisconnect, &QPushButton::clicked, [=] () {
+        QSettings().setValue("mobileapp/connectedname", "");
+        saveNewSecret("");
+
+        updateConnectedUI();
+    });
+    
+    QObject::connect(ui->txtConnStr, &QLineEdit::cursorPositionChanged, [=](int, int) {
+        ui->txtConnStr->selectAll();
+    });
+
+    QObject::connect(ui->chkInternetConn, &QCheckBox::stateChanged, [=] (int state) {
+        if (state == Qt::Checked) {
+
+        }
+        updateUIWithNewQRCode(parent);
+    });
+
+    // If we're not listening for the app, then start the websockets
+    if (!parent->isWebsocketListening()) {
+        QString wormholecode = "";
+        if (getAllowInternetConnection())
+            wormholecode = AppDataServer::getInstance()->getWormholeCode(AppDataServer::getInstance()->getSecretHex());
+
+        parent->createWebsocket(wormholecode);
+    }
+
+    d.exec();
+
+    // If there is nothing connected when the dialog exits, then shutdown the websockets
+    if (!isAppConnected()) {
+        parent->stopWebsocket();
+    }
+
+    // Cleanup
+    tempSecret = "";
+    
+    delete tempWormholeClient;
+    tempWormholeClient = nullptr;
+
+    delete ui;
+    ui = nullptr;
+}
+
+void AppDataServer::updateUIWithNewQRCode(MainWindow* mainwindow) {
+    // Get the address of the localhost
+    auto addrList = QNetworkInterface::allAddresses();
+
+    // Find a suitable address
+    QString ipv4Addr;
+    for (auto addr : addrList) {
+        if (addr.isLoopback() || addr.protocol() == QAbstractSocket::IPv6Protocol)
+            continue;
+
+        ipv4Addr = addr.toString();
+        break;
+    }
+
+    if (ipv4Addr.isEmpty())
+        return;
+    
+    QString uri = "ws://" + ipv4Addr + ":8237";
+
+    // Get a new secret
+    unsigned char* secretBin = new unsigned char[crypto_secretbox_KEYBYTES];
+    randombytes_buf(secretBin, crypto_secretbox_KEYBYTES);
+    char* secretHex = new char[crypto_secretbox_KEYBYTES*2 + 1];
+    sodium_bin2hex(secretHex, crypto_secretbox_KEYBYTES*2+1, secretBin, crypto_secretbox_KEYBYTES);
+
+    QString secretStr(secretHex);
+    QString codeStr = uri + "," + secretStr;
+
+    if (ui->chkInternetConn->isChecked()) {
+        codeStr = codeStr + ",1";
+    }
+
+    registerNewTempSecret(secretStr, ui->chkInternetConn->isChecked(), mainwindow);
+
+    ui->qrcode->setQrcodeString(codeStr);
+    ui->txtConnStr->setText(codeStr);
+}
+
+void AppDataServer::registerNewTempSecret(QString tmpSecretHex, bool allowInternet, MainWindow* main) {
+    tempSecret = tmpSecretHex;
+
+    delete tempWormholeClient;
+    tempWormholeClient = nullptr;
+
+    if (allowInternet)
+        tempWormholeClient = new WormholeClient(main, getWormholeCode(tempSecret));
+}
+
+QString AppDataServer::connDesc(AppConnectionType t) {
+    if (t == AppConnectionType::DIRECT) {
+        return QObject::tr("Connected directly");
+    }
+    else {
+        return QObject::tr("Connected over the internet via zec-qt-wallet wormhole service");
+    }
+}
+
+void AppDataServer::updateConnectedUI() {
+    if (ui == nullptr)
+        return;
+
+    auto remoteName = getConnectedName();
+
+    ui->lblRemoteName->setText(remoteName.isEmpty() ?  "(Not connected to any device)" : remoteName);
+    ui->lblLastSeen->setText(remoteName.isEmpty() ? "" : getLastSeenTime().toString(Qt::SystemLocaleLongDate));
+    ui->lblConnectionType->setText(remoteName.isEmpty() ? "" : connDesc(getLastConnectionType()));
+
+    ui->btnDisconnect->setEnabled(!remoteName.isEmpty());
+}
+
+QString AppDataServer::getNonceHex(NonceType nt) {
+    QSettings s;
+    QString hex;
+    if (nt == NonceType::LOCAL) {
+        // The default local nonce starts from 1, to always keep it odd
+        auto defaultLocalNonce = "01" + QString("00").repeated(crypto_secretbox_NONCEBYTES-1);
+        hex = s.value("mobileapp/localnoncehex", defaultLocalNonce).toString();
+    }
+    else {
+        hex = s.value("mobileapp/remotenoncehex", QString("00").repeated(crypto_secretbox_NONCEBYTES)).toString();
+    }
+    return hex;
+}
+
+void AppDataServer::saveNonceHex(NonceType nt, QString noncehex) {
+    QSettings s;
+    assert(noncehex.length() == crypto_secretbox_NONCEBYTES * 2);
+    if (nt == NonceType::LOCAL) {
+        s.setValue("mobileapp/localnoncehex", noncehex);
+    }
+    else {
+        s.setValue("mobileapp/remotenoncehex", noncehex);
+    }
+    s.sync();
+}
+
+// Encrypt an outgoing message with the stored secret key.
+QString AppDataServer::encryptOutgoing(QString msg) {
+    if (msg.length() % 256 > 0) {
+        msg = msg + QString(" ").repeated(256 - (msg.length() % 256));
+    }
+
+    QString localNonceHex = getNonceHex(NonceType::LOCAL);
+
+    unsigned char* noncebin = new unsigned char[crypto_secretbox_NONCEBYTES];
+    sodium_hex2bin(noncebin, crypto_secretbox_NONCEBYTES, localNonceHex.toStdString().c_str(), localNonceHex.length(),
+        NULL, NULL, NULL);
+
+    // Increment the nonce +2 and save
+    sodium_increment(noncebin, crypto_secretbox_NONCEBYTES);
+    sodium_increment(noncebin, crypto_secretbox_NONCEBYTES);
+
+    char* newLocalNonce = new char[crypto_secretbox_NONCEBYTES*2 + 1];
+    sodium_memzero(newLocalNonce, crypto_secretbox_NONCEBYTES*2 + 1);
+    sodium_bin2hex(newLocalNonce, crypto_secretbox_NONCEBYTES*2+1, noncebin, crypto_box_NONCEBYTES);
+
+    saveNonceHex(NonceType::LOCAL, QString(newLocalNonce));
+
+    unsigned char* secret = new unsigned char[crypto_secretbox_KEYBYTES];
+    sodium_hex2bin(secret, crypto_secretbox_KEYBYTES, getSecretHex().toStdString().c_str(), crypto_secretbox_KEYBYTES*2, 
+        NULL, NULL, NULL);
+
+    int msgSize = strlen(msg.toStdString().c_str());
+    unsigned char* encrpyted = new unsigned char[ msgSize + crypto_secretbox_MACBYTES];
+
+    crypto_secretbox_easy(encrpyted, (const unsigned char *)msg.toStdString().c_str(), msgSize, noncebin, secret);
+
+    int encryptedHexSize = (msgSize + crypto_secretbox_MACBYTES) * 2 + 1;
+    char * encryptedHex = new char[encryptedHexSize];     
+    sodium_memzero(encryptedHex, encryptedHexSize);
+    sodium_bin2hex(encryptedHex, encryptedHexSize, encrpyted, msgSize + crypto_secretbox_MACBYTES);
+
+    auto json =  QJsonDocument(QJsonObject{
+            {"nonce", QString(newLocalNonce)},
+            {"payload", QString(encryptedHex)},
+            {"to", getWormholeCode(getSecretHex())}
+        });
+    
+    delete[] noncebin;
+    delete[] newLocalNonce;
+    delete[] secret;
+    delete[] encrpyted;
+    delete[] encryptedHex;
+
+    return json.toJson();
+}
+
+/**
+  Attempt to decrypt a message. If the decryption fails, it returns the string "error", the decrypted message otherwise. 
+  It will use the given secret to attempt decryption. In addition, it will enforce that the nonce is greater than the last seen nonce, 
+  unless the skipNonceCheck = true, which is used when attempting decrtption with a temp secret key.
+*/
+QString AppDataServer::decryptMessage(QJsonDocument msg, QString secretHex, QString lastRemoteNonceHex) {
+    // Decrypt and then process
+    QString noncehex = msg.object().value("nonce").toString();
+    QString encryptedhex = msg.object().value("payload").toString();
+
+    // Enforce limits on the size of the message
+    if (noncehex.length() > ((int)crypto_secretbox_NONCEBYTES * 2) ||
+        encryptedhex.length() > 2 * 50 * 1024 /*50kb*/) {
+        return "error";
+    }
+
+    // Check to make sure that the nonce is greater than the last known remote nonce
+    unsigned char* lastRemoteBin = new unsigned char[crypto_secretbox_NONCEBYTES];
+    sodium_hex2bin(lastRemoteBin, crypto_secretbox_NONCEBYTES, lastRemoteNonceHex.toStdString().c_str(), lastRemoteNonceHex.length(),
+        NULL, NULL, NULL);
+
+    unsigned char* noncebin = new unsigned char[crypto_secretbox_NONCEBYTES];
+    sodium_hex2bin(noncebin, crypto_secretbox_NONCEBYTES, noncehex.toStdString().c_str(), noncehex.length(),
+        NULL, NULL, NULL);
+
+    assert(crypto_secretbox_KEYBYTES == crypto_hash_sha256_BYTES);
+    if (sodium_compare(lastRemoteBin, noncebin, crypto_secretbox_NONCEBYTES) != -1) {
+        // Refuse to accept a lower nonce, return an error
+        delete[] lastRemoteBin;
+        delete[] noncebin;
+        return "error";
+    }
+    
+    unsigned char* secret = new unsigned char[crypto_secretbox_KEYBYTES];
+    sodium_hex2bin(secret, crypto_secretbox_KEYBYTES, secretHex.toStdString().c_str(), crypto_secretbox_KEYBYTES*2, 
+        NULL, NULL, NULL);
+
+    unsigned char* encrypted = new unsigned char[encryptedhex.length() / 2];
+    sodium_hex2bin(encrypted, encryptedhex.length() / 2, encryptedhex.toStdString().c_str(), encryptedhex.length(),
+                    NULL, NULL, NULL);
+
+    int decryptedLen = encryptedhex.length() / 2 - crypto_secretbox_MACBYTES;
+    unsigned char* decrypted = new unsigned char[decryptedLen];
+    int result = crypto_secretbox_open_easy(decrypted, encrypted, encryptedhex.length() / 2, noncebin, secret);
+
+    QString payload;
+    if (result == -1) {
+        payload = "error";        
+    } else {
+        // Update the last seen remote hex
+        saveNonceHex(NonceType::REMOTE, noncehex);
+        saveLastSeenTime();
+
+        char* decryptedStr = new char[decryptedLen + 1];
+        sodium_memzero(decryptedStr, decryptedLen + 1);
+        memcpy(decryptedStr, decrypted, decryptedLen);
+
+        payload = QString(decryptedStr);
+
+        delete[] decryptedStr;
+    }
+
+    delete[] secret;
+    delete[] lastRemoteBin;
+    delete[] noncebin;
+    delete[] encrypted;
+    delete[] decrypted;
+    
+    return payload;
+}
+
+// Process an incoming text message. The message has to be encrypted with the secret key (or the temporary secret key)
+void AppDataServer::processMessage(QString message, MainWindow* mainWindow, QWebSocket* pClient, AppConnectionType connType) {
+    auto replyWithError = [=]() {
+        auto r = QJsonDocument(QJsonObject{
+                    {"error", "Encryption error"},
+                    {"to", getWormholeCode(getSecretHex())}
+            }).toJson();
+            pClient->sendTextMessage(r);
+            return;
+    };
+    
+    // First, extract the command from the message
+    auto msg = QJsonDocument::fromJson(message.toUtf8());
+
+    // Check if we got an error from the websocket
+    if (msg.object().contains("error")) {
+        qDebug() << "Error:" << msg.toJson();
+        return;
+    }
+
+    // If the message is a ping, just ignore it
+    if (msg.object().contains("ping")) {
+        return;
+    }
+
+    // Then, check if the message is encrpted
+    if (!msg.object().contains("nonce")) {
+        replyWithError();
+        return;
+    }
+
+    auto decrypted = decryptMessage(msg, getSecretHex(), getNonceHex(NonceType::REMOTE));
+
+    // If the decryption failed, maybe this is a new connection, so see if the dialog is open and a 
+    // temp secret is in place
+    if (decrypted == "error") {
+        // If the dialog is open, then there might be a temporary, new secret key. Attempt to decrypt
+        // with that.
+        if (!tempSecret.isEmpty()) {
+            // Since this is a temp secret, the last seen nonce will be "0", so basically we'll accept any nonce
+            QString zeroNonce = QString("00").repeated(crypto_secretbox_NONCEBYTES);
+            decrypted = decryptMessage(msg, tempSecret, zeroNonce);
+            if (decrypted == "error") {
+                // Oh, well. Just return an error
+                replyWithError();
+                return;
+            }
+            else {
+                // This is a new connection. So, update the the secret. Note the last seen remote nonce has already been updated by
+                // decryptMessage()
+                saveNewSecret(tempSecret);
+                setAllowInternetConnection(tempWormholeClient != nullptr);
+
+                // Swap out the wormhole connection
+                mainWindow->replaceWormholeClient(tempWormholeClient);
+                tempWormholeClient = nullptr;
+
+                saveLastConnectedOver(connType);
+                processDecryptedMessage(decrypted, mainWindow, pClient);
+
+                // If the Connection UI is showing, we have to update the UI as well
+                if (ui != nullptr) {
+                    // Update the connected phone information
+                    updateConnectedUI();
+
+                    // Update with a new QR Code for safety, so this secret isn't used by anyone else
+                    updateUIWithNewQRCode(mainWindow);
+                }
+
+                return;
+            }
+        }
+        else {
+            replyWithError();
+            return;
+        }
+    } else {
+        saveLastConnectedOver(connType);
+        processDecryptedMessage(decrypted, mainWindow, pClient);
+        return;
+    }
+}
+
+// Decrypted method will be executed here. 
+void AppDataServer::processDecryptedMessage(QString message, MainWindow* mainWindow, QWebSocket* pClient) {
+    // First, extract the command from the message
+    auto msg = QJsonDocument::fromJson(message.toUtf8());
+
+    if (!msg.object().contains("command")) {
+        auto r = QJsonDocument(QJsonObject{
+            {"errorCode", -1},
+            {"errorMessage", "Unknown JSON format"}
+        }).toJson();
+        pClient->sendTextMessage(encryptOutgoing(r));
+        return;
+    }
+    
+    if (msg.object()["command"] == "getInfo") {
+        processGetInfo(msg.object(), mainWindow, pClient);
+    }
+    else if (msg.object()["command"] == "getTransactions") {
+        processGetTransactions(mainWindow, pClient);
+    }
+    else if (msg.object()["command"] == "sendTx") {
+        processSendTx(msg.object()["tx"].toObject(), mainWindow, pClient);
+    }
+    else {
+        auto r = QJsonDocument(QJsonObject{
+            {"errorCode", -1},
+            {"errorMessage", "Command not found:" + msg.object()["command"].toString()}
+        }).toJson();
+        pClient->sendTextMessage(encryptOutgoing(r));
+    }
+}
+
+// "sendTx" command. This method will actually send money, so be careful with everything
+void AppDataServer::processSendTx(QJsonObject sendTx, MainWindow* mainwindow, QWebSocket* pClient) {
+    auto error = [=](QString reason) {
+        auto r = QJsonDocument(QJsonObject{
+           {"errorCode", -1},
+           {"errorMessage", "Couldn't send Tx:" + reason}
+        }).toJson();
+        pClient->sendTextMessage(encryptOutgoing(r));
+        return;
+    };
+
+    // Refuse to send if the node is still syncing
+    if (Settings::getInstance()->isSyncing()) {
+        error(QObject::tr("Node is still syncing."));
+        return;
+    }
+
+    // Create a Tx Object
+    Tx tx;
+    tx.fee = Settings::getMinerFee();
+
+    // Find a from address that has at least the sending amout
+    double amt = sendTx["amount"].toString().toDouble();
+    auto allBalances = mainwindow->getRPC()->getAllBalances();
+    QList<QPair<QString, double>> bals;
+    for (auto i : allBalances->keys()) {
+        // Filter out sprout addresses
+        if (Settings::getInstance()->isSproutAddress(i))
+            continue;
+        // Filter out balances that don't have the requisite amount
+        if (allBalances->value(i) < amt)
+            continue;
+
+        bals.append(QPair<QString, double>(i, allBalances->value(i)));
+    }
+
+    if (bals.isEmpty()) {
+        error(QObject::tr("No sapling or transparent addresses with enough balance to spend."));
+        return;
+    }
+
+    std::sort(bals.begin(), bals.end(), [=](const QPair<QString, double>a, const QPair<QString, double> b) -> bool {
+        // Sort z addresses first
+        return a.first > b.first;
+    });
+
+    tx.fromAddr = bals[0].first;
+    tx.toAddrs = { ToFields{ sendTx["to"].toString(), amt, sendTx["memo"].toString(), sendTx["memo"].toString().toUtf8().toHex()} };
+
+    // TODO: Respect the autoshield change setting
+
+    QString validation = mainwindow->doSendTxValidations(tx);
+    if (!validation.isEmpty()) {
+        error(validation);
+        return;
+    }
+
+    json params = json::array();
+    mainwindow->getRPC()->fillTxJsonParams(params, tx);
+    std::cout << std::setw(2) << params << std::endl;
+
+    // And send the Tx
+    mainwindow->getRPC()->executeTransaction(tx,
+        [=] (QString) {}, 
+        // Submitted Tx successfully
+        [=] (QString, QString txid) {
+            auto r = QJsonDocument(QJsonObject{
+               {"version", 1.0},
+               {"command", "sendTxSubmitted"},
+               {"txid",  txid}
+            }).toJson();
+            if (pClient->isValid())
+                pClient->sendTextMessage(encryptOutgoing(r));
+        },
+        // Errored while submitting Tx
+        [=] (QString, QString errStr) {
+            auto r = QJsonDocument(QJsonObject{
+               {"version", 1.0},
+               {"command", "sendTxFailed"},
+               {"err",  errStr}
+            }).toJson();
+            if (pClient->isValid())
+                pClient->sendTextMessage(encryptOutgoing(r));
+        }   
+    );
+
+    auto r = QJsonDocument(QJsonObject{
+            {"version", 1.0},
+            {"command", "sendTx"},
+            {"result",  "success"}
+        }).toJson();
+    pClient->sendTextMessage(encryptOutgoing(r));
+}
+
+// "getInfo" command
+void AppDataServer::processGetInfo(QJsonObject jobj, MainWindow* mainWindow, QWebSocket* pClient) {
+    auto connectedName = jobj["name"].toString();
+    
+    if (mainWindow == nullptr || mainWindow->getRPC() == nullptr ||
+            mainWindow->getRPC()->getAllBalances() == nullptr) {
+        pClient->close(QWebSocketProtocol::CloseCodeNormal, "Not yet ready");
+        return;
+    }
+
+
+    // Max spendable safely from a z address and from any address
+    double maxZSpendable = 0;
+    double maxSpendable = 0;
+    for (auto a : mainWindow->getRPC()->getAllBalances()->keys()) {
+        if (Settings::getInstance()->isSaplingAddress(a)) {
+            if (mainWindow->getRPC()->getAllBalances()->value(a) > maxZSpendable) {
+                maxZSpendable = mainWindow->getRPC()->getAllBalances()->value(a);
+            }
+        }
+        if (mainWindow->getRPC()->getAllBalances()->value(a) > maxSpendable) {
+            maxSpendable = mainWindow->getRPC()->getAllBalances()->value(a);
+        }
+    }
+
+    setConnectedName(connectedName);
+
+    auto r = QJsonDocument(QJsonObject{
+        {"version", 1.0},
+        {"command", "getInfo"},
+        {"saplingAddress", mainWindow->getRPC()->getDefaultSaplingAddress()},
+        {"tAddress", mainWindow->getRPC()->getDefaultTAddress()},
+        {"balance", AppDataModel::getInstance()->getTotalBalance()},
+        {"maxspendable", maxSpendable},
+        {"maxzspendable", maxZSpendable},
+        {"tokenName", Settings::getTokenName()},
+        {"zecprice", Settings::getInstance()->getZECPrice()},
+        {"serverversion", QString(APP_VERSION)}
+    }).toJson();
+    pClient->sendTextMessage(encryptOutgoing(r));
+}
+
+void AppDataServer::processGetTransactions(MainWindow* mainWindow, QWebSocket* pClient) {
+    QJsonArray txns;
+    auto model = mainWindow->getRPC()->getTransactionsModel();
+
+    // Manually add pending ops, so that computing transactions will also show up
+    auto wtxns = mainWindow->getRPC()->getWatchingTxns();
+    for (auto opid : wtxns.keys()) {
+        txns.append(QJsonObject{
+            {"type", "send"},
+            {"datetime", QDateTime::currentSecsSinceEpoch()},
+            {"amount", Settings::getDecimalString(wtxns[opid].tx.toAddrs[0].amount)},
+            {"txid", ""},
+            {"address", wtxns[opid].tx.toAddrs[0].addr},
+            {"memo", wtxns[opid].tx.toAddrs[0].txtMemo},
+            {"confirmations", 0}
+            });
+    }
+    
+    // Add transactions
+    for (int i = 0; i < model->rowCount(QModelIndex()) && i < Settings::getMaxMobileAppTxns(); i++) {
+        txns.append(QJsonObject{
+            {"type", model->getType(i)},
+            {"datetime", model->getDate(i)},
+            {"amount", model->getAmt(i)},
+            {"txid", model->getTxId(i)},
+            {"address", model->getAddr(i)},
+            {"memo", model->getMemo(i)},
+            {"confirmations", model->getConfirmations(i)}
+        });
+    }
+
+    auto r = QJsonDocument(QJsonObject{
+            {"version", 1.0},
+            {"command", "getTransactions"},
+            {"transactions", txns}
+        }).toJson();
+    pClient->sendTextMessage(encryptOutgoing(r));
+}
+
+// ==============================
+// AppDataModel
+// ==============================
+AppDataModel* AppDataModel::instance = nullptr;

src/websockets.h

@@ -0,0 +1,161 @@
+#ifndef WEBSOCKETS_H
+#define WEBSOCKETS_H
+
+#include "precompiled.h"
+
+#include "mainwindow.h"
+#include "ui_mobileappconnector.h"
+
+
+QT_FORWARD_DECLARE_CLASS(QWebSocketServer)
+QT_FORWARD_DECLARE_CLASS(QWebSocket)
+
+class WSServer : public QObject
+{
+    Q_OBJECT
+public:
+    explicit WSServer(quint16 port, bool debug = false, QObject *parent = nullptr);
+    ~WSServer();
+
+Q_SIGNALS:
+    void closed();
+
+private Q_SLOTS:
+    void onNewConnection();
+    void processTextMessage(QString message);
+    void processBinaryMessage(QByteArray message);
+    void socketDisconnected();
+
+private:
+    QWebSocketServer *m_pWebSocketServer;
+    MainWindow *m_mainWindow;
+    QList<QWebSocket *> m_clients;
+    bool m_debug;
+};
+
+class WormholeClient : public QObject {
+    Q_OBJECT 
+
+private Q_SLOTS:
+    void onConnected();
+    void onTextMessageReceived(QString message);
+    void closed();
+
+public:
+    WormholeClient(MainWindow* parent, QString wormholeCode);
+    ~WormholeClient();
+
+    void connect();
+    void retryConnect();
+
+private:
+    MainWindow* parent = nullptr;    
+    QWebSocket*  m_webSocket = nullptr;
+    
+    QTimer* timer            = nullptr;
+
+    QString     code;
+    int  retryCount          = 0;
+    bool shuttingDown        = false;
+};
+
+enum NonceType {
+    LOCAL = 1,
+    REMOTE
+};
+
+enum AppConnectionType {
+    DIRECT = 1,
+    INTERNET
+};
+
+class AppDataServer {
+public:
+    static AppDataServer* getInstance() {
+        if (instance == nullptr) {
+            instance = new AppDataServer();
+        }
+        return instance;
+    }
+
+    void          connectAppDialog(MainWindow* parent);
+    void          updateConnectedUI();
+    void          updateUIWithNewQRCode(MainWindow* mainwindow);
+
+    void          processSendTx(QJsonObject sendTx, MainWindow* mainwindow, QWebSocket* pClient);
+    void          processMessage(QString message, MainWindow* mainWindow, QWebSocket* pClient, AppConnectionType connType);
+    void          processGetInfo(QJsonObject jobj, MainWindow* mainWindow, QWebSocket* pClient);
+    void          processDecryptedMessage(QString message, MainWindow* mainWindow, QWebSocket* pClient);
+    void          processGetTransactions(MainWindow* mainWindow, QWebSocket* pClient);
+
+    QString       decryptMessage(QJsonDocument msg, QString secretHex, QString lastRemoteNonceHex);
+    QString       encryptOutgoing(QString msg);
+
+    QString       getWormholeCode(QString secretHex);
+    QString       getSecretHex();
+    void          saveNewSecret(QString secretHex);
+
+    void          registerNewTempSecret(QString tmpSecretHex, bool allowInternet, MainWindow* main);
+
+    QString       getNonceHex(NonceType nt);
+    void          saveNonceHex(NonceType nt, QString noncehex);
+
+    bool          getAllowInternetConnection();
+    void          setAllowInternetConnection(bool allow);
+
+    void          saveLastSeenTime();
+    QDateTime     getLastSeenTime();
+
+    void          setConnectedName(QString name);   
+    QString       getConnectedName();
+    bool          isAppConnected();
+
+    QString       connDesc(AppConnectionType t);
+
+    void               saveLastConnectedOver(AppConnectionType type);
+    AppConnectionType  getLastConnectionType();
+
+private:
+    AppDataServer() = default;
+
+    static AppDataServer*   instance;
+    Ui_MobileAppConnector*  ui;
+
+    QString                 tempSecret;
+    WormholeClient*         tempWormholeClient = nullptr;
+};
+
+class AppDataModel {
+public:
+    static AppDataModel* getInstance() {
+        if (instance == NULL)
+            instance = new AppDataModel();
+
+        return instance;
+    }
+
+    double getTBalance()     { return balTransparent;  }
+    double getZBalance()     { return balShielded; }
+    double getTotalBalance() { return balTotal; }
+
+    void   setBalances(double transparent, double shielded) {
+        balTransparent = transparent;
+        balShielded = shielded;
+        balTotal = balTransparent + balShielded;
+    }
+
+private:
+    AppDataModel() = default;   // Private, for singleton
+
+    double balTransparent;
+    double balShielded;
+    double balTotal;
+
+    QString saplingAddress;
+
+    static AppDataModel* instance;
+};
+
+
+
+#endif // WEBSOCKETS_H

wsclient.html

@@ -0,0 +1,102 @@
+<html>
+<head>
+    <title>WebSocket Echo Client</title>
+</head>
+<body>
+    <h1>WebSocket Echo Client</h1>
+    <p>
+        <button onClick="initWebSocket();">Connect</button>
+        <button onClick="stopWebSocket();">Disconnect</button>
+        <button onClick="checkSocket();">State</button>
+    </p>
+    <p>
+        <textarea id="debugTextArea" style="width:400px;height:200px;"></textarea>
+    </p>
+    <p>
+        <input type="text" id="inputText" onkeydown="if(event.keyCode==13)sendMessage();" />
+        <button onClick="sendMessage();">Send</button>
+    </p>
+
+    <script type="text/javascript">
+            var debugTextArea = document.getElementById("debugTextArea");
+            function debug(message) {
+                debugTextArea.value += message + "\n";
+                debugTextArea.scrollTop = debugTextArea.scrollHeight;
+            }
+
+            function sendMessage() {
+                var msg = document.getElementById("inputText").value;
+                if ( websocket != null )
+                {
+                    document.getElementById("inputText").value = "";
+                    websocket.send( msg );
+                    console.log( "string sent :", '"'+msg+'"' );
+                }
+            }
+
+            var wsUri = "ws://localhost:7070";
+            var websocket = null;
+
+            function initWebSocket() {
+                try {
+                    if (typeof MozWebSocket == 'function')
+                        WebSocket = MozWebSocket;
+                    if ( websocket && websocket.readyState == 1 )
+                        websocket.close();
+                    websocket = new WebSocket( wsUri );
+                    websocket.onopen = function (evt) {
+                        debug("CONNECTED");
+                    };
+                    websocket.onclose = function (evt) {
+                        debug("DISCONNECTED");
+                    };
+                    websocket.onmessage = function (evt) {
+                        console.log( "Message received :", evt.data );
+                        debug( evt.data );
+                    };
+                    websocket.onerror = function (evt) {
+                        debug('ERROR: ' + evt.data);
+                    };
+                } catch (exception) {
+                    debug('ERROR: ' + exception);
+                }
+            }
+
+            function stopWebSocket() {
+                if (websocket)
+                    websocket.close();
+            }
+
+            function checkSocket() {
+                if (websocket != null) {
+                    var stateStr;
+                    switch (websocket.readyState) {
+                        case 0: {
+                            stateStr = "CONNECTING";
+                            break;
+                        }
+                        case 1: {
+                            stateStr = "OPEN";
+                            break;
+                        }
+                        case 2: {
+                            stateStr = "CLOSING";
+                            break;
+                        }
+                        case 3: {
+                            stateStr = "CLOSED";
+                            break;
+                        }
+                        default: {
+                            stateStr = "UNKNOWN";
+                            break;
+                        }
+                    }
+                    debug("WebSocket state = " + websocket.readyState + " ( " + stateStr + " )");
+                } else {
+                    debug("WebSocket is null");
+                }
+            }
+    </script>
+</body>
+</html>

zec-qt-wallet.pro

@@ -10,7 +10,8 @@ CONFIG += precompile_header
 
 PRECOMPILED_HEADER = src/precompiled.h
 
-greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
+QT += widgets
+QT += websockets
 
 TARGET = zec-qt-wallet
 
@@ -45,13 +46,15 @@ SOURCES += \
     src/sendtab.cpp \
     src/senttxstore.cpp \
     src/txtablemodel.cpp \
-	src/turnstile.cpp \
+    src/turnstile.cpp \
     src/qrcodelabel.cpp \
     src/connection.cpp \
     src/fillediconlabel.cpp \
     src/addressbook.cpp \
     src/logger.cpp \
     src/addresscombo.cpp \
+    src/websockets.cpp \
+    src/mobileappconnector.cpp \
     src/recurring.cpp
 
 HEADERS += \
@@ -66,13 +69,15 @@ HEADERS += \
     src/settings.h \
     src/txtablemodel.h \
     src/senttxstore.h \
-	src/turnstile.h \
+    src/turnstile.h \
     src/qrcodelabel.h \
     src/connection.h \
     src/fillediconlabel.h \
     src/addressbook.h \
     src/logger.h \
     src/addresscombo.h \ 
+    src/websockets.h \
+    src/mobileappconnector.h \
     src/recurring.h
 
 FORMS += \
@@ -87,6 +92,8 @@ FORMS += \
     src/connection.ui \
     src/zboard.ui \
     src/addressbook.ui \
+    src/mobileappconnector.ui \
+    src/createzcashconfdialog.ui \
     src/recurringdialog.ui \
     src/newrecurring.ui
 
@@ -94,14 +101,32 @@ FORMS += \
 TRANSLATIONS = res/zec_qt_wallet_es.ts \
                res/zec_qt_wallet_fr.ts \
                res/zec_qt_wallet_de.ts \
-               res/zec_qt_wallet_pt.ts 
+               res/zec_qt_wallet_pt.ts \
+               res/zec_qt_wallet_it.ts 
 
 win32: RC_ICONS = res/icon.ico
 ICON = res/logo.icns
 
+libsodium.target = $$PWD/res/libsodium.a
+libsodium.commands = res/libsodium/buildlibsodium.sh
+
+QMAKE_EXTRA_TARGETS += libsodium
+QMAKE_CLEAN += res/libsodium.a
 
 # Default rules for deployment.
 qnx: target.path = /tmp/$${TARGET}/bin
 else: unix:!android: target.path = /opt/$${TARGET}/bin
 !isEmpty(target.path): INSTALLS += target
 
+win32:CONFIG(release, debug|release): LIBS += -L$$PWD/res/ -llibsodium
+else:win32:CONFIG(debug, debug|release): LIBS += -L$$PWD/res/ -llibsodiumd
+else:unix: LIBS += -L$$PWD/res/ -lsodium
+
+INCLUDEPATH += $$PWD/res
+DEPENDPATH += $$PWD/res
+
+win32-g++:CONFIG(release, debug|release): PRE_TARGETDEPS += $$PWD/res/liblibsodium.a
+else:win32-g++:CONFIG(debug, debug|release): PRE_TARGETDEPS += $$PWD/res/liblibsodium.a
+else:win32:!win32-g++:CONFIG(release, debug|release): PRE_TARGETDEPS += $$PWD/res/libsodium.lib
+else:win32:!win32-g++:CONFIG(debug, debug|release): PRE_TARGETDEPS += $$PWD/res/libsodiumd.lib
+else:unix: PRE_TARGETDEPS += $$PWD/res/libsodium.a