Merge branch 'dev'

configure.ac

@@ -3,7 +3,7 @@ AC_PREREQ([2.60])
 define(_CLIENT_VERSION_MAJOR, 3)
 dnl Must be kept in sync with src/clientversion.h , ugh!
 define(_CLIENT_VERSION_MINOR, 9)
-define(_CLIENT_VERSION_REVISION, 3)
+define(_CLIENT_VERSION_REVISION, 4)
 define(_CLIENT_VERSION_BUILD, 50)
 define(_ZC_BUILD_VAL, m4_if(m4_eval(_CLIENT_VERSION_BUILD < 25), 1, m4_incr(_CLIENT_VERSION_BUILD), m4_eval(_CLIENT_VERSION_BUILD < 50), 1, m4_eval(_CLIENT_VERSION_BUILD - 24), m4_eval(_CLIENT_VERSION_BUILD == 50), 1, , m4_eval(_CLIENT_VERSION_BUILD - 50)))
 define(_CLIENT_VERSION_SUFFIX, m4_if(m4_eval(_CLIENT_VERSION_BUILD < 25), 1, _CLIENT_VERSION_REVISION-beta$1, m4_eval(_CLIENT_VERSION_BUILD < 50), 1, _CLIENT_VERSION_REVISION-rc$1, m4_eval(_CLIENT_VERSION_BUILD == 50), 1, _CLIENT_VERSION_REVISION, _CLIENT_VERSION_REVISION-$1)))

contrib/sda_checkpoints.pl

@@ -0,0 +1,48 @@
+#!/usr/bin/perl
+# Copyright (c) 2016-2022 The Hush developers
+# Distributed under the GPLv3 software license, see the accompanying
+# file COPYING or https://www.gnu.org/licenses/gpl-3.0.en.html
+
+# This script is used to generate the checkpoint data used by the SilentDragon Android SDK
+# https://git.hush.is/fekt/hush-android-wallet-sdk/src/branch/main/sdk-lib/src/main/assets/co.electriccoin.zcash/checkpoint/mainnet
+
+use warnings;
+use strict;
+my $hush    = "./src/hush-cli";
+my $getblock= "$hush getblock";
+my $gethash = "$hush getblockhash";
+my $gettree = "$hush getblockmerkletree";
+my $start   = shift || 1190000;
+my $end     = shift || 1260000;
+my $stride  = shift || 10000;
+
+my $blocks  = qx{$hush getblockcount};
+if($?) {
+    print "ERROR, is hushd running? exiting...\n";
+    exit 1;
+}
+
+if ($end > $blocks) {
+    print "The block $end is beyond how many blocks this node knows about, exiting...\n";
+    exit 1;
+}
+
+if ($start < 1) {
+    print "Invalid start block $start, exiting...\n";
+    exit 1;
+}
+
+my $block = $start;
+while (1) {
+    last if $block > $end;
+	my $blockhash = qx{$gethash $block};
+	my $blocktime = qx{$getblock $block | grep time};
+	my $merkle    = qx{$gettree $block};
+    chomp $merkle;
+    chomp $blockhash;
+    chomp $blocktime;
+    $blocktime =~ s/^\s+|\s+$//g ;
+    print qq{{\n\t"network": "main",\n\t"height": "$block",\n\t"hash": "$blockhash",\n\t$blocktime\n\t"saplingTree": "$merkle"\n},\n};
+
+    $block += $stride;
+}

contrib/seeds/nodes_main.txt

@@ -16,6 +16,9 @@
 # lite.hushpool.is
 149.28.102.219
 
+# lite2.hushpool.is
+155.138.228.68
+
 # wtfistheinternet.hush.is
 107.174.70.251
 

depends/packages/boost.mk

@@ -4,6 +4,7 @@ $(package)_version=1_72_0
 $(package)_download_path=https://boostorg.jfrog.io/artifactory/main/release/$(subst _,.,$($(package)_version))/source/
 $(package)_sha256_hash=59c9b274bc451cf91a9ba1dd2c7fdcaf5d60b1b3aa83f2c9fa143417cc660722
 $(package)_file_name=$(package)_$($(package)_version).tar.bz2
+$(package)_patches=fix-Solaris.patch
 
 define $(package)_set_vars
 $(package)_config_opts_release=variant=release
@@ -27,7 +28,8 @@ endef
 
 
 define $(package)_preprocess_cmds
-  echo "using $(boost_toolset_$(host_os)) : : $($(package)_cxx) : <cxxflags>\"$($(package)_cxxflags) $($(package)_cppflags)\" <linkflags>\"$($(package)_ldflags)\" <archiver>\"$(boost_archiver_$(host_os))\" <striper>\"$(host_STRIP)\"  <ranlib>\"$(host_RANLIB)\" <rc>\"$(host_WINDRES)\" : ;" > user-config.jam
+  echo "using $(boost_toolset_$(host_os)) : : $($(package)_cxx) : <cxxflags>\"$($(package)_cxxflags) $($(package)_cppflags)\" <linkflags>\"$($(package)_ldflags)\" <archiver>\"$(boost_archiver_$(host_os))\" <striper>\"$(host_STRIP)\"  <ranlib>\"$(host_RANLIB)\" <rc>\"$(host_WINDRES)\" : ;" > user-config.jam&& \
+  patch -p1 < $($(package)_patch_dir)/fix-Solaris.patch
 endef
 
 define $(package)_config_cmds
@@ -36,16 +38,16 @@ endef
 
 ifeq ($(host_os),linux)
 define $(package)_build_cmds
-  ./b2 -d2 -j2 -d1 --prefix=$($(package)_staging_prefix_dir) $($(package)_config_opts) cxxflags=-std=c++11 stage
+  ./b2 -d2 -d1 --prefix=$($(package)_staging_prefix_dir) $($(package)_config_opts) cxxflags=-std=c++11 stage
 endef
 define $(package)_stage_cmds
-  ./b2 -d0 -j4 --prefix=$($(package)_staging_prefix_dir) $($(package)_config_opts) cxxflags=-std=c++11 install
+  ./b2 -d0 --prefix=$($(package)_staging_prefix_dir) $($(package)_config_opts) cxxflags=-std=c++11 install
 endef
 else
 define $(package)_build_cmds
-  ./b2 -d2 -j2 -d1 --prefix=$($(package)_staging_prefix_dir) $($(package)_config_opts) stage
+  ./b2 -d2 -d1 --prefix=$($(package)_staging_prefix_dir) $($(package)_config_opts) stage
 endef
 define $(package)_stage_cmds
-  ./b2 -d0 -j4 --prefix=$($(package)_staging_prefix_dir) $($(package)_config_opts) install
+  ./b2 -d0 --prefix=$($(package)_staging_prefix_dir) $($(package)_config_opts) install
 endef
 endif

depends/packages/libcurl.mk

@@ -1,9 +1,9 @@
 package=libcurl
-$(package)_version=7.67.0
+$(package)_version=7.77.0
 $(package)_dependencies=wolfssl
 $(package)_download_path=https://curl.haxx.se/download
 $(package)_file_name=curl-$($(package)_version).tar.gz
-$(package)_sha256_hash=52af3361cf806330b88b4fe6f483b6844209d47ae196ac46da4de59bb361ab02
+$(package)_sha256_hash=b0a3428acb60fa59044c4d0baae4e4fc09ae9af1d8a3aa84b2e3fbcd99841f77
 $(package)_config_opts_linux=--disable-shared --enable-static --with-wolfssl --without-ssl --prefix=$(host_prefix) --host=$(host)
 $(package)_config_opts_mingw32=--enable-mingw --disable-shared --enable-static --with-wolfssl --without-ssl --prefix=$(host_prefix) --host=x86_64-w64-mingw32
 $(package)_config_opts_darwin=--disable-shared --enable-static --with-wolfssl --without-ssl --prefix=$(host_prefix)

depends/packages/libevent.mk

@@ -4,8 +4,11 @@ $(package)_download_path=https://github.com/libevent/libevent/archive
 $(package)_file_name=$(package)-$($(package)_version).tar.gz
 $(package)_download_file=release-$($(package)_version)-stable.tar.gz
 $(package)_sha256_hash=316ddb401745ac5d222d7c529ef1eada12f58f6376a66c1118eee803cb70f83d
+$(package)_patches=detect-arch4random_addrandom.patch detect-arch4random_addrandom-fix.patch
 
 define $(package)_preprocess_cmds
+  patch -p1 <$($(package)_patch_dir)/detect-arch4random_addrandom.patch && \
+  patch -p1 <$($(package)_patch_dir)/detect-arch4random_addrandom-fix.patch && \
   ./autogen.sh
 endef
 

depends/packages/rust.mk

@@ -46,12 +46,12 @@ define $(package)_extract_cmds
 endef
 
 define $(package)_stage_cmds
-  bash ./install.sh --destdir=$($(package)_staging_dir) --prefix=$(host_prefix)/native --disable-ldconfig && \
-  ../$(canonical_host)/install.sh --destdir=$($(package)_staging_dir) --prefix=$(host_prefix)/native --disable-ldconfig
+  bash ./install.sh --destdir=$($(package)_staging_dir) --prefix=$(host_prefix)/native --disable-ldconfig --without=rust-docs && \
+  ../$(canonical_host)/install.sh --destdir=$($(package)_staging_dir) --prefix=$(host_prefix)/native --disable-ldconfig --without=rust-docs
 endef
 else
 
 define $(package)_stage_cmds
-  bash ./install.sh --destdir=$($(package)_staging_dir) --prefix=$(host_prefix)/native --disable-ldconfig
+  bash ./install.sh --destdir=$($(package)_staging_dir) --prefix=$(host_prefix)/native --disable-ldconfig --without=rust-docs
 endef
 endif

depends/patches/boost/fix-Solaris.patch

@@ -0,0 +1,23 @@
+From 74fb0a26099bc51d717f5f154b37231ce7df3e98 Mon Sep 17 00:00:00 2001
+From: Rob Boehne <robb@datalogics.com>
+Date: Wed, 20 Nov 2019 11:25:20 -0600
+Subject: [PATCH] Revert change to elide a warning that caused Solaris builds to fail.
+
+---
+ boost/thread/pthread/thread_data.hpp | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+diff --git a/boost/thread/pthread/thread_data.hpp b/boost/thread/pthread/thread_data.hpp
+index aefbeb43c..bc9b1367a 100644
+--- a/boost/thread/pthread/thread_data.hpp
++++ b/boost/thread/pthread/thread_data.hpp
+@@ -57,7 +57,7 @@ namespace boost
+ #else
+           std::size_t page_size = ::sysconf( _SC_PAGESIZE);
+ #endif
+-#if PTHREAD_STACK_MIN > 0
+-          if (size<PTHREAD_STACK_MIN) size=PTHREAD_STACK_MIN;
++#ifdef PTHREAD_STACK_MIN
++          if (size<static_cast<std::size_t>(PTHREAD_STACK_MIN)) size=PTHREAD_STACK_MIN;
+ #endif
+           size = ((size+page_size-1)/page_size)*page_size;

depends/patches/libevent/detect-arch4random_addrandom-fix.patch

@@ -0,0 +1,43 @@
+From 266f43af7798befa3d27bfabaa9ae699259c3924 Mon Sep 17 00:00:00 2001
+From: Azat Khuzhin <a3at.mail@gmail.com>
+Date: Mon, 27 Mar 2017 15:50:23 +0300
+Subject: [PATCH] Fix arc4random_addrandom() detecting and fallback
+ (regression)
+
+But this is kind of hot-fix, we definitelly need more sane arc4random
+compat layer.
+
+Fixes: #488
+Introduced-in: 6541168 ("Detect arch4random_addrandom() existence")
+---
+ event-config.h.cmake  | 3 +++
+ include/event2/util.h | 2 +-
+ 2 files changed, 4 insertions(+), 1 deletion(-)
+
+diff --git a/event-config.h.cmake b/event-config.h.cmake
+index b7f0be57c..5c233a3d9 100644
+--- a/event-config.h.cmake
++++ b/event-config.h.cmake
+@@ -53,6 +53,9 @@
+ /* Define to 1 if you have the `arc4random_buf' function. */
+ #cmakedefine EVENT__HAVE_ARC4RANDOM_BUF 1
+ 
++/* Define to 1 if you have the `arc4random_addrandom' function. */
++#cmakedefine EVENT__HAVE_ARC4RANDOM_ADDRANDOM 1
++
+ /* Define if clock_gettime is available in libc */
+ #cmakedefine EVENT__DNS_USE_CPU_CLOCK_FOR_ID 1
+ 
+diff --git a/include/event2/util.h b/include/event2/util.h
+index c4af2bd60..ca4048944 100644
+--- a/include/event2/util.h
++++ b/include/event2/util.h
+@@ -842,7 +842,7 @@ int evutil_secure_rng_init(void);
+ EVENT2_EXPORT_SYMBOL
+ int evutil_secure_rng_set_urandom_device_file(char *fname);
+ 
+-#ifdef EVENT__HAVE_ARC4RANDOM_ADDRANDOM
++#if !defined(EVENT__HAVE_ARC4RANDOM) || defined(EVENT__HAVE_ARC4RANDOM_ADDRANDOM)
+ /** Seed the random number generator with extra random bytes.
+ 
+     You should almost never need to call this function; it should be

depends/patches/libevent/detect-arch4random_addrandom.patch

@@ -0,0 +1,77 @@
+From 6541168d7037457b8e5c51cc354f11bd94e618b6 Mon Sep 17 00:00:00 2001
+From: Marek Sebera <marek.sebera@gmail.com>
+Date: Mon, 6 Mar 2017 00:55:16 +0300
+Subject: [PATCH] Detect arch4random_addrandom() existence
+
+Refs: #370
+Refs: #475
+---
+ CMakeLists.txt        | 1 +
+ configure.ac          | 1 +
+ evutil_rand.c         | 2 ++
+ include/event2/util.h | 2 ++
+ 4 files changed, 6 insertions(+)
+
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index a861e7d96..f609d02d0 100644
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -338,6 +338,7 @@ CHECK_FUNCTION_EXISTS_EX(sysctl EVENT__HAVE_SYSCTL)
+ CHECK_FUNCTION_EXISTS_EX(accept4 EVENT__HAVE_ACCEPT4)
+ CHECK_FUNCTION_EXISTS_EX(arc4random EVENT__HAVE_ARC4RANDOM)
+ CHECK_FUNCTION_EXISTS_EX(arc4random_buf EVENT__HAVE_ARC4RANDOM_BUF)
++CHECK_FUNCTION_EXISTS_EX(arc4random_addrandom EVENT__HAVE_ARC4RANDOM_ADDRANDOM)
+ CHECK_FUNCTION_EXISTS_EX(epoll_create1 EVENT__HAVE_EPOLL_CREATE1)
+ CHECK_FUNCTION_EXISTS_EX(getegid EVENT__HAVE_GETEGID)
+ CHECK_FUNCTION_EXISTS_EX(geteuid EVENT__HAVE_GETEUID)
+diff --git a/configure.ac b/configure.ac
+index a127bbc91..e73c29b14 100644
+--- a/configure.ac
++++ b/configure.ac
+@@ -342,6 +342,7 @@ AC_CHECK_FUNCS([ \
+   accept4 \
+   arc4random \
+   arc4random_buf \
++  arc4random_addrandom \
+   eventfd \
+   epoll_create1 \
+   fcntl \
+diff --git a/evutil_rand.c b/evutil_rand.c
+index 046a14b07..4be0b1c5e 100644
+--- a/evutil_rand.c
++++ b/evutil_rand.c
+@@ -192,12 +192,14 @@ evutil_secure_rng_get_bytes(void *buf, size_t n)
+ 	ev_arc4random_buf(buf, n);
+ }
+ 
++#if !defined(EVENT__HAVE_ARC4RANDOM) || defined(EVENT__HAVE_ARC4RANDOM_ADDRANDOM)
+ void
+ evutil_secure_rng_add_bytes(const char *buf, size_t n)
+ {
+ 	arc4random_addrandom((unsigned char*)buf,
+ 	    n>(size_t)INT_MAX ? INT_MAX : (int)n);
+ }
++#endif
+ 
+ void
+ evutil_free_secure_rng_globals_(void)
+diff --git a/include/event2/util.h b/include/event2/util.h
+index dd4bbb69d..c4af2bd60 100644
+--- a/include/event2/util.h
++++ b/include/event2/util.h
+@@ -842,6 +842,7 @@ int evutil_secure_rng_init(void);
+ EVENT2_EXPORT_SYMBOL
+ int evutil_secure_rng_set_urandom_device_file(char *fname);
+ 
++#ifdef EVENT__HAVE_ARC4RANDOM_ADDRANDOM
+ /** Seed the random number generator with extra random bytes.
+ 
+     You should almost never need to call this function; it should be
+@@ -858,6 +859,7 @@ int evutil_secure_rng_set_urandom_device_file(char *fname);
+  */
+ EVENT2_EXPORT_SYMBOL
+ void evutil_secure_rng_add_bytes(const char *dat, size_t datlen);
++#endif
+ 
+ #ifdef __cplusplus
+ }

doc/man/hush-cli.1

@@ -1,9 +1,9 @@
-.\" DO NOT MODIFY THIS FILE!  It was generated by help2man 1.47.13.
-.TH HUSH-CLI "1" "February 2023" "hush-cli v3.9.3" "User Commands"
+.\" DO NOT MODIFY THIS FILE!  It was generated by help2man 1.47.6.
+.TH HUSH-CLI "1" "June 2023" "hush-cli v3.9.4" "User Commands"
 .SH NAME
-hush-cli \- manual page for hush-cli v3.9.3
+hush-cli \- manual page for hush-cli v3.9.4
 .SH DESCRIPTION
-Hush RPC client version v3.9.3\-1313d39a7
+Hush RPC client version v3.9.4\-44595d5ab
 .PP
 In order to ensure you are adequately protecting your privacy when using Hush,
 please see <https://hush.is/security/>.

doc/man/hush-tx.1

@@ -1,9 +1,9 @@
-.\" DO NOT MODIFY THIS FILE!  It was generated by help2man 1.47.13.
-.TH HUSH-TX "1" "February 2023" "hush-tx v3.9.3" "User Commands"
+.\" DO NOT MODIFY THIS FILE!  It was generated by help2man 1.47.6.
+.TH HUSH-TX "1" "June 2023" "hush-tx v3.9.4" "User Commands"
 .SH NAME
-hush-tx \- manual page for hush-tx v3.9.3
+hush-tx \- manual page for hush-tx v3.9.4
 .SH DESCRIPTION
-hush\-tx utility version v3.9.3\-1313d39a7
+hush\-tx utility version v3.9.4\-44595d5ab
 .SS "Usage:"
 .TP
 hush\-tx [options] <hex\-tx> [commands]

doc/man/hushd.1

@@ -1,9 +1,9 @@
-.\" DO NOT MODIFY THIS FILE!  It was generated by help2man 1.47.13.
-.TH HUSHD "1" "February 2023" "hushd v3.9.3" "User Commands"
+.\" DO NOT MODIFY THIS FILE!  It was generated by help2man 1.47.6.
+.TH HUSHD "1" "June 2023" "hushd v3.9.4" "User Commands"
 .SH NAME
-hushd \- manual page for hushd v3.9.3
+hushd \- manual page for hushd v3.9.4
 .SH DESCRIPTION
-Hush Daemon version v3.9.3\-1313d39a7
+Hush Daemon version v3.9.4\-44595d5ab
 .PP
 In order to ensure you are adequately protecting your privacy when using Hush,
 please see <https://hush.is/security/>.
@@ -78,7 +78,7 @@ applied)
 .HP
 \fB\-par=\fR<n>
 .IP
-Set the number of script verification threads (\fB\-8\fR to 16, 0 = auto, <0 =
+Set the number of script verification threads (\fB\-6\fR to 16, 0 = auto, <0 =
 leave that many cores free, default: 0)
 .HP
 \fB\-pid=\fR<file>

doc/release-process.md

@@ -76,6 +76,7 @@ Install deps on Linux:
      - Comment out the HUSHVER line and uncomment the line above it with a hardcoded version number
    - PROTIP: Man page creation must be done after updating the version number and recompiling and before Debian package creation
  - Update checkpoints in src/chainparams.cpp via util/checkpoints.pl
+   - Run "./util/checkpoints.pl help" to get example usage
    - hushd must be running to run this script, since it uses hush-cli to get the data
    - Look for line which says "END HUSH mainnet checkpoint data" near line 560 in chainparams.cpp , that is where checkpoint data ends
    - Find the highest block height of checkpoint data, let's call it HEIGHT
@@ -95,6 +96,7 @@ Install deps on Linux:
      - They only provide limited security, because they talk about the past, not future block heights.
    - Try to generate checkpoints as close to the release as possible, so you can have a recent block height be protected.
      - For instance, don't update checkpoints and then do a release a month later. You can always update checkpoint data again or multiple times
+   - DRAGONX now has checkpoints, you can generate them with: `./util/checkpoints.pl 1000 1 DRAGONX`
  - Update copyright years if applicable. Example: `./util/update-copyrights.h 2022 2023`
  - Update doc/relnotes/README.md
    - To get the stats of file changes: `git diff --stat master...dev`

doc/relnotes/README.md

@@ -10,6 +10,34 @@ and no longer on Github, since they banned Duke Leto and
 also because they censor many people around the world and work with
 evil organizations.
 
+# Hush 3.9.4 "Maniacal Manticore"
+
+```
+68 files changed, 1304 insertions(+), 1343 deletions(-)
+```
+
+This is an OPTIONAL release. It is recommended for exchanges, solo miners and mining pools to update to this release.
+
+  * New features and improvements
+    * Hush and DragonX nodes will now sync much faster
+    * DragonX now has checkpoints for faster better chain security
+    * Updated to the latest RandomX code
+	* Rate limiting for the processing of incoming addr messages for increased security.
+	* Removed unused function CWalletTx::GetRequestCount
+	* Removed mapRequest tracking that only affects Qt display.
+	* Randomized message processing peer order for increased privacy.
+	* Removed BIP35 mempool p2p message for increased privacy.
+	* Additional community seed node
+  * Build Improvements
+	* Use custom jobs param when compiling boost for faster compile times
+	* Now builds with gcc13 thanks to testing from jahway
+	* We have an aarch64 deb now thanks to jahway
+  * Bug fixes:
+	* -stratumallowip works with CIDR and netmask ranges again for solo miners
+	* Detect missing autoreconf in build.sh
+	* Various assertions removed from BIP155 changes in previous release. 
+
+
 # Hush 3.9.3 "Lateral Larvacean"
 
 ```

src/RandomX/src/allocator.cpp

@@ -50,11 +50,14 @@ namespace randomx {
 	template struct AlignedAllocator<CacheLineSize>;
 
 	void* LargePageAllocator::allocMemory(size_t count) {
-		return allocLargePagesMemory(count);
+		void *mem = allocLargePagesMemory(count);
+		if (mem == nullptr)
+			throw std::bad_alloc();
+		return mem;
 	}
 
 	void LargePageAllocator::freeMemory(void* ptr, size_t count) {
 		freePagedMemory(ptr, count);
 	};
 
-}
+}

src/RandomX/src/intrin_portable.h

@@ -337,19 +337,19 @@ FORCE_INLINE int rx_vec_i128_w(rx_vec_i128 a) {
 	return _a.i32[3];
 }
 
-FORCE_INLINE rx_vec_i128 rx_set_int_vec_i128(int _I3, int _I2, int _I1, int _I0) {
-	return (rx_vec_i128)((__m128li){_I0,_I1,_I2,_I3});
+FORCE_INLINE rx_vec_i128 rx_set_int_vec_i128(int i3, int i2, int i1, int i0) {
+	return (rx_vec_i128)((__m128li){i0,i1,i2,i3});
 };
 
-FORCE_INLINE rx_vec_i128 rx_xor_vec_i128(rx_vec_i128 _A, rx_vec_i128 _B) {
-	return (rx_vec_i128)vec_xor(_A,_B);
+FORCE_INLINE rx_vec_i128 rx_xor_vec_i128(rx_vec_i128 a, rx_vec_i128 b) {
+	return (rx_vec_i128)vec_xor(a,b);
 }
 
-FORCE_INLINE rx_vec_i128 rx_load_vec_i128(rx_vec_i128 const *_P) {
+FORCE_INLINE rx_vec_i128 rx_load_vec_i128(rx_vec_i128 const *p) {
 #if defined(NATIVE_LITTLE_ENDIAN)
-	return *_P;
+	return *p;
 #else
-	uint32_t* ptr = (uint32_t*)_P;
+	uint32_t* ptr = (uint32_t*)p;
 	vec_u c;
 	c.u32[0] = load32(ptr + 0);
 	c.u32[1] = load32(ptr + 1);
@@ -359,13 +359,13 @@ FORCE_INLINE rx_vec_i128 rx_load_vec_i128(rx_vec_i128 const *_P) {
 #endif
 }
 
-FORCE_INLINE void rx_store_vec_i128(rx_vec_i128 *_P, rx_vec_i128 _B) {
+FORCE_INLINE void rx_store_vec_i128(rx_vec_i128 *p, rx_vec_i128 b) {
 #if defined(NATIVE_LITTLE_ENDIAN)
-	*_P = _B;
+	*p = b;
 #else
-	uint32_t* ptr = (uint32_t*)_P;
+	uint32_t* ptr = (uint32_t*)p;
 	vec_u B;
-	B.i = _B;
+	B.i = b;
 	store32(ptr + 0, B.u32[0]);
 	store32(ptr + 1, B.u32[1]);
 	store32(ptr + 2, B.u32[2]);
@@ -487,12 +487,12 @@ FORCE_INLINE int rx_vec_i128_w(rx_vec_i128 a) {
 	return vgetq_lane_s32(vreinterpretq_s32_u8(a), 3);
 }
 
-FORCE_INLINE rx_vec_i128 rx_set_int_vec_i128(int _I3, int _I2, int _I1, int _I0) {
+FORCE_INLINE rx_vec_i128 rx_set_int_vec_i128(int i3, int i2, int i1, int i0) {
 	int32_t data[4];
-	data[0] = _I0;
-	data[1] = _I1;
-	data[2] = _I2;
-	data[3] = _I3;
+	data[0] = i0;
+	data[1] = i1;
+	data[2] = i2;
+	data[3] = i3;
 	return vreinterpretq_u8_s32(vld1q_s32(data));
 };
 
@@ -662,29 +662,29 @@ FORCE_INLINE int rx_vec_i128_w(rx_vec_i128 a) {
 	return a.u32[3];
 }
 
-FORCE_INLINE rx_vec_i128 rx_set_int_vec_i128(int _I3, int _I2, int _I1, int _I0) {
+FORCE_INLINE rx_vec_i128 rx_set_int_vec_i128(int i3, int i2, int i1, int i0) {
 	rx_vec_i128 v;
-	v.u32[0] = _I0;
-	v.u32[1] = _I1;
-	v.u32[2] = _I2;
-	v.u32[3] = _I3;
+	v.u32[0] = i0;
+	v.u32[1] = i1;
+	v.u32[2] = i2;
+	v.u32[3] = i3;
 	return v;
 };
 
-FORCE_INLINE rx_vec_i128 rx_xor_vec_i128(rx_vec_i128 _A, rx_vec_i128 _B) {
+FORCE_INLINE rx_vec_i128 rx_xor_vec_i128(rx_vec_i128 a, rx_vec_i128 b) {
 	rx_vec_i128 c;
-	c.u32[0] = _A.u32[0] ^ _B.u32[0];
-	c.u32[1] = _A.u32[1] ^ _B.u32[1];
-	c.u32[2] = _A.u32[2] ^ _B.u32[2];
-	c.u32[3] = _A.u32[3] ^ _B.u32[3];
+	c.u32[0] = a.u32[0] ^ b.u32[0];
+	c.u32[1] = a.u32[1] ^ b.u32[1];
+	c.u32[2] = a.u32[2] ^ b.u32[2];
+	c.u32[3] = a.u32[3] ^ b.u32[3];
 	return c;
 }
 
-FORCE_INLINE rx_vec_i128 rx_load_vec_i128(rx_vec_i128 const*_P) {
+FORCE_INLINE rx_vec_i128 rx_load_vec_i128(rx_vec_i128 const* p) {
 #if defined(NATIVE_LITTLE_ENDIAN)
-	return *_P;
+	return *p;
 #else
-	uint32_t* ptr = (uint32_t*)_P;
+	uint32_t* ptr = (uint32_t*)p;
 	rx_vec_i128 c;
 	c.u32[0] = load32(ptr + 0);
 	c.u32[1] = load32(ptr + 1);
@@ -694,15 +694,15 @@ FORCE_INLINE rx_vec_i128 rx_load_vec_i128(rx_vec_i128 const*_P) {
 #endif
 }
 
-FORCE_INLINE void rx_store_vec_i128(rx_vec_i128 *_P, rx_vec_i128 _B) {
+FORCE_INLINE void rx_store_vec_i128(rx_vec_i128 *p, rx_vec_i128 b) {
 #if defined(NATIVE_LITTLE_ENDIAN)
-	*_P = _B;
+	*p = b;
 #else
-	uint32_t* ptr = (uint32_t*)_P;
-	store32(ptr + 0, _B.u32[0]);
-	store32(ptr + 1, _B.u32[1]);
-	store32(ptr + 2, _B.u32[2]);
-	store32(ptr + 3, _B.u32[3]);
+	uint32_t* ptr = (uint32_t*)p;
+	store32(ptr + 0, b.u32[0]);
+	store32(ptr + 1, b.u32[1]);
+	store32(ptr + 2, b.u32[2]);
+	store32(ptr + 3, b.u32[3]);
 #endif
 }
 

src/RandomX/src/jit_compiler_a64.cpp

@@ -93,6 +93,8 @@ JitCompilerA64::JitCompilerA64()
 	, literalPos(ImulRcpLiteralsEnd)
 	, num32bitLiterals(0)
 {
+	if (code == nullptr)
+		throw std::runtime_error("allocMemoryPages");
 	memset(reg_changed_offset, 0, sizeof(reg_changed_offset));
 	memcpy(code, (void*) randomx_program_aarch64, CodeSize);
 

src/RandomX/src/jit_compiler_x86.cpp

@@ -225,6 +225,8 @@ namespace randomx {
 
 	JitCompilerX86::JitCompilerX86() {
 		code = (uint8_t*)allocMemoryPages(CodeSize);
+		if (code == nullptr)
+			throw std::runtime_error("allocMemoryPages");
 		memcpy(code, codePrologue, prologueSize);
 		memcpy(code + epilogueOffset, codeEpilogue, epilogueSize);
 	}

src/RandomX/src/randomx.cpp

@@ -113,6 +113,10 @@ extern "C" {
 				cache = nullptr;
 			}
 		}
+		if (cache && cache->memory == nullptr) {
+			randomx_release_cache(cache);
+			cache = nullptr;
+		}
 
 		return cache;
 	}
@@ -130,9 +134,7 @@ extern "C" {
 
 	void randomx_release_cache(randomx_cache* cache) {
 		assert(cache != nullptr);
-		if (cache->memory != nullptr) {
-			cache->dealloc(cache);
-		}
+		cache->dealloc(cache);
 		delete cache;
 	}
 
@@ -162,6 +164,10 @@ extern "C" {
 				dataset = nullptr;
 			}
 		}
+		if (dataset && dataset->memory == nullptr) {
+			randomx_release_dataset(dataset);
+			dataset = nullptr;
+		}
 
 		return dataset;
 	}

src/RandomX/src/tests/utility.hpp

@@ -32,6 +32,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <cstdlib>
 #include <iostream>
 #include <fstream>
+#include <cstdint>
 
 constexpr char hexmap[] = "0123456789abcdef";
 inline void outputHex(std::ostream& os, const char* data, int length) {

src/addrman.cpp

@@ -143,15 +143,17 @@ void CAddrMan::SwapRandom(unsigned int nRndPos1, unsigned int nRndPos2)
     if (nRndPos1 == nRndPos2)
         return;
 
-    assert(nRndPos1 < vRandom.size() && nRndPos2 < vRandom.size());
+    // assert(nRndPos1 < vRandom.size() && nRndPos2 < vRandom.size());
 
     int nId1 = vRandom[nRndPos1];
     int nId2 = vRandom[nRndPos2];
 
     const auto it_1{mapInfo.find(nId1)};
     const auto it_2{mapInfo.find(nId2)};
-    assert(it_1 != mapInfo.end());
-    assert(it_2 != mapInfo.end());
+
+    if( (it_1 == mapInfo.end()) || (it_2 == mapInfo.end())) {
+        return;
+    }
 
     it_1->second.nRandomPos = nRndPos2;
     it_2->second.nRandomPos = nRndPos1;
@@ -167,8 +169,8 @@ void CAddrMan::Delete(int nId)
     const auto it{mapInfo.find(nId)};
     if (it != mapInfo.end()) {
         CAddrInfo& info = (*it).second;
-        assert(!info.fInTried);
-        assert(info.nRefCount == 0);
+        // assert(!info.fInTried);
+        // assert(info.nRefCount == 0);
 
         SwapRandom(info.nRandomPos, vRandom.size() - 1);
         vRandom.pop_back();
@@ -189,7 +191,10 @@ void CAddrMan::ClearNew(int nUBucket, int nUBucketPos)
         const auto it{mapInfo.find(nIdDelete)};
         if (it != mapInfo.end()) {
             CAddrInfo& infoDelete = (*it).second;
-            assert(infoDelete.nRefCount > 0);
+            // assert(infoDelete.nRefCount > 0);
+            if (infoDelete.nRefCount == 0) {
+                return;
+            }
             infoDelete.nRefCount--;
             vvNew[nUBucket][nUBucketPos] = -1;
             if (infoDelete.nRefCount == 0) {
@@ -217,7 +222,7 @@ void CAddrMan::MakeTried(CAddrInfo& info, int nId)
     }
     nNew--;
 
-    assert(info.nRefCount == 0);
+    //assert(info.nRefCount == 0);
 
     // which tried bucket to move the entry to
     int nKBucket = info.GetTriedBucket(nKey, m_asmap);
@@ -227,7 +232,7 @@ void CAddrMan::MakeTried(CAddrInfo& info, int nId)
     if (vvTried[nKBucket][nKBucketPos] != -1) {
         // find an item to evict
         int nIdEvict = vvTried[nKBucket][nKBucketPos];
-        assert(mapInfo.count(nIdEvict) == 1);
+        //assert(mapInfo.count(nIdEvict) == 1);
         CAddrInfo& infoOld = mapInfo[nIdEvict];
 
         // Remove the to-be-evicted item from the tried set.
@@ -239,14 +244,14 @@ void CAddrMan::MakeTried(CAddrInfo& info, int nId)
         int nUBucket = infoOld.GetNewBucket(nKey, m_asmap);
         int nUBucketPos = infoOld.GetBucketPosition(nKey, true, nUBucket);
         ClearNew(nUBucket, nUBucketPos);
-        assert(vvNew[nUBucket][nUBucketPos] == -1);
+        //assert(vvNew[nUBucket][nUBucketPos] == -1);
 
         // Enter it into the new set again.
         infoOld.nRefCount = 1;
         vvNew[nUBucket][nUBucketPos] = nIdEvict;
         nNew++;
     }
-    assert(vvTried[nKBucket][nKBucketPos] == -1);
+    //assert(vvTried[nKBucket][nKBucketPos] == -1);
 
     vvTried[nKBucket][nKBucketPos] = nId;
     nTried++;
@@ -499,7 +504,12 @@ CAddrInfo CAddrMan::Select_(bool newOnly)
                     MilliSleep(kRetrySleepInterval);
             }
             int nId = vvTried[nKBucket][nKBucketPos];
-            assert(mapInfo.count(nId) == 1);
+            // assert(mapInfo.count(nId) == 1);
+            if(mapInfo.count(nId) != 1) {
+                fprintf(stderr,"%s: Could not find tried node with nId=%d=vvTried[%d][%d], mapInfo.count(%d)=%lu\n", __func__, nId, nKBucket, nKBucketPos, nId, mapInfo.count(nId) );
+                continue;
+            }
+
             CAddrInfo& info = mapInfo[nId];
             if (info.IsReachableNetwork()) {
                 //deprioritize unreachable networks
@@ -534,7 +544,12 @@ CAddrInfo CAddrMan::Select_(bool newOnly)
                     MilliSleep(kRetrySleepInterval);
             }
             int nId = vvNew[nUBucket][nUBucketPos];
-            assert(mapInfo.count(nId) == 1);
+
+            if(mapInfo.count(nId) != 1) {
+                fprintf(stderr,"%s: Could not find new node with nId=%d=vvNew[%d][%d], mapInfo.count(%d)=%lu\n", __func__, nId, nUBucket, nUBucketPos, nId, mapInfo.count(nId) );
+                continue;
+            }
+            // assert(mapInfo.count(nId) == 1);
             CAddrInfo& info = mapInfo[nId];
             if (info.IsReachableNetwork()) {
                 //deprioritize unreachable networks
@@ -655,7 +670,7 @@ void CAddrMan::GetAddr_(std::vector<CAddress>& vAddr, bool wants_addrv2)
         if (vAddr.size() >= nNodes)
             break;
 
-        assert(mapInfo.count(vRandom[n]) == 1);
+        // assert(mapInfo.count(vRandom[n]) == 1);
         const CAddrInfo& ai = mapInfo[vRandom[n]];
 
         if (!ai.IsTerrible()) {

src/cc/CCMarmara.h

@@ -1,53 +0,0 @@
-// Copyright (c) 2016-2023 The Hush developers
-// Distributed under the GPLv3 software license, see the accompanying
-// file COPYING or https://www.gnu.org/licenses/gpl-3.0.en.html
-/******************************************************************************
- * Copyright © 2014-2019 The SuperNET Developers.                             *
- *                                                                            *
- * See the AUTHORS, DEVELOPER-AGREEMENT and LICENSE files at                  *
- * the top-level directory of this distribution for the individual copyright  *
- * holder information and the developer policies on copyright and licensing.  *
- *                                                                            *
- * Unless otherwise agreed in a custom licensing agreement, no part of the    *
- * SuperNET software, including this file may be copied, modified, propagated *
- * or distributed except according to the terms contained in the LICENSE file *
- *                                                                            *
- * Removal or modification of this copyright notice is prohibited.            *
- *                                                                            *
- ******************************************************************************/
-
-
-#ifndef CC_MARMARA_H
-#define CC_MARMARA_H
-
-/*
-
-#include "CCinclude.h"
-#include "../hush_cJSON.h"
-
-#define MARMARA_GROUPSIZE 60
-#define MARMARA_MINLOCK (1440 * 3 * 30)
-#define MARMARA_MAXLOCK (1440 * 24 * 30)
-#define MARMARA_VINS 16
-#define EVAL_MARMARA 0xef
-
-extern uint8_t ASSETCHAINS_MARMARA;
-uint64_t hush_block_prg(uint32_t nHeight);
-int32_t MarmaraGetcreatetxid(uint256 &createtxid,uint256 txid);
-int32_t MarmaraGetbatontxid(std::vector<uint256> &creditloop,uint256 &batontxid,uint256 txid);
-UniValue MarmaraCreditloop(uint256 txid);
-UniValue MarmaraSettlement(uint64_t txfee,uint256 batontxid);
-UniValue MarmaraLock(uint64_t txfee,int64_t amount,int32_t height);
-
-UniValue MarmaraPoolPayout(uint64_t txfee,int32_t firstheight,double perc,char *jsonstr); // [[pk0, shares0], [pk1, shares1], ...]
-UniValue MarmaraReceive(uint64_t txfee,CPubKey senderpk,int64_t amount,std::string currency,int32_t matures,uint256 batontxid,bool automaticflag);
-UniValue MarmaraIssue(uint64_t txfee,uint8_t funcid,CPubKey receiverpk,int64_t amount,std::string currency,int32_t matures,uint256 approvaltxid,uint256 batontxid);
-UniValue MarmaraInfo(CPubKey refpk,int32_t firstheight,int32_t lastheight,int64_t minamount,int64_t maxamount,std::string currency);
-
-bool MarmaraValidate(struct CCcontract_info *cp,Eval* eval,const CTransaction &tx, uint32_t nIn);
-
-// CCcustom
-UniValue MarmaraInfo();
-*/
-
-#endif

src/cc/CCcustom.cpp

@@ -30,7 +30,6 @@
 #include "CCOracles.h"
 #include "CCPrices.h"
 #include "CCPegs.h"
-#include "CCMarmara.h"
 #include "CCPayments.h"
 #include "CCGateways.h"
 #include "CCtokens.h"
@@ -192,17 +191,6 @@ uint8_t PegsCCpriv[32] = { 0x52, 0x56, 0x4c, 0x78, 0x87, 0xf7, 0xa2, 0x39, 0xb0,
 #undef FUNCNAME
 #undef EVALCODE
 
-// Marmara
-#define FUNCNAME IsMarmaraInput
-#define EVALCODE EVAL_MARMARA
-const char *MarmaraCCaddr = "RGLSRDnUqTB43bYtRtNVgmwSSd1sun2te8";
-const char *MarmaraNormaladdr = "RMN25Tn8NNzcyQDiQNuMp8UmwLMFd9thYc";
-char MarmaraCChexstr[67] = { "03afc5be570d0ff419425cfcc580cc762ab82baad88c148f5b028d7db7bfeee61d" };
-uint8_t MarmaraCCpriv[32] = { 0x7c, 0x0b, 0x54, 0x9b, 0x65, 0xd4, 0x89, 0x57, 0xdf, 0x05, 0xfe, 0xa2, 0x62, 0x41, 0xa9, 0x09, 0x0f, 0x2a, 0x6b, 0x11, 0x2c, 0xbe, 0xbd, 0x06, 0x31, 0x8d, 0xc0, 0xb9, 0x96, 0x76, 0x3f, 0x24 };
-#include "CCcustom.inc"
-#undef FUNCNAME
-#undef EVALCODE
-
 // Payments
 #define FUNCNAME IsPaymentsInput
 #define EVALCODE EVAL_PAYMENTS

src/cc/assets.cpp

@@ -150,20 +150,6 @@ bool AssetsValidate(struct CCcontract_info *cpAssets,Eval* eval,const CTransacti
     outputsDummy = inputs = 0;
     preventCCvins = preventCCvouts = -1;
     
-    // add specific chains exceptions for old token support:
-    if (strcmp(SMART_CHAIN_SYMBOL, "SEC") == 0 && chainActive.Height() <= 144073)
-        return true;
-    
-    if (strcmp(SMART_CHAIN_SYMBOL, "MGNX") == 0 && chainActive.Height() <= 210190)
-        return true;
-
-    // add specific chains exceptions for old token support:
-    if (strcmp(SMART_CHAIN_SYMBOL, "SEC") == 0 && chainActive.Height() <= 144073)
-        return true;
-
-    if (strcmp(SMART_CHAIN_SYMBOL, "MGNX") == 0 && chainActive.Height() <= 210190)
-        return true;
-        
 	if (numvouts == 0)
 		return eval->Invalid("AssetValidate: no vouts");
 

src/cc/import.cpp

@@ -672,9 +672,6 @@ bool Eval::ImportCoin(const std::vector<uint8_t> params, const CTransaction &imp
 
     LOGSTREAM("importcoin", CCLOG_DEBUG1, stream << "Validating import tx..., txid=" << importTx.GetHash().GetHex() << std::endl);
 
-    if (strcmp(SMART_CHAIN_SYMBOL, "CFEKDIMXY6") == 0 && chainActive.Height() <= 44693)
-        return true;
-
     if (importTx.vout.size() < 2)
         return Invalid("too-few-vouts");
     // params

src/chainparams.cpp

@@ -1547,13 +1547,697 @@ void *chainparams_commandline() {
                 (1249000,     uint256S("0x00000001170d6ae54d494bd2dbf29c5ab7f560f51874987d7dbe129d549c097f"))
                 (1250000,     uint256S("0x000000033226eef40d094c8aa88d03bbc9146856c52248760e28c45426787352"))
                 (1251000,     uint256S("0x0000000281c7f7ef75ac6539791e26b9744cccd59414b04ddc4697bcd3595209"))
-                ,(int64_t)  1675926362, // time of last checkpointed block
-                (int64_t) 2022392,      // total txs
-                (double)  1371        // txs in the last day before block 1251770
+
+		// Generated at 1688095440 via hush3 util/checkpoints.pl by fekt
+		(1252000,     uint256S("0x00000002a23866c4bc24b6d14b8039eb38530936fd7ba230cd41bbffe457c0eb"))
+		(1253000,     uint256S("0x000000021fb79ebfda0aa2dde15ef1fc669003911bc771d1700f8b6785d86aa9"))
+		(1254000,     uint256S("0x000000020083112cbd6ac00fff2dbbd4c72e3c1d2636138cd42a63b7fc0af798"))
+		(1255000,     uint256S("0x00000000247e68c0c4bd2cffedf9dff84dc67e49f9c90b6df073d4c6e913856a"))
+		(1256000,     uint256S("0x00000002556455ce2059602aa43b7dc0ed5014bc157e78e9283bc2610946720e"))
+		(1257000,     uint256S("0x00000003119deacf7b787311ef767abb173594d22979797a58a2ad01b7bda0a5"))
+		(1258000,     uint256S("0x000000024edab00216ccb7ef39dd16b782e14179f90aace0d812b33ecbefdde0"))
+		(1259000,     uint256S("0x00000003016ee9e404906afe5542afa1b614be768187d8a9f9c7ebf598d76695"))
+		(1260000,     uint256S("0x00000000b7fc90789fca4e53b5966707642d1d9ffcccc99c28fd194135d08618"))
+		(1261000,     uint256S("0x00000001e43bbacba953a662435791e7f4bc1c3fada97d8a279c8b26598fecc7"))
+		(1262000,     uint256S("0x00000002993a7913e93d68bf44bd0f5c0102a7ab196ed6ee4ae9ea790b197854"))
+		(1263000,     uint256S("0x000000016bf7677b49e8df24d03c3ba6ab060356c72501de94938ad2e7be946c"))
+		(1264000,     uint256S("0x00000002c616eed07db9e4695ac9cee6989e42a76c6f61a4e0ebe0bb5abf692f"))
+		(1265000,     uint256S("0x000000024d31a0ef0a466f573bb7c0e0970fc52e895c3b01d95b5b38e81322ca"))
+		(1266000,     uint256S("0x000000011e54e3519dd6ea6af0443e309c8e226e2ccd775b28cc4f12f08c0d39"))
+		(1267000,     uint256S("0x0000000393da90dc30fde8005d7f2d2318f8785e2a32bc865bf8383f7c8ffea8"))
+		(1268000,     uint256S("0x000000027f04b7efb776bd8420de4cc0228561aa773d59cb0b2e9f6025389322"))
+		(1269000,     uint256S("0x000000061807ebcde0469dd2c3b3bf682864b593da8bc8c64d354108961a6514"))
+		(1270000,     uint256S("0x00000000041c198471a04f305344aeae7650140175c97d62765861d6416a4ed1"))
+		(1271000,     uint256S("0x00000001f0e911e3ce304f9785f4c43ae7087eca9c4cadc677c4f49659b121dc"))
+		(1272000,     uint256S("0x000000035098a7b17ae7be1c6decf88dbca85562137c8d2200bd84cb59148788"))
+		(1273000,     uint256S("0x00000005d5d27e58ecb84658d2c3f2d8c87bae08ee0d81c6d4cdfc347ec13ec9"))
+		(1274000,     uint256S("0x00000001623cd2acb0005393f2378a2d1ed5603511ee806b1e04f4e677b7531b"))
+		(1275000,     uint256S("0x0000000140a568b0870d2c6853fe3fdcd94193652ef61ba9d430989e9a521a77"))
+		(1276000,     uint256S("0x000000046e660edfdbae93511bb48f335df7523bae3cd5bfcb77cd81525585bb"))
+		(1277000,     uint256S("0x000000022c296e5406126bbd6040316b2706c489c58d2b7593e1ec1637d31432"))
+		(1278000,     uint256S("0x000000012b5d649609b503398d7af1fa7e14e9e58bd8e6746d6f44bbeb311270"))
+		(1279000,     uint256S("0x000000039deede9e29ba8c7178df43374e83d6691556103a337c58822f2501fc"))
+		(1280000,     uint256S("0x0000000172d327c94631b30e851ada193ad0d4b05a659db7e92cdaf4a5859841"))
+		(1281000,     uint256S("0x00000002cf093cdd98e566534b7b5aaa91ee125e71283d654a75b878f08ba015"))
+		(1282000,     uint256S("0x0000000306c146a88cd6a2cce453ac72d632a9bebf49abf27c684b4957f8380a"))
+		(1283000,     uint256S("0x00000004738db155d0d8b5d95abd4484962c16a40eab2047b5b20fa4c5df890e"))
+		(1284000,     uint256S("0x00000001bba05b8445a32d3856a1e4dbe9f65a96c39ca92c654ac01e675b1076"))
+		(1285000,     uint256S("0x00000002fbc4853d6183b848e5ad32637478358521e87a7c1febfde93c4dcaa8"))
+		(1286000,     uint256S("0x00000002fd09e8f12b1ade668a238b4badda452869f770c20bf3edd0c9a2b984"))
+		(1287000,     uint256S("0x0000000568e3a41c8ac6e4d5ed59630a1aeff0b957494388a4c939f206ecac0c"))
+		(1288000,     uint256S("0x000000024cf90a1150d224e167503dd79d2261de0e5e7a7e35b04949c95b8fd6"))
+		(1289000,     uint256S("0x00000004ecdab6f1bf5f2cfd924afefb167160a49d5aa9a2b4790b4fce190427"))
+		(1290000,     uint256S("0x0000000305db71205f1c622693cc55fee7c3b7c26400e13e82b3855a13c40df7"))
+		(1291000,     uint256S("0x000000032d1115be00930015cb1f6fe824349bd4ff367ec675c4c92d7b268904"))
+		(1292000,     uint256S("0x00000000a0fa63c1264eadb0fd86f1f420c74c2b5593604897c6ebe4aa4691b5"))
+		(1293000,     uint256S("0x00000002bfd681e56afbb24664cd056812d1347bab971b44ff957a7ecd4a54ce"))
+		(1294000,     uint256S("0x00000000ba8ac906a4fea8b779d6272e2648a30a488c4c390f1c761fbf53e76d"))
+		(1295000,     uint256S("0x00000000859df3b6859bdd415b8d1b1fb8c396a279c8ddd6b1f39d41cec89579"))
+		(1296000,     uint256S("0x000000008e62f687dc9899200671a9c595e1626e29477080ab052be584349ba5"))
+		(1297000,     uint256S("0x00000003e9d6c1cce45b1d76a775f3d6e6ebbd5caa62427ae015e954e1f14d05"))
+		(1298000,     uint256S("0x00000000fa5a495e60cfe2c8de8d8e52c2bb1ddf335a891f69be2c7eae901dcc"))
+		(1299000,     uint256S("0x0000000326ff88c4546f65313522fe9466b33e96af50e6a6db09dfe59193bc63"))
+		(1300000,     uint256S("0x00000003f498d56accc70c7257bfd708a22128dda0a038499f0c984f3e9ba2c0"))
+		(1301000,     uint256S("0x00000001313da1129ba7de5f415d211ea1e3f51ae9d910abb2624aeae15b4a56"))
+		(1302000,     uint256S("0x000000034cdf6686f4350dcc4f1f0887bb128746afd7cc3aeba5bf8b000c636f"))
+		(1303000,     uint256S("0x00000003dffb121ae41569ca13d851f3c45668e8ee351680c2db1871f251eb3e"))
+		(1304000,     uint256S("0x00000000c5bb42d8bfe94087c5d129fafe2677e62edadfaa7415b8a7bb4277ff"))
+		(1305000,     uint256S("0x0000000046e1db3cc0047a85b815b745c4a0f4af4244b79d90a57cfafdf85699"))
+		(1306000,     uint256S("0x00000004418d213a0ecced05de5b1fcaca70fe272d37773377e02c1873d27068"))
+		(1307000,     uint256S("0x00000001cce1afda2c61046fd571edf01bdcc5a09260fcc7727caca8e3eb6ed6"))
+		(1308000,     uint256S("0x00000000a453c4fd6f537776b730e5b8ae4d238c2f9215ed4f6e709b8aa177ac"))
+		(1309000,     uint256S("0x000000009c9d7cb8f66d9ccdb7ce77a3c36c8d7df74e21326ef86000627091d4"))
+		(1310000,     uint256S("0x00000000cd97fe334d3be6f3fda419589ebf643bffab3194d5cdeb7d324d123c"))
+		(1311000,     uint256S("0x00000004fd9a887ae0db3333544e3027fe79f59fbdf8116ca516650e165bcd52"))
+		(1312000,     uint256S("0x0000000349b8956bf4cf1b9566580e7362dfdd512ac5f7ef6a300ce2c0cf343e"))
+		(1313000,     uint256S("0x000000030a692fe283bdbc7e1e11f8827da5a1e7b4aa3cca3c089803af547025"))
+		(1314000,     uint256S("0x000000034e3ff90ae3436af4d7e1caec9604c5d347bded5fc6e0b05f3d0902f8"))
+		(1315000,     uint256S("0x000000011044536fe0741ffb747e3b0f0cf826b3103d50b41f392772ed55607c"))
+		(1316000,     uint256S("0x000000022ca70a448e4f6693aafeb5f0eac948064188933a01cd15db835e1bc3"))
+		(1317000,     uint256S("0x00000005b8f471f902a540463c5a8ce962a34da30157bb4c094bbfee85b3ad36"))
+		(1318000,     uint256S("0x000000020bada11214b8cf7784286aa4e5120c14b5b5e47516f619e6411badc0"))
+		(1319000,     uint256S("0x00000001642ce9e76b5ebe167b03fdd00d0e6d595abb09ee9bd6c033f947f2db"))
+		(1320000,     uint256S("0x00000000995d4bafd5b3e9bcc709cf0623090008aa34c9ee6b44c815ad08bc48"))
+		(1321000,     uint256S("0x00000001bd0fff7aff0e313d8b458568a65a395d037b6d2999328798c441d8d3"))
+		(1322000,     uint256S("0x000000015cd85c1fc0fc6877cb6c9ff4d9ab99bc7ece23d96c468c549ee3e368"))
+		(1323000,     uint256S("0x000000033cdd6bc9051d956dc774e7c8066ae6f2272f2cbd23a5cb34a6f21947"))
+		(1324000,     uint256S("0x00000001feaf5da15ade7a2a7f039ef95f506dfa7c8d7a3077dc6b77106a4aa9"))
+		(1325000,     uint256S("0x00000002ed58d3afaa3044dde92a4af3908c154895651c46b8ad24bdcd702021"))
+		(1326000,     uint256S("0x0000000377de030a756db011af1cf8d6ea1cabec0ad4957055de3435ee1102bf"))
+		(1327000,     uint256S("0x00000002b68d85dc8783068c6878f128c048aa85dae10c5e0495768e76b153a8"))
+		(1328000,     uint256S("0x000000022c5ea4c4f470006d99898a1de5d783967dfc4f0759835f60a0f376d9"))
+		(1329000,     uint256S("0x0000000448c2f62ad26c51c3481b702615acf71f40631dc384e081e579993bf2"))
+		(1330000,     uint256S("0x000000004bfdeafb2dcdbb7b0a214c62fc4f03583f3f6f27bbe2dd78c083bc6a"))
+		(1331000,     uint256S("0x0000000008f29e6bfeedea18387ec2df4f1518f03de03073bd402d3d84daa40d"))
+		(1332000,     uint256S("0x00000003b6b0fdb24bcd5b132ab25d97ce116d4fce4edc70037848340f9cd6a0"))
+		(1333000,     uint256S("0x0000000540eb80533c3ad5fb11028ef74e41cf66afeeb49d38c8e91e1b9be071"))
+		(1334000,     uint256S("0x000000024e829222c6b338723ea69a1aaf8ca426db6f1dc5ed6a508aa4eba324"))
+		(1335000,     uint256S("0x00000001c34ef432a6d7c5b537e4157bcdc6a2f4c3d30d25cb9bb47ff395b5a6"))
+		(1336000,     uint256S("0x000000011cda647d4405fbcffc35ce161a057911bc551290848a56a832835c14"))
+		(1337000,     uint256S("0x0000000297dddb61d28cd456b11c6683f5c040ea1d798462cba45ff4d9acb7aa"))
+		(1338000,     uint256S("0x000000031a44d98fee4c721d7cf692b5c6d49c72b9e514a9eea8d7a3a980cb42"))
+		(1339000,     uint256S("0x000000016a3b0d888eaaf488fe99202db0cadabcace4f5606e13a8021e208beb"))
+		(1340000,     uint256S("0x0000000296642fe481256d81da12afbbfc867a6e56f7e88ee575376171a2eb2b"))
+		(1341000,     uint256S("0x000000047f7f7df7d25d0f93873e81f317b4c59970021ff99097b90662b34886"))
+		(1342000,     uint256S("0x00000003dee60bf850c721422ead96876a6479c0e249252cd7a0819756f214f0"))
+		(1343000,     uint256S("0x0000000479b89d6106880dd554c9f0839893680f6aaf1d17bdd353b5ff3b690d"))
+		(1344000,     uint256S("0x000000043e08866b7b3a2fb729934e38ed68a7158aae743dbd67e915cbbe25fa"))
+		(1345000,     uint256S("0x000000010d28f703987f82d284a6ab34eeb9c6cdf528cfd8ea9467377b48f978"))
+		(1346000,     uint256S("0x000000047577df762e1b9d1d36efd124d7c587e8a1b04992d012b48e1da03d1c"))
+		(1347000,     uint256S("0x000000050e60e964649507f0abaa9041969bc292e762179cc48e370d1e85109f"))
+		(1348000,     uint256S("0x0000000458aac55b9a6a7610abf79769ccbd21bccabe262d49313b637f360b7d"))
+		(1349000,     uint256S("0x00000001b36d5248c6632d6f353376991a3d7ce4b6730cd777042e8eef4c2050"))
+		(1350000,     uint256S("0x0000000040bdf5b1900a2d20f6fb7824f7f0ad2117a357ac212388bbe5238f40"))
+		(1351000,     uint256S("0x00000004a5e89800bd3e433dc1c3f36370b14523a219ccc513e9451c6354bb86"))
+		(1352000,     uint256S("0x000000025bda557523475832f119f8d5ebdd02f131c0004f529b0e6b16343a8e"))
+		(1353000,     uint256S("0x000000012e20cd31e7f6eda7d0e1d1777fde4a312a4c2ce6948d629e10b196ab"))
+		(1354000,     uint256S("0x0000000247ea366ee0719df82303d8e74aec615b2c006bb1b7d37c1d42366785"))
+		(1355000,     uint256S("0x0000000038f84260adf0773fa051af3467e0e4bf17adf73c4a9f8cc0ae0eb52f"))
+		(1356000,     uint256S("0x00000001b109fae9d09d98e829e273037a6209d29347485ffdee066f8f32d070"))
+		(1357000,     uint256S("0x00000002c9047e284ad3699ee0ccd158c141ad281fe7c78bcb8cae0012e2a7a5"))
+		(1358000,     uint256S("0x000000046e5f2a9d1b043840165ba292042ca4a6927f9451d8eb379e9f6b479f"))
+		(1359000,     uint256S("0x00000001fe154c692d9a7255fa9657023d213d3a2b0c6025bc2942452ff0bfa7"))
+		(1360000,     uint256S("0x00000002e0a212bc285eef4232f6805f95ef054582a43fd4b926ed23e75ec378"))
+		(1361000,     uint256S("0x0000000170ffed44b6503976cf15289556ec5ac785c63f371990dc1dcd01c0c1"))
+		(1362000,     uint256S("0x00000004b0a51f49dc942a4dac1c8cb7ebc3b5dc70c27488b950033543de9188"))
+		(1363000,     uint256S("0x00000002d39b32395989ff7065d238a9e6ca9643dde76f2c4fa090da64a9dfb0"))
+		(1364000,     uint256S("0x00000003fe2c6dafe4f7c45c2a07307864a85c649738a68fa9736990385aa1b6"))
+		(1365000,     uint256S("0x000000006a96f8887cb0b261ff9c0947ec9a35e388354a088012e0f3587a915d"))
+		(1366000,     uint256S("0x00000000b19f6e3ea6282cad35d25bd45f4a90799ca30de76ebfaa58360102b3"))
+		(1367000,     uint256S("0x00000005a4c7746ba3aa321bf6d0d939b65053fd7b8993541c4382d81b1df164"))
+		(1368000,     uint256S("0x00000005a2f3fac3d68493253cc28762ed0e7d8be207b72e9b3eba49b1301661"))
+		(1369000,     uint256S("0x00000001d963d93ec5f029920cd5ca0f8bfca9c85ce99f84585062d2c08edca3"))
+		(1370000,     uint256S("0x000000033c971fbcf50d26531667597acd4abf989473c10a7ecd23cd4546dc05"))
+		(1371000,     uint256S("0x00000002a277717fd9f5b05370e9c610662ffdb6f5489e96b96bc587dc22dc70"))
+		(1372000,     uint256S("0x00000001ef0f457f58b3523ec79d6ec265928ba5aaec6a5ee282242334883e15"))
+		(1373000,     uint256S("0x000000005911ed4432d3077e7254e35767ca8b00a674a1b047fd0dcc12bb1e6f"))
+		(1374000,     uint256S("0x0000000538363b8b3a25dce0a88990b96dff9787c2ec8189b70b13222008adfc"))
+		(1375000,     uint256S("0x000000021d15ac7123e2dc7ae2de2f045165911151b898063768eca1c27e31fa"))
+		(1376000,     uint256S("0x000000047928c3ff4ca5dec8dd99087df4770abd50469ce2bd3328346858373f"))
+		(1377000,     uint256S("0x0000000271c0b5532f810a9ffb563d09bf74b959fb1939c741dc140ec1874d09"))
+		(1378000,     uint256S("0x0000000048678a71baf3fdb3c5f905a78a75b6ffb02018b186693e87d8172eb4"))
+		(1379000,     uint256S("0x00000003460b8c58481e205f842eb3fda43f313a87a303f64a8f971268fba367"))
+		(1380000,     uint256S("0x000000023a6ce85edc04e5af620930477bea1aaf31ee262678968976717d176e"))
+		(1381000,     uint256S("0x0000000436b6c757c06b32648e510c4249b88928921f4d0bc39371600d0d0824"))
+		(1382000,     uint256S("0x00000001c7fd7b29c040c9c56d641ca219800d234e1eb8c640d86663de6cb335"))
+		(1383000,     uint256S("0x00000002b9cb3b2aca628572ae964b334efc22acc8ed50500d76e834cecb264f"))
+		(1384000,     uint256S("0x0000000550b1b189873d81707719eb1be9e2492f3897f59cf39aad447d12fe7d"))
+		(1385000,     uint256S("0x00000002c778e98b2871165ee43f441496ed6c50e6cd97bccc82448498ca3a2b"))
+		(1386000,     uint256S("0x000000037b6d4f8ed38297729f65b7dda39a0e297d0dff2b7ab11c31b784b5ce"))
+		(1387000,     uint256S("0x00000002aa3edc372bb3030959ee6eda0fc188b0837d8409c073553124e31ca3"))
+		(1388000,     uint256S("0x00000004c2ad445251b1faf327fcc6d4364d941e8b95377588d764845ce98e14"))
+		(1389000,     uint256S("0x00000003730f20a59c6c6bfb8ee168145113eab1db437a1683c782ad59a593cc"))
+		(1390000,     uint256S("0x00000001f4f78ddb8d92d00fea207be21bed937c632a70681a522f2b21257f30"))
+		(1391000,     uint256S("0x0000000252c913ab26a7d67b1ef969399edc40c0cb89c564a90bca7478511d06"))
+		(1392000,     uint256S("0x00000001a4fd677cd1510d2253223d62f3c1adc493ce88178663698aaae85ad4"))
+		(1393000,     uint256S("0x0000000326c759d56837a8ded29af2f0628c89ea018f45f44ccc27539cda123c"))
+		(1394000,     uint256S("0x00000006e8c60ec3bf6dbe664da6b86e29c0a6220706617b8bc024f313f600e5"))
+		(1395000,     uint256S("0x00000001a089c52a4740433d3395e9faedca3d80bba38a5c1d51bfa5d61a82a7"))
+		(1396000,     uint256S("0x00000009cb3a07fbfb926a75481ab04db3d1a108c73782272e184a66d55e5de9"))
+		(1397000,     uint256S("0x00000004aa55ca33c9e6fc43f9ddd0b0f32cade6a3c0dc120c7faf60d72903ff"))
+		(1398000,     uint256S("0x00000006091fd1a0d34b6dd29c590ba69569f910b96bcbc8434758c177f04022"))
+		(1399000,     uint256S("0x00000003c85038020294c7c58ea8a4bec845cf6494bdf63222b31f4748fea77a"))
+		(1400000,     uint256S("0x00000008d0941b9a5b394d19cff188a665cb8a57b89de8ad06f58fd08c6fcb8e"))
+		(1401000,     uint256S("0x000000013a5e8cd206aad4b6b1c256e567def77a371254f2b33096f315f401f9"))
+		(1402000,     uint256S("0x000000016587d0e9753056f74305dc05d818904248512bdc87dadc624e0be6dc"))
+		(1403000,     uint256S("0x000000015575532cb246eb7c065b955921104a246d4fef43f14009bf2da0d9eb"))
+		(1404000,     uint256S("0x000000055c93b66f7be3213b21f2f77eaf5e76c43060125d6cb3a91ca5ba8bd3"))
+		(1405000,     uint256S("0x00000003df2e2b33cbeeb78d320e273880df4d6deb0e661b576052ddcaccb11c"))
+		(1406000,     uint256S("0x00000003a9e7a1b897857b1df59931eae36855a66e39c4fe872c68440b8a77b6"))
+		(1407000,     uint256S("0x000000007f74d842e9a2923f32a0d64bdf3bfdf9bd742bcd689a8647b487de60"))
+		(1408000,     uint256S("0x000000004a021a23c0c31f2fcd82d757e20f2d7257880dec999061546c0309c9"))
+		(1409000,     uint256S("0x0000000078be552c979aaf660ef8b2d6a7f3d6878975f49f6d24c0c4d70fbe07"))
+		(1410000,     uint256S("0x000000071ffa758ba71f243c8b4106cdabaaa5ec0df9247af03f5dc9221b58b2"))
+		(1411000,     uint256S("0x00000007be4b7695ad2a5ef100899a22efad8b142ecbc8b93d5f8d553f9286d4"))
+		,(int64_t)  1688026050, // time of last checkpointed block
+		(int64_t) 0,      // total txs
+		(double)  2304        // txs in the last day before block 1411911
 
                 };
                 // END HUSH mainnet checkpoint data
+        } else if (strcmp(SMART_CHAIN_SYMBOL,"DRAGONX") == 0) {
+            checkpointData = //(Checkpoints::CCheckpointData)
+                   {
+                            boost::assign::map_list_of
+                    // Generated at 1686858269 via hush3 util/checkpoints.pl by Duke Leto
+                    (1000,     uint256S("0x000bffdae30339fad4ed82a2d2bfc0846f12fb9aeef5e33bb563f4cdd376dc08"))
+                    (2000,     uint256S("0x0003578c68350c7afacdc940c87ea9255681a135a0a9b2c13a075485d96155ed"))
+                    (3000,     uint256S("0x0001fef5443794fe61e0d397897f0a45a66c5473a70819608504f1395aed1d8c"))
+                    (4000,     uint256S("0x000197510698c8fc50133971744d1dd49aae371366d3986c412a189e9c617974"))
+                    (5000,     uint256S("0x00000094754d610b08b801545dbdbf57433e7c4d2a48818ff499f8fab05b0927"))
+                    (6000,     uint256S("0x0002116377d2d0c04344f0ed7eec63814b54bae740562ccede0c3d9404900cdb"))
+                    (7000,     uint256S("0x0001c74d83479bf05a3d9181555ff4ed373a642b1b4cb9cc633c090a522c10e0"))
+                    (8000,     uint256S("0x00011c3cd9aeadb039ba28547f232391ded0329ab6b7ec454aeb671246c94b58"))
+                    (9000,     uint256S("0x00005b1b0187ba523b6670e65262d1b028a140582301c7ea65065cd47a679c6d"))
+                    (10000,     uint256S("0x0000f32ac2bd4581ef4b651f72b27d92dfca04d4dc721c505214f113e209b10e"))
+                    (11000,     uint256S("0x000086e271117d75ac85fd00fbec94bbc53a5b990ccb362a8a2f064a97cdf7b2"))
+                    (12000,     uint256S("0x000098431effc021e44f867cffa2e309d7bbcc34201ea8d3bc7b08faeca556e3"))
+                    (13000,     uint256S("0x000194c6d37ebd00f7746536a7f3a891866954c1020f61be5573b055ea991fa1"))
+                    (14000,     uint256S("0x0001102d2b0c1efe8c07768b3bd540e8b2ef8c03e2f8271a58def634a51c576f"))
+                    (15000,     uint256S("0x0000c616068d8730adbd87b2bc9d4d5322610e52da6806b9cb2f1894af37d933"))
+                    (16000,     uint256S("0x0000049f6a5818a48aafb52781f91f8eca4d05c29c537a85c34b6fa342996a27"))
+                    (17000,     uint256S("0x000079bf17272dc67ca18df9f7c5b817c37bd2d103ee76d3b2271511c5aa0b82"))
+                    (18000,     uint256S("0x00005f4d742dc1b0e12200c4da8080d75973b18b6d2bdf748f149be72a313627"))
+                    (19000,     uint256S("0x0000368eaee2a6f22d64c66c0e3cfc7fe2709f7ced31a589ac8b4c461eca2fff"))
+                    (20000,     uint256S("0x0001b4057aebdc835c63dfb581235d5917af697fff962ecfe47e8a26c0b3ac55"))
+                    (21000,     uint256S("0x00010a339a0830471d384741ff24161252fdfab8ecfb493b6e8d1f1e7ce342b7"))
+                    (22000,     uint256S("0x000013c834a72926969cf8ed88b79175aa3ea952e67b7054c4fa06cc4e5209c4"))
+                    (23000,     uint256S("0x0000386a639d79d35972576b55787a80986a27c7415949dc645dc50522f6487a"))
+                    (24000,     uint256S("0x000075055db90559920ac02c2de8e1622533b7532b84fe702baf05082161e011"))
+                    (25000,     uint256S("0x0001b866113317839d2f6fa608f98f798db1570b4f84e36789126edda9b75d35"))
+                    (26000,     uint256S("0x00012ce8394b99c4fff5c052a0abb142c8c1eaa58b830699222a8eacb95298af"))
+                    (27000,     uint256S("0x000058bbe34298518632e0522d3ba10e050a5a31e2c4fd862a576f300e9f5c1d"))
+                    (28000,     uint256S("0x000163c608d28f1c3a10f8425b5469099b7fff50e25424659887e011d2c0281e"))
+                    (29000,     uint256S("0x0000c3baca291f20849d96de3436dad0efc24aa5b44bbdd466ea841b28d70a2e"))
+                    (30000,     uint256S("0x000075d2e08eafd62f4633cc1cabf281de17e7e0bba7965db75f3cf268b9a980"))
+                    (31000,     uint256S("0x00010cc563eef842749ea14412e922bad6e3515c049f639612a07b221aff4de2"))
+                    (32000,     uint256S("0x000150dee2380f76bb144f8c5433bd27e049c54feaaeadeb8bfc3948293453a9"))
+                    (33000,     uint256S("0x0000ec245f9808c6792915ae2a467593a1675efce42a2d0ee486e091913159d8"))
+                    (34000,     uint256S("0x000166dbcd4f262032e7a981207ac709f7be88a037650ca454db43018286c8f8"))
+                    (35000,     uint256S("0x0001a5c13dd9333a4ec60bc6af488ef7e3738aaf2170c70b716a30597b8e2d70"))
+                    (36000,     uint256S("0x00018e4fe65c96f0e187c265fa3faa49156ad07991284920beaef3b3b499dcbe"))
+                    (37000,     uint256S("0x00017e952f47ea070893b41a76468fee7db3073184eab10c960e2aead6fddf7e"))
+                    (38000,     uint256S("0x00010e3c64c0127fb995ab10d45bb281e5c78239c0303c825d81bb4cf994c7c0"))
+                    (39000,     uint256S("0x0001db8de504639d87029c9be04acdfef038601af58ea38ba307a7cc0ce8fdf7"))
+                    (40000,     uint256S("0x00015fc2f6953e67578c6484c3a5342d883fd3ef051456edc55064e544f04df2"))
+                    (41000,     uint256S("0x000200e23bc81ee9e9a9b29eb9c478c035d52de845c118a1645a3876d0f0f7ec"))
+                    (42000,     uint256S("0x00018b8b952e0268ee7007ca2bfe3499f1c78911e5d308d877aa3829a8ddfa95"))
+                    (43000,     uint256S("0x00005cc6dc81cdd3ad3c1bc5675064b8d6d01ac85348c116f4db28c61df5cb52"))
+                    (44000,     uint256S("0x0002a71c4a45353eeed81519d1f4b78e4be13702907bc872fd605c094eb5c8fe"))
+                    (45000,     uint256S("0x00005c3e9bdb78fa205f39a6f4fff5c547775ee90e79fedebecb17336c03e868"))
+                    (46000,     uint256S("0x00024017e7985c841e8b607624f74f3efe46f915d272f9f8c07a93353858d92b"))
+                    (47000,     uint256S("0x0000d29c58bb338aa55bb017d8fbbe3b7c3bed83f212094a18ef7fde7f8eb675"))
+                    (48000,     uint256S("0x00024b1c2d6131f7ec9748c763c3168d2d761c7617e10d09fb93aff2b4a29ca3"))
+                    (49000,     uint256S("0x000120f81110878ca7ec75d155badf2348bda20a9034b24b8317ba0f16568788"))
+                    (50000,     uint256S("0x000207bddb3ebb7cb8000f84e63ae7be40e74dde52c8bfa4f0cc913b048e5767"))
+                    (51000,     uint256S("0x0001c8554ac45a19684c7328056420d7b27c1c5c9f03059c095ca4a2749b29f4"))
+                    (52000,     uint256S("0x000104d93b769e9e7190b031f6250445b05750a36231f8ea7f2dce8c8a0487be"))
+                    (53000,     uint256S("0x00002ab5a1e72ef163242f4be6a26063f26cef6f1eccb4cfe44a099ba710fdc4"))
+                    (54000,     uint256S("0x000117645f0ee76f12601abe5554729ca9241c65e49cbefae77e67d18204795f"))
+                    (55000,     uint256S("0x0000ab7cf81435f26f56b9687b8f6feaaed95ed8090a1dac8a690a39b9a89c8b"))
+                    (56000,     uint256S("0x000134d8809fb2222a3ed76958f998589ac69d6d08d534309ecf569b6d448cb3"))
+                    (57000,     uint256S("0x00003daaec8c3d9c31b32163cef47c4883ad9b12b85a641eefbd02b06c4b6083"))
+                    (58000,     uint256S("0x000096456c3f1af39489df84dbf0a0975c9cc29fa1f524e72cf4421fd6465b82"))
+                    (59000,     uint256S("0x00016202a3cdcb3b0c27e75f84cebcf576bc7869abf0fab13c68abd3b111fb9e"))
+                    (60000,     uint256S("0x000071cd818c3fa9f155ec8ac65333f43e0d86b4f6ea98fc702ae0fe1ec3126f"))
+                    (61000,     uint256S("0x0000d1654355ba77105cc07e7cf024e0200f39646ea3cbf816737e621857ff36"))
+                    (62000,     uint256S("0x0000f1e6a09effa09329175ee4d8b42fdae3c365f1232fd440d0d41b6c090dc9"))
+                    (63000,     uint256S("0x0000ffbceee7b86cb04a37fefeb0452de8305aef4c37b6bfa84cffe4dba168be"))
+                    (64000,     uint256S("0x00002db24701b3d6c0d7547c1636b0aae754c050915ba607da1022e859bf0a07"))
+                    (65000,     uint256S("0x000102bfa6361b71cc51e231b87c653dfd21a865284fe013d65bac8fb2d96878"))
+                    (66000,     uint256S("0x000061e9bf36f9b2d110d7d545d9fa1deaaf39ce91d2d5e3f51b5e8eec37d820"))
+                    (67000,     uint256S("0x00000128e4528bae30aae739e7d1d1528e366739878878bdec5e5d5f5639de21"))
+                    (68000,     uint256S("0x0000c45a027fe81eb60c60573bffa4558b3d187f7144131eff0b97fc52d8fbcf"))
+                    (69000,     uint256S("0x00005fc22d9c90e1c88c5724ea8b45d2b198bd03d77931c4d328e88313d9080e"))
+                    (70000,     uint256S("0x0000bbfd71d248074239456adf756eff007bcbe004b8c02eed8dd1b1656d9270"))
+                    (71000,     uint256S("0x00003f2d633d303c935554a414ec99443e01f5e626522159d97b7774f939158f"))
+                    (72000,     uint256S("0x0001514d0a98b94dbc81f70c59d29ae437a4690beb464d1b92abe7bd1e055a35"))
+                    (73000,     uint256S("0x0000807fe075a08da2bb07b8f4bb9a02b7e450fe6e5be062c21b15beed210dfa"))
+                    (74000,     uint256S("0x00006bf606a3c548c55c079343183caaebaa2c23d8580abb9eedf2a7e9b2a453"))
+                    (75000,     uint256S("0x00016da1e267ef35372482c84a37012e74c136fea0015b48ac7e039a5025b71e"))
+                    (76000,     uint256S("0x000029e02c641075abe8adabdb3b59e3696611f37c3da3f3bfcad72a705e7a3c"))
+                    (77000,     uint256S("0x000105f3af93470b7076fdfb9a0e9714f596ca4366deb3c35333648257464d67"))
+                    (78000,     uint256S("0x000144235c2eb2e871e11eca2ef9c051432bce4e9a1bb346b0b895e8e559286b"))
+                    (79000,     uint256S("0x0000b73f9f1a91cacb3c93638fe7ef6fa91072fd76d91cb51f34e794941f7325"))
+                    (80000,     uint256S("0x00001d995acdf7ac796829dcc869dae073258e5c608a8daa709b4c512c3a3343"))
+                    (81000,     uint256S("0x0000b163da6072538fc53a789dc47228a691b734a74e551e0e2e9e0d26fdbcff"))
+                    (82000,     uint256S("0x00012e9491a6d4d2b32f1869eb44672e1833ab718e580bf5609d7f9c58bc0af3"))
+                    (83000,     uint256S("0x00017280176966d19319f3c4d67440759e072e0c8b66b93d1f87921743b99fd1"))
+                    (84000,     uint256S("0x0000f62cd78630155998d1a64104c2f66328a586988b18874e99364eb60fc0d9"))
+                    (85000,     uint256S("0x00000d6fe7b9dec442628066442bd0558ceaa1a8d664d82f122790b2c917f950"))
+                    (86000,     uint256S("0x000029a1d545e5b7fdd28617de6195347d719524d5626f12d19924921e7f2359"))
+                    (87000,     uint256S("0x000138aea3caee3827eacfea9efd4d41f74958992c3b17a19599c28932aec442"))
+                    (88000,     uint256S("0x0000ace521b7b212027faf886832a3858b6b1391face5d9bfa21a58d08577f17"))
+                    (89000,     uint256S("0x000054190734e754a5aa58f1cb70753fcba0a88f512185578b8d772918dbf549"))
+                    (90000,     uint256S("0x0000d841407e0ac42c190ca65319bf2c4ec056724c75774bbfaaaf28fc022fec"))
+                    (91000,     uint256S("0x0000d95e5a72eb25762fd65ed7901ee7c5365d1b7ada72080743f95fe9bfd308"))
+                    (92000,     uint256S("0x0000c77b274f557cca7a381b64ccba1412a4f927ae850cc5e0ea3b3fe6a85947"))
+                    (93000,     uint256S("0x000006ce04d80995709a8a93da2eaa6c00a7b0c15e7f409a1cbfa64f92ec4aee"))
+                    (94000,     uint256S("0x0000e610317357e75beadac9a249f9b1847e26d98dfde191f9e421df0ac009ec"))
+                    (95000,     uint256S("0x000039e0566bdb30c72857c5e05afeefefcb4fea69ee24e86fb3506c93c4169a"))
+                    (96000,     uint256S("0x00007707c899da1d86457bc55fc614cef6dfc73216d04f26b500728c57b8b7c6"))
+                    (97000,     uint256S("0x000133c725bdbbf3c4c3669e32f459f3d0cb6c473b5a9dcfac06c486e1ece294"))
+                    (98000,     uint256S("0x00001d75a7c92f3586045b534f5a80c474b9b1ba463acd1462b9494bc9dbc12d"))
+                    (99000,     uint256S("0x000070946880c634b930804e55cc2f380fbd897d4d1713e6ab0a86ec66299f44"))
+                    (100000,     uint256S("0x00005af032270f04bc9be8072ee0b70820b88303dc25770a8dfb5c6f00341ae8"))
+                    (101000,     uint256S("0x00015739048f9cd91a5f5da04d9b1f0b220d719c13a6b03577d60027ba0cf130"))
+                    (102000,     uint256S("0x0000ae124051763e3ccdc1beff5d4ba304715e06f6a54124ee4ce4a4424e2925"))
+                    (103000,     uint256S("0x0000b46bd79314799b28964e5bc9cfbfd4481fd4148c4775337cc7a3458f411f"))
+                    (104000,     uint256S("0x0000546d926811aeaa19b14fb06c919174d73ceb41800f21e8856b940ea0d51e"))
+                    (105000,     uint256S("0x00006f831295c6d417a10268beda28ef058a646d68dcf53f6c5197c7c0071144"))
+                    (106000,     uint256S("0x0000aa4f504584b2e604186eb4edc1d60caa757ef25db86a35aca9b9e03bab02"))
+                    (107000,     uint256S("0x0000e945fef42d3eb4cc606aa888cb9908a9778592470e6630035821b83bf32a"))
+                    (108000,     uint256S("0x000042b833a40904ba608c715efca50f3b351924cddc50793af26be698b791b4"))
+                    (109000,     uint256S("0x00008b8778ff887a3ae0dc04a9cc546408c8b7cc4f23668b2e38ade6fbe31487"))
+                    (110000,     uint256S("0x00007558a72be2b93ff9c32a3c8c8896f4fd7b8d59430a1917755412307bbcde"))
+                    (111000,     uint256S("0x00005fcd2934faee4f6cf128a272a03c7001be0f59abe873c4ef5dbd469fee67"))
+                    (112000,     uint256S("0x0000ea01486382afa2787d723f80d1073bd8924181f9e0aba2e4a253e4fb571d"))
+                    (113000,     uint256S("0x00002e5f65baec8b526c5096351a30bc33cee3692ed4e3b4144229cf9ca6dc83"))
+                    (114000,     uint256S("0x0000177996f4e8f436672b0405b1de6bb7335bdc32cea1635d6122c4d6af7563"))
+                    (115000,     uint256S("0x00011891d2d508824de7657981c754372a2c2985b2d483fc48003de27f9b5716"))
+                    (116000,     uint256S("0x000088d8381d4a1c3b468bedbf6320e7dba41285ae99bcaf0b4750ca9cada4bb"))
+                    (117000,     uint256S("0x0000b0dacbd93ed6feb0c83af3f8b57598ca9b59b87c4a0f6f8b7738b37ba280"))
+                    (118000,     uint256S("0x000141aa854c151264db40b7fb065d5d6402c03786d1201a428bdb2f3cf4be0d"))
+                    (119000,     uint256S("0x00001dcec0e976c13fa307ee80f37a7d188e80b7e18c6aa744948139090ee4c6"))
+                    (120000,     uint256S("0x000159aac0c2854248eeaa7717b5f9defed70ec7eb56225f74650e2e4dd14ab0"))
+                    (121000,     uint256S("0x0000ffaabd57940430c76493f65b2ea9588ea5d218bf4ab8cd7986a4f36d85ed"))
+                    (122000,     uint256S("0x00004997285f83bdf2b84e906a5427d1246d2a9576fe70ba98db0fb1906e2a81"))
+                    (123000,     uint256S("0x00011189d192349030a4d667504557de1c6f321c2d2b433f279d83aefd49a88d"))
+                    (124000,     uint256S("0x000021e928fa16624a41e6d5d3275ecbf15d4f2e7ac529f411c071090b01a501"))
+                    (125000,     uint256S("0x0001678ffaaf26a44aacadf79d4312a1a3269e110df6a25b00371575574c5fd5"))
+                    (126000,     uint256S("0x00014435157bc5cf46047a2080a3fac7680635b4bd269404297581b884f26aff"))
+                    (127000,     uint256S("0x00005b0ee65fba4d6eb0902766eadf515fb252b86140e9093d249d8f9a54a128"))
+                    (128000,     uint256S("0x000021b7d3534640ec2854c0fcc08b1342162770a4e1c37870e9cf0030582d85"))
+                    (129000,     uint256S("0x00009fb144dfe588c1ae56ba6e17a6d6b1565c1b27464c5cba79c918b56a1760"))
+                    (130000,     uint256S("0x0000674dcced99276e684e9ac19eb2412e55c968a2bb524069384647cb45eefc"))
+                    (131000,     uint256S("0x0000ad841440e59715c68856f4011e854031cad19788438bdceaa4ca161f06a1"))
+                    (132000,     uint256S("0x00002789aed78f0b29396c9d654c1599b35cae19704d1b15e4f266af109c1f8c"))
+                    (133000,     uint256S("0x00002a422e40e72b7a35d4818a59297bfdcc5efcaeaa30d54d1d290e85a6f1de"))
+                    (134000,     uint256S("0x00003628a789756f15bb46fd8de99f9baab50f19a935716785dcae0275bf4a05"))
+                    (135000,     uint256S("0x000075517e8be4c0ed800d66ad00dd67346ea2b34348e594b769fa9bac3fecb5"))
+                    (136000,     uint256S("0x00002b4196ca58d9e2b7c75f1e8de291cf22b7bbc4be8dc2cfb29f54c256d3ba"))
+                    (137000,     uint256S("0x0000180d66e02d24330e9ef3d49813136eac06802e2989fa379d7a88e4067e01"))
+                    (138000,     uint256S("0x0000ad0a51cac855e0b162fbf069b560cd8d21fb5275f9d06304a740129bc809"))
+                    (139000,     uint256S("0x0000219d48ec853516f9262b41d84c5fbc5417b604e3b9001769bd5ac3f59b28"))
+                    (140000,     uint256S("0x00012475b06db9b0c4befe66ed3de054b993bc787092488df2383c566155921e"))
+                    (141000,     uint256S("0x000061896c62d282efc098341741a1a67c4d9c87fec6f1948a2225bc56c44c78"))
+                    (142000,     uint256S("0x0000444880b2e2b46b874fbb0acd44675ce257d2bac4eade4b9b9929a7b39b08"))
+                    (143000,     uint256S("0x0000509c13924e0733c5d6fc3bc7a270d2dd3b4c82db7fdfcaf02a410103ca78"))
+                    (144000,     uint256S("0x0000dd507d1b7059fb9c41c103ff43190425d567a661a59d704563c9dce1a1c9"))
+                    (145000,     uint256S("0x000097e5ebd34461ebcb5fdd3beb6e973fa752817f2ebe9fd3d57a56537e1ec0"))
+                    (146000,     uint256S("0x0000afb0eab0639d2623a15d8454cc7464c83f677fa7461259a445304fc3d3a8"))
+                    (147000,     uint256S("0x000123ce32adbc6c65e490bcc21554b0afda1476b2a6da11a28e264f1964cda6"))
+                    (148000,     uint256S("0x00016278bed29b081e4986de9c6422a89d8aa719dd1ab422c1ea7fa10284094b"))
+                    (149000,     uint256S("0x0001484305013531de1e5abda094fb453d5c5fb0d35812327ea01517c9149cdc"))
+                    (150000,     uint256S("0x0000da3a58875dc171e5bb9747cff5dfa2880d39e244d3f10acccf5232aac81b"))
+                    (151000,     uint256S("0x000006f333c55d2b6ab5f334a6d05f96fe74e301d4110ac92807239873f25671"))
+                    (152000,     uint256S("0x00008844695c54bee8e1711ec7e80f474c7a3bf1b78aa272553ca233746c912f"))
+                    (153000,     uint256S("0x00011c8bc4ffe00ea899ae19daa572e61e4cb951a594229d67e2af19d6388d21"))
+                    (154000,     uint256S("0x000111aaabb95e1cb1a225e5e8b2a6727c11da97c7391800618c7ba11c6ad669"))
+                    (155000,     uint256S("0x0001011a4d88acf916da949572a7f1c208bd7d31e0598d4337980c48ed88b18f"))
+                    (156000,     uint256S("0x0000651ee0d6bdaeec5bf585fa628e4336e7238974ca90461d38506c34d6f00b"))
+                    (157000,     uint256S("0x0000d2ecfe64aa069aeba21fb1bd8995cfad455c296670e3dec13fde989aa1c5"))
+                    (158000,     uint256S("0x000113b2ab0d24a2bac410a0155ca9d2fa6b2923c0042c228dd86fe37ad04469"))
+                    (159000,     uint256S("0x0000b1741e1d0b841bf0c0d5b3a0b9a906cde8e630e10b71ebfdf18ae5197d9f"))
+                    (160000,     uint256S("0x0000419b54cbe8a842b92201996bd74382b63db7ab0b1989b932ecb19bdd6f4a"))
+                    (161000,     uint256S("0x000076eac68434f40b6921b251fc2ec5de4748044d849887a70116f344f1477c"))
+                    (162000,     uint256S("0x0000fb948303f30cde6c2ed932915e0f6aaa932dc3dec324851b256e82f4f2a0"))
+                    (163000,     uint256S("0x000025244341c537faf365bb46626f0283a2fc0cd668c93cb9771da7f7c6be56"))
+                    (164000,     uint256S("0x000046fc2919f8ae4b88c1faecea97f6301a27a9a16184934d70b0b305891a14"))
+                    (165000,     uint256S("0x000116cc086ac32a24092d39089d2bcf5977bbc08ad916a8fac2aaefb48f2220"))
+                    (166000,     uint256S("0x0000dc6455e6eaae079ba6592fe0d5688c696955f00d33dbfc0cf76aac48e10a"))
+                    (167000,     uint256S("0x00012685e23a0997797098d047631fe7da1849e763dda0c7a00f47c7dfd13366"))
+                    (168000,     uint256S("0x0000b28813965516fe96909418dc72a4ce126401cd7a03919b9888d0da3b37d3"))
+                    (169000,     uint256S("0x00014522bcc0fa9995c6b1b6e6ba3ddd4298b0dd59854d25e713c43778d93d77"))
+                    (170000,     uint256S("0x0000f8e02172873f12b2b1adf8709b5d1990ef64b674fb0e5ed1ea08db9b6a48"))
+                    (171000,     uint256S("0x0000b0d9d1cced1c0396bab1f1003c9a009dc47da63c8220fc23bb3948a82ed2"))
+                    (172000,     uint256S("0x000099c8db9b14c2d5f7c685ee8569755bc50306397f749c7e0e31e709bfc4f3"))
+                    (173000,     uint256S("0x00007c422bc9f8295deeb35ea5225bc4f8021fee412c9a5127b6067582b356fa"))
+                    (174000,     uint256S("0x0001127a0d14aec0b5ba96dfb606cb9a562d5dafe79646076b9c0a7f7bbc8ffa"))
+                    (175000,     uint256S("0x000091c16ae7ffb036f716ac975bf6a9572fd9d439abef21036d18c3be0f90c7"))
+                    (176000,     uint256S("0x0000f4e7f4a42a9bf0dfe831764ccf9a8116f98e8158d072b8034d6b7a1e0400"))
+                    (177000,     uint256S("0x00006a9efe8a6d93dc8d16757a425c2cb8b910195f08fa210bb0bb3daec47080"))
+                    (178000,     uint256S("0x000065fdff26f07f13a0e9db44f6847161b360a6dea1cb7ef810c93a62043025"))
+                    (179000,     uint256S("0x0001a0a5300ed334e0ada6eb53d762ebcb1bf7ad0b6312905257f7698477ed51"))
+                    (180000,     uint256S("0x000131b050c745484f85e2c8422bf4624f23c69969d1c7d2f6760ef62a864746"))
+                    (181000,     uint256S("0x0000cf46ed02cc030fa3209a7fdca35a99249a17b241d30849ea094cdc827a49"))
+                    (182000,     uint256S("0x0000b16cd4ef9db7e929372be056e12d8422575891d032298cc17853d043a6e8"))
+                    (183000,     uint256S("0x0000d5d53dbb045bedbd997855eb931d7e671740e2aa37a84e184b43b90cf1a5"))
+                    (184000,     uint256S("0x00010f06fdae2de13519604475ff9412eb67731f9d4d0420c00b1f2530a5fd91"))
+                    (185000,     uint256S("0x000145be18021effbc081d0ca8fd549317766b57d828bc946436e84325b17c7c"))
+                    (186000,     uint256S("0x00006e592793a9bb5795a4f76b5ed47af4ce51b0d2e6730888c2c38dca5864b2"))
+                    (187000,     uint256S("0x0000438bdd8a024ccc008726a1690873039153df76ed254d2d773e55def68742"))
+                    (188000,     uint256S("0x00010108fe7c2543e5b258ee511ded17e12f3ed1688164ef78526684c1ea193e"))
+                    (189000,     uint256S("0x00005cc59b9b2116afa0e6ecc12769ee5f91efa91d245fc64bfda90479f8c9a7"))
+                    (190000,     uint256S("0x0000572751fda233f466c6ad237184ff6a7a15f8d84e5471e3dc5288ad74f592"))
+                    (191000,     uint256S("0x0000b5bb7236376176640e75308466cec3c3fa7bde6f24b1d12c96e94df2bb58"))
+                    (192000,     uint256S("0x0000620eaa310878ce85d6cd90d2b4724b36236575ff26c2ed6e34c93f6a8625"))
+                    (193000,     uint256S("0x00003a8b7d4cc3a92bb3b5301f9d7ca91941150e5bbc10f1204ec0175053bae2"))
+                    (194000,     uint256S("0x00007144b1bd53defd4cc1e78832a2bec8d66e094a0f03c22276e846cf8b598e"))
+                    (195000,     uint256S("0x00010530fcae36dc749c679366101df5d344243238e0e6dff2cbf57f9e25d5ce"))
+                    (196000,     uint256S("0x00002d2b003cc4851f4950cdfe7996f55b26c7564e60feb6e19597db49dd998b"))
+                    (197000,     uint256S("0x00011545798a62155ff5aa047a1cb59c0860b187a59bce8976b57f9c3bb35184"))
+                    (198000,     uint256S("0x000061433820de56f44eb774c2f54181b0e6d1e6b27e4a8eefef90039bbecd07"))
+                    (199000,     uint256S("0x0000403ced11ef43d8324070ddc30fc69a0c2d8186e4551c140a9378f0312d34"))
+                    (200000,     uint256S("0x00009ca9950079d5cd882b615fc068df25beed137642b751b224d6a939a87c69"))
+                    (201000,     uint256S("0x000015eb67778c671b0fd29016482d42758cc2edd8361f30788ab95c8328efa5"))
+                    (202000,     uint256S("0x0000c6e1a58b63e282fdedf31c1da7cc6d8b0a6dad82fc425672ac0eaf737c84"))
+                    (203000,     uint256S("0x000078e0e23fa6f7ccf5e8bb8d6703e0d70b7a86fc0c7493f61ef57e945a8250"))
+                    (204000,     uint256S("0x0000451704df4c8a94edd50b78540e8852bb55eef42bf2da3e19a173b8c246d5"))
+                    (205000,     uint256S("0x0000309772c01eeda1979e18f93a8721bfdd08c1796ea3a5861011c3de0f9fc1"))
+                    (206000,     uint256S("0x00001ba8aa17a23a2c6af771063cbe0afba5bed5b9a7b6c12d3cf0240277fa39"))
+                    (207000,     uint256S("0x0000bc3893889caddd09c6117bbd6dd044ebff10b28e008f19f7c43a496592fc"))
+                    (208000,     uint256S("0x0000684467ca15f917315fbab3fc3f2907c5f30153c5b884d0298a0d1e77815a"))
+                    (209000,     uint256S("0x0000a4f86f394beec9c9241e6dcb05b49393653bc5eaf35820403e54a23bcab6"))
+                    (210000,     uint256S("0x000097146b9280bac0344dc886cc4c77141b7467e2ef68e657525d789a9cdcc1"))
+                    (211000,     uint256S("0x0000298926d49fc5da4f866133c5c1d1e48d10a17b384eac616022057a7a46c9"))
+                    (212000,     uint256S("0x0000eca72307d64a15d234ee372e18862a46d6fc7fd2d0ef3d35c0e5ac836cfa"))
+                    (213000,     uint256S("0x0000d89ced1ffc0a9fbc0763d6d090bb19e2657f93c43144b359c16804778a89"))
+                    (214000,     uint256S("0x00010f939491f8393ddf82118d72bf420c3ebe01788d3cc69163865bcd848738"))
+                    (215000,     uint256S("0x00006ad713ab44526e84e11d0400e5619c2415773cf5068f4946d52bf9633f10"))
+                    (216000,     uint256S("0x00008410e6c8ecde65179424ec6443ec1b2215d2403d8b6f779da51136ec02a1"))
+                    (217000,     uint256S("0x000020ee6b9a6228bbb57a3dbfab949740801149096f7d0633066026e6792ee5"))
+                    (218000,     uint256S("0x0000d38defba9427c17c1cb43398593528af10ae6fbec1d445ce2533c4a0228d"))
+                    (219000,     uint256S("0x00001066c0c557ad46f0228c6b8ca18f17979032c55ae24ddab15394080987da"))
+                    (220000,     uint256S("0x00010f0dfb2aa26bcd90f8769709a91e0948c03b56ca24740a94f59d5822a815"))
+                    (221000,     uint256S("0x000058f2dc34a3060aa22edeb91d3a389f0732e479dc2c0d33696fe61ef1c9f0"))
+                    (222000,     uint256S("0x0000533b7f73d91cbe609c8626083dc44e8ce65ddc723729a16e9469030ba263"))
+                    (223000,     uint256S("0x0000f81efaff06d9a57c42026bc5aabe52a0ff81a37220e16c4c84904e7cab64"))
+                    (224000,     uint256S("0x000130f784b48728fa8f619617996b7e99dfb430176f9ba894a68630a851cd4f"))
+                    (225000,     uint256S("0x00003c810725d91c1c489ec513ae71f29562fbc4292719babfcc78dcb293a9e2"))
+                    (226000,     uint256S("0x0000dd323efe5d0e9adc1389e4c9eb1c4070fb38d932683032910aba746b3c2e"))
+                    (227000,     uint256S("0x000132092774885d1ce3ec989f1b199bdc178b7d406ad9b0d23d3e4e6720d3ca"))
+                    (228000,     uint256S("0x0000cf429d0c05ce9e009e501d724d8929fc40027a2f78f7e67ec7d86e91cd57"))
+                    (229000,     uint256S("0x000061b40ec34dab4fa83698ace103b6caf9271cbca2b8c7ead55fd299f23f1d"))
+                    (230000,     uint256S("0x0000ca632b73f5b1ca9d60ede2010290712fc2f2d28d08ecb31b0affc5b8284f"))
+                    (231000,     uint256S("0x000025ffb1c37889da722af7ecfe87e3897c813e4b948d30e1647d44f1a2439a"))
+                    (232000,     uint256S("0x0000147749add04281819da29a8c6d7d7e30fa9e8307738519d33605bb26772d"))
+                    (233000,     uint256S("0x0000b9ef9879f18d47d7248a8404b2f2b38490f1ea2272e2ab5d10e57e687698"))
+                    (234000,     uint256S("0x000006a82f41ac94661d4e0a3dd8d5ef790b5c7c3f68b3bbf9b2c0749ff3171d"))
+                    (235000,     uint256S("0x000088d9f88a14a5fefcba4bb61c05e43518806bbb489ea4ea3c53e48ed8262b"))
+                    (236000,     uint256S("0x000036c1032ea9f7091faa0ba289ef025926e4f012e19a65476ad061d61343dc"))
+                    (237000,     uint256S("0x000016076e6dfd0f0de47d77f975823d286c9458f0e9ce851b8a585e442d1503"))
+                    (238000,     uint256S("0x0000b228ebfb020faedd5db874ff7c20bf50f33e0ed824ce30da871ef8859a30"))
+                    (239000,     uint256S("0x000098f1ed04960ba6dada245c1d954dda785a250f1365b1d46934514b513e6e"))
+                    (240000,     uint256S("0x00004827b75431d480812d39ca8e0925e44889c18b08778b2171c78aacc800f9"))
+                    (241000,     uint256S("0x000047f75806dff17a4fbdf87a2361ebf325eb3043d3e7cee86cacabc81394d4"))
+                    (242000,     uint256S("0x000027fb57cd69593cc13f6e4ba8cc32bf5982f301c2a9e04474abac8313ced6"))
+                    (243000,     uint256S("0x0000d6fb59a655b9402dddd35f09e25085ba1a472e3c344b392d5b3ee293db81"))
+                    (244000,     uint256S("0x0000913dc99d2bc33a75deae45a155e2b8dd7953dcd87be10be4943d1b20a82f"))
+                    (245000,     uint256S("0x000041e52aed642e547ec8895d84d25203b296f871b50a1f0250ca00c5cf01ea"))
+                    (246000,     uint256S("0x00000dbbaad4e01e63b8e068a25d0210ad2c5f656f6d77da241b980fbf77932b"))
+                    (247000,     uint256S("0x00010edbb33cf3df1dc924eac96ced741f3a735394bc9fed3b8c1ad3692b3ec5"))
+                    (248000,     uint256S("0x00008e0bfb7b326a4bfc6a2995a14f357a27f5725d930a62d2d3ba80f59b2ee0"))
+                    (249000,     uint256S("0x00000cf51bb1334a730b924430908700a6f6a995bd9dd252d77b7f94a014c8a8"))
+                    (250000,     uint256S("0x000090c5798405d73f400657dcc5685172c6b2608809a9ec2e82297716e5f5cd"))
+                    (251000,     uint256S("0x000082d84ca93a2211bb870b3dc2865092fba3b772acbe934cb0a6ff99338762"))
+                    (252000,     uint256S("0x000090f2de1badb88177db6c3682f0f223196f51a3e054fe6b06caa5d5e914e3"))
+                    (253000,     uint256S("0x0000e0f97c745975bbe5050af8fe92637a7d0cd458cd1706221d34af719f995c"))
+                    (254000,     uint256S("0x0000b8eb6c3ec95367882780cba0369222a9acbdbd626bbdc2efa5e9806309ee"))
+                    (255000,     uint256S("0x00003f05f5e1dbdc2038158fe47ec02994e8cc643a710a513f8f489dd58f61e8"))
+                    (256000,     uint256S("0x0000d31f04b719ad5681f7e1b517daccd9694fbc9409ccd286f558455982d261"))
+                    (257000,     uint256S("0x0000ed07ac5882e040bb9de0f4ad4d4527ca5c73c4f1a88eb53dc0651ecbd1b4"))
+                    (258000,     uint256S("0x000097e6df4db5049fcff2e691c02570d82c7dbd168189c06f31dd94949ba8b1"))
+                    (259000,     uint256S("0x0000e2e8b741d28d9a097229d6e5a2ba1732a82fa2ddcfb41f20eebd94c76c32"))
+                    (260000,     uint256S("0x0000263c2baec9d5575580a30787d4893c1517b64ff7294e41f2efb16d21ef85"))
+                    (261000,     uint256S("0x00008b142681d8cfc53df1ea806f828f9bdf64789eddd8ee3d031bb8ef8acba8"))
+                    (262000,     uint256S("0x0000d2482da09b9d9f76fea70205c1de1029074f2b352ce4b44e86188139daef"))
+                    (263000,     uint256S("0x00007ab5c28f261713ec133b8543393d556c1a259ca05968bd3075792aab3ca8"))
+                    (264000,     uint256S("0x0000a75e0af3d8f54950cdbe04a0d083eab58c4aa5c83151883f1e4ed3b81364"))
+                    (265000,     uint256S("0x0000189eb94df3a9cbc293fb896cdd2c0a11a96c6312ebc48dabcc87c1ce77d5"))
+                    (266000,     uint256S("0x00006843e067df56f2eda15d3d2f2b0a3ce1f9ccca76267b43b355939538d94f"))
+                    (267000,     uint256S("0x000061e5f1d6bec772831bfcdf02331a6cb8824a2cca249ffa49737d19782447"))
+                    (268000,     uint256S("0x00007f909a3f437fbef9702678e510ab70af79371ea7810af0ae12fc5e9e014b"))
+                    (269000,     uint256S("0x00007de818cb26675fd9edef889f228985951c8654354ff50671f672bc868815"))
+                    (270000,     uint256S("0x000027590b1638a77fbcf91aa46bb6fe044bf24a63a79ad6cc74b46d2318368c"))
+                    (271000,     uint256S("0x000066e889f46e219dcf0b4406ad481e8fc400bc65bc4de757f8a2cc946ce9cd"))
+                    (272000,     uint256S("0x0000380a032fc737f0d643ad61ba707f4c6fe939a2b430b10fa581f5a0679100"))
+                    (273000,     uint256S("0x0000126824caa6aae226452aab57a114ffb6afbf8cf261963a3961318a28b419"))
+                    (274000,     uint256S("0x00005c4c0b084a1d192dfe12783aa91c778f1e709457e73cf76f5889cc26bb78"))
+                    (275000,     uint256S("0x00007dc532c6b377c64462a8b8c16b3eff0096fbd9c6b4006c752ce7d653989e"))
+                    (276000,     uint256S("0x000010f0388da6d99966cf52ea61c27d687ebe07e8235725df251ad15ead0dee"))
+                    (277000,     uint256S("0x00003e8d6d6063171e835af9113f880af2a5907712d3c0e96350d3851961856c"))
+                    (278000,     uint256S("0x000037ba4dbfc93957ec601b00835a98c16ad2ed58c26c61ce4b9c2a3d333ec2"))
+                    (279000,     uint256S("0x00006717a9b460b220defcd60216be89ee2c433a2d888bfcab850ad5f209d94c"))
+                    (280000,     uint256S("0x000041384c4c769143b1501c7c6f892a4ae5e295ca471499e08c8299f5162099"))
+                    (281000,     uint256S("0x00000b03c4c5ebafada3fa92aee6703ddaefaab554f48bb204e358ac0aa97add"))
+                    (282000,     uint256S("0x00006be32af84c330c5d7d2d97684f1e3fac9e1f298784cb15b35df6bc606f8a"))
+                    (283000,     uint256S("0x00000dc131bd64e0911950eccc6ce708ac27bd7388da64e19d4cf23ef888b5c7"))
+                    (284000,     uint256S("0x000075deef6c427d641f480805c5ddcf260481983924be5f6a22af7a934ddaf0"))
+                    (285000,     uint256S("0x00007a019cb2e868b90a7c30debd7de1bfb5440e06c5bd8187f921358c7ae781"))
+                    (286000,     uint256S("0x00001095ccb8ef1028bf4ef8df40467441167280b6a7a15384ba60708ca4ed29"))
+                    (287000,     uint256S("0x000085d7c734a13bebb8057beff8deec794a930bd6300af1becd7de50d425fa4"))
+                    (288000,     uint256S("0x00001d8395c53c0fc68e536df49fe942caa67f6d8a3f91cdcc018d15b3fe0593"))
+                    (289000,     uint256S("0x000050cee8c1581b2d8214d43f9a8c888bdb390b91352fd5347b48df92828b8b"))
+                    (290000,     uint256S("0x00004240e011ef34f0b6015698b4baa2728b2885a69284afab0424fc6b09877d"))
+                    (291000,     uint256S("0x00007c90a0da5bd891f8de0a7a09d1b8af3831143926d02e90d29d9d1934b5e6"))
+                    (292000,     uint256S("0x000015965fa7e60705a11e595a18875ed065d8b11d8030880e59a5d474e458f0"))
+                    (293000,     uint256S("0x00008981da5387cdfb537ec9d4eb8e8bc81bf5f18938eaf04889acf011c96749"))
+                    (294000,     uint256S("0x00003810c0f915b3fc12207edc99f7b9226f5572f491e7349e79b228c8e7469a"))
+                    (295000,     uint256S("0x000087f128604abe37b8fefd2f098b0e0984e6e7a65e2151889a302a68c06eca"))
+                    (296000,     uint256S("0x000062a42664d4c4e88bbdbd991e7fee35f779c126dd27386e5225d2237dc2d7"))
+                    (297000,     uint256S("0x00001c42f5f24b38f202527e3c2cfec3f5621ad87e75253b5d431452d786d4c4"))
+                    (298000,     uint256S("0x0000198517575016a98ee8b54deb7232c2312f017d60959280060ea3cf92e4f2"))
+                    (299000,     uint256S("0x00003a9031fb5b7e9a318c08588f63e52a6c91845b444e515bfde4c9b88bffe0"))
+                    (300000,     uint256S("0x00000c72234e026b3ac4be4a972889fe48810cb27d551058b77d4c5e9b32575c"))
+                    (301000,     uint256S("0x000099dff2afc7600c8b724dfc3202d0d29d38ebef21ffc02f4e2f2a66ccea99"))
+                    (302000,     uint256S("0x000085a79dd00da9a21cff9b4266a8fe5c2e90b5ea53ec1c7792295192a2e37e"))
+                    (303000,     uint256S("0x00005798b40b3eb295eeb9be6af8ca5007784beda82d04a4a8b9c3a2ac0b1096"))
+                    (304000,     uint256S("0x00004eedbf20eec4f279484eb5c13c266d463475ad2fdbb7447bf0a8acb7ac6c"))
+                    (305000,     uint256S("0x000029cab3bf30d2b12ef99eb43ed67bf6f81399938cde4f061dcf1d3a3b8282"))
+                    (306000,     uint256S("0x000030648c81f681bc962e698a27f587da62182e555579910c456f723109b42f"))
+                    (307000,     uint256S("0x0000085e26e0618a933a35267273dbeec35ef76f83d7543443cd55a2ca0e233c"))
+                    (308000,     uint256S("0x0000239ea91faaf5425f65fc585e7fac6dc518869a1a7091450f90ee8bdb2fd1"))
+                    (309000,     uint256S("0x00001b62fdf4af7be68cd70b1f982d29260dd1e667ef349314a4bddd73d55496"))
+                    (310000,     uint256S("0x0000765eb51eaa30265211672e8311dd40e265ad4142f4a03efd2f4089d9e186"))
+                    (311000,     uint256S("0x0000140c77cdf8f9d4b289aebc0310305693f970ec409f2b828c3ed513f3e58e"))
+                    (312000,     uint256S("0x00003f6e2f0e82c242e5b0a7e126ad210e53fb0dfbe794ff2d7e1cdd3873e818"))
+                    (313000,     uint256S("0x00002e678cd8a3a18a1cdc5c957b6c0c880acc21b801c68cc4d7b37110a83f22"))
+                    (314000,     uint256S("0x0000198bbbeec4927abfc60f2becfb96a5b0846962d65b32de3f9243bdf39af8"))
+                    (315000,     uint256S("0x00006c90b93d54587dfd63105e063f6ddf43cff500aa9968622df5c93a5b0798"))
+                    (316000,     uint256S("0x00004c21c397bf276a5cd62d960e308fcb098ec45bd60a4f1bf023b6edf2e6ad"))
+                    (317000,     uint256S("0x000036b7f6b9e2dea52a6067a94f2e2704bc1824c8e11bd300a841c46e7dd2c2"))
+                    (318000,     uint256S("0x000025029ef96a105a50a7030fb0d61edeceea25e4effb02b3ce8eb4c6205782"))
+                    (319000,     uint256S("0x00003537409e025a8075526fa097882f919ee169606a9368d8c3db2d33119e14"))
+                    (320000,     uint256S("0x000023b752e4c077f231d05026220244ca10a603324035b885e1b0dd6443c148"))
+                    (321000,     uint256S("0x000003411062d7ec945c786237575766c5ce2e48c4f94ca04f28b1404ba86097"))
+                    (322000,     uint256S("0x000022447ebbb48e06508a70746f87b2e55f026b8ae3052a168f29848d3e2aa7"))
+                    (323000,     uint256S("0x000057eac2e6c611398b43e8a72b83f5863b104fa66120e707df6e3e6fa1ba8e"))
+                    (324000,     uint256S("0x00006fa40d2be13a2ba910156769754eab5d55059729597a02194e5e0f84b336"))
+                    (325000,     uint256S("0x000007fcd4dab7c2cfcfea47ce88932d3ced21fa9264c1c8ed9cbf3fee08635e"))
+                    (326000,     uint256S("0x000017fdd022300e952d9274c63cffd8c791dcaa4d82e5d1c9615464df19ae13"))
+                    (327000,     uint256S("0x00006739a0fc2ad8788ef615aa26d6a9c7c6d6adf9a9e84f7ae68379eca2a0b3"))
+                    (328000,     uint256S("0x0000777de98944635470c99ec1652aa2c15ce3ff4b19de17eed5373d2474a6ab"))
+                    (329000,     uint256S("0x000042206ddb76bd7efdb14b694543b685771c6c341089f5bd1dbfa04d6eace2"))
+                    (330000,     uint256S("0x000069d6c21607c368128d4586255f315c55380759a766f961acc35a2e9cb166"))
+                    (331000,     uint256S("0x00005b19671f21015db7011c9702a420bab766d8bb7cf25b8525429eeff36b45"))
+                    (332000,     uint256S("0x00002d62d1f4d13ec708f65c04937b86cf86a36f68caec269f598e8835ca362f"))
+                    (333000,     uint256S("0x000013ef2283eae4c9631b4bbbe80b4fb06b663e25a569336326d7897d80a9f8"))
+                    (334000,     uint256S("0x000018b4c8d94267953a1df06439a1393c903255a58c9152593eb2d369d87399"))
+                    (335000,     uint256S("0x000022628e5db36faec4fe5f107deab56c47c61bb29a51177ecd6f86939d83c1"))
+                    (336000,     uint256S("0x00000f22f49242eb151276aa5fc84debb67bc632197c448dd23a501923f6cdc9"))
+                    (337000,     uint256S("0x00004aea6cad4849f27af16c298a990e242b77e249eff52fc9c955c121d5ea62"))
+                    (338000,     uint256S("0x000064b79a8fd98e2c57184d6ac67daad8278419aee044bec13c7d8de0baebba"))
+                    (339000,     uint256S("0x00007ed65e7fe77d691f91d1ed0fbc40413f277770c8a5aa389505b2a179f428"))
+                    (340000,     uint256S("0x00002d001410cef77057d66b49c1949ca1367e11297a595b13f17ff1676e55e9"))
+                    (341000,     uint256S("0x0000544668ada85a8429537011fa53be0a2c2801c6c022289b8b056ee54e96ef"))
+                    (342000,     uint256S("0x0000311ec160ae645fdbffa2eccbdd4212d6c7a5de7e78786d37e9341d531f75"))
+                    (343000,     uint256S("0x000010a8f4eefa8040add659396d269e245441439e33154a3b7324ba8884a6fa"))
+                    (344000,     uint256S("0x0000500a9df05634fe8987d437cd3ccb502fc36c00fdc73195bbce7d63d1a7a9"))
+                    (345000,     uint256S("0x000002a979e67ec52d92b87c4637f166c694378a9a57e3f8103c7d8a084f551a"))
+                    (346000,     uint256S("0x000026662841a071a8c0cc28bd560b42af3b739db3d494dc9bf2754bba021da5"))
+                    (347000,     uint256S("0x000031d4a32cf5e1c4f1b7d7e3556a2ce8de88ad3f5307f5b20cd7e40a2d1401"))
+                    (348000,     uint256S("0x00000f91efbd01c0cd21b1ab0e0daf2d014a7e6bab3fda7ef480ab35c80a2421"))
+                    (349000,     uint256S("0x0000460718b2aee973f80306a37506f9cbf40123fd1205c26c33b0d9749d524b"))
+                    (350000,     uint256S("0x00005953abe841392b72e8fab12e3cbceb18c128f73e1aa4406defd18543fe4c"))
+                    (351000,     uint256S("0x000018647cfc45a1524168193e67e6af22e8677ba3428dde5f6a2f76c199532d"))
+                    (352000,     uint256S("0x00004d0d3fc72f9d7f9a6712c098eb6cef0a7756886011f036736de200fbe5c9"))
+                    (353000,     uint256S("0x00007948b8f6bb2433088cffb4bb18ca1d03aad3068a7ea923475f1aa108fd20"))
+                    (354000,     uint256S("0x00000a0072325a23f9afcaff49a8c3bcb04f1fcb01612de33bcb9f0f20ebb356"))
+                    (355000,     uint256S("0x00003e0133ccefae6723c9f14bfd290a7aaf60c2bc962c293fb58b5957ed1a2e"))
+                    (356000,     uint256S("0x000005b41a41a8ec5c60cad85a03d9fa5025b5d9a088a6bbc2ebd1d8e858189e"))
+                    (357000,     uint256S("0x000021655f02625c28257183e5c4639841b11661cf40f00fc5ac4bcfcf1eb072"))
+                    (358000,     uint256S("0x00007c3fe61dca2d5c52bd5e9090c91812bab9c6a7407e32ed0a930b421f5b80"))
+                    (359000,     uint256S("0x000063f8390cad7ad17cbd18983b923e18a1469d5730dec7a62e12914c66df9c"))
+                    (360000,     uint256S("0x00000f11a3a78c71d8a7c722cfb52f51006b3656b707cf94c0b08a80c4fd4dc9"))
+                    (361000,     uint256S("0x000008e76b1c141b783936c946af3f121d5b96fb8766d83c58ea7f7602c78386"))
+                    (362000,     uint256S("0x00000c92d4b3163c33c0efa3feaf6f4c170f9d6288d2435a09435eac87d04e09"))
+                    (363000,     uint256S("0x0000567379ab1430696266da7ee6dd1e7ba0eb91bba09c85f558c181e01625e5"))
+                    (364000,     uint256S("0x00000712954e172eef571e8297ea1843aba0a762b31b5b2b40ca2027e7c0b1ec"))
+                    (365000,     uint256S("0x0000627358770bbc0bf614acb3d02d996f220562f083d08c75e71aa2e83a7870"))
+                    (366000,     uint256S("0x0000404c17107474c2a0704c9920ee16e502c8119581f4707e0959af3004746a"))
+                    (367000,     uint256S("0x00006c5d54ad2b5279842e8ee726359064c72a034c5c3d5f261413c2cc6a4e6f"))
+                    (368000,     uint256S("0x00000df9f5d119afd39c0654010f1ff492f8e04dc1dbe1cc0d3ad5767601c91b"))
+                    (369000,     uint256S("0x00004e47d205ac774a1f6d7d8bcc29d6eba6f11005b75aee6dedca1e46a1c1db"))
+                    (370000,     uint256S("0x0000810057e4efa124db97d9433372af35b93ae61ea4b620f7ac3ac26658a5aa"))
+                    (371000,     uint256S("0x00007e49d0ae73df2647b33550aad63d79c05e40b08fc1c25cb9450ad2b5e8f3"))
+                    (372000,     uint256S("0x0000076bfad90f3f5befd763f0abdfd05077821099e0c33bc3947ed853d0b928"))
+                    (373000,     uint256S("0x00000d03d70c31a5ae2d32b66a3528981c88d361cc165512a3d9278ebace0589"))
+                    (374000,     uint256S("0x00003e477b6dd1ffc2218862bc18b5a651c82122cdcec0c455613d1891e9a727"))
+                    (375000,     uint256S("0x000012ad562f8b65a93cb2eb5f708d55e4c3ac689d2020843c55b34099755233"))
+                    (376000,     uint256S("0x0000556b17a0197dbaba33c7f58fee2cc9219b6918d925a4146fa7fd5de0e94b"))
+                    (377000,     uint256S("0x00005f1ac71e07fcc4f44fdfef693983a872be58f5b1bc04d13873408a54f2e2"))
+                    (378000,     uint256S("0x000014e65f4e30b3097d2ebb33c11ada6abaf81e8ac3ffc2e0b6d4756b59822a"))
+                    (379000,     uint256S("0x000021418aa5de171ac72097abad42b7f1af1a2f7e19b4c98c7174d5164fa5bc"))
+                    (380000,     uint256S("0x000046b214d061a9c237e42bf42493f9792cf80b95f89ef10f432cacee23eba6"))
+                    (381000,     uint256S("0x000068f06f5bf5b288e78d694775cb76cf1ed473f95da29790e4b60133d6bb87"))
+                    (382000,     uint256S("0x000008c5632f8e3f8e61aebd686b624c7ad644227639d320c3ad286f71d4e14d"))
+                    (383000,     uint256S("0x00003b7fffa7e988b90e05d94d24153b0a22e01d9ee0c56e04e9263c88c558ee"))
+                    (384000,     uint256S("0x0000083022ca686c81f5f403743dba37334a0e96f96d3c8bed7353a1bd11e58b"))
+                    (385000,     uint256S("0x0000485dc4369a16c2c8bde7577ce99ffd0a15a1d21cdf61c01f0bee17b36b2a"))
+                    (386000,     uint256S("0x00006da0099b6f9edb40dab855231677bf4f97b0e7643fccad05cd97a8b76397"))
+                    (387000,     uint256S("0x000063ff38ec555dc089900fe0ff5648488421918db713941d6c24cfebad37fe"))
+                    (388000,     uint256S("0x000069ca27290d71648678a0c5ebd379a17ffc895fea7b23837093a337563060"))
+                    (389000,     uint256S("0x00004a1e13ef7557c9dfe0c7daf3e7483e7d1420afff64a5325af7d5bfe49994"))
+                    (390000,     uint256S("0x00001dce3a9cdd42f97d3268d29bdad179375f61f7d4e729919450996917c583"))
+                    (391000,     uint256S("0x0000071173926b7f9492e35cf48185c2cb57ffcaff2149dcef5c40148a55255d"))
+                    (392000,     uint256S("0x00007c3336097b98f2fbc46dcd4f981e73ddb93c8096015282eba490b773cda4"))
+                    (393000,     uint256S("0x00000738869c9b8cf66aaa075ebefc5209c90a0f225b405e1850b0b00343bc2e"))
+                    (394000,     uint256S("0x0000537c3d2b6794fc5c2636a3311e1cdb34c019ae2dc09778d0c500e1593f2f"))
+                    (395000,     uint256S("0x00000dad4673f1db54a434d106a69af55f494ac29a428ff37f4e4aa3b734a37d"))
+                    (396000,     uint256S("0x0000514b509a25edc24df6d94e24e2aac5727c18d361fdd7e64356f2233016b2"))
+                    (397000,     uint256S("0x00000eaaf35e4358bee2a8c5981683b15214d7ecc03701438f94f5306d10c6c3"))
+                    (398000,     uint256S("0x00007cb707f7132454c53ba8410dbb588c3b23e7d731f824d58da21f4ac62330"))
+                    (399000,     uint256S("0x00000cc6edba6cf9dd44204502309c781a1f769e019e42306c785dfd2d3614eb"))
+                    (400000,     uint256S("0x000023fc6e679339fa72280568217dee1ea0c26790c13f80d0092f9b12ed5f38"))
+                    (401000,     uint256S("0x00004ee2b9c7df597e26a4ee85b56c0842380adf5d15b9f6667a132f7cb0b07c"))
+                    (402000,     uint256S("0x000073b711054a260c45b4ad63796949d2a00a0baca00e1a68ed16fc98f45d70"))
+                    (403000,     uint256S("0x000070b43d9d52a1f896a13bfdfb445fcc3b1374b7ef123b0cce1488f551a954"))
+                    (404000,     uint256S("0x00007864734f9e3f3596d9d92df853d3a9b1172ff747fe5983e09028114404c3"))
+                    (405000,     uint256S("0x000075ff54f6af74e69cb36dfd7634dace0c68e00d309da017f81ea5dcc9480d"))
+                    (406000,     uint256S("0x00008b908deffb33856ccd1ef6afa73cf8bd01e8c3b5be502829dd64157e3f7e"))
+                    (407000,     uint256S("0x000023d28f6b13c134285247c6d8191f16a94463ccd84a506c99ba52706b67e6"))
+                    (408000,     uint256S("0x0000723a9c35577d2e56749861ad4e9d3c61b1c650e0c7c832cb1d60346fb46c"))
+                    (409000,     uint256S("0x000021a04d41834edb1ebf0c3c09488fb1e3da4c30acfda07ef154de955dbfc0"))
+                    (410000,     uint256S("0x00007b63162192a0b9c1015a227df9fe264591b5842aab61a637c06768a5e3d7"))
+                    (411000,     uint256S("0x0000064165fbcae2b8c44549630ec47c9504c77ddd0aaea91e846539ce023c6d"))
+                    (412000,     uint256S("0x000048d4879eb955e516485f822f2f52fa078f02396fcdbd1e0fc0698a90d577"))
+                    (413000,     uint256S("0x00006df51ae354366835450d019ea8a7a59a34060dec74de630bdf8004bbbd18"))
+                    (414000,     uint256S("0x0000113f9fa68a6a1acc32aeab61e8ca15e1f53e9f43b9e77bca85fecc7871d8"))
+                    (415000,     uint256S("0x000003ec7bf286218a52ceea9a5b8ec460a5a77211679c2b8d1d1e4ff96c03fe"))
+                    (416000,     uint256S("0x00000c4a34784e10158b231baa9c35b6aca1cb1d967f65bdeed7480f55df869d"))
+                    (417000,     uint256S("0x00004462829936ef1967f6604d00c0e034588642dacc1ec827ec3b4468202ab0"))
+                    (418000,     uint256S("0x00005debf20584e6e0adb8c05a73bf4b30484451964d39536f50bb02b426b0b1"))
+                    (419000,     uint256S("0x00006357b1afbb6aebcfc778c06ed1fc51fbb51a7fc9b882c4c9bb4a35e0b4ed"))
+                    (420000,     uint256S("0x000040207b5dc0f5e2509b1216b549672c58d68bac8224f67492aa803b2f2570"))
+                    (421000,     uint256S("0x000042124fbfa2ba3db57f39bfd4f5986969c5c4faf8b1c06cf470a5ea001788"))
+                    (422000,     uint256S("0x00003c97f3bdafac16b245ea1f3b941c52388be5bec9c087186ac17088d5cbf5"))
+                    (423000,     uint256S("0x00005068310436b42ace3d987e8a10eb858b4a23321dfeeefaef22e9446fa2b0"))
+                    (424000,     uint256S("0x00005ef6829528a3504565070d82e425614426ab25b45bca04aa4af3d7e0e29c"))
+                    (425000,     uint256S("0x000024123c6a896dfb002e50b4574037d07bb94e0a0e9544e67f8a2e090b6b89"))
+                    (426000,     uint256S("0x00004f641099594d32e1880080931343420e8597be3939a4f6628969d4c94a4d"))
+                    (427000,     uint256S("0x000078d2859474d6b72acaa6060ced2386028e457743bad4cd9b0ced3f8ab154"))
+                    (428000,     uint256S("0x000087e3b407861303f6b32015910f4a3dd0f1f78a4e53f178ca442e9275c317"))
+                    (429000,     uint256S("0x000060b5c76252c68f358202b6f6c421d5ca9c705dd28240882258df8a809174"))
+                    (430000,     uint256S("0x0000305e76e05f96396d96187e6d35e900a4d735aeee6f105168eb45846d7055"))
+                    (431000,     uint256S("0x00002181db7f434ad47bfc295f8ebf8caa382f13829ff70b06263648e0e033ad"))
+                    (432000,     uint256S("0x00003e3f8d3848689893840e239619e875db02745d68709a533e30fef16fe9b1"))
+                    (433000,     uint256S("0x00007ec0e6150fdeee913a18f5c8f3d7099bc744a218dc6a01c63580aa9c8eb1"))
+                    (434000,     uint256S("0x0000415b347418526dbbce15098f2d8d1b5a1dd0446151efcfdd3318d5861351"))
+                    (435000,     uint256S("0x0000663b475c89a1ead8cc41c1ed10c8fcdbf417d007a6f0b95580a1165eaa1a"))
+                    (436000,     uint256S("0x00001783f2a7362a81e0b49cfdeb7dbb032e6e9ab4f66b3cefb4e52f1c5dfb34"))
+                    (437000,     uint256S("0x00008486eaa2a91c1ef5c530065431dbbb0c4240dea7a2101ab0582484003280"))
+                    (438000,     uint256S("0x00004fd678f5f493ea4e9ec5b54dd66749350fcd325c5ec677c154bcbca88799"))
+                    (439000,     uint256S("0x00009244e5e34e05cfcf1bbf619c8a8b43ceb538fabfa7843be9796a295e49e8"))
+                    (440000,     uint256S("0x000036b5b2b13908454ede21c5826af6331b728a66da7fc67bfedca910ff9b80"))
+                    (441000,     uint256S("0x000034367b426ed559bb7d0b1046eec735a850c53fce26f8b0716198ff90051e"))
+                    (442000,     uint256S("0x000059583a267d919d5bc4c65abf8c304150e45a336b9f34bb35ddaf0bcb1787"))
+                    (443000,     uint256S("0x00004f414772200bfaf67651fbc4cc103367a5108a35fe026850a4bfd92d38ff"))
+                    (444000,     uint256S("0x00001b9bc79d27709c34a96a5dbd6a259fa1495afdf8fd05c23a2d659602620c"))
+                    (445000,     uint256S("0x000061e49c4d2d995a43a2d2b491a023444b70aba5150ee4d2789cfca6018710"))
+                    (446000,     uint256S("0x000051f2bc3eb24aa77017476494528e0096a0a1cb1e29b4318ce9b3410c6751"))
+                    (447000,     uint256S("0x00002979121255c18f58c5ec1a4267104585577b91e2e61682b44d65930400f5"))
+                    (448000,     uint256S("0x00001122c7a9f21b96941e6e074122ce55cb412d659ffbfad8a0bebcbd487533"))
+                    (449000,     uint256S("0x00005ed4ab8507e94702e24ce16b257e8eac754be1eb3e743b430bdbe3e2eb14"))
+                    (450000,     uint256S("0x00001579df12ce8d38b8f4416f221964af6aa54bd065201c578bee6e03596463"))
+                    (451000,     uint256S("0x000057eae48d40b8b59a16f65fa4b5902b27dbe0bb5470cd27214f4045172d87"))
+                    (452000,     uint256S("0x00006e7bbad31584a17b7bae4b7555a4807ce276cd5046a309d79f0a402cdbd9"))
+                    (453000,     uint256S("0x0000011e661360329ac1ba58e11f2358731abd884d1c590525d074195bfc8ddd"))
+                    (454000,     uint256S("0x000065acdfbb8d1e0d66b358f81acd99711adedb85f37fd522b8b515184a073c"))
+                    (455000,     uint256S("0x000026888730aacaf408c7b6cdd5a4ebce04f4c2aea22061f5ee832a65c52b24"))
+                    (456000,     uint256S("0x0000602cca1d31d8a750c84cda243b6d454d4d93bcc2241cf0ae6982a4716755"))
+                    (457000,     uint256S("0x00002d7fd2ac55de783d6f69270fd9e499789185e98eca4561bcfb13be663cee"))
+                    (458000,     uint256S("0x000015971c8c8c0d2b2ba9b9c0dd5c97091b77e3bd747cd8f5a1396d7cbc39d0"))
+                    (459000,     uint256S("0x00008473ea08a574ab72f3246462ca97fed87478c6e5fb39bb9b340f6c8b0f44"))
+                    (460000,     uint256S("0x00006487396edc5cb9bf6f5cd62491d1d5a47e89257ac0286cbcc8f428239fb7"))
+                    (461000,     uint256S("0x00004579751a959bf33a7418c872ee533c11dd0db764bdbf800317fcca50db74"))
+                    (462000,     uint256S("0x00005e57d635a75aae751e87aa9081218babed5522861be57ca55ea5d91e5cc3"))
+                    (463000,     uint256S("0x00000fb2816e0c45b5414b72aa67a918c1ffc6a5e114d4f4aa2c1863f9d7ea7a"))
+                    (464000,     uint256S("0x00003c2985800d71f2875169d86d911bbf3ede85eaec083869bcb817d5930407"))
+                    (465000,     uint256S("0x000037d41b8dcc82d16da8907512e4c0dd4d98e5f8e1985f6c418d62fe38bf20"))
+                    (466000,     uint256S("0x000034e51cc154129c394b6130d3711bf930c47a0943c0e08598353565781e8e"))
+                    (467000,     uint256S("0x00004c2bd9c0a4414e9c689b21a8266dcd0ea9f0363559940c77f53dac76a746"))
+                    (468000,     uint256S("0x0000097d658883238e26170d0244759a6a0fb53204e392bd5607bff329e52580"))
+                    (469000,     uint256S("0x000068c832e7335fa8b095693ede2161463e250a6857171efb34e8b2c858f0cc"))
+                    (470000,     uint256S("0x000016f55342090f2f7dd1013c1780daea3e18331b9e481e44cc969e42267c9a"))
+                    (471000,     uint256S("0x00002544263ac1d071b15575a1be34f3e220e97b631bbd0a37ca2211da3be579"))
+                    (472000,     uint256S("0x000082479a6d345f52f2f6a3a7f8b3e1bde3e31bdf6971ae7e17a4e9ceb9f3d8"))
+                    (473000,     uint256S("0x00006af93834d09ba9e22c0e9bcf041df511fa73adc7c3b90b20930c14dc3afc"))
+                    (474000,     uint256S("0x000009f5395a0e10bd3467d49468f22a17b96cc56f133742b4b94f81d055a1ed"))
+                    (475000,     uint256S("0x00000732dfcbe6c20963da08712f407c0137c686c2c5b8199be7ab93533ca75e"))
+                    (476000,     uint256S("0x0000212ee23e893f853ef49641d748435b3a783c12eccfaa9d113ed1039a59aa"))
+                    (477000,     uint256S("0x00002eb7f121312d1702a95d23e6058d305bc2fcec6b665918d1f61ccdce3d8a"))
+                    (478000,     uint256S("0x00007c3f92685d1ab3a31d4462286825e1edf247b74f0f2acf203cfda160b4b6"))
+                    (479000,     uint256S("0x0000387969e04687fa879ecc4b7ef42e94d7702b2adc5c895b91036f2b2b32a5"))
+                    (480000,     uint256S("0x00004fcf6a8c13044beef7a176c1b872bbec53cc00aee74a4cbc9f7cb332ad29"))
+                    (481000,     uint256S("0x000071ff0caf576084563d6bc15fe7887b261a22cd7f2540a047486dc97cd961"))
+                    (482000,     uint256S("0x00000d18b5deb42f4a383a510d5ce92e4ffe84cf12556adb09cfc381eae9343a"))
+                    (483000,     uint256S("0x00003045108fd460198ab5db9154df288f796e4714d78bfc030bf32a0d72ece4"))
+                    (484000,     uint256S("0x000077ab6ef56dc32d8d78340e0f69e9666914ce0299c16d80c9ed44b95cc74c"))
+                    (485000,     uint256S("0x00005641dd3b8af4af4328e7240b2f614d4f9bc02d941f1cb753fd9b9e648ac3"))
+                    (486000,     uint256S("0x000045d840594db850fdf19c03b29b2587b225f7c17009b6bc92c3a95d913714"))
+                    (487000,     uint256S("0x0000428e6bef96b2cfa2a512d10ff22f459e1c81dfd833935bd2bec9a9401c70"))
+                    (488000,     uint256S("0x00004b7a10c67d0bd09058183babec02861c0722b09b75038d3779a586bcee48"))
+                    (489000,     uint256S("0x000023557e9510f58a398eeaf0c36753b93ade77ce885f8736011f5eba399340"))
+                    (490000,     uint256S("0x000021e70faa40c6b1cd9ed3f91b8ad43e2570a00e34c54c5ed74218ac33bf72"))
+                    (491000,     uint256S("0x00002edd58e2126702485fddda9eb55d1d39880c44de8d8c0efdcdecdae2722c"))
+                    (492000,     uint256S("0x00004f00c0831ebd6675da2aa83a3352e79affee2786a26dab96cda9336b7ccc"))
+                    (493000,     uint256S("0x000064438694b83dc959b20b82cd5da3f4622186404753b97340450be0a15755"))
+                    (494000,     uint256S("0x00003607262aef0da4f84721222cfb5cbb915db323ec95e1b4e70bf3ce860c6b"))
+                    (495000,     uint256S("0x000024c603dbf750c01c2975ab60624bfe5ed2e44532649917d9645ae6209ebf"))
+                    (496000,     uint256S("0x0000191661868f098c37178cebe1c4eea37f311eaeb82e5148f1452b26d1fbca"))
+                    (497000,     uint256S("0x000029b3502c67a39247b646f286d925af7d0501f994c4367d8769dadaa9ab1b"))
+                    (498000,     uint256S("0x00003e7be1463cf709a8a1fc6b431c442de0f5e972b8b2444fcb2d275287d36c"))
+                    (499000,     uint256S("0x00000d00e2075b9de577c9f2b21927ea21f4bc6719734888073e039a43e3f30c"))
+                    (500000,     uint256S("0x000038889c413584ecab16aaf0ae8f050fec136484416084187a2fa27ed1efc4"))
+                    (501000,     uint256S("0x00003e0981fdee677dbfdffbf5910ab8ccab4d91e2e3f10594668cad35e0fe1b"))
+                    (502000,     uint256S("0x00000e08e2495364b7cdd48cd2999e568e92f4ca9b27343af4240f9adc194f9d"))
+                    (503000,     uint256S("0x000014996d031f6c0b0d3e0268d22c75ee9bed7e9f845f81b8df5dd38b195995"))
+                    (504000,     uint256S("0x0000041a7d55d6e9344faff6af6a60608a4572f3c12adb79a326606e5b168cd2"))
+                    (505000,     uint256S("0x00002df16f23a38f3bf6e3e42f5f14ff44bb357a975c8eb43d4985f16e4a7628"))
+                    (506000,     uint256S("0x000042c9adeb835a1105e772a9fc637d156cc8eff5d71a78243dbf3fe0ab096f"))
+                    (507000,     uint256S("0x000001c27a7bf812eb8ba21e6ce59591b2eaaf50121e5c98fd740629d00a4e2b"))
+                    (508000,     uint256S("0x00000716bb09e7513f50d5ea46d15324d892c305a11267306c009c720f51d3bb"))
+                    (509000,     uint256S("0x00007358b4d32fac5362839bf3bebdd938905766ef3e853d00ebf8557a724239"))
+                    (510000,     uint256S("0x000045c957443966535795a08bc5feffee0f0c59b55d7ba727593dbc459a1c34"))
+                    (511000,     uint256S("0x00001d9b8898a1a26bec928ded3b3650b6e0b6cf6589f95072fbff5586057716"))
+                    (512000,     uint256S("0x00006c49e4544ce19a6b3e4a4e82e05fbc3ef1ce9d3dee203cf09f047ec92d30"))
+                    ,(int64_t)  1686842247, // time of last checkpointed block
+                    (int64_t) 523914,      // total txs
+                    (double)  1454        // txs in the last day before block 512445
+                    };
         } else {
+            // all other HSC's with no checkpoints
             checkpointData = //(Checkpoints::CCheckpointData)
                    {
                             boost::assign::map_list_of

src/chainparamsseeds.h

@@ -17,6 +17,7 @@ static const uint8_t chainparams_seed_main[] = {
     0x01,0x04,0x57,0xfb,0x4c,0x21,0x00,0x00, // 87.251.76.33
     0x01,0x04,0x89,0x4a,0x04,0xc6,0x00,0x00, // 137.74.4.198
     0x01,0x04,0x95,0x1c,0x66,0xdb,0x00,0x00, // 149.28.102.219
+    0x01,0x04,0x9b,0x8a,0xe4,0x44,0x00,0x00, // 155.138.228.68
     0x01,0x04,0x6b,0xae,0x46,0xfb,0x00,0x00, // 107.174.70.251
     0x04,0x20,0xef,0xad,0x0c,0x95,0x3e,0x61,0xee,0x69,0x57,0x67,0xdb,0x4f,0xb7,0x8d,0xc2,0x35,0x1c,0x6b,0x96,0xf4,0x1f,0x7a,0xb4,0x06,0x09,0x3a,0x64,0x33,0xf4,0x0b,0x2c,0x94,0x00,0x00, // 56wqzfj6mhxgsv3h3nh3pdocguogxfxud55libqjhjsdh5alfsko2iqd.onion
     0x04,0x20,0x3d,0x24,0x7a,0xec,0xfe,0x60,0x6e,0x3d,0x3d,0xf3,0x4f,0x35,0x12,0x29,0xdb,0x48,0x89,0x71,0x19,0xb9,0xee,0x6a,0xfd,0xb2,0x02,0xa7,0x99,0x89,0xbb,0x69,0x39,0xdb,0x00,0x00, // hushv3h6mbxd2pptj42reko3jcexcgnz5zvp3mqcu6myto3jhhn4yzyd.onion

src/clientversion.h

@@ -30,7 +30,7 @@
 // Must be kept in sync with configure.ac , ugh!
 #define CLIENT_VERSION_MAJOR 3
 #define CLIENT_VERSION_MINOR 9
-#define CLIENT_VERSION_REVISION 3
+#define CLIENT_VERSION_REVISION 4
 #define CLIENT_VERSION_BUILD 50
 
 //! Set to true for release, false for prerelease or test build

src/dragonx-cli.bat

@@ -0,0 +1,10 @@
+@call :GET_CURRENT_DIR
+@cd %THIS_DIR%
+hush-cli.exe -ac_name=DRAGONX %*
+@goto :EOF
+
+:GET_CURRENT_DIR
+@pushd %~dp0
+@set THIS_DIR=%CD%
+@popd
+@goto :EOF

src/dragonxd.bat

@@ -0,0 +1,10 @@
+@call :GET_CURRENT_DIR
+@cd %THIS_DIR%
+hushd.exe -ac_name=DRAGONX -ac_algo=randomx -ac_halving=3500000 -ac_reward=300000000 -ac_blocktime=36 -ac_private=1 -addnode=176.126.87.241 %*
+@goto :EOF
+
+:GET_CURRENT_DIR
+@pushd %~dp0
+@set THIS_DIR=%CD%
+@popd
+@goto :EOF

src/httpserver.cpp

@@ -37,6 +37,7 @@
 
 #include <boost/algorithm/string/case_conv.hpp> // for to_lower()
 #include <boost/foreach.hpp>
+#include <deque>
 #include <boost/scoped_ptr.hpp>
 
 /** HTTP request work item */

src/hush_bitcoind.h

@@ -505,7 +505,7 @@ int32_t hush_verifynotarization(char *symbol,char *dest,int32_t height,int32_t N
     {
         if ( (json= cJSON_Parse(jsonstr)) != 0 )
         {
-            if ( (txjson= jobj(json,(char *)"result")) != 0 && (vouts= jarray(&n,txjson,(char *)"vout")) > 0 )
+            if ( (txjson= jobj(json,(char *)"result")) != 0 && (vouts= jarray(&n,txjson,(char *)"vout")) != 0 )
             {
                 vout = jitem(vouts,n-1);
                 if ( 0 && SMART_CHAIN_SYMBOL[0] != 0 )

src/hush_gateway.h

@@ -18,40 +18,9 @@
 // paxdeposit equivalent in reverse makes opreturn and HUSH does the same in reverse
 #include "hush_defs.h"
 
-/*#include "secp256k1/include/secp256k1.h"
-#include "secp256k1/include/secp256k1_schnorrsig.h"
-#include "secp256k1/include/secp256k1_musig.h"
-int32_t dummy_linker_tricker()
-{
-    secp256k1_context *ctx = 0; std::vector<uint8_t> musig64; CPubKey pk; secp256k1_schnorrsig musig; secp256k1_pubkey combined_pk;
-    if ( secp256k1_schnorrsig_parse((const secp256k1_context *)ctx,&musig,(const uint8_t *)&musig64[0]) > 0 && secp256k1_ec_pubkey_parse(ctx,&combined_pk,pk.begin(),33) > 0 )
-        return(1);
-}*/
 
 int32_t pax_fiatstatus(uint64_t *available,uint64_t *deposited,uint64_t *issued,uint64_t *withdrawn,uint64_t *approved,uint64_t *redeemed,char *base)
 {
-    int32_t baseid; struct hush_state *sp; int64_t netliability,maxallowed,maxval;
-    *available = *deposited = *issued = *withdrawn = *approved = *redeemed = 0;
-    if ( (baseid= hush_baseid(base)) >= 0 )
-    {
-        if ( (sp= hush_stateptrget(base)) != 0 )
-        {
-            *deposited = sp->deposited;
-            *issued = sp->issued;
-            *withdrawn = sp->withdrawn;
-            *approved = sp->approved;
-            *redeemed = sp->redeemed;
-            maxval = sp->approved;
-            if ( sp->withdrawn > maxval )
-                maxval = sp->withdrawn;
-            netliability = (sp->issued - maxval) - sp->shorted;
-            maxallowed = hush_maxallowed(baseid);
-            if ( netliability < maxallowed )
-                *available = (maxallowed - netliability);
-            //printf("%llu - %llu %s %.8f %.8f %.8f %.8f %.8f\n",(long long)maxallowed,(long long)netliability,base,dstr(*deposited),dstr(*issued),dstr(*withdrawn),dstr(*approved),dstr(*redeemed));
-            return(0);
-        } else printf("pax_fiatstatus cant get basesp.%s\n",base);
-    } // else printf("pax_fiatstatus illegal base.%s\n",base);
     return(-1);
 }
 
@@ -210,71 +179,7 @@ int32_t hush_rwapproval(int32_t rwflag,uint8_t *opretbuf,struct pax_transaction
 
 int32_t hush_issued_opreturn(char *base,uint256 *txids,uint16_t *vouts,int64_t *values,int64_t *srcvalues,int32_t *hushheights,int32_t *otherheights,int8_t *baseids,uint8_t *rmd160s,uint8_t *opretbuf,int32_t opretlen,int32_t iskomodo)
 {
-    struct pax_transaction p,*pax; int32_t i,n=0,j,len=0,incr,height,otherheight; uint8_t type,rmd160[20]; uint64_t fiatoshis; char symbol[HUSH_SMART_CHAIN_MAXLEN];
-    //if ( HUSH_PAX == 0 )
-    //    return(0);
-    incr = 34 + (iskomodo * (2*sizeof(fiatoshis) + 2*sizeof(height) + 20 + 4));
-    //41e77b91cb68dc2aa02fa88550eae6b6d44db676a7e935337b6d1392d9718f03cb0200305c90660400000000fbcbeb1f000000bde801006201000058e7945ad08ddba1eac9c9b6c8e1e97e8016a2d152
-
-    // 41e94d736ec69d88c08b5d238abeeca609c02357a8317e0d56c328bcb1c259be5d0200485bc80200000000404b4c000000000059470200b80b000061f22ba7d19fe29ac3baebd839af8b7127d1f9075553440046bb4cc7a3b5cd39dffe7206507a3482a00780e617f68b273cce9817ed69298d02001069ca1b0000000080f0fa02000000005b470200b90b000061f22ba7d19fe29ac3baebd839af8b7127d1f90755
-
-    //for (i=0; i<opretlen; i++)
-    //    printf("%02x",opretbuf[i]);
-    //printf(" opretlen.%d (%s)\n",opretlen,base);
-    //printf(" opretlen.%d vs %d incr.%d (%d)\n",opretlen,(int32_t)(2*sizeof(fiatoshis) + 2*sizeof(height) + 20 + 2),incr,opretlen/incr);
-    //if ( SMART_CHAIN_SYMBOL[0] == 0 || strncmp(SMART_CHAIN_SYMBOL,base,strlen(base)) == 0 )
-    {
-        type = opretbuf[0];
-        opretbuf++, opretlen--;
-        for (n=0; n<opretlen/incr; n++)
-        {
-            if ( iskomodo != 0 )
-            {
-                memset(&p,0,sizeof(p));
-                len += hush_rwapproval(0,&opretbuf[len],&p);
-                if ( values != 0 && srcvalues != 0 && hushheights != 0 && otherheights != 0 && baseids != 0 && rmd160s != 0 )
-                {
-                    txids[n] = p.txid;
-                    vouts[n] = p.vout;
-                    values[n] = (strcmp("HUSH3",base) == 0) ? p.puposhis : p.fiatoshis;
-                    srcvalues[n] = (strcmp("HUSH3",base) == 0) ? p.fiatoshis : p.puposhis;
-                    hushheights[n] = p.height;
-                    otherheights[n] = p.otherheight;
-                    memcpy(&rmd160s[n * 20],p.rmd160,20);
-                    baseids[n] = hush_baseid(p.source);
-                    if ( 0 )
-                    {
-                        char coinaddr[64];
-                        bitcoin_address(coinaddr,60,&rmd160s[n * 20],20);
-                        printf(">>>>>>> %s: (%s) fiat %.8f hushheight.%d other.%d -> %s %.8f\n",type=='A'?"approvedA":"issuedX",baseids[n]>=0?CURRENCIES[baseids[n]]:"???",dstr(p.fiatoshis),hushheights[n],otherheights[n],coinaddr,dstr(values[n]));
-                    }
-                }
-            }
-            else
-            {
-                for (i=0; i<4; i++)
-                    base[i] = opretbuf[opretlen-4+i];
-                for (j=0; j<32; j++)
-                {
-                    ((uint8_t *)&txids[n])[j] = opretbuf[len++];
-                    //printf("%02x",((uint8_t *)&txids[n])[j]);
-                }
-                vouts[n] = opretbuf[len++];
-                vouts[n] = (opretbuf[len++] << 8) | vouts[n];
-                baseids[n] = hush_baseid(base);
-                if ( (pax= hush_paxfinds(txids[n],vouts[n])) != 0 )
-                {
-                    values[n] = (strcmp("HUSH3",base) == 0) ? pax->puposhis : pax->fiatoshis;
-                    srcvalues[n] = (strcmp("HUSH3",base) == 0) ? pax->fiatoshis : pax->puposhis;
-                    hushheights[n] = pax->height;
-                    otherheights[n] = pax->otherheight;
-                    memcpy(&rmd160s[n * 20],pax->rmd160,20);
-                }
-            }
-            //printf(" hush_issued_opreturn issuedtxid v%d i.%d opretlen.%d\n",vouts[n],n,opretlen);
-        }
-    }
-    return(n);
+    return 0;
 }
 
 int32_t hush_paxcmp(char *symbol,int32_t hushheight,uint64_t value,uint64_t checkvalue,uint64_t seed)
@@ -624,38 +529,6 @@ int32_t hush_gateway_deposits(CMutableTransaction *txNew,char *base,int32_t toko
     return(0);
 }
 
-const char *banned_txids[] =
-{
-    "78cb4e21245c26b015b888b14c4f5096e18137d2741a6de9734d62b07014dfca", // vout1 only 233559
-    "00697be658e05561febdee1aafe368b821ca33fbb89b7027365e3d77b5dfede5", //234172
-    "e909465788b32047c472d73e882d79a92b0d550f90be008f76e1edaee6d742ea", //234187
-    "f56c6873748a327d0b92b8108f8ec8505a2843a541b1926022883678fb24f9dc", //234188
-    "abf08be07d8f5b3a433ddcca7ef539e79a3571632efd6d0294ec0492442a0204", //234213
-    "3b854b996cc982fba8c06e76cf507ae7eed52ab92663f4c0d7d10b3ed879c3b0", //234367
-    "fa9e474c2cda3cb4127881a40eb3f682feaba3f3328307d518589024a6032cc4", //234635
-    "ca746fa13e0113c4c0969937ea2c66de036d20274efad4ce114f6b699f1bc0f3", //234662
-    "43ce88438de4973f21b1388ffe66e68fda592da38c6ef939be10bb1b86387041", //234697
-    "0aeb748de82f209cd5ff7d3a06f65543904c4c17387c9d87c65fd44b14ad8f8c", //234899
-    "bbd3a3d9b14730991e1066bd7c626ca270acac4127131afe25f877a5a886eb25", //235252
-    "fa9943525f2e6c32cbc243294b08187e314d83a2870830180380c3c12a9fd33c", //235253
-    "a01671c8775328a41304e31a6693bbd35e9acbab28ab117f729eaba9cb769461", //235265
-    "2ef49d2d27946ad7c5d5e4ab5c089696762ff04e855f8ab48e83bdf0cc68726d", //235295
-    "c85dcffb16d5a45bd239021ad33443414d60224760f11d535ae2063e5709efee", //235296
-    // all vouts banned
-    "c4ea1462c207547cd6fb6a4155ca6d042b22170d29801a465db5c09fec55b19d", //246748
-    "305dc96d8bc23a69d3db955e03a6a87c1832673470c32fe25473a46cc473c7d1", //247204
-    //"43416a0c4da6b1a5c1d375bdbe8f7dc8d44d8f60df593d3376aa8221ec66357e", // vout0 only
-    //"1eb295ed54c47f35cbccd7e7e40d03041f1853581da6d41102a9d8813782b6cb",
-    //"db121e4012222adfc841824984a2a90b7e5b018dd71307822537d58160195e43",
-    //"28f95b8148ac4ae6e09c7380e34422fab41d568a411e53dc94823e36a3d6f386",
-    //"01d8c839463bda2f2f6400ede4611357913684927a767422a8560ead1b22557c",
-    //"6e4980a9e1bd669f4df04732dc6f11b7773b6de88d1abcf89a6b9007d72ef9ac",
-    //"6cc1d0495170bc0e11fd3925297623562e529ea1336b66ea61f8a1159041aed2",
-    //"250875424cece9bcd98cb226b09da7671625633d6958589e3a462bad89ad87cc", // missed
-    //"ea8659011de52f4dac42cda12326064b7b5013b8492f88e33159884ca299aa05", // missed
-    //"ce567928b5490a17244167af161b1d8dd6ff753fef222fe6855d95b2278a35b3", // missed
-};
-
 int32_t hush_checkvout(int32_t vout,int32_t k,int32_t indallvouts)
 {
     if ( k < indallvouts )
@@ -665,169 +538,8 @@ int32_t hush_checkvout(int32_t vout,int32_t k,int32_t indallvouts)
     else return(vout == 0);
 }
 
-int32_t hush_bannedset(int32_t *indallvoutsp,uint256 *array,int32_t max)
-{
-    int32_t i;
-    if ( sizeof(banned_txids)/sizeof(*banned_txids) > max )
-    {
-        fprintf(stderr,"hush_bannedset: buffer too small %d vs %d\n",(int32_t)(sizeof(banned_txids)/sizeof(*banned_txids)),max);
-        StartShutdown();
-    }
-    for (i=0; i<sizeof(banned_txids)/sizeof(*banned_txids); i++)
-        array[i] = uint256S(banned_txids[i]);
-    *indallvoutsp = i-2;
-    return(i);
-}
-
 void hush_passport_iteration();
 
-int32_t hush_check_deposit(int32_t height,const CBlock& block,uint32_t prevtime) // verify above block is valid pax pricing
-{
-    static uint256 array[64]; static int32_t numbanned,indallvouts;
-    int32_t i,j,k,n,ht,baseid,txn_count,activation,num,opretlen,offset=1,errs=0,notmatched=0,matched=0,hushheights[256],otherheights[256]; uint256 hash,txids[256]; char symbol[HUSH_SMART_CHAIN_MAXLEN],base[HUSH_SMART_CHAIN_MAXLEN]; uint16_t vouts[256]; int8_t baseids[256]; uint8_t *script,opcode,rmd160s[256*20]; uint64_t total,subsidy,available,deposited,issued,withdrawn,approved,redeemed,seed; int64_t checktoshis,values[256],srcvalues[256]; struct pax_transaction *pax; struct hush_state *sp; CTransaction tx;
-    activation = 235300;
-    if ( *(int32_t *)&array[0] == 0 )
-        numbanned = hush_bannedset(&indallvouts,array,(int32_t)(sizeof(array)/sizeof(*array)));
-    memset(baseids,0xff,sizeof(baseids));
-    memset(values,0,sizeof(values));
-    memset(srcvalues,0,sizeof(srcvalues));
-    memset(rmd160s,0,sizeof(rmd160s));
-    memset(hushheights,0,sizeof(hushheights));
-    memset(otherheights,0,sizeof(otherheights));
-    txn_count = block.vtx.size();
-    if ( SMART_CHAIN_SYMBOL[0] == 0 )
-    {
-        for (i=0; i<txn_count; i++)
-        {
-            if ( i == 0 && txn_count > 1 && block.vtx[txn_count-1].vout.size() > 0 && block.vtx[txn_count-1].vout[0].nValue == 5000 )
-            {
-                /*
-                if ( block.vtx[txn_count-1].vin.size() == 1 && GetTransaction(block.vtx[txn_count-1].vin[0].prevout.hash,tx,hash,false) && block.vtx[0].vout[0].scriptPubKey == tx.vout[block.vtx[txn_count-1].vin[0].prevout.n].scriptPubKey )
-                    notmatched = 1;
-                */
-                if ( block.vtx[txn_count-1].vin.size() == 1 ) {
-                    uint256 hashNotaryProofVin = block.vtx[txn_count-1].vin[0].prevout.hash;
-                    int fNotaryProofVinTxFound = GetTransaction(hashNotaryProofVin,tx,hash,false);
-                    if (!fNotaryProofVinTxFound) {
-                        // try to search in the same block
-                        BOOST_FOREACH(const CTransaction &txInThisBlock, block.vtx) {
-                            if (txInThisBlock.GetHash() == hashNotaryProofVin) {
-                                fNotaryProofVinTxFound = 1;
-                                tx = txInThisBlock;
-                                hash = block.GetHash();
-                                break;
-                            }
-                        }
-                    }
-                    if ( fNotaryProofVinTxFound && block.vtx[0].vout[0].scriptPubKey == tx.vout[block.vtx[txn_count-1].vin[0].prevout.n].scriptPubKey )
-                        {
-                            notmatched = 1;
-                        }
-                }  
-            }
-            n = block.vtx[i].vin.size();
-            for (j=0; j<n; j++)
-            {
-                for (k=0; k<numbanned; k++)
-                {
-                    if ( block.vtx[i].vin[j].prevout.hash == array[k] && hush_checkvout(block.vtx[i].vin[j].prevout.n,k,indallvouts) != 0 ) //(block.vtx[i].vin[j].prevout.n == 1 || k >= indallvouts)  )
-                    {
-                        printf("banned tx.%d being used at ht.%d txi.%d vini.%d\n",k,height,i,j);
-                        return(-1);
-                    }
-                }
-            }
-        }
-    }
-    if ( SMART_CHAIN_SYMBOL[0] == 0 ||
-         ((ASSETCHAINS_COMMISSION != 0 || ASSETCHAINS_FOUNDERS_REWARD) && height > 1) ||
-         NetworkUpgradeActive(height, Params().GetConsensus(), Consensus::UPGRADE_SAPLING) )
-    {
-        n = block.vtx[0].vout.size();
-        int64_t val,prevtotal = 0; int32_t strangeout=0,overflow = 0;
-        total = 0;
-        for (i=1; i<n; i++)
-        {
-            script = (uint8_t *)&block.vtx[0].vout[i].scriptPubKey[0];
-            if ( (val= block.vtx[0].vout[i].nValue) < 0 || val >= MAX_MONEY )
-            {
-                overflow = 1;
-                break;
-            }
-            if ( i > 1 && script[0] != 0x6a && val < 5000 )
-                strangeout++;
-            total += val;
-            if ( total < prevtotal || (val != 0 && total == prevtotal) )
-            {
-                overflow = 1;
-                break;
-            }
-            prevtotal = total;
-        }
-        if ( SMART_CHAIN_SYMBOL[0] == 0 )
-        {
-            if ( overflow != 0 || total > COIN/10 )
-            {
-                if ( height >= activation )
-                {
-                    if ( height > 800000 )
-                        fprintf(stderr,">>>>>>>> <<<<<<<<<< ht.%d illegal nonz output %.8f n.%d\n",height,dstr(block.vtx[0].vout[1].nValue),n);
-                    return(-1);
-                }
-            }
-            else if ( block.nBits == HUSH_MINDIFF_NBITS && total > 0 ) // to deal with fee stealing
-            {
-                fprintf(stderr,"notary mined ht.%d with extra %.8f\n",height,dstr(total));
-                if ( height > HUSH_NOTARIES_HEIGHT1 )
-                    return(-1);
-            }
-            if ( strangeout != 0 || notmatched != 0 )
-            {
-                if ( 0 && strcmp(NOTARY_PUBKEY.c_str(),"03b7621b44118017a16043f19b30cc8a4cfe068ac4e42417bae16ba460c80f3828") == 0 )
-                    fprintf(stderr,">>>>>>>>>>>>> DUST ht.%d strangout.%d notmatched.%d <<<<<<<<<\n",height,strangeout,notmatched);
-                if ( height > 1000000 && strangeout != 0 )
-                    return(-1);
-            }
-            else if ( height > 814000 )
-            {
-                script = (uint8_t *)&block.vtx[0].vout[0].scriptPubKey[0];
-                //int32_t notary = hush_electednotary(&num,script+1,height,0);
-                //if ( (-1 * (hush_electednotary(&num,script+1,height,0) >= 0) * (height > 1000000)) < 0 )
-                //    fprintf(stderr, ">>>>>>> FAILED BLOCK.%d notary.%d insync.%d\n",height,notary,HUSH_INSYNC);
-                //else
-                //    fprintf(stderr, "<<<<<<< VALID BLOCK.%d notary.%d insync.%d\n",height,notary,HUSH_INSYNC);
-                return(-1 * (hush_electednotary(&num,script+1,height,0) >= 0) * (height > 1000000));
-            }
-        }
-        else
-        {
-            checktoshis = 0;
-            if ( (ASSETCHAINS_COMMISSION != 0 || ASSETCHAINS_FOUNDERS_REWARD) && height > 1 )
-            {
-                if ( (checktoshis= hush_checkcommission((CBlock *)&block,height)) < 0 )
-                {
-                    fprintf(stderr,"ht.%d checktoshis %.8f overflow.%d total %.8f strangeout.%d\n",height,dstr(checktoshis),overflow,dstr(total),strangeout);
-                    return(-1);
-                }
-            }
-            if ( height > 1 && checktoshis == 0 )
-            {
-                checktoshis = ((uint64_t)GetBlockSubsidy(height, Params().GetConsensus()) - block.vtx[0].vout[0].nValue);
-                // some pools will need to change their pool fee to be (poolfee % - txfees)
-                //checktoshis += txn_count * 0.001; // rely on higher level validations to prevent emitting more coins than actual txfees
-            }
-            if ( height >= 2 && (overflow != 0 || total > checktoshis || strangeout != 0) )
-            {
-                fprintf(stderr,"checkdeposit: ht.%d checktoshis %.8f overflow.%d total %.8f strangeout.%d\n",height,dstr(checktoshis),overflow,dstr(total),strangeout);
-                if ( strangeout != 0 )
-                    fprintf(stderr,">>>>>>>>>>>>> %s DUST ht.%d strangeout.%d notmatched.%d <<<<<<<<<\n",SMART_CHAIN_SYMBOL,height,strangeout,notmatched);
-                return(-1);
-            }
-        }
-    }
-    return(0);
-}
-
 const char *hush_opreturn(int32_t height,uint64_t value,uint8_t *opretbuf,int32_t opretlen,uint256 txid,uint16_t vout,char *source)
 {
     uint8_t rmd160[20],rmd160s[64*20],addrtype,shortflag,pubkey33[33]; int32_t didstats,i,j,n,kvheight,len,tokomodo,hushheight,otherheights[64],hushheights[64]; int8_t baseids[64]; char base[4],coinaddr[64],destaddr[64]; uint256 txids[64]; uint16_t vouts[64]; uint64_t convtoshis,seed; int64_t fee,fiatoshis,puposhis,checktoshis,values[64],srcvalues[64]; struct pax_transaction *pax,*pax2; struct hush_state *basesp; double diff;

src/hush_globals.h

@@ -29,8 +29,6 @@ int32_t hush_chosennotary(int32_t *notaryidp,int32_t height,uint8_t *pubkey33,ui
 int32_t hush_isrealtime(int32_t *hushheightp);
 uint64_t hush_paxtotal();
 int32_t hush_longestchain();
-uint64_t hush_maxallowed(int32_t baseid);
-int32_t hush_bannedset(int32_t *indallvoutsp,uint256 *array,int32_t max);
 int32_t hush_checkvout(int32_t vout,int32_t k,int32_t indallvouts);
 pthread_mutex_t hush_mutex;
 

src/hush_nSPV_superlite.h

@@ -1,5 +1,4 @@
 // Copyright (c) 2016-2023 The Hush developers
-
 /******************************************************************************
  * Copyright © 2014-2019 The SuperNET Developers.                             *
  *                                                                            *
@@ -392,8 +391,6 @@ UniValue NSPV_utxoresp_json(struct NSPV_utxoresp *utxos,int32_t numutxos)
         item.push_back(Pair("txid",utxos[i].txid.GetHex()));
         item.push_back(Pair("vout",(int64_t)utxos[i].vout));
         item.push_back(Pair("value",(double)utxos[i].satoshis/COIN));
-        if ( SMART_CHAIN_SYMBOL[0] == 0 )
-            item.push_back(Pair("interest",(double)utxos[i].extradata/COIN));
         array.push_back(item);
     }
     return(array);
@@ -409,8 +406,6 @@ UniValue NSPV_utxosresp_json(struct NSPV_utxosresp *ptr)
     result.push_back(Pair("height",(int64_t)ptr->nodeheight));
     result.push_back(Pair("numutxos",(int64_t)ptr->numutxos));
     result.push_back(Pair("balance",(double)ptr->total/COIN));
-    if ( SMART_CHAIN_SYMBOL[0] == 0 )
-        result.push_back(Pair("interest",(double)ptr->interest/COIN));
     result.push_back(Pair("filter",(int64_t)ptr->filter));
     result.push_back(Pair("lastpeer",NSPV_lastpeer));
     return(result);

src/hush_nSPV_wallet.h

@@ -383,12 +383,7 @@ UniValue NSPV_spend(char *srcaddr,char *destaddr,int64_t satoshis) // what its a
     mtx.nExpiryHeight = 0;
     mtx.nVersionGroupId = SAPLING_VERSION_GROUP_ID;
     mtx.nVersion = SAPLING_TX_VERSION;
-    if ( SMART_CHAIN_SYMBOL[0] == 0 ) {
-        if ( !hush_hardfork_active((uint32_t)chainActive.LastTip()->nTime) )
-            mtx.nLockTime = (uint32_t)time(NULL) - 777;
-        else
-            mtx.nLockTime = (uint32_t)chainActive.Tip()->GetMedianTimePast();
-    }
+    mtx.nLockTime = (uint32_t)chainActive.Tip()->GetMedianTimePast();
         
     memset(used,0,sizeof(used));
 
@@ -402,14 +397,6 @@ UniValue NSPV_spend(char *srcaddr,char *destaddr,int64_t satoshis) // what its a
             return(result);
         }
         hex = NSPV_signtx(rewardsum,interestsum,retcodes,mtx,txfee,opret,used);
-        if ( SMART_CHAIN_SYMBOL[0] == 0 )
-        {
-            char numstr[64];
-            sprintf(numstr,"%.8f",(double)interestsum/COIN);
-            result.push_back(Pair("rewards",numstr));
-            sprintf(numstr,"%.8f",(double)rewardsum/COIN);
-            result.push_back(Pair("validated",numstr));
-        }
         if ( hex.size() > 0 )
         {
             if ( DecodeHexTx(tx,hex) != 0 )

src/hush_pax.h

@@ -18,213 +18,13 @@
 
 #include "hush_defs.h"
 
-#define USD 0
-#define EUR 1
-#define JPY 2
-#define GBP 3
-#define AUD 4
-#define CAD 5
-#define CHF 6
-#define NZD 7
-
-#define CNY 8
-#define RUB 9
-#define MXN 10
-#define BRL 11
-#define INR 12
-#define HKD 13
-#define TRY 14
-#define ZAR 15
-
-#define PLN 16
-#define NOK 17
-#define SEK 18
-#define DKK 19
-#define CZK 20
-#define HUF 21
-#define ILS 22
-#define KRW 23
-
-#define MYR 24
-#define PHP 25
-#define RON 26
-#define SGD 27
-#define THB 28
-#define BGN 29
-#define IDR 30
-#define HRK 31
-
-#define MAX_CURRENCIES 32
-extern char CURRENCIES[][8];
-
-uint64_t M1SUPPLY[] = { 3317900000000, 6991604000000, 667780000000000, 1616854000000, 331000000000, 861909000000, 584629000000, 46530000000, // major currencies
-    45434000000000, 16827000000000, 3473357229000, 306435000000, 27139000000000, 2150641000000, 347724099000, 1469583000000, 749543000000, 1826110000000, 2400434000000, 1123925000000, 3125276000000, 13975000000000, 317657000000, 759706000000000, 354902000000, 2797061000000, 162189000000, 163745000000, 1712000000000, 39093000000, 1135490000000000, 80317000000,
-    100000000 };
-
-#define MIND 1000
-uint32_t MINDENOMS[] = { MIND, MIND, 100*MIND, MIND, MIND, MIND, MIND, MIND, // major currencies
-    10*MIND, 100*MIND, 10*MIND, MIND, 100*MIND, 10*MIND, MIND, 10*MIND, MIND, 10*MIND, 10*MIND, 10*MIND, 10*MIND, 100*MIND, MIND, 1000*MIND, MIND, 10*MIND, MIND, MIND, 10*MIND, MIND, 10000*MIND, 10*MIND, // end of currencies
-10*MIND,
-};
-
-int32_t Peggy_inds[539] = {289, 404, 50, 490, 59, 208, 87, 508, 366, 288, 13, 38, 159, 440, 120, 480, 361, 104, 534, 195, 300, 362, 489, 108, 143, 220, 131, 244, 133, 473, 315, 439, 210, 456, 219, 352, 153, 444, 397, 491, 286, 479, 519, 384, 126, 369, 155, 427, 373, 360, 135, 297, 256, 506, 322, 425, 501, 251, 75, 18, 420, 537, 443, 438, 407, 145, 173, 78, 340, 240, 422, 160, 329, 32, 127, 128, 415, 495, 372, 522, 60, 238, 129, 364, 471, 140, 171, 215, 378, 292, 432, 526, 252, 389, 459, 350, 233, 408, 433, 51, 423, 19, 62, 115, 211, 22, 247, 197, 530, 7, 492, 5, 53, 318, 313, 283, 169, 464, 224, 282, 514, 385, 228, 175, 494, 237, 446, 105, 150, 338, 346, 510, 6, 348, 89, 63, 536, 442, 414, 209, 216, 227, 380, 72, 319, 259, 305, 334, 236, 103, 400, 176, 267, 355, 429, 134, 257, 527, 111, 287, 386, 15, 392, 535, 405, 23, 447, 399, 291, 112, 74, 36, 435, 434, 330, 520, 335, 201, 478, 17, 162, 483, 33, 130, 436, 395, 93, 298, 498, 511, 66, 487, 218, 65, 309, 419, 48, 214, 377, 409, 462, 139, 349, 4, 513, 497, 394, 170, 307, 241, 185, 454, 29, 367, 465, 194, 398, 301, 229, 212, 477, 303, 39, 524, 451, 116, 532, 30, 344, 85, 186, 202, 517, 531, 515, 230, 331, 466, 147, 426, 234, 304, 64, 100, 416, 336, 199, 383, 200, 166, 258, 95, 188, 246, 136, 90, 68, 45, 312, 354, 184, 314, 518, 326, 401, 269, 217, 512, 81, 88, 272, 14, 413, 328, 393, 198, 226, 381, 161, 474, 353, 337, 294, 295, 302, 505, 137, 207, 249, 46, 98, 27, 458, 482, 262, 253, 71, 25, 0, 40, 525, 122, 341, 107, 80, 165, 243, 168, 250, 375, 151, 503, 124, 52, 343, 371, 206, 178, 528, 232, 424, 163, 273, 191, 149, 493, 177, 144, 193, 388, 1, 412, 265, 457, 255, 475, 223, 41, 430, 76, 102, 132, 96, 97, 316, 472, 213, 263, 3, 317, 324, 274, 396, 486, 254, 205, 285, 101, 21, 279, 58, 467, 271, 92, 538, 516, 235, 332, 117, 500, 529, 113, 445, 390, 358, 79, 34, 488, 245, 83, 509, 203, 476, 496, 347, 280, 12, 84, 485, 323, 452, 10, 146, 391, 293, 86, 94, 523, 299, 91, 164, 363, 402, 110, 321, 181, 138, 192, 469, 351, 276, 308, 277, 428, 182, 260, 55, 152, 157, 382, 121, 507, 225, 61, 431, 31, 106, 327, 154, 16, 49, 499, 73, 70, 449, 460, 187, 24, 248, 311, 275, 158, 387, 125, 67, 284, 35, 463, 190, 179, 266, 376, 221, 42, 26, 290, 357, 268, 43, 167, 99, 374, 242, 156, 239, 403, 339, 183, 320, 180, 306, 379, 441, 20, 481, 141, 77, 484, 69, 410, 502, 172, 417, 118, 461, 261, 47, 333, 450, 296, 453, 368, 359, 437, 421, 264, 504, 281, 270, 114, 278, 56, 406, 448, 411, 521, 418, 470, 123, 455, 148, 356, 468, 109, 204, 533, 365, 8, 345, 174, 370, 28, 57, 11, 2, 231, 310, 196, 119, 82, 325, 44, 342, 37, 189, 142, 222, 9, 54, };
-
-uint64_t peggy_smooth_coeffs[sizeof(Peggy_inds)/sizeof(*Peggy_inds)] =	// numprimes.13
-{
-    962714545, 962506087, 962158759, 961672710, 961048151, 960285354, 959384649, 958346426, 957171134, // x.8
-    955859283, 954411438, 952828225, 951110328, 949258485, 947273493, 945156207, 942907532, 940528434, // x.17
-    938019929, 935383089, 932619036, 929728945, 926714044, 923575608, 920314964, 916933485, 913432593, // x.26
-    909813756, 906078486, 902228342, 898264923, 894189872, 890004874, 885711650, 881311964, 876807614, // x.35
-    872200436, 867492300, 862685110, 857780804, 852781347, 847688737, 842505000, 837232189, 831872382, // x.44
-    826427681, 820900212, 815292123, 809605581, 803842772, 798005901, 792097186, 786118864, 780073180, // x.53
-    773962395, 767788778, 761554609, 755262175, 748913768, 742511686, 736058231, 729555707, 723006417, // x.62
-    716412665, 709776755, 703100984, 696387648, 689639036, 682857428, 676045100, 669204315, 662337327, // x.71
-    655446378, 648533696, 641601496, 634651978, 627687325, 620709702, 613721256, 606724115, 599720386, // x.80
-    592712154, 585701482, 578690411, 571680955, 564675105, 557674825, 550682053, 543698699, 536726645, // x.89
-    529767743, 522823816, 515896658, 508988029, 502099660, 495233249, 488390461, 481572928, 474782249, // x.98
-    468019988, 461287675, 454586804, 447918836, 441285195, 434687268, 428126409, 421603932, 415121117, // x.107
-    408679208, 402279408, 395922888, 389610779, 383344175, 377124134, 370951677, 364827785, 358753406, // x.116
-    352729449, 346756785, 340836251, 334968645, 329154729, 323395230, 317690838, 312042206, 306449955, // x.125
-    300914667, 295436891, 290017141, 284655897, 279353604, 274110676, 268927490, 263804394, 258741701, // x.134
-    253739694, 248798623, 243918709, 239100140, 234343077, 229647649, 225013957, 220442073, 215932043, // x.143
-    211483883, 207097585, 202773112, 198510404, 194309373, 190169909, 186091877, 182075118, 178119452, // x.152
-    174224676, 170390565, 166616873, 162903335, 159249664, 155655556, 152120688, 148644718, 145227287, // x.161
-    141868021, 138566528, 135322401, 132135218, 129004542, 125929924, 122910901, 119946997, 117037723, // x.170
-    114182582, 111381062, 108632643, 105936795, 103292978, 100700645, 98159238, 95668194, 93226942, // x.179
-    90834903, 88491495, 86196126, 83948203, 81747126, 79592292, 77483092, 75418916, 73399150, // x.188
-    71423178, 69490383, 67600142, 65751837, 63944844, 62178541, 60452305, 58765515, 57117547, // x.197
-    55507781, 53935597, 52400377, 50901505, 49438366, 48010349, 46616844, 45257246, 43930951, // x.206
-    42637360, 41375878, 40145912, 38946876, 37778185, 36639262, 35529533, 34448428, 33395384, // x.215
-    32369842, 31371249, 30399057, 29452725, 28531717, 27635503, 26763558, 25915365, 25090413, // x.224
-    24288196, 23508216, 22749980, 22013003, 21296806, 20600917, 19924870, 19268206, 18630475, // x.233
-    18011231, 17410035, 16826458, 16260073, 15710466, 15177224, 14659944, 14158231, 13671694, // x.242
-    13199950, 12742625, 12299348, 11869759, 11453500, 11050225, 10659590, 10281262, 9914910, // x.251
-    9560213, 9216856, 8884529, 8562931, 8251764, 7950739, 7659571, 7377984, 7105706, // x.260
-    6842471, 6588020, 6342099, 6104460, 5874861, 5653066, 5438844, 5231969, 5032221, // x.269
-    4839386, 4653254, 4473620, 4300287, 4133059, 3971747, 3816167, 3666139, 3521488, // x.278
-    3382043, 3247640, 3118115, 2993313, 2873079, 2757266, 2645728, 2538325, 2434919, // x.287
-    2335380, 2239575, 2147382, 2058677, 1973342, 1891262, 1812325, 1736424, 1663453, // x.296
-    1593311, 1525898, 1461118, 1398879, 1339091, 1281666, 1226519, 1173569, 1122736, // x.305
-    1073944, 1027117, 982185, 939076, 897725, 858065, 820033, 783568, 748612, // x.314
-    715108, 682999, 652233, 622759, 594527, 567488, 541597, 516808, 493079, // x.323
-    470368, 448635, 427841, 407948, 388921, 370725, 353326, 336692, 320792, // x.332
-    305596, 291075, 277202, 263950, 251292, 239204, 227663, 216646, 206130, // x.341
-    196094, 186517, 177381, 168667, 160356, 152430, 144874, 137671, 130806, // x.350
-    124264, 118031, 112093, 106437, 101050, 95921, 91039, 86391, 81968, // x.359
-    77759, 73755, 69945, 66322, 62877, 59602, 56488, 53528, 50716, // x.368
-    48043, 45505, 43093, 40803, 38629, 36564, 34604, 32745, 30980, // x.377
-    29305, 27717, 26211, 24782, 23428, 22144, 20927, 19774, 18681, // x.386
-    17646, 16665, 15737, 14857, 14025, 13237, 12491, 11786, 11118, // x.395
-    10487, 9890, 9325, 8791, 8287, 7810, 7359, 6933, 6531, // x.404
-    6151, 5792, 5453, 5133, 4831, 4547, 4278, 4024, 3785, // x.413
-    3560, 3347, 3147, 2958, 2779, 2612, 2454, 2305, 2164, // x.422
-    2032, 1908, 1791, 1681, 1577, 1480, 1388, 1302, 1221, // x.431
-    1145, 1073, 1006, 942, 883, 827, 775, 725, 679, // x.440
-    636, 595, 557, 521, 487, 456, 426, 399, 373, // x.449
-    348, 325, 304, 284, 265, 248, 231, 216, 202, // x.458
-    188, 175, 164, 153, 142, 133, 124, 115, 107, // x.467
-    100, 93, 87, 81, 75, 70, 65, 61, 56, // x.476
-    53, 49, 45, 42, 39, 36, 34, 31, 29, // x.485
-    27, 25, 23, 22, 20, 19, 17, 16, 15, // x.494
-    14, 13, 12, 11, 10, 9, 9, 8, 7, // x.503
-    7, 6, 6, 5, 5, 5, 4, 4, 4, // x.512
-    3, 3, 3, 3, 2, 2, 2, 2, 2, // x.521
-    2, 2, 1, 1, 1, 1, 1, 1, 1, // x.530
-    1, 1, 1, 1, 1, 1, 0, 0, // isum 100000000000
-};
-
-uint64_t hush_maxallowed(int32_t baseid)
-{
-    uint64_t mult,val = COIN * (uint64_t)10000;
-    if ( baseid < 0 || baseid >= 32 )
-        return(0);
-    if ( baseid < 10 )
-        val *= 4;
-    mult = MINDENOMS[baseid] / MIND;
-    return(mult * val);
-}
-
-uint64_t hush_paxvol(uint64_t volume,uint64_t price)
-{
-    if ( volume < 10000000000 )
-        return((volume * price) / 1000000000);
-    else if ( volume < (uint64_t)10 * 10000000000 )
-        return((volume * (price / 10)) / 100000000);
-    else if ( volume < (uint64_t)100 * 10000000000 )
-        return(((volume / 10) * (price / 10)) / 10000000);
-    else if ( volume < (uint64_t)1000 * 10000000000 )
-        return(((volume / 10) * (price / 100)) / 1000000);
-    else if ( volume < (uint64_t)10000 * 10000000000 )
-        return(((volume / 100) * (price / 100)) / 100000);
-    else if ( volume < (uint64_t)100000 * 10000000000 )
-        return(((volume / 100) * (price / 1000)) / 10000);
-    else if ( volume < (uint64_t)1000000 * 10000000000 )
-        return(((volume / 1000) * (price / 1000)) / 1000);
-    else if ( volume < (uint64_t)10000000 * 10000000000 )
-        return(((volume / 1000) * (price / 10000)) / 100);
-    else return(((volume / 10000) * (price / 10000)) / 10);
-}
-
-void pax_rank(uint64_t *ranked,uint32_t *pvals)
-{
-    int32_t i; uint64_t vals[32],sum = 0;
-    for (i=0; i<32; i++)
-    {
-        vals[i] = hush_paxvol(M1SUPPLY[i] / MINDENOMS[i],pvals[i]);
-        sum += vals[i];
-    }
-    for (i=0; i<32; i++)
-    {
-        ranked[i] = (vals[i] * 1000000000) / sum;
-        //printf("%.6f ",(double)ranked[i]/1000000000.);
-    }
-    //printf("sum %llu\n",(long long)sum);
-};
-
-#define BTCFACTOR_HEIGHT 466266
-
-double PAX_BTCUSD(int32_t height,uint32_t btcusd)
-{
-    double btcfactor,BTCUSD;
-    if ( height >= BTCFACTOR_HEIGHT )
-        btcfactor = 100000.;
-    else btcfactor = 1000.;
-    BTCUSD = ((double)btcusd / (1000000000. / btcfactor));
-    if ( height >= BTCFACTOR_HEIGHT && height < 500000 && BTCUSD > 20000 && btcfactor == 100000. )
-        BTCUSD /= 100;
-    return(BTCUSD);
-}
-
 int32_t PAX_pubkey(int32_t rwflag,uint8_t *pubkey33,uint8_t *addrtypep,uint8_t rmd160[20],char fiat[4],uint8_t *shortflagp,int64_t *fiatoshisp)
 {
-    if ( rwflag != 0 )
-    {
-        memset(pubkey33,0,33);
-        pubkey33[0] = 0x02 | (*shortflagp != 0);
-        memcpy(&pubkey33[1],fiat,3);
-        dragon_rwnum(rwflag,&pubkey33[4],sizeof(*fiatoshisp),(void *)fiatoshisp);
-        pubkey33[12] = *addrtypep;
-        memcpy(&pubkey33[13],rmd160,20);
-    }
-    else
-    {
-        *shortflagp = (pubkey33[0] == 0x03);
-        memcpy(fiat,&pubkey33[1],3);
-        fiat[3] = 0;
-        dragon_rwnum(rwflag,&pubkey33[4],sizeof(*fiatoshisp),(void *)fiatoshisp);
-        if ( *shortflagp != 0 )
-            *fiatoshisp = -(*fiatoshisp);
-        *addrtypep = pubkey33[12];
-        memcpy(rmd160,&pubkey33[13],20);
-    }
     return(33);
 }
 
 double PAX_val(uint32_t pval,int32_t baseid)
 {
-    //printf("PAX_val baseid.%d pval.%u\n",baseid,pval);
-    if ( baseid >= 0 && baseid < MAX_CURRENCIES )
-        return(((double)pval / 1000000000.) / MINDENOMS[baseid]);
     return(0.);
 }
 
@@ -232,68 +32,6 @@ void hush_pvals(int32_t height,uint32_t *pvals,uint8_t numpvals)
 {
 }
 
-uint64_t hush_paxcorrelation(uint64_t *votes,int32_t numvotes,uint64_t seed)
-{
-    int32_t i,j,k,ind,zeroes,wt,nonz; int64_t delta; uint64_t lastprice,tolerance,den,densum,sum=0;
-    for (sum=i=zeroes=nonz=0; i<numvotes; i++)
-    {
-        if ( votes[i] == 0 )
-            zeroes++;
-        else sum += votes[i], nonz++;
-    }
-    if ( nonz < (numvotes >> 2) )
-        return(0);
-    sum /= nonz;
-    lastprice = sum;
-    for (i=0; i<numvotes; i++)
-    {
-        if ( votes[i] == 0 )
-            votes[i] = lastprice;
-        else lastprice = votes[i];
-    }
-    tolerance = sum / 50;
-    for (k=0; k<numvotes; k++)
-    {
-        ind = Peggy_inds[(k + seed) % numvotes];
-        i = (int32_t)(ind % numvotes);
-        wt = 0;
-        if ( votes[i] != 0 )
-        {
-            for (j=0; j<numvotes; j++)
-            {
-                if ( votes[j] != 0 )
-                {
-                    if ( (delta= (votes[i] - votes[j])) < 0 )
-                        delta = -delta;
-                        if ( delta <= tolerance )
-                        {
-                            wt++;
-                            if ( wt > (numvotes >> 1) )
-                                break;
-                        }
-                }
-            }
-        }
-        if ( wt > (numvotes >> 1) )
-        {
-            ind = i;
-            for (densum=sum=j=0; j<numvotes; j++)
-            {
-                den = peggy_smooth_coeffs[j];
-                densum += den;
-                sum += (den * votes[(ind + j) % numvotes]);
-                //printf("(%llu/%llu %.8f) ",(long long)sum,(long long)densum,(double)sum/densum);
-            }
-            if ( densum != 0 )
-                sum /= densum;
-            //sum = (sum * basevolume);
-            //printf("paxprice seed.%llx sum %.8f densum %.8f\n",(long long)seed,dstr(sum),dstr(densum));
-            break;
-        }
-    }
-    return(sum);
-}
-
 uint64_t hush_paxpriceB(uint64_t seed,int32_t height,char *base,char *rel,uint64_t basevolume)
 {
     return 0;

src/hush_utils.h

@@ -2335,7 +2335,6 @@ void hush_args(char *argv0)
 
         if ( (baseid = hush_baseid(SMART_CHAIN_SYMBOL)) >= 0 && baseid < 32 )
         {
-            //hush_maxallowed(baseid);
             if(fDebug) 
                 printf("baseid.%d MAX_MONEY.%s %.8f\n",baseid,SMART_CHAIN_SYMBOL,(double)MAX_MONEY/SATOSHIDEN);
         }
@@ -2460,8 +2459,6 @@ void hush_args(char *argv0)
         }
     } else BITCOIND_RPCPORT = GetArg("-rpcport", BaseParams().RPCPort());
     HUSH_DPOWCONFS = GetArg("-dpowconfs",dpowconfs);
-    if ( strcmp(SMART_CHAIN_SYMBOL,"CA333LIES") == 0 )
-        HUSH_EXTRASATOSHI = 1;
 }
 
 void hush_nameset(char *symbol,char *dest,char *source)
@@ -2478,11 +2475,13 @@ void hush_nameset(char *symbol,char *dest,char *source)
 struct hush_state *hush_stateptrget(char *base)
 {
     int32_t baseid;
-    if ( base == 0 || base[0] == 0 || strcmp(base,(char *)"KYCSELLOUTS") == 0 )
+    if ( base == 0 || base[0] == 0 ) {
         return(&HUSH_STATES[33]);
-    else if ( (baseid= hush_baseid(base)) >= 0 )
+    } else if ( (baseid= hush_baseid(base)) >= 0 ) {
         return(&HUSH_STATES[baseid+1]);
-    else return(&HUSH_STATES[0]);
+    } else {
+        return(&HUSH_STATES[0]);
+    }
 }
 
 struct hush_state *hush_stateptr(char *symbol,char *dest)

src/init.cpp

@@ -809,9 +809,7 @@ bool files_exist(boost::filesystem::path file1, boost::filesystem::path file2) {
     return boost::filesystem::exists(file1) && boost::filesystem::exists(file2);
 }
 
-static void ZC_LoadParams(
-    const CChainParams& chainparams
-)
+static void ZC_LoadParams(const CChainParams& chainparams)
 {
     namespace fs = boost::filesystem;
     struct timeval tv_start, tv_end;
@@ -841,18 +839,18 @@ static void ZC_LoadParams(
        if (files_exist(sapling_spend, sapling_output)) {
             LogPrintf("Found sapling params in /usr/share/hush\n");
             found=true;
-                    }
-                }
+        }
+    }
 
-    if (!found) {
+	if (!found) {
         // Try ..
         sapling_spend  = boost::filesystem::path("..") / "sapling-spend.params";
         sapling_output = boost::filesystem::path("..") / "sapling-output.params";
         if (files_exist(sapling_spend, sapling_output)) {
             LogPrintf("Found sapling params in ..\n");
             found = true;
-                }
         }
+    }
 
     if (!found) {
         // This will catch the case of any external software (i.e. GUI wallets) needing params and installed in same dir as hush3.git
@@ -861,7 +859,7 @@ static void ZC_LoadParams(
         if (files_exist(sapling_spend, sapling_output)) {
             LogPrintf("Found sapling params in ../hush3\n");
             found = true;
-    }
+    	}
     }
 
     if (!found) {
@@ -871,17 +869,37 @@ static void ZC_LoadParams(
         if (files_exist(sapling_spend, sapling_output)) {
             LogPrintf("Found sapling params in /Applications/Contents/MacOS\n");
             found = true;
+    	}
     }
+    
+    if (!found) {
+        // This will only work when SDX is installed into /Applications, which is the only supported method
+        sapling_spend  = boost::filesystem::path("/Applications/silentdragonx.app/Contents/MacOS") / "sapling-spend.params";
+        sapling_output = boost::filesystem::path("/Applications/silentdragonx.app/Contents/MacOS") / "sapling-output.params";
+        if (files_exist(sapling_spend, sapling_output)) {
+            LogPrintf("Found sapling params in /Applications/Contents/MacOS\n");
+            found = true;
+    	}
     }
 
     if (!found) {
-        // DMG Support: Apple just has to do things differently...
+        // SD DMG Support: Apple just has to do things differently...
         sapling_spend  = boost::filesystem::path("./silentdragon.app/Contents/MacOS") / "sapling-spend.params";
         sapling_output = boost::filesystem::path("./silentdragon.app/Contents/MacOS") / "sapling-output.params";
         if (files_exist(sapling_spend, sapling_output)) {
             LogPrintf("Found sapling params in /Applications/Contents/MacOS\n");
             found = true;
-}
+		}
+    }
+    
+    if (!found) {
+        // SDX DMG Support: Apple just has to do things differently...
+        sapling_spend  = boost::filesystem::path("./silentdragonx.app/Contents/MacOS") / "sapling-spend.params";
+        sapling_output = boost::filesystem::path("./silentdragonx.app/Contents/MacOS") / "sapling-output.params";
+        if (files_exist(sapling_spend, sapling_output)) {
+            LogPrintf("Found sapling params in /Applications/Contents/MacOS\n");
+            found = true;
+		}
     }
 
     if (!found) {
@@ -893,7 +911,7 @@ static void ZC_LoadParams(
             LogPrintf("Found sapling params in ~/.zcash\n");
             found = true;
         }
-}
+	}
 
     if (!found) {
         // No Sapling params, at least we tried
@@ -1158,9 +1176,17 @@ bool AppInit2(boost::thread_group& threadGroup, CScheduler& scheduler)
                             if(fs::exists(asmap_path)) {
                                 printf("%s: found asmap file at %s\n", __func__, asmap_path.c_str() );
                             } else {
-                                // Shit is fucked up, die an honorable death
-                                InitError(strprintf(_("Could not find any asmap file! Please report this bug to Hush Developers")));
-                                return false;
+                            	// Mac SDX
+                            	asmap_path = fs::path("/Applications/SilentDragonX.app/Contents/MacOS/") / DEFAULT_ASMAP_FILENAME;
+                            	printf("%s: looking for asmap file at %s\n", __func__, asmap_path.c_str() );
+                            	if(fs::exists(asmap_path)) {
+                                	printf("%s: found asmap file at %s\n", __func__, asmap_path.c_str() );
+                            	} 	
+                            	else {
+                                	// Shit is fucked up, die an honorable death
+                                	InitError(strprintf(_("Could not find any asmap file! Please report this bug to Hush Developers")));
+                                	return false;
+                            	}
                             }
                         }
                     }

src/main.cpp

@@ -1340,22 +1340,6 @@ bool ContextualCheckTransaction(int32_t slowflag,const CBlock *block, CBlockInde
 
     }
 
-    if (!(tx.IsMint() || tx.vjoinsplit.empty()))
-    {
-        BOOST_STATIC_ASSERT(crypto_sign_PUBLICKEYBYTES == 32);
-
-        // We rely on libsodium to check that the signature is canonical.
-        // https://github.com/jedisct1/libsodium/commit/62911edb7ff2275cccd74bf1c8aefcc4d76924e0
-        if (crypto_sign_verify_detached(&tx.joinSplitSig[0],
-                                        dataToBeSigned.begin(), 32,
-                                        tx.joinSplitPubKey.begin()
-                                        ) != 0) {
-            return state.DoS(isInitBlockDownload() ? 0 : 100,
-                                error("CheckTransaction(): invalid joinsplit signature"),
-                                REJECT_INVALID, "bad-txns-invalid-joinsplit-signature");
-        }
-    }
-
     if (tx.IsCoinBase())
     {
         if (!ContextualCheckCoinbaseTransaction(slowflag,block,previndex,tx, nHeight,validateprices))
@@ -1363,6 +1347,11 @@ bool ContextualCheckTransaction(int32_t slowflag,const CBlock *block, CBlockInde
                                 REJECT_INVALID, "bad-txns-invalid-script-data-for-coinbase-time-lock");
     }
 
+    // Avoid ztx validation during IBD if height is less than latest checkpoint
+    if (fCheckpointsEnabled && (nHeight < Checkpoints::GetTotalBlocksEstimate(Params().Checkpoints())) ) {
+        return true;
+    }
+
     if (!tx.vShieldedSpend.empty() ||
         !tx.vShieldedOutput.empty())
     {
@@ -1422,26 +1411,6 @@ bool ContextualCheckTransaction(int32_t slowflag,const CBlock *block, CBlockInde
 bool CheckTransaction(uint32_t tiptime,const CTransaction& tx, CValidationState &state,
                       libzcash::ProofVerifier& verifier,int32_t txIndex, int32_t numTxs)
 {
-    static uint256 array[64]; static int32_t numbanned,indallvouts; int32_t j,k,n;
-    if ( *(int32_t *)&array[0] == 0 )
-        numbanned = hush_bannedset(&indallvouts,array,(int32_t)(sizeof(array)/sizeof(*array)));
-    n = tx.vin.size();
-    if ( SMART_CHAIN_SYMBOL[0] == 0 )
-    {
-        for (j=0; j<n; j++)
-        {
-            for (k=0; k<numbanned; k++)
-            {
-                if ( tx.vin[j].prevout.hash == array[k] && hush_checkvout(tx.vin[j].prevout.n,k,indallvouts) != 0 ) //(tx.vin[j].prevout.n == 1 || k >= indallvouts) )
-                {
-                    static uint32_t counter;
-                    if ( counter++ < 100 )
-                        printf("MEMPOOL: banned tx.%d being used at ht.%d vout.%d\n",k,(int32_t)chainActive.Tip()->GetHeight(),j);
-                    return(false);
-                }
-            }
-        }
-    }
     // Don't count coinbase transactions because mining skews the count
     if (!tx.IsCoinBase()) {
         transactionsValidated.increment();
@@ -5012,7 +4981,6 @@ bool CheckBlockHeader(int32_t *futureblockp,int32_t height,CBlockIndex *pindex,
     return true;
 }
 
-int32_t hush_check_deposit(int32_t height,const CBlock& block,uint32_t prevtime);
 int32_t hush_checkPOW(int32_t slowflag,CBlock *pblock,int32_t height);
 
 bool CheckBlock(int32_t *futureblockp,int32_t height,CBlockIndex *pindex,const CBlock& block, CValidationState& state,
@@ -5134,7 +5102,9 @@ bool ContextualCheckBlockHeader(const CBlockHeader& block, CValidationState& sta
         // changing at run-time, from Consensus::Params being a const struct
         unsigned int nNextWork = GetNextWorkRequired(pindexPrev, &block, consensusParams);
 
-        LogPrintf("%s: nbits ,%d,%lu,%lu,%d\n",__func__, nHeight, nNextWork, block.nBits, nNextWork - block.nBits );
+        if (fDebug) {
+            LogPrintf("%s: nbits ,%d,%lu,%lu,%d\n",__func__, nHeight, nNextWork, block.nBits, nNextWork - block.nBits );
+        }
         if (block.nBits != nNextWork) {
                 // Enforce correct nbits at DAA fork height, before that, ignore
                 if (nHeight > daaForkHeight) {
@@ -5980,7 +5950,7 @@ bool static LoadBlockIndexDB()
     PruneBlockIndexCandidates();
 
     double progress;
-    if ( SMART_CHAIN_SYMBOL[0] == 0 ) {
+    if ( ishush3 ) {
         progress = Checkpoints::GuessVerificationProgress(chainparams.Checkpoints(), chainActive.LastTip());
     } else {
         int32_t longestchain = hush_longestchain();
@@ -6841,9 +6811,6 @@ void static ProcessGetData(CNode* pfrom)
                 }
             }
 
-            // Track requests for our stuff.
-            GetMainSignals().Inventory(inv.hash);
-
             if (inv.type == MSG_BLOCK || inv.type == MSG_FILTERED_BLOCK)
                 break;
         }
@@ -7000,6 +6967,10 @@ bool static ProcessMessage(CNode* pfrom, string strCommand, CDataStream& vRecv,
             {
                 pfrom->PushMessage(NetMsgType::GETADDR);
                 pfrom->fGetAddr = true;
+                // pfrom->m_getaddr_sent = true;
+                // When requesting a getaddr, accept an additional MAX_ADDR_TO_SEND addresses in response
+                // (bypassing the MAX_ADDR_PROCESSING_TOKEN_BUCKET limit).
+                pfrom->m_addr_token_bucket += MAX_ADDR_TO_SEND;
             }
             addrman.Good(pfrom->addr);
         } else {
@@ -7103,15 +7074,37 @@ bool static ProcessMessage(CNode* pfrom, string strCommand, CDataStream& vRecv,
         vector<CAddress> vAddrOk;
         int64_t nNow = GetTime();
         int64_t nSince = nNow - 10 * 60;
+
+        // Update/increment addr rate limiting bucket.
+        const int64_t current_time = GetTimeMicros();
+        if (pfrom->m_addr_token_bucket < MAX_ADDR_PROCESSING_TOKEN_BUCKET) {
+            // Don't increment bucket if it's already full
+            const auto time_diff = std::max(current_time - pfrom->m_addr_token_timestamp, (int64_t) 0);
+            const double increment = (time_diff / 1000000) * MAX_ADDR_RATE_PER_SECOND;
+            pfrom->m_addr_token_bucket = std::min<double>(pfrom->m_addr_token_bucket + increment, MAX_ADDR_PROCESSING_TOKEN_BUCKET);
+        }
+        pfrom->m_addr_token_timestamp = current_time;
+
+        uint64_t num_proc = 0;
+        uint64_t num_rate_limit = 0;
+
         BOOST_FOREACH(CAddress& addr, vAddr)
         {
             boost::this_thread::interruption_point();
+            // Apply rate limiting if the address is not allowlisted
+            if (!pfrom->IsAllowlistedRange(addr)) {
+                if (pfrom->m_addr_token_bucket < 1.0) break;
+                pfrom->m_addr_token_bucket -= 1.0;
+            }
+
             if(p2pdebug)
                 fprintf(stderr,"%s: %s.nTime=%d\n", __func__, addr.ToString().c_str(), addr.nTime);
 
             if (addr.nTime <= 100000000 || addr.nTime > nNow + 10 * 60)
                 addr.nTime = nNow - 5 * 24 * 60 * 60;
-            pfrom->AddAddressKnown(addr);
+            pfrom->AddAddressIfNotAlreadyKnown(addr);
+
+            ++num_proc;
             bool fReachable = IsReachable(addr);
             if (addr.nTime > nSince && !pfrom->fGetAddr && vAddr.size() <= 10 && addr.IsRoutable())
             {
@@ -7150,6 +7143,15 @@ bool static ProcessMessage(CNode* pfrom, string strCommand, CDataStream& vRecv,
                     fprintf(stderr,"%s: %s with nTime=%d is not reachable\n",__func__,addr.ToString().c_str(), addr.nTime);
             }
         }
+        pfrom->m_addr_processed += num_proc;
+        pfrom->m_addr_rate_limited += num_rate_limit;
+        LogPrintf("ProcessMessage: Received addr: %u addresses (%u processed, %u rate-limited) from peer=%d%s\n",
+                 vAddr.size(),
+                 num_proc,
+                 num_rate_limit,
+                 pfrom->GetId(),
+                 fLogIPs ? ", peeraddr=" + pfrom->addr.ToString() : "");
+
         addrman.Add(vAddrOk, pfrom->addr, 2 * 60 * 60);
         if (vAddr.size() < 1000)
             pfrom->fGetAddr = false;
@@ -7320,9 +7322,6 @@ bool static ProcessMessage(CNode* pfrom, string strCommand, CDataStream& vRecv,
                 }
             }
 
-            // Track requests for our stuff
-            GetMainSignals().Inventory(inv.hash);
-
             if (pfrom->nSendSize > (SendBufferSize() * 2)) {
                 Misbehaving(pfrom->GetId(), 50);
                 return error("send buffer size() = %u", pfrom->nSendSize);
@@ -7663,31 +7662,6 @@ bool static ProcessMessage(CNode* pfrom, string strCommand, CDataStream& vRecv,
                 Misbehaving(pfrom->GetId(), nDoS);
             }
         }
-
-    } else if (strCommand == NetMsgType::MEMPOOL) {
-        LOCK2(cs_main, pfrom->cs_filter);
-        //LogPrintf("%s: mempool request from %s",__func__, pfrom->addr.ToString().c_str());
-        // TODO: limit mempool requests per time and per peer
-
-        std::vector<uint256> vtxid;
-        mempool.queryHashes(vtxid);
-        vector<CInv> vInv;
-        BOOST_FOREACH(uint256& hash, vtxid) {
-            CInv inv(MSG_TX, hash);
-            if (pfrom->pfilter) {
-                CTransaction tx;
-                bool fInMemPool = mempool.lookup(hash, tx);
-                if (!fInMemPool) continue; // another thread removed since queryHashes, maybe...
-                if (!pfrom->pfilter->IsRelevantAndUpdate(tx)) continue;
-            }
-            vInv.push_back(inv);
-            if (vInv.size() == MAX_INV_SZ) {
-                pfrom->PushMessage(NetMsgType::INV, vInv);
-                vInv.clear();
-            }
-        }
-        if (vInv.size() > 0)
-            pfrom->PushMessage(NetMsgType::INV, vInv);
     } else if (strCommand == NetMsgType::ALERT) {
 	// Small DoS penalty so peers that send us lots of
 	// duplicate/expired/invalid-signature/whatever alerts
@@ -7960,9 +7934,8 @@ bool SendMessages(CNode* pto, bool fSendTrickle)
             vAddr.reserve(pto->vAddrToSend.size());
             BOOST_FOREACH(const CAddress& addr, pto->vAddrToSend)
             {
-                if (!pto->addrKnown.contains(addr.GetKey()))
+                if (pto->AddAddressIfNotAlreadyKnown(addr))
                 {
-                    pto->addrKnown.insert(addr.GetKey());
                     vAddr.push_back(addr);
 
                     if (vAddr.size() >= MAX_ADDR_TO_SEND)

src/miner.cpp

@@ -628,8 +628,6 @@ CBlockTemplate* CreateNewBlock(CPubKey _pk,const CScript& _scriptPubKeyIn, int32
         else txNew.nLockTime = std::max((int64_t)(pindexPrev->nTime+1), GetTime());
 
 
-        if ( SMART_CHAIN_SYMBOL[0] == 0 && IS_HUSH_NOTARY != 0 && My_notaryid >= 0 )
-            txNew.vout[0].nValue += 5000;
         pblock->vtx[0] = txNew;
 
         if ( nHeight > 1 && SMART_CHAIN_SYMBOL[0] != 0 && (ASSETCHAINS_OVERRIDE_PUBKEY33[0] != 0 || ASSETCHAINS_SCRIPTPUB.size() > 1) && (ASSETCHAINS_COMMISSION != 0 || ASSETCHAINS_FOUNDERS_REWARD != 0)  && (commission= the_commission((CBlock*)&pblocktemplate->block,(int32_t)nHeight)) != 0 )
@@ -924,13 +922,6 @@ static bool ProcessBlockFound(CBlock* pblock)
             reservekey.KeepKey();
         }
     }
-    // Track how many getdata requests this block gets
-    //if ( 0 )
-    {
-        //fprintf(stderr,"lock cs_wallet\n");
-        LOCK(wallet.cs_wallet);
-        wallet.mapRequestCount[pblock->GetHash()] = 0;
-    }
 #endif
     //fprintf(stderr,"process new block\n");
 
@@ -1449,8 +1440,6 @@ void static BitcoinMiner()
         if ( hush_baseid(SMART_CHAIN_SYMBOL) < 0 )
             break;
     }
-    if ( SMART_CHAIN_SYMBOL[0] == 0 )
-        hush_chosennotary(&notaryid,chainActive.LastTip()->GetHeight(),NOTARY_PUBKEY33,(uint32_t)chainActive.LastTip()->GetBlockTime());
     if ( notaryid != My_notaryid )
         My_notaryid = notaryid;
     std::string solver;
@@ -1580,61 +1569,7 @@ void static BitcoinMiner()
             savebits = pblock->nBits;
             HASHTarget = arith_uint256().SetCompact(savebits);
             roundrobin_delay = ROUNDROBIN_DELAY;
-            if ( SMART_CHAIN_SYMBOL[0] == 0 && notaryid >= 0 )
-            {
-                j = 65;
-                if ( (Mining_height >= 235300 && Mining_height < 236000) || (Mining_height % HUSH_DPOW_GAP) > 64 || (Mining_height % HUSH_DPOW_GAP) == 0 || Mining_height > 1000000 )
-                {
-                    int32_t dispflag = 0;
-                    if ( notaryid <= 3 || notaryid == 32 || (notaryid >= 43 && notaryid <= 45) || notaryid == 51 || notaryid == 52 || notaryid == 56 || notaryid == 57 )
-                        dispflag = 1;
-                    hush_eligiblenotary(pubkeys,mids,blocktimes,&nonzpkeys,pindexPrev->GetHeight());
-                    if ( nonzpkeys > 0 )
-                    {
-                        for (i=0; i<33; i++)
-                            if( pubkeys[0][i] != 0 )
-                                break;
-                        if ( i == 33 )
-                            externalflag = 1;
-                        else externalflag = 0;
-                        if ( IS_HUSH_NOTARY != 0 )
-                        {
-                            for (i=1; i<66; i++)
-                                if ( memcmp(pubkeys[i],pubkeys[0],33) == 0 )
-                                    break;
-                            if ( externalflag == 0 && i != 66 && mids[i] >= 0 )
-                                printf("VIOLATION at %d, notaryid.%d\n",i,mids[i]);
-                            for (j=gpucount=0; j<65; j++)
-                            {
-                                if ( dispflag != 0 )
-                                {
-                                    if ( mids[j] >= 0 )
-                                    {
-                                        if ( mids[j] == notaryid )
-                                            fprintf(stderr,"--<%d>-- ",mids[j]);
-                                        else
-                                            fprintf(stderr,"%d ",mids[j]);
-                                    } else fprintf(stderr,"GPU ");
-                                }
-                                if ( mids[j] == -1 )
-                                    gpucount++;
-                            }
-                            if ( dispflag != 0 )
-                                fprintf(stderr," <- prev minerids from ht.%d notary.%d gpucount.%d %.2f%% t.%u\n",pindexPrev->GetHeight(),notaryid,gpucount,100.*(double)gpucount/j,(uint32_t)time(NULL));
-                        }
-                        for (j=0; j<65; j++)
-                            if ( mids[j] == notaryid )
-                                break;
-                        if ( j == 65 )
-                            HUSH_LASTMINED = 0;
-                    } else fprintf(stderr,"no nonz pubkeys\n");
-                    if ( (Mining_height >= 235300 && Mining_height < 236000) || (j == 65 && Mining_height > HUSH_MAYBEMINED+1 && Mining_height > HUSH_LASTMINED+64) )
-                    {
-                        HASHTarget = arith_uint256().SetCompact(HUSH_MINDIFF_NBITS);
-                        fprintf(stderr,"I am the chosen one for %s ht.%d\n",SMART_CHAIN_SYMBOL,pindexPrev->GetHeight()+1);
-                    } //else fprintf(stderr,"duplicate at j.%d\n",j);
-                } else Mining_start = 0;
-            } else Mining_start = 0;
+            Mining_start = 0;
 
             //else if ( ASSETCHAINS_ADAPTIVEPOW > 0 )
             //    HASHTarget_POW = hush_adaptivepow_target(Mining_height,HASHTarget,pblock->nTime);

src/net.cpp

@@ -556,6 +556,10 @@ void CNode::CloseSocketDisconnect()
             CloseSocket(hSocket);
         }
     }
+    {
+        LOCK(cs_addrKnown);
+        addrKnown.reset();
+    }
 
     // in case this fails, we'll empty the recv buffer when the CNode is deleted
     TRY_LOCK(cs_vRecvMsg, lockRecv);
@@ -809,6 +813,9 @@ void CNode::copyStats(CNodeStats &stats, const std::vector<bool> &m_asmap)
     stats.dPingTime = (((double)nPingUsecTime) / 1e6);
     stats.dMinPing  = (((double)nMinPingUsecTime) / 1e6);
     stats.dPingWait = (((double)nPingUsecWait) / 1e6);
+    stats.m_addr_processed = m_addr_processed.load();
+    stats.m_addr_rate_limited = m_addr_rate_limited.load();
+
 
     // Leave string empty if addrLocal invalid (not filled in yet)
     stats.addrLocal = addrLocal.IsValid() ? addrLocal.ToString() : "";
@@ -1945,6 +1952,11 @@ void ThreadMessageHandler()
 
         bool fSleep = true;
 
+        // Randomize the order in which we process messages from/to our peers.
+        // This prevents attacks in which an attacker exploits having multiple
+        // consecutive connections in the vNodes list.
+        random_shuffle(vNodesCopy.begin(), vNodesCopy.end(), GetRandInt);
+
         BOOST_FOREACH(CNode* pnode, vNodesCopy)
         {
             if (pnode->fDisconnect)

src/net.h

@@ -72,6 +72,13 @@ static const int TIMEOUT_INTERVAL = 20 * 60;
 static const unsigned int MAX_INV_SZ = 50000;
 /** The maximum number of new addresses to accumulate before announcing. */
 static const unsigned int MAX_ADDR_TO_SEND = 1000;
+/** The maximum rate of address records we're willing to process on average. Can be bypassed using
+ *  the NetPermissionFlags::Addr permission. */
+static constexpr double MAX_ADDR_RATE_PER_SECOND{0.1};
+/** The soft limit of the address processing token bucket (the regular MAX_ADDR_RATE_PER_SECOND
+ *  based increments won't go above this, but the MAX_ADDR_TO_SEND increment following GETADDR
+ *  is exempt from this limit. */
+static constexpr size_t MAX_ADDR_PROCESSING_TOKEN_BUCKET{MAX_ADDR_TO_SEND};
 /** Maximum length of incoming protocol messages (no message over 2 MiB is currently acceptable). */
 static const unsigned int MAX_PROTOCOL_MESSAGE_LENGTH = (_MAX_BLOCK_SIZE + 24); // 24 is msgheader size
 /** Maximum length of strSubVer in `version` message */
@@ -295,6 +302,9 @@ public:
     // CAddress addrBind; // https://github.com/bitcoin/bitcoin/commit/a7e3c2814c8e49197889a4679461be42254e5c51
     uint32_t m_mapped_as;
 
+    uint64_t m_addr_processed{0};
+    uint64_t m_addr_rate_limited{0};
+
     /**
      * Whether the peer has signaled support for receiving ADDRv2 (BIP155)
      * messages, implying a preference to receive ADDRv2 instead of ADDR ones.
@@ -302,9 +312,6 @@ public:
     bool m_wants_addrv2;
 };
 
-
-
-
 class CNetMessage {
 public:
     bool in_data;                   // parsing header (false) or data (true)
@@ -425,6 +432,8 @@ public:
     CCriticalSection cs_filter;
     CBloomFilter* pfilter;
     int nRefCount;
+    CRollingBloomFilter addrKnown;
+    mutable CCriticalSection cs_addrKnown;
     NodeId id;
 
     /**
@@ -433,6 +442,15 @@ public:
      */
     bool m_wants_addrv2{false};
 
+    /** Number of addr messages that can be processed from this peer. Start at 1 to  permit self-announcement. */
+    double m_addr_token_bucket{1.0};
+    /** When m_addr_token_bucket was last updated */
+    int64_t m_addr_token_timestamp{GetTimeMicros()};
+    /** Total number of addresses that were dropped due to rate limiting. */
+    std::atomic<uint64_t> m_addr_rate_limited{0};
+    /** Total number of addresses that were processed (excludes rate limited ones). */
+    std::atomic<uint64_t> m_addr_processed{0};
+
 protected:
 
     // Denial-of-service detection/prevention
@@ -462,7 +480,6 @@ public:
 
     // flood relay
     std::vector<CAddress> vAddrToSend;
-    CRollingBloomFilter addrKnown;
     bool fGetAddr;
     std::set<uint256> setKnown;
 
@@ -545,11 +562,25 @@ public:
         nRefCount--;
     }
 
+    bool AddAddressIfNotAlreadyKnown(const CAddress& addr)
+    {
+        LOCK(cs_addrKnown);
+        // Avoid adding to addrKnown after it has been reset in CloseSocketDisconnect.
+        if (fDisconnect) {
+            return false;
+        }
+        if (!addrKnown.contains(addr.GetKey())) {
+            addrKnown.insert(addr.GetKey());
+            return true;
+        } else {
+            return false;
+        }
+    }
 
-
-    void AddAddressKnown(const CAddress& _addr)
+    bool IsAddressKnown(const CAddress& addr) const
     {
-        addrKnown.insert(_addr.GetKey());
+        LOCK(cs_addrKnown);
+        return addrKnown.contains(addr.GetKey());
     }
 
     void PushAddress(const CAddress& _addr)
@@ -562,7 +593,8 @@ public:
         // Known checking here is only to save space from duplicates.
         // SendMessages will filter it again for knowns that were added
         // after addresses were pushed.
-        if (_addr.IsValid() && !addrKnown.contains(_addr.GetKey()) && addr_format_supported) {
+        if (_addr.IsValid() && !IsAddressKnown(addr) && addr_format_supported) {
+
             if (vAddrToSend.size() >= MAX_ADDR_TO_SEND) {
                 vAddrToSend[insecure_rand() % vAddrToSend.size()] = _addr;
             } else {

src/pow.cpp

@@ -503,8 +503,9 @@ unsigned int GetNextWorkRequired(const CBlockIndex* pindexLast, const CBlockHead
         nbits = bnTarget.GetCompact();
         nbits = (nbits & 0xfffffffc) | zawyflag;
     }
-    //if(fDebug)
+    if(fDebug) {
         fprintf(stderr,"%s: nbits=%d\n", __func__, nbits);
+    }
     return(nbits);
 }
 
@@ -537,11 +538,15 @@ unsigned int CalculateNextWorkRequired(arith_uint256 bnAvg,
 
     if ( ASSETCHAINS_ADAPTIVEPOW <= 0 ) {
         if (nActualTimespan < params.MinActualTimespan()) {
-            fprintf(stderr,"%s: Adjusting nActualTimespan up to min value %li\n", __func__, params.MinActualTimespan() );
+            if(fDebug) {
+                fprintf(stderr,"%s: Adjusting nActualTimespan up to min value %li\n", __func__, params.MinActualTimespan() );
+            }
             nActualTimespan = params.MinActualTimespan();
         }
         if (nActualTimespan > params.MaxActualTimespan()) {
-            fprintf(stderr,"%s: Adjusting nActualTimespan down to max value %li\n", __func__, params.MaxActualTimespan() );
+            if(fDebug) {
+                fprintf(stderr,"%s: Adjusting nActualTimespan down to max value %li\n", __func__, params.MaxActualTimespan() );
+            }
             nActualTimespan = params.MaxActualTimespan();
         }
     }

src/protocol.cpp

@@ -51,7 +51,6 @@ const char *TX="tx"; //used
 const char *HEADERS="headers"; //used
 const char *BLOCK="block"; //used
 const char *GETADDR="getaddr"; //used
-const char *MEMPOOL="mempool"; //used
 const char *PING="ping"; //used
 const char *PONG="pong"; //used
 const char *NOTFOUND="notfound"; //used
@@ -96,7 +95,6 @@ const static std::string allNetMessageTypes[] = {
     NetMsgType::HEADERS,
     NetMsgType::BLOCK,
     NetMsgType::GETADDR,
-    NetMsgType::MEMPOOL,
     NetMsgType::PING,
     NetMsgType::PONG,
     NetMsgType::NOTFOUND,

src/protocol.h

@@ -158,12 +158,6 @@ extern const char* BLOCK;
  * preferably one with lots of IP addresses of other receiving nodes.
  */
 extern const char* GETADDR;
-/**
- * The mempool message requests the TXIDs of transactions that the receiving
- * node has verified as valid but which have not yet appeared in a block.
- * @since protocol version 60002.
- */
-extern const char* MEMPOOL;
 /**
  * The ping message is sent periodically to help confirm that the receiving
  * peer is still connected.

src/rpc/blockchain.cpp

@@ -1061,79 +1061,8 @@ UniValue notaries(const UniValue& params, bool fHelp, const CPubKey& mypk)
 }
 
 int32_t hush_pending_withdraws(char *opretstr);
-int32_t pax_fiatstatus(uint64_t *available,uint64_t *deposited,uint64_t *issued,uint64_t *withdrawn,uint64_t *approved,uint64_t *redeemed,char *base);
 extern char CURRENCIES[][8];
 
-UniValue paxpending(const UniValue& params, bool fHelp, const CPubKey& mypk)
-{
-    UniValue ret(UniValue::VOBJ); UniValue a(UniValue::VARR); char opretbuf[10000*2]; int32_t opretlen,baseid; uint64_t available,deposited,issued,withdrawn,approved,redeemed;
-    if ( fHelp || params.size() != 0 )
-        throw runtime_error("paxpending needs no args\n");
-    LOCK(cs_main);
-    if ( (opretlen= hush_pending_withdraws(opretbuf)) > 0 )
-        ret.push_back(Pair("withdraws", opretbuf));
-    else ret.push_back(Pair("withdraws", (char *)""));
-    for (baseid=0; baseid<32; baseid++)
-    {
-        UniValue item(UniValue::VOBJ); UniValue obj(UniValue::VOBJ);
-        if ( pax_fiatstatus(&available,&deposited,&issued,&withdrawn,&approved,&redeemed,CURRENCIES[baseid]) == 0 )
-        {
-            if ( deposited != 0 || issued != 0 || withdrawn != 0 || approved != 0 || redeemed != 0 )
-            {
-                item.push_back(Pair("available", ValueFromAmount(available)));
-                item.push_back(Pair("deposited", ValueFromAmount(deposited)));
-                item.push_back(Pair("issued", ValueFromAmount(issued)));
-                item.push_back(Pair("withdrawn", ValueFromAmount(withdrawn)));
-                item.push_back(Pair("approved", ValueFromAmount(approved)));
-                item.push_back(Pair("redeemed", ValueFromAmount(redeemed)));
-                obj.push_back(Pair(CURRENCIES[baseid],item));
-                a.push_back(obj);
-            }
-        }
-    }
-    ret.push_back(Pair("fiatstatus", a));
-    return ret;
-}
-
-UniValue paxprice(const UniValue& params, bool fHelp, const CPubKey& mypk)
-{
-    if ( fHelp || params.size() > 4 || params.size() < 2 )
-        throw runtime_error("paxprice \"base\" \"rel\" height\n");
-    LOCK(cs_main);
-    UniValue ret(UniValue::VOBJ); uint64_t basevolume=0,relvolume,seed;
-    std::string base = params[0].get_str();
-    std::string rel = params[1].get_str();
-    int32_t height;
-    if ( params.size() == 2 )
-        height = chainActive.LastTip()->GetHeight();
-    else height = atoi(params[2].get_str().c_str());
-    //if ( params.size() == 3 || (basevolume= COIN * atof(params[3].get_str().c_str())) == 0 )
-        basevolume = 100000;
-    relvolume = hush_paxprice(&seed,height,(char *)base.c_str(),(char *)rel.c_str(),basevolume);
-    ret.push_back(Pair("base", base));
-    ret.push_back(Pair("rel", rel));
-    ret.push_back(Pair("height", height));
-    char seedstr[32];
-    sprintf(seedstr,"%llu",(long long)seed);
-    ret.push_back(Pair("seed", seedstr));
-    if ( height < 0 || height > chainActive.Height() )
-        throw JSONRPCError(RPC_INVALID_PARAMETER, "Block height out of range");
-    else
-    {
-        CBlockIndex *pblockindex = chainActive[height];
-        if ( pblockindex != 0 )
-            ret.push_back(Pair("timestamp", (int64_t)pblockindex->nTime));
-        if ( basevolume != 0 && relvolume != 0 )
-        {
-            ret.push_back(Pair("price",((double)relvolume / (double)basevolume)));
-            ret.push_back(Pair("invprice",((double)basevolume / (double)relvolume)));
-            ret.push_back(Pair("basevolume",ValueFromAmount(basevolume)));
-            ret.push_back(Pair("relvolume",ValueFromAmount(relvolume)));
-        } else ret.push_back(Pair("error", "overflow or error in one or more of parameters"));
-    }
-    return ret;
-}
-
 UniValue gettxout(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() < 2 || params.size() > 3)

src/rpc/client.cpp

@@ -154,9 +154,6 @@ static const CRPCConvertParam vRPCConvertParams[] =
     { "z_shieldcoinbase", 3},
     { "z_getoperationstatus", 0},
     { "z_getoperationresult", 0},
-    { "paxprice", 4 },
-    { "paxprices", 3 },
-    { "paxpending", 0 },
     { "notaries", 2 },
     { "minerids", 1 },
     { "kvsearch", 1 },

src/rpc/net.cpp

@@ -204,6 +204,8 @@ UniValue getpeerinfo(const UniValue& params, bool fHelp, const CPubKey& mypk)
             obj.push_back(Pair("inflight", heights));
         }
         obj.push_back(Pair("allowlisted", stats.fAllowlisted));
+        obj.pushKV("addr_processed", stats.m_addr_processed);
+        obj.pushKV("addr_rate_limited", stats.m_addr_rate_limited);
 
         ret.push_back(obj);
     }

src/rpc/server.cpp

@@ -332,9 +332,6 @@ static const CRPCCommand vRPCCommands[] =
     { "blockchain",         "gettxoutsetinfo",        &gettxoutsetinfo,        true  },
     { "blockchain",         "verifychain",            &verifychain,            true  },
     { "blockchain",         "getspentinfo",           &getspentinfo,           false },
-    //{ "blockchain",         "paxprice",               &paxprice,               true  },
-    //{ "blockchain",         "paxpending",             &paxpending,             true  },
-    //{ "blockchain",         "paxprices",              &paxprices,              true  },
     { "blockchain",         "notaries",               &notaries,               true  },
     //{ "blockchain",         "height_MoM",             &height_MoM,             true  },
     //{ "blockchain",         "txMoMproof",             &txMoMproof,             true  },

src/rpc/server.h

@@ -502,10 +502,5 @@ extern UniValue notaries(const UniValue& params, bool fHelp, const CPubKey& mypk
 extern UniValue minerids(const UniValue& params, bool fHelp, const CPubKey& mypk);
 extern UniValue kvsearch(const UniValue& params, bool fHelp, const CPubKey& mypk);
 extern UniValue kvupdate(const UniValue& params, bool fHelp, const CPubKey& mypk);
-extern UniValue paxprice(const UniValue& params, bool fHelp, const CPubKey& mypk);
-extern UniValue paxpending(const UniValue& params, bool fHelp, const CPubKey& mypk);
-extern UniValue paxprices(const UniValue& params, bool fHelp, const CPubKey& mypk);
-extern UniValue paxdeposit(const UniValue& params, bool fHelp, const CPubKey& mypk);
-extern UniValue paxwithdraw(const UniValue& params, bool fHelp, const CPubKey& mypk);
 
 #endif // HUSH_RPCSERVER_H

src/stratum.cpp

@@ -123,10 +123,8 @@ namespace { // better to use anonymous namespace for helper routines
         if (mapMultiArgs.count("-stratumallowip")) {
             const std::vector<std::string>& vAllow = mapMultiArgs["-stratumallowip"];
             for(const std::string& strAllow : vAllow) {
-    		CNetAddr netaddr;
-		// todo: v6
-    		LookupHost(strAllow.c_str(), netaddr, false);
-                CSubNet subnet(netaddr);
+		CSubNet subnet;
+    		LookupSubNet(strAllow.c_str(), subnet);
                 if (!subnet.IsValid()) {
                     uiInterface.ThreadSafeMessageBox(
                         strprintf("Invalid -stratumallowip subnet specification: %s. Valid are a single IP (e.g. 1.2.3.4), a network/netmask (e.g. 1.2.3.4/255.255.255.0) or a network/CIDR (e.g. 1.2.3.4/24).", strAllow),

src/txdb.cpp

@@ -203,7 +203,7 @@ bool CCoinsViewDB::BatchWrite(CCoinsMap &mapCoins,
 CBlockTreeDB::CBlockTreeDB(size_t nCacheSize, bool fMemory, bool fWipe, bool compression, int maxOpenFiles) : CDBWrapper(GetDataDir() / "blocks" / "index", nCacheSize, fMemory, fWipe, compression, maxOpenFiles) {
 }
 
-bool CBlockTreeDB::ReadBlockFileInfo(int nFile, CBlockFileInfo &info) {
+bool CBlockTreeDB::ReadBlockFileInfo(int nFile, CBlockFileInfo &info) const {
     return Read(make_pair(DB_BLOCK_FILES, nFile), info);
 }
 
@@ -214,12 +214,12 @@ bool CBlockTreeDB::WriteReindexing(bool fReindexing) {
         return Erase(DB_REINDEX_FLAG);
 }
 
-bool CBlockTreeDB::ReadReindexing(bool &fReindexing) {
+bool CBlockTreeDB::ReadReindexing(bool &fReindexing) const {
     fReindexing = Exists(DB_REINDEX_FLAG);
     return true;
 }
 
-bool CBlockTreeDB::ReadLastBlockFile(int &nFile) {
+bool CBlockTreeDB::ReadLastBlockFile(int &nFile) const {
     return Read(DB_LAST_BLOCK, nFile);
 }
 
@@ -293,7 +293,7 @@ bool CBlockTreeDB::EraseBatchSync(const std::vector<const CBlockIndex*>& blockin
     return WriteBatch(batch, true);
 }
 
-bool CBlockTreeDB::ReadTxIndex(const uint256 &txid, CDiskTxPos &pos) {
+bool CBlockTreeDB::ReadTxIndex(const uint256 &txid, CDiskTxPos &pos) const {
     return Read(make_pair(DB_TXINDEX, txid), pos);
 }
 
@@ -304,7 +304,7 @@ bool CBlockTreeDB::WriteTxIndex(const std::vector<std::pair<uint256, CDiskTxPos>
     return WriteBatch(batch);
 }
 
-bool CBlockTreeDB::ReadSpentIndex(CSpentIndexKey &key, CSpentIndexValue &value) {
+bool CBlockTreeDB::ReadSpentIndex(CSpentIndexKey &key, CSpentIndexValue &value) const {
     return Read(make_pair(DB_SPENTINDEX, key), value);
 }
 
@@ -625,7 +625,7 @@ bool CBlockTreeDB::WriteTimestampBlockIndex(const CTimestampBlockIndexKey &block
     return WriteBatch(batch);
 }
 
-bool CBlockTreeDB::ReadTimestampBlockIndex(const uint256 &hash, unsigned int &ltimestamp) {
+bool CBlockTreeDB::ReadTimestampBlockIndex(const uint256 &hash, unsigned int &ltimestamp) const {
 
     CTimestampBlockIndexValue(lts);
     if (!Read(std::make_pair(DB_BLOCKHASHINDEX, hash), lts))
@@ -639,7 +639,7 @@ bool CBlockTreeDB::WriteFlag(const std::string &name, bool fValue) {
     return Write(std::make_pair(DB_FLAG, name), fValue ? '1' : '0');
 }
 
-bool CBlockTreeDB::ReadFlag(const std::string &name, bool &fValue) {
+bool CBlockTreeDB::ReadFlag(const std::string &name, bool &fValue) const {
     char ch;
     if (!Read(std::make_pair(DB_FLAG, name), ch))
         return false;

src/txdb.h

@@ -93,13 +93,13 @@ private:
 public:
     bool WriteBatchSync(const std::vector<std::pair<int, const CBlockFileInfo*> >& fileInfo, int nLastFile, const std::vector<const CBlockIndex*>& blockinfo);
     bool EraseBatchSync(const std::vector<const CBlockIndex*>& blockinfo);
-    bool ReadBlockFileInfo(int nFile, CBlockFileInfo &fileinfo);
-    bool ReadLastBlockFile(int &nFile);
+    bool ReadBlockFileInfo(int nFile, CBlockFileInfo &fileinfo) const;
+    bool ReadLastBlockFile(int &nFile) const;
     bool WriteReindexing(bool fReindex);
-    bool ReadReindexing(bool &fReindex);
-    bool ReadTxIndex(const uint256 &txid, CDiskTxPos &pos);
+    bool ReadReindexing(bool &fReindex) const;
+    bool ReadTxIndex(const uint256 &txid, CDiskTxPos &pos) const;
     bool WriteTxIndex(const std::vector<std::pair<uint256, CDiskTxPos> > &list);
-    bool ReadSpentIndex(CSpentIndexKey &key, CSpentIndexValue &value);
+    bool ReadSpentIndex(CSpentIndexKey &key, CSpentIndexValue &value) const;
     bool UpdateSpentIndex(const std::vector<std::pair<CSpentIndexKey, CSpentIndexValue> >&vect);
     bool UpdateAddressUnspentIndex(const std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue > >&vect);
     bool ReadAddressUnspentIndex(uint160 addressHash, int type,
@@ -112,9 +112,9 @@ public:
     bool WriteTimestampIndex(const CTimestampIndexKey &timestampIndex);
     bool ReadTimestampIndex(const unsigned int &high, const unsigned int &low, const bool fActiveOnly, std::vector<std::pair<uint256, unsigned int> > &vect);
     bool WriteTimestampBlockIndex(const CTimestampBlockIndexKey &blockhashIndex, const CTimestampBlockIndexValue &logicalts);
-    bool ReadTimestampBlockIndex(const uint256 &hash, unsigned int &logicalTS);
+    bool ReadTimestampBlockIndex(const uint256 &hash, unsigned int &logicalTS) const;
     bool WriteFlag(const std::string &name, bool fValue);
-    bool ReadFlag(const std::string &name, bool &fValue);
+    bool ReadFlag(const std::string &name, bool &fValue) const;
     bool LoadBlockIndexGuts();
     bool blockOnchainActive(const uint256 &hash);
     UniValue Snapshot(int top);

src/util/string.h

@@ -15,6 +15,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <cstdint>
 
 [[nodiscard]] inline std::string TrimString(const std::string& str, const std::string& pattern = " \f\n\r\t\v")
 {

src/validationinterface.cpp

@@ -16,6 +16,7 @@
 
 #include <chrono>
 #include <thread>
+#include <functional>
 
 static CMainSignals g_signals;
 
@@ -31,19 +32,15 @@ void RegisterValidationInterface(CValidationInterface* pwalletIn) {
     g_signals.UpdatedTransaction.connect(boost::bind(&CValidationInterface::UpdatedTransaction, pwalletIn, _1));
     g_signals.ChainTip.connect(boost::bind(&CValidationInterface::ChainTip, pwalletIn, _1, _2, _3));
     g_signals.SetBestChain.connect(boost::bind(&CValidationInterface::SetBestChain, pwalletIn, _1));
-    g_signals.Inventory.connect(boost::bind(&CValidationInterface::Inventory, pwalletIn, _1));
     g_signals.Broadcast.connect(boost::bind(&CValidationInterface::ResendWalletTransactions, pwalletIn, _1));
     g_signals.BlockChecked.connect(boost::bind(&CValidationInterface::BlockChecked, pwalletIn, _1, _2));
     //g_signals.ScriptForMining.connect(boost::bind(&CValidationInterface::GetScriptForMining, pwalletIn, _1));
-    g_signals.BlockFound.connect(boost::bind(&CValidationInterface::ResetRequestCount, pwalletIn, _1));
 }
 
 void UnregisterValidationInterface(CValidationInterface* pwalletIn) {
-    g_signals.BlockFound.disconnect(boost::bind(&CValidationInterface::ResetRequestCount, pwalletIn, _1));
     //g_signals.ScriptForMining.disconnect(boost::bind(&CValidationInterface::GetScriptForMining, pwalletIn, _1));
     g_signals.BlockChecked.disconnect(boost::bind(&CValidationInterface::BlockChecked, pwalletIn, _1, _2));
     g_signals.Broadcast.disconnect(boost::bind(&CValidationInterface::ResendWalletTransactions, pwalletIn, _1));
-    g_signals.Inventory.disconnect(boost::bind(&CValidationInterface::Inventory, pwalletIn, _1));
     g_signals.ChainTip.disconnect(boost::bind(&CValidationInterface::ChainTip, pwalletIn, _1, _2, _3));
     g_signals.SetBestChain.disconnect(boost::bind(&CValidationInterface::SetBestChain, pwalletIn, _1));
     g_signals.UpdatedTransaction.disconnect(boost::bind(&CValidationInterface::UpdatedTransaction, pwalletIn, _1));
@@ -57,7 +54,6 @@ void UnregisterAllValidationInterfaces() {
     //g_signals.ScriptForMining.disconnect_all_slots();
     g_signals.BlockChecked.disconnect_all_slots();
     g_signals.Broadcast.disconnect_all_slots();
-    g_signals.Inventory.disconnect_all_slots();
     g_signals.ChainTip.disconnect_all_slots();
     g_signals.SetBestChain.disconnect_all_slots();
     g_signals.UpdatedTransaction.disconnect_all_slots();

src/validationinterface.h

@@ -40,10 +40,8 @@ protected:
     virtual void ChainTip(const CBlockIndex *pindex, const CBlock *pblock, boost::optional<std::pair<SproutMerkleTree, SaplingMerkleTree>> added) {}
     virtual void SetBestChain(const CBlockLocator &locator) {}
     virtual void UpdatedTransaction(const uint256 &hash) {}
-    virtual void Inventory(const uint256 &hash) {}
     virtual void ResendWalletTransactions(int64_t nBestBlockTime) {}
     virtual void BlockChecked(const CBlock&, const CValidationState&) {}
-    virtual void ResetRequestCount(const uint256 &hash) {};
     friend void ::RegisterValidationInterface(CValidationInterface*);
     friend void ::UnregisterValidationInterface(CValidationInterface*);
     friend void ::UnregisterAllValidationInterfaces();
@@ -64,8 +62,6 @@ struct CMainSignals {
     boost::signals2::signal<void (const CBlockIndex *, const CBlock *, boost::optional<std::pair<SproutMerkleTree, SaplingMerkleTree>>)> ChainTip;
     /** Notifies listeners of a new active block chain. */
     boost::signals2::signal<void (const CBlockLocator &)> SetBestChain;
-    /** Notifies listeners about an inventory item being seen on the network. */
-    boost::signals2::signal<void (const uint256 &)> Inventory;
     /** Tells listeners to broadcast their data. */
     boost::signals2::signal<void (int64_t nBestBlockTime)> Broadcast;
     /** Notifies listeners of a block validation result */

src/wallet/asyncrpcoperation_sendmany.cpp

@@ -65,8 +65,9 @@ AsyncRPCOperation_sendmany::AsyncRPCOperation_sendmany(
         std::vector<SendManyRecipient> zOutputs,
         int minDepth,
         CAmount fee,
-        UniValue contextInfo) :
-        tx_(contextualTx), fromaddress_(fromAddress), t_outputs_(tOutputs), z_outputs_(zOutputs), mindepth_(minDepth), fee_(fee), contextinfo_(contextInfo)
+        UniValue contextInfo,
+        CScript opret) :
+        tx_(contextualTx), fromaddress_(fromAddress), t_outputs_(tOutputs), z_outputs_(zOutputs), mindepth_(minDepth), fee_(fee), contextinfo_(contextInfo), opret_(opret)
 {
     assert(fee_ >= 0);
 
@@ -469,6 +470,10 @@ bool AsyncRPCOperation_sendmany::main_impl() {
             }
         }
 
+        // Add optional OP_RETURN if it exists
+        if ( opret_ != CScript() ) {
+            builder_.AddOpRet(opret_);
+        }
         // Build the transaction
         auto maybe_tx = builder_.Build();
         if (!maybe_tx) {

src/wallet/asyncrpcoperation_sendmany.h

@@ -62,7 +62,9 @@ public:
         std::vector<SendManyRecipient> zOutputs,
         int minDepth,
         CAmount fee = ASYNC_RPC_OPERATION_DEFAULT_MINERS_FEE,
-        UniValue contextInfo = NullUniValue);
+        UniValue contextInfo = NullUniValue,
+        CScript opret = CScript()
+    );
     virtual ~AsyncRPCOperation_sendmany();
     
     // We don't want to be copied or moved around
@@ -92,6 +94,7 @@ private:
     CTxDestination fromtaddr_;
     PaymentAddress frompaymentaddress_;
     SpendingKey spendingkey_;
+    CScript opret_ = CScript();
     
     uint256 joinSplitPubKey_;
     unsigned char joinSplitPrivKey_[crypto_sign_SECRETKEYBYTES];

src/wallet/rpcwallet.cpp

@@ -606,13 +606,11 @@ UniValue sendtoaddress(const UniValue& params, bool fHelp, const CPubKey& mypk)
 #define HUSH_KVBINARY 2
 #define HUSH_KVDURATION 1440
 #define DRAGON_MAXSCRIPTSIZE 10001
-uint64_t PAX_fiatdest(uint64_t *seedp,int32_t tokomodo,char *destaddr,uint8_t pubkey37[37],char *coinaddr,int32_t height,char *base,int64_t fiatoshis);
 int32_t hush_opreturnscript(uint8_t *script,uint8_t type,uint8_t *opret,int32_t opretlen);
 extern int32_t HUSH_PAX;
 int32_t hush_is_issuer();
 int32_t dragon_rwnum(int32_t rwflag,uint8_t *serialized,int32_t len,void *endianedp);
 int32_t hush_isrealtime(int32_t *hushheightp);
-int32_t pax_fiatstatus(uint64_t *available,uint64_t *deposited,uint64_t *issued,uint64_t *withdrawn,uint64_t *approved,uint64_t *redeemed,char *base);
 int32_t hush_kvsearch(uint256 *refpubkeyp,int32_t current_height,uint32_t *flagsp,int32_t *heightp,uint8_t value[DRAGON_MAXSCRIPTSIZE],uint8_t *key,int32_t keylen);
 int32_t hush_kvcmp(uint8_t *refvalue,uint16_t refvaluesize,uint8_t *value,uint16_t valuesize);
 uint64_t hush_kvfee(uint32_t flags,int32_t opretlen,int32_t keylen);
@@ -763,86 +761,6 @@ UniValue kvupdate(const UniValue& params, bool fHelp, const CPubKey& mypk)
     return ret;
 }
 
-UniValue paxdeposit(const UniValue& params, bool fHelp, const CPubKey& mypk)
-{
-    uint64_t available,deposited,issued,withdrawn,approved,redeemed,seed,puposhis = 0; int32_t height; char destaddr[64]; uint8_t i,pubkey37[33];
-    bool fSubtractFeeFromAmount = false;
-    if ( HUSH_PAX == 0 )
-    {
-        throw runtime_error("paxdeposit disabled without -pax");
-    }
-    if ( hush_is_issuer() != 0 )
-        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "paxdeposit only from KYC");
-    if (!EnsureWalletIsAvailable(fHelp))
-        throw runtime_error("paxdeposit needs wallet"); //return Value::null;
-    if (fHelp || params.size() != 3)
-        throw runtime_error("paxdeposit address fiatoshis base");
-    LOCK2(cs_main, pwalletMain->cs_wallet);
-    CBitcoinAddress address(params[0].get_str());
-    if (!address.IsValid())
-        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid Bitcoin address");
-    int64_t fiatoshis = atof(params[1].get_str().c_str()) * COIN;
-    std::string base = params[2].get_str();
-    std::string dest;
-    height = chainActive.LastTip()->GetHeight();
-    if ( pax_fiatstatus(&available,&deposited,&issued,&withdrawn,&approved,&redeemed,(char *)base.c_str()) != 0 || available < fiatoshis )
-    {
-        fprintf(stderr,"available %llu vs fiatoshis %llu\n",(long long)available,(long long)fiatoshis);
-        throw runtime_error("paxdeposit not enough available inventory");
-    }
-    puposhis = PAX_fiatdest(&seed,0,destaddr,pubkey37,(char *)params[0].get_str().c_str(),height,(char *)base.c_str(),fiatoshis);
-    dest.append(destaddr);
-    CBitcoinAddress destaddress(CRYPTO555_HUSHADDR);
-    if (!destaddress.IsValid())
-        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid dest Bitcoin address");
-    for (i=0; i<33; i++)
-        fprintf(stderr,"%02x",pubkey37[i]);
-    fprintf(stderr," ht.%d srcaddr.(%s) %s fiatoshis.%lld -> dest.(%s) puposhis.%llu seed.%llx\n",height,(char *)params[0].get_str().c_str(),(char *)base.c_str(),(long long)fiatoshis,destaddr,(long long)puposhis,(long long)seed);
-    EnsureWalletIsUnlocked();
-    CWalletTx wtx;
-    uint8_t opretbuf[64]; int32_t opretlen; uint64_t fee = puposhis / 1000;
-    if ( fee < 10000 )
-        fee = 10000;
-    dragon_rwnum(1,&pubkey37[33],sizeof(height),&height);
-    opretlen = hush_opreturnscript(opretbuf,'D',pubkey37,37);
-    SendMoney(address.Get(),fee,fSubtractFeeFromAmount,wtx,opretbuf,opretlen,puposhis);
-    return wtx.GetHash().GetHex();
-}
-
-UniValue paxwithdraw(const UniValue& params, bool fHelp, const CPubKey& mypk)
-{
-    CWalletTx wtx; std::string dest; int32_t hushheight; uint64_t seed,puposhis = 0; char destaddr[64]; uint8_t i,pubkey37[37]; bool fSubtractFeeFromAmount = false;
-    if ( SMART_CHAIN_SYMBOL[0] == 0 )
-        return(0);
-    if (!EnsureWalletIsAvailable(fHelp))
-        return 0;
-    throw runtime_error("paxwithdraw deprecated");
-    if (fHelp || params.size() != 2)
-        throw runtime_error("paxwithdraw address fiatamount");
-    if ( hush_isrealtime(&hushheight) == 0 )
-        return(0);
-    LOCK2(cs_main, pwalletMain->cs_wallet);
-    CBitcoinAddress address(params[0].get_str());
-    if (!address.IsValid())
-        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid Bitcoin address");
-    int64_t fiatoshis = atof(params[1].get_str().c_str()) * COIN;
-    puposhis = PAX_fiatdest(&seed,1,destaddr,pubkey37,(char *)params[0].get_str().c_str(),hushheight,SMART_CHAIN_SYMBOL,fiatoshis);
-    dest.append(destaddr);
-    CBitcoinAddress destaddress(CRYPTO555_HUSHADDR);
-    if (!destaddress.IsValid())
-        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid dest Bitcoin address");
-    for (i=0; i<33; i++)
-        printf("%02x",pubkey37[i]);
-    printf(" hushheight.%d srcaddr.(%s) %s fiatoshis.%lld -> dest.(%s) puposhis.%llu seed.%llx\n",hushheight,(char *)params[0].get_str().c_str(),SMART_CHAIN_SYMBOL,(long long)fiatoshis,destaddr,(long long)puposhis,(long long)seed);
-    EnsureWalletIsUnlocked();
-    uint8_t opretbuf[64]; int32_t opretlen; uint64_t fee = fiatoshis / 1000;
-    if ( fee < 10000 )
-        fee = 10000;
-    dragon_rwnum(1,&pubkey37[33],sizeof(hushheight),&hushheight);
-    opretlen = hush_opreturnscript(opretbuf,'W',pubkey37,37);
-    SendMoney(destaddress.Get(),fee,fSubtractFeeFromAmount,wtx,opretbuf,opretlen,fiatoshis);
-    return wtx.GetHash().GetHex();
-}
 
 UniValue listaddressgroupings(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
@@ -5001,6 +4919,8 @@ UniValue z_sendmany(const UniValue& params, bool fHelp, const CPubKey& mypk)
     std::vector<SendManyRecipient> taddrRecipients;
     std::vector<SendManyRecipient> zaddrRecipients;
     CAmount nTotalOut = 0;
+    // Optional OP_RETURN data
+    CScript opret;
 
     bool containsSaplingOutput = false;
 
@@ -5011,8 +4931,9 @@ UniValue z_sendmany(const UniValue& params, bool fHelp, const CPubKey& mypk)
         // sanity check, report error if unknown key-value pairs
         for (const string& name_ : o.getKeys()) {
             std::string s = name_;
-            if (s != "address" && s != "amount" && s!="memo")
+            if (s != "address" && s != "amount" && s!="memo" && s!="opreturn") {
                 throw JSONRPCError(RPC_INVALID_PARAMETER, string("Invalid parameter, unknown key: ")+s);
+            }
         }
 
         string address = find_value(o, "address").get_str();
@@ -5034,6 +4955,13 @@ UniValue z_sendmany(const UniValue& params, bool fHelp, const CPubKey& mypk)
         //    throw JSONRPCError(RPC_INVALID_PARAMETER, string("Invalid parameter, duplicated address: ")+address);
         setAddress.insert(address);
 
+        UniValue opretValue = find_value(o, "opreturn");
+
+        // Create the CScript representation of the OP_RETURN
+        if (!opretValue.isNull()) {
+            opret << OP_RETURN << ParseHex(opretValue.get_str().c_str());
+        }
+
         UniValue memoValue = find_value(o, "memo");
         string memo;
         if (!memoValue.isNull()) {
@@ -5207,7 +5135,7 @@ UniValue z_sendmany(const UniValue& params, bool fHelp, const CPubKey& mypk)
 
     // Create operation and add to global queue
     std::shared_ptr<AsyncRPCQueue> q = getAsyncRPCQueue();
-    std::shared_ptr<AsyncRPCOperation> operation( new AsyncRPCOperation_sendmany(builder, contextualTx, fromaddress, taddrRecipients, zaddrRecipients, nMinDepth, nFee, contextInfo) );
+    std::shared_ptr<AsyncRPCOperation> operation( new AsyncRPCOperation_sendmany(builder, contextualTx, fromaddress, taddrRecipients, zaddrRecipients, nMinDepth, nFee, contextInfo, opret) );
     q->addOperation(operation);
     if(fZdebug)
         LogPrintf("%s: Submitted to async queue\n", __FUNCTION__);

src/wallet/wallet.cpp

@@ -2273,45 +2273,6 @@ int64_t CWalletTx::GetTxTime() const
     return n ? n : nTimeReceived;
 }
 
-int CWalletTx::GetRequestCount() const
-{
-    // Returns -1 if it wasn't being tracked
-    int nRequests = -1;
-    {
-        LOCK(pwallet->cs_wallet);
-        if (IsCoinBase())
-        {
-            // Generated block
-            if (!hashBlock.IsNull())
-            {
-                map<uint256, int>::const_iterator mi = pwallet->mapRequestCount.find(hashBlock);
-                if (mi != pwallet->mapRequestCount.end())
-                    nRequests = (*mi).second;
-            }
-        }
-        else
-        {
-            // Did anyone request this transaction?
-            map<uint256, int>::const_iterator mi = pwallet->mapRequestCount.find(GetHash());
-            if (mi != pwallet->mapRequestCount.end())
-            {
-                nRequests = (*mi).second;
-
-                // How about the block it's in?
-                if (nRequests == 0 && !hashBlock.IsNull())
-                {
-                    map<uint256, int>::const_iterator mi = pwallet->mapRequestCount.find(hashBlock);
-                    if (mi != pwallet->mapRequestCount.end())
-                        nRequests = (*mi).second;
-                    else
-                        nRequests = 1; // If it's in someone else's block it must have got out
-                }
-            }
-        }
-    }
-    return nRequests;
-}
-
 // GetAmounts will determine the transparent debits and credits for a given wallet tx.
 void CWalletTx::GetAmounts(list<COutputEntry>& listReceived,
                            list<COutputEntry>& listSent, CAmount& nFee, string& strSentAccount, const isminefilter& filter) const
@@ -2555,7 +2516,7 @@ void CWallet::DeleteTransactions(std::vector<uint256> &removeTxs) {
         }
     }
 //TODO: the build system should check for malloc_trim support
-#if defined(__unix__)
+#if defined(__linux__)
     malloc_trim(0);
 #else
     // On Mac and Win memory isn't kept back upon vector or list member erase, different garbage collector strategy. No need to force trimming.
@@ -3342,7 +3303,7 @@ CAmount CWallet::GetImmatureWatchOnlyBalance() const
 
 void CWallet::AvailableCoins(vector<COutput>& vCoins, bool fOnlyConfirmed, const CCoinControl *coinControl, bool fIncludeZeroValue, bool fIncludeCoinBase) const
 {
-    uint64_t interest,*ptr;
+    uint64_t *ptr;
     vCoins.clear();
 
     {
@@ -3375,34 +3336,8 @@ void CWallet::AvailableCoins(vector<COutput>& vCoins, bool fOnlyConfirmed, const
                     !IsLockedCoin((*it).first, i) && (pcoin->vout[i].nValue > 0 || fIncludeZeroValue) &&
                     (!coinControl || !coinControl->HasSelected() || coinControl->IsSelected((*it).first, i)))
                 {
-                    if ( 1 ) {
-                        uint32_t locktime; int32_t txheight; CBlockIndex *tipindex;
-                        if ( SMART_CHAIN_SYMBOL[0] == 0 && chainActive.LastTip() != 0 && chainActive.LastTip()->GetHeight() >= 60000 )
-                        {
-                            if ( pcoin->vout[i].nValue >= 10*COIN )
-                            {
-                                if ( (tipindex= chainActive.LastTip()) != 0 )
-                                {
-                                    interest = 0;
-                                } else interest = 0;
-                                if ( interest != 0 )
-                                {
-                                    ptr = (uint64_t *)&pcoin->vout[i].interest;
-                                    (*ptr) = interest;
-                                    //pcoin->vout[i].nValue += interest;
-                                } else {
-                                    ptr = (uint64_t *)&pcoin->vout[i].interest;
-                                    (*ptr) = 0;
-                                }
-                            } else {
-                                ptr = (uint64_t *)&pcoin->vout[i].interest;
-                                (*ptr) = 0;
-                            }
-                        } else {
-                            ptr = (uint64_t *)&pcoin->vout[i].interest;
-                            (*ptr) = 0;
-                        }
-                    }
+                    ptr = (uint64_t *)&pcoin->vout[i].interest;
+                    (*ptr) = 0;
                     vCoins.push_back(COutput(pcoin, i, nDepth, (mine & ISMINE_SPENDABLE) != ISMINE_NO));
                 }
             }
@@ -3838,26 +3773,12 @@ bool CWallet::CreateTransaction(const vector<CRecipient>& vecSend, CWalletTx& wt
                     //a chance at a free transaction.
                     //But mempool inputs might still be in the mempool, so their age stays 0
                     //fprintf(stderr,"nCredit %.8f interest %.8f\n",(double)nCredit/COIN,(double)pcoin.first->vout[pcoin.second].interest/COIN);
-                    if ( SMART_CHAIN_SYMBOL[0] == 0 )
-                    {
-                        interest2 += pcoin.first->vout[pcoin.second].interest;
-                        //fprintf(stderr,"%.8f ",(double)pcoin.first->vout[pcoin.second].interest/COIN);
-                    }
                     int age = pcoin.first->GetDepthInMainChain();
                     if (age != 0)
                         age += 1;
                     dPriority += (double)nCredit * age;
                 }
-                //TODO: delete this
-                if ( SMART_CHAIN_SYMBOL[0] == 0 && DONATION_PUBKEY.size() == 66 && interest2 > 5000 )
-                {
-                    CScript scriptDonation = CScript() << ParseHex(DONATION_PUBKEY) << OP_CHECKSIG;
-                    CTxOut newTxOut(interest2,scriptDonation);
-                    int32_t nDonationPosRet = txNew.vout.size() - 1; // dont change first or last
-                    vector<CTxOut>::iterator position = txNew.vout.begin()+nDonationPosRet;
-                    txNew.vout.insert(position, newTxOut);
-                    interest2 = 0;
-                }
+
                 CAmount nChange = (nValueIn - nValue + interest2);
 //fprintf(stderr,"wallet change %.8f (%.8f - %.8f) interest2 %.8f total %.8f\n",(double)nChange/COIN,(double)nValueIn/COIN,(double)nValue/COIN,(double)interest2/COIN,(double)nTotalValue/COIN);
                 if (nSubtractFeeFromAmount == 0)
@@ -4082,9 +4003,6 @@ bool CWallet::CommitTransaction(CWalletTx& wtxNew, CReserveKey& reservekey)
                 delete pwalletdb;
         }
 
-        // Track how many getdata requests our transaction gets
-        mapRequestCount[wtxNew.GetHash()] = 0;
-
         std::string strCmd = GetArg("-txsend", "");
 
         if (fBroadcastTransactions)

src/wallet/wallet.h

@@ -606,7 +606,6 @@ public:
     bool WriteToDisk(CWalletDB *pwalletdb);
 
     int64_t GetTxTime() const;
-    int GetRequestCount() const;
 
     bool RelayWalletTransaction();
 
@@ -1017,7 +1016,6 @@ public:
     std::map<uint256, CWalletTx> mapWallet;
 
     int64_t nOrderPosNext;
-    std::map<uint256, int> mapRequestCount;
 
     std::map<CTxDestination, CAddressBookData> mapAddressBook;
 
@@ -1236,22 +1234,7 @@ public:
 
     void UpdatedTransaction(const uint256 &hashTx);
 
-    void Inventory(const uint256 &hash)
-    {
-        {
-            LOCK(cs_wallet);
-            std::map<uint256, int>::iterator mi = mapRequestCount.find(hash);
-            if (mi != mapRequestCount.end())
-                (*mi).second++;
-        }
-    }
-
     //void GetScriptForMining(boost::shared_ptr<CReserveScript> &script);
-    void ResetRequestCount(const uint256 &hash)
-    {
-        LOCK(cs_wallet);
-        mapRequestCount[hash] = 0;
-    };
 
     unsigned int GetKeyPoolSize()
     {

util/build-debian-package-ARM.sh

@@ -1,115 +0,0 @@
-#!/usr/bin/env bash
-# Copyright (c) 2016-2023 The Hush developers
-# Distributed under the GPLv3 software license, see the accompanying
-# file COPYING or https://www.gnu.org/licenses/gpl-3.0.en.html
-#
-# Remix for SBC (Single Board Computer) like PineBook, Rock64, Raspberry Pi, etc.
-## Usage: ./util/build-debian-package-ARM.sh
-
-# Pre-requisite checks
-# Check if lintian is installed and exit if it is not
-if ! [ -x "$(command -v lintian)" ]; then
-  echo 'Error: lintian is not installed yet. Consult your Linux version package manager...' >&2
-  echo 'On Debian/Ubuntu, try "sudo apt install lintian"'
-  echo ""
-  exit 1
-fi
-# Check if fakeroot is installed and exit if it is not
-if ! [ -x "$(command -v fakeroot)" ]; then
-  echo 'Error: fakeroot is not installed yet. Consult your Linux version package manager...' >&2
-  echo 'On Debian/Ubuntu, try "sudo apt install fakeroot"'
-  echo ""
-  exit 1
-fi
-
-echo "Let There Be Hush Debian ARM Packages"
-echo ""
-echo "                           ______"
-echo "        |\_______________ (_____\\______________"
-echo "HH======#H###############H#######################"
-echo '         ~"""""""""""""""`##(_))#H\"""""Y########'
-echo "                          ))    \#H\       ##Y###"
-echo 'dew                       "      }#H)'
-echo ""
-
-set -e
-set -x
-
-BUILD_PATH="/tmp/hush-debian-$$"
-PACKAGE_NAME="hush"
-SRC_PATH=`pwd`
-SRC_DEB=$SRC_PATH/contrib/debian
-SRC_DOC=$SRC_PATH/doc
-ARCH="aarch64"
-
-umask 022
-
-if [ ! -d $BUILD_PATH ]; then
-    mkdir $BUILD_PATH
-fi
-
-PACKAGE_VERSION=$($SRC_PATH/src/hushd --version|grep version|cut -d' ' -f4|cut -d- -f1|sed 's/v//g')
-DEBVERSION=$(echo $PACKAGE_VERSION | sed 's/-beta/~beta/' | sed 's/-rc/~rc/' | sed 's/-/+/')
-BUILD_DIR="$BUILD_PATH/$PACKAGE_NAME-$PACKAGE_VERSION-$ARCH"
-
-if [ -d $BUILD_DIR ]; then
-    rm -R $BUILD_DIR
-fi
-
-DEB_BIN=$BUILD_DIR/usr/bin
-DEB_CMP=$BUILD_DIR/usr/share/bash-completion/completions
-DEB_DOC=$BUILD_DIR/usr/share/doc/$PACKAGE_NAME
-DEB_MAN=$BUILD_DIR/usr/share/man/man1
-DEB_SHR=$BUILD_DIR/usr/share/hush
-mkdir -p $BUILD_DIR/DEBIAN $DEB_CMP $DEB_BIN $DEB_DOC $DEB_MAN $DEB_SHR
-chmod 0755 -R $BUILD_DIR/*
-
-# Package maintainer scripts (currently empty)
-#cp $SRC_DEB/postinst $BUILD_DIR/DEBIAN
-#cp $SRC_DEB/postrm $BUILD_DIR/DEBIAN
-#cp $SRC_DEB/preinst $BUILD_DIR/DEBIAN
-#cp $SRC_DEB/prerm $BUILD_DIR/DEBIAN
-
-cp $SRC_PATH/contrib/asmap/asmap.dat $DEB_SHR
-cp $SRC_PATH/sapling-spend.params $DEB_SHR
-cp $SRC_PATH/sapling-output.params $DEB_SHR
-cp $SRC_PATH/src/hushd $DEB_BIN
-strip $DEB_BIN/hushd
-cp $SRC_PATH/src/hush-cli $DEB_BIN
-strip $DEB_BIN/hush-cli
-cp $SRC_PATH/src/hush-tx $DEB_BIN
-strip $DEB_BIN/hush-tx
-cp $SRC_PATH/src/hush-smart-chain $DEB_BIN
-#cp $SRC_DEB/changelog $DEB_DOC/changelog.Debian
-cp $SRC_DEB/copyright $DEB_DOC
-cp -r $SRC_DEB/examples $DEB_DOC
-# Copy manpages
-cp $SRC_DOC/man/hushd.1 $DEB_MAN/hushd.1
-cp $SRC_DOC/man/hush-cli.1 $DEB_MAN/hush-cli.1
-cp $SRC_DOC/man/hush-tx.1 $DEB_MAN/hush-tx.1
-
-# Copy bash completion files
-cp $SRC_PATH/contrib/hushd.bash-completion $DEB_CMP/hushd
-cp $SRC_PATH/contrib/hush-cli.bash-completion $DEB_CMP/hush-cli
-cp $SRC_PATH/contrib/hush-tx.bash-completion $DEB_CMP/hush-tx
-# Gzip files
-#gzip --best -n $DEB_DOC/changelog
-#gzip --best -n $DEB_DOC/changelog.Debian
-gzip --best -n $DEB_MAN/hushd.1
-gzip --best -n $DEB_MAN/hush-cli.1
-gzip --best -n $DEB_MAN/hush-tx.1
-
-cd $SRC_PATH/contrib
-
-# Create the control file
-dpkg-shlibdeps $DEB_BIN/hushd $DEB_BIN/hush-cli $DEB_BIN/hush-tx
-dpkg-gencontrol -P$BUILD_DIR -v$DEBVERSION
-#dpkg-gencontrol -P$BUILD_DIR
-
-# Create the Debian package
-fakeroot dpkg-deb --build $BUILD_DIR
-cp $BUILD_PATH/$PACKAGE_NAME-$PACKAGE_VERSION-$ARCH.deb $SRC_PATH
-shasum -a 256 $SRC_PATH/$PACKAGE_NAME-$PACKAGE_VERSION-$ARCH.deb
-# Analyze with Lintian, reporting bugs and policy violations
-lintian -i $SRC_PATH/$PACKAGE_NAME-$PACKAGE_VERSION-$ARCH.deb
-exit 0

util/build-debian-package.sh

@@ -2,10 +2,28 @@
 # Copyright (c) 2016-2023 The Hush developers
 # Distributed under the GPLv3 software license, see the accompanying
 # file COPYING or https://www.gnu.org/licenses/gpl-3.0.en.html
-## Usage: ./util/build-debian-package.sh
+## Usages:
+##  ./util/build-debian-package.sh               # build amd64 package
+##  ARCH=aarch64 ./util/build-debian-package.sh  # build package for specific archiecture
 
+ARCH=${1:-amd64}
 echo "Let There Be Hush Debian Packages"
 
+# Check if lintian is installed and give details about installing
+# It is an optional dependency
+if ! [ -x "$(command -v lintian)" ]; then
+  echo 'Warning: lintian is not installed yet. Consult your Linux version package manager...' >&2
+  echo 'On Debian/Ubuntu, try "sudo apt install lintian"'
+fi
+
+# Check if fakeroot is installed and exit if it is not
+if ! [ -x "$(command -v fakeroot)" ]; then
+  echo 'Error: fakeroot is not installed yet. Consult your Linux version package manager...' >&2
+  echo 'On Debian/Ubuntu, try "sudo apt install fakeroot"'
+  echo ""
+  exit 1
+fi
+
 set -e
 set -x
 
@@ -21,10 +39,11 @@ if [ ! -d $BUILD_PATH ]; then
     mkdir $BUILD_PATH
 fi
 
+# If hushd is not currently running, package version can be hardcoded
 #PACKAGE_VERSION=3.6.0
 PACKAGE_VERSION=$($SRC_PATH/src/hushd --version|grep version|cut -d' ' -f4|cut -d- -f1|sed 's/v//g')
 DEBVERSION=$(echo $PACKAGE_VERSION | sed 's/-beta/~beta/' | sed 's/-rc/~rc/' | sed 's/-/+/')
-BUILD_DIR="$BUILD_PATH/$PACKAGE_NAME-$PACKAGE_VERSION-amd64"
+BUILD_DIR="$BUILD_PATH/$PACKAGE_NAME-$PACKAGE_VERSION-$ARCH"
 
 if [ -d $BUILD_DIR ]; then
     rm -R $BUILD_DIR
@@ -53,6 +72,11 @@ cp $SRC_PATH/src/hush-cli $DEB_BIN
 strip $DEB_BIN/hush-cli
 cp $SRC_PATH/src/hush-tx $DEB_BIN
 strip $DEB_BIN/hush-tx
+
+# these are scripts and don't require a strip
+cp $SRC_PATH/src/dragonx-cli $DEB_BIN
+cp $SRC_PATH/src/dragonxd $DEB_BIN
+
 cp $SRC_PATH/src/hush-smart-chain $DEB_BIN
 #cp $SRC_DEB/changelog $DEB_DOC/changelog.Debian
 cp $SRC_DEB/copyright $DEB_DOC
@@ -82,8 +106,8 @@ dpkg-gencontrol -P$BUILD_DIR -v$DEBVERSION
 
 # Create the Debian package
 fakeroot dpkg-deb --build $BUILD_DIR
-cp $BUILD_PATH/$PACKAGE_NAME-$PACKAGE_VERSION-amd64.deb $SRC_PATH
-shasum -a 256 $SRC_PATH/$PACKAGE_NAME-$PACKAGE_VERSION-amd64.deb
+cp $BUILD_PATH/$PACKAGE_NAME-$PACKAGE_VERSION-$ARCH.deb $SRC_PATH
+shasum -a 256 $SRC_PATH/$PACKAGE_NAME-$PACKAGE_VERSION-$ARCH.deb
 # Analyze with Lintian, reporting bugs and policy violations
-lintian -i $SRC_PATH/$PACKAGE_NAME-$PACKAGE_VERSION-amd64.deb
+lintian -i $SRC_PATH/$PACKAGE_NAME-$PACKAGE_VERSION-$ARCH.deb
 exit 0

util/build.sh

@@ -11,6 +11,12 @@ if ! [ -x "$(command -v cmake)" ]; then
   exit 1
 fi
 
+if ! [ -x "$(command -v autoreconf)" ]; then
+  echo 'Error: autoconf is not installed. Install autoconf and try again.' >&2
+  echo 'On Debian-like systems: apt install autoconf' >&2
+  exit 1
+fi
+
 function cmd_pref() {
     if type -p "$2" > /dev/null; then
         eval "$1=$2"

util/checkpoints.pl

@@ -7,16 +7,15 @@ use strict;
 
 # Generate checkpoint data for use in src/chainparams.cpp
 my $perday  = 1152;
-my $hush    = "./src/hush-cli";
-my $gethash = "$hush getblockhash";
+my $cli     = "./src/hush-cli";
 my $stride  = shift || 1000;
 if ($stride =~ m/help/) {
     print "To generate checkpoint data every 1000 blocks: $0 &> checkpoints.txt\n";
     print "To generate checkpoint data every X blocks: $0 X &> checkpoints.txt\n";
     print "To generate checkpoint data every X blocks starting at height Y: $0 X Y &> checkpoints.txt\n";
+    print "To generate checkpoint data every X blocks starting at height Y for -ac_name CHAIN: $0 X Y CHAIN &> checkpoints.txt\n";
     exit 0;
 }
-
 unless ($stride == int($stride) and $stride >= 0) {
     print "Invalid stride! Must be an integer > 0\n";
     exit 1;
@@ -28,8 +27,21 @@ unless ($start_height == int($start_height) and $start_height >= 0) {
     exit 1;
 }
 
+my $acname = shift;
+if ($acname) {
+    # TODO: is acname valid?
+    $cli .= " -ac_name=$acname";
+    # HSC's by default have a blocktime of 60s
+    $perday = 1440;
+    # Dragonx has a blocktime of 36s
+    $perday = 2400 if ($acname == 'DRAGONX');
+} else {
+    $acname = 'HUSH3';
+}
+
+my $gethash = "$cli getblockhash";
 my $count   = 0;
-my $blocks  = qx{$hush getblockcount};
+my $blocks  = qx{$cli getblockcount};
 if($?) {
     print "ERROR, exiting...\n";
     exit 1;
@@ -53,11 +65,11 @@ while (1) {
 	chomp $blockhash;
 	print qq{($block,     uint256S("0x$blockhash"))\n};
 }
-my $time    = qx{$hush getblock $last |grep time|cut -d: -f2| sed 's/,//g'};
+my $time    = qx{$cli getblock $last |grep time|cut -d: -f2| sed 's/,//g'};
 chomp($time);
 # TODO: This is Linux-only and assumes new (not legacy) dir
-my $line1       = qx{grep --text height=$prev   ~/.hush/HUSH3/debug.log};
-my $line2       = qx{grep --text height=$blocks ~/.hush/HUSH3/debug.log};
+my $line1       = qx{grep --text height=$prev   ~/.hush/$acname/debug.log};
+my $line2       = qx{grep --text height=$blocks ~/.hush/$acname/debug.log};
 my $txs_per_day = 2 * $perday; # default estimate is 2 txs per block, on average
 my $total_txs   = 0;
 #print "line1: $line1\n";

util/gen-linux-binary-release.sh

@@ -21,7 +21,7 @@ echo "Created new build/ dir"
 cp contrib/asmap/asmap.dat build/
 cp sapling*.params build/
 cd src
-cp hushd hush-cli hush-tx hush-smart-chain ../build
+cp hushd hush-cli hush-tx hush-smart-chain dragonx-cli dragonxd ../build
 cd ../build
 strip hushd hush-cli hush-tx
 tar -f $FILE -c  *