diff --git a/configure.ac b/configure.ac index aa424d534..728795f41 100644 --- a/configure.ac +++ b/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))) diff --git a/contrib/sda_checkpoints.pl b/contrib/sda_checkpoints.pl new file mode 100644 index 000000000..ab468af86 --- /dev/null +++ b/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; +} diff --git a/contrib/seeds/nodes_main.txt b/contrib/seeds/nodes_main.txt index 9cd90fe9e..0d5e68fd4 100644 --- a/contrib/seeds/nodes_main.txt +++ b/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 diff --git a/depends/packages/boost.mk b/depends/packages/boost.mk index c925e52ef..fde0c92c3 100644 --- a/depends/packages/boost.mk +++ b/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) : \"$($(package)_cxxflags) $($(package)_cppflags)\" \"$($(package)_ldflags)\" \"$(boost_archiver_$(host_os))\" \"$(host_STRIP)\" \"$(host_RANLIB)\" \"$(host_WINDRES)\" : ;" > user-config.jam + echo "using $(boost_toolset_$(host_os)) : : $($(package)_cxx) : \"$($(package)_cxxflags) $($(package)_cppflags)\" \"$($(package)_ldflags)\" \"$(boost_archiver_$(host_os))\" \"$(host_STRIP)\" \"$(host_RANLIB)\" \"$(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 diff --git a/depends/packages/libcurl.mk b/depends/packages/libcurl.mk index ae2b07bd3..1ece9ce64 100644 --- a/depends/packages/libcurl.mk +++ b/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) diff --git a/depends/packages/libevent.mk b/depends/packages/libevent.mk index ffe6f7e79..b3881738a 100644 --- a/depends/packages/libevent.mk +++ b/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 diff --git a/depends/packages/rust.mk b/depends/packages/rust.mk index 6fbdda037..6bae892a2 100644 --- a/depends/packages/rust.mk +++ b/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 diff --git a/depends/patches/boost/fix-Solaris.patch b/depends/patches/boost/fix-Solaris.patch new file mode 100644 index 000000000..cb8006092 --- /dev/null +++ b/depends/patches/boost/fix-Solaris.patch @@ -0,0 +1,23 @@ +From 74fb0a26099bc51d717f5f154b37231ce7df3e98 Mon Sep 17 00:00:00 2001 +From: Rob Boehne +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; + #endif + size = ((size+page_size-1)/page_size)*page_size; diff --git a/depends/patches/libevent/detect-arch4random_addrandom-fix.patch b/depends/patches/libevent/detect-arch4random_addrandom-fix.patch new file mode 100644 index 000000000..69e55bf11 --- /dev/null +++ b/depends/patches/libevent/detect-arch4random_addrandom-fix.patch @@ -0,0 +1,43 @@ +From 266f43af7798befa3d27bfabaa9ae699259c3924 Mon Sep 17 00:00:00 2001 +From: Azat Khuzhin +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 diff --git a/depends/patches/libevent/detect-arch4random_addrandom.patch b/depends/patches/libevent/detect-arch4random_addrandom.patch new file mode 100644 index 000000000..f8f2b947d --- /dev/null +++ b/depends/patches/libevent/detect-arch4random_addrandom.patch @@ -0,0 +1,77 @@ +From 6541168d7037457b8e5c51cc354f11bd94e618b6 Mon Sep 17 00:00:00 2001 +From: Marek Sebera +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 + } diff --git a/doc/man/hush-cli.1 b/doc/man/hush-cli.1 index 235409cac..a82565e74 100644 --- a/doc/man/hush-cli.1 +++ b/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 . diff --git a/doc/man/hush-tx.1 b/doc/man/hush-tx.1 index 0d930a9a4..a4bc4033b 100644 --- a/doc/man/hush-tx.1 +++ b/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] [commands] diff --git a/doc/man/hushd.1 b/doc/man/hushd.1 index aad7da4d9..627c9c651 100644 --- a/doc/man/hushd.1 +++ b/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 . @@ -78,7 +78,7 @@ applied) .HP \fB\-par=\fR .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 diff --git a/doc/release-process.md b/doc/release-process.md index bd0d70633..93fec2434 100644 --- a/doc/release-process.md +++ b/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` diff --git a/doc/relnotes/README.md b/doc/relnotes/README.md index 39c56e213..294f3d299 100644 --- a/doc/relnotes/README.md +++ b/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" ``` diff --git a/src/RandomX/src/allocator.cpp b/src/RandomX/src/allocator.cpp index 4c6d86e05..6b48a7e70 100644 --- a/src/RandomX/src/allocator.cpp +++ b/src/RandomX/src/allocator.cpp @@ -50,11 +50,14 @@ namespace randomx { template struct AlignedAllocator; 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); }; -} \ No newline at end of file +} diff --git a/src/RandomX/src/intrin_portable.h b/src/RandomX/src/intrin_portable.h index 05f6cd33b..8c09ae885 100644 --- a/src/RandomX/src/intrin_portable.h +++ b/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 } diff --git a/src/RandomX/src/jit_compiler_a64.cpp b/src/RandomX/src/jit_compiler_a64.cpp index e45774e93..fc4634868 100644 --- a/src/RandomX/src/jit_compiler_a64.cpp +++ b/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); diff --git a/src/RandomX/src/jit_compiler_x86.cpp b/src/RandomX/src/jit_compiler_x86.cpp index e75f76328..5587e6afb 100644 --- a/src/RandomX/src/jit_compiler_x86.cpp +++ b/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); } diff --git a/src/RandomX/src/randomx.cpp b/src/RandomX/src/randomx.cpp index 7d239f6fa..7daaa46df 100644 --- a/src/RandomX/src/randomx.cpp +++ b/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; } diff --git a/src/RandomX/src/tests/utility.hpp b/src/RandomX/src/tests/utility.hpp index 92723b979..ceb33d9fd 100644 --- a/src/RandomX/src/tests/utility.hpp +++ b/src/RandomX/src/tests/utility.hpp @@ -32,6 +32,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #include #include +#include constexpr char hexmap[] = "0123456789abcdef"; inline void outputHex(std::ostream& os, const char* data, int length) { diff --git a/src/addrman.cpp b/src/addrman.cpp index 60f27347a..a832ffc4c 100644 --- a/src/addrman.cpp +++ b/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& 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()) { diff --git a/src/cc/CCMarmara.h b/src/cc/CCMarmara.h deleted file mode 100644 index 58b8072b6..000000000 --- a/src/cc/CCMarmara.h +++ /dev/null @@ -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 &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 diff --git a/src/cc/CCcustom.cpp b/src/cc/CCcustom.cpp index b463df52b..005fb1def 100644 --- a/src/cc/CCcustom.cpp +++ b/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 diff --git a/src/cc/assets.cpp b/src/cc/assets.cpp index ebc977dc0..d2ec4f21b 100644 --- a/src/cc/assets.cpp +++ b/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"); diff --git a/src/cc/import.cpp b/src/cc/import.cpp index bb88e8831..98cd3f30c 100644 --- a/src/cc/import.cpp +++ b/src/cc/import.cpp @@ -672,9 +672,6 @@ bool Eval::ImportCoin(const std::vector 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 diff --git a/src/chainparams.cpp b/src/chainparams.cpp index 6eb1368ff..ef7ab5d70 100644 --- a/src/chainparams.cpp +++ b/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 diff --git a/src/chainparamsseeds.h b/src/chainparamsseeds.h index 1fd92af93..54125e3c4 100644 --- a/src/chainparamsseeds.h +++ b/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 diff --git a/src/clientversion.h b/src/clientversion.h index 86489bafb..235661630 100644 --- a/src/clientversion.h +++ b/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 diff --git a/src/dragonx-cli.bat b/src/dragonx-cli.bat new file mode 100644 index 000000000..5edecfd8e --- /dev/null +++ b/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 diff --git a/src/dragonxd.bat b/src/dragonxd.bat new file mode 100644 index 000000000..0dc4fd2c9 --- /dev/null +++ b/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 diff --git a/src/httpserver.cpp b/src/httpserver.cpp index 59e35ddc9..700027419 100644 --- a/src/httpserver.cpp +++ b/src/httpserver.cpp @@ -37,6 +37,7 @@ #include // for to_lower() #include +#include #include /** HTTP request work item */ diff --git a/src/hush_bitcoind.h b/src/hush_bitcoind.h index 77ded63f8..b09c756ad 100644 --- a/src/hush_bitcoind.h +++ b/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 ) diff --git a/src/hush_gateway.h b/src/hush_gateway.h index 0002e69a9..8068b3259 100644 --- a/src/hush_gateway.h +++ b/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 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>>>>>> %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 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= 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= 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; diff --git a/src/hush_globals.h b/src/hush_globals.h index 9bfb59302..e307f774c 100644 --- a/src/hush_globals.h +++ b/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; diff --git a/src/hush_nSPV_superlite.h b/src/hush_nSPV_superlite.h index 84b6aa6cd..418957e57 100644 --- a/src/hush_nSPV_superlite.h +++ b/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); diff --git a/src/hush_nSPV_wallet.h b/src/hush_nSPV_wallet.h index da8038fb6..af098407d 100644 --- a/src/hush_nSPV_wallet.h +++ b/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 ) diff --git a/src/hush_pax.h b/src/hush_pax.h index 9289ce15d..029f6e31f 100644 --- a/src/hush_pax.h +++ b/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> 2) ) - return(0); - sum /= nonz; - lastprice = sum; - for (i=0; i (numvotes >> 1) ) - break; - } - } - } - } - if ( wt > (numvotes >> 1) ) - { - ind = i; - for (densum=sum=j=0; j= 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) diff --git a/src/init.cpp b/src/init.cpp index 3e5e85337..f49e146dd 100644 --- a/src/init.cpp +++ b/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; + } } } } diff --git a/src/main.cpp b/src/main.cpp index 220c0aa0b..2c037297b 100644 --- a/src/main.cpp +++ b/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= 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 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(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 vtxid; - mempool.queryHashes(vtxid); - vector 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) diff --git a/src/miner.cpp b/src/miner.cpp index f677d6b43..ee85a52eb 100644 --- a/src/miner.cpp +++ b/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(¬aryid,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); diff --git a/src/net.cpp b/src/net.cpp index e8f693c11..b460f3c37 100644 --- a/src/net.cpp +++ b/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 &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) diff --git a/src/net.h b/src/net.h index d89ecbc00..95e1c58f0 100644 --- a/src/net.h +++ b/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 m_addr_rate_limited{0}; + /** Total number of addresses that were processed (excludes rate limited ones). */ + std::atomic m_addr_processed{0}; + protected: // Denial-of-service detection/prevention @@ -462,7 +480,6 @@ public: // flood relay std::vector vAddrToSend; - CRollingBloomFilter addrKnown; bool fGetAddr; std::set 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 { diff --git a/src/pow.cpp b/src/pow.cpp index 260785860..9ac8ef80e 100644 --- a/src/pow.cpp +++ b/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(); } } diff --git a/src/protocol.cpp b/src/protocol.cpp index 5aa3a7dd6..326cb6193 100644 --- a/src/protocol.cpp +++ b/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, diff --git a/src/protocol.h b/src/protocol.h index 3cd06fc88..f91e5e70e 100644 --- a/src/protocol.h +++ b/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. diff --git a/src/rpc/blockchain.cpp b/src/rpc/blockchain.cpp index 1c34cd1b0..7bdf840da 100644 --- a/src/rpc/blockchain.cpp +++ b/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) diff --git a/src/rpc/client.cpp b/src/rpc/client.cpp index 9e9178f25..563864c12 100644 --- a/src/rpc/client.cpp +++ b/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 }, diff --git a/src/rpc/net.cpp b/src/rpc/net.cpp index 8e6c539f2..67812ddb6 100644 --- a/src/rpc/net.cpp +++ b/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); } diff --git a/src/rpc/server.cpp b/src/rpc/server.cpp index e81ad19e6..703cdc7b9 100644 --- a/src/rpc/server.cpp +++ b/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", ¬aries, true }, //{ "blockchain", "height_MoM", &height_MoM, true }, //{ "blockchain", "txMoMproof", &txMoMproof, true }, diff --git a/src/rpc/server.h b/src/rpc/server.h index 87b46610d..3bfc0654e 100644 --- a/src/rpc/server.h +++ b/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 diff --git a/src/stratum.cpp b/src/stratum.cpp index c4e2fc161..5d20e8a7c 100644 --- a/src/stratum.cpp +++ b/src/stratum.cpp @@ -123,10 +123,8 @@ namespace { // better to use anonymous namespace for helper routines if (mapMultiArgs.count("-stratumallowip")) { const std::vector& 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), diff --git a/src/txdb.cpp b/src/txdb.cpp index 1035f3070..dbba3654f 100644 --- a/src/txdb.cpp +++ b/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& 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 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 <imestamp) { +bool CBlockTreeDB::ReadTimestampBlockIndex(const uint256 &hash, unsigned int <imestamp) 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; diff --git a/src/txdb.h b/src/txdb.h index f96f73650..0b0ac376c 100644 --- a/src/txdb.h +++ b/src/txdb.h @@ -93,13 +93,13 @@ private: public: bool WriteBatchSync(const std::vector >& fileInfo, int nLastFile, const std::vector& blockinfo); bool EraseBatchSync(const std::vector& 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 > &list); - bool ReadSpentIndex(CSpentIndexKey &key, CSpentIndexValue &value); + bool ReadSpentIndex(CSpentIndexKey &key, CSpentIndexValue &value) const; bool UpdateSpentIndex(const std::vector >&vect); bool UpdateAddressUnspentIndex(const std::vector >&vect); bool ReadAddressUnspentIndex(uint160 addressHash, int type, @@ -112,9 +112,9 @@ public: bool WriteTimestampIndex(const CTimestampIndexKey ×tampIndex); bool ReadTimestampIndex(const unsigned int &high, const unsigned int &low, const bool fActiveOnly, std::vector > &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); diff --git a/src/util/string.h b/src/util/string.h index a10a59df7..13a6154a8 100644 --- a/src/util/string.h +++ b/src/util/string.h @@ -15,6 +15,7 @@ #include #include #include +#include [[nodiscard]] inline std::string TrimString(const std::string& str, const std::string& pattern = " \f\n\r\t\v") { diff --git a/src/validationinterface.cpp b/src/validationinterface.cpp index a5eb77e94..12cabfac5 100644 --- a/src/validationinterface.cpp +++ b/src/validationinterface.cpp @@ -16,6 +16,7 @@ #include #include +#include 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(); diff --git a/src/validationinterface.h b/src/validationinterface.h index 122976f51..e815b6d57 100644 --- a/src/validationinterface.h +++ b/src/validationinterface.h @@ -40,10 +40,8 @@ protected: virtual void ChainTip(const CBlockIndex *pindex, const CBlock *pblock, boost::optional> 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>)> ChainTip; /** Notifies listeners of a new active block chain. */ boost::signals2::signal SetBestChain; - /** Notifies listeners about an inventory item being seen on the network. */ - boost::signals2::signal Inventory; /** Tells listeners to broadcast their data. */ boost::signals2::signal Broadcast; /** Notifies listeners of a block validation result */ diff --git a/src/wallet/asyncrpcoperation_sendmany.cpp b/src/wallet/asyncrpcoperation_sendmany.cpp index b54a9b5de..d1573e02f 100644 --- a/src/wallet/asyncrpcoperation_sendmany.cpp +++ b/src/wallet/asyncrpcoperation_sendmany.cpp @@ -65,8 +65,9 @@ AsyncRPCOperation_sendmany::AsyncRPCOperation_sendmany( std::vector 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) { diff --git a/src/wallet/asyncrpcoperation_sendmany.h b/src/wallet/asyncrpcoperation_sendmany.h index 696cf1761..162680e20 100644 --- a/src/wallet/asyncrpcoperation_sendmany.h +++ b/src/wallet/asyncrpcoperation_sendmany.h @@ -62,7 +62,9 @@ public: std::vector 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]; diff --git a/src/wallet/rpcwallet.cpp b/src/wallet/rpcwallet.cpp index 97c89b97d..cdf16c695 100644 --- a/src/wallet/rpcwallet.cpp +++ b/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 taddrRecipients; std::vector 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 q = getAsyncRPCQueue(); - std::shared_ptr operation( new AsyncRPCOperation_sendmany(builder, contextualTx, fromaddress, taddrRecipients, zaddrRecipients, nMinDepth, nFee, contextInfo) ); + std::shared_ptr 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__); diff --git a/src/wallet/wallet.cpp b/src/wallet/wallet.cpp index faf98f8e2..96d01260d 100644 --- a/src/wallet/wallet.cpp +++ b/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::const_iterator mi = pwallet->mapRequestCount.find(hashBlock); - if (mi != pwallet->mapRequestCount.end()) - nRequests = (*mi).second; - } - } - else - { - // Did anyone request this transaction? - map::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::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& listReceived, list& listSent, CAmount& nFee, string& strSentAccount, const isminefilter& filter) const @@ -2555,7 +2516,7 @@ void CWallet::DeleteTransactions(std::vector &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& 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& 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& 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::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) diff --git a/src/wallet/wallet.h b/src/wallet/wallet.h index b6ee86a4d..c3c105b71 100644 --- a/src/wallet/wallet.h +++ b/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 mapWallet; int64_t nOrderPosNext; - std::map mapRequestCount; std::map mapAddressBook; @@ -1236,22 +1234,7 @@ public: void UpdatedTransaction(const uint256 &hashTx); - void Inventory(const uint256 &hash) - { - { - LOCK(cs_wallet); - std::map::iterator mi = mapRequestCount.find(hash); - if (mi != mapRequestCount.end()) - (*mi).second++; - } - } - //void GetScriptForMining(boost::shared_ptr &script); - void ResetRequestCount(const uint256 &hash) - { - LOCK(cs_wallet); - mapRequestCount[hash] = 0; - }; unsigned int GetKeyPoolSize() { diff --git a/util/build-debian-package-ARM.sh b/util/build-debian-package-ARM.sh deleted file mode 100755 index ebd6a71e8..000000000 --- a/util/build-debian-package-ARM.sh +++ /dev/null @@ -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 diff --git a/util/build-debian-package.sh b/util/build-debian-package.sh index ee4ce8a8c..11e9c1073 100755 --- a/util/build-debian-package.sh +++ b/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 diff --git a/util/build.sh b/util/build.sh index 4af38908f..3f45f1b59 100755 --- a/util/build.sh +++ b/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" diff --git a/util/checkpoints.pl b/util/checkpoints.pl index a79ba2753..153c2dcba 100755 --- a/util/checkpoints.pl +++ b/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"; diff --git a/util/gen-linux-binary-release.sh b/util/gen-linux-binary-release.sh index e4b9bf567..3a2b4e235 100755 --- a/util/gen-linux-binary-release.sh +++ b/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 *