diff --git a/.gitmodules b/.gitmodules
deleted file mode 100644
index e69de29bb..000000000
diff --git a/COPYING b/COPYING
index e2383446e..c8e0c34c2 100644
--- a/COPYING
+++ b/COPYING
@@ -1,4 +1,4 @@
-Copyright (c) 2018-2020 The Hush developers
+Copyright (c) 2018-2025 The Hush developers
Copyright (c) 2009-2017 The Bitcoin Core developers
Copyright (c) 2009-2018 Bitcoin Developers
Copyright (c) 2016-2017 The Zcash developers
diff --git a/DEVELOPER-AGREEMENT b/DEVELOPER-AGREEMENT
deleted file mode 100644
index 85d69b4f3..000000000
--- a/DEVELOPER-AGREEMENT
+++ /dev/null
@@ -1 +0,0 @@
-You must agree that Duke Leto is the Elder of jl777.
diff --git a/Dockerfile b/Dockerfile
index b011397d8..946cbbd88 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -25,7 +25,7 @@ RUN cd /hush && \
RUN ln -sf /hush/src/hushd /usr/bin/hushd && \
ln -sf /hush/src/hush-tx /usr/bin/hush-tx && \
ln -sf /hush/src/wallet-utility /usr/bin/hush-wallet-utility && \
- ln -sf /hush/src/hush-smart-chain /usr/bin/hush-smart-chain && \
+ ln -sf /hush/src/hush-arrakis-chain /usr/bin/hush-arrakis-chain && \
ln -sf /hush/util/docker-entrypoint.sh /usr/bin/entrypoint && \
ln -sf /hush/util/docker-hush-cli.sh /usr/bin/hush-cli
diff --git a/INSTALL-BIN.md b/INSTALL-BIN.md
deleted file mode 100644
index 38c8e5a7d..000000000
--- a/INSTALL-BIN.md
+++ /dev/null
@@ -1,11 +0,0 @@
-# Installing Hush binaries
-
-1. First [download the release](https://git.hush.is/hush/hush3/releases) you want to install. It will have a .deb file extension.
-
-1. Next install the Debian package (change the version to what you downloaded above):
-
- `dpkg -i hush-3.8.0-amd64.deb`
-
-1. If you want to remove it, then run this to uninstall:
-
- `apt-get remove hush`
diff --git a/INSTALL.md b/INSTALL.md
deleted file mode 100644
index 51edd9fdb..000000000
--- a/INSTALL.md
+++ /dev/null
@@ -1,122 +0,0 @@
-# Installing Hush
-
-Instructions to compile Hush yourself.
-
-## Swap Space (Optional)
-You will need at least 4GB of RAM to build hush from git source, OR you can
-enable a swap file. To enable a 4GB swap file on modern Linux distributions:
-
-```sh
-sudo fallocate -l 4G /swapfile
-sudo chmod 600 /swapfile
-sudo mkswap /swapfile
-sudo swapon /swapfile
-```
-
-## Build on Debian/Ubuntu:
-
-```sh
-# install build dependencies
-sudo apt-get install build-essential pkg-config libc6-dev m4 g++-multilib \
- autoconf libtool ncurses-dev unzip git zlib1g-dev wget \
- bsdmainutils automake curl unzip nano libsodium-dev cmake
-# clone git repo
-git clone https://git.hush.is/hush/hush3
-cd hush3
-# Build
-# This uses 3 build processes, you need 2GB of RAM for each.
-./build.sh -j3
-```
-
-## Build on Arch:
-
-```sh
-# install build dependencies
-sudo pacman -S gcc libsodium lib32-zlib unzip wget git python rust curl autoconf cmake
-# clone git repo
-git clone https://git.hush.is/hush/hush3
-cd hush3
-# Build
-# This uses 3 build processes, you need 2GB of RAM for each.
-./build.sh -j3
-```
-
-## Build on Fedora:
-
-```sh
-# install build dependencies
-sudo dnf install make automake gcc gcc-c++ kernel-devel cmake libtool ncurses-devel patch -y
-# clone git repo
-git clone https://git.hush.is/hush/hush3
-cd hush3
-# Build
-# This uses 3 build processes, you need 2GB of RAM for each.
-./build.sh -j3
-```
-
-### Building On Ubuntu 16.04 and older systems
-
-Some older compilers may not be able to compile modern code, such as gcc 5.4 which comes with Ubuntu 16.04 by default. Here is how to install gcc 7 on Ubuntu 16.04. Run these commands as root:
-
-```
-add-apt-repository ppa:ubuntu-toolchain-r/test && \
-apt update && \
-apt-get install -y gcc-7 g++-7 && \
- update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-7 60 && \
- update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-7 60
-```
-
-### Build on Mac
-
-These instructions are a work in progress. Please report issues to https://hush.is/tg_support
-
-```
-sudo port update
-sudo port upgrade outdated
-sudo port install qt5
-
-# clone git repo
-git clone https://git.hush.is/hush/hush3
-cd hush3
-# Build
-# This uses 3 build processes, you need 2GB of RAM for each.
-./build.sh -j3
-```
-
-## Run a HUSH Node
-
-After you have compiled Hush, then you can run it with the following command:
-
-```sh
-./src/hushd
-```
-
-## Windows (cross-compiled on Linux)
-Get dependencies:
-```ssh
-sudo apt-get install \
- build-essential pkg-config libc6-dev m4 g++-multilib \
- autoconf libtool ncurses-dev unzip git python \
- zlib1g-dev wget bsdmainutils automake mingw-w64 cmake libsodium-dev
-```
-
-Downloading Git source repo, building and running Hush:
-
-```sh
-# pull
-git clone https://git.hush.is/hush/hush3
-cd hush
-# Build
-./build-win.sh -j$(nproc)
-# Run a HUSH node
-./src/hushd
-```
-
-## ARM Architecture
-
-Currently, any ARMv7 machine will not be able to build this repo, because the
-underlying tech (zcash and the zksnark library) do not support that instruction
-set.
-
-This also means that old RaspberryPi devices will not work, unless they have a
-newer ARMv8-based Raspberry Pi. Raspberry Pi 4 and newer are known to work.
diff --git a/Makefile.am b/Makefile.am
index ace177a9d..216a1e1d0 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -235,7 +235,7 @@ endif
dist_bin_SCRIPTS =
dist_noinst_SCRIPTS = autogen.sh util/build-debian-package.sh util/build.sh
-EXTRA_DIST = $(top_srcdir)/share/genbuild.sh qa/pull-tester/rpc-tests.sh qa/pull-tester/run-bitcoin-cli qa/rpc-tests qa/hush $(DIST_DOCS) $(BIN_CHECKS)
+EXTRA_DIST = $(top_srcdir)/util/genbuild.sh qa/pull-tester/rpc-tests.sh qa/pull-tester/run-bitcoin-cli qa/rpc-tests qa/hush $(DIST_DOCS) $(BIN_CHECKS)
install-exec-hook:
echo "We no longer install fetch-params!"
diff --git a/README.md b/README.md
index 2a2bd9431..4a7cfd389 100644
--- a/README.md
+++ b/README.md
@@ -1,75 +1,197 @@
-# Hush
+
+ 
+
-## What is Hush?
+
-
+| Introduction | Install | Compile | FAQ | Documentation |
+| :---: | :---: | :---: | :---: | :---: |
+| [What is Hush?](#what-is-hush) | [Windows 10 - Video Tutorial](#install-on-windows-10) | [Build on Debian or Ubuntu](#build-on-debian-or-ubuntu) | [Where can I buy Hush?](#where-can-i-buy-hush) | [Cross compiling Windows binaries](#windows-cross-compiled-on-linux)
+| [Why not GitHub?](#banned-by-github) | [Build on Mac](#build-on-mac) | [Build on Arch](#build-on-arch) | [Can I mine with CPU or GPU?](#can-i-mine-with-cpu-or-gpu) | [Hush DevOps for pools and CEXs](https://git.hush.is/hush/docs/src/branch/master/advanced/devops.md)
+| [What is HushChat?](#what-is-hushchat) | [Debian and Ubuntu](#installing-hush-binaries) | [Build on Fedora](#build-on-fedora) | [Claiming funds from old Hush wallets](https://git.hush.is/hush/hush3/src/branch/master/doc/OLD_WALLETS.md) | [Earn Hush bounty](#earn-hush-bounty)
+| [What is SilentDagon?](#what-is-silentdagon) | [Raspberry Pi](#install-on-arm-architecture) | [Build on Ubuntu 16.04 or older](#building-on-ubuntu-16-04-and-older-systems) | [Where can I spend Hush?](#where-can-i-spend-hush) | [Cross compiling from amd64 to arm64](https://git.hush.is/hush/docs/src/branch/master/advanced/cross-compile-hush-full-node-to-aarch64-with-docker.md)
+
+
+
+# What is Hush?
Hush implements Extreme Privacy via blockchain tech. We have our own
genesis block. We are not a chain fork (copy) of another coin. We are based on
Bitcoin code, with sophisticated zero-knowledge mathematics added for privacy.
This keeps your transaction metadata private!
-### This repository
+# What is this repository?
This software is the Hush node and command-line client. It downloads and stores
the entire history of Hush transactions; depending on the speed of your
computer and network connection, it will likely take a few hours at least, but
-some people report full nodes syncing in less than 1.5 hours. A competing privacy
-coin takes over 24 hours to sync their full nodes because of Sprout Transactions, lulz.
+some people report full nodes syncing in less than 1.5 hours.
-### BANNED BY GITHUB
+# Banned by GitHub
In working on this release, Duke Leto was suspended from Github, which gave Hush developers
-the impetus to completely leave that racist and censorship-loving platform.
-
-Hush now has it's own [git.hush.is](https://git.hush.is/hush) Gitea instance,
-because we will not be silenced by Microsoft.
-
-All Hush software will be released from git.hush.is and hush.is, downloads from any other
+the impetus to completely leave that racist and censorship-loving platform. Hush now has it's own [git.hush.is](https://git.hush.is/hush) Gitea instance,
+because we will not be silenced by Microsoft. All Hush software will be released from git.hush.is and hush.is, downloads from any other
domains should be assumed to be backdoored.
**Hush is unfinished and highly experimental.** Use at your own risk! Just like Bitcoin.
-## Installing
+# Build on Debian or Ubuntu
-You can either compile it yourself or you can install a binary which was compiled by us.
-Please refer to the instructions which apply to you below:
+```sh
+# install build dependencies
+sudo apt-get install build-essential pkg-config libc6-dev m4 g++-multilib \
+ autoconf libtool ncurses-dev unzip git zlib1g-dev wget \
+ bsdmainutils automake curl unzip nano libsodium-dev cmake
+# clone git repo
+git clone https://git.hush.is/hush/hush3
+cd hush3
+# Build
+# This uses 3 build processes, you need 2GB of RAM for each.
+./build.sh -j3
+```
+Video Tutorial: https://videos.hush.is/videos/how-to-install-on-linux
-* See [INSTALL.md](INSTALL.md) to compile from source on Linux and to cross-compile for Windows
-* See [INSTALL-BIN.md](INSTALL-BIN.md) to install pre-compiled binary on Linux
+# Build on Arch
-### Claiming Funds From Old Hush Wallets
+```sh
+# install build dependencies
+sudo pacman -S gcc libsodium lib32-zlib unzip wget git python rust curl autoconf cmake
+# clone git repo
+git clone https://git.hush.is/hush/hush3
+cd hush3
+# Build
+# This uses 3 build processes, you need 2GB of RAM for each.
+./build.sh -j3
+```
-If you have an older wallet, then refer to [OLD_WALLETS.md](OLD_WALLETS.md).
+# Build on Fedora
-### Official Explorers
+```sh
+# install build dependencies
+sudo dnf install make automake gcc gcc-c++ kernel-devel cmake libtool ncurses-devel patch -y
+# clone git repo
+git clone https://git.hush.is/hush/hush3
+cd hush3
+# Build
+# This uses 3 build processes, you need 2GB of RAM for each.
+./build.sh -j3
+```
+
+# Install on Windows 10
+
+Video Tutorial: https://videos.hush.is/videos/how-to-install-on-windows
+
+# Install on ARM Architecture
+
+Use this if you have a Raspberry Pi or similar computer. Currently, any ARMv7 machine will not be able to build this repo, because the underlying tech (zcash and the zksnark library) do not support that instruction set. This also means that old RaspberryPi devices will not work, unless they have a newer ARMv8-based Raspberry Pi. Raspberry Pi 4 and newer are known to work.
+
+1. [Download the latest Debian package with the AARCH64 designation from the releases page](https://git.hush.is/hush/hush3/releases).
+1. Install the Debian package, substituting "VERSION-NUMBER" for the version you have downloaded: `sudo dpkg -i hush-VERSION-NUMBER-aarch64.deb`.
+1. Run with: `hushd`.
+
+If you would like to compile this for ARM yourself, then please refer to the [Cross compiling a Hush full node daemon from AMD64 to ARM64(aarch64) CPU architecture with Docker](https://git.hush.is/jahway603/hush-docs/src/branch/master/advanced/cross-compile-hush-full-node-to-aarch64-with-docker.md) documentation to do that.
+
+# Building On Ubuntu 16.04 and older systems
+
+Some older compilers may not be able to compile modern code, such as gcc 5.4 which comes with Ubuntu 16.04 by default. Here is how to install gcc 7 on Ubuntu 16.04. Run these commands as root:
+
+```
+add-apt-repository ppa:ubuntu-toolchain-r/test && \
+apt update && \
+apt-get install -y gcc-7 g++-7 && \
+ update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-7 60 && \
+ update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-7 60
+```
+
+# Build on Mac
+
+```
+sudo port update
+sudo port upgrade outdated
+sudo port install qt5
+
+# clone git repo
+git clone https://git.hush.is/hush/hush3
+cd hush3
+# Build
+# This uses 3 build processes, you need 2GB of RAM for each.
+./build.sh -j3
+```
+
+# Installing Hush binaries
+
+1. [Download the release](https://git.hush.is/hush/hush3/releases) with a .deb file extension.
+1. Install the Debian package, substituting "VERSION-NUMBER" for the version you have downloaded: `sudo dpkg -i hush-VERSION-NUMBER-amd64.deb`.
+1. Run with: `hushd`.
+
+# Windows (cross-compiled on Linux)
+Get dependencies:
+```ssh
+sudo apt-get install \
+ build-essential pkg-config libc6-dev m4 g++-multilib libdb++-dev \
+ autoconf libtool ncurses-dev unzip git zip \
+ zlib1g-dev wget bsdmainutils automake mingw-w64 cmake libsodium-dev
+```
+
+Downloading Git source repo, building and running Hush:
+
+```sh
+# pull
+git clone https://git.hush.is/hush/hush3
+cd hush3
+# Build
+./util/build-win.sh -j$(nproc)
+# Run a HUSH node
+./src/hushd
+```
+
+# Official Explorers
The links for the Official Hush explorers:
* [explorer.hush.is](https://explorer.hush.is)
* [explorer.hush.land](https://explorer.hush.land)
-We are looking for alternate explorers to be run on Tor, i2P and other TLDs, if you are interested
-please join Telegram and ask questions.
+# What is SilentDragon?
-### For system admins
+* [SilentDragon](https://git.hush.is/hush/SilentDragon) is a desktop wallet for HUSH full node.
+* [SilentDragonLite](https://git.hush.is/hush/SilentDragonLite) is a desktop wallet that does not require you to download the full blockchain.
+* [SilentDragonAndroid](https://git.hush.is/hush/SilentDragonAndroid) is a wallet for Android devices.
+* [SilentDragonPaper](https://git.hush.is/hush/SilentDragonPaper) is a paper wallet generator that can be run completely offline.
-There is a new systemd user service script so you can easily start/stop/restart your hushd service on your server.
-[Try it out today](doc/hushd-systemd.md) and the systemd script is located in the doc directory of the source tree.
+# What is HushChat?
-## Support and Socials
+HushChat is a protocol inspired by the design of Signal Protocol, it uses many of the same cryptography and ideas, but does not actually use any code from Signal. Signal requires phone numbers and is a centralized service. HushChat is completely anonymous and decentralized and requires absolutely no metadata be given to any centralized third parties.
-Please feel free to join us on Telegram for official support:
-* Main group: https://hush.is/tg
-* Support group: https://hush.is/telegram_support
-* Mining group: https://hush.is/telegram_mining
+# Can I mine with CPU or GPU?
-Other socials:
-* Twitter: @hushisprivacy
-* Matrix: @hush_main:meowchat.xyz
-* PeerTube videos.hush.is
-* Reddit @Myhush
-* Mastodon @myhushteam@fosstodon.org
+Hush cannot be efficiently mined with CPU or GPU, only ASIC mining is recommended. HUSH uses Equihash (200,9) algo, as does Zcash, Horizen or Komodo.
-## License
+# Where can I buy Hush?
+
+1. https://nonkyc.io/market/HUSH_BTC
+1. https://tradeogre.com/exchange/BTC-HUSH
+
+# Where can I spend Hush?
+
+AgoraX market: https://agorax.is
+
+# Earn Hush bounty
+
+Developers can earn bounty by fixing bugs or solving feature requests listed in `Issues->Label`:
+- https://git.hush.is/hush/hush3/issues
+- https://git.hush.is/hush/SilentDragon/issues
+- https://git.hush.is/hush/SilentDragonLite/issues
+
+
+
+# Support and Socials
+
+* Telegram: [https://hush.is/tg](https://hush.is/tg)
+* Matrix: [https://hush.is/matrix](https://hush.is/matrix)
+* Twitter: [https://hush.is/twitter](https://hush.is/twitter)
+* PeerTube [https://hush.is/peertube](https://hush.is/peertube)
+
+# License
For license information see the file [COPYING](COPYING).
diff --git a/SECURITY.md b/SECURITY.md
deleted file mode 100644
index 97a9a68ce..000000000
--- a/SECURITY.md
+++ /dev/null
@@ -1,90 +0,0 @@
-## Reporting a Vulnerability
-
-You can use [Keybase](https://keybase.io/dukeleto) to find secure contact information.
-
-You can also contact Duke directly via SilentDragon wallet, via "Contact Duke". Encrypted sensitive data
-in memo fields in highly encouraged.
-
-We kindly ask you to not publish or exploit any found vulnerabilities without at least contacting us first.
-
-Fingerprint: F16219F4C23F91112E9C734A8DFCBF8E5A4D8019
-
-```
------BEGIN PGP PUBLIC KEY BLOCK-----
-Version: Keybase OpenPGP v2.0.8
-Comment: https://keybase.io/crypto
-
-xsFNBFU/8aYBEADf7eIcersi4Fbxdc2O6fuy3F9eoW6ap+bBz53fvZFMgBrKcUoV
-2q6HkTQr/CWgPjx1LDwwBo7CBxOeg5FI8W5NVmVA+1XQ0TSa1fx8COpkPOAyCeDa
-6aNQI1ciZS9xJeWy65gF2Mn+iJpgdkQj7xFxxaQpg8Uadq+jKzKp8BIMFyK10eSa
-Pdn1xRDN3Bp5Ze2KUkv59nUc+C1Qx8mE5taXspSdHhrIL/78saGUZ4Q1bnlNex5u
-aiAGRr5L/Qr0e5oEmfId56aQiCBqfvZmgUoun4djLdkAdhMW9bR8msbL/AycFvBn
-C7fNTvic/vOw3yShd5jlr92OfNfHSgzJ5oa+BvMxPDbY4be8GPiTEvaGlPeEAec+
-HyQQHD2yzkhDCLPKbf6WDyRfnUTe3YoAEEmZWkgyP36ggB9gpoW5QuGC0P0Oz8Gz
-jeqBdtnSwR30cwkH535ChjDP/W+KR1yoKZgenV5KuyA6WOZTkdFnDr1R33CkWA+q
-NlZixmSYXZKPeL/z95ZDOiMTuUpG2/fqJsZMSfJ4GcMuF6UtWT5jM+/pzxPg0szq
-8vEu8UZJD4UnUKJAb8XgfQbTXgmG3C+xAxPO2nrUD4etr375yyLR922mc9IRNj3v
-oJqGYsYUfPwKS7ZsJU1N8bAtjdaxRHs6BL0r2sqEyvLwJLh/CdaNCK4HQQARAQAB
-zSlrZXliYXNlLmlvL2R1a2VsZXRvIDxkdWtlbGV0b0BrZXliYXNlLmlvPsLBcAQT
-AQoAGgUCVT/xpgIbLwMLCQcDFQoIAh4BAheAAhkBAAoJEI38v45aTYAZ0q0P/17Q
-URAJGiJqQF7Lqon8bHlvM6jdnHhkv0We50pU+aLXGwaSTy60uj7sqPte6TxWM5BD
-2BGi2viXuJfP+NrM8WJyRqZ0+SHlGM7vHwrHhfGC3sh+Bvh/T9ToXBRDPcp/zbvD
-dqoF4KyI7qUH69mrf9THn+5fM3vF2PNwkEaXLvF7KAHZcFza2tLcEu8kBpTBpd5w
-ZwVGfOTGTw5mbUwB3P6k0pY/SVF31cynCbIszr6YA0p0EUHirzPB8faHfRxzkyt3
-U6MFSHD070vqFu5W9QdwEFlVKn4G5RP4bD/i4Omjt8uHt2oWm3CqmJc+CVsEsxLz
-gLXQmsTZTWYPGQcFc/oUTfBdfeXMsB2tZbuw56Ua/rFH03wgB6pp9pCKb/UDUC1R
-tUQxGliQCA23444i4Pq1aGeTYVEBVHDw6xsp7lXDQi1AzhjXxzrf0Axt7khEX6Z8
-OilDT3ChhCkFacWt2YhudEU4gS1mAbnl1H2bn41FquoLqHCc4vPJlc5OzdhkDaeT
-NjNCEgiCu8F42vfRaDQOeZdC2Rh1vJoe9GAv7OPg9nRv1caJQvIWHRIWkBotNAMz
-q1vQaTB+LDnBpz3gG07EW60WYzuvOm6dyK5PH2BBMHS7J7UyRXERjmB2+5LvK1my
-sDLV2qk+ToQgU8h2dJt+phyzKizVt9VfKTEFN/t6zsBNBFU/8aYBCADN9oyrBJam
-Ly2QLBgihg/yifPoZClq0Z6M86M+VaeWKAKwdNE4r9bBR0ze8f6wuCMix5J+p+lb
-UMFn5GubNgMLzcuuJ2nLqAKInAt3TxbYGz/MQm77DnuW0/b6XfniUKTe+Nf8vOBZ
-HH7cyuhZdV549JaT2BOFXWFayLZF986atPN+NuX8kOzqD0InzEzbDwH1OVxhpeFV
-r7W9s7HUGEDmBDXOLhdLmqx5mEcjumKUSWbMnwgHkR203RGY4H15/jSbpthE8/hH
-z0FgRZWg69f/mZckyoKmjFeiNs5FaQKj2C1q6CEawYyzPd9P1WpCH97t/Y3//XRr
-98bwOT8Rb6R/ABEBAAHCwoQEGAEKAA8FAlU/8aYFCQ8JnAACGwIBKQkQjfy/jlpN
-gBnAXSAEGQEKAAYFAlU/8aYACgkQcteVKUeHcFho5wf+Ma++R1tGsmrI20sA04jz
-jYRag7eVLnC9jhby6T8qIjOR13QaqZelZ0Tr0GBM0KRjU+ehmquw2Mx+NdE7+H60
-h0/D8sPHcOoabYztHz7EPto/lWGcjbEGNLx9Go6049XbTGiL+UfKWfHEzNdEeRX6
-0n1X3JOS67esaJg/ch7cgFrc/5V9Er2b+MBll2doPLh2QTtS7ECfxLzjkiRjwk9u
-9warhCVqZd11xz1CCT+/8TRSSkJYgNkCAtogmrWiJ+HWAhlpr2eRdq1ESMmC4myP
-oElx3FQWBdAY281aJ6EOBjwjpmPLElgltdQ5+yatlLR/j3E2J7jguXIzOEpGgFoO
-i7HsD/0XQYgZ7/HtFka4xYBNHR1tw+F7uY3UzaQ8214sfRWoTtJmSPLeAFQZFh6E
-OoGFPbimDTGttKPfIorZsUnGkZLcWrEqAAieFRmiL8Eyq98zQSEb4S/mMFYcgYMf
-qYWm0dpX5sNQxZfw2Ny4JMPUFRT2LHlk1CC9dpdMvpkK5EqLBb8HVCwW+NFkwZBB
-rzUtyWeSRd8HSDPqdy8T6BG0zTwZ+axIs7VH9nyo4Wyc+irVWctqYkAGyuJRci0s
-C0lb9xgP7gwlEc/o0IpcAwCdSh/4aH4YTYyGOny1TQLWW6vYKwMMLtfdhqrD1Gzw
-SnBo/6vfsELjt1IexEoAU1AaGRf4n7AyRPmhd3SFqtqXhv0bosv+oxi1WVbs4vB+
-rbfMpv4mq9CjbJQRr1gE9NAohqKLTlV5ADDcBc6uN6G5uUsgxzLdPo987rqQxW26
-XWpiJ309vQlgvkJjkOzS1YeDmsLnpSy/i5vocDs7G9XgI0CpuCs3C5kh+6L/ipB3
-78opGszS6yXFvVIPmklA57+F5pbZu4KlONCdlAoH3szZpDjUBashkvEKbbk25JVV
-382WTLLbUz+s2rDAiU0eXCpkI/Zrkt1R8YYCCe09OeUAK1cMfm9v1QQaJaMFMA0L
-mNXQ98FHvgfVa5vo/jxzKH4HqPPpTyKyKWhDJKCHJVmWfnec387ATQRVP/GmAQgA
-wG70Vd4u64nHmAzLUe3dLuOIIIxBX6M4MYe6QXLyjsQ5vv8ScsF9QTRw3SMIw2Aa
-9SB3I+bt6DKRUQOyWyUH74XZdEHveUip7GYglm9+rhiVHT3QfhiVWJo+84j9hG3J
-C4gg3jkB0VzYUSU3lrRX0hRIl5C0oLa+ce80PM0MlmuwnJtRKCi5cNSjQKLi6PEu
-ZlaKwkJvO+hbCguxtfuCK9qDd+l8vY63UM+Crqpc1QTNuEgD0MmOKqk/jyt6WUOC
-Flep1zOMrbvpBYj3a01TdvG3J+5uuh9d2aKH3IhZyOPwu651DNLcRatF/36QmGQ0
-HFHYvM40UF0F06iHcDFw5QARAQABwsKEBBgBCgAPBQJVP/GmBQkPCZwAAhsMASkJ
-EI38v45aTYAZwF0gBBkBCgAGBQJVP/GmAAoJENA7aXPDXJizlg8H/1SP4CP7ZCd4
-J9ptegCvfpcB1KRyIuIUxjDi4XuX6g+QLyZE98eSeoDj6JlYVVHOwACXcNtoBzIm
-7/nk7afFTVYHVEyOCDFprml8qTmQ6aXOgv7z1Ib3Q8rw7EyaMWifsD3f757TSOKw
-H0JBeQYrnhC0Mg9YunjepvamvTvHwZrLNNMltAznXQ2NGqS7dokPNGOmusGmW29a
-EvK8K+AqSuCk2DB4UkaQul1UVmRhMjpKj/nQ9ubEsTDODbouRuLELqOLWmVAyE2V
-WRq3VaGm23N/7w2FlsfPzfElHhmA3znx+2NllNB4nRHforu3/bmUJljozwBwDAN1
-+CfAct5LTQbn+w/8DtEiEZ3BMFU0WWo6W/NqvF5R4x/Hyns50L1GIA6UZqfs9Pdj
-94EgoCVBGzgwUAl241HT7R4Kys58KlFNhlq3fFxlAADAY/ToCyNCK84PR10EDN6I
-Q0jWZaMzMSSm6fJT75br93Sp4TNpTuVhGijR4ZehdDmclbShS28jrJo3u0vfOBoT
-Sy7IchvuudIonnL5UKlA4a1KZOjuEfQfUId/iiIzRhTF+cPsvjqRv6lxLNjdbrDr
-BMCsvwqZl4Qst2Z2kAZYND6gSSQAlef4j3EGtoVrS46maPTimv1KoLsgCQ4ycFmP
-4uU+2KebEY1IdJW50gAEipajiqwH0Biy+H1muanSluZLeC/LYRdH+ebXuguhYZbI
-m4qCbO5rupke0gBFZ7rmqmnDhDg7riVUWvIrtL2YtWX8y8u50TCaQaRjyf0Fqyv8
-G76/DUCUCYcwNkm2qJdHpjVqOU+7E+iWfooA4obfGyPLtuLw2fpVDEDgn+csd+M4
-KlRY6butx+NDUqHtx1Axf6aC9Dl6LAE33UY8nlQWWFvJbQBAY54IzU0WehSgrJSB
-tnKq9uroBB7qDoJExmOnlUaAsmJWjkfxsQS9lFam6lf1UD01AFiIql0rQTcacxrF
-NvQ1HJmZvDZF/K37DrE72NmkYz1aJhTokGFHOGoCqLt146bA2IRkpQRXCv4=
-=YSWs
------END PGP PUBLIC KEY BLOCK-----
-
-```
diff --git a/antispam b/antispam
deleted file mode 100755
index 143c8ef32..000000000
--- a/antispam
+++ /dev/null
@@ -1,4 +0,0 @@
-#!/bin/sh
-
-echo "./src/hush-cli -ac_name=ANTISPAM $@"
-./src/hush-cli -ac_name=ANTISPAM "$@"
diff --git a/asmap.dat b/asmap.dat
index aaf3fdada..03eac1146 100644
Binary files a/asmap.dat and b/asmap.dat differ
diff --git a/code_of_conduct.md b/code_of_conduct.md
deleted file mode 100644
index 3c8ae50a3..000000000
--- a/code_of_conduct.md
+++ /dev/null
@@ -1,8 +0,0 @@
-# Contributor Code of Conduct
-
-As contributors and maintainers of this project, and in the interest of
-fostering an open and welcoming community, we pledge to respect all people who
-contribute through reporting issues, posting feature requests, updating
-documentation, submitting pull requests or patches, and other activities.
-
-Don't be an asshole.
diff --git a/configure.ac b/configure.ac
index ffcf18ad8..a7be75c61 100644
--- a/configure.ac
+++ b/configure.ac
@@ -3,12 +3,12 @@ AC_PREREQ([2.60])
define(_CLIENT_VERSION_MAJOR, 3)
dnl Must be kept in sync with src/clientversion.h , ugh!
define(_CLIENT_VERSION_MINOR, 10)
-define(_CLIENT_VERSION_REVISION, 2)
+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)))
define(_CLIENT_VERSION_IS_RELEASE, true)
-define(_COPYRIGHT_YEAR, 2024)
+define(_COPYRIGHT_YEAR, 2025)
AC_INIT([Hush],[_CLIENT_VERSION_MAJOR._CLIENT_VERSION_MINOR._CLIENT_VERSION_SUFFIX(_ZC_BUILD_VAL)],[https://git.hush.is/hush/hush3],[hush])
AC_CONFIG_SRCDIR([src/main.cpp])
AC_CONFIG_HEADERS([src/config/bitcoin-config.h])
@@ -644,6 +644,17 @@ AX_BOOST_PROGRAM_OPTIONS
AX_BOOST_THREAD
AX_BOOST_CHRONO
+dnl Prevent use of std::unary_function, which was removed in C++17,
+dnl and will generate warnings with newer compilers for Boost
+dnl older than 1.80.
+dnl See: https://github.com/boostorg/container_hash/issues/22, https://github.com/boostorg/config/pull/430.
+
+dnl _HAS_AUTO_PTR_ETC check required only for boost 1.72 and older, for 1.73+ we can use BOOST_NO_CXX98_FUNCTION_BASE
+AX_CHECK_PREPROC_FLAG([-D_HAS_AUTO_PTR_ETC=0], [BOOST_CPPFLAGS="$BOOST_CPPFLAGS -D_HAS_AUTO_PTR_ETC=0"], [], [$CXXFLAG_WERROR],
+ [AC_LANG_PROGRAM([[#include ]])])
+AX_CHECK_PREPROC_FLAG([-DBOOST_NO_CXX98_FUNCTION_BASE], [BOOST_CPPFLAGS="$BOOST_CPPFLAGS -DBOOST_NO_CXX98_FUNCTION_BASE"], [], [$CXXFLAG_WERROR],
+ [AC_LANG_PROGRAM([[#include ]])])
+
fi
if test x$use_reduce_exports = xyes; then
@@ -947,11 +958,12 @@ echo
echo " target os = $TARGET_OS"
echo " build os = $BUILD_OS"
echo
-echo " CC = $CC"
-echo " CFLAGS = $CFLAGS"
-echo " CPPFLAGS = $CPPFLAGS"
-echo " CXX = $CXX"
-echo " CXXFLAGS = $CXXFLAGS"
-echo " LDFLAGS = $LDFLAGS"
-echo " ARFLAGS = $ARFLAGS"
+echo " CC = $CC"
+echo " CFLAGS = $CFLAGS"
+echo " CPPFLAGS = $CPPFLAGS"
+echo " CXX = $CXX"
+echo " CXXFLAGS = $CXXFLAGS"
+echo " BOOST_CPPFLAGS = $BOOST_CPPFLAGS"
+echo " LDFLAGS = $LDFLAGS"
+echo " ARFLAGS = $ARFLAGS"
echo
diff --git a/contrib/asmap/README.md b/contrib/asmap/README.md
index c23d8da74..cbb6f7526 100644
--- a/contrib/asmap/README.md
+++ b/contrib/asmap/README.md
@@ -2,4 +2,5 @@
Files relating to -asmap=... feature, to use ASNs
-Originally from https://github.com/sipa/asmap/blob/master/demo.map
+From https://github.com/asmap/asmap-data/blob/main/1730210400_asmap.dat
+[Upstream Commit dcce69e48211facdbd52a461cfce333d5800b7de](https://github.com/asmap/asmap-data/commit/dcce69e48211facdbd52a461cfce333d5800b7de)
diff --git a/contrib/asmap/asmap.dat b/contrib/asmap/asmap.dat
index aaf3fdada..03eac1146 100644
Binary files a/contrib/asmap/asmap.dat and b/contrib/asmap/asmap.dat differ
diff --git a/contrib/avg_blocktime.pl b/contrib/avg_blocktime.pl
new file mode 100755
index 000000000..adfa25427
--- /dev/null
+++ b/contrib/avg_blocktime.pl
@@ -0,0 +1,57 @@
+#!/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
+
+use warnings;
+use strict;
+my $cli = "./src/hush-cli";
+my $coin = shift || '';
+unless (-e $cli) {
+ die "$cli does not exist, aborting";
+}
+if ($coin) {
+ $cli .= " -ac_name=$coin";
+}
+my $getblock= "$cli getblock";
+my $start = shift || 1850000;
+my $end = shift || 1853000;
+
+my $blocks = qx{$cli getblockcount};
+if($?) {
+ print "ERROR, is node 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;
+my $prev_blocktime = 0;
+my $total_duration = 0;
+
+while ($block <= $end) {
+ my $blocktime = qx{$getblock $block | grep time};
+ chomp $blocktime;
+ if($blocktime =~ m/(\d+)/) {
+ $blocktime = $1;
+ }
+ my $duration = $blocktime - $prev_blocktime;
+ if($prev_blocktime > 0) {
+ $total_duration += $duration;
+ }
+ #print "$block $blocktime $prev_blocktime $duration\n";
+ print "$block $duration\n";
+ $block++;
+ $prev_blocktime = $blocktime;
+}
+my $num_blocks = $end - $start;
+my $avg_duration = $total_duration / $num_blocks;
+print "Avg blocktime over $num_blocks blocks = $avg_duration\n";
diff --git a/contrib/block_time.pl b/contrib/block_time.pl
index 3e3cf014d..2fc9299fb 100755
--- a/contrib/block_time.pl
+++ b/contrib/block_time.pl
@@ -5,7 +5,7 @@
use warnings;
use strict;
-# Given a block time, estimate when it will happen
+# Given a block height, estimate when it will happen
my $block = shift || die "Usage: $0 123";
my $coin = shift || '';
my $hush = "./src/hush-cli";
@@ -30,7 +30,7 @@ if ($block <= $blockcount) {
if ($coin eq 'DRAGONX') {
$minpb = 0.6; # minutes per block
} elsif ($coin) {
- # TODO: support custom bloctimes
+ # TODO: support custom blocktimes
$minpb = 1; # assumes default blocktime of 60s
}
my $minutes = $diff*$minpb;
diff --git a/contrib/debian/changelog b/contrib/debian/changelog
index 08ed69a2c..421d39379 100644
--- a/contrib/debian/changelog
+++ b/contrib/debian/changelog
@@ -1,3 +1,429 @@
+hush (3.10.3) stable; urgency=high
+
+ * Use WolfSSL 4.8.1 to prevent nodes from getting stuck and when shutting down
+ * Set minimum fee to 0.1 HUSH per 1 KB of data if `OP_RETURN` is used.
+ * Absurd fee allows sending amount < fee; used only in a full node.
+ * Fixed various bugs relating to lock ordering and missing locks
+ * Fixed RPC docs for addnode and disconnectnode having incorrect port for HACs
+ * Value of DEBUG_LOCKORDER is now logged to debug.log on node startup
+ * New script ./debug-build.sh to make it easier to make debug builds
+ * DragonX nodes now have their own list of seed nodes
+ * Hush nodes now have own protocol version independent from HACs
+ * Fixed off-by-one bug in `newSietchRecipient`
+ * Performance improvement to `ActivateBestChainStep` ed86f2dd1d
+ * Improved navigation in README for new users.
+ * Updated doc/release-process.md to resolve Issue #407
+ * Added build.sh checks for as and ld to be installed to resolve Issue #73
+
+ -- Hush Core Mon, 30 Sep 2024 11:22:33 -0700
+
+hush (3.10.2) stable; urgency=medium
+
+ * Upgraded WolfSSL to 5.2.0 on Linux and Mac: #380.
+ * Upgraded to 4.8.1 on Windows because newer versions do not compile on it
+ * Only Hush and DragonX will automatically connect to various seed nodes
+ * Updated i2p seed node: 8c8b6e88f0.
+ * Removed unused code.
+ * Fixed boost download link: 323d2134a1.
+ * Hush and DragonX full nodes take up a lot less memory and binaries are now
+ smaller due to the cryptoconditions removal, which means syncing, rescanning
+ and compiling is faster: #381.
+ * Removed CLI options related to CryptoConditions: -ac_cc, -ac_cclib,
+ -ac_ccenable, and -ac_ccactivate
+ * Large page support enabled, which can lead to a 1-2% speed increase in
+ mining depending on RAM and CPU.
+ * Various small optimizations such as making some variables static or const
+ and removing unnecessary conditionals.
+ * Mining now starts faster because instead of only using 2 threads to prepare
+ data needed to mine, it now uses all physical cores: 1b5422eb2d.
+ * RandomX mining now takes slightly less memory.
+ * Added script for scanning DragonX nodes: 0679468f60.
+ * More details about p2p encryption: ccc86839b9, a358acab0b, 4ed576a7e2.
+ * Added Fedora install process: #384.
+ * Added Arch install process: #393.
+ * Implemented better error messages: f64c10baa9, f71f8124c3.
+ * Improved hush_scanner and seed node contrib file: 16dd3aef74.
+ * Removed unused Makefile: #291.
+
+ -- Hush Core Tue, 05 Mar 2024 18:29:47 -0700
+
+hush (3.10.1) stable; urgency=medium
+
+ * Fixed bug causing "payment to wrong pubkey" error when syncing a new node
+ * Faster syncing of Hush and DragonX full nodes
+ * Slightly less memory usage in each Equihash/RandomX mining thread
+ * Fixed compiling issues related to RandomX v1.2.1
+ * Improved RPC docs for getblocktemplate
+ * Removed the getdeprecationinfo RPC
+
+ -- Hush Core Tue, 02 Jan 2024 15:16:40 -0700
+
+hush (3.10.0) stable; urgency=high
+
+ * Hush and all Hush Smart Chains now use less RAM #283
+ * Hush and all Hush Smart Chains now make it harder and more expensive for
+ an attacker to send shielded spam. This raises the cost in CPU 14d3ae1785
+ and transaction fees 2308db22ee for Denial-of-Service attacks.
+ * Bug fix: Fixed hush-cli stop not stopping the node during the "Building
+ Witnesses" rescan phase #330
+ * Bug fix: Fixed abortrescan couldn't be used when node starting up (RPC
+ warmup) and where it could not abort the rescan if it was in the "Building
+ Witnesses" phase #331
+ * Bug fix: Fixed z_mergetoaddress where docs said you could use ANY_ZADDR
+ but you couldn't 7eb9d75b94
+ * New RPC: z_listunspent now returns the text representation of a memo in
+ memoStr key
+ * New RPC: z_getstats which reports data about numer of shielded inputs (zins)
+ and shielded outputs (zouts) in transactions. 96ae2d61ca
+ * CVE fix: Upgraded curl to 8.4.0 #325 to fix CVE-2023-38545
+ * New documentation about using CJDNS with Hush
+ * Implemented decentralized Devtax
+ * Updated to latest RandomX v1.2.1 which includes mining optimizations
+ * Fixed RandomX mining memory leak and crash #324
+ * Fixed quoting bugs with dragonx-cli script
+
+ -- Hush Core Tue, 28 Nov 2023 16:47:59 -0700
+
+hush (3.9.4) stable; urgency=medium
+
+ * Hush and DragonX nodes will now sync much faster
+ * DragonX now has checkpoints for faster & better chain security #243 #304
+ * Updated to the latest RandomX code
+ * Rate limiting for the processing of incoming address messages for
+ increased security. #272
+ * Removed unused function CWalletTx::GetRequestCount #273
+ * Removed mapRequest tracking that only affects Qt display. #274
+ * Randomized message processing peer order for increased privacy. #275
+ * Removed BIP35 mempool p2p message for increased privacy. #284
+ * Added additional community seed nodes
+ * Use custom jobs param when compiling boost for faster compile times #288
+ * Now builds with gcc13 thanks to testing from jahway #293
+ * Bug fix: -stratumallowip works with CIDR and netmask ranges again for solo
+ miners #270
+ * Bug fix: Detect missing autoreconf in build.sh #289
+ * Bug fix: Various assertions removed from BIP155 changes #297
+
+ -- Hush Core Sun, 02 Jul 2023 17:47:39 -0700
+
+hush (3.9.3) stable; urgency=medium
+
+ * Difficulty bug affecting DRAGONX has been fixed
+ * RandomX mining hashrate increase of about 60X
+ * Optimized memory usage of RandomX mining
+ * Adds Tor v3 and i2p support (BIP155 also known as addrv2)
+ * New RPC: getrescaninfo - Says if node is rescanning with additional info
+ about progress
+ * New RPC: abortrescan - Stops rescanning if node is currently rescanning
+
+ -- Hush Core Mon, 13 Feb 2023 15:02:48 -0700
+
+hush (3.9.2) stable; urgency=medium
+
+ * This release adds RandomX support in Hush Smart Chains (HSCs)
+ * A new feature called "zsweep" has been added, which defaults to disabled.
+ * Expired transactions will not be relayed & nodes doing so no longer banned
+ * Fix a rare coredump when nodes have many unconfirmed or expired transactions
+ * New RPC: getblockmerkletree, which shows full Merkle Tree for a block height
+ * New RPC: z_consolidationstatus will show config + stats about consolidation
+ * New RPC: z_anonsettxdelta : Returns delta (difference) in the anonset for a
+ given txid.
+ * New RPC: z_anonsetblockdelta : Returns delta (difference) in the anonset for
+ a given block.
+ * getrawtransaction RPC now returns a "size" key with the size in bytes of a
+ transaction
+ * sendmany RPC will now reject transactions that send to t-addresses
+ immediately, instead of them being rejected in mempool
+ * New contrib script: contrib/gen-zaddrs.pl - Generates z-addresses in bulk
+ * New contrib script: contrib/sdl_checkpoints.pl - Generate SDL checkpoints
+ using getblockmerkletree
+ * ZeroMQ support has been removed from Hush
+
+ -- Hush Core Tue, 27 Sep 2022 14:08:15 -0700
+
+hush (3.9.1) stable; urgency=medium
+
+ * Fix RPC deadlocks, which caused the RPC interface to hang
+ * The listbanned RPC now returns a new key time_remaining which tells how many
+ seconds are remaining in the ban
+ * The rescan RPC now works correctly when given a height. This can be used to
+ do a partial rescan from a custom height, without restarting the node.
+ * Minimum disk space required for running full node increased to 1GB from 50MB
+ * Dockerfile has been updated
+
+ -- Hush Core Tue, 25 Jan 2022 06:39:18 -0700
+
+hush (3.9.0) stable; urgency=high
+
+ * hushd, hush-cli, and hush-tx are now true binaries instead of shell scripts
+ * New official location for full node data is ~/.hush and existing full
+ nodes will continue to use the legacy ~/.komodo directory
+ * Hush full nodes will now attempt to talk to two more nodes by default:
+ node1.hush.land and node2.hush.land
+ * New RPC: listaddresses - Show all taddrs in this wallet.dat
+ * New RPC: rpcinfo - Shows stats about RPC internals
+ * These RPCs can now be run during RPC warmup: listaddresses, z_exportwallet,
+ signmessage, decoderawtransaction, and getnetworkinfo
+ * New doc/hushd.service to use hushd with systemd
+ * Optimize zaddrs by only building block's witness caches involving our wallet
+ connection on
+ * When RPC connection fails hush-cli now tells you which port it was trying to
+ connect to
+ * Calculation of HSC "network magic" has changed as of 3.9.0
+ * New Stratum API so you can Solo mine with your full node, enable it
+ with -stratum=1
+ * hush-smart-chain script now installed in Debian packages
+ * Now compatible on SBC (Single Board Computer) like PineBook, Rock64,
+ Raspberry Pi, etc.
+
+ -- Hush Core Thu, 21 Oct 2021 04:44:44 -0700
+
+hush (3.8.0) stable; urgency=medium
+
+ * New Sietch feature: Randomized change output location
+ * New Sietch feature: Sietch-ified z_shieldcoinbase
+ * Implemented patch to fix how the longest chain is calculated, which could
+ prevent mining pools from making payout transactions
+ * plz_stop feature implemented for when RPC interface is not functioning
+ (such as filled by deadlocks) making it impossible to shut it down correctly
+ * -keepnotewitnesscache prevents Sapling Note Witness cache from being
+ deleted from wallet.dat on shutdown.
+ * -rescanheight can be used with -keepnotewitnesscache and -rescan to do a
+ partial rescan of history and avoid completely rebuilding the Witness Cache
+ * -zindex data is now stored on disk in the new zindex.dat file
+ * getpeerinfo now returns a relaytxes key which says if a remote node is
+ relaying transactions to your node
+ * Improvements to the RPC help documentation
+
+ -- Hush Core Sat, 10 Jul 2021 06:53:52 -0700
+
+hush (3.7.1) stable; urgency=medium
+
+ * Removed more internals code related to unused Sprout transactions, making
+ Hush run and compile faster and use less memory.
+ * Now provides more useful error message when user attempts to make
+ transaction before the node is synced.
+ * z_sendmany RPC docs now show an example of a z2z transaction
+ * Deprecated alert p2p message no longer processed & nodes using it will be
+ banned
+ * try-before-evict ported from BTC core to help protect against Eclipse and
+ Sybil Attacks
+ * "Feeler connections" ported from BTC, which is another technique to make
+ Eclipse and Sybil Attacks harder and more expensive
+ * New RPC: z_getbalances returns a list of all zaddrs with non-zero balance.
+ * "Automagic z_sendmany" makes the RPC easier to use and also improves privacy
+
+ -- Hush Core Wed, 21 Apr 2021 14:18:12 -0700
+
+hush (3.7.0) stable; urgency=medium
+
+ * Improved TLS error reporting
+ * Fix bug relating to calculating difficulty
+
+ -- Hush Core Thu, 01 Apr 2021 02:53:21 -0700
+
+hush (3.6.3) stable; urgency=low
+
+ * Maintenance release, which is mostly the same as 3.6.2 but it fixes some
+ issues in Debian+Arch packages and binaries not able to find asmap.dat
+
+ -- Hush Core Fri, 26 Feb 2021 14:42:59 -0700
+
+hush (3.6.2) stable; urgency=medium
+
+ * Autonomous System Map (asmap) bucketing by default
+ * New CLI flag -asmap is on by default, and can be turned off with -asmap=0
+ * debug.log is now shrunk to 15MB instead of 100MB
+ * The max size of debug.log can now be controlled via -maxdebugfilesize
+
+ -- Hush Core Sun, 21 Feb 2021 14:21:31 -0700
+
+hush (3.6.1) stable; urgency=low
+
+ * WolfSSL upgraded to 4.6.0 and side-channel resistance enabled via
+ ECC_TIMING_RESISTANT
+ * Hush full nodes now exclusively communivate via P2P messages with TLS1.3 as
+ the option -tls=only has become default and cannot be turned off
+ * Improved error-handling and logging of TLS connections
+ * getpeerinfo now shows 3 new keys for each peer
+ * New developer documentation in DEVELOPING.md
+ * -whitelist and -whitelistaddress now called -allowlist and -allowlistaddress
+ * Minimum protocol version is now 1987420
+
+ -- Hush Core Wed, 27 Jan 2021 19:42:38 -0700
+
+hush (3.6.0) stable; urgency=medium
+
+ * Fixes sync issues near block 340k caused by blocktime halving bug
+ * New official domain https://hush.is reflected everywhere
+ * New Hush DPoW Notaries replace KMD Notaries
+ * Increased in-memory UTXO cache db by 100MB (25%) to increase performance of
+ initial syncing
+ * Prevent Delayed-Proof-of-Work attack from Komodo Notaries
+ * New -dpow-start-height CLI flag used to reject all DPoW transactions (and
+ attacks) up to a certain height, as general defense against any DPoW attacks
+ * More secure + private TLS 1.3 implementation
+ * Switched to WolfSSL 4.5.0 instead of OpenSSL
+ * Nodes randomly choose between GCM-SHA384 and CHACHA20-POLY1305-SHA256 when
+ making connections to other nodes.
+ * Faster release binaries with -03
+ * Optimized and hardened memory pool code
+ * getblocktemplate RPC now provides better error reporting about whether there
+ are no peers or if it's not in sync
+ * Removed more Sprout code, which is tightly mixed into deep internals,
+ resulting in increased compile speed and reduced memory overhead
+ * New P2P protocol version. Peers only talk to 3.5.x nodes and newer
+
+ -- Hush Core Fri, 18 Dec 2020 02:07:35 -0700
+
+hush (3.5.2) stable; urgency=low
+
+ * Re-released hushd under the GNU Public License Version 3 (GPLv3)
+ * The z_listreceivedaddress RPC now returns a memoStr key for the utf8 string
+ representation of a shielded memo, if it exists
+
+ -- Hush Core Thu, 22 Oct 2020 16:16:19 -0700
+
+hush (3.5.1) stable; urgency=low
+
+ * TLS 1.3 support ported from ZEN with custom Hush tweaks
+ * All nodes will try using encrypted TLS connections with peers by default
+ * getinfo now returns a tls_connections key in JSON data
+ * -tls=only can be used to only use encrypted connections
+ * ASN map filtering of peers, ported from KMD + BTC Core
+
+ -- Hush Core Tue, 06 Oct 2020 07:43:47 -0700
+
+hush (3.5.0) stable; urgency=medium
+
+ * Finalize changes to support new Blocktime of 75 seconds
+ * Updated the Hush Halving schedule, i.e. Emission Curve, for the next ~120
+ years (the next 30 halvings)
+ * The Hush Block Reward will go to zero at Block 50740000 in the year 2140
+ * Greatly improved Sietch implementation with "amnesia zdust" addresses
+ * Sietch zdust outputs now always contain "random/encrypted" data
+ * -wallet CLI option supports wallets outside the datadir and relative paths
+ * -txsend CLI option ported from Zcash upstream to help with i2p integration
+ * Improved aarch64 support for Raspberry Pi 4
+ * Removed the proton optional dependency
+ * GetAdjustedTime() replaced with GetTime()
+ * Correctly keep track of ChainShieldedSpends for z_getchaintxstats
+ * timeoffset key in getpeerinfo and getnetworkifo deprecated and now always 0
+ * More remnants of dead Sprout/JoinSplit code removed
+ * Added a z_listreceivedaddress RPC which internals never had RPC access
+ * Fixes and improvements to deletetx=1, still considered experimental
+ * Checkpoints updated up to Block 300K
+
+ -- Hush Core Wed, 23 Sep 2020 22:03:17 -0700
+
+hush (3.4.0) stable; urgency=high
+
+ * New Season 4 KMD Notary pubkeys have been updated (as of Block 245555)
+ * ENFORCED PRIVACY (aka z2z) merged & set to take effect at Block 340000
+ * All remaining internals code relating to Sprout has been deleted
+ * The new Subatomic Dapp has been ported from KMD, which supports z2z swaps
+ * Implemented own mirror of Boost in our build system
+ * Merged various fixes relating to CryptoConditions from KMD upstream
+ * Optimizations and bug fixes to Sapling Consolidation
+ * Fixes CVE-2018-20586 from KMD (which ported it from BTC)
+ * Added z_getnotescount RPC
+ * Updated ccache dependency to 3.7.9
+ * Ported the -txexpirynotify CLI option from ZEC upstream
+ * Added rescan RPC for wallets to initiate a rescan without importing a key
+ and without restarting
+
+ -- Hush Core Thu, 18 Jun 2020 09:35:31 -0700
+
+hush (3.3.2) stable; urgency=medium
+
+ * ARMv8 support added
+ * Sapling Zaddr Consolidation, which reduces the size of wallets and
+ increases performance for service providers
+ * New CLI options added to hushd - refer to release notes for specifics
+ * New RPCs: z_getinfo, z_listsentbyaddress, z_listreceivedbyaddress,
+ getalldata
+ * New -opretmintxfee ported from KMD upstream
+ * ThreadNotifyWallets refactor ported from ZEC upstream
+ * Deletion of libsnark internal library
+ * Shielded index (zindex) statistics of coinbase and organic
+ transactions/payments corrected
+ * Updated dependencies: curl, boost, native_ccache, openssl, and proton
+ * Removed more Sprout-only RPC's (zcbenchmark, zcrawjoinsplit) and code
+ * Various improvements to RPC documentation
+
+ -- Hush Core Wed, 08 Apr 2020 12:21:44 -0700
+
+hush (3.3.1) stable; urgency=low
+
+ * Maintenance release fixes a non-consensus bug in sendmany which prevented
+ it from working.
+
+ -- Hush Core Sat, 18 Jan 2020 09:16:21 -0700
+
+hush (3.3.0) stable; urgency=high
+
+ * New "Sietch" functionality protects against new metadata attacks
+ * New ability to launch Hush Smart Chains with a single command
+ * Fixes CVE-2019-18936 in UniValue dependency: bitcoin/bitcoin#17742
+ * New experimental Shielded Index (-zindex) which keeps track of many stats
+ seen via the new getchaintxstats RPC including shielded payments,
+ anonymity set size and many other things.
+ * New experimental z_listnullifiers RPC which returns Sapling nullifiers.
+ * Updates + fixes to all CryptoConditions smart contracts from KMD 0.5.0
+ * Updates NSPV/Superlite code from KMD 0.5.0
+ * Update 3rd party KMD Notary node pubkeys moving Hush from a run-time
+ fork of KMD to a source code fork
+ * Enable creation of z-only (like Pirate) Hush Smart Chains via -ac_private=1
+ * Removed more Sprout-specific code, making hushd faster & easier to maintain
+ * Allow hush-cli stop to be run during RPC warmup
+ * Update to libsodium 1.0.18
+ * Removes VerusHash from the source code
+ * Removed large amounts of Proof-of-Stake-related code not used in Hush
+ * Ported AFL fuzzing features to our build system from Zcash
+ * Changed max debug.log size from 10MB to 100MB
+ * Added checkpoints for every 1000th Hush block
+ * New contrib/checkpoints.pl script to automatically generate checkpoints
+ * Deleted QT wallet code inherited from Bitcoin, which was old and broken
+ * z_exportwallet can now optionally not rescan
+ * New SHA256 SSE4 routines ported from KMD (which was ported from BTC),
+ enabled with --enable-experimental-asm=yes
+ * debug.log no longer containts a log2_stake column
+ * New --hardfork-height CLI option for devs+notaries for testing
+
+ -- Hush Core Fri, 03 Jan 2020 10:13:17 -0700
+
+hush (3.2.3) stable; urgency=low
+
+ * Update build dependencies to use own forks of libgmp, libsnark, libsodium
+ * New RPC keys are now returned in getblockchaininfo : longestchain and
+ notarized which are now used by the SDL backend
+
+ -- Hush Core Sat, 14 Dec 2019 04:59:59 -0700
+
+hush (3.2.2) stable; urgency=medium
+
+ * Fix CVE-2017-18350 from ZEC and windows portability fix from KMD upstream
+ * Removed some Sprout code
+ * Fixed some rare edge case bugs in Sapling param finding code
+ * New detection of "corrupt" Sapling params (invalid sizes) to helps give
+ users the correct error in a GUI wallet (corrupt versus no params)
+ * Fix Sapling params to support Mac DMGs being installed to /Applications
+
+ -- Hush Core Tue, 26 Nov 2019 12:17:17 -0700
+
+hush (3.2.1) stable; urgency=low
+
+ * Fixes issues discovered in Hush 3.2.0
+ * New DEVELOPING.md document for advice working on Hush codebase
+ * Updated to latest upstream SuperLite/nSPV features
+ * Merged in latest cryptocondition/Antara module updates from KMD upstream
+ * Fixed a bug that corrupts the block index on second startup
+ * Improved code to locate installed Sapling params, since Debian packages
+ install them into /usr/share/hush
+ * Updated DNSSeeds
+ * Fix fees associated with transactions in the mempool with fSkipExpiry=0
+
+ -- Hush Core Tue, 29 Oct 2019 22:34:35 -0700
+
hush (3.2.0) stable; urgency=medium
* 3.2.0.1 release.
diff --git a/contrib/debian/compat b/contrib/debian/compat
index ec635144f..b1bd38b62 100644
--- a/contrib/debian/compat
+++ b/contrib/debian/compat
@@ -1 +1 @@
-9
+13
diff --git a/contrib/debian/control b/contrib/debian/control
index 8526dd6b4..7d1e6e2a2 100644
--- a/contrib/debian/control
+++ b/contrib/debian/control
@@ -13,4 +13,6 @@ Vcs-Browser: https://git.hush.is/hush/hush3
Package: hush
Architecture: amd64 arm64
Depends: ${shlibs:Depends}
-Description: Hush cryptocoin full node. Speak And Transact Freely. Hush inherits from Bitcoin Protocol and Zcash Protocol and is focused on private communications.
+Description: Cryptocoin full node for Hush
+ Speak And Transact Freely with Hush, which inherits from Bitcoin Protocol and
+ Zcash Protocol and is focused on private communications.
diff --git a/contrib/debian/copyright b/contrib/debian/copyright
index 6231c2023..905f248bb 100644
--- a/contrib/debian/copyright
+++ b/contrib/debian/copyright
@@ -1,5 +1,5 @@
Files: *
-Copyright: 2016-2020, The Hush developers
+Copyright: 2016-2024, The Hush developers
2009-2016, Bitcoin Core developers
License: GPLv3
Comment: https://hush.is
diff --git a/contrib/debian/hush.example b/contrib/debian/hush.example
index 924659c02..43111f548 100644
--- a/contrib/debian/hush.example
+++ b/contrib/debian/hush.example
@@ -1 +1 @@
-DEBIAN/examples/zcash.conf
+DEBIAN/examples/HUSH3.conf
diff --git a/contrib/dragonx_scanner b/contrib/dragonx_scanner
index 4f97d8da4..8e11610ae 100755
--- a/contrib/dragonx_scanner
+++ b/contrib/dragonx_scanner
@@ -1,4 +1,4 @@
-#!/bin/bash
+#!/usr/bin/env bash
# Copyright (c) 2016-2024 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
diff --git a/contrib/hush_seed_nodes.txt b/contrib/hush_seed_nodes.txt
index d176dc884..8edf78b70 100644
--- a/contrib/hush_seed_nodes.txt
+++ b/contrib/hush_seed_nodes.txt
@@ -12,9 +12,6 @@
155.138.228.68
107.174.70.251
# hush_scanner uses nc which cannot deal with these
-# 56wqzfj6mhxgsv3h3nh3pdocguogxfxud55libqjhjsdh5alfsko2iqd.onion
-# hushv3h6mbxd2pptj42reko3jcexcgnz5zvp3mqcu6myto3jhhn4yzyd.onion
-# hushv3xvheqh42ms3ld2nh555muscietkib7gycb7s4psbrjsysfywqd.onion
# iljqq7nnmw2ij2ezl334cerwwmgzmmbmoc3n4saditd2xhi3xohq.b32.i2p
# [2a0c:b641:6f1:34::2]
# [2a0c:b641:6f1:c::2]
@@ -28,8 +25,3 @@ node5.hush.is
node6.hush.is
node7.hush.is
node8.hush.is
-node1.hush.land
-node2.hush.land
-node3.hush.land
-node4.hush.land
-node5.hush.land
diff --git a/contrib/sdl_checkpoints.pl b/contrib/sdl_checkpoints.pl
index 8b7ea54ea..938aee872 100755
--- a/contrib/sdl_checkpoints.pl
+++ b/contrib/sdl_checkpoints.pl
@@ -8,7 +8,11 @@
use warnings;
use strict;
-my $hush = "./src/hush-cli";
+
+# call this script like this to generate checkpoints for a HAC such as DragonX:
+# CLI=./src/dragonx-cli ./contrib/sdl_checkpoints.pl ...
+
+my $hush = $ENV{CLI} || "./src/hush-cli";
my $gethash = "$hush getblockhash";
my $gettree = "$hush getblockmerkletree";
my $start = shift || 300000;
diff --git a/contrib/seeds/nodes_main.txt b/contrib/seeds/nodes_main.txt
index 2fc59ec5e..c7ac709e7 100644
--- a/contrib/seeds/nodes_main.txt
+++ b/contrib/seeds/nodes_main.txt
@@ -1,17 +1,14 @@
-# node1.hush.land
-91.208.127.81
+# node1.hush.is
+103.69.128.148
-# node2.hush.land
-87.251.76.166
+# node2.hush.is
+194.29.100.179
-# node3.hush.land
-45.82.68.233
+# node3.hush.is
+45.132.75.69
-# node4.hush.land
-87.251.76.33
-
-# node5.hush.land
-178.250.189.141
+# node4.hush.is
+170.205.39.39
# lite.hushpool.is
149.28.102.219
@@ -22,14 +19,20 @@
# wtfistheinternet.hush.is
107.174.70.251
+# arrakis.hush.is
+178.250.189.141
+
# torv3
-56wqzfj6mhxgsv3h3nh3pdocguogxfxud55libqjhjsdh5alfsko2iqd.onion
-hushv3h6mbxd2pptj42reko3jcexcgnz5zvp3mqcu6myto3jhhn4yzyd.onion
-hushv3xvheqh42ms3ld2nh555muscietkib7gycb7s4psbrjsysfywqd.onion
+b2dln7mw7ydnuopls444tuixujhcw5kn5o22cna6gqfmw2fl6drb5nad.onion
+dslbaa5gut5kapqtd44pbg65tpl5ydsamfy62hjbldhfsvk64qs57pyd.onion
+vsqdumnh5khjbrzlxoeucbkiuaictdzyc3ezjpxpp2ph3gfwo2ptjmyd.onion
# ipv6
-2a0c:b641:6f1:34::2
-2a0c:b641:6f1:c::2
+2a0c:b641:6f1:18e::2
+2406:ef80:3:1269::1
+2406:ef80:2:3b59::1
+2406:ef80:1:146e::1
+2406:ef80:4:2132::1
# i2p
7oumuppuzgbzlkahavx7qrtjnvbhkixjqdmeg7f6fhndgfhz7mlq.b32.i2p
diff --git a/debug-build.sh b/debug-build.sh
new file mode 100755
index 000000000..d3ba81320
--- /dev/null
+++ b/debug-build.sh
@@ -0,0 +1,24 @@
+#!/usr/bin/env bash
+# Copyright (c) 2016-2024 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
+
+set -eu -o pipefail
+
+echo "Compiling a debug build with --enable-debug..."
+
+# run correct build script for detected OS
+if [[ "$OSTYPE" == "linux-gnu"* ]]; then
+ # TODO: we only have debug builds on linux for now
+ CONFIGURE_FLAGS=--enable-debug ./util/debug-build.sh --disable-tests $@
+elif [[ "$OSTYPE" == "darwin"* ]]; then
+ # code from ./util/build.sh needs to be ported to support --disable-tests
+ #./util/build-mac.sh --disable-tests $@
+ CONFIGURE_FLAGS=--enable-debug ./util/build-mac.sh $@
+elif [[ "$OSTYPE" == "msys"* ]]; then
+ CONFIGURE_FLAGS=--enable-debug ./util/build-win.sh --disable-tests $@
+elif [[ "$OSTYPE" == "freebsd"* ]]; then
+ CONFIGURE_FLAGS=--enable-debug ./util/build.sh --disable-tests $@
+else
+ echo "Unable to detect your OS. What are you using?"
+fi
diff --git a/depends/packages/boost.mk b/depends/packages/boost.mk
index f7d34c253..ac9f5f74c 100644
--- a/depends/packages/boost.mk
+++ b/depends/packages/boost.mk
@@ -7,7 +7,7 @@ $(package)_sha256_hash=59c9b274bc451cf91a9ba1dd2c7fdcaf5d60b1b3aa83f2c9fa143417c
$(package)_download_path=https://git.hush.is/attachments
$(package)_file_name=7b13759e-8623-4e48-ae08-f78502f4b6a5
$(package)_download_file=7b13759e-8623-4e48-ae08-f78502f4b6a5
-$(package)_patches=fix-Solaris.patch
+$(package)_patches=fix-Solaris.patch ignore_wnonnull_gcc_11.patch range_enums_clang_16.patch
define $(package)_set_vars
$(package)_config_opts_release=variant=release
@@ -32,7 +32,9 @@ 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&& \
- patch -p1 < $($(package)_patch_dir)/fix-Solaris.patch
+ patch -p1 < $($(package)_patch_dir)/fix-Solaris.patch &&\
+ patch -p2 < $($(package)_patch_dir)/ignore_wnonnull_gcc_11.patch &&\
+ patch -p2 < $($(package)_patch_dir)/range_enums_clang_16.patch
endef
define $(package)_config_cmds
diff --git a/depends/packages/libevent.mk b/depends/packages/libevent.mk
index b3881738a..8b01061fc 100644
--- a/depends/packages/libevent.mk
+++ b/depends/packages/libevent.mk
@@ -13,7 +13,7 @@ define $(package)_preprocess_cmds
endef
define $(package)_set_vars
- $(package)_config_opts=--disable-shared --disable-openssl --disable-libevent-regress
+ $(package)_config_opts=--disable-shared --disable-openssl --disable-libevent-regress --disable-samples
$(package)_config_opts_release=--disable-debug-mode
$(package)_config_opts_linux=--with-pic
endef
diff --git a/depends/packages/libgmp.mk b/depends/packages/libgmp.mk
index 92cd95fbc..4ec7cde16 100644
--- a/depends/packages/libgmp.mk
+++ b/depends/packages/libgmp.mk
@@ -8,22 +8,25 @@ $(package)_sha256_hash=67df06ed50f288bd7b1ec6907973684fb7cf1196f2cb368b59d423e42
$(package)_git_commit=42ba95387cdfd67399f7aac52fddb8d6e1258ee6
$(package)_dependencies=
$(package)_config_opts=--enable-cxx --disable-shared
-else ifeq ($(build_os),darwin)
+else
+#else ifeq ($(build_os),darwin)
$(package)_version=6.1.1
$(package)_download_path=https://git.hush.is/attachments
$(package)_file_name=d613c855-cd92-4efb-b893-658496852019
$(package)_download_file=d613c855-cd92-4efb-b893-658496852019
$(package)_sha256_hash=a8109865f2893f1373b0a8ed5ff7429de8db696fc451b1036bd7bdf95bbeffd6
$(package)_config_opts=--enable-cxx --disable-shared
-else
-$(package)_version=6.1.1
-$(package)_download_path=https://ftp.gnu.org/gnu/gmp
-$(package)_file_name=gmp-$($(package)_version).tar.bz2
-$(package)_sha256_hash=a8109865f2893f1373b0a8ed5ff7429de8db696fc451b1036bd7bdf95bbeffd6
-$(package)_dependencies=
-$(package)_config_opts=--enable-cxx --disable-shared
endif
+#else
+#$(package)_version=6.1.1
+#$(package)_download_path=https://ftp.gnu.org/gnu/gmp
+#$(package)_file_name=gmp-$($(package)_version).tar.bz2
+#$(package)_sha256_hash=a8109865f2893f1373b0a8ed5ff7429de8db696fc451b1036bd7bdf95bbeffd6
+#$(package)_dependencies=
+#$(package)_config_opts=--enable-cxx --disable-shared
+#endif
+
define $(package)_config_cmds
$($(package)_autoconf) --host=$(host) --build=$(build)
endef
diff --git a/depends/packages/wolfssl.mk b/depends/packages/wolfssl.mk
index 44cdec866..21b95e0ab 100644
--- a/depends/packages/wolfssl.mk
+++ b/depends/packages/wolfssl.mk
@@ -1,13 +1,19 @@
package=wolfssl
ifeq ($(host_os),mingw32)
+# this is the highest version known to compile on windows
$(package)_version=4.8.1
$(package)_file_name=wolfssl-$($(package)_version).tar.gz
$(package)_sha256_hash=50db45f348f47e00c93dd244c24108220120cb3cc9d01434789229c32937c444
else
-$(package)_version=5.2.0
+# BEWARE: Updating this version could cause weird bugs where nodes
+# hang after a few days or do not respond to the "stop" RPC . 5.2.0
+# definitely has problems, versions between 4.8.1 and 5.2.0 have not
+# been tested yet. Make sure to do extensive testing when changing this
+# package version
+$(package)_version=4.8.1
$(package)_file_name=wolfssl-$($(package)_version).tar.gz
-$(package)_sha256_hash=409b4646c5f54f642de0e9f3544c3b83de7238134f5b1ff93fb44527bf119d05
+$(package)_sha256_hash=50db45f348f47e00c93dd244c24108220120cb3cc9d01434789229c32937c444
endif
$(package)_download_path=https://github.com/wolfSSL/wolfssl/archive
diff --git a/depends/patches/boost/ignore_wnonnull_gcc_11.patch b/depends/patches/boost/ignore_wnonnull_gcc_11.patch
new file mode 100644
index 000000000..f914c1e68
--- /dev/null
+++ b/depends/patches/boost/ignore_wnonnull_gcc_11.patch
@@ -0,0 +1,68 @@
+diff --git a/include/boost/concept/detail/general.hpp b/include/boost/concept/detail/general.hpp
+index eeb08750..8d7d6f69 100644
+--- a/include/boost/concept/detail/general.hpp
++++ b/include/boost/concept/detail/general.hpp
+@@ -28,7 +28,14 @@ namespace detail
+ template
+ struct requirement
+ {
++# if defined(BOOST_GCC) && (BOOST_GCC >= 110000)
++# pragma GCC diagnostic push
++# pragma GCC diagnostic ignored "-Wnonnull"
++# endif
+ static void failed() { ((Model*)0)->~Model(); }
++# if defined(BOOST_GCC) && (BOOST_GCC >= 110000)
++# pragma GCC diagnostic pop
++# endif
+ };
+
+ struct failed {};
+@@ -36,7 +43,14 @@ struct failed {};
+ template
+ struct requirement
+ {
++# if defined(BOOST_GCC) && (BOOST_GCC >= 110000)
++# pragma GCC diagnostic push
++# pragma GCC diagnostic ignored "-Wnonnull"
++# endif
+ static void failed() { ((Model*)0)->~Model(); }
++# if defined(BOOST_GCC) && (BOOST_GCC >= 110000)
++# pragma GCC diagnostic pop
++# endif
+ };
+
+ # ifdef BOOST_OLD_CONCEPT_SUPPORT
+@@ -44,7 +58,14 @@ struct requirement
+ template
+ struct constraint
+ {
++# if defined(BOOST_GCC) && (BOOST_GCC >= 110000)
++# pragma GCC diagnostic push
++# pragma GCC diagnostic ignored "-Wnonnull"
++# endif
+ static void failed() { ((Model*)0)->constraints(); }
++# if defined(BOOST_GCC) && (BOOST_GCC >= 110000)
++# pragma GCC diagnostic pop
++# endif
+ };
+
+ template
+diff --git a/include/boost/concept/usage.hpp b/include/boost/concept/usage.hpp
+index 373de63a..fe88b5f5 100644
+--- a/include/boost/concept/usage.hpp
++++ b/include/boost/concept/usage.hpp
+@@ -13,7 +13,14 @@ namespace boost { namespace concepts {
+ template
+ struct usage_requirements
+ {
++# if defined(BOOST_GCC) && (BOOST_GCC >= 110000)
++# pragma GCC diagnostic push
++# pragma GCC diagnostic ignored "-Wnonnull"
++# endif
+ ~usage_requirements() { ((Model*)0)->~Model(); }
++# if defined(BOOST_GCC) && (BOOST_GCC >= 110000)
++# pragma GCC diagnostic pop
++# endif
+ };
+
+ # if BOOST_WORKAROUND(__GNUC__, <= 3)
diff --git a/depends/patches/boost/range_enums_clang_16.patch b/depends/patches/boost/range_enums_clang_16.patch
new file mode 100644
index 000000000..3e049e261
--- /dev/null
+++ b/depends/patches/boost/range_enums_clang_16.patch
@@ -0,0 +1,75 @@
+diff --git a/include/boost/numeric/conversion/detail/int_float_mixture.hpp b/include/boost/numeric/conversion/detail/int_float_mixture.hpp
+index 464e527..7690d07 100644
+--- a/include/boost/numeric/conversion/detail/int_float_mixture.hpp
++++ b/include/boost/numeric/conversion/detail/int_float_mixture.hpp
+@@ -16,15 +16,15 @@
+ #include "boost/numeric/conversion/int_float_mixture_enum.hpp"
+ #include "boost/numeric/conversion/detail/meta.hpp"
+
+-#include "boost/mpl/integral_c.hpp"
++#include "boost/type_traits/integral_constant.hpp"
+
+ namespace boost { namespace numeric { namespace convdetail
+ {
+ // Integral Constants for 'IntFloatMixture'
+- typedef mpl::integral_c int2int_c ;
+- typedef mpl::integral_c int2float_c ;
+- typedef mpl::integral_c float2int_c ;
+- typedef mpl::integral_c float2float_c ;
++ typedef boost::integral_constant int2int_c ;
++ typedef boost::integral_constant int2float_c ;
++ typedef boost::integral_constant float2int_c ;
++ typedef boost::integral_constant float2float_c ;
+
+ // Metafunction:
+ //
+diff --git a/include/boost/numeric/conversion/detail/sign_mixture.hpp b/include/boost/numeric/conversion/detail/sign_mixture.hpp
+index c7f9e42..fde1584 100644
+--- a/include/boost/numeric/conversion/detail/sign_mixture.hpp
++++ b/include/boost/numeric/conversion/detail/sign_mixture.hpp
+@@ -16,15 +16,15 @@
+ #include "boost/numeric/conversion/sign_mixture_enum.hpp"
+ #include "boost/numeric/conversion/detail/meta.hpp"
+
+-#include "boost/mpl/integral_c.hpp"
++#include "boost/type_traits/integral_constant.hpp"
+
+ namespace boost { namespace numeric { namespace convdetail
+ {
+ // Integral Constants for 'SignMixture'
+- typedef mpl::integral_c unsig2unsig_c ;
+- typedef mpl::integral_c sig2sig_c ;
+- typedef mpl::integral_c sig2unsig_c ;
+- typedef mpl::integral_c unsig2sig_c ;
++ typedef boost::integral_constant unsig2unsig_c ;
++ typedef boost::integral_constant sig2sig_c ;
++ typedef boost::integral_constant sig2unsig_c ;
++ typedef boost::integral_constant unsig2sig_c ;
+
+ // Metafunction:
+ //
+diff --git a/include/boost/numeric/conversion/detail/udt_builtin_mixture.hpp b/include/boost/numeric/conversion/detail/udt_builtin_mixture.hpp
+index 36dbc49..a39d29f 100644
+--- a/include/boost/numeric/conversion/detail/udt_builtin_mixture.hpp
++++ b/include/boost/numeric/conversion/detail/udt_builtin_mixture.hpp
+@@ -15,15 +15,15 @@
+ #include "boost/numeric/conversion/udt_builtin_mixture_enum.hpp"
+ #include "boost/numeric/conversion/detail/meta.hpp"
+
+-#include "boost/mpl/integral_c.hpp"
++#include "boost/type_traits/integral_constant.hpp"
+
+ namespace boost { namespace numeric { namespace convdetail
+ {
+ // Integral Constants for 'UdtMixture'
+- typedef mpl::integral_c builtin2builtin_c ;
+- typedef mpl::integral_c builtin2udt_c ;
+- typedef mpl::integral_c udt2builtin_c ;
+- typedef mpl::integral_c udt2udt_c ;
++ typedef boost::integral_constant builtin2builtin_c ;
++ typedef boost::integral_constant builtin2udt_c ;
++ typedef boost::integral_constant udt2builtin_c ;
++ typedef boost::integral_constant udt2udt_c ;
+
+ // Metafunction:
+ //
diff --git a/CONTRIBUTING.md b/doc/CONTRIBUTING.md
similarity index 100%
rename from CONTRIBUTING.md
rename to doc/CONTRIBUTING.md
diff --git a/DEVELOPING.md b/doc/DEVELOPING.md
similarity index 63%
rename from DEVELOPING.md
rename to doc/DEVELOPING.md
index 1de87fcc6..4b6302daf 100644
--- a/DEVELOPING.md
+++ b/doc/DEVELOPING.md
@@ -89,6 +89,41 @@ After successfully compiling Hush, you can generate a debian package of these bi
This command will not work on Mac OS X. Currently you cannot generate a Debian package
from operating systems other than Linux. Oh well.
+## Adding new CLI options that change consensus rules
+
+If you are adding a new CLI option that changes consensus rules such as
+`-ac_foo` then make sure to also modify the the `extraptr` variable in
+`src/hush_utils.h` with the value of the `ASSETCHAINS_FOO` variable. Our
+convention is that if a CLI option affects consensus, it MUST begin with `-ac_`
+and if it does not affect consensus (such as -datadir) then it MUST NOT begin
+with `-ac_`. Originally the `ac` meant "asset chain" but now it means "affects
+consensus" or "arrakis chain", take your pick.
+
+The reason for this is the `extraptr` variable is used to deterministically
+generate the "chain magic" `ASSETCHAINS_MAGIC` as well as the default p2p and
+rpc ports for a HAC. This means that if two HACs have *exactly* the same
+consensus options except for `-ac_foo` (even if they have the same `-ac_name`)
+then they will still get different chain magic values and p2p and rpc ports.
+This is a way of preventing HACs with different consensus rules from trying to
+talk with each other when they should not. For instance, if you make a HAC with
+`-ac_name=MYCOIN` on one machine with one set of consensus rules and then
+another HAC with the same name on a different machine but with different
+consensus rules, the chain magic being different (as well as the default p2p
+port) are ways to prevent them from communicating. This is good because these
+two HACs will eventually chain fork due to their different consensus rules and
+ban each other, wasting time, bandwidth and sanity.
+
+An example of doing this can be seen in the commit
+https://git.hush.is/hush/hush3/commit/d39503c13b7419620d138050899705ced557eef9
+which added the `-ac_burn` consensus changing option.
+
+The chain magic value is the CRC32 checksum of every non-default consensus
+option the HAC uses.
+
+Also make sure to actually validate the new consensus option! That is probably
+going to happen in `src/main.cpp` . If you don't, a malicious node can just
+modify `src/miner.cpp` to do whatever they want.
+
## Updates to this document
If you think something else should be in this guide, please send your suggestions!
diff --git a/OLD_WALLETS.md b/doc/OLD_WALLETS.md
similarity index 100%
rename from OLD_WALLETS.md
rename to doc/OLD_WALLETS.md
diff --git a/doc/bips.md b/doc/bips.md
deleted file mode 100644
index 35ef70c65..000000000
--- a/doc/bips.md
+++ /dev/null
@@ -1,4 +0,0 @@
-BIPs that are implemented by Hush (up-to-date up to **v1.1.0**):
-
-* Numerous historic BIPs were present in **v1.0.0** at launch; see [the protocol spec](https://github.com/zcash/zips/blob/master/protocol/protocol.pdf) for details.
-* [`BIP 111`](https://github.com/bitcoin/bips/blob/master/bip-0111.mediawiki): `NODE_BLOOM` service bit added, but only enforced for peer versions `>=170004` as of **v1.1.0** ([PR #2814](https://github.com/zcash/zcash/pull/2814)).
diff --git a/doc/cjdns.md b/doc/cjdns.md
index 4b47bb8ac..17f5773d2 100644
--- a/doc/cjdns.md
+++ b/doc/cjdns.md
@@ -106,10 +106,7 @@ details.
## CJDNS-related information in Hush
There are several ways to see your CJDNS address in Hush:
-- in the "Local addresses" output of CLI `-netinfo`
- in the "localaddresses" output of RPC `getnetworkinfo`
-To see which CJDNS peers your node is connected to, use `hush-cli -netinfo 4`
-or the `getpeerinfo` RPC (i.e. `hush-cli getpeerinfo`).
-
-You can use the `getnodeaddresses` RPC to fetch a number of CJDNS peers known to your node; run `hush-cli help getnodeaddresses` for details.
+To see which CJDNS peers your node is connected to, use `hush-cli getpeerinfo`
+RPC.
diff --git a/doc/developer-notes.md b/doc/developer-notes.md
index df090cd05..e83a92145 100644
--- a/doc/developer-notes.md
+++ b/doc/developer-notes.md
@@ -18,8 +18,8 @@ git checkout dev
Then install needed dependencies. This is different on each OS as well as
older or newer systems. See https://git.hush.is/hush/hush3/src/branch/dev/INSTALL.md for
-details on installing dependencies. If you are using a recent-ish Linux distro, this
-is probably what you need:
+details on installing dependencies. If you are using a recent-ish Ubuntu or Debian Linux
+distro, this is probably what you need:
```
# install build dependencies
diff --git a/doc/help.md b/doc/help.md
new file mode 100644
index 000000000..b0559a221
--- /dev/null
+++ b/doc/help.md
@@ -0,0 +1,52 @@
+# How To Fix Various Problems
+
+This document will document how to recover and fix various issues that users may run into.
+
+## Database corruption
+
+The problem: You see an error like
+
+```
+EXCEPTION: 15dbwrapper_error
+Database corrupted
+```
+
+This means your blockchain data on disk is corrupted. This is not the same as wallet corruption.
+The fix to this is to do a fresh sync using the same wallet.dat file. You need to find
+where this data lives on your computer and then move some files around, then restart the wallet.
+
+### On Linux
+
+If you are on Linux, your wallet lives at `~/.hush/HUSH3/wallet.dat` or if you have a really old
+legacy wallet it could be at `~/.komodo/HUSH3/wallet.dat` . We will assume the first location.
+
+What we will do is backup your entire `HUSH3` directory, including the blockchain data and wallet,
+then copy the wallet from there into a new directory. This is a non-destructive process that creates
+a new backup of your wallet.
+
+```
+# Make sure your node is not running before doing any of this!
+# Doing this while your node is running could corrupt your wallet.dat
+cd ~/.hush
+mv HUSH3 HUSH3-backup # backup all data
+mkdir HUSH3 # make a new dir
+cp HUSH3-backup/wallet.dat HUSH3/wallet.dat # copy old wallet to new dir
+```
+
+At this point if you are GUI user using SilentDragon, you can restart the GUI wallet
+and it should perform a fresh sync with your wallet. This will likely take at least
+a few hours or much longer depending on your internet connection.
+
+### On Windows
+
+Basically you want to find where your Hush wallet is, move the directory that contains
+that wallet.dat file to a new name, then create that same directory and then copy wallet.dat into it.
+Different versions of Windows store things in different locations.
+
+For example your wallet might be in `C:\Users\Admin\AppData\Roaming\Hush\HUSH3\wallet.dat` .
+That means you need to
+
+ * Rename the directory `C:\Users\Admin\AppData\Roaming\Hush\HUSH3` to something like `C:\Users\Admin\AppData\Roaming\Hush\HUSH3-backup`
+ * Create a new directory called `C:\Users\Admin\AppData\Roaming\Hush\HUSH3`
+ * Copy the file `C:\Users\Admin\AppData\Roaming\Hush\HUSH3-backup\wallet.dat` to `C:\Users\Admin\AppData\Roaming\Hush\HUSH3`
+ * Now start the SilentDragon GUI wallet
diff --git a/doc/hsc.md b/doc/hsc.md
index 3ff3bc263..1636419b6 100644
--- a/doc/hsc.md
+++ b/doc/hsc.md
@@ -1,10 +1,10 @@
-# Hush Smart Chains
+# Hush Arrakis Chains
An overview of HSCs can be found here:
https://git.hush.is/hush/hush-smart-chains
-Hush Smart Chains allow you to create a privacy coin with no custom C++ code, just running one command!
+Hush Arrakis Chains allow you to create a privacy coin with no custom C++ code, just running one command!
The new coin that is created can use either Equihash PoW (ASIC or GPU) or RandomX PoW (CPU).
## HSC Creator
@@ -13,7 +13,7 @@ https://git.hush.is/hush/hsc-creator with its site https://hush.is/hsc-creator
## HSC HOWTO
-https://git.hush.is/onryo/hush-smart-chain-how-to
+https://git.hush.is/onryo/hush-arrakis-chain-how-to
## HSC CLI
diff --git a/doc/hush/earnhush.png b/doc/hush/earnhush.png
new file mode 100644
index 000000000..9437fb259
Binary files /dev/null and b/doc/hush/earnhush.png differ
diff --git a/doc/hush/hush0.png b/doc/hush/hush0.png
new file mode 100644
index 000000000..32f77375d
Binary files /dev/null and b/doc/hush/hush0.png differ
diff --git a/doc/i2p.md b/doc/i2p.md
index 8cc3a6557..3e5fabb39 100644
--- a/doc/i2p.md
+++ b/doc/i2p.md
@@ -100,15 +100,11 @@ address.
There are several ways to see your I2P address if accepting
incoming I2P connections (`-i2pacceptincoming`):
-- in the "Local addresses" output of CLI `-netinfo`
- in the "localaddresses" output of RPC `getnetworkinfo`
- in the debug log (grep for `AddLocal`; the I2P address ends in `.b32.i2p`)
- in the i2p/i2pd web console under "SAM Sessions"
-To see which I2P peers your node is connected to, use `hush-cli -netinfo 4`
-or the `getpeerinfo` RPC (e.g. `hush-cli getpeerinfo`).
-
-To see which I2P addresses your node knows, use the `getnodeaddresses 0 i2p`
+To see which I2P peers your node is connected to, use `hush-cli getpeerinfo`
RPC.
## Compatibility
diff --git a/doc/man/hush-cli.1 b/doc/man/hush-cli.1
index bab9652d0..8547a839a 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.49.3.
-.TH HUSH-CLI "1" "February 2024" "hush-cli v3.10.2" "User Commands"
+.\" DO NOT MODIFY THIS FILE! It was generated by help2man 1.47.13.
+.TH HUSH-CLI "1" "July 2025" "hush-cli v3.10.4" "User Commands"
.SH NAME
-hush-cli \- manual page for hush-cli v3.10.2
+hush-cli \- manual page for hush-cli v3.10.4
.SH DESCRIPTION
-Hush RPC client version v3.10.2\-138cd7ab6
+Hush RPC client version v3.10.4\-7e63e2f01\-dirty
.PP
In order to ensure you are adequately protecting your privacy when using Hush,
please see .
@@ -75,7 +75,7 @@ Read extra arguments from standard input, one per line until EOF/Ctrl\-D
In order to ensure you are adequately protecting your privacy when using Hush,
please see .
-Copyright (C) 2016-2024 Duke Leto and The Hush Developers
+Copyright (C) 2016-2025 Duke Leto and The Hush Developers
Copyright (C) 2016-2020 jl777 and SuperNET developers
diff --git a/doc/man/hush-tx.1 b/doc/man/hush-tx.1
index 69b6f9477..939d2deed 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.49.3.
-.TH HUSH-TX "1" "February 2024" "hush-tx v3.10.2" "User Commands"
+.\" DO NOT MODIFY THIS FILE! It was generated by help2man 1.47.13.
+.TH HUSH-TX "1" "July 2025" "hush-tx v3.10.4" "User Commands"
.SH NAME
-hush-tx \- manual page for hush-tx v3.10.2
+hush-tx \- manual page for hush-tx v3.10.4
.SH DESCRIPTION
-hush\-tx utility version v3.10.2\-138cd7ab6
+hush\-tx utility version v3.10.4\-7e63e2f01\-dirty
.SS "Usage:"
.TP
hush\-tx [options] [commands]
@@ -89,7 +89,7 @@ Set register NAME to given JSON\-STRING
In order to ensure you are adequately protecting your privacy when using Hush,
please see .
-Copyright (C) 2016-2024 Duke Leto and The Hush Developers
+Copyright (C) 2016-2025 Duke Leto and The Hush Developers
Copyright (C) 2016-2020 jl777 and SuperNET developers
diff --git a/doc/man/hushd.1 b/doc/man/hushd.1
index 4164550cc..4eda8843a 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.49.3.
-.TH HUSHD "1" "February 2024" "hushd v3.10.2" "User Commands"
+.\" DO NOT MODIFY THIS FILE! It was generated by help2man 1.47.13.
+.TH HUSHD "1" "July 2025" "hushd v3.10.4" "User Commands"
.SH NAME
-hushd \- manual page for hushd v3.10.2
+hushd \- manual page for hushd v3.10.4
.SH DESCRIPTION
-Hush Daemon version v3.10.2\-138cd7ab6
+Hush Daemon version v3.10.4\-7e63e2f01\-dirty
.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\-12\fR to 16, 0 = auto, <0 =
+Set the number of script verification threads (\fB\-8\fR to 16, 0 = auto, <0 =
leave that many cores free, default: 0)
.HP
\fB\-pid=\fR
@@ -245,6 +245,11 @@ Disable Ipv4 network connections (default: 0)
.IP
Disable Ipv6 network connections (default: 0)
.HP
+\fB\-clearnet\fR
+.IP
+Enable clearnet connections. Setting to 0 will disable clearnet and use
+sane defaults for Tor/i2p (default: 1)
+.HP
\fB\-permitbaremultisig\fR
.IP
Relay non\-P2SH multisig (default: 1)
@@ -395,11 +400,6 @@ Keep the last transactions (default: 200)
.IP
Keep transactions for at least blocks (default: 10000)
.HP
-\fB\-opretmintxfee=\fR
-.IP
-Minimum fee (in HUSH/kB) to allow for OP_RETURN transactions (default:
-400000)
-.HP
\fB\-paytxfee=\fR
.IP
Fee (in HUSH/kB) to add to transactions you send (default: 0.00)
@@ -674,6 +674,14 @@ Block time in seconds, default is 60
.IP
BEAM integration
.HP
+\fB\-ac_burn\fR
+.IP
+Allow sending funds to the transparent burn address when \fB\-ac_private\fR=\fI\,1\/\fR
+.HP
+\fB\-ac_minopreturnfee\fR
+.IP
+OP_RETURN minimum fee per tx, regardless of tx size, default is 1 coin
+.HP
\fB\-ac_coda\fR
.IP
CODA integration
@@ -751,7 +759,7 @@ Enforce transaction\-rate limit, default 0
In order to ensure you are adequately protecting your privacy when using Hush,
please see .
-Copyright (C) 2016-2024 Duke Leto and The Hush Developers
+Copyright (C) 2016-2025 Duke Leto and The Hush Developers
Copyright (C) 2016-2020 jl777 and SuperNET developers
diff --git a/doc/randomx.md b/doc/randomx.md
index a690ded2b..1075c8890 100644
--- a/doc/randomx.md
+++ b/doc/randomx.md
@@ -1,9 +1,9 @@
# RandomX
-Hush Smart Chains support using RandomX as a Proof-Of-Work algorithm as of release 3.9.2 .
+Hush Arrakis Chains support using RandomX as a Proof-Of-Work algorithm as of release 3.9.2 .
This means you can now launch a privacy coin with Hush tech that can be mined with a CPU
instead of requiring an ASIC or GPU. RandomX is the same algorithm that Monero (XMR) and
-various other cryptocoins use. As far as we know, Hush Smart Chains are the first coins
+various other cryptocoins use. As far as we know, Hush Arrakis Chains are the first coins
based on Zcash Protocol that can use the RandomX PoW algorithm. Many thanks to all the
people who helped make this possible.
@@ -13,12 +13,12 @@ The following command can be used to launch an HSC on a single computer. Each op
HSC CLI arguments that start with `-ac_` means they *Affect Consensus*.
```
-./src/hush-smart-chain -ac_halving=100 -ac_algo=randomx -ac_name=RANDOMX -ac_private=1 -ac_blocktime=15 -ac_reward=500000000 -ac_supply=55555 -gen=1 -genproclimit=1 -testnode=1
+./src/hush-arrakis-chain -ac_halving=100 -ac_algo=randomx -ac_name=RANDOMX -ac_private=1 -ac_blocktime=15 -ac_reward=500000000 -ac_supply=55555 -gen=1 -genproclimit=1 -testnode=1
```
- * `hush-smart-chain` is the script used to launch or connect to HSCs
+ * `hush-arrakis-chain` is the script used to launch or connect to HSCs
* It lives in the `./src` directory, next to `hushd` and `hush-cli`
- * It is called `hush-smart-chain.bat` on Windows
+ * It is called `hush-arrakis-chain.bat` on Windows
* `-ac_halving=100` means "the block reward halves every 100 blocks"
* `-ac_algo=randomx` means "use RandomX for Proof-Of-Work
* The default is Equihash (200,9)
@@ -41,12 +41,12 @@ HSC CLI arguments that start with `-ac_` means they *Affect Consensus*.
* One node would use
```
# first node
-./src/hush-smart-chain -ac_halving=100 -ac_algo=randomx -ac_name=RANDOMX -ac_private=1 -ac_blocktime=15 -ac_reward=500000000 -ac_supply=55555
+./src/hush-arrakis-chain -ac_halving=100 -ac_algo=randomx -ac_name=RANDOMX -ac_private=1 -ac_blocktime=15 -ac_reward=500000000 -ac_supply=55555
```
* And the second node would use:
```
# mining node. NOTE: This node will mine the genesis block and pre-mine, if any
-./src/hush-smart-chain -ac_halving=100 -ac_algo=randomx -ac_name=RANDOMX -ac_private=1 -ac_blocktime=15 -ac_reward=500000000 -ac_supply=55555 -gen=1 -genproclimit=1
+./src/hush-arrakis-chain -ac_halving=100 -ac_algo=randomx -ac_name=RANDOMX -ac_private=1 -ac_blocktime=15 -ac_reward=500000000 -ac_supply=55555 -gen=1 -genproclimit=1
```
# Advanced Options
@@ -67,7 +67,7 @@ HUSH RandomX currently has two advanced options that some may want to use:
This section is not required reading if you just want to use it as a PoW algorithm for an HSC. Here we will explain how the internals of RandomX works inside of the Hush codebase.
-We use the official RandomX implementation from https://github.com/tevador/RandomX with custom configuration options. If some type of hardware is created to mine the XMR RandomX algorithm, it will not be compatible with the Hush RandomX algorithm. This is by design. All Hush Smart Chains use the same RandomX config options, so if a hardware device is created to mine one HSC that uses RandomX, it can be used to mine any HSC using RandomX. Every HSC with unique consensus parameters will start off with it's own unique key block with at least 9 bytes of entropy.
+We use the official RandomX implementation from https://github.com/tevador/RandomX with custom configuration options. If some type of hardware is created to mine the XMR RandomX algorithm, it will not be compatible with the Hush RandomX algorithm. This is by design. All Hush Arrakis Chains use the same RandomX config options, so if a hardware device is created to mine one HSC that uses RandomX, it can be used to mine any HSC using RandomX. Every HSC with unique consensus parameters will start off with it's own unique key block with at least 9 bytes of entropy.
The source code of RandomX is embedded in the Hush source code at `./src/RandomX` and the configuration options used are at `./src/RandomX/src/configuration.h` .
diff --git a/doc/release-process.md b/doc/release-process.md
index 566de1b1f..c1adb3269 100644
--- a/doc/release-process.md
+++ b/doc/release-process.md
@@ -58,7 +58,7 @@ Look for Git issues that should be fixed in the next release. Especially low-ris
Install deps on Linux:
- apt-get install help2man debchange
+ apt-get install help2man devscripts
## Release process
- If new seeds are being added or seeds are changing:
@@ -111,20 +111,24 @@ Install deps on Linux:
- Make sure git tag starts with a `v` such as `v3.9.2`
- Use util/gen-linux-binary-release.sh to make a Linux release binary
- Upload Linux binary to Gitea release and add SHA256 sum
- - Use util/build-debian-package.sh to make an x86 Debian package for the release
+ - Create an x86 Debian package for the release:
+ - Edit contrib/debian/changelog to add information about the new release
+ - Use `util/build-debian-package.sh` to make an x86 Debian package for the release
- Debian packages should be done after you make manpages, because those are included in Debian packages
- `lintian` is an optional dependency, it's not needed to build the .deb
- Upload .deb to Gitea release
- Add SHA256 checksum of .deb to release
- Use util/build-debian-package-ARM.sh (does this still work?) to make an ARM Debian package for the release
- Upload the debian packages to the Gitea release page, with SHA256 sums
- - Figure out how to update https://faq.hush.is/rpc/ for new release
+ - Update the rpc.hush.is repo for new release by [following these instructions](https://git.hush.is/hush/rpc.hush.is/src/branch/master/README.md)
+ - Update https://faq.hush.is/rpc/ for new release after updating the rpc.hush.is repo
## Platform-specific notes
-Use `./util/build-mac.sh` to compile on Apple/Mac systems, use `./util/build-win.sh` to build on Windows and `./util/build-arm.sh` to build on ARMv8 systems.
-
-Use `./util/build-debian-package.sh aarch64` to build a Debian package for aarch64 .
+- Use `./util/build-mac.sh` to compile on Apple/Mac systems
+- Use `./util/build-win.sh` to build on Windows
+- Use [these cross compile instructions](https://git.hush.is/jahway603/hush-docs/src/branch/master/advanced/cross-compile-hush-full-node-to-aarch64-with-docker.md) to build the release for ARMv8 (aarch64) systems, as the current build system does not permit us to natively build this on the SBC device
+ - Then use `./util/build-debian-package.sh aarch64` to build a Debian package for ARMv8 (aarch64)
## Optional things
diff --git a/doc/relnotes/README.md b/doc/relnotes/README.md
index 89d526429..21d952a27 100644
--- a/doc/relnotes/README.md
+++ b/doc/relnotes/README.md
@@ -8,7 +8,59 @@ and now are officially part of our Git repo.
Hush releases are on our own Gitea at git.hush.is
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.
+evil organizations. They also use all your "private" repos to train their AI.
+
+# Hush 3.10.4 "Hazy Hākuturi"
+
+This is an OPTIONAL but RECOMMENDED upgrade. Some seed nodes have changed so if you are having
+problems finding nodes, you want to upgrade.
+
+ * `z_sendmany` changes:
+ * Now supports UTF8 strings as memos instead of requiring hex
+ * Give a memo as "utf8:this is my memo" and it will automatically be hex encoded
+ * New optional 5th argument to `z_sendmany` allows specifying an `OP_RETURN` for the transaction
+ * `OP_RETURN` can also be specified as a UTF8 string with 'utf8:' prefix or hex encoded
+ * Updated seed node list
+ * New CLI option -clearnet=0 which disables clearnet networking, i.e. only Tor or i2p are allowed
+ * Note that at least one of a Tor or i2p daemon are needed for -clearnet=0, both are not needed but supported
+ * -clearnet=0 is equivalent to the following CLI params:
+```
+-disableipv4=1
+-disableipv6=1
+-dns=0
+-dnsseed=0
+-bind=127.0.0.1
+-onlynet="onion"
+-onlynet="i2p"
+-onion="127.0.0.1:9050
+-i2psam="127.0.0.1:7656"
+```
+ * Using -mineraddress with -clearnet=0 is disallowed since it would reduce privacy
+ * Add CLI options `-disableipv4` and `-disableipv6` which can be used to disable IPv4 or IPv6
+ * New HAC CLI consensus option `-ac_minopreturnfee`
+ * `OP_RETURN` minimum fee per tx, regardless of tx size, default is 1 coin, specified in puposhis
+ * Updated ASmap, which maps IP addresses to Autonomous System (AS) numbers
+ * Added ASmap health check, which logs stats about the ASmap once per 24 hours
+ * Improved cjdns/i2p/tor docs
+ * Updated protocol version
+ * Fixed warnings caused by newer compilers
+
+# Hush 3.10.3 "Persistent Pezoporus"
+
+ * Use WolfSSL 4.8.1 which prevents nodes from getting stuck in general and when shutting down
+ * Set minimum fee to 0.1 HUSH per 1 KB of data if `OP_RETURN` is used.
+ * A feature in absurd fee that allows sending amount < fee, can be used only in a full node by advanced users.
+ * Fixed various bugs relating to lock ordering and missing locks
+ * Fixed RPC docs for addnode and disconnectnode having the incorrect port for HACs
+ * Value of DEBUG_LOCKORDER is now logged to debug.log on node startup
+ * New script ./debug-build.sh to make it easier to make debug builds
+ * DragonX nodes now have their own list of seed nodes
+ * Hush nodes now have their own protocol version which is independent from HACs
+ * Fixed off-by-one bug in `newSietchRecipient`
+ * Performance improvement to `ActivateBestChainStep` https://git.hush.is/hush/hush3/commit/ed86f2dd1da370fe2dbf7db475afc41b218cbc5f
+ * Improved navigation in README for new users.
+ * Updated doc/release-process.md to resolve Issue #407
+ * Added build.sh checks for as and ld to be installed to resolve Issue #73
# Hush 3.10.2 "Fiendish Fenrir"
diff --git a/doc/tor.md b/doc/tor.md
index fe0608888..002b95754 100644
--- a/doc/tor.md
+++ b/doc/tor.md
@@ -16,7 +16,6 @@ configure Tor.
## How to see information about your Tor configuration via Hush
There are several ways to see your local onion address in Hush:
-- in the "Local addresses" output of CLI `-netinfo`
- in the "localaddresses" output of RPC `getnetworkinfo`
- in the debug log (grep for "AddLocal"; the Tor address ends in `.onion`)
@@ -27,9 +26,6 @@ CLI `-addrinfo` returns the number of addresses known to your node per
network. This can be useful to see how many onion peers your node knows,
e.g. for `-onlynet=onion`.
-To fetch a number of onion addresses that your node knows, for example seven
-addresses, use the `getnodeaddresses 7 onion` RPC.
-
## 1. Run Hush behind a Tor proxy
The first step is running Hush behind a Tor proxy. This will already anonymize all
diff --git a/migratecoin.sh b/migratecoin.sh
deleted file mode 100644
index a4b05f417..000000000
--- a/migratecoin.sh
+++ /dev/null
@@ -1,43 +0,0 @@
-#!/usr/usr/bin/env bash
-# Copyright (c) 2016-2024 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 makes the neccesary transactions to migrate
-# coin between 2 assetchains on the same -ac_cc id
-set -e
-source=DERPZ
-target=DERPZ000
-address="Rxxx"
-amount=1
-
-# Alias for running cli on source chain
-cli_source="hush-cli -ac_name=$source"
-
-# Raw tx that we will work with
-txraw=`$cli_source createrawtransaction "[]" "{\"$address\":$amount}"`
-
-# Convert to an export tx
-exportData=`$cli_source migrate_converttoexport $txraw $target $amount`
-exportRaw=`echo $exportData | jq -r .exportTx`
-exportPayouts=`echo $exportData | jq -r .payouts`
-
-# Fund
-exportFundedData=`$cli_source fundrawtransaction $exportRaw`
-exportFundedTx=`echo $exportFundedData | jq -r .hex`
-
-# Sign
-exportSignedData=`$cli_source signrawtransaction $exportFundedTx`
-exportSignedTx=`echo $exportSignedData | jq -r .hex`
-
-# Send
-echo "Sending export tx"
-$cli_source sendrawtransaction $exportSignedTx
-
-read -p "Wait for a notarization to HUSH, and then two more notarizations from the target chain, and then press enter to continue"
-
-# Create import
-importTx=`$cli_source migrate_createimporttransaction $exportSignedTx $payouts`
-importTx=`hush-cli migrate_completeimporttransaction $importTx`
-
-# Send import
-hush-cli -ac_name=$target sendrawtransaction $importTx
diff --git a/qa/hush/create_benchmark_archive.py b/qa/hush/create_benchmark_archive.py
index 612d5bcad..15994b1a6 100644
--- a/qa/hush/create_benchmark_archive.py
+++ b/qa/hush/create_benchmark_archive.py
@@ -1,3 +1,4 @@
+#!/usr/bin/env python2
# Copyright (c) 2016-2024 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
diff --git a/qa/rpc-tests/test_framework/authproxy.py b/qa/rpc-tests/test_framework/authproxy.py
index 158fc04e9..366140aab 100644
--- a/qa/rpc-tests/test_framework/authproxy.py
+++ b/qa/rpc-tests/test_framework/authproxy.py
@@ -1,3 +1,4 @@
+#!/usr/bin/env python2
# Copyright (c) 2016-2024 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
diff --git a/qa/rpc-tests/test_framework/bignum.py b/qa/rpc-tests/test_framework/bignum.py
index f77bc2226..de5bf3f0e 100644
--- a/qa/rpc-tests/test_framework/bignum.py
+++ b/qa/rpc-tests/test_framework/bignum.py
@@ -1,3 +1,4 @@
+#!/usr/bin/env python2
# Copyright (c) 2016-2024 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
diff --git a/qa/rpc-tests/test_framework/blockstore.py b/qa/rpc-tests/test_framework/blockstore.py
index e1ecf7648..5a3e911e2 100644
--- a/qa/rpc-tests/test_framework/blockstore.py
+++ b/qa/rpc-tests/test_framework/blockstore.py
@@ -1,3 +1,4 @@
+#!/usr/bin/env python2
# Copyright (c) 2016-2024 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
diff --git a/qa/rpc-tests/test_framework/blocktools.py b/qa/rpc-tests/test_framework/blocktools.py
index 5e87321ec..6f111f3bf 100644
--- a/qa/rpc-tests/test_framework/blocktools.py
+++ b/qa/rpc-tests/test_framework/blocktools.py
@@ -1,3 +1,4 @@
+#!/usr/bin/env python2
# Copyright (c) 2016-2024 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
diff --git a/qa/rpc-tests/test_framework/equihash.py b/qa/rpc-tests/test_framework/equihash.py
index c19b24217..7a182274d 100755
--- a/qa/rpc-tests/test_framework/equihash.py
+++ b/qa/rpc-tests/test_framework/equihash.py
@@ -1,3 +1,4 @@
+#!/usr/bin/env python2
# Copyright (c) 2016-2024 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
diff --git a/qa/rpc-tests/test_framework/mininode.py b/qa/rpc-tests/test_framework/mininode.py
index 4a7624cc8..69120e5b8 100755
--- a/qa/rpc-tests/test_framework/mininode.py
+++ b/qa/rpc-tests/test_framework/mininode.py
@@ -1,3 +1,4 @@
+#!/usr/bin/env python2
# Copyright (c) 2016-2024 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
diff --git a/qa/rpc-tests/test_framework/script.py b/qa/rpc-tests/test_framework/script.py
index 67a868cf6..29ac60ab7 100644
--- a/qa/rpc-tests/test_framework/script.py
+++ b/qa/rpc-tests/test_framework/script.py
@@ -1,3 +1,4 @@
+#!/usr/bin/env python2
# Copyright (c) 2016-2024 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
diff --git a/qa/rpc-tests/test_framework/socks5.py b/qa/rpc-tests/test_framework/socks5.py
index 36e2d66b3..16a2d4cbe 100644
--- a/qa/rpc-tests/test_framework/socks5.py
+++ b/qa/rpc-tests/test_framework/socks5.py
@@ -1,3 +1,4 @@
+#!/usr/bin/env python2
# Copyright (c) 2016-2024 The Hush developers
# Copyright (c) 2015 The Bitcoin Core developers
# Distributed under the GPLv3 software license, see the accompanying
diff --git a/qa/rpc-tests/test_framework/test_framework.py b/qa/rpc-tests/test_framework/test_framework.py
index ff9cfaea6..273d9c6bf 100755
--- a/qa/rpc-tests/test_framework/test_framework.py
+++ b/qa/rpc-tests/test_framework/test_framework.py
@@ -162,10 +162,10 @@ class ComparisonTestFramework(BitcoinTestFramework):
def add_options(self, parser):
parser.add_option("--testbinary", dest="testbinary",
- default=os.getenv("BITCOIND", "hush-smart-chain"),
+ default=os.getenv("BITCOIND", "hush-arrakis-chain"),
help="bitcoind binary to test")
parser.add_option("--refbinary", dest="refbinary",
- default=os.getenv("BITCOIND", "hush-smart-chain"),
+ default=os.getenv("BITCOIND", "hush-arrakis-chain"),
help="bitcoind binary to use for reference nodes (if any)")
def setup_chain(self):
diff --git a/src/Makefile.am b/src/Makefile.am
index 846c941fb..d6ed7eb41 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -251,7 +251,7 @@ LIBHUSH_H = \
obj/build.h: FORCE
@$(MKDIR_P) $(builddir)/obj
- @$(top_srcdir)/share/genbuild.sh $(abs_top_builddir)/src/obj/build.h \
+ @$(top_srcdir)/util/genbuild.sh $(abs_top_builddir)/src/obj/build.h \
$(abs_top_srcdir)
libbitcoin_util_a-clientversion.$(OBJEXT): obj/build.h
diff --git a/src/bitcoin-cli.cpp b/src/bitcoin-cli.cpp
index e37305ae3..15a726d09 100644
--- a/src/bitcoin-cli.cpp
+++ b/src/bitcoin-cli.cpp
@@ -87,7 +87,7 @@ static int AppInitRPC(int argc, char* argv[])
ParseParameters(argc, argv);
std:string name;
- // default HSC is HUSH3 itself, which to the internals, is also an HSC
+ // default HAC is HUSH3 itself, which to the internals, is also a HAC
name = GetArg("-ac_name","HUSH3");
if ( !name.empty() )
diff --git a/src/bitcoind.cpp b/src/bitcoind.cpp
index 609fb5555..22bffe71a 100644
--- a/src/bitcoind.cpp
+++ b/src/bitcoind.cpp
@@ -74,30 +74,17 @@ void WaitForShutdown(boost::thread_group* threadGroup)
while (!fShutdown)
{
- //fprintf(stderr,"call passport iteration\n");
- if ( SMART_CHAIN_SYMBOL[0] == 0 )
- {
- if ( HUSH_NSPV_FULLNODE )
- hush_passport_iteration();
- for (i=0; i<10; i++)
- {
- fShutdown = ShutdownRequested();
- if ( fShutdown != 0 )
- break;
- MilliSleep(1000);
- }
- } else {
- //hush_longestchain();
- if ( ASSETCHAINS_CBOPRET != 0 )
- hush_cbopretupdate(0);
- for (i=0; i<=ASSETCHAINS_BLOCKTIME/5; i++)
- {
- fShutdown = ShutdownRequested();
- if ( fShutdown != 0 )
- break;
- MilliSleep(1000);
- }
- }
+ //hush_longestchain();
+ if ( ASSETCHAINS_CBOPRET != 0 )
+ hush_cbopretupdate(0);
+ for (i=0; i<=ASSETCHAINS_BLOCKTIME/5; i++)
+ {
+ fShutdown = ShutdownRequested();
+ if ( fShutdown != 0 )
+ break;
+ MilliSleep(1000);
+ }
+
fShutdown = ShutdownRequested();
}
//fprintf(stderr,"%s: fShutdown=%d\n", __FUNCTION__, fShutdown);
diff --git a/src/cc/CCinclude.h b/src/cc/CCinclude.h
index 29cc60d6c..0c7737234 100644
--- a/src/cc/CCinclude.h
+++ b/src/cc/CCinclude.h
@@ -47,49 +47,6 @@
#define SATOSHIDEN ((uint64_t)100000000L)
#define dstr(x) ((double)(x) / SATOSHIDEN)
#define CCDISABLEALL memset(ASSETCHAINS_CCDISABLES,1,sizeof(ASSETCHAINS_CCDISABLES))
-#define CCENABLE(x) ASSETCHAINS_CCDISABLES[((uint8_t)x)] = 0
-
-/* moved to hush_cJSON.h
-#ifndef _BITS256
-#define _BITS256
- union _bits256 { uint8_t bytes[32]; uint16_t ushorts[16]; uint32_t uints[8]; uint64_t ulongs[4]; uint64_t txid; };
- typedef union _bits256 bits256;
-#endif
-*/
-/// \endcond
-
-/// identifiers of additional data blobs in token opreturn script:
-/// @see EncodeTokenCreateOpRet(uint8_t funcid, std::vector origpubkey, std::string name, std::string description, std::vector> oprets)
-/// @see GetOpretBlob
-enum opretid : uint8_t {
- // cc contracts data:
- OPRETID_NONFUNGIBLEDATA = 0x11, //!< NFT data id
- OPRETID_ASSETSDATA = 0x12, //!< assets contract data id
- OPRETID_GATEWAYSDATA = 0x13, //!< gateways contract data id
- OPRETID_CHANNELSDATA = 0x14, //!< channels contract data id
- OPRETID_HEIRDATA = 0x15, //!< heir contract data id
- OPRETID_ROGUEGAMEDATA = 0x16, //!< rogue contract data id
- OPRETID_PEGSDATA = 0x17, //!< pegs contract data id
-
- /*! \cond INTERNAL */
- // non cc contract data:
- OPRETID_FIRSTNONCCDATA = 0x80,
- /*! \endcond */
- OPRETID_BURNDATA = 0x80, //!< burned token data id
- OPRETID_IMPORTDATA = 0x81 //!< imported token data id
-};
-
-/// finds opret blob data by opretid in the vector of oprets
-/// @param oprets vector of oprets
-/// @param id opret id to search
-/// @param vopret found opret blob as byte array
-/// @returns true if found
-/// @see opretid
-inline bool GetOpretBlob(const std::vector>> &oprets, uint8_t id, std::vector &vopret) {
- vopret.clear();
- for(auto p : oprets) if (p.first == id) { vopret = p.second; return true; }
- return false;
-}
/// \cond INTERNAL
struct CC_utxo
@@ -100,16 +57,6 @@ struct CC_utxo
};
/// \endcond
-/// \cond INTERNAL
-struct CC_meta
-{
- std::vector version;
- uint8_t evalCode;
- bool is1of2;
- uint8_t numDestinations;
- // followed by address destinations
-};
-/// \endcond
/// CC contract (Antara module) info structure that contains data used for signing and validation of cc contract transactions
struct CCcontract_info
@@ -184,16 +131,6 @@ struct CCcontract_info
/// @returns pointer to the passed CCcontract_info structure, it must not be freed
struct CCcontract_info *CCinit(struct CCcontract_info *cp,uint8_t evalcode);
-/// \cond INTERNAL
-struct oracleprice_info
-{
- CPubKey pk;
- std::vector data;
- int32_t height;
-};
-/// \endcond
-
-
typedef std::vector vscript_t;
extern struct NSPV_CCmtxinfo NSPV_U; //!< global variable with info about mtx object and used utxo
@@ -258,7 +195,6 @@ bool myIsutxo_spentinmempool(uint256 &spenttxid,int32_t &spentvini,uint256 txid,
bool myAddtomempool(CTransaction &tx, CValidationState *pstate = NULL, bool fSkipExpiry = false);
bool mytxid_inmempool(uint256 txid);
int32_t myIsutxo_spent(uint256 &spenttxid,uint256 txid,int32_t vout);
-int32_t myGet_mempool_txs(std::vector &txs,uint8_t evalcode,uint8_t funcid);
/// \endcond
/// \cond INTERNAL
@@ -393,52 +329,6 @@ bool getCCopret(const CScript &scriptPubKey, CScript &opret);
/// @private
bool makeCCopret(CScript &opret, std::vector> &vData);
-/// CCaddr2set sets private key for additional eval code global address.
-/// This allows to spend from two cc global addresses in one transaction (the first one is set in cp object by @see CCinit function).
-/// @param cp contract info structure (@see CCcontract_info) where the private key is set
-/// @param evalcode eval code of the other contract
-/// @param pk global public key of the other contract
-/// @param priv private key for the global public key of the other contract
-/// @param coinaddr cc address obtained for this global pubkey and eval code with _GetCCaddress
-/// @see CCinit
-/// @see CCcontract_info
-/// @see _GetCCaddress
-void CCaddr2set(struct CCcontract_info *cp,uint8_t evalcode,CPubKey pk,uint8_t *priv,char *coinaddr);
-
-/// CCaddr2set sets private key for yet another eval code global address.
-/// This allows to spend from three cc global addresses in one transaction (the first one is set in cp object by CCinit function, the second is set by CCaddr2set function).
-/// @param cp contract info structure where the private key is set
-/// @param evalcode eval code of the other contract
-/// @param pk global public key of the other contract
-/// @param priv private key for the global public key of the other contract
-/// @param coinaddr the cc address obtained for this global pubkey and eval code with _GetCCaddress
-/// @see CCinit
-/// @see CCcontract_info
-/// @see CCaddr2set
-/// @see _GetCCaddress
-void CCaddr3set(struct CCcontract_info *cp,uint8_t evalcode,CPubKey pk,uint8_t *priv,char *coinaddr);
-
-/// CCaddr1of2set sets pubkeys, private key and cc addr for spending from 1of2 cryptocondition vout
-/// @param cp contract info structure where the private key is set
-/// @param pk1 one of the two public keys of the 1of2 cc
-/// @param pk2 second of the two public keys of the 1of2 cc
-/// @param priv private key for one of the two pubkeys
-/// @param coinaddr the cc address obtained for this 1of2 cc with GetCCaddress1of2
-/// @see CCinit
-/// @see CCcontract_info
-/// @see GetCCaddress1of2
-void CCaddr1of2set(struct CCcontract_info *cp, CPubKey pk1, CPubKey pk2,uint8_t *priv,char *coinaddr);
-
-/// CCaddrTokens1of2set sets pubkeys, private key and cc addr for spending from 1of2 token cryptocondition vout
-/// @param cp contract info structure where the private key is set
-/// @param pk1 one of the two public keys of the 1of2 cc
-/// @param pk2 second of the two public keys of the 1of2 cc
-/// @param priv private key for one of the two pubkeys
-/// @param coinaddr the cc address obtained for this 1of2 token cc with GetTokensCCaddress1of2
-/// @see GetTokensCCaddress
-/// @see CCcontract_info
-void CCaddrTokens1of2set(struct CCcontract_info *cp, CPubKey pk1, CPubKey pk2, uint8_t *priv, char *coinaddr);
-
/// IsCCInput checks if scriptSig object contains a cryptocondition
/// @param scriptSig scriptSig object with a cryptocondition
/// @returns true if the scriptSig object contains a cryptocondition
@@ -476,8 +366,6 @@ CPubKey pubkey2pk(std::vector vpubkey);
/// @param tokenid id of token (id of token creation tx)
int64_t CCfullsupply(uint256 tokenid);
-/// @private
-bool ConstrainVout(CTxOut vout,int32_t CCflag,char *cmpaddr,int64_t nValue);
/// Returns bitcoin address for the scriptPubKey parameter
/// @param[out] destaddr the returned address of the scriptPubKey, the buffer should have size of at least 64 chars
@@ -485,24 +373,10 @@ bool ConstrainVout(CTxOut vout,int32_t CCflag,char *cmpaddr,int64_t nValue);
/// @returns true if success
bool Getscriptaddress(char *destaddr,const CScript &scriptPubKey);
-/// Returns custom bitcoin address for the scriptPubKey parameter
-/// @param[out] destaddr the returned address of the scriptPubKey, the buffer should have size of at least 64 chars
-/// @param scriptPubKey scriptPubKey object
-/// @param taddr custom address prefix
-/// @param prefix custom pubkey prefix
-/// @param prefix2 custom script prefix
-/// @returns true if success
-bool GetCustomscriptaddress(char *destaddr,const CScript &scriptPubKey,uint8_t taddr,uint8_t prefix,uint8_t prefix2);
-
/// Returns my pubkey, that is set by -pubkey hushd parameter
/// @returns public key as byte array
std::vector Mypubkey();
-/// Returns my private key, that is private key for the my pubkey
-/// @returns private key as byte array
-/// @see Mypubkey
-bool Myprivkey(uint8_t myprivkey[]);
-
/// @private
uint256 BitcoinGetProofMerkleRoot(const std::vector &proofData, std::vector &txids);
@@ -638,9 +512,6 @@ bits256 bits256_doublesha256(char *deprecated,uint8_t *data,int32_t datalen);
// UniValue ValueFromAmount(const CAmount& amount); // defined in server.h
/*! \endcond */
-/*! \cond INTERNAL */
-int64_t TotalPubkeyNormalInputs(const CTransaction &tx, const CPubKey &pubkey);
-int64_t TotalPubkeyCCInputs(const CTransaction &tx, const CPubKey &pubkey);
inline std::string STR_TOLOWER(const std::string &str) { std::string out; for (std::string::const_iterator i = str.begin(); i != str.end(); i++) out += std::tolower(*i); return out; }
/*! \endcond */
@@ -651,60 +522,4 @@ inline std::string STR_TOLOWER(const std::string &str) { std::string out; for (s
void AddSigData2UniValue(UniValue &result, int32_t vini, UniValue& ccjson, std::string sscriptpubkey, int64_t amount);
-#ifndef LOGSTREAM_DEFINED
-#define LOGSTREAM_DEFINED
-// bitcoin LogPrintStr with category "-debug" cmdarg support for C++ ostringstream:
-
-// log levels:
-#define CCLOG_ERROR (-1) //!< error level
-#define CCLOG_INFO 0 //!< info level
-#define CCLOG_DEBUG1 1 //!< debug level 1
-#define CCLOG_DEBUG2 2 //!< debug level 2
-#define CCLOG_DEBUG3 3 //!< debug level 3
-#define CCLOG_MAXLEVEL 3
-
-/// @private
-extern void CCLogPrintStr(const char *category, int level, const std::string &str);
-
-/// @private
-template
-void CCLogPrintStream(const char *category, int level, const char *functionName, T print_to_stream)
-{
-}
-/// Macro for logging messages using bitcoin LogAcceptCategory and LogPrintStr functions.
-/// Supports error, info and three levels of debug messages.
-/// Logging category is set by -debug=category hushd param.
-/// To set debug level pass -debug=category-1, -debug=category-2 or -debug=category-3 param. If some level is enabled lower level messages also will be printed.
-/// To print info-level messages pass just -debug=category parameter, with no level.
-/// Error-level messages will always be printed, even if -debug parameter is not set
-/// @param category category of message, for example Antara module name
-/// @param level debug-level, use defines CCLOG_ERROR, CCLOG_INFO, CCLOG_DEBUGN
-/// @param logoperator to form the log message (the 'stream' name is mandatory)
-/// usage: LOGSTREAM("category", debug-level, stream << "some log data" << data2 << data3 << ... << std::endl);
-/// example: LOGSTREAM("heir", CCLOG_INFO, stream << "heir public key is " << HexStr(heirPk) << std::endl);
-#define LOGSTREAM(category, level, logoperator) CCLogPrintStream( category, level, NULL, [=](std::ostringstream &stream) {logoperator;} )
-
-/// LOGSTREAMFN is a version of LOGSTREAM macro which adds calling function name with the standard define \_\_func\_\_ at the beginning of the printed string.
-/// LOGSTREAMFN parameters are the same as in LOGSTREAM
-/// @see LOGSTREAM
-#define LOGSTREAMFN(category, level, logoperator) CCLogPrintStream( category, level, __func__, [=](std::ostringstream &stream) {logoperator;} )
-
-/// @private
-template
-UniValue report_ccerror(const char *category, int level, T print_to_stream)
-{
- UniValue err(UniValue::VOBJ);
- std::ostringstream stream;
-
- print_to_stream(stream);
- err.push_back(Pair("result", "error"));
- err.push_back(Pair("error", stream.str()));
- stream << std::endl;
- CCLogPrintStr(category, level, stream.str());
- return err;
-}
-
-/// @private
-#define CCERR_RESULT(category,level,logoperator) return report_ccerror(category, level, [=](std::ostringstream &stream) {logoperator;})
-#endif // #ifndef LOGSTREAM_DEFINED
#endif
diff --git a/src/cc/CCutilbits.cpp b/src/cc/CCutilbits.cpp
index e0ad86c04..17de1e356 100644
--- a/src/cc/CCutilbits.cpp
+++ b/src/cc/CCutilbits.cpp
@@ -102,7 +102,3 @@ CPubKey pubkey2pk(std::vector vpubkey)
pk.Set(vpubkey.begin(), vpubkey.end());
return(pk);
}
-
-void CCLogPrintStr(const char *category, int level, const std::string &str)
-{
-}
diff --git a/src/cc/CCutils.cpp b/src/cc/CCutils.cpp
index e46793288..6e3f2f735 100644
--- a/src/cc/CCutils.cpp
+++ b/src/cc/CCutils.cpp
@@ -100,38 +100,6 @@ uint32_t GetLatestTimestamp(int32_t height)
return(hush_heightstamp(height));
} // :P
-void CCaddr2set(struct CCcontract_info *cp,uint8_t evalcode,CPubKey pk,uint8_t *priv,char *coinaddr)
-{
- cp->unspendableEvalcode2 = evalcode;
- cp->unspendablepk2 = pk;
- memcpy(cp->unspendablepriv2,priv,32);
- strcpy(cp->unspendableaddr2,coinaddr);
-}
-
-void CCaddr3set(struct CCcontract_info *cp,uint8_t evalcode,CPubKey pk,uint8_t *priv,char *coinaddr)
-{
- cp->unspendableEvalcode3 = evalcode;
- cp->unspendablepk3 = pk;
- memcpy(cp->unspendablepriv3,priv,32);
- strcpy(cp->unspendableaddr3,coinaddr);
-}
-
-void CCaddr1of2set(struct CCcontract_info *cp, CPubKey pk1, CPubKey pk2, uint8_t *priv, char *coinaddr)
-{
- cp->coins1of2pk[0] = pk1;
- cp->coins1of2pk[1] = pk2;
- memcpy(cp->coins1of2priv,priv,32);
- strcpy(cp->coins1of2addr,coinaddr);
-}
-
-void CCaddrTokens1of2set(struct CCcontract_info *cp, CPubKey pk1, CPubKey pk2, uint8_t *priv, char *tokenaddr)
-{
- cp->tokens1of2pk[0] = pk1;
- cp->tokens1of2pk[1] = pk2;
- memcpy(cp->tokens1of2priv,priv,32);
- strcpy(cp->tokens1of2addr, tokenaddr);
-}
-
bool Getscriptaddress(char *destaddr,const CScript &scriptPubKey)
{
CTxDestination address; txnouttype whichType;
@@ -148,18 +116,6 @@ bool Getscriptaddress(char *destaddr,const CScript &scriptPubKey)
return(false);
}
-bool GetCustomscriptaddress(char *destaddr,const CScript &scriptPubKey,uint8_t taddr,uint8_t prefix, uint8_t prefix2)
-{
- CTxDestination address; txnouttype whichType;
- if ( ExtractDestination(scriptPubKey,address) != 0 )
- {
- strcpy(destaddr,(char *)CCustomBitcoinAddress(address,taddr,prefix,prefix2).ToString().c_str());
- return(true);
- }
- //fprintf(stderr,"ExtractDestination failed\n");
- return(false);
-}
-
bool pubkey2addr(char *destaddr,uint8_t *pubkey33)
{
std::vectorpk; int32_t i;
@@ -168,27 +124,6 @@ bool pubkey2addr(char *destaddr,uint8_t *pubkey33)
return(Getscriptaddress(destaddr,CScript() << pk << OP_CHECKSIG));
}
-bool ConstrainVout(CTxOut vout, int32_t CCflag, char *cmpaddr, int64_t nValue)
-{
- char destaddr[64];
- if ( vout.scriptPubKey.IsPayToCryptoCondition() != CCflag )
- {
- fprintf(stderr,"constrain vout error isCC %d vs %d CCflag\n", vout.scriptPubKey.IsPayToCryptoCondition(), CCflag);
- return(false);
- }
- else if ( cmpaddr != 0 && (Getscriptaddress(destaddr, vout.scriptPubKey) == 0 || strcmp(destaddr, cmpaddr) != 0) )
- {
- fprintf(stderr,"constrain vout error: check addr %s vs script addr %s\n", cmpaddr!=0?cmpaddr:"", destaddr!=0?destaddr:"");
- return(false);
- }
- else if ( nValue != 0 && nValue != vout.nValue ) //(nValue == 0 && vout.nValue < 10000) || (
- {
- fprintf(stderr,"constrain vout error nValue %.8f vs %.8f\n",(double)nValue/COIN,(double)vout.nValue/COIN);
- return(false);
- }
- else return(true);
-}
-
bool priv2addr(char *coinaddr,uint8_t *buf33,uint8_t priv32[32])
{
CKey priv; CPubKey pk; int32_t i; uint8_t *src;
@@ -219,60 +154,6 @@ extern char NSPV_wifstr[],NSPV_pubkeystr[];
extern uint32_t NSPV_logintime;
#define NSPV_AUTOLOGOUT 777
-bool Myprivkey(uint8_t myprivkey[])
-{
- char coinaddr[64],checkaddr[64]; std::string strAddress; char *dest; int32_t i,n; CBitcoinAddress address; CKeyID keyID; CKey vchSecret; uint8_t buf33[33];
- if ( HUSH_NSPV_SUPERLITE )
- {
- if ( NSPV_logintime == 0 || time(NULL) > NSPV_logintime+NSPV_AUTOLOGOUT )
- {
- fprintf(stderr,"need to be logged in to get myprivkey\n");
- return false;
- }
- vchSecret = DecodeSecret(NSPV_wifstr);
- memcpy(myprivkey,vchSecret.begin(),32);
- //for (i=0; i<32; i++)
- // fprintf(stderr,"%02x",myprivkey[i]);
- //fprintf(stderr," myprivkey %s\n",NSPV_wifstr);
- memset((uint8_t *)vchSecret.begin(),0,32);
- return true;
- }
- if ( Getscriptaddress(coinaddr,CScript() << Mypubkey() << OP_CHECKSIG) != 0 )
- {
- n = (int32_t)strlen(coinaddr);
- strAddress.resize(n+1);
- dest = (char *)strAddress.data();
- for (i=0; iGetKey(keyID,vchSecret) != 0 )
- {
- memcpy(myprivkey,vchSecret.begin(),32);
- memset((uint8_t *)vchSecret.begin(),0,32);
- if ( 0 )
- {
- for (i=0; i<32; i++)
- fprintf(stderr,"0x%02x, ",myprivkey[i]);
- fprintf(stderr," found privkey for %s!\n",dest);
- }
- if ( priv2addr(checkaddr,buf33,myprivkey) != 0 )
- {
- if ( buf2pk(buf33) == Mypubkey() && strcmp(checkaddr,coinaddr) == 0 )
- return(true);
- else printf("mismatched privkey -> addr %s vs %s\n",checkaddr,coinaddr);
- }
- return(false);
- }
-#endif
- }
- }
- fprintf(stderr,"privkey for the -pubkey= address is not in the wallet, importprivkey!\n");
- return(false);
-}
-
CPubKey GetUnspendable(struct CCcontract_info *cp,uint8_t *unspendablepriv)
{
if ( unspendablepriv != 0 )
@@ -282,57 +163,9 @@ CPubKey GetUnspendable(struct CCcontract_info *cp,uint8_t *unspendablepriv)
int32_t NSPV_coinaddr_inmempool(char const *logcategory,char *coinaddr,uint8_t CCflag);
-int32_t myIs_coinaddr_inmempoolvout(char const *logcategory,char *coinaddr)
-{
- int32_t i,n; char destaddr[64];
- if ( HUSH_NSPV_SUPERLITE )
- return(NSPV_coinaddr_inmempool(logcategory,coinaddr,1));
- BOOST_FOREACH(const CTxMemPoolEntry &e,mempool.mapTx)
- {
- const CTransaction &tx = e.GetTx();
- if ( (n= tx.vout.size()) > 0 )
- {
- const uint256 &txid = tx.GetHash();
- for (i=0; i &txs,uint8_t evalcode,uint8_t funcid)
-{
- int i=0;
-
- if ( HUSH_NSPV_SUPERLITE )
- {
- CTransaction tx; uint256 hashBlock;
-
- NSPV_evalcode_inmempool(evalcode,funcid);
- for (int i=0;i valtype;
- std::vector vSolutions;
- txnouttype whichType;
-
- if (Solver(vintx.vout[vin.prevout.n].scriptPubKey, whichType, vSolutions)) {
- switch (whichType) {
- case TX_PUBKEY:
- if (pubkey == CPubKey(vSolutions[0])) // is my input?
- total += vintx.vout[vin.prevout.n].nValue;
- break;
- case TX_PUBKEYHASH:
- if (pubkey.GetID() == CKeyID(uint160(vSolutions[0]))) // is my input?
- total += vintx.vout[vin.prevout.n].nValue;
- break;
- }
- }
- }
- }
- return total;
-}
-
-// returns total of CC inputs signed with this pubkey
-int64_t TotalPubkeyCCInputs(const CTransaction &tx, const CPubKey &pubkey)
-{
- int64_t total = 0;
- return total;
-}
-
extern std::string MYCCLIBNAME;
diff --git a/src/cc/Makefile_custom b/src/cc/Makefile_custom
index 3c71a60c0..9db01b106 100644
--- a/src/cc/Makefile_custom
+++ b/src/cc/Makefile_custom
@@ -4,7 +4,7 @@ CC_DARWIN = g++-8
CC_WIN = x86_64-w64-mingw32-gcc-posix
CC_AARCH64 = aarch64-linux-gnu-g++
CFLAGS_DARWIN = -DBUILD_CUSTOMCC -std=c++11 -arch x86_64 -I../secp256k1/include -I../../depends/$(shell echo `../..//depends/config.guess`/include) -I../univalue/include -I../leveldb/include -I.. -I. -fPIC -Wl,-undefined -Wl,dynamic_lookup -Wno-write-strings -shared -dynamiclib
-CFLAGS = -Wno-write-strings -DBUILD_CUSTOMCC -std=c++11 -I../secp256k1/include -I../../depends/$(shell echo `../..//depends/config.guess`/include) -I../univalue/include -I../leveldb/include -I.. -I. -fPIC -shared
+CFLAGS = -D_HAS_AUTO_PTR_ETC=0 -DBOOST_NO_CXX98_FUNCTION_BASE -Wno-write-strings -DBUILD_CUSTOMCC -std=c++11 -I../secp256k1/include -I../../depends/$(shell echo `../..//depends/config.guess`/include) -I../univalue/include -I../leveldb/include -I.. -I. -fPIC -shared
CFLAGS_WIN = -Wno-write-strings -DBUILD_CUSTOMCC -std=c++11 -I../secp256k1/include -I../../depends/x86_64-w64-mingw32/include -I../univalue/include -I../leveldb/include -I.. -I. -fPIC -shared
DEBUGFLAGS = -O0 -D _DEBUG
RELEASEFLAGS = -O2 -D NDEBUG -combine -fwhole-program
diff --git a/src/cc/customcc.cpp b/src/cc/customcc.cpp
index 7edb95f79..961089de8 100644
--- a/src/cc/customcc.cpp
+++ b/src/cc/customcc.cpp
@@ -1,88 +1,15 @@
// Copyright (c) 2016-2024 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
-/*
- simple stub custom cc
-
- Just update the functions in this file, then from ~/hush3/src/cc
-
- ../hush-cli -ac_name=CUSTOM stop
- ./makecustom
- ../hush-smart-chain -ac_name=CUSTOM -ac_cclib=custom -ac_cc=2 ...
-
- The above will rebuild hushd and get it running again
- */
-
-CScript custom_opret(uint8_t funcid,CPubKey pk)
-{
- CScript opret; uint8_t evalcode = EVAL_CUSTOM;
- opret << OP_RETURN << E_MARSHAL(ss << evalcode << funcid << pk);
- return(opret);
-}
-
-uint8_t custom_opretdecode(CPubKey &pk,CScript scriptPubKey)
-{
- std::vector vopret; uint8_t e,f;
- GetOpReturnData(scriptPubKey,vopret);
- if ( vopret.size() > 2 && E_UNMARSHAL(vopret,ss >> e; ss >> f; ss >> pk) != 0 && e == EVAL_CUSTOM )
- {
- return(f);
- }
- return(0);
-}
-
-UniValue custom_rawtxresult(UniValue &result,std::string rawtx,int32_t broadcastflag)
-{
- CTransaction tx;
- if ( rawtx.size() > 0 )
- {
- result.push_back(Pair("hex",rawtx));
- if ( DecodeHexTx(tx,rawtx) != 0 )
- {
- if ( broadcastflag != 0 && myAddtomempool(tx) != 0 )
- RelayTransaction(tx);
- result.push_back(Pair("txid",tx.GetHash().ToString()));
- result.push_back(Pair("result","success"));
- } else result.push_back(Pair("error","decode hex"));
- } else result.push_back(Pair("error","couldnt finalize CCtx"));
- return(result);
-}
UniValue custom_func0(uint64_t txfee,struct CCcontract_info *cp,cJSON *params)
{
UniValue result(UniValue::VOBJ);
- result.push_back(Pair("result","success"));
- result.push_back(Pair("message","just an example of an information returning rpc"));
return(result);
}
-// send yourself 1 coin to your CC address using normal utxo from your -pubkey
-
UniValue custom_func1(uint64_t txfee,struct CCcontract_info *cp,cJSON *params)
{
- CMutableTransaction mtx = CreateNewContextualCMutableTransaction(Params().GetConsensus(), hush_nextheight()); std::string rawtx;
- UniValue result(UniValue::VOBJ); CPubKey mypk; int64_t amount = COIN; int32_t broadcastflag=0;
- if ( txfee == 0 )
- txfee = CUSTOM_TXFEE;
- mypk = pubkey2pk(Mypubkey());
- if ( AddNormalinputs2(mtx,COIN+txfee,64) >= COIN+txfee ) // add utxo to mtx
- {
- // make op_return payload as normal.
- CScript opret = custom_opret('1',mypk);
- std::vector> vData = std::vector>();
- if ( makeCCopret(opret, vData) )
- {
- // make vout0 with op_return included as payload.
- mtx.vout.push_back(MakeCC1vout(cp->evalcode,amount,mypk,&vData));
- fprintf(stderr, "vout size2.%li\n", mtx.vout.size());
- rawtx = FinalizeCCTx(0,cp,mtx,mypk,txfee,CScript());
- return(custom_rawtxresult(result,rawtx,broadcastflag));
- }
- }
+ UniValue result(UniValue::VOBJ);
return(result);
}
-
-bool custom_validate(struct CCcontract_info *cp,int32_t height,Eval *eval,const CTransaction tx)
-{
- return false;
-}
diff --git a/src/cc/customcc.h b/src/cc/customcc.h
index 4159d9608..7dfb78f84 100644
--- a/src/cc/customcc.h
+++ b/src/cc/customcc.h
@@ -1,20 +1,6 @@
// Copyright (c) 2016-2024 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
-/*
- to create a custom libcc.so:
-
- 1. change "func0" and "func1" to method names that fit your custom cc. Of course, you can create more functions by adding another entry to RPC_FUNCS. there is not any practical limit to the number of methods.
-
- 2. For each method make sure there is a UniValue function declaration and CUSTOM_DISPATCH has an if statement checking for it that calls the custom_func
-
- 3. write the actual custom_func0, custom_func1 and custom_validate in customcc.cpp
-
- 4. ./makecustom, which builds cclib.cpp with -DBUILD_CUSTOMCC and puts the libcc.so in ~/hush3/src and rebuilds hushd
-
- 5. launch your chain with -ac_cclib=customcc -ac_cc=2
-
- */
std::string MYCCLIBNAME = (char *)"customcc";
@@ -27,22 +13,3 @@ std::string MYCCLIBNAME = (char *)"customcc";
{ (char *)MYCCNAME, (char *)"func0", (char *)"", 1, 1, '0', EVAL_CUSTOM }, \
{ (char *)MYCCNAME, (char *)"func1", (char *)"", 0, 0, '1', EVAL_CUSTOM },
-bool custom_validate(struct CCcontract_info *cp,int32_t height,Eval *eval,const CTransaction tx);
-UniValue custom_func0(uint64_t txfee,struct CCcontract_info *cp,cJSON *params);
-UniValue custom_func1(uint64_t txfee,struct CCcontract_info *cp,cJSON *params);
-
-#define CUSTOM_DISPATCH \
-if ( cp->evalcode == EVAL_CUSTOM ) \
-{ \
- if ( strcmp(method,"func0") == 0 ) \
- return(custom_func0(txfee,cp,params)); \
- else if ( strcmp(method,"func1") == 0 ) \
- return(custom_func1(txfee,cp,params)); \
- else \
- { \
- result.push_back(Pair("result","error")); \
- result.push_back(Pair("error","invalid customcc method")); \
- result.push_back(Pair("method",method)); \
- return(result); \
- } \
-}
diff --git a/src/cc/dapps/dappinc.h b/src/cc/dapps/dappinc.h
index d9d77e4dc..e9afd7fdc 100644
--- a/src/cc/dapps/dappinc.h
+++ b/src/cc/dapps/dappinc.h
@@ -339,7 +339,7 @@ cJSON *get_hushcli(char *refcoin,char **retstrp,char *acname,char *method,char *
if ( acname[0] != 0 ) {
if ( refcoin[0] != 0 && strcmp(refcoin,"HUSH3") != 0 && strcmp(refcoin,acname) != 0 )
printf("unexpected: refcoin.(%s) acname.(%s)\n",refcoin,acname);
- sprintf(cmdstr,"hush-smart-chain -ac_name=%s %s %s %s %s %s %s %s %s > %s\n",acname,method,arg0,arg1,arg2,arg3,arg4,arg5,arg6,fname);
+ sprintf(cmdstr,"hush-arrakis-chain -ac_name=%s %s %s %s %s %s %s %s %s > %s\n",acname,method,arg0,arg1,arg2,arg3,arg4,arg5,arg6,fname);
}
else if ( strcmp(refcoin,"HUSH3") == 0 )
sprintf(cmdstr,"hush-cli %s %s %s %s %s %s %s %s > %s\n",method,arg0,arg1,arg2,arg3,arg4,arg5,arg6,fname);
diff --git a/src/cc/dapps/zmigrate.c b/src/cc/dapps/zmigrate.c
index e373d788b..4ccbc3636 100644
--- a/src/cc/dapps/zmigrate.c
+++ b/src/cc/dapps/zmigrate.c
@@ -23,7 +23,7 @@
#include "cJSON.c"
/*
-NOTE: HUSH nor any Hush Smart Chain has any sprout outputs. This code is kept for historical and educational purposes.
+NOTE: HUSH nor any Hush Arrakis Chain has any sprout outputs. This code is kept for historical and educational purposes.
z_migrate: the purpose of z_migrate is to make converting of all sprout outputs into sapling. the usage would be for the user to specify a sapling address and call z_migrate zsaddr, until it returns that there is nothing left to be done.
diff --git a/src/chainparams.cpp b/src/chainparams.cpp
index 3242316ef..106ce8c1d 100644
--- a/src/chainparams.cpp
+++ b/src/chainparams.cpp
@@ -117,7 +117,7 @@ public:
consensus.nPowMaxAdjustDown = 32; // 32% adjustment down
consensus.nPowMaxAdjustUp = 16; // 16% adjustment up
// we are emulating old node behavior at startup, they used 150s
- consensus.nPowTargetSpacing = 150; // 75; // HUSH is 75 seconds, Hush Smart Chains are 60 seconds by default
+ consensus.nPowTargetSpacing = 150; // 75; // HUSH is 75 seconds, Hush Arrakis Chains are 60 seconds by default
consensus.nPowAllowMinDifficultyBlocksAfterHeight = boost::none;
// HUSH never had Sprout in our blockchain history, but some internals require *knowing* about Sprout
// or it breaks backward compatibility. We do what we can.
@@ -222,24 +222,6 @@ void CChainParams::SetCheckpointData(CChainParams::CCheckpointData checkpointDat
CChainParams::checkpointData = checkpointData;
}
-/*
- To change the max block size, all that needs to be updated is the #define _MAX_BLOCK_SIZE in utils.h
-
- However, doing that without any other changes will allow forking non-updated nodes by creating a larger block. So, make sure to height activate the new blocksize properly.
-
- Assuming it is 8MB, then:
- #define _OLD_MAX_BLOCK_SIZE (4096 * 1024)
- #define _MAX_BLOCK_SIZE (2 * 4096 * 1024)
-
- change the body of if:
- {
- if ( height < saplinght+1000000 ) // activates 8MB blocks 1 million blocks after saplinght
- return(_OLD_MAX_BLOCK_SIZE);
- else return(_MAX_BLOCK_SIZE);
- }
-
-*/
-
// Unused Testnet, for completeness. We make testcoins instead.
class CTestNetParams : public CChainParams {
public:
@@ -358,7 +340,7 @@ public:
assert(maxUint/UintToArith256(consensus.powLimit) >= consensus.nPowAveragingWindow);
consensus.nPowMaxAdjustDown = 0; // Turn off adjustment down
consensus.nPowMaxAdjustUp = 0; // Turn off adjustment up
- consensus.nPowTargetSpacing = 60; // HSC's default to 60 seconds so a theoretical testnet should as well
+ consensus.nPowTargetSpacing = 60; // HAC's default to 60 seconds so a theoretical testnet should as well
consensus.nPowAllowMinDifficultyBlocksAfterHeight = 0;
ups[Consensus::BASE_SPROUT].nProtocolVersion = 170002;
ups[Consensus::BASE_SPROUT].nActivationHeight = NUNU::ALWAYS_ACTIVE;
@@ -490,15 +472,27 @@ void UpdateNetworkUpgradeParameters(Consensus::UpgradeIndex idx, int nActivation
regTestParams.UpdateNetworkUpgradeParameters(idx, nActivationHeight);
}
+/*
+ To change the max block size, all that needs to be updated is the #define _MAX_BLOCK_SIZE in utils.h
+
+ However, doing that without any other changes will allow forking non-updated nodes by creating a larger block. So, make sure to height activate the new blocksize properly.
+
+ Assuming it is 8MB, then:
+ #define _OLD_MAX_BLOCK_SIZE (4096 * 1024)
+ #define _MAX_BLOCK_SIZE (2 * 4096 * 1024)
+
+ change the body of MAX_BLOCK_SIZE() function to
+ {
+ if ( height < saplinght+1000000 ) // activates 8MB blocks 1 million blocks after saplinght
+ return(_OLD_MAX_BLOCK_SIZE);
+ else return(_MAX_BLOCK_SIZE);
+ }
+
+*/
+
int32_t MAX_BLOCK_SIZE(int32_t height)
{
- int32_t saplinght = pCurrentParams->consensus.vUpgrades[Consensus::UPGRADE_SAPLING].nActivationHeight;
- //fprintf(stderr,"MAX_BLOCK_SIZE %d vs. %d\n",height,mainParams.consensus.vUpgrades[Consensus::UPGRADE_SAPLING].nActivationHeight);
- if ( height <= 0 || (saplinght > 0 && height >= saplinght) )
- {
- return(_MAX_BLOCK_SIZE);
- }
- else return(2000000);
+ return(_MAX_BLOCK_SIZE);
}
// Change the Hush blocktime at run-time(!)
@@ -1921,7 +1915,7 @@ void *chainparams_commandline() {
(1620000, uint256S("0x000000048c6667a8724512cbd999bc491ec8522b1f3817001c7ba485dec46d10"))
(1621000, uint256S("0x00000005d981cd3473f8815d18965c0e0035993117390e9659fe8d3b9562c8dc"))
(1622000, uint256S("0x0000000371a1663973c7b19a0b4dd8673f1ddb14a0438c89de3908712437f688"))
- // Generated at 1709141140 via hush3 util/checkpoints.pl by onryo
+ // Generated at 1709544651 via hush3 util/checkpoints.pl by onryo
(1623000, uint256S("0x000000038ed359f4cdcfb54a0ba36a8ac89e4f697836920c28dd038d643064d1"))
(1624000, uint256S("0x00000000ca915eb30164ac2aad328ae5d9d4531bf8ef30c7bdf3c18c0abcdae4"))
(1625000, uint256S("0x0000000303957deb36dc6a3b6597984ca9585172a198342eb102a9d3b9455596"))
@@ -1989,10 +1983,563 @@ void *chainparams_commandline() {
(1687000, uint256S("0x00000003eda47c88b7d313cc525f0511934dacc364d045057eefc2148934cfbb"))
(1688000, uint256S("0x000000040d7bda41689357c29aedb77b016f3cd2ce2bc3ba04c4bdd95d455286"))
(1689000, uint256S("0x0000000128027ca8f7b2dccb44d26946b9df6533f05e63da9d475867c4b251fa"))
- (1690000, uint256S("0x00000002dbbef67d168a562e36ba850e15acfad1172d1134df4f1f4288c9d865"))
- ,(int64_t) 1709123120, // time of last checkpointed block
- (int64_t) 2533194, // total txs
- (double) 1555 // txs in the last day before block 1690236
+ (1690000, uint256S("0x00000002dbbef67d168a562e36ba850e15acfad1172d1134df4f1f4288c9d865"))
+ (1691000, uint256S("0x000000048ad7645fb07ec103dadabfb66c2b544c69bd920692a834a8844be93d"))
+ (1692000, uint256S("0x000000010ddd71bc79e292a7c6e3c70565ba211f918eb1751e905301acbcd517"))
+ (1693000, uint256S("0x000000010dc70ae11c82e34000cd7d1a344bbf9fcf6344b3ac04f3173d1703d0"))
+ (1694000, uint256S("0x000000027e5cb8c5bfd613100811708f7d180b994650d3ca6900a81683d50fa0"))
+ (1695000, uint256S("0x000000014325867b388dc34843b695536eb9185c6782707f1c86edf0b5b89e9d"))
+ // Generated at 1726148271 via hush3 util/checkpoints.pl by onryo
+ (1696000, uint256S("0x000000046385ad70b5c3de53eb6634836758eea4f7ee7b81a889f7201e27337d"))
+ (1697000, uint256S("0x00000004bbef43e1ad19298dea05462d23e7de9482dfda72c8643cc5a73e3356"))
+ (1698000, uint256S("0x00000000c7fa58a2b8420904097a9e02bc0b7aa9bc9e427ae1eed1908a150b0c"))
+ (1699000, uint256S("0x000000020ddfe5a4caddee1261f1b30faebfa220184e7e8fafee520d1bdc2452"))
+ (1700000, uint256S("0x00000001c8a7698cd8594605fed3594a8a576535d94f3440ba69b2ec01706e2f"))
+ (1701000, uint256S("0x00000002e9daa2a596858bd331b6320b4aaa34124ace3dbabbd50502b58eaf6b"))
+ (1702000, uint256S("0x000000015cfe670509475a9e7f693b5169e02d54bf459342f511b39ae05d8ce5"))
+ (1703000, uint256S("0x0000000045def8972d1adc0828618f4186f89b2d550a03f099ea4a72a78161ec"))
+ (1704000, uint256S("0x00000001a4a313c141aa9f20bb8011d00315bcfab4784a711d1529851ca6f218"))
+ (1705000, uint256S("0x00000000fc4bbd9320b7b0f3329c52e604655d872caa8ef9a64eb34e44b42795"))
+ (1706000, uint256S("0x0000000614e676936e086495ec9b3b1688a7d6030d032c3da7c241a417e6dbe7"))
+ (1707000, uint256S("0x000000005ebf5e6aa923dd2a4367d7747126343356710659b4b105b5557b26be"))
+ (1708000, uint256S("0x00000002dbfbbfa81aba34a934a69c7d6db57ace02eb20b7f1be183d8bc67b49"))
+ (1709000, uint256S("0x0000000481ece1648cf7bc906f3f912d7900170d6adda615c6e9402e7aae7a71"))
+ (1710000, uint256S("0x00000003b17400949f2f3c82142eca4c6590e863f657b64a3dbe7f79fccf38d0"))
+ (1711000, uint256S("0x00000004f87d08b7c4d366db9cdcef3f427842525b6e61c42338474821a22e03"))
+ (1712000, uint256S("0x000000049b7af8b5b5f9eb3f29d37e312abde898ad5b4891cd7d0ca1a7ee6c9d"))
+ (1713000, uint256S("0x00000002fe801673cf970df547fc14c4028b7c77abc185cb733b1726d8bcbce1"))
+ (1714000, uint256S("0x00000004a088e6e02bdc2cd157915dc13f4ff56eaaa0e7e79b796b5b3c72a89b"))
+ (1715000, uint256S("0x00000002e2d5aab4a2e23b05498896ff1e8c509e66ea5018c5a48135d65f54cf"))
+ (1716000, uint256S("0x0000000050ffc3dc91d5a8514d461b81515ebd67e22e2e3588436a8a10d7b768"))
+ (1717000, uint256S("0x000000017bfd0ce4a25cb8d4bae41b7e8d007854c1a66ea2fc015259b1e76174"))
+ (1718000, uint256S("0x00000000c8746b2e580c8e50800000d65fe893b974c2b0825521d916a87f6bbc"))
+ (1719000, uint256S("0x00000004647c20d62c9d15237d1f7d7996fd09c3e3a22f85439d1437eba50ca3"))
+ (1720000, uint256S("0x0000000087327d6b4e0644f9160915ad6f9e61497569d6223f079f7e9745674e"))
+ (1721000, uint256S("0x0000000201320ec96d6595875bcea2e431521b5035a766b072152af196004dbf"))
+ (1722000, uint256S("0x00000003d96adf0598c8a738e69fab7e578be011a49725b7dc77ebec29641dfd"))
+ (1723000, uint256S("0x0000000539537247a56af803ea95566ed5460664b0ba7958304f8f12ddbd657d"))
+ (1724000, uint256S("0x00000000e00f083cf90a695e5d6027a64e6cf3d42597a56871d17f310d7d3136"))
+ (1725000, uint256S("0x00000000888dbc0aa88e5d36cea342943d0271d5bfb15feebf637a838088aad3"))
+ (1726000, uint256S("0x000000059b3c06996b53335953a921cbd3edd0987b95a6be1987517afa58fd6c"))
+ (1727000, uint256S("0x000000048b539eaf18dfb0a9ce0b69a089fb4bdc80f4248dfd3e0270a2de6ce2"))
+ (1728000, uint256S("0x00000001055b9a98fd452d8b15f32990319ee5cb55fcd2463f382f1c9ba3ef4a"))
+ (1729000, uint256S("0x00000004237a1b7205a35ff9d2ed13198899f6995a0c9080ea1e0fce6b119d6c"))
+ (1730000, uint256S("0x00000002db2eb82e6309c174228bd0ef365f39ae75774123ff97ac729ce2ed42"))
+ (1731000, uint256S("0x000000066d71c51b95c32540d10fb0a7dcd8057ed812fb3bad4e084926b6cfe4"))
+ (1732000, uint256S("0x0000000285bd425dd245cc5456f6e0df4d1fc35531019297f3ba4a39e1c0f20e"))
+ (1733000, uint256S("0x000000020aad80909c26fc60918260f1096897a67d8d0e8e712b5374c04df5f4"))
+ (1734000, uint256S("0x0000000454b30f370832f4f09dcb3cc25347185fe78e6a20f53bc929c1f4f046"))
+ (1735000, uint256S("0x000000031c20ff6b27992f7df1c7852100844745d06eb081f1d7a14f8945a15d"))
+ (1736000, uint256S("0x00000002e8bb07f38fea576318d0daf090360d1c80f22d2c4d5acb18167985d3"))
+ (1737000, uint256S("0x000000029a2c942f291b050a17474b6fc0302911cbe28200133e6da35e282e7d"))
+ (1738000, uint256S("0x00000000ff3a12e66d4ea8356848f5fd4ee9a08793d182c91e805a0783dbb0ad"))
+ (1739000, uint256S("0x0000000141c88040bb76f4a44c42df8bab23b7d8cc582cdd76e7ce76ef56cb1d"))
+ (1740000, uint256S("0x00000001b8e797ff118fa4c0275efc75d8a1c57753b60939bd3365b29f801b7e"))
+ (1741000, uint256S("0x00000003f9d0ab66675f262a3bdcc1a31dcc31726ee7765ab29378d543329e49"))
+ (1742000, uint256S("0x000000002d3600b5c69588493b3129d847bb6e2576c0bc3ff9f6460efd2581f5"))
+ (1743000, uint256S("0x0000000282cadbec2f99e0c8e944b9260f13f7133cc56416870fe38e4848bfff"))
+ (1744000, uint256S("0x000000038e69af50667adef2cb0e9aeee8bccd52bea7e46227294f6a5e0c0438"))
+ (1745000, uint256S("0x000000057c5b7c69c1c10a2d11caecfbe17eb62e9be08bcf70334e25709d85b2"))
+ (1746000, uint256S("0x000000005590217461b08cffd1058091affebbed9715322a924057cbe697e94f"))
+ (1747000, uint256S("0x00000001f6a7c6dcb1984728e353cf24a3bea2e68c73754a916aefcdfb0cf29c"))
+ (1748000, uint256S("0x000000050efca03a20ac1d081f7b237e0187003765c302826c1c5ebb6eb251a2"))
+ (1749000, uint256S("0x000000029dc342a556a0f39de61340bf1913a001f2bedffb2d2fc75e9b2306bd"))
+ (1750000, uint256S("0x000000014c90d5bd41f3bb9cc83e966d17245989901adea24e9fb803a3af796f"))
+ (1751000, uint256S("0x00000002a3ace1b4b93e182cc8ab48c2d5f21d098435e08d6ffa006e66bde526"))
+ (1752000, uint256S("0x000000014717eb5f4d01bfe4a62a0a3cf5767ac1fe61d20782767b9ad38551a4"))
+ (1753000, uint256S("0x0000000165c3cd794a3ad5f5f7cf858228dd7bafea465d89d9ea6bb9d50c9a8b"))
+ (1754000, uint256S("0x0000000425309c3ac83b8f59e0987213c44f9d1a70af1b2df67acef706e37da6"))
+ (1755000, uint256S("0x00000003d788414e454fdf516d768165cd6efd59da056ad9275a2818bbf29dd0"))
+ (1756000, uint256S("0x0000000665956fc396e2c1b42c3932580e37f478ec7c15e28f35a76195a986d5"))
+ (1757000, uint256S("0x00000000dc5ace43a116ccc9358a1a6a1f21b99a4d4b38b939b5dc732578e340"))
+ (1758000, uint256S("0x00000000e2a0b7e090507f4f13e21aa73024fb5f8eb946975c8e18d3fbe5425c"))
+ (1759000, uint256S("0x000000037def7a52163a882e40c5f693d718ee3c9a3ff72765c91e5b6f9af913"))
+ (1760000, uint256S("0x000000045769ff47e8e3f1cb51a9b6ff1378899a231161da2a3b3caa8413b94a"))
+ (1761000, uint256S("0x000000052ffed0ce57ccfad266b64d9a949ad2784af80a066902dca2b2d417c8"))
+ (1762000, uint256S("0x000000010bef4889898cf3e2c3d0cb0ad0cc15a7aa394b6db6949aac4414e9d7"))
+ (1763000, uint256S("0x000000052b4397f24c7be192df7c617a3ec05eea73a9f0a71d294749c0555521"))
+ (1764000, uint256S("0x000000024051d111a516bd779d7a854c658439a0f82664ae7742fb76f2d87a86"))
+ (1765000, uint256S("0x000000054ae9cfdc5678a79671544817cfb5c45c865ce489388c6f4aab2216ee"))
+ (1766000, uint256S("0x00000004221eb0fac5a1340dec575372ca0ea842ac3f13eaeb41e848a9b3d605"))
+ (1767000, uint256S("0x0000000365cfe174006b52e5699397e641be7aaac2e4dd954bdc417dc2077004"))
+ (1768000, uint256S("0x00000003fdc4b4eda17fb6af8ae1551a13fc0d655a6b9559f61f39dc08ba0087"))
+ (1769000, uint256S("0x000000037d29ae542edf0e8fe09b2cf95d36f90d827152d4693244915b3ee456"))
+ (1770000, uint256S("0x00000004c918f544097141d0d6086567f483f707e948b6b9a9de762ed5281205"))
+ (1771000, uint256S("0x0000000436ac22a224104b08bff31869c7ac3102b9e35ae3cc23190809008abb"))
+ (1772000, uint256S("0x00000002385ec38d63ba954913958bc0c973698667f0cf37fe840faf362add07"))
+ (1773000, uint256S("0x00000004b1bd7d5616aaccf2eb556dfcd704c82c60c0b4eebc29f8f640903168"))
+ (1774000, uint256S("0x000000036415ef1337b9120373ccc66e851cf33e77579832eb65983bafeecbec"))
+ (1775000, uint256S("0x00000004c4bab47e83343b2bfce06d1542ebdefe1fddb286ed8f91a6c84769c7"))
+ (1776000, uint256S("0x000000016a5765722d608457aa92632a328ae581a5de599504c0935ca6092e82"))
+ (1777000, uint256S("0x0000000701c4bab1ce3c92668ed4949496b0830cf1d771670bb5631df8c7f643"))
+ (1778000, uint256S("0x000000013d0ff9925033ce0b3162926f200f867ee43efac2a7bdf6a95a56c351"))
+ (1779000, uint256S("0x000000003b272c6520cb8893f29db1e667aacbf40ff6da4da3ac325516c16e57"))
+ (1780000, uint256S("0x000000013df5ab5ff720342b732febd98fa9320bc64ea34714dbf7b4fbcd53aa"))
+ (1781000, uint256S("0x0000000b64be023cbcfcec386c79d708467e466782b835d1e67b486f2e5c2d74"))
+ (1782000, uint256S("0x000000021b2a9cd3cbbba257a3ce503f6fa1e39c6d1804100a14c13744b24363"))
+ (1783000, uint256S("0x00000007cde6f7ef2a41c581b122b24877e4203b3445baf0034d73ed14204ed2"))
+ (1784000, uint256S("0x000000004b37bb794f24abca1c311145c97550199373b17d2c7c07df5ebb9538"))
+ (1785000, uint256S("0x000000047edc917325ce9578a4c94f00a1183cd753c76b12c195e0e820d556f3"))
+ (1786000, uint256S("0x000000025c0177811a33925ddb7c245e56b941a6fbbabad67f300489e98817cf"))
+ (1787000, uint256S("0x0000000459dc750d8d9310ea28c7f88bdc2c2816b185ec45919bffd62153a57d"))
+ (1788000, uint256S("0x000000034ca7412ad71c48d3772d97dc99bbe3418b1c3cdd538b9700936fb199"))
+ (1789000, uint256S("0x000000076f64250f26cd16523a1785b7add386b594ebd457acbff0b7a6aa89cd"))
+ (1790000, uint256S("0x000000060d72c59bb12a1633dce31071cc6a132c626ab16caec774c1c7eb4d35"))
+ (1791000, uint256S("0x00000001515c3d79e4e28cdeaaa4a5b95b94e3a20e54c788bd66c7d79b312a5c"))
+ (1792000, uint256S("0x000000030f57e0c948e41863bda05f6c144ac8c9e0811e3c1844cc417e2ac8f9"))
+ (1793000, uint256S("0x00000005dcbfb0ea2a75b3babdf61fdaa8bc4bb24f08f2aadce4d431a681ad3d"))
+ (1794000, uint256S("0x00000005471c52605a54456a45e70e78f212988a21dbfc2b44329595c9d61dcd"))
+ (1795000, uint256S("0x000000041746a3ea05c2e383917554b8687bedce1c79c59e4d48a9dad86245af"))
+ (1796000, uint256S("0x00000002381f362803c3c533767dfbcb32f9756ae6bf9b7bfbf717751959be15"))
+ (1797000, uint256S("0x000000010a66bfc8280389b9358b7d32df17368c8d207385827ce5dcc26d8928"))
+ (1798000, uint256S("0x00000003170e34e98d6f7465c2aca3ac03fd6838770c639ffaaffdf47b2b5a5e"))
+ (1799000, uint256S("0x0000000d1f702ffae124c4d2ec4094b453f6a730f7d137638e517f377b2699f0"))
+ (1800000, uint256S("0x00000003119096a306aeb83dc7c3fa2c1baecaed090d88fac9751b85c02d5392"))
+ (1801000, uint256S("0x00000005583508df3d48ca3ea7aa8b1790a12b9d68a1537316d3ba83041acb70"))
+ (1802000, uint256S("0x000000060084882a0c69971fa6b1f5b219fe582b715864791c24fbdf779e30ef"))
+ (1803000, uint256S("0x0000000362f4bdac37f39bc886b56518b27ddca7df34c93170b316dc861997b0"))
+ (1804000, uint256S("0x000000052ac5a611ef3aded2989cc41fe7ef76ee95235ddc8904035ea6b41220"))
+ (1805000, uint256S("0x000000053f82b8a019469735d361dfe98b0ede3b7eeb1ea98bd266e4957c2009"))
+ (1806000, uint256S("0x00000002a73fd89ea6c9cc235a70d6d5de89870669b89a96a917f8bf96b9f799"))
+ (1807000, uint256S("0x000000045c45f117de62f01bc283f6170fda3ccc403aef07ad8d1b30eaf11031"))
+ (1808000, uint256S("0x00000004a6be7713af8533717d906be3d0b3df6b845be498591e775b27b570a5"))
+ (1809000, uint256S("0x000000030e95b1540d64d3cc1f596b3b84e21b7211595210d51807f12f784d29"))
+ (1810000, uint256S("0x00000000b00c53c576fc4938e55c3e091eebc59b67007a819d7ac77ab56fd296"))
+ (1811000, uint256S("0x000000008dffebe6bdf334c49df095ac5cfbcd6c81b2737e57f3ae706ee1355d"))
+ (1812000, uint256S("0x00000004870a62faf53b5bc60093537140a2ed830773294dac7fbe7caceac315"))
+ (1813000, uint256S("0x00000001cfa729a10b2978412336e3b8e5e776b79ebae946c23027fd54acae47"))
+ (1814000, uint256S("0x000000041aaaaa85cec731049de070fdc2b307b452cc305e8c75664efe5041bc"))
+ (1815000, uint256S("0x00000002ae8ca8bf637db8f46524c969fb60ec976dee9337c85e12acda1b800a"))
+ (1816000, uint256S("0x000000025cc83efcfa5b31b0a4b547cf5923b2f28344079f50ff09310b4e3149"))
+ (1817000, uint256S("0x000000038d0d1c7c923615fb07937822e313804269fccf884e38e613db802db8"))
+ (1818000, uint256S("0x00000005cdaec2266a5c21932dd2289a0171931aa4bdc39bcdc381d6194f3733"))
+ (1819000, uint256S("0x0000001f9bdedeacacc6602bf223dab9e25944637920fc6799738795c3c7efde"))
+ (1820000, uint256S("0x00000003a5a16120bde4b1a6a784ace30b616be37b8429e4f43eee44ceee0598"))
+ (1821000, uint256S("0x00000001f3c39cbe6a2bc81b0a6e6aa257de0bf13452d9adcaeeb71cc23ad029"))
+ (1822000, uint256S("0x00000004e0bbde4a8783d01581c7a1ba255506e9f967d8c096bc6c9034f70222"))
+ (1823000, uint256S("0x00000004a6d66ca53dbf714c238022cc0a42126540dff2f9cff7c59395a5752a"))
+ (1824000, uint256S("0x000000014b2b5044d0150acb34d993faa9ef0120a0842455e112d78632659c4f"))
+ (1825000, uint256S("0x0000000263a08ebf63abf6bd81764d1215a5a90aaded13d11bd04e2eb5107a05"))
+ (1826000, uint256S("0x000000065c08ecd03aa691178834c112fa5e728ecd82a8927f0e4f49664d5af8"))
+ (1827000, uint256S("0x000000058d8e8b4a7d38afa75d99f5e91b440fc209572ff26a98b1aabbbdbdcd"))
+ (1828000, uint256S("0x00000004480b9a3c0f9c87307804c6278dcb49c3fc362370a9fc424f27bac805"))
+ (1829000, uint256S("0x00000000f0b3cb7e289f48c72af19d62075c3390cd2991447216be87f9d372ae"))
+ (1830000, uint256S("0x000000008cd6ca08f95df6d9fab3faf3ab1ea74570d953fc05dea018f7ab0d95"))
+ (1831000, uint256S("0x0000000434184bdedea630dcdfeb3ff92aa48c46623f9237ee4b965150557c5a"))
+ (1832000, uint256S("0x00000003bf13197e2553f80bb4f1f41a27aafff87829e921fbddbdfa58718c78"))
+ (1833000, uint256S("0x000000037027ca30d184228e7ff663a9c0dde0f8f26f99bd587e0b8a309389fc"))
+ (1834000, uint256S("0x00000002827b9efc26f29c80eb728cb8ecd6cfc1a968b03c3f0e8fdd81625d88"))
+ (1835000, uint256S("0x000000049a0d5128db2dfa0961db2058bf7d153ebf0f4cc6d5054f561736f90c"))
+ (1836000, uint256S("0x00000003f67c56ff4281d35dfa78392f7ca0fe10cca06015e60b4c6ebfa2da7c"))
+ (1837000, uint256S("0x00000007ab31a2d80026cb363b965ed0b43a122b3e03e53b6f6614ed5ad835e6"))
+ (1838000, uint256S("0x00000009024dd6c35f41ebd7b759f8b108fb990c337fb2b764abcf571c731098"))
+ (1839000, uint256S("0x00000004a77cdd4e5130cee8c0ac9ecde7c22b0e342463596275db8b249d235e"))
+ (1840000, uint256S("0x0000000194db82e2be83455d477ba908718dc3c0b1092a4ef62459ad9b75b864"))
+ (1841000, uint256S("0x000000039654d65ddca898e2e13af01982516a542d3ede41163bb5e57c62cfcd"))
+ (1842000, uint256S("0x000000026c7a39b765fd8fab1cbd39bb4acb76e65de4d84996e90b6bc5cbbb8e"))
+ (1843000, uint256S("0x00000004ce2314f45bfeb207e27324783207dccc9a032f4f7560d5b63073d7bc"))
+ (1844000, uint256S("0x0000000830425ecc1282b45f0d9d2496eda51e7d29ffba7900441132c7a49d59"))
+ (1845000, uint256S("0x0000000a2f8f3e74c416dcd911fb06985baafa789066a7d98535fc7ccaf01299"))
+ (1846000, uint256S("0x00000002ac3047bbaf9a6fb3158e1245022251c40ad29c7b7d9e0dc117bae112"))
+ (1847000, uint256S("0x000000048c49382f8e79ae130453614ed621975037119573a8442e0c5674b7d2"))
+ (1848000, uint256S("0x00000007a618116d10d5cd2d61f3a542d44780a951f18b217ae394a95a51f946"))
+ (1849000, uint256S("0x000000053b6032fcd14396e27f966ce552450219e4f77a4bcfc7759362975d2f"))
+ (1850000, uint256S("0x0000000a68b3397504659a4e8eea87fc7c8788b8ce6616148c02addf46fb5a38"))
+ (1851000, uint256S("0x000000095bfe4bbdf20dafff20a5ba564b879595eb543394b789337e5493e766"))
+ (1852000, uint256S("0x000000027befad10df24147b92fc6b0b1310311fbcea57cb0ecb0f20cac43c60"))
+ (1853000, uint256S("0x00000000eb95b25125c7b58b9685242b4e29c4bce0f952b96475971d2b4bac51"))
+ (1854000, uint256S("0x000000035427daf79fdbba6152e558cb835c87817952e16dc83694d74f577dd9"))
+ (1855000, uint256S("0x00000000e86cebd49029f1348ecf3fec3d042fe3ad054040cf809975d676ccab"))
+ (1856000, uint256S("0x00000006d804ca22bbc006e2204ed721e35ca88675a66817f56a5daf3d34aaf3"))
+ (1857000, uint256S("0x000000069547a70ca10c149dc211c92c986800b9a4f74a44a0892f187ddf5042"))
+ (1858000, uint256S("0x00000002ca6303d0b280024eac8b07405dc2cfc86d54f3668074f60180bff21c"))
+ (1859000, uint256S("0x00000009736485bdfbcc7fef9068d2c50690e1331c0063381bb96940ce6740c7"))
+ (1860000, uint256S("0x00000003a9ec571fce90048e4c46586dd0a764a332b9aad36783ebe6ef225ef6"))
+ (1861000, uint256S("0x00000002fba6f836e098c87c71e6fc2fc811ef2c3e4014b8f66ca241c9538370"))
+ (1862000, uint256S("0x0000000458bcae098b9aed006b5f5b71cdfb5f7b73b0217a809d4ab5db2be96b"))
+ (1863000, uint256S("0x00000001e71c2b9725fd5afbb8586d6312200eada7971fdfab2d9c888daaf350"))
+ (1864000, uint256S("0x00000000971b82db5d846116c8bce305134f155730fc61a0f3b1e3fdc75828eb"))
+ (1865000, uint256S("0x00000000e999b3f061a706af846bc212e4e2ce41151a9c5d9ca6504ee7dc9675"))
+ (1866000, uint256S("0x000000003919b6575c4d446f14b00a57c326f282ed2e00cf75f72006d67680e3"))
+ (1867000, uint256S("0x00000001008c08cbae80cbf264f8c4aba686928fd72459df2298f2a6042d074c"))
+ (1868000, uint256S("0x000000000b8c1a48392a319214fefaf0a1aa0ff9c3ec57437fcce5068f2c4789"))
+ (1869000, uint256S("0x0000000758b5ff8f3edf6cf1f3b8c31778595eacc6e9139c3cd7485abf6ac8ac"))
+ (1870000, uint256S("0x00000006c0e18a5966014b683fc2ad66e67233857f870d1dfc3e4ba24c8d8c80"))
+ (1871000, uint256S("0x0000000aca708fa0f28d3c6dd195bce536428919684852372cca706440ce6470"))
+ (1872000, uint256S("0x00000009f1e7e2ee40d6436009ef884d25171058221068e6b561649164b921a3"))
+ (1873000, uint256S("0x000000041205df49ec40c992d36f19bb697f0dd25fd9474a613cdd4aea8cdf9e"))
+ (1874000, uint256S("0x0000000578b693fff37a8603939098aea30340b7c805a98317ced77cc9a9d738"))
+ (1875000, uint256S("0x000000038b9acc3c108412fe3a61bd7f77c4e709e7923fce6730173edc851ff3"))
+ (1876000, uint256S("0x00000002500162bbfcabe7018c43756da89dd5f5dd86b7a59d81b0aab222a4b1"))
+ (1877000, uint256S("0x00000001653423619a040072d21407c8f3e481c5d2da428a8c3aec4ff044ca3a"))
+ (1878000, uint256S("0x00000007c40a0e9e986333cbdabc6d81e100eaa1eea7a983b8bbb78317d05072"))
+ (1879000, uint256S("0x00000000742d5d64baebfca3b564937726ea4d4928f5b14bc5a5e70fd9c72e99"))
+ (1880000, uint256S("0x000000024d22fa0bdfeec3156b14a6ec455e0dccb913d006d701087a962bf692"))
+ (1881000, uint256S("0x000000077867103cbb1befdf33a24850470f1e26d8942a8c694b0cfd736cc8a6"))
+ (1882000, uint256S("0x00000003e31aad71429d93282c80b73903df35d6a762eae880ce7f746e39acb7"))
+ (1883000, uint256S("0x00000007df770a4a295aaed19a510535217663471284c37e62171a0b8b69070e"))
+ (1884000, uint256S("0x00000004f813d155265f3f09d6e0512bd0111e81708bd6c4b5857fa4c85bbf02"))
+ (1885000, uint256S("0x00000006236adc55d27b875af36649c7482b16a33842546bf4e8212805174e76"))
+ (1886000, uint256S("0x000000075757edd65122294031731b6038daefeb2d18e9adacda4b85da530fc0"))
+ (1887000, uint256S("0x000000021f9eaf50778462b2b58aa21b047200697c6c41880b014a14d9883c33"))
+ (1888000, uint256S("0x00000043c363d1126947ebea3156d801ef0922ecc57f2130793526801f11772b"))
+ (1889000, uint256S("0x0000000353d262ed384f346d50d7fa64ac7e513c155f4322386a0f1e33d626d1"))
+ (1890000, uint256S("0x000000029f50b0065af5c1eec4de04b140d847535d5422215dd0e26eed008d35"))
+ (1891000, uint256S("0x00000001f5b6af002a9524a8991426ee891a268f885139001ed6fdef2e1b0cb0"))
+ (1892000, uint256S("0x00000003c7318412f7ebd0a1da5e2809abf6293b2cf6ec519ed91a44a9b5acff"))
+ (1893000, uint256S("0x0000000c0efaacf06f7d9f5ce1a5211671201c24bbbe4fcbd759d17daf07d3f9"))
+ (1894000, uint256S("0x0000000095e2ba9e15c007baca9a01ea50ec64d87bf84f32fa9749d6f3c69f4a"))
+ (1895000, uint256S("0x00000002909536ceb779f4fb3bff8bf68aabcf26d953a6ccf9eac2b012c348fe"))
+ (1896000, uint256S("0x000000099876579cb3995e07b004c5b25304db77604b049c36473bb3be195159"))
+ (1897000, uint256S("0x00000009a267875f480399b16c0aa89f915d7d0a4ae15cf3bef66f9a104219d7"))
+ (1898000, uint256S("0x00000004321a0d47a384e405e4d3d585c7b5e064559b394d9b8517d409b81647"))
+ (1899000, uint256S("0x000000083025e8364786b286eb3d65cc39fa9cad4720ffef5a22da2618c4ddce"))
+ (1900000, uint256S("0x00000003df9302cdceced304405e46e3fe5950e191173e2afc810527d4a45472"))
+ (1901000, uint256S("0x00000001634453c1ad96fc6bae21a1e58c6b48af72ba9633b95fd313f4bf68da"))
+ (1902000, uint256S("0x0000000bc5de5e55f8d89dd1e26125b69767df8b410163d4903cfdc69687c2d7"))
+ (1903000, uint256S("0x0000000425dbba65f46a66a3255fe4c3e446c460970ecc066270abc0ef53ddf4"))
+ (1904000, uint256S("0x00000005cfedd11ec3f788d8c3e6a126c47c6bfffe0d34b821a0a1ebbd2bd0ed"))
+ (1905000, uint256S("0x00000004c602ef20f36b9dcfefe1970f3e008157ffcc8ddde3eb5f304f566618"))
+ (1906000, uint256S("0x00000004051959adaef5d9e0dc2b142351c5a5afc9a01b5c9b333a8f72844902"))
+ (1907000, uint256S("0x000000095bc01b7e1fdefcdc2fdfa5e9a9be8a896fae2d2b0907a5c6fc741fd2"))
+ (1908000, uint256S("0x00000007258940eebc238e5aabd9403c3ad97e88a90e0596a15a50f979c3b7a4"))
+ (1909000, uint256S("0x0000000623a348b65f08632fa073d3226831f677299eaa98afc249c6b7dea056"))
+ (1910000, uint256S("0x00000011f5e9f50fd2aa37b4c1bcb42a3607f4837687300be7cfc0acfe4db976"))
+ (1911000, uint256S("0x00000004bfc1a263d309938f5604f5c8cbc54d7b580c0b2300f6d96a2e6ac4e5"))
+ (1912000, uint256S("0x0000000137671d01cfcefa184b3a3365bce9caa2b8db024101f5c996b9cb2dcf"))
+ (1913000, uint256S("0x00000008b7007ec04ad61ce451f94a3c6fb2adb7426fc6071b2a5ea48c4f9fd8"))
+ (1914000, uint256S("0x0000000243fe84ebc7f9e6464ea68e938c3095e51561d168cac11e02da7dfffc"))
+ (1915000, uint256S("0x0000000463ee472250bc95ddf1403ac7ce518cb52b4570c5bf53c7c055f718e0"))
+ // Generated at 1750947275 via hush3 util/checkpoints.pl by Duke Leto
+ (1916000, uint256S("0x00000007450182fd8b6e17ab04c95182aa33ab281399e590538f3c6a5daff7cc"))
+ (1917000, uint256S("0x0000000a3e34f534cb787befc6520577404e39ddfb8331e587912e3c35f8eee3"))
+ (1918000, uint256S("0x0000000a8377c632f26108c153d2fd1d42e13e7bbfb8e62642d5e80546e2ed62"))
+ (1919000, uint256S("0x000000016e1b54a1aea7c531c47a3cd6aa5e0722d294c8fc0b718a9aa4574792"))
+ (1920000, uint256S("0x00000003e6d1d949658d5852b9319dbe0e75a4c171d2282a091a97aadc301da0"))
+ (1921000, uint256S("0x00000003d37c4d24c50bc32f815a8c089862d2a33f5e5010c0c36cf51f23d430"))
+ (1922000, uint256S("0x00000001de45a81a83b52246f6bdfd8ce4ab49ff209377f348040a2f7a08f540"))
+ (1923000, uint256S("0x00000006ec45bdf0764f20744447b67227cc91330bded5797881616372aa0400"))
+ (1924000, uint256S("0x00000003f57657a30f1fc6107611dc86dff2ea88a58d46a37339a1bc199c8f96"))
+ (1925000, uint256S("0x000000012f56b581239965f384ee45d91f58818781616b24e37b1a0f9ff3d21d"))
+ (1926000, uint256S("0x00000001fac2e82d4b4e4dc95f62625d259c29a16527dcd2ee8f1a5005944269"))
+ (1927000, uint256S("0x00000003ab28525c560ac0f8ba5a5ab32975b87ba1d423bdd1d1a9a675d668c6"))
+ (1928000, uint256S("0x0000001fc650e767800d6e022e173a9d1608ef821c296dfaabc8ac1e4f60f10c"))
+ (1929000, uint256S("0x00000000a297246c427d1d21d43110f0e4561e42ab940c1269d5cca17f0904e1"))
+ (1930000, uint256S("0x00000012f367afa4b2981c51d39b2d5181b076d93f85220a2e6c373be5c3ba13"))
+ (1931000, uint256S("0x0000000195f51b18da7a447e64c29086d9b9239f344592fdc31dd4793f6fb4dc"))
+ (1932000, uint256S("0x0000000a72a3f81eecf15b2b06b37e5d0e5c8be26945be29f7b80242dd8d866d"))
+ (1933000, uint256S("0x0000000602cec0393e21864f1f9de0e9a31c9eaf96d406d976b2932cb076f945"))
+ (1934000, uint256S("0x000000026ae0bfcedd170c1a7ec3c282806d522c714337105a5b9e3c9f75f51f"))
+ (1935000, uint256S("0x000000096c05eb37e98c0ac1e5da953f75c416b1939d05c3a7f38b443075274f"))
+ (1936000, uint256S("0x00000000b366ca6e89b40632b26fe80c14fb549c70484adede899f4b9550594b"))
+ (1937000, uint256S("0x00000002407697e167d3a957bf6e89a3f6ef12448ec37dc077c36541c08d9d9c"))
+ (1938000, uint256S("0x000000010e122ecf450e3f7af854c5d5af48ff297dc9f7b49ee60d7bb26b8744"))
+ (1939000, uint256S("0x00000004ace5ced8a4f052dd1260cccb305f4ec05207d3882b9ef40d11a5fe6b"))
+ (1940000, uint256S("0x00000001e668c7e4bcdee1a9b291e5ecfcad3eeb84ec4cff80eab05ce23109cd"))
+ (1941000, uint256S("0x0000000913631ecaeefb24c9d168a9a0c05df2012f3e988030eed645687a6ec3"))
+ (1942000, uint256S("0x0000000315b6039d0a0c14820f396dc960ad507783847f599b7d5154f88f94e0"))
+ (1943000, uint256S("0x00000005b7bc0112d299c2f0caed3b0cfa6c1bb730c9004e4d6ef2ceeec9efe0"))
+ (1944000, uint256S("0x00000007c64f0a932a8edfebb2d494665e524afc5ab755e2cefec84ce77d259a"))
+ (1945000, uint256S("0x00000006c6a9fe8c05283f310c0dff22a2d92304b605b593fe1c1fdfc1085bb3"))
+ (1946000, uint256S("0x000000054b5c0409f082be6f0b4deac5ef5106fc44173f3422885fb23bd73f7d"))
+ (1947000, uint256S("0x000000069a8e31d32df50f35ef63029bdd3a56d042d34cf6d02f6efc637c8dd1"))
+ (1948000, uint256S("0x0000000885fd68fb764457590ddee9aef3e4256f2ef067388a9c72714fa775b7"))
+ (1949000, uint256S("0x000000064285b903e667a64cb598f7aee2cbcf8a513a681334adef89f58b58c5"))
+ (1950000, uint256S("0x0000000a706ce153f138e155a21da714642ccf0997f9f9229dded6335a59ba07"))
+ (1951000, uint256S("0x00000005a15015e01043f708b242ae79f71694be8546098085f6604c007c40c3"))
+ (1952000, uint256S("0x0000000acf2ac942089d2f1dee9428c42ca89857b4cd412daedc8c68f1ca4b0b"))
+ (1953000, uint256S("0x00000001b11437b9668a1ba11d70af25a2c9c1635604e689d7e846d154af7503"))
+ (1954000, uint256S("0x0000000217414e96a2db88062abb846422f94a5329f9b89545c5c85848b3050f"))
+ (1955000, uint256S("0x0000000007a180128bd24de08bcda9a1f14985facc7836f4e0807c8f35b6f390"))
+ (1956000, uint256S("0x0000000e2a5b0ea6c830770e16614a39704d94224b317a3c82361e5c833e5480"))
+ (1957000, uint256S("0x00000004e224492b153481750f677db156a960d80e046c0a99fd05e3841f7a2d"))
+ (1958000, uint256S("0x000000038b6f492cfe2bbdef289854fb1b095c240dd4166a8f235e9eb8156258"))
+ (1959000, uint256S("0x00000001e59f4c934ef2f778612da7e8574649cce4638a7b4a9d9833ad32b6cc"))
+ (1960000, uint256S("0x0000000dad02b04d06cf33f129c4001eee6a1633281ad1966089287542dbf0d4"))
+ (1961000, uint256S("0x00000003bbbb92d446e92a6ca1c2026ca5acff6ef342ad7f98220e4a9f8e7ea4"))
+ (1962000, uint256S("0x0000000c344d3c9c22450b075f54711dda6d6f31bd4131cd8ace9197bbc79d11"))
+ (1963000, uint256S("0x00000007f00366ec50f4b795574ab91f426e130cd9b03999fb06a72fb4398f65"))
+ (1964000, uint256S("0x00000000bc0ccb4e73a3b1da4c8b9898176658fd67e0be6268e4e6a7d15a910b"))
+ (1965000, uint256S("0x000000037ef51b844eeddc16da9879defc6a3445142281ae34024447c3c8d9c5"))
+ (1966000, uint256S("0x00000001874485237ab2d0f395532fa16907e2cb0f25e5651312be730a2edcb0"))
+ (1967000, uint256S("0x000000054de0e7518f1263b6d0235f1e2430f7dd23cc1620122357a68731eab9"))
+ (1968000, uint256S("0x00000000a63a04fda160827bf347d6a6cd72ba97ae1608a76716cd97926ea88b"))
+ (1969000, uint256S("0x000000063f5c075dc64a67c603d21416c75ec633c1dcd0e7a93fc03bc21c6979"))
+ (1970000, uint256S("0x00000007790e2edf51dbaced8ac240a960dd133cbab4c0c642b93614987aedb5"))
+ (1971000, uint256S("0x00000007158c4e8d7ad061228c7386179ab5bececfc8e9719dc3129c6c441acc"))
+ (1972000, uint256S("0x0000000c1827bbab90381298cb73f55a2e146bbf235dfa57d6bc08632448acd0"))
+ (1973000, uint256S("0x00000005da023a70008ab851ec50b8b900332376f17f99588c91504c26b5b125"))
+ (1974000, uint256S("0x00000002114d8ecee02f6b3be44335ab85df887a86d78992af6a3ce9ba669c56"))
+ (1975000, uint256S("0x0000000a397eb6d899727ca5db6db81c6ad676c58020a0ffb3f391ff6888f3e3"))
+ (1976000, uint256S("0x00000009bbbf4aab09bb73cc6ed628211b1977ae5a3265fc778dcc06391c4c3e"))
+ (1977000, uint256S("0x0000000b7fb944df8a5b894a38b96c17eda331b3d8c406c5921f470d4adeda22"))
+ (1978000, uint256S("0x00000004008b94214bded7d7f14981a445055997d76b92a920dc4d55681066b0"))
+ (1979000, uint256S("0x000000074afc0070f2fe5643ae73e82f9e2a00c2bd10b65c4009f1fa8b9bb447"))
+ (1980000, uint256S("0x000000104f63e7a22c822a5185dfcf3daea94d1dc4eb72cdd1c0d5819b284b2a"))
+ (1981000, uint256S("0x000000056829646eb2ec3e513ae9bce58e55cc76ff9a8cca9ef9ba1665a39010"))
+ (1982000, uint256S("0x00000001519cc29c8c85f9f4aa37226b7d3a8a65f922f0406a9c5d92175c3c3a"))
+ (1983000, uint256S("0x00000017dc2451bb004694edbc90d12fc16aa45b25ac6b7b3d0179527e1c45ab"))
+ (1984000, uint256S("0x000000020d0f451448959d98abbdc7c9d890b8d52257323b551497376a558a1d"))
+ (1985000, uint256S("0x00000002577dcc6f4fe27913c036fb90161d35ce4ad9eec7fc311eaaef60e94a"))
+ (1986000, uint256S("0x0000000202b6fcf0b41f9214f65d5c2180815004d39ec2de27cacd3a92576607"))
+ (1987000, uint256S("0x000000055865f161ff5e3c9761b37505064dc7583ce5e5e592b6721ee6cb5347"))
+ (1988000, uint256S("0x000000080f858e3d234d701da31ef2aa1254fda3150e3ac368cb51e2115e3200"))
+ (1989000, uint256S("0x0000000cfa4d1e2bbdcbb234fe2f082850dcdfa858a32bef37cf89d00c89f396"))
+ (1990000, uint256S("0x0000000a4c621c54b6e3b4a75e9fa4f018960a1200f074de82324f68b294f04d"))
+ (1991000, uint256S("0x00000000cc0f49d2b2448b362e28daf3e57e1bafdb634ba2c85a51bbbec57afb"))
+ (1992000, uint256S("0x00000002ebd4290f45632a9573abcf4d6fc1639b34aa990eef34b6b0935cf14d"))
+ (1993000, uint256S("0x0000000b6d0c384a04f998e996f453058e006cd0d2bc3abdd518804eb3263fab"))
+ (1994000, uint256S("0x00000002c0fcac020a83d330d6e56255c82d0b47b048270dc33d6ce05b18048d"))
+ (1995000, uint256S("0x00000001d0cd3b61e536c43dac7d4f072769ae8e3b9abdd7f934059e5692c6ef"))
+ (1996000, uint256S("0x0000000ac753c7ed5450d7b05b0bd98a29df7059769c8bc07e04a2ca609c346e"))
+ (1997000, uint256S("0x00000004f457ce81972f0eff5cac5a63832b0d043e0ca9fc5ecac6dbdce65240"))
+ (1998000, uint256S("0x0000000b572087155a59cc67ba355d3a3ffaccfd685570ec56778329b27fb9ce"))
+ (1999000, uint256S("0x00000006e4773706c3a83ed448da34fc4e3e737d47df623254e059fd76643a52"))
+ (2000000, uint256S("0x00000006104d9702e1e5347418c213ba31fc3c14e009ab2d802de64f75f5ef8b"))
+ (2001000, uint256S("0x00000003e0ca20ef98823c384607d34fbadd3425f54b75b92a2f7b898386afff"))
+ (2002000, uint256S("0x0000000486c9388c8932401756df96c043e39bdfb52d8d0a147a5b97922b428e"))
+ (2003000, uint256S("0x00000001e639068d2aada8551e23effbea6e281bc8b10a74e8f9fd757a9d7f26"))
+ (2004000, uint256S("0x00000004e6f8077d8cb9adb4b0c4f08e88deb784c57b461167000763c9f7e22c"))
+ (2005000, uint256S("0x0000000381e818c7c3598ce66fceeb3f76538b851a33672b6fb7f63b0ee1376c"))
+ (2006000, uint256S("0x00000005956353cc542e589709ef1d1859c0466ae6590459ac3299513431e935"))
+ (2007000, uint256S("0x00000000efc171f4a2eab03c8ce32dadade866aee3a9c70b430daf051715f900"))
+ (2008000, uint256S("0x0000000120aad6d1c226a6ec15887cbc96135d2237f37c8c076dd20c81122cad"))
+ (2009000, uint256S("0x000000048d5381588a5be440fd9ad45747f76f6f5ce6e0b679ef549e0ab33979"))
+ (2010000, uint256S("0x000000086d9b6cfc665cd910e9d3832cde002278ae7342b1d660141390e81ed9"))
+ (2011000, uint256S("0x000000070b22fa037c6d290ba7811448bea1cf00c8f22aaf70b992a0456aaca0"))
+ (2012000, uint256S("0x00000003b32bf142b85b39c398205f42b3e10fa967fd78db41cec936347fa545"))
+ (2013000, uint256S("0x00000003b5bd355c58956838c927059b221c87af7e8282a5e0027e8c552d082f"))
+ (2014000, uint256S("0x00000001c5f2d5cccc99b43f7a9c1b9e3315eb4feef4bf611c680d6d55a1c395"))
+ (2015000, uint256S("0x00000006f94f71772329e7ebab13a932297c37faef047b4777f276281a6412e6"))
+ (2016000, uint256S("0x0000000421b342cf93513b1d098fc1a50904a1583f11a67b2d1286b4311270aa"))
+ (2017000, uint256S("0x000000035cfdd315adf7eb39f24b1114c316559b7266e28e369bd335332ed26e"))
+ (2018000, uint256S("0x00000004178109bc2e463872fed909113bb4a047722e7d4131f9f5e75e3b5d07"))
+ (2019000, uint256S("0x000000040bee044c9437828ac4569799f69d14527918015b94c6ef9f0ec771a2"))
+ (2020000, uint256S("0x00000002b5a7669c48ab1e6405688bf645062c2098ffaa8784bb6b9e952f32c3"))
+ (2021000, uint256S("0x00000003e7f2248ec7063391c0b8f650f6f02abcea8146025685cce41f1967db"))
+ (2022000, uint256S("0x00000002a3057653ae6c75eecd9f4688f0440b4e44f81af95cfa2072e01cf366"))
+ (2023000, uint256S("0x000000043d0b453924262edf2f2b07419cb1c79a22d2aeb9d0352727b8b95770"))
+ (2024000, uint256S("0x0000000857efe8be5bee7d4949b4a46924a6b16a773267faa47924db46755adc"))
+ (2025000, uint256S("0x00000007e197ec851d99abb18e9bda39af5acd4ebdf1cb284cf24becaa621936"))
+ (2026000, uint256S("0x00000008e7576b9fd21454ee1c241ad5ff86de27b90a2038b17c05174af6aa2b"))
+ (2027000, uint256S("0x00000007852b9d9c07bb4fb396bfcf1651fed5afacf91ac051e6232cc79eaf43"))
+ (2028000, uint256S("0x00000002134827686fa7399d930d28e1379d806c5da307ee8b6420e43e587c95"))
+ (2029000, uint256S("0x000000064d359b9d5968be2e7f2629363f16f14f2e2c23f9f113bb8074219eeb"))
+ (2030000, uint256S("0x0000000b62411c2027634d87f0fe56311f891a2471c2dc59f881e909fa62e21d"))
+ (2031000, uint256S("0x0000000b69aa3c2e0a408071337b0b8e500d7168ae58866008278bd876711b8e"))
+ (2032000, uint256S("0x00000004ce57ce1b210ec68c6d78d3e61b1bb61b15b42829f59adc144243396c"))
+ (2033000, uint256S("0x00000004024fdc3d1fac61b6713ad6013a2f36738d63cc8da836baf294bee671"))
+ (2034000, uint256S("0x000000057861c7bc5314e0da1aec9f1ebc1ffb4faf6955e0b75a892601edff73"))
+ (2035000, uint256S("0x00000010c8a56a05dad2b598c2912c8ea541b4a26f1547d96a653f6a4201bd22"))
+ (2036000, uint256S("0x000000041e11ed9bd926c40d810330fac5a7d68e6eaa363e0bb5c61af322ea65"))
+ (2037000, uint256S("0x0000000a7e65071ac725747967d8fa4c05cf1c3cf707bf32ea3af64b5be1b708"))
+ (2038000, uint256S("0x0000000f2bf661c814dd4c29018d5990125f5b944f8ff32d1dab74c4df96bb22"))
+ (2039000, uint256S("0x00000011646bb384a33b2176522d0b1890c4252e004f6e39a8a24ef23de7d4c6"))
+ (2040000, uint256S("0x000000049927621327cb34f68b8fa4a7a27a8f348284fbbe19a31dfb05796028"))
+ (2041000, uint256S("0x00000012aa50fdd25fa7bec01b4b23bf185028ee9b391ee01f448e3466dde830"))
+ (2042000, uint256S("0x0000001448dbbce0a941d62af80a4802b4125dbb703b8d6afc562f6f6a71c2ce"))
+ (2043000, uint256S("0x00000008425d39caac093da2d3bca16eb6341a5a5c6a0c9c3b29e59b613f19d5"))
+ (2044000, uint256S("0x00000003646c87e167ccec6a46c532299ff95ad0e09d763c77dea1b1f77fa41d"))
+ (2045000, uint256S("0x00000008a305f798f921a659779f2faa0c9b6061654f128bc0288e5ffba5617b"))
+ (2046000, uint256S("0x00000005f13275b498964e0b1b2175e9269c6e72f8d3d4a6c8800866648cc139"))
+ (2047000, uint256S("0x00000001faff2ed7233ac268b0dea48ca095c4221531fd5cb0a717be44fa57f2"))
+ (2048000, uint256S("0x000000096067600fb16cf37ff22348b0f66e81e70b9db5594ec96e55ea2aed3e"))
+ (2049000, uint256S("0x00000004a5c77487e8b9ce874907d1d87a5cc9a233b8200dc29424fc4d05c4ad"))
+ (2050000, uint256S("0x00000000f9e4a246d317efc0058c117518058b90e354fd0832a8aa3f2817ad98"))
+ (2051000, uint256S("0x00000004c25718021a1640d581520087f4b1ca550f60624e4f0165c42811f591"))
+ (2052000, uint256S("0x00000001f1cc162af35f2b78d57ce24699ddade07e9e28a72024eed4ae6d88da"))
+ (2053000, uint256S("0x0000000675cd8c85204a982290cbcee1ce7744883f50e49b42ec19bc3f26a6cd"))
+ (2054000, uint256S("0x000000073ae301de16e3a8ddfc31461abaaa6d0f68dce219e021e60786a87e33"))
+ (2055000, uint256S("0x0000000c3c1403f65d6d949bf47ac6c20ddf1a72a4746d489ac0373d0019ef36"))
+ (2056000, uint256S("0x00000000bbd938ba5199353f4464da3e0548a161b659d4158022c494e5964c53"))
+ (2057000, uint256S("0x00000002ef9613e873ab3e696bc67a854ca0fbd5d2c80ca2813790c7e68f7ca0"))
+ (2058000, uint256S("0x0000000aa352bf7be4811a434ed81b599c8bb75b51c9180ed950ed93025896bc"))
+ (2059000, uint256S("0x00000008758359b387368898cb7a1ab2637e8afcc25be27639c92044b6d38481"))
+ (2060000, uint256S("0x00000007e482f4d5931a4900fea1fe60e9b5272340930740d1daf0ddcb60fba6"))
+ (2061000, uint256S("0x00000002a4cc006f2a4a8dfe6031a8224f13a1653d2d7cb759f6424e973b21bc"))
+ (2062000, uint256S("0x00000002a89e57d8aa5073bbf9b47d3a1406b880d5a10cd04bf4db15b8d52f9f"))
+ (2063000, uint256S("0x00000001c2c88d5d2afd8e5d3ac0a58f75f1233278bad1f509c04bf2de8a0cd7"))
+ (2064000, uint256S("0x00000001e96c132713c76b3b660176376eee4d01aca688ccbd1f052c7e02eab9"))
+ (2065000, uint256S("0x00000009be2a5ecaa562da4b4a89974c63e41fff0d45e67aaef52cd5628832a7"))
+ (2066000, uint256S("0x00000002b9e96ca7a4702ff76b0e8985bd5b8165a844b0ff524118cb73b81b91"))
+ (2067000, uint256S("0x0000000b08dc59f10fbf0be04059d20d0fe8dffa0775a27deddeea31f1aa9c08"))
+ (2068000, uint256S("0x00000004f4bad2cf91e2ca928674dc26219b9fd5d51089b71ffa3a0e40c1a8cb"))
+ (2069000, uint256S("0x000000020ef61abb460f3bf1805208c67ef076169cc3d93feea93a44549e6b01"))
+ (2070000, uint256S("0x0000001933ccfe24b7f15e44ffcd6c70eb07ddd1e5153572c587c71604e037de"))
+ (2071000, uint256S("0x00000000b837126d714857fbefa49ba9b57a5c8e4131bc58a57a8cb72e0db9a7"))
+ (2072000, uint256S("0x00000009fe7c493b1bedea4cbe111dc917f36a5daa7c515efc1b152b5a4f898b"))
+ (2073000, uint256S("0x000000017b1dcba194020efecba83e73dc5c79d61a67909ba9697be7a096fa21"))
+ (2074000, uint256S("0x0000000523d291de6295dccc955ce5ad336f16f7758be2fe806828c577aceb10"))
+ (2075000, uint256S("0x000000000797b81b51747b233de0f2af1996321a91f3e4202b6ec009c084fa40"))
+ (2076000, uint256S("0x00000001e24e43918b04c68bdb3d6f344fa45161d6a83214d33182c266106942"))
+ (2077000, uint256S("0x0000000cd024f9475ad27396e68f77d14f261db3168510b7d5fd985e15317fe7"))
+ (2078000, uint256S("0x0000000098a181b61158deab23686d5fd27124e333c9db07b23144d490e94e21"))
+ (2079000, uint256S("0x00000008530c9cf4c78823bb23f1c12bf06fba66b757e5c0289c49a695d0f0de"))
+ (2080000, uint256S("0x00000006d0cfee04fb90dcbc7a3e97928228f9d49311f0c03ba36ebd91714c0e"))
+ (2081000, uint256S("0x000000061584569c356147479c7b59896050f266971b3ba39f2afd863c9d5da7"))
+ (2082000, uint256S("0x000000038a92b82d08c169edac37a1b6686d32c9b62efb79a1e0120a2e5b980c"))
+ (2083000, uint256S("0x0000000ed590f12cc3b91f450e5d30a317fb745dfd0559640bbd1822be0892cf"))
+ (2084000, uint256S("0x000000033451b003a9784bf72fb2fdf45a39b324efc6b58c5428ce4d06ae9383"))
+ (2085000, uint256S("0x00000006d0106b85a660e384bcf50003fbb3ebf4dc8ea4666745d18aad0ce706"))
+ (2086000, uint256S("0x000000046acf8da7d34ea59dee43aed38d8b174b8d3945223fd302fd43d1da30"))
+ (2087000, uint256S("0x00000005ced9d8c38416be2bf222b4e6bd0c116b8f3f7eb64b6a8979c4d42496"))
+ (2088000, uint256S("0x000000056abb81bb40ce200afa9431ec809a0b32614bc0a222d8f5363457cb1d"))
+ (2089000, uint256S("0x00000007510588a1f76e1bfd1d71302c734296e56654b973633cdd09715ac1b1"))
+ (2090000, uint256S("0x0000000419b70e2eee4092d5a7a6567d4f0f44bd25bb2e0c9c93640c147c8ad7"))
+ (2091000, uint256S("0x00000005a64ce43194676a276f61bc316b122526487eb6446900ecc3128d2b59"))
+ (2092000, uint256S("0x00000008a604ff11b8c78d309b067636a08881d6b67a262c33a35b7103228a8d"))
+ (2093000, uint256S("0x00000005cd8ad1d36831cb219e751d6fdea3c1ef5984106d4267181574abbb7a"))
+ (2094000, uint256S("0x000000084ecece471b2a7c20058821bc00507948c4e2ddda440fbbff20e8f9d0"))
+ (2095000, uint256S("0x00000004febb4db9b9a83945d1e876e6a1df57e9d4b7c7be522c313ca14b0684"))
+ (2096000, uint256S("0x00000000c6b4ad716b1ecdf2941ac5951566349430f4f65ab30a19d4683e06fe"))
+ (2097000, uint256S("0x0000000a69188059da26fcda56fda6616b6a7b910d81fbac0bed9cd2788fe11d"))
+ (2098000, uint256S("0x000000000964c0376b72fd3475fe3e20ebc0f43269d7c7be0c1b3e1ae3b084a2"))
+ (2099000, uint256S("0x000000075489657e7019ba875720ba133610cccbd69873b2409d293973878de6"))
+ (2100000, uint256S("0x000000048bce0d172dc7f21cfdd89cebc1dc8fda33b53ccd483fa77465601469"))
+ (2101000, uint256S("0x0000000d17a5f6802150f5f317617439d1406c1a6c9905360d5b8936f1235bf1"))
+ (2102000, uint256S("0x0000000a2e1dab28ba0b9d381c2a1dfc503dfc3ece2e7382efeef7fc0a9114ee"))
+ (2103000, uint256S("0x0000000af3728cb8cfd44ebba3ad4371affc1b77dded8c1016f6aa1e7533620f"))
+ (2104000, uint256S("0x00000004d3121b000e5fdfb36181921f290f9b0e88bca5e7db73edfe39ad4389"))
+ (2105000, uint256S("0x0000001578e4d7efa6c5071cce3bcb6c313dc20024605fc68ec52373940e2503"))
+ (2106000, uint256S("0x000000091602e3e0e6f2696b637f278878aa9df54b5da697623d3ff15758f530"))
+ (2107000, uint256S("0x0000000b40c4b2d15563ea4a4526618bc7456ae7af75b43564ef0cec35ad938f"))
+ (2108000, uint256S("0x0000000682e77053c4d4bcd7b6c2104e4e3c194154ef857cd05115f02681d81f"))
+ (2109000, uint256S("0x000000035a9bbeba87ba109903ffee9c71fd62a0a6395f1696490ea674e5a658"))
+ (2110000, uint256S("0x0000000547f13c557983f66c18ab0db1a64c9a8892dd84127e04025b5335a816"))
+ (2111000, uint256S("0x00000011342622886386272683f28994966657f559c5a39dbef9aef6c14314f3"))
+ (2112000, uint256S("0x0000000446d090e0f478bcb7d90cbb15142eb585c31229a433f8fb1470252be2"))
+ (2113000, uint256S("0x0000000db1383e1c4ca8e5f29136deb3f65ff989acbca44c94cdd4d431d6e40d"))
+ (2114000, uint256S("0x00000001574baeb58d2999e2ce95b0049ba0d680cc68caf2ee644abe05d17c58"))
+ (2115000, uint256S("0x0000000b784255ee9900040a759883da9cb04d29fd96f2b2bc8fa777377666e3"))
+ (2116000, uint256S("0x00000002598ad558cd93fbc11106615d187c227d80f4b9e30ba480c264bd2345"))
+ (2117000, uint256S("0x00000009d3b9dbbd63b11aa254b53421d55c864578617c5a57addb7b2b058f51"))
+ (2118000, uint256S("0x0000001083f791fdb1d314ac096a510e829d849c51ecfd07b05a97beca0fdc9f"))
+ (2119000, uint256S("0x0000000ef2775f3449c5f473744e92018681e9de74c59695457d4aa6fdd6d74c"))
+ (2120000, uint256S("0x000000044205e969e5d5ce1f297de9fa11fa23e0407dd28b852d48ab5e45f1da"))
+ (2121000, uint256S("0x00000010b04548479daf16dfa9c8e3c0e5b4e5b29876cb8a307d2e407aa3e5ab"))
+ (2122000, uint256S("0x000000052cd0199a56b4f840e6cd06afc7bae1fe5c6b060ad56b25e60037acbb"))
+ (2123000, uint256S("0x000000059972a7dde8caf40947c0e6fad1e85558e6da1e444be6c246589ed617"))
+ (2124000, uint256S("0x00000009eb2cbc8df55758e60fe06d9b38e57e1408caa4e03724519cf2639e7e"))
+ (2125000, uint256S("0x0000000118e98419f9b56c890c77e53298fa478bf0adaa1cd4e9617f575d442c"))
+ (2126000, uint256S("0x0000001168a734074aaeaa042800ebfd7a1283e0fea5ec8a688beed2822983e4"))
+ (2127000, uint256S("0x00000006dc5056e1e4ecd42ab4247ad9aeeb78313d5b00c14038a91c4c18b6dd"))
+ (2128000, uint256S("0x00000000310924a85b39bbd14bcb151d11e450bd69af772276509e007d93bf7e"))
+ (2129000, uint256S("0x00000014a0d1ad70f7e8b9444143cea92f0bbbba8f3490a502ccb26169acc3c3"))
+ (2130000, uint256S("0x000000077bafacdc4d2276cbd5e97b7f303c98570932991935d947c2bdcf6d0e"))
+ (2131000, uint256S("0x0000000af47253f4aea86c4af51be4b34f5aba1c454aa41098c41d84793cfb5f"))
+ (2132000, uint256S("0x0000000d8b0fd244174731a7f03a399597be4b27ea30f82711c5ce5a7b4cb778"))
+ (2133000, uint256S("0x000000096f73526a734ef98d58ceaf9839095180f96b27aa0b68f8e9bc395cc1"))
+ (2134000, uint256S("0x000000135654421fab135971b1654a79dddb59195ccc060a5b19ba80beef5955"))
+ (2135000, uint256S("0x0000000a93e5abb450f1f1aded4f38b808dfd038fd72e4c20b697aa98fa9cfdc"))
+ (2136000, uint256S("0x0000000408c0887a70fe0fa4a43c477426589ce4f552db7d176eb140a9a30fcc"))
+ (2137000, uint256S("0x0000000464a46aa2d5f22f3f4a39803aad1084a22dccd1fcb83f08e29d3e28b2"))
+ (2138000, uint256S("0x000000064a011e9ecef25946fe33f9c18371e051eb246cd3621090f8139ced91"))
+ (2139000, uint256S("0x000000082fa6fc9c1a92ebf29a0ba2eadccd20508a1db83619357894062a5aff"))
+ (2140000, uint256S("0x0000000460f855e76c4d739a4023d17fe1ac6376614a1764141770edb1d687c8"))
+ (2141000, uint256S("0x0000000481247aaabde662576ee0178a48a4f25ddf188eebc95db4ce2c578bb2"))
+ (2142000, uint256S("0x00000011b7aa00475cf8620ccb296970536e0a7e3cd928d5ed05020f95923ff7"))
+ (2143000, uint256S("0x00000004a48dfe4fdf0eec5f130563783c60e56115226c5febfa0a5201ba7b25"))
+ (2144000, uint256S("0x00000013dad0ea792083834d4e02a711a738ccc4f51955fca5852b151e469f05"))
+ (2145000, uint256S("0x000000054ce9776cbf4d7d957865c0b3aed4a6f466459b5f2f395d2b2a2da6f2"))
+ (2146000, uint256S("0x00000001e0aafae6d61db4d7fb1441e1ce8381a3243e8904ff453857d0b3456c"))
+ (2147000, uint256S("0x000000084f0c9ba9b8490ed271747910a4053bc09ec4ec74f399fe7262e822dd"))
+ (2148000, uint256S("0x00000003f7b29fb734195f4ea924862811300096a17367c0334bf74e2f483fdd"))
+ (2149000, uint256S("0x00000002586cd17b50a802cf1a37cbf0ae8c4f165a8b4bb1dbbf0f434832e44f"))
+ (2150000, uint256S("0x0000000234336fc37adb386d4d3ba166106b1888f6b15210b476778e1cdba617"))
+ (2151000, uint256S("0x0000000abd4237926addc45f8aa8e2e8e3dcecc8f9a065538a0d8add0a41adcd"))
+ (2152000, uint256S("0x00000004063fbe8f4cb1c212ebe3c4655744728091e92e219b245fcd5a0c572a"))
+ (2153000, uint256S("0x000000015299ea3f0bbac8c1e87774255918e60405de053e01f468605169721a"))
+ (2154000, uint256S("0x000000009f685faddbdded0d7aa0360e5fd0434672ec0bd7a496ef14f300d9c6"))
+ (2155000, uint256S("0x00000004e2bab8860d90b57285c78d521d0a67826c6b59ee53907a97ebc3e98b"))
+ (2156000, uint256S("0x0000000365fc20fedaf53e4eb761e8b3efa219d6bb5eee72b569d49302b098f6"))
+ (2157000, uint256S("0x0000000ee0631ed6e44c0ad4e2ab99732088a92b17b946afd6782faf8c1039be"))
+ (2158000, uint256S("0x0000000f64d288fff1628defcbfc0ca5c41a45cdffad7ac8b425eb688645090c"))
+ (2159000, uint256S("0x0000000b4b3609b61df88081218a64157546e78be3125f02e0fb9a2ad7dc6fe0"))
+ (2160000, uint256S("0x0000000c658223e9d6a2b966022dfadc8e6b4a54e04710d2ebcded687cead660"))
+ (2161000, uint256S("0x0000001159a41488ff78d7bedca36a0fd79b841dab0e8ab3904d82860baa8b8a"))
+ (2162000, uint256S("0x00000011fecb4f33f5707ebb37badaf7ff933f117e892f58782b4a9a5f3baa63"))
+ (2163000, uint256S("0x0000000f5797242276a9a7a8cd70d8efbc6c225fcec4cb733ddec3c763ca42e4"))
+ (2164000, uint256S("0x0000000886bfacf5c79a53fbd9533b7af09f22e1a340284f9cff2644fe0b4b6b"))
+ (2165000, uint256S("0x0000000ba2f63317611c67307a58afc3f536568cc8a26c3e1a7c96bfeae50d04"))
+ (2166000, uint256S("0x0000000e2cf36af435818846e670e89b01c4204520108b24fd8b7138da9a80fc"))
+ (2167000, uint256S("0x000000015fcddcda4bf66d26410b003fe1f117701d72a85a2ec308db6a88cacc"))
+ (2168000, uint256S("0x000000129c923c361fd4caeee0bfabef70c5358489ca3a64ccb2c0fb74c2d759"))
+ (2169000, uint256S("0x0000000246c65f7233c3319283c4600600ba6bec6ecf33113552762f8bcc82ee"))
+ (2170000, uint256S("0x0000000ac527711a96daa55c309ac6090e0c5e47f4dc43720fffaf3167d9385a"))
+ (2171000, uint256S("0x000000065376b6bdc5dc0bc108400a4749afddde1c1757c17f11476c1d612220"))
+ (2172000, uint256S("0x00000006ca134d446c4e8cbbd1f8c3fa0276a12dfd5419ac83797e01e87a7836"))
+ (2173000, uint256S("0x00000009009d3bb8f190afc32b77661e0081d2c3f5d7e5e3377b4bb53d5c1a9b"))
+ (2174000, uint256S("0x00000010feb7099c8e0a2f0582c653d131123ca678c11965886b7f283438d5b4"))
+ (2175000, uint256S("0x00000011dbb4610eadd4991bd7a29360d2e73e98ac053445639fa63d87df9364"))
+ (2176000, uint256S("0x000000085561ce48c0eac05bc168bf5eb4eec888795be1ce26ad10e9543b9f66"))
+ (2177000, uint256S("0x000000095e48492726b15e24aa78ada0ec58a06f3d8c6588e9d732f377748596"))
+ (2178000, uint256S("0x0000001219fe5ea9287939ddd0e6e5e2f8ad4d6556a52002ad5074de9f53227d"))
+ (2179000, uint256S("0x00000010e3820efc9a0adc4ef3871f03f2f4722c982a77b30f757b3ef9975cb2"))
+ (2180000, uint256S("0x000000081877c0925c42cb866f4100f49eeb17af7ce3527744e10d519a35dc90"))
+ (2181000, uint256S("0x0000000cea4a29dcf89dc3d699ffc9e04aef2e923f4b75ba9af5c89ebffdb9d7"))
+ (2182000, uint256S("0x000000018920865bb9ea4a7458fec9e3b0e9f28c9bef25488ce444f08c58a062"))
+ (2183000, uint256S("0x0000001353c7fdf1416a0d361dcbe669de666166fe645188a26eea4c78ddf03a"))
+ (2184000, uint256S("0x00000007dbbe33596b119695ebd530869646c32e322b5fcd377d48bc31fd8c2b"))
+ (2185000, uint256S("0x000000198ffa20fcd5fcc98d5242f43ed1fad39015885cafd817870237420ee2"))
+ (2186000, uint256S("0x0000000914848d7c0720bf947010055b0a99b1854e305ca5146658181493d4bc"))
+ (2187000, uint256S("0x00000005b671f40e14f57ae18eb2aef37c233be1f6958a8deb25897b0755d88b"))
+ (2188000, uint256S("0x00000010ff6edb5e128fb6c729fdca152931cdd2c85161770833ed0a4021556f"))
+ (2189000, uint256S("0x0000001790079fc71b5cf4c9e28e8c4f7c2ed68db86618fdab844ed92f49869a"))
+ (2190000, uint256S("0x0000001ac858c2579fe6804e17c9a4ffac6f87ad218a42e0023d4f4a937d256a"))
+ (2191000, uint256S("0x0000000657e488ff574b139465409d783d5e7b12275b9a904adc4bdcbec555a6"))
+ (2192000, uint256S("0x0000000f5d7531d2be768b6b077cc1981f3da77065ddac9019c376abd771d2bf"))
+ (2193000, uint256S("0x0000002bf66b350408816e2dcc6166a7438786d28b5dc96eb2be8251c9edd915"))
+ (2194000, uint256S("0x00000006bf224770c8ed65aba45a66e04a484d4e11718586ca367e76d23570c1"))
+ (2195000, uint256S("0x0000000d1a303359ca7cfff975ea261045650efae95a58ec942ae6b65418760d"))
+ (2196000, uint256S("0x0000000c10de971b747e2d8dcf0b435ad911c5c4e650c22c2926317f9737f958"))
+ (2197000, uint256S("0x000000147f6a742c2a6177e3d265a0ebda14d8b065ccb31979e5a98d886136eb"))
+ (2198000, uint256S("0x000000104a69691ae8661a505be930491f1f8e778b66f236fd82238f1ecc55b5"))
+ (2199000, uint256S("0x0000001d15e004f42cb05c998b9bc4dc523be01d38b05b70d6247b7b273b3b1a"))
+ (2200000, uint256S("0x00000008cfb7b2ee0a5efbcaf54fb9343fd45aa0fc15fdf9f793a9ec84b1b3d8"))
+ (2201000, uint256S("0x00000014ffb9bacf3a7cce9172c18acaefb7e37be1622c058239c3903a41b1fb"))
+ (2202000, uint256S("0x000000199098587a246d8326b2bcd3edb13f9a5929164973f3dba9aafc7e2db1"))
+ (2203000, uint256S("0x000000003bbc88abdde6242b28a8f7ad7c80a0a4b2b02f7c13f1e851a87c0531"))
+ (2204000, uint256S("0x0000000b9454d46cdc35e507b9aa0b98f8c6c98bc7473281a5925efa25e7d9f7"))
+ (2205000, uint256S("0x00000003c6742a5eb51b71732d4ad13bddabe1a22a0f9bb1879c726853db4ea0"))
+ (2206000, uint256S("0x00000010ee207e0218f281066a8cb3a208540766a34818d001859a4ff21a9442"))
+ (2207000, uint256S("0x00000011fdbf6ed34b05e960036e4d1bd5087cb10a3fb37edad1847403d0a5fc"))
+ (2208000, uint256S("0x00000017fd1de616ff467b5a6ec399703f232dd5e20021f0325df4cd5066047e"))
+ (2209000, uint256S("0x0000001b0d85a780bc6c1fcf95d775ddf7d11930b8a7d0f30c76e17fe5b91f08"))
+ (2210000, uint256S("0x000000320ac1d0412b54f38d926afd63830f91fcbcc06869b9970f53804c8b05"))
+ (2211000, uint256S("0x0000000e89eb1167ff72252d64de56463e8bb89a546a318100bc1e09b40c75ed"))
+ (2212000, uint256S("0x0000000929563985b806ac74a296d19869e5e74942e73a8769da3380b0be3769"))
+ (2213000, uint256S("0x0000000268c366b226e82917d23c89eebfab13d226388362220b0052cefeda9d"))
+ (2214000, uint256S("0x0000000667ffb02f6dfceba778614abdbf5ae11b73ce4d8e5524d3e77b6d1bf0"))
+ (2215000, uint256S("0x00000009c0432726c9666371c3834e5b500b38caf41080b68869cfbb12af6dc2"))
+ (2216000, uint256S("0x0000000b4a5c376d4fc524ad456c90147206bbd445509be5a191ad9979c51f67"))
+ (2217000, uint256S("0x0000000563e32e4235ab5694177fc53923b9b742d0cb8b6dd654a1b45b5b9e9f"))
+ (2218000, uint256S("0x00000002e16de2a52496ac6caff3454fcc8dda9291b042607ab5b8cb4eb06149"))
+ (2219000, uint256S("0x00000003f615c3a50807128b9eb71dd357782edc581b923f0d97ecb169f00744"))
+ (2220000, uint256S("0x00000005a5d40c3f2239ceab163c6b0065b5c8eb98608a67943c42a7d0efdf06"))
+ (2221000, uint256S("0x000000052f90cdbad630bfc9639680fa20fd40af4448d6222b832b1496f9d611"))
+ (2222000, uint256S("0x0000000a114845b86115b2b7e83999f8745d795b3e712481dd8fcad6b017ad6c"))
+ (2223000, uint256S("0x0000000671f202549cf64821f6a7f9a722cf79054fd415af2c38477ed11f4509"))
+ (2224000, uint256S("0x00000006f8d21a9b3ffca12033f5e27d7a4b45c6254cd3bcfa0a6a7e252ffbdc"))
+ (2225000, uint256S("0x0000000e97a31cd82ec650d23de1d6a505ebc6f752b1bedb9f9295be69840212"))
+ (2226000, uint256S("0x0000000a77b14d5e8aa98dc37bab028d11c999478a344dc2d9eb4db350a8fffb"))
+ (2227000, uint256S("0x0000000886cde6f06d72666d7ed1d85866f8bea788102932c973fe39af80a74a"))
+ (2228000, uint256S("0x00000009af43eb0ed51d153a3462b65d09b4730c277d528016852980e4168752"))
+ (2229000, uint256S("0x00000003f464599aa6386056de225d1cbef006b8da9c0d27cc6fa779089868ca"))
+ (2230000, uint256S("0x0000000c0bd50433b89655bf283daf43856db8d822e996f614397c8b1c393e38"))
+ (2231000, uint256S("0x00000003254820b91ccca295afaa3c9562ec15032953d5ad0782c95f7d4da9fb"))
+ (2232000, uint256S("0x0000000349afb4e98ae708f7dff039c54b1446da2664ad0dddd5f5b94755cbfc"))
+ (2233000, uint256S("0x0000000297526918a57fb1a21b70cd8ed1265547d4a61ecd57302c29d16aba1c"))
+ (2234000, uint256S("0x00000003288ea064a3f6ddc603de61bdb4c0ccfee2a70b621a7fe95f9ad35a8c"))
+ (2235000, uint256S("0x0000000b8a88cee5ac71e4b61ace898cafe7c895c9bf0b5db00b9d71fda173d7"))
+ (2236000, uint256S("0x000000056051307f0119d828d8d621b34ef6f60a06694c569c669ead97b9a00d"))
+ (2237000, uint256S("0x000000001f5aa9e9dbb3be2b01a4ab0b108b85fd375f23a0452930126a00c21c"))
+ (2238000, uint256S("0x00000002daa24ab7db17601826843cef57562ccc1aa80a692daf45435d816cca"))
+ (2239000, uint256S("0x0000000a9a4283412f076a0e1d36e1e02571468ff12d06c0d075e1dfa569af8c"))
+ (2240000, uint256S("0x00000008b78c49c1d514ce9cc583ec04c36023911ed7772d1cf0c50b5ce1f8c8"))
+ (2241000, uint256S("0x0000000cbb3151b62023e1cafa4476d7bf2cf34c13229f3ba510053182133ef2"))
+ ,(int64_t) 1750938666, // time of last checkpointed block
+ (int64_t) 3149229, // total txs
+ (double) 1257 // txs in the last day before block 2241103
};
// END HUSH mainnet checkpoint data
} else if (strcmp(SMART_CHAIN_SYMBOL,"DRAGONX") == 0) {
@@ -2989,7 +3536,7 @@ void *chainparams_commandline() {
(987000, uint256S("0x00002723abb80e9ece84055c113e0caa507177ddc88cb6b8011ecba39b490dd8"))
(988000, uint256S("0x00001938e724c8033d1f60ddd27512f6f358847e96c63def28e85bd40616117c"))
(989000, uint256S("0x00003071ff9188d27f744395aefb1d406cccc15f61b7f79bba0ea9d100475a63"))
- // Generated at 1709141373 via hush3 util/checkpoints.pl by onryo
+ // Generated at 1709542425 via hush3 util/checkpoints.pl by onryo
(990000, uint256S("0x00005340e6855081dd3fade7baa8db18b660ffd272373e67c812c5cf69006300"))
(991000, uint256S("0x000027d07656cbdbd3746495e091388f35c9e2a11a2389174490a9433a9e0da4"))
(992000, uint256S("0x00001413d8eb317a69e45bf44aba0af79c724b45272043307480213bd4e7d653"))
@@ -3132,12 +3679,1124 @@ void *chainparams_commandline() {
(1129000, uint256S("0x00004691aec7b3d82d064a112e4a480e48ec3d7fa678862df12ae146265f5482"))
(1130000, uint256S("0x000082de552f3b0dbd1a805e08db29f9f60fe020ee88944b0266e55cda2f7e78"))
(1131000, uint256S("0x0000061cc63ed366899e9d4d7c748ac75ae3ef9a32ef60e92cf7c0c306ee9711"))
- ,(int64_t) 1709135822, // time of last checkpointed block
- (int64_t) 1158597, // total txs
- (double) 2480 // txs in the last day before block 1131156
+ (1132000, uint256S("0x00008bd55bfae2a954b70b04f570e03b9148d639358a697b5d2e948fc6345918"))
+ (1133000, uint256S("0x00003a59655529f46df2b436019db7b1d7b9757f4416699ab5d895cd68f9be64"))
+ (1134000, uint256S("0x00004f6097651296f52e7d69a51e7b82ce12599109c5abc201d77cf9af9d6e88"))
+ (1135000, uint256S("0x000049450fcc6b737c938099e17bc0c54cd18b385112cd7689477a9cc8a27e99"))
+ (1136000, uint256S("0x00005ea94a0ee3a23b8224a87dd107e13ea0e86a59c3d2de4fb9fd3a94c0fe27"))
+ (1137000, uint256S("0x0000270eb8f01ef39a7a1cbc8a3d0d2ceefc65f5842ac3001b4a5247e8c2e525"))
+ (1138000, uint256S("0x0000339b020870d50d1496802dcf21142c95971f1781000c202d1e8a52bf12ca"))
+ (1139000, uint256S("0x0000716e4b703564bd4b4bfa84fd6b317aefcea3d13e6eead901de144a703005"))
+ (1140000, uint256S("0x0000012c87cc87745fe70667c7a2eca8b03dac27a8424b0830c06a18fdf9fc77"))
+ (1141000, uint256S("0x00006bf655db63cb0e89eb631a25d198d80d593cd4d35c8c9de2b62003a8f4f2"))
+ (1142000, uint256S("0x00000949c0348276363e0aabc6895b7a5298ba2ba1f003c2a4a23be5c6d843a7"))
+ // Generated at 1726147945 via hush3 util/checkpoints.pl by onryo
+ (1143000, uint256S("0x0000559866cc5a14cf418bec8754ac4790dd538fefb17cbfad7ba5d186dc8f31"))
+ (1144000, uint256S("0x00004f970b2fc229ea23e0294ff43e7858e00a6ef2ccad15d48c7b8e5bf9e270"))
+ (1145000, uint256S("0x00000a8c950b018ed9517b58f2559fd4a5a9213dcd552e78ca25b3c76b8456df"))
+ (1146000, uint256S("0x00002be2e2e097c68eb85b60ec0ebbe4e87438a25affd4ed2dc29387d5069ba6"))
+ (1147000, uint256S("0x0000474f086d74c4a20bbb6131bc75aea1bbc2ff5a32f462fae87a2375b85d26"))
+ (1148000, uint256S("0x000054292fe108d54727c31aacf212b6697dc6aed6d14140e75d3982458f6af1"))
+ (1149000, uint256S("0x00004d8a8bc4a47f060fa8903ea8d73528f83873f878516e7554decbbfd1b3c8"))
+ (1150000, uint256S("0x0000383d666b6039ad272fadc0e6375def512cdaa0d958ef03369eb286f7f790"))
+ (1151000, uint256S("0x000011afd8e3a4920090b635cacad14e12c61d9b64b12498dc533bc3ea7a2c07"))
+ (1152000, uint256S("0x00000992f60aa90c6f8f17d9b1e3e22500cb13d254d1a736dd34fd4838ea5dc0"))
+ (1153000, uint256S("0x000027c82a655f31c8614ca71b2ca7913379b735e6800abe41634ca9a778bc49"))
+ (1154000, uint256S("0x00001800e1d84ba053d1cecbf92e02577c06b05f5963c13df01802eab626448f"))
+ (1155000, uint256S("0x00005254625752fad08e9a965f7b8e2c44710250782d307c02a6a97ae011d76a"))
+ (1156000, uint256S("0x000051ee7e11ebb76f6e27e1d4fd206f5527a6dd3ec58e0bbed04f75b6462339"))
+ (1157000, uint256S("0x00002dd6c9a7fd522d5a2c9810da28dc8d456fac65e4faa377f6247f37b08978"))
+ (1158000, uint256S("0x00007ce77f64fbf985fc4e2e90dc6bec6ca17845eb7f9096d7f8e463540dd394"))
+ (1159000, uint256S("0x000029591fa14c002a6befeb3d567ab73be62600f40e337c525eca3412b6c8d9"))
+ (1160000, uint256S("0x000033a737dae6e4c83b3cc5eb9cfab2d69119096dd958a620b3d4d28505461c"))
+ (1161000, uint256S("0x00006f6989a5cae0b1974edc9d9b9eeb028208a285820429f3fa63ed8bc9466a"))
+ (1162000, uint256S("0x00004329014090653fe61bc5760b392730d2d4926228538d322f3c10d5d00fd6"))
+ (1163000, uint256S("0x000050ed4d90504ee338510f3fa404411a6c124561b1d697042b3644101d73df"))
+ (1164000, uint256S("0x00001733edfd42ca5d95d039ff31eb28cdeb72bb6a63a6f797d097bc850cf874"))
+ (1165000, uint256S("0x00006132cc449bcc44ac4cc8077991419558463b936cd2dcd498d7d384de957c"))
+ (1166000, uint256S("0x0000233926a59b4b5b859af2f89159d72fdaf70b4d291bfd28376efb5b1af8b5"))
+ (1167000, uint256S("0x00006cf8e4257f5ac086e112f1bad8e5d119220545ed98dbaf17b6585cc8f8b3"))
+ (1168000, uint256S("0x00005dea4f2ff28f229bf3fb9ab4c8d5aecd79417acaf9c1fe875c223030b228"))
+ (1169000, uint256S("0x000009472a9a906e93ab907a41f5b67466e64d19142ed6889c769b8ec0941603"))
+ (1170000, uint256S("0x000015438fdf9acff1bfb51f49362ae1c1573c278f5048def1dc5b3f6ebb4d46"))
+ (1171000, uint256S("0x00002e38ea63b3e4b6a7cd5d8034f0e3f6fcfe9640c0d5d9ef1ea657788c88be"))
+ (1172000, uint256S("0x00001affe5e20f07596836762c185c83e6a80b1e61f6c3f6b75c19cf78756f7c"))
+ (1173000, uint256S("0x000062ac3dbdcc95b2419b9bb887bfe51b2517fde6e17bfd0d7108a704878c74"))
+ (1174000, uint256S("0x00003efdb7414f360b533f699d4af99a93f1d2752617a21cc2f780b54d8bab6b"))
+ (1175000, uint256S("0x000017520993990f7cab94d7047d745d533252d577479e22fd630dd4df0943b4"))
+ (1176000, uint256S("0x000024bd3f052e52f37d15a9e71729a85c2f06adbb99cb38e95f48ab658aa331"))
+ (1177000, uint256S("0x00004a741fdc39082def272557e0cb43996b917707190b8203dbd8d98df6502c"))
+ (1178000, uint256S("0x0000123fab19710ddc712ff96a8fa813a4b8ce174dc6a4015f63957cac36e276"))
+ (1179000, uint256S("0x000007e82b343a8b76a0964206a34f5cb0c5765f7b02fe4c538b2a45b36d9b09"))
+ (1180000, uint256S("0x0000649ca5e4674aaafd4a4ba0471871174ea06c10509d112eea15ee99fe8daf"))
+ (1181000, uint256S("0x000029fb97da343e7e6402af6cc9b4f3796be80b2896a54fb579e471c6bf115a"))
+ (1182000, uint256S("0x00002af27c646a7b0fa7c96ea6edf9c098d6fde6ff35f1e793820dc5b808280d"))
+ (1183000, uint256S("0x00003e2f509c57db42106586345b8a1078223ef43f6b29aed8ec1cfefcaee17c"))
+ (1184000, uint256S("0x0000073e3365f8b253334d549ca50a5adedce9f97427bef3ebe314c04f983b63"))
+ (1185000, uint256S("0x000001ce36b5afec8ad1771670f9a17755efbd78b169c17c8f1977903d7942b6"))
+ (1186000, uint256S("0x0000572991b2ab1139dd0e06d6d326dc924536f62d563a3f6b4bb31d5f8da850"))
+ (1187000, uint256S("0x00000e430150aca093ddd310bffffbd4c28fa65423d6f5491c902c7fe5bb3c50"))
+ (1188000, uint256S("0x000063da1fbcf413ea1a8664352c409ea2b2eee698fc953313e04e8f9c4c13f6"))
+ (1189000, uint256S("0x00005bbc9f9803ca56d18da09b6e8158a9efd9795753e477636948049fb6b077"))
+ (1190000, uint256S("0x00002245226551549ffa162c710225978f840faa0970916927ba949cfc9abd11"))
+ (1191000, uint256S("0x00000750a1a7f0b9f320c07e4239c8266ca8203184cf2840d2117e06da625e2d"))
+ (1192000, uint256S("0x00000340cc881b0ff9a1045da2e513e1dfaa9784d5c74b71d06a69ba08f9bdc6"))
+ (1193000, uint256S("0x00004af98432b689093039aa7bb31407320db379bb7a1af401f4ab3b50b4c7cb"))
+ (1194000, uint256S("0x00002811098dabbf8b0d9a187a7d6aa946eee22ca7a2d4fc0e2db05c85d9e7ee"))
+ (1195000, uint256S("0x000023354ca74ce1d65c067a43bc287b178db1accc68d0e255affb783d28fb1e"))
+ (1196000, uint256S("0x000022f383c401cdd9b5428a35d2912c32da96ee75d9ca11d6c950bd26a85ae4"))
+ (1197000, uint256S("0x00006128dee332a6b6a60bbec4cb87a21a7caa4d998bd50e4e17f93a9fafa947"))
+ (1198000, uint256S("0x000040c6d3b8a3056f809beb6fe99193c95fb1e675217fc4c672947e4ad28b5b"))
+ (1199000, uint256S("0x00000526a9c4e9c16dd17b43fedd5c93484bcaff8c659fd8c590c4150674fefe"))
+ (1200000, uint256S("0x000013ad8b897aa023a26864bc8499fadc17c37214b46f0d4b84dc4744a3f270"))
+ (1201000, uint256S("0x00005499d0c4695da60fddd08c03f2f88fc73bce71fc2db01287afb58f6c0be8"))
+ (1202000, uint256S("0x00002fd7cf1273183ee655a1453d99accf4911134f14819ed04af6a22e4869f2"))
+ (1203000, uint256S("0x00000c5686cbe6e542dfadb8a8c72f5fbd6f3e4c4151363dd5ffed5ed4e0de93"))
+ (1204000, uint256S("0x000011645bb9c42eaccdf0736c7cbb9d446cb0ce42b9298824fad5a9c896cf1b"))
+ (1205000, uint256S("0x000037b4659afc89a6c0c31773590af066cbd8cefd257f4f97d6715589196230"))
+ (1206000, uint256S("0x00006401cfc88a271056704d6820a97e30d32e1f55f045070f1f2864e37477bc"))
+ (1207000, uint256S("0x0000384c8c430ec912faf02763b45908661c49a09d957e04fd666c1853a445f0"))
+ (1208000, uint256S("0x00001272213359e1fa3986880da18000d1dbeb472794b6ef3e119f1f924dd0d5"))
+ (1209000, uint256S("0x00004ea7dcd4baa421d2f25cdd3d154fbeb80b48bef575bc1abf7be30b531782"))
+ (1210000, uint256S("0x000014155338aa216d649ff656fa174fa2ef31f709ff6733a6dca2cac5fbfaac"))
+ (1211000, uint256S("0x000050cfccf156ec081627ea46874a77f210dbcf5f815e67476104a49d2234ae"))
+ (1212000, uint256S("0x000002361f8cdb0ef51cab2067b81285e5ad470876eda334357c1becb4e14a0e"))
+ (1213000, uint256S("0x0000148363d3feb29f88b422299e0b6c4d02579a390f2ba5f813d8b834c6c9ba"))
+ (1214000, uint256S("0x000014dfe478cea8044551facc7a21e3cd150d1bbe36b240567c3e605d240f78"))
+ (1215000, uint256S("0x000066ab5b4c8ca88603b375dadfd7437e82afe4c0becf0c823ea52389c95592"))
+ (1216000, uint256S("0x0000192d568f61af06e235d325ed8a25e338ecde8ebb7550168c3eda7271f8b9"))
+ (1217000, uint256S("0x0000082ce9b9bf87cd52d99fa606276cfe37f3735f87e6124929d1904f9a8e59"))
+ (1218000, uint256S("0x0000664551fda17ca48d894328a14ee1ad6cfbe3b093cfe2af5cfa6c326385b3"))
+ (1219000, uint256S("0x0000567bc2fba439fa518ace0e3e1a3de20dd681787c55cd47fc5fc3270dd689"))
+ (1220000, uint256S("0x000032c41595c1d0856b5f42cc223f718fc39730a8ccc7da12979eeb16843b17"))
+ (1221000, uint256S("0x000068a6d0e870f3066eb53fff971a3bd2ed5e6be356aa60b5471acddbab1463"))
+ (1222000, uint256S("0x0000501c420637240ced9e7b1ac94d1ed6628c32df44516b3cee7e362f68bcf7"))
+ (1223000, uint256S("0x000017febc9a274e74e08e1bcc0d2437502c2367565cc66a41418750f14996ed"))
+ (1224000, uint256S("0x00001cdd2659af3594e105128d614ed88275a3aaf17ebebb7462efac3d7a8308"))
+ (1225000, uint256S("0x00004c9e0b767f0af5af5ee53f0815c1250412a6da9b095d71bdc4b1d04aacf1"))
+ (1226000, uint256S("0x000040ccb928b631aaa50329c3aa6c261e0e259be89bc44d241d32a06906b7d2"))
+ (1227000, uint256S("0x00000636ff452b4189d3e504317cd1e0565f6989c08689876f175976c8e5f6d5"))
+ (1228000, uint256S("0x00003922ee1388e9dd42ec9085be131adac3cb192889573c7dc95f0d5b10fb2a"))
+ (1229000, uint256S("0x00000d6cc5c06405e558d1586ba42cb7a7a33658e806ae84956c501da672b15a"))
+ (1230000, uint256S("0x0000172fe9a0cdfa70d80e99586ac8a26034d7100a74c45aa5cb832be780b602"))
+ (1231000, uint256S("0x000042423636e41f92ed92e94573a7757c5683c71d794ca329f4dc250d496562"))
+ (1232000, uint256S("0x000030db4f249f0a8a0cc452f7c286346193a9b9a58c612a3026cc5196f34b65"))
+ (1233000, uint256S("0x000008739a594e05fe74e78016df5a8cc9f534c35f476f31cc53c1f728ddbd0b"))
+ (1234000, uint256S("0x00005686cacd29d4b25154f85a59b96ad38f76b1dc50189ccd7c2ff64916d500"))
+ (1235000, uint256S("0x00004dd1ed8cc9d9fae3dda3dac545c1013888053d7d172c93243bafc12ab6bf"))
+ (1236000, uint256S("0x000039da72e90fdf62c5058186ece9f625a6fb752468dfcb554cce91de40533e"))
+ (1237000, uint256S("0x000051b553a4247a192a3c467cca2761c03b083e72d3b3876e00cfdbae61ee1c"))
+ (1238000, uint256S("0x0000470a1946478d605cd8de5837f6605bbb783d8e20437b4a72574d9c8135cc"))
+ (1239000, uint256S("0x00002b7de55538a8b5a5d7f3869e24585a7da48da6770900620f37e3ae3cb067"))
+ (1240000, uint256S("0x00005dd97b8aa7bba0d0a2743f39b6a483884db7397b65abedb866bdb27acdb6"))
+ (1241000, uint256S("0x00005370d77990c5391a2bad8c76eb21ac87642f70ce4cb859e2998f327c76c7"))
+ (1242000, uint256S("0x000013e9aebc799c5feb3a8048d663f698ea1e2ea69f0f493fa5f0051fb63a1a"))
+ (1243000, uint256S("0x0000149885bc1668a1993b87def2c16c546cbff364cac2aa9bffbf98dacfab30"))
+ (1244000, uint256S("0x00002c685cda1ff8c394cac9d350a58edf7202a8f0d28a6ee08cd72ca052cbfd"))
+ (1245000, uint256S("0x0000102705046f777fac46a021ad9658c4413fcfc45079c4f2d72a4628317a87"))
+ (1246000, uint256S("0x00000fa7de6082201c2367a3fbce4dc81f68442bcd953053e495cd546791e589"))
+ (1247000, uint256S("0x0000154a5c84fe71a13ce57bb79d10a96c87cae33377e7964b23ae94a2253a17"))
+ (1248000, uint256S("0x000000be86b23e43ff6a25bc0762054094c9610de62e7f402ef6d5fbf997ab1e"))
+ (1249000, uint256S("0x00005b543b6fc0104ff434f493e9e40e6c60e2dfcdf64fad44418ccf6b186b5c"))
+ (1250000, uint256S("0x000040801b1c63452f1fe4a0549d5062b24f9d96ae8813e38e5310f2feab28f4"))
+ (1251000, uint256S("0x000057fb0a2062247b3a8536b4890ef2474e9a0e995a834feea2e51eaf43829b"))
+ (1252000, uint256S("0x00004e2b5964a7b44110b6ffa12aba62d497333c41216e2a177d49593181d5a6"))
+ (1253000, uint256S("0x0000319fa7a3b0ed79476b6568f4e64136a5d427d1ae00aaa38f2db6113ec7ef"))
+ (1254000, uint256S("0x000019a583a766c17f6d107bb941752783b3b595ea5cb02279b2915645782881"))
+ (1255000, uint256S("0x00002001eba0b7c49990435285721c5e8d8dfe087a33a0149bfaa138ebdb11b7"))
+ (1256000, uint256S("0x00002932656be7b66c9a751d8da9b20e54972a7c0c260976cc47f4a48ec8e0d9"))
+ (1257000, uint256S("0x00000a8566c990bd741caae3dde65b624b884b463b9bbb5cacc4078fbf0339e8"))
+ (1258000, uint256S("0x000039e1f356f63faf24d72e9ff9c29f77df9f40756d5dd524a3b250ae2e871f"))
+ (1259000, uint256S("0x00001eb035d147edeaf8d88049502b2044e2d8da4750f5c1b9a7aef9c6943195"))
+ (1260000, uint256S("0x000012c037027810296ce25642167daf3d0495e1ef9292544f47599531244bd2"))
+ (1261000, uint256S("0x00002abb17fa2d045456b3961696f7b36b1443603ccbadf2e6395dc1d1fb140d"))
+ (1262000, uint256S("0x0000088736c35e41ff0566ff9fe6d76e0cc142e99beb5854bd8f589d90d7ef0a"))
+ (1263000, uint256S("0x00001ed2d037a67a4ec8aa01138726214016edf506251c6b454404e98cb766df"))
+ (1264000, uint256S("0x000005e40cd01ce160b4fe154922162fd3d492aa52951bf44337a139409a4452"))
+ (1265000, uint256S("0x0000676839db3008652bef92beea49cb82abad08c7eccc57284094fad7feca13"))
+ (1266000, uint256S("0x000013074b6318eb49001ece9fc669438b0e77c686c5a43b3744d0cf47a0beb1"))
+ (1267000, uint256S("0x000022aa82205b1067a9a2ebc5930b70b6881d984d0ce1a8b029fd6f0bd88f45"))
+ (1268000, uint256S("0x000031b0063d7f9063d54bb07fe9e56cbc3b75022080fe7a5c25cfa78e867d24"))
+ (1269000, uint256S("0x000060c8a2b63b45fbf8a359485425c0ae083d4654d2d062f1a9dbb4a1b4a1e6"))
+ (1270000, uint256S("0x000022d4eefaaed23d27ad85bb00e92349b53c3f81d4d308acc53434dafdf731"))
+ (1271000, uint256S("0x0000077b6614dba2b69bae84afbe8d11e3beb9b12c869c8a9160f3dccbd833ee"))
+ (1272000, uint256S("0x0000359829c6014d0707fd13bb5f66e1906346fcf6a64fb5e81a29d7efcd52c4"))
+ (1273000, uint256S("0x000044586991e1f5cee09e2c0b3e175845e659945b8f680d2bc148c495156395"))
+ (1274000, uint256S("0x0000460b6b756e425a9ec78111b4c3dac21fd61027f4cd4ba557d7cace76f400"))
+ (1275000, uint256S("0x00000c6fc0db70726dc0a40e9b12f636cb4830c42c1b06de34d8dbc618685cfa"))
+ (1276000, uint256S("0x00001d7679c574c9c5dc3cadf6bd27f67126db8f79e5190f8ddb9acfaf85209a"))
+ (1277000, uint256S("0x0000355d71b43c37b2426466692eadb1a425a1dbaa15960cd99b1b9935a90006"))
+ (1278000, uint256S("0x00004c7ad5faffd431bff2e9f3de5f7e89ab8fee40c0a5c997bb999a6c5b4cda"))
+ (1279000, uint256S("0x0000474d6f4ea13eb5559ad26b7adbb580c6a44dfae04beeb49bb4f994da4fd2"))
+ (1280000, uint256S("0x0000187b49dbd8b87d68adc0070413d3ba904df45d27d1837aede0aa50993df5"))
+ (1281000, uint256S("0x000053c0c7c2df5c493b6c94c90f7d54c9d16182f673f0d79697dc4bf56b551c"))
+ (1282000, uint256S("0x000032a389674742454fe3410cf839a0a761cfa46dfa126cb1a32da994d272de"))
+ (1283000, uint256S("0x000034e46e23ea151912514e0736c9b27efbf9be08dbf8d931f9686092534280"))
+ (1284000, uint256S("0x00000a5df550a85eac7892811fee5473ff7a9c8308d70671e6c279500ad731df"))
+ (1285000, uint256S("0x000015935070956de8543a6d36d7b97436e1b8b933c308c3929a404b15a56dc9"))
+ (1286000, uint256S("0x00001a57e5646201963da0f7e3d130ec1ea70e017883f677a7cee17d6abae9d0"))
+ (1287000, uint256S("0x00004a92e3671588fcb49a8db0283320b13138edd92e19fbf1c843df9e5ab2ae"))
+ (1288000, uint256S("0x00002c10244eb91ecfb44089ec47cc3594b6876f1db247ca49f378ad4b216dba"))
+ (1289000, uint256S("0x000050a8a6902ec83acbd97c599b0cb1b503437ed964c98e9bfeb8a0f2bbcc62"))
+ (1290000, uint256S("0x00000ed28be2c4c802b598a19ed177364bf86029e8b20e43338c721f231e4279"))
+ (1291000, uint256S("0x00004d122c9a324995e3246836d0bac61f731d82331c2a62b47f78ca45cd09bf"))
+ (1292000, uint256S("0x0000088be22cde734cea1d67f8a3f1d5297fd79b1c9e5fe44be483057b08439f"))
+ (1293000, uint256S("0x00001b62d2ae6cec0a041b5d6b7ab112b618354e4788476d2b0fe6abf138fd03"))
+ (1294000, uint256S("0x00000a13aea1a99a8167cd04ec6c0363de67f49ab6b1a7e5d76612dea2ca0cf5"))
+ (1295000, uint256S("0x000033982767c8bcc47dd13c5be0f843e1385bc51aeb87debdd5258bbcde9d2c"))
+ (1296000, uint256S("0x0000125c70cfad5ac088c0043509f659f59878758234b89cf31010e2ad028a82"))
+ (1297000, uint256S("0x0000259af057d1738063700bbdb1352a381c01092d6aca3380218ed6a5fca750"))
+ (1298000, uint256S("0x00000441c838672326020f9b1e1036f108254216d50af05bddb4b19357d95855"))
+ (1299000, uint256S("0x000018fb87a76ae93b2c9f8052442c875a68b474dd81af0c59221eee714c9e6e"))
+ (1300000, uint256S("0x000009b6907f7923dc9b784b0077bb713a8856ca9d940f57078b44d0f83ac312"))
+ (1301000, uint256S("0x00004289784e21a386a8190738da51c2d3f77900259414860b5e81539e9558e5"))
+ (1302000, uint256S("0x0000289a30b70cf0ec123814a18ff6f0d87165f762207ee4e931a355afe452e6"))
+ (1303000, uint256S("0x000023cf6ecda684faa7500e030e6dcbdf63af8a26dc498d94364df7bfdae0d7"))
+ (1304000, uint256S("0x000034c8fe4345599dcb66d08bc7595d99cf70f3f8a53628b43eb27fc849ea0d"))
+ (1305000, uint256S("0x000043b3c599734e3c7c3fe8223fba99d1362f3a5cbcf92b6a5965fec8eb14e5"))
+ (1306000, uint256S("0x00003c914f7c29699e4532cb69a7cf806e76bd93bce5a16802bd6fcb72cf0869"))
+ (1307000, uint256S("0x00004b4b26da50b96f76b2bc4fb2a86d9770998e8e5d4150e1d6b747eba925e9"))
+ (1308000, uint256S("0x00002fc77f9b68d13c067311e6ca0ef116eaf711823d4b1b584f9acd7f0ce82a"))
+ (1309000, uint256S("0x00002d1b444197e533f8025ef5ebb6ccb279094c1ebe1dc999d6604554f0c91e"))
+ (1310000, uint256S("0x0000136813f4498435a9f1d740616be5aa8a7dc5fe1fd893a86400959f2667c4"))
+ (1311000, uint256S("0x000015aa7a373c271f2761066a9fce067540bedca683e0cb2e7cb075c2f7ae56"))
+ (1312000, uint256S("0x000049027d369fba3fe3a0dc4c34a8f19ceb7c728aa8a01863368e65a74a0402"))
+ (1313000, uint256S("0x000021265084f0017f10af2adec81ad77fdff31e99109787af283cd6ce276d86"))
+ (1314000, uint256S("0x00001dc5b690ef30a433b9b92aa2f53083e7f97ace9e7efa3b66c6e45237539d"))
+ (1315000, uint256S("0x00003b70d6876046d2815d25c254e7a28687344d8d8d881b5a2cb490dbe1b7b0"))
+ (1316000, uint256S("0x0000035c58cfcf4e3bffa99a55195ec63519b41d2158cf35a98e31f0b2ff4fb1"))
+ (1317000, uint256S("0x00002871c10c82a4b527d460036b93a3218ea8f4c0d4d5962000b21fac6ce5c2"))
+ (1318000, uint256S("0x0000523e5cc8af99515b772098780d643ecf8d1bb60a44e9ed01e1e6ac05fbbc"))
+ (1319000, uint256S("0x00007649faacbc98ca50131914a671cac3449faf45efc358687bf46daf01bfc3"))
+ (1320000, uint256S("0x000054f5e7a90e9b5e70336442e07c569da53095163b6e6029c2cf7012737654"))
+ (1321000, uint256S("0x000073d0f551b3e768bf3435d170b1299e8abbde276127e7f73d070421cb7f9f"))
+ (1322000, uint256S("0x00004ee980bd008cc453ed43891ead6f4047a5b26eacfed37368c44784027e65"))
+ (1323000, uint256S("0x00006a06db6521b45b0e6aad0576294d6eae7f0f88f64bfee971fa83847dfa2d"))
+ (1324000, uint256S("0x000052748d09b26b13adfd512ce2ab015cb4d82e171afff48c28908017a63f9a"))
+ (1325000, uint256S("0x0000243fc652997bc4b6a2315b9384a54e312678d09fb00c068981456ad76449"))
+ (1326000, uint256S("0x00000b1efbae985fe97c5664bb006b2a5d9c929502619cdc6a08488427b8bfd8"))
+ (1327000, uint256S("0x00003eab5ef74d212a6031d1333a8e32a7476618639eeb9709601247dcf28b52"))
+ (1328000, uint256S("0x0000205d5addc63d62805bf598664eee091b52d3222a5b5fb5494a6efb584cd6"))
+ (1329000, uint256S("0x00004b5a5e95536ac8036a4b3e95df41f372699387600a7f3bd340a0c04c8d5f"))
+ (1330000, uint256S("0x0000190c2db32da38586594ee3c67a95fd1ebf4b6fa288c8407decefc23eb420"))
+ (1331000, uint256S("0x00003ed190a2570d494dee7e966544c3d3981a1c4dfcf25f6f1c5b543bd3aa71"))
+ (1332000, uint256S("0x0000151e66c75701e9040b8bed59abebaa51e7c2465773f1b07c7063c2ef9c02"))
+ (1333000, uint256S("0x00002c5a586b74cb3c2595441f48e4ce62997b86e997cb87fa6e5eddbfa9ac52"))
+ (1334000, uint256S("0x00002a52be65eb1c9dc8bbe85d68583a74e0ec93a518ab1b5e2cb24a5a80bd19"))
+ (1335000, uint256S("0x000021fd0d351efa9e040a873c446e1302a5ac5b5025084563b3e7a60ff2c2c6"))
+ (1336000, uint256S("0x000053d767bc40e54e6b1aef2f51ee7755b36209a2c283d50827c05b92fb0e0a"))
+ (1337000, uint256S("0x000013d91d3baf584f200f050564b5efd2cd098d378d448643e21601a56504d2"))
+ (1338000, uint256S("0x0000413db692b66b4db2ddd2e55f53dcc7e6e1c1784373a0b67fadadddff5aa1"))
+ (1339000, uint256S("0x00005c660d497cdfb5a13be94b69226077506128b46a0659b6ea4d5b3c8d9d1a"))
+ (1340000, uint256S("0x000025a875bb614824947cfefc70701ae1bf573a38f5fd5255d97238947d4d46"))
+ (1341000, uint256S("0x00000ae023b2b24a6f8bbea6268100bca725b8da415eeef679b1c35f8a836787"))
+ (1342000, uint256S("0x00000201c23daa15a0241c0e1291fac68143ac9fe72f66370bc9c151a109da98"))
+ (1343000, uint256S("0x0000305946c0b179db2aab47885b509fbc931874a89cafd046dffab5266d9432"))
+ (1344000, uint256S("0x00000317b608a52b734a7b3aad36143b761f34e47f26ab1c7c05c75c3af31a24"))
+ (1345000, uint256S("0x000034f335b83c243f68ff7be160dee32e1faa6b6f05094946f0f169fa6770fe"))
+ (1346000, uint256S("0x0000207f8a87af0453b46fed4fff804419fb1ffa178ee0086be40d61bbc5d304"))
+ (1347000, uint256S("0x00001f72cb20b6197b3de236eb3d57bd46878bee758787e75af50b963dacb863"))
+ (1348000, uint256S("0x00005b521b1d95b13625a9e349354cea391e8caf58db86e07c86642ef9d5b433"))
+ (1349000, uint256S("0x000064bc53df71822fd8f7a451cdcf6a4837631aa208675e64cfa4fc8f3ee284"))
+ (1350000, uint256S("0x00001b9b8fa3e8f35dbc95a27c88ae13b6c5d70ad81c7d4353e7f2b0096d8cc3"))
+ (1351000, uint256S("0x000008939e57dd2d369604bcfbbff892fbd89a4f8526ad0b021fffb01f06a2b4"))
+ (1352000, uint256S("0x00006f4f0458341f0fb67de2542818a688a772c4e3b785d00336de59c9947b0c"))
+ (1353000, uint256S("0x0000727e0460a180bd36f387e28a2bc0c24ea5dc34910e1f59c430861e810882"))
+ (1354000, uint256S("0x0000502d7a840217c1310c002a10dbb9e38826b9bcca353efb318e3712ebc1ad"))
+ (1355000, uint256S("0x000063fb9048dd54c0350c3f14ca94d561b24ba64e339eac3b741666b2a7ae58"))
+ (1356000, uint256S("0x00004f08f17e3543181de2cba7842dece3ba3fa7c6014c6b4b43095481646c08"))
+ (1357000, uint256S("0x000025fa2b0bcd25cdf5877561579f0e394f5129cae461c3a817af816e0d458d"))
+ (1358000, uint256S("0x000034f582b22ba9a754b83197b6c09fd811dc6a24d7ae80d28d4e405fd44bc0"))
+ (1359000, uint256S("0x00006317029a3817cd40290b1d7a5f6c88f3c0d33ec2131f5b25dd798b1ecbfc"))
+ (1360000, uint256S("0x00005be02850d4d4fcc57f1af06934459b2beb0c3e218e41f31b44383e3bc6b6"))
+ (1361000, uint256S("0x0000477079b78868204a9065bb1f55a3e1b2231ba95421bbd656a4de648583f7"))
+ (1362000, uint256S("0x00002effd551c67a9ff3b4a83eb19bfd9bcf899ad021fb749524c2889e3e0f84"))
+ (1363000, uint256S("0x000030de375a7891acc79ed08c5f1f2e462391e825e24bf367283ff761c8a0c5"))
+ (1364000, uint256S("0x00001a67a194321cc66ac092354827207ccb6b163a094bc670a1e0266024ef85"))
+ (1365000, uint256S("0x00003f3ae3ef89b9d1f196f47e8b3e42c7f1d4947c518a61239584d1fd1c5efb"))
+ (1366000, uint256S("0x00000b2c437d78f45eff553c1200e4c017cec07e825359842a764e5fe7f0c8be"))
+ (1367000, uint256S("0x0000211500a4981a24ab387a229440741f7bb1d230fd41152fa1a2ce55f13d9e"))
+ (1368000, uint256S("0x00003c915106dce5166bec267e52beed2b998eec834817eafa9fe90e5636e62b"))
+ (1369000, uint256S("0x0000549ef7cc9bb848c447bc326977798dd599aa25c224c94ee36bc8e568b6b2"))
+ (1370000, uint256S("0x00000156aa005f16d2c49557dde9ab4e8c8f7988ad3d742349ac7d8e5a540dbe"))
+ (1371000, uint256S("0x000026010d2b966d1c844d51fca19f808ba9ac595b7f6e67e92d1c57fcf96002"))
+ (1372000, uint256S("0x0000229d1a4c8ee6fcc5d4a8a8185466f8d9cda1eedbf06e8fd42916def5a00c"))
+ (1373000, uint256S("0x00000183822f5fd258a0546bf0d99679b6b6250a6dfd00ec41950fa607d80b21"))
+ (1374000, uint256S("0x00004121cbde3764685f88becc2f76cc82bf267b8e2c6cfb290705286d35a963"))
+ (1375000, uint256S("0x00004f01f0471283f9e3539aeea5a7fdde6e262bbbac7371ead9f8be817b57b5"))
+ (1376000, uint256S("0x00005e3524bbf76ca54513bebe1543728110d24b7b57ed29df454d0b5ae9113e"))
+ (1377000, uint256S("0x000038495b87d9f88798b8c4d9ef076e77533df730af15c59ed2099a22a0132b"))
+ (1378000, uint256S("0x00000e07849388d96f40d68bfef4eb519cba87b83502fa3ec7b3ad19b7b5e3d7"))
+ (1379000, uint256S("0x000027f63bf39af6977c10274283d3d9f323fbe265f6947f7281aeffefdc5ba4"))
+ (1380000, uint256S("0x00005505fc6e9964c5046bfdcba3ed94b981c39d81057fd1e159066d86503b0b"))
+ (1381000, uint256S("0x000010c64d196f9eaa408a041ca83f4f302f55f3ac336a622ee71305c3b29388"))
+ (1382000, uint256S("0x00001643b8cc9dae02bece65ff6522bbfd6c376d714d7f6fd49e382d9df42db5"))
+ (1383000, uint256S("0x00000e8168f5c7315866986466a2c798e5310dbed27fd07fa0985f5c341a86a6"))
+ (1384000, uint256S("0x0000631b02985c7f9a4c4f6687f5ae7f099c12f03f6bd2a5eb1aa7eee1f97a94"))
+ (1385000, uint256S("0x00005de1bda0086f5536e4541c116f782c4fcf288d4f28ed8871be8649dd54bf"))
+ (1386000, uint256S("0x000016ecc09da98c1adc4cde6ffdf6b1e5b34be2392ddd49d917e12268159c9a"))
+ (1387000, uint256S("0x000016b0710e0f91f24b6307fd32163358e844ca729e1f02e4ce8e99cbdb79bc"))
+ (1388000, uint256S("0x00007746c4cd4567c2215530e3f617c1cd533d89025d50ca39aeaa5e6bcdfd44"))
+ (1389000, uint256S("0x00007e6e74437b5e17b8b3c758009957ca4a865fe23e5c33e0099e6f0d8ee845"))
+ (1390000, uint256S("0x00007250c54dea4de6ae66a06b19a5538a64a98475c1f890e2845cfd0b0f6f87"))
+ (1391000, uint256S("0x000043385abbf08e4f0aa190078923bc7d27254b6c93256c8f56d026992de23e"))
+ (1392000, uint256S("0x0000264465ee861672764b4328d3e0a1bb4f2ebe168eaf3bf2e3c7bd68e47057"))
+ (1393000, uint256S("0x00002bdc46d2a233b0643e8c5b4eb5b4805e94d846b7a3543a72cd184b556e88"))
+ (1394000, uint256S("0x00001d7e7ef3992f2c2a90dc163a75868cb922762653c92d4e339d63e478f67e"))
+ (1395000, uint256S("0x000002cb974dbeacf08022dd44eb46648d5aec77cbcb72e04f6b5a511f4221d4"))
+ (1396000, uint256S("0x00006a978b1ae0aa4dc8b8b7ef6c864ad4f1be7da453480d2f088698810ea735"))
+ (1397000, uint256S("0x00002f68dd57c62f1086876fec0d9082c3da2566c2f0e6a22bdc429968209197"))
+ (1398000, uint256S("0x00008031c280fc082ddc06f14750f865da4d885b60f0fc6354481d7a00a52c63"))
+ (1399000, uint256S("0x00003a8a94de485da24caf7dc18fd923d27bcb07d29a5a4701c9930cf4f98d46"))
+ (1400000, uint256S("0x000011096de8cdd5942f4bdb443bdb8ad336342b3173ef8fa05307a9c8cf58ee"))
+ (1401000, uint256S("0x00001a22b299474069d4d834ec72a8a26f18640701c575500e0b5fb6b02fd021"))
+ (1402000, uint256S("0x00005dea39ad54b2862ae95657164f650e28ba250a4e1c9663b2fbc3db76a53e"))
+ (1403000, uint256S("0x000055857eed6134a03b6f5fcfb9112dd75b809ca8f579e11cd7b5846fb87c3a"))
+ (1404000, uint256S("0x000049548a6d09685e90375c2476674ca6e27453a8e05f8874fe0ba6e93d28c9"))
+ (1405000, uint256S("0x00000aeda49c9635b1079d3497d51e4ae1af507b16eaa4b7337bfde0f4e7ae6a"))
+ (1406000, uint256S("0x00003ae2cbae0d61d8dfb474f124cf2f6a994e5dcbfb3633bb1e357e358a3404"))
+ (1407000, uint256S("0x00004f41a6bc783f7c0d1f0c958e360a62ff50c6a40cc18b6a40bcd3a6add2a0"))
+ (1408000, uint256S("0x000031fe6e28dba476f91e83402b912c47df4002b97ed2f6999c30fa985996fd"))
+ (1409000, uint256S("0x0000727d07f32206cf915066e9fdb9907c3d25d49ba660db641494d5155a8127"))
+ (1410000, uint256S("0x0000405c1dc5e1e9bcc44a2c21c1bea6c2fe9b61ce3383ca2bc8051e954bc7e9"))
+ (1411000, uint256S("0x000035579f681bc9587ed9bb15a692da25409cfbefa79a1a89c5cb80fd3c0571"))
+ (1412000, uint256S("0x0000508dfbad47ff590c35883c493a875fa012d13bd1347d98a0a1a2bb7902f5"))
+ (1413000, uint256S("0x000017f5eb3f35a0d31d56b7adf60526a8ae44cc5c30b78e1416e633f7e8d5d3"))
+ (1414000, uint256S("0x0000808b8460ffb966b6313507830f6737c030f220e071de5619f21dfc8da78b"))
+ (1415000, uint256S("0x00001b587ffb3f55a7ea904532a213c2a4284b872c0ab9e803f320f195834db8"))
+ (1416000, uint256S("0x00001a140ad86b1b89f133819fd2ebc32729659a10489d0e7563c258fb67834b"))
+ (1417000, uint256S("0x0000459938d0e333ce98ece0a10cbed2f8ab955a2f70b1638e367049fe03b039"))
+ (1418000, uint256S("0x00002775ccbfb25998045102ad45a4a8b60403e877f9a60684a37fb9f1e24ac7"))
+ (1419000, uint256S("0x00001d4c713389cda24457fdbf22d1c513829e59ebaab09788b66c450574017b"))
+ (1420000, uint256S("0x0000716e6829dcda9d949cca382e41034a038b018a418bb6cec025bd7aa6b6a9"))
+ (1421000, uint256S("0x000016072ac6ceb3d2b8835be8e3276ea3fdca6082c922fbf4a2d66cc0b2de1f"))
+ (1422000, uint256S("0x00003cdeb85dd131660109a77b32ff072cce5119268524f7ff4e363b26e38f9d"))
+ (1423000, uint256S("0x00003facc7586105dcdaa31deafb1df8d3599e9fa93b1580856e2339148c506d"))
+ (1424000, uint256S("0x00005fb14795c1157ff1a95988d3defd1e39ac720ecf8595b99e413c7435130c"))
+ (1425000, uint256S("0x00005bb58f776f79f1a524ad3145b20114a12c5a620b9073b0e0f0730fd07bcb"))
+ (1426000, uint256S("0x0000607570d3c5d7ead43017397804b87868398256f2af8e61c24b62af3dce1a"))
+ (1427000, uint256S("0x000071c76f0aef33c1324393d145bf2c794162cce33e992bfc65b75765c6a0bc"))
+ (1428000, uint256S("0x00006018fc369b3af83b17854e093c9087ddd77802c21fb12497e94a1bc5afd4"))
+ (1429000, uint256S("0x00002a4e85b18e3dd7c4a07d0730bab0eda36a97a7eba58b7397a026083bbeee"))
+ (1430000, uint256S("0x000009d80d24169a4bc873c9f878ba7b08a0fefc85a40c1048721b343f249dbf"))
+ (1431000, uint256S("0x000026f094183a7f07bd8756f7becffd05cd4e7634a5b213ef3c23e5b6f97ef9"))
+ (1432000, uint256S("0x00007f7ddf1e1ceef2c23ed49e5fba39bfe33a2beb0189049e91cd475eb9f155"))
+ (1433000, uint256S("0x000060ea03b0e8aa7899d0d1b98b52b4a4c33b205983812d14b81ef09287b19e"))
+ (1434000, uint256S("0x00002284a454241cdcb0e95f0d9c0d247f6d915ba2214ed5a314a0225977199c"))
+ (1435000, uint256S("0x00001dd2d4d2dad999376d08dd1e2c472dc1e3455cf7d7221eeff8f6cf9fb114"))
+ (1436000, uint256S("0x00007bf3f632d51fea6cc6f20bc2f0fb85874a789dc3cd6a1f0f2dc66b5538bf"))
+ (1437000, uint256S("0x00000db26fa1ec1619344134d24dd24b5a29d510c3f06216630f4dbf73565dd4"))
+ (1438000, uint256S("0x000047a4145ee353646f39e1a6a6225214630f4e8cb4875e910809f6cb5a767a"))
+ (1439000, uint256S("0x00004267abb63e82ba97d51ffed3dd98e1460a5baba5aeff17bb941cd5e4240c"))
+ (1440000, uint256S("0x00005242530b3faa4c464a684aa360213d185b5532279e50048c22478b587e4d"))
+ (1441000, uint256S("0x00000f7ecbab8367bdcedd3882a469e95dc02a104bf9fe21c3493f6e7eb7678b"))
+ (1442000, uint256S("0x0000259a5a60df413dabe2177c51574ad856024bf02cab06404d9bf3979f255e"))
+ (1443000, uint256S("0x000019b6d30bf30393118deb097d33ccb1a296a297bb56efa95a0edcb823778b"))
+ (1444000, uint256S("0x000001e7d450d911390dd0d21a727f3963c6e2787ab48c9eb52f5f8805bcca43"))
+ (1445000, uint256S("0x00001ddda6fc26a28b6156c72aef52d46c9cf6f131da11aabc296ab737e84e12"))
+ (1446000, uint256S("0x00007ef41d460d18ffd70624ffb716b47daeb1fdf1ef8c749e5c6cfeda7e2fd9"))
+ (1447000, uint256S("0x00003cc8059291cc699032ab2ee35cd58630e91d538f80171e28f3c574eaa72c"))
+ (1448000, uint256S("0x00005b329cd2f049e697abf9d740d8181ef501357c7bfc1ca0980d15d127c079"))
+ (1449000, uint256S("0x0000145558665a6e1c6698240d7921c09a80df1265e0316dbccd6427c8cbd0ad"))
+ (1450000, uint256S("0x00002ab142f116f52000cacdd3f05da45dc7d1a188d04cf57095dde1e10e7c45"))
+ (1451000, uint256S("0x00002ed9d3dc2d60ebc8fd71bf958f7a16c99c1073ddfd06ca3d3964bf8d0fcc"))
+ (1452000, uint256S("0x00006c99a63588e991244cb16d65241e7f8c8a51c69f27013972cdfb627ef469"))
+ (1453000, uint256S("0x00005d800553e59397fd1852bc11ab440d40202a1514d47786e45538debc727e"))
+ (1454000, uint256S("0x000015d919078132a9919315c6cbc1f016fa32912f6e6d765b57caa64a038c69"))
+ (1455000, uint256S("0x00001e7eb6d77f2fc2cb60cf49581b18ed0704686a5b9c0d9681f84ad67af3c5"))
+ (1456000, uint256S("0x000050f68cb35ba10b95d3542d1d1cd7299805675f52870b54a2b35da6a47376"))
+ (1457000, uint256S("0x00002d3b75f6416e72777492b18de9c487cdc209f82750bf9bb0c61d79830ae2"))
+ (1458000, uint256S("0x00004d39813c667b84fa19e1ba8934b197accb59141d3b407c8e6310a2be353c"))
+ (1459000, uint256S("0x00003f9968f692a32404d64403d7574d4053d75d28c73bc4832ede6363a37815"))
+ (1460000, uint256S("0x0000457bf2734cdb31c828d467d6678140942cd27fe84091543a33c1a786ff0e"))
+ (1461000, uint256S("0x00003640de8991d2dce4dfbc5aaa40195c1d248d70e4ece748bf3841aa68a9cd"))
+ (1462000, uint256S("0x000038feafbcf1b9c8fe8b07ede5051a04b9a3f935b5b63796b9b822c2af6f7c"))
+ (1463000, uint256S("0x00002933fd1e62ab5cd54a40efd87091c057886fc0ccb5e8865ff53583ba3134"))
+ (1464000, uint256S("0x00004a7bc1706346d7fc51fda7d5dcc993592fe683d2f17bf594868c0ac7e6e4"))
+ (1465000, uint256S("0x0000620221261d65b72fd31fcb2ccbf37f743282455312a5013ec58901bea574"))
+ (1466000, uint256S("0x000017ec19979da76669b4dc9bc3c20ea74d0a9ee3d8c93dbbd45393f4278510"))
+ (1467000, uint256S("0x000030cd35ee603269884c9fea00e6fe9abd8a58a2ed15a72ca909f67c9ade24"))
+ (1468000, uint256S("0x0000576c624d94aa124844c995943a953fc9ef249783a76f1bb10ea5246a3309"))
+ (1469000, uint256S("0x00000bceda549d22ff52a7f21769aa9cafba2adfb5f2039b71536c841d72fe80"))
+ (1470000, uint256S("0x000027cf3973376f2e39711853c969763b3a9a5f614c479d36a82328b4034714"))
+ (1471000, uint256S("0x00005477303f498253b92eb410b9ce73e377edba795013722a8d84f8141ad872"))
+ (1472000, uint256S("0x000053a3db0b7b34004610d7cfdf59e72fe278468dfea1f5faadb251a0304f3e"))
+ (1473000, uint256S("0x00001e515ef508874a83e6e75906dc64c2ee25fb5c462b6712f947ce725195e5"))
+ (1474000, uint256S("0x000037d40334077f5387ad4e5aacc41fe720d5593e2d75fa6e7a12d23dd2251d"))
+ (1475000, uint256S("0x00003ff337fba64eec0d5f2374194d8764dab3c173c7ab593490fe0dba23ba6e"))
+ (1476000, uint256S("0x00000f028d26078a5beb3ee987635bdaa93d4d8a4addc0bd82d185844f4c78db"))
+ (1477000, uint256S("0x0000337fc9cf8d52b2ab171460cbb3976ccfbc34e2366b50c65ef86f4a8058d3"))
+ (1478000, uint256S("0x00001e75d7b55d58122fcf44ae97243fad28993ba9ecf8e29b57cd8d726dc448"))
+ (1479000, uint256S("0x00001bbfca4da29a52407aa2d8b49c77b5bc48ed0f62e59fe37d513cc51e2c8f"))
+ (1480000, uint256S("0x00006f49e804684d1c7e50bf8e1234fc1fbd123af27ba7459f20c07203b93054"))
+ (1481000, uint256S("0x000025bb119aa40cc5a1064366b832a489fee8ec615e8a57b9b5c6fcb9989160"))
+ (1482000, uint256S("0x00004e4df74223c0aa441425d08fd3e9eb3d6c54a12b3060d99e9b5ae3009399"))
+ (1483000, uint256S("0x00001d35a5f1960bdd484ce1c3e4a51163d4fe153f6f0fdbd8286c6834e59ba3"))
+ (1484000, uint256S("0x000027928236cc6cb5403e3cbf3157d4146de4d34e12bcf8af233918f3c6d52d"))
+ (1485000, uint256S("0x000064be474b3ec1e860f61848bdab8a01bf0412bbc7c979d8b4b05a18b1ce6e"))
+ (1486000, uint256S("0x00003f75f24012a202f6916ac20ebedbe14e6fd1ef09b037404565a311643307"))
+ (1487000, uint256S("0x000055c76e5db476d20d9a5fd219fce2c9c8586bc69750a66c19407947ebe0eb"))
+ (1488000, uint256S("0x00000ba35f0ccd2e8fc94caecb8e034b39aaef28bc68cf268033e765edb8670c"))
+ (1489000, uint256S("0x000037b5608bfd9417c5aaaac6dd4689a2e286f61e046421aabfcd27c42fcbd6"))
+ (1490000, uint256S("0x000047018d94461b91f86e2591f8a175b54d797fab29e8cdd07a38d546cd2ae5"))
+ (1491000, uint256S("0x0000339ebc81a4d1c99266c1ad4c0bd9e60bdf9f3f7a5fc2b7d7c0ff1023a20e"))
+ (1492000, uint256S("0x000034f2be651c725a501710b90dfc7ac2a7439a7790d178f37e635339582d19"))
+ (1493000, uint256S("0x00004e36b6c7820cec761cf75c6be0817a893dd2c28ecadc52fe9570276c6676"))
+ (1494000, uint256S("0x0000436de2198200c988fb5329dd0629693ea351099e6a7ee54f2fcd15fc848f"))
+ (1495000, uint256S("0x000030e54f3e42971065cfb365889092df67c4f4cbd8d9882309d408beaef4be"))
+ (1496000, uint256S("0x00002c91d87c10542b3db4d339f84ca3d6f537c631f4d3a545fcc63c242d47c2"))
+ (1497000, uint256S("0x00000e03462a161ce11c317d3c3959d057f4dfdb72ca767d3ea92dec5381f4ae"))
+ (1498000, uint256S("0x00000b00fef2c10cbb333e159bd725051cb2b8868c3fa7794180a862b8c4bc2b"))
+ (1499000, uint256S("0x00003b1c63ff1b19cc6579c949f4e3a8a70257b61cb13cba980470cda9296a40"))
+ (1500000, uint256S("0x0000324248e01dbc3a4dcf9d3065e5e1eb6c81fa8586d4b82b32e97cc43d8356"))
+ (1501000, uint256S("0x000043493acb1081ca68732119a37f8a37bbd98875aed14da785180190be64f1"))
+ (1502000, uint256S("0x0000560985bff5d7439e08ce1dad6deb423279192f27ced560c3a01e037f95c1"))
+ (1503000, uint256S("0x00000f4203bcef4cd3199e40f90e164de773436eaaec87cd8a9dd932d08c01a2"))
+ (1504000, uint256S("0x00001a20bfdbec3a4640a5a0b494d8850326fbed04d790fb552198ef2b081782"))
+ (1505000, uint256S("0x00003ef1fdd6eb80ac9a5d58ae0323795e0ca7ff3942ef0b7738cc6c6af3ae27"))
+ (1506000, uint256S("0x00002c0517b5619ccc18ea8ac5717dc57cc3b613de03b040490199e463db2738"))
+ (1507000, uint256S("0x000051e4b0a891542c75f463c089d4e5f0e5af64a8d1aea734de1d28acfd2fb6"))
+ (1508000, uint256S("0x0000533831066724eab70c56e2ff2ea6d91a4af4c455b41f9dc6bd3072189fc9"))
+ (1509000, uint256S("0x00001305d4a25f67fc5365df6403a6caf3b44199cd7499da724eae6f2ccf65d5"))
+ (1510000, uint256S("0x000029fd6680e674dad7ad6a5fd3f44e73287062d47bb97c7644db3489a4fa36"))
+ (1511000, uint256S("0x00000e8c0c7c707dfde3d1b31a3290f8c90e709698e79c70c0c692d31a11ddde"))
+ (1512000, uint256S("0x0000619dc165673789b342d1840fdf31dbd3a0a1593513cafa3bb63af729402f"))
+ (1513000, uint256S("0x0000459b32b8f32c9f6744e4d7efe9dd2f387140cb1b0f9d4b6e9357f10ad16e"))
+ (1514000, uint256S("0x00006f522875038fce8852a8846919f8206026dca7932c996d5f32f49e31a35f"))
+ (1515000, uint256S("0x000039e9c41476289108b9b4c69adc07451a35fc9f156db6e7267cf2bd160d33"))
+ (1516000, uint256S("0x00003bf37101566dd38384ef39896ac740fb0d5cdfcdacab406bc89f3c3a1b1d"))
+ (1517000, uint256S("0x00004932a3e8b7a39d1af6e5687a73cdccc1da437bf14995c023f5f0d3cd66f2"))
+ (1518000, uint256S("0x0000637f5d64d8a2517a806c784086134630d740b932be18d45ae20f130e996a"))
+ (1519000, uint256S("0x00005340b308a63376f46ac08ebd71c70aebddaba4705122aa0a3019331bfc63"))
+ (1520000, uint256S("0x0000037445ddb55d5c28f2a4446780e4be0c7f47cccb626bb0fbb8a3a10f728a"))
+ (1521000, uint256S("0x00006946ca6a97c12f2b8e6009f40bf670914f9867fa846cab06f1e0a674c65b"))
+ (1522000, uint256S("0x000004827524135eab105b368e2aa794224de498f31392c0a6fd3a4aea38c837"))
+ (1523000, uint256S("0x000036e8232c944a7b9b2a2068555c91fd6529fdf335fa9626c5e096b2271ea8"))
+ (1524000, uint256S("0x000023c8cbb293fb6a3a973b5d7610ae3d88f7c8b6402248d8b81024d5cc5fcb"))
+ (1525000, uint256S("0x00005cd2813b417613f5dae9692064e6aa7fb8c74b71afc649f06128df62d0cf"))
+ (1526000, uint256S("0x00001ba5005432017e83161723a376e787796e66b66c65cf0cdb2a01dbe2040f"))
+ (1527000, uint256S("0x00001d5c090338beef5d6218e8f1b452098cad822f656e9c4c42188806d20b46"))
+ (1528000, uint256S("0x00000a466b5e366cebd5a05f4791664b692e7795bb432e860a7e6e9f51a7ec67"))
+ (1529000, uint256S("0x00005d9434f77694bc50168a7568a6bd8be685c9346dbe2e500ceaf188e43bb4"))
+ (1530000, uint256S("0x000059d5ff92b926dbff5b3d54f35a544b02501851c58d1abe75bffbd41dfc5e"))
+ (1531000, uint256S("0x000058b961b0a4c0bf3e3ef170d4a292fadcb35542b473a2427100e6438bcdf8"))
+ (1532000, uint256S("0x00002bb6b5aa24b3d8cef0a87fd2433e4a71044337af7d4b8efa2de3165c545d"))
+ (1533000, uint256S("0x00002f998ff8c1796e20a4a0fda67042a9536932631e36453fb0d572044b1236"))
+ (1534000, uint256S("0x000005b39e2588b0bde112382f92fa3c31b46fb8db4b9cf807aa6d55f4c8d818"))
+ (1535000, uint256S("0x000043743d50a88fa433397d198a0a7d695d38ba765ed10d256506e866b5a3de"))
+ (1536000, uint256S("0x00002c52d80c50f3a11bbea52bd8df8a79a09c7dff6f9d9bac57ef7af3a0f9f5"))
+ (1537000, uint256S("0x0000540162434470999d0b649f28f5372fa0a1e8ac0e1377fbb7cd4741b266c1"))
+ (1538000, uint256S("0x0000616aa7db059317abdf3474912a9d924b66dc2b5937b9b21810baf553237a"))
+ (1539000, uint256S("0x00003c64995ff3c589a2ac3f0471ebeb1542a7efc907c818081a41bbc803e429"))
+ (1540000, uint256S("0x00006e5ef028324567cb084b819d13b8ff2ba8d2d1f4d682cfba675455007a3d"))
+ (1541000, uint256S("0x00003d5fe2645115ea34279ce8fa1999e77242ee194cc0f8f28d6939cfe54e5b"))
+ (1542000, uint256S("0x00006fb56c95b6fc0b371d5028d26269c2f80bb8adaa2cc6521ee3e22db04b0b"))
+ (1543000, uint256S("0x00003f1d51f1135bc204c22bcf3401b580efb17b08a164c60d6d66ba2b6d58de"))
+ (1544000, uint256S("0x0000112c5a0b02d5258361bd4ca4e859c2cfaeb80caef4fb6dd6a79f1856d85b"))
+ (1545000, uint256S("0x0000369839fcf820ca45525787abc752a54826fd0a2ac5f6a4da13a1aefaa562"))
+ (1546000, uint256S("0x00006200ddb88ab631c1a2fe6b3fa3b19e7568069e0381e061af26c3578fef7c"))
+ (1547000, uint256S("0x000056f960fda0ec23bd1102a9b28d513e1f927449cc23a5e68f7e6ac9fee73f"))
+ (1548000, uint256S("0x0000528915ed9c5b205fa0c8d1e3e354df58d87facd66bb441c0b572416bc668"))
+ (1549000, uint256S("0x000058d83f9d7347a849e1097c45de1b2a3d8b0d66c2c9ffac1ef50d5f8f2e35"))
+ (1550000, uint256S("0x00002f2255e089937ae2c11e0bf2f096dd2e4602b9d1e2c10747ade07629b45b"))
+ (1551000, uint256S("0x00000b75bab95db82fe97910341f75a403ecd8ad7226e4cd20a1fdbe6e22c099"))
+ (1552000, uint256S("0x00006c630f876f9d8c511c56ece86f6649dfc4e431c10e1b07d6adbcf35083b0"))
+ (1553000, uint256S("0x000058856c3e68ed63195a8da5814c7a1163068e1431d2d956790a4ecf107f02"))
+ (1554000, uint256S("0x00006269759675c42f0fef86e5a638b8ffe8e8e0a93ea08483398dc70a1dd32f"))
+ (1555000, uint256S("0x00001350376b081909694bfabd00f0e87276bc896440f23ed0252f2e2a5194f5"))
+ (1556000, uint256S("0x00003d7079ef71e7c159e6ab1cd92f3af5ac9e362e42a14530f1c31a8b74f5b0"))
+ (1557000, uint256S("0x0000595ac7499c1fb41bd90a175c31ec50570d948491270931bd07e1492e251c"))
+ (1558000, uint256S("0x00000e52e16cbc10f302a8b1676eccc61a687d7e595830afd37a9e6a2a553673"))
+ (1559000, uint256S("0x000016ea90eaa3e6ed5ec1c0df2a9db32d4f5a3f85ef3ae276aa9aefca29d9cb"))
+ (1560000, uint256S("0x0000280433109582ea0c96fa1867c86f70600dac6f9914a91ea049969594b809"))
+ (1561000, uint256S("0x00006d64f133b1b715f1e8ba259f452e068d935216b52006623615cdeb5364bf"))
+ (1562000, uint256S("0x00005ce06c254d44629cb5c7e1444a2662e74a39020e05c43c64f4a0315e362a"))
+ (1563000, uint256S("0x000052fb949f15f05421f6682171802a7aa2138aafcc95d5f22bfb22542d59f4"))
+ (1564000, uint256S("0x000057d41a403a9f0c0ec301f45ca86e4cb3df50bcfda7d7b0bab86ba9122205"))
+ (1565000, uint256S("0x000051dad695df837258e4ab91db4f08efbaee1556a80b69a9c06461e1874a6f"))
+ (1566000, uint256S("0x000007d82ca32972994e90aa8e2cd9555e31f9f8277949405249f15d45e963ea"))
+ (1567000, uint256S("0x00002ddd9c4656c7d78d8917434f94070c0672967ae255d6f57646b9b09506ce"))
+ (1568000, uint256S("0x00006bca7a17c03734dfeca39f23510a8eb8f25030034c99daa52111119d6331"))
+ (1569000, uint256S("0x00007066b928536fc27343c0fec355ad0c52b59906223f48308e41c4ffd22339"))
+ (1570000, uint256S("0x00001e8f4d2fd86654189f494ace0a835f855c960358d901b51a0eacbb391543"))
+ (1571000, uint256S("0x00001309773bc979bed740fa624ed136241c8e492825b6ecfbdc39c025b24550"))
+ (1572000, uint256S("0x000038cfb767f3b97dd3b546f1e9e6e52d7a623dcb41c5a7454597cecc1db4b7"))
+ (1573000, uint256S("0x00008032108731e660a00b2812cb8b9a75f0ec16b143f9bceaf6410294c75904"))
+ (1574000, uint256S("0x00002f7c6593ffc9e2ad1eabb1c9b3ba04f43f433ca62e93c9f318c6fe5ee3d9"))
+ (1575000, uint256S("0x0000174e15f30ef6a742622af6659ad1c0641833156ac4c64144b54773cb7e30"))
+ (1576000, uint256S("0x000081f693a5455a8b28883eb4c97ae09440bfe6c81a0f8253bccc76cb644fb9"))
+ (1577000, uint256S("0x00006080530e97ff85b33784ea5fc8195320a4cb329e49a773df0a9f604a9aaa"))
+ (1578000, uint256S("0x00002821144963291e50d22046bf65f5c01ebbe1607746b34461013664039a93"))
+ (1579000, uint256S("0x00004cf0fa901f1e16bd5f0963773e5a5df0e210168a44a13be9398bfd7ca112"))
+ (1580000, uint256S("0x00001e5033df33216358904bbbf6cb9cb3b03b2956893cfd8c032b4e5c4ca08a"))
+ (1581000, uint256S("0x000087635ea70c8b1ccaa3754106dfb4f5d92219f522e7e7609b4dc75f404634"))
+ (1582000, uint256S("0x00007745f61f8e388b3d0ae55b6313a695cc8622d8d76497ea4745e294061f7e"))
+ (1583000, uint256S("0x0000636ab289c2287033066f8bea4222c5ee9dbdf3eab7945830d8779650a471"))
+ (1584000, uint256S("0x000004128d5a5cf452ef9aff1a87f39613ead76508367786c72679be963a6d4b"))
+ (1585000, uint256S("0x00000920f2773b73d275fef0ac909578d7d436423533c58b70201b552e010e74"))
+ (1586000, uint256S("0x000018fda4e4ca2e4f0716e30c9f743cd415947bff1a8eb384dd50c92b2f0143"))
+ (1587000, uint256S("0x00000aefb81fcf668e42994c46c961215518f712df4aa5556b7004a0c0bdc2c1"))
+ (1588000, uint256S("0x000037177927587a0e5903dbf93408ca263bcf868018d827f7b248bb36394a7d"))
+ (1589000, uint256S("0x00007e364a90288aae61feefbe6dcc218458c98ed9d4ab62a522a727f9dbd7e6"))
+ (1590000, uint256S("0x000047707a12173afcfff8dfa0ab9790c84a2f233630adb35187656cdce4dbfa"))
+ (1591000, uint256S("0x00001660b1ee772ad34fb435f8939f669ab3aa4e49c839f3c19fc380ce1bdb08"))
+ (1592000, uint256S("0x000016d5ee6370b9e4e3d7fdd60c5791032c6df4b396a1bfed2a517444955f6e"))
+ (1593000, uint256S("0x00002fd99027c0d83531ecd1b940f4c81b8f72796fba37f05f4f57cf788d2d90"))
+ (1594000, uint256S("0x0000075f6c2da6e0f6323d083fd69ad0ec7119356aaf50b6d02f859af1f868ae"))
+ (1595000, uint256S("0x0000a7ffc5b96746369c1a04dd062cc4ededf64f2a9ef11cf4b3bcab99946f55"))
+ (1596000, uint256S("0x0000930876f4fdaeb5e7ff316214247ab7d47fee47f6d3c65b93639f7fbea0a1"))
+ (1597000, uint256S("0x000064a14bdf8276b1ec884a0c9983f277a0bfeeeef5782b4e79dc7deae3c19e"))
+ (1598000, uint256S("0x000084c89eb1776d748687f2e180d6640e5a7cc8c8de75706b02e29f87fef8be"))
+ (1599000, uint256S("0x00001cdb7ec465e5edb8aaf78570970a425309f050fdb9ed376ad4b98a888b11"))
+ (1600000, uint256S("0x000026c04739309ae03a6578613b71fca0572c9793521809967ada579cc1830b"))
+ (1601000, uint256S("0x000090beea47fe396580e3669295f1463abc047585d3c5029d3a29e473f2e4e8"))
+ (1602000, uint256S("0x0000a8ca712ed653cf5cdf141382b02b552e21f4dc687a89ca946d7a236fca29"))
+ (1603000, uint256S("0x000009762ffa6eefefcd29703f41cf9bbe5e44b4a757968f107ad9e20679c373"))
+ // Generated at 1750959556 via hush3 util/checkpoints.pl by Duke Leto
+ (1604000, uint256S("0x000000047ec28daa1ebd35d272006bb99be1bfc432e64fa9ba7558669a0beebc"))
+ (1605000, uint256S("0x00000002829e77226633eecc400ad22f7c0051e9acea26285ffb12cad1fd3461"))
+ (1606000, uint256S("0x00000005c2cb7675138e10f36971d9620254bc4781d07f0785c0567068e39ef5"))
+ (1607000, uint256S("0x00000005703e6b60f7004a502a54615df241f38e1b4f30856a21db2ab8e2a162"))
+ (1608000, uint256S("0x00000000397c7d1a709c8156ef2d3da4f63b06cef6e16656510e9fb07e398d94"))
+ (1609000, uint256S("0x000000031accfc8544bde0cf3d160e9c46186d1330bfbc2f075bda9e63e71058"))
+ (1610000, uint256S("0x00000000318ea4aea52e334b9b3f8bf91e63fe485468936bba68485ae1095a46"))
+ (1611000, uint256S("0x0000000197b39d70fb42cd31ddc99cc3993f8fcf143f4f13138908bad9be1dfb"))
+ (1612000, uint256S("0x000000032441e4bbf21affe0c75a11c2aa6e8527be12effc017cb0601dd0d88a"))
+ (1613000, uint256S("0x00000002ff16ad0bafee22be75b953357ac958b64aa74761017cf27ef349093f"))
+ (1614000, uint256S("0x00000003a313b96708612dd8223e7d1bf0384b6edc56320a9932f64d1d638db6"))
+ (1615000, uint256S("0x00000000d192d0150f90daa6b4e2e6f7236cd641314fdced99fce65fe30d48be"))
+ (1616000, uint256S("0x000000036a26bb9a2481f666975bd98a478b52eb98cc0719fea84bac424a7ba8"))
+ (1617000, uint256S("0x000000015b35b9e2df778aac51af83403d9f361c582ff8a91a3dc4fdfadf7018"))
+ (1618000, uint256S("0x0000000638029048e3dff9fba19fcf06b88543ecfe45980cfdb1282670095d85"))
+ (1619000, uint256S("0x000000025fcd19b079405d3037588012a9cdc138ee633dd5ab5cdef92a8de23d"))
+ (1620000, uint256S("0x000000048c6667a8724512cbd999bc491ec8522b1f3817001c7ba485dec46d10"))
+ (1621000, uint256S("0x00000005d981cd3473f8815d18965c0e0035993117390e9659fe8d3b9562c8dc"))
+ (1622000, uint256S("0x0000000371a1663973c7b19a0b4dd8673f1ddb14a0438c89de3908712437f688"))
+ (1623000, uint256S("0x000000038ed359f4cdcfb54a0ba36a8ac89e4f697836920c28dd038d643064d1"))
+ (1624000, uint256S("0x00000000ca915eb30164ac2aad328ae5d9d4531bf8ef30c7bdf3c18c0abcdae4"))
+ (1625000, uint256S("0x0000000303957deb36dc6a3b6597984ca9585172a198342eb102a9d3b9455596"))
+ (1626000, uint256S("0x00000001485e2bf5e67162c35b4dddb9ea709e639bfdf79c8b9d1e0fd9abcf00"))
+ (1627000, uint256S("0x000000000cb8f8b60fa1e57622a7a5bb2daa07899d1eb39f817f8c424a52a3e5"))
+ (1628000, uint256S("0x00000000eab91143aa66330d27d57f77bb7feb904d17e9a3ec20c7836c701f35"))
+ (1629000, uint256S("0x00000002ed48f715858c998e5133c0d6748b820ce3380e2759db5558209a167a"))
+ (1630000, uint256S("0x000000032c724b40a4fb6d3e613aed9f294f22b76fc30b6caaa3bfe7ce3b01ad"))
+ (1631000, uint256S("0x000000008b0eb942b318fe821ccbf977d24a34cb9138555cc02130ecc655af81"))
+ (1632000, uint256S("0x0000000061c1e1eef48730e29b494681c2a3aab036219bbea140e0e4f51e0d6e"))
+ (1633000, uint256S("0x00000003b3d9950c5ddb598a474edc15fcc323dd59b44c32534354a043014707"))
+ (1634000, uint256S("0x00000001e6b8b9a471537f3b006c75428405c0f877e638e417ee9be9d2ff43b1"))
+ (1635000, uint256S("0x000000030073be68be4e7d68bcdb151ecf5af613bdfb9e93e7d1f7b0752f7aa5"))
+ (1636000, uint256S("0x00000000fd1b3853a2d59705d5b36e76491c58e0fbb81d2b35d7a7e3add3b4e1"))
+ (1637000, uint256S("0x000000023620ab021fb58eee94b3fbcff4b7d502807d028bdb2f32708150aae4"))
+ (1638000, uint256S("0x000000043c2e172e6ca4248a65ba64bdbe445f5f81844752f988a107845f349a"))
+ (1639000, uint256S("0x00000002fcbf7f7b4e04fa895012776248ce5020ec4bded612537a58c9dd87ea"))
+ (1640000, uint256S("0x00000000d6605a8a213fa134a2bf74cc901a42d0706718090788d6915c7ebbfd"))
+ (1641000, uint256S("0x00000001716416197b1802314a0d0f1679ab789e258ed3c930ac3456dba9bed4"))
+ (1642000, uint256S("0x000000044a7353133354febf9a2549d6033cabff8b3e9cb8c4335ca809d9d048"))
+ (1643000, uint256S("0x00000004b7eaa979bcbd468e4f9f0e4c1c9a7dde3eedd1ea53a5ce2bef562b09"))
+ (1644000, uint256S("0x000000027430ab7a59514ba994b3f114e5c28ea36f714515ed3cf70caeb8d227"))
+ (1645000, uint256S("0x00000000d4de211a3a25d4243278e0fc498058a9bae5860ae35963bcf155ba4f"))
+ (1646000, uint256S("0x00000004d8e662533da408b1427c4840c477bb176f5d6cc16e989a57646ecba5"))
+ (1647000, uint256S("0x0000000213f087be9c672b98a13d76dfb77bf276dee00e14a708c3b864427331"))
+ (1648000, uint256S("0x0000000129f391dd5e18ce5efbfff76edbdbd87914b7b07a68a6bbee01b4efa1"))
+ (1649000, uint256S("0x00000003c84f48d9074fe0dd3132843feebc204b7832fcf58265ed2b0fc91e9f"))
+ (1650000, uint256S("0x00000000922fca1c2ab235f6592387433c0622665408caf1a689d588acd7ef4a"))
+ (1651000, uint256S("0x0000000235c9ddae6fcee3486886406cdfacf06729a6a7e2abbd1a12d5b65367"))
+ (1652000, uint256S("0x00000001122a37089bc208bf027091c41aeed037a011aebfd1beb1388aa6e3ea"))
+ (1653000, uint256S("0x000000013177553290193311f8cffaa71c3648cd54039bd700685f626b7f61c3"))
+ (1654000, uint256S("0x00000003fadb924a1ff4dc97591004198afc9711dbbd404099f671ad93a372f5"))
+ (1655000, uint256S("0x0000000155ca47f18a7bc8dd51e68140cdb9a8e9d3b774276ba1dbebb1755857"))
+ (1656000, uint256S("0x00000003899e96ab824d812f38ac7de0c68edd5092fdbed2bc2c25ff98d64a23"))
+ (1657000, uint256S("0x0000000382b6257c88191f59c00b494a70a9748fa6e15edfa3a7861961836125"))
+ (1658000, uint256S("0x000000015f51ec2a910d81081f3458e384fa6fd3687b6b6081da5d908c21fed4"))
+ (1659000, uint256S("0x000000002613a74bdcb2a4321f2bf8b17dfd247cfe139ea569c0912ded3c7d2d"))
+ (1660000, uint256S("0x000000049e13deb195724e2a64bf4d7a476b44d67d9779a321cdc32f2363c691"))
+ (1661000, uint256S("0x0000000188e1647808e786af316efa45a9faba7241a24ea44a7b3b1487db382d"))
+ (1662000, uint256S("0x00000001edfb091e9ea392c20a197002d7de65656f41b97fdd2b175dc92860ca"))
+ (1663000, uint256S("0x000000029800198e2b567a2b256bc5089e6d3a57379e22ff966126151acad77b"))
+ (1664000, uint256S("0x0000000215402fce1b5853158fc0210b3cd3d8ad125af4692562ed8f9c399075"))
+ (1665000, uint256S("0x00000003164d40c0bb82317df59c0e325601b268d2c579d8f81e593c1e85adda"))
+ (1666000, uint256S("0x00000004a4bb0d82d09a6cfdea1493de1e960adf9bf58ecf12fcc65d8c076db6"))
+ (1667000, uint256S("0x00000000677a80fc06a62957146bdcfc83c637504683265fb09ca655b14a1ad8"))
+ (1668000, uint256S("0x00000002d16c791f19fbfb53f6b8b061af5276a756b632a59627889291caade0"))
+ (1669000, uint256S("0x0000000063226419faac0536ce13765bcf210fb02f4b32aa34dc68e36edc62ff"))
+ (1670000, uint256S("0x00000001d70644f12e0ed97832baea5d8d52b4109c3eb6d13628ca61c6983af6"))
+ (1671000, uint256S("0x00000001cf40d5ab42932e082e3c8f0bb769d46e759776113a40e864d9aa4aad"))
+ (1672000, uint256S("0x00000002070b8a20b0c1491cb30554beaa4070ca92c043a436de279794e9f24c"))
+ (1673000, uint256S("0x00000002619389bf5e4e12e728a4879f0ae9e09e59721313efaf00c293dbb3fd"))
+ (1674000, uint256S("0x000000032517420588e7b8fa7892ebe9c04fa247dc04a77cf7ff8cd96dcdfaf1"))
+ (1675000, uint256S("0x00000002e056c3b3501346a044723757bdf22448957ed61f580482cead17db2b"))
+ (1676000, uint256S("0x000000021956ce039b89a4dc4f57bbd948852fb8e60cbee97e47914476a00af7"))
+ (1677000, uint256S("0x00000000dcd83c42b2bd5a062c0e46237232166a3fd11fe0909908675d4b2960"))
+ (1678000, uint256S("0x00000002be3d780622e1c8d12dfb9ce8e00d1a6a0774edac2ec7cacd0d47968c"))
+ (1679000, uint256S("0x000000021acce8c8f368551df6373c7a87d884847a4837abfdeca3a412b50cdb"))
+ (1680000, uint256S("0x00000005910f9f52c1b2c386a051811f11d3eaa4c737dcce58ab3cc37fcd62fb"))
+ (1681000, uint256S("0x000000049ffd7d05bb3c1b49874baceea1bc7b6b900e31100c2ca3bcc28a25a2"))
+ (1682000, uint256S("0x00000001b230ac60a34ebd20a60b32c881c6d720e61eb8ff353426579d9a38b4"))
+ (1683000, uint256S("0x0000000427e6838977f26189ff5e1d56ebc6ecd7a9eb06d0ad1cae3ef773519e"))
+ (1684000, uint256S("0x000000022f04d5082852031d455546c7ca4a25e964008f8ea69d29946f28e1e6"))
+ (1685000, uint256S("0x0000000475bec2831d736ed0a14462c023bbd80ae03d0ec2e5c4633339332456"))
+ (1686000, uint256S("0x000000047a42b4eabe3ffab8d95e3cb1a2d923afcbda4e335374e728777fc474"))
+ (1687000, uint256S("0x00000003eda47c88b7d313cc525f0511934dacc364d045057eefc2148934cfbb"))
+ (1688000, uint256S("0x000000040d7bda41689357c29aedb77b016f3cd2ce2bc3ba04c4bdd95d455286"))
+ (1689000, uint256S("0x0000000128027ca8f7b2dccb44d26946b9df6533f05e63da9d475867c4b251fa"))
+ (1690000, uint256S("0x00000002dbbef67d168a562e36ba850e15acfad1172d1134df4f1f4288c9d865"))
+ (1691000, uint256S("0x000000048ad7645fb07ec103dadabfb66c2b544c69bd920692a834a8844be93d"))
+ (1692000, uint256S("0x000000010ddd71bc79e292a7c6e3c70565ba211f918eb1751e905301acbcd517"))
+ (1693000, uint256S("0x000000010dc70ae11c82e34000cd7d1a344bbf9fcf6344b3ac04f3173d1703d0"))
+ (1694000, uint256S("0x000000027e5cb8c5bfd613100811708f7d180b994650d3ca6900a81683d50fa0"))
+ (1695000, uint256S("0x000000014325867b388dc34843b695536eb9185c6782707f1c86edf0b5b89e9d"))
+ (1696000, uint256S("0x000000046385ad70b5c3de53eb6634836758eea4f7ee7b81a889f7201e27337d"))
+ (1697000, uint256S("0x00000004bbef43e1ad19298dea05462d23e7de9482dfda72c8643cc5a73e3356"))
+ (1698000, uint256S("0x00000000c7fa58a2b8420904097a9e02bc0b7aa9bc9e427ae1eed1908a150b0c"))
+ (1699000, uint256S("0x000000020ddfe5a4caddee1261f1b30faebfa220184e7e8fafee520d1bdc2452"))
+ (1700000, uint256S("0x00000001c8a7698cd8594605fed3594a8a576535d94f3440ba69b2ec01706e2f"))
+ (1701000, uint256S("0x00000002e9daa2a596858bd331b6320b4aaa34124ace3dbabbd50502b58eaf6b"))
+ (1702000, uint256S("0x000000015cfe670509475a9e7f693b5169e02d54bf459342f511b39ae05d8ce5"))
+ (1703000, uint256S("0x0000000045def8972d1adc0828618f4186f89b2d550a03f099ea4a72a78161ec"))
+ (1704000, uint256S("0x00000001a4a313c141aa9f20bb8011d00315bcfab4784a711d1529851ca6f218"))
+ (1705000, uint256S("0x00000000fc4bbd9320b7b0f3329c52e604655d872caa8ef9a64eb34e44b42795"))
+ (1706000, uint256S("0x0000000614e676936e086495ec9b3b1688a7d6030d032c3da7c241a417e6dbe7"))
+ (1707000, uint256S("0x000000005ebf5e6aa923dd2a4367d7747126343356710659b4b105b5557b26be"))
+ (1708000, uint256S("0x00000002dbfbbfa81aba34a934a69c7d6db57ace02eb20b7f1be183d8bc67b49"))
+ (1709000, uint256S("0x0000000481ece1648cf7bc906f3f912d7900170d6adda615c6e9402e7aae7a71"))
+ (1710000, uint256S("0x00000003b17400949f2f3c82142eca4c6590e863f657b64a3dbe7f79fccf38d0"))
+ (1711000, uint256S("0x00000004f87d08b7c4d366db9cdcef3f427842525b6e61c42338474821a22e03"))
+ (1712000, uint256S("0x000000049b7af8b5b5f9eb3f29d37e312abde898ad5b4891cd7d0ca1a7ee6c9d"))
+ (1713000, uint256S("0x00000002fe801673cf970df547fc14c4028b7c77abc185cb733b1726d8bcbce1"))
+ (1714000, uint256S("0x00000004a088e6e02bdc2cd157915dc13f4ff56eaaa0e7e79b796b5b3c72a89b"))
+ (1715000, uint256S("0x00000002e2d5aab4a2e23b05498896ff1e8c509e66ea5018c5a48135d65f54cf"))
+ (1716000, uint256S("0x0000000050ffc3dc91d5a8514d461b81515ebd67e22e2e3588436a8a10d7b768"))
+ (1717000, uint256S("0x000000017bfd0ce4a25cb8d4bae41b7e8d007854c1a66ea2fc015259b1e76174"))
+ (1718000, uint256S("0x00000000c8746b2e580c8e50800000d65fe893b974c2b0825521d916a87f6bbc"))
+ (1719000, uint256S("0x00000004647c20d62c9d15237d1f7d7996fd09c3e3a22f85439d1437eba50ca3"))
+ (1720000, uint256S("0x0000000087327d6b4e0644f9160915ad6f9e61497569d6223f079f7e9745674e"))
+ (1721000, uint256S("0x0000000201320ec96d6595875bcea2e431521b5035a766b072152af196004dbf"))
+ (1722000, uint256S("0x00000003d96adf0598c8a738e69fab7e578be011a49725b7dc77ebec29641dfd"))
+ (1723000, uint256S("0x0000000539537247a56af803ea95566ed5460664b0ba7958304f8f12ddbd657d"))
+ (1724000, uint256S("0x00000000e00f083cf90a695e5d6027a64e6cf3d42597a56871d17f310d7d3136"))
+ (1725000, uint256S("0x00000000888dbc0aa88e5d36cea342943d0271d5bfb15feebf637a838088aad3"))
+ (1726000, uint256S("0x000000059b3c06996b53335953a921cbd3edd0987b95a6be1987517afa58fd6c"))
+ (1727000, uint256S("0x000000048b539eaf18dfb0a9ce0b69a089fb4bdc80f4248dfd3e0270a2de6ce2"))
+ (1728000, uint256S("0x00000001055b9a98fd452d8b15f32990319ee5cb55fcd2463f382f1c9ba3ef4a"))
+ (1729000, uint256S("0x00000004237a1b7205a35ff9d2ed13198899f6995a0c9080ea1e0fce6b119d6c"))
+ (1730000, uint256S("0x00000002db2eb82e6309c174228bd0ef365f39ae75774123ff97ac729ce2ed42"))
+ (1731000, uint256S("0x000000066d71c51b95c32540d10fb0a7dcd8057ed812fb3bad4e084926b6cfe4"))
+ (1732000, uint256S("0x0000000285bd425dd245cc5456f6e0df4d1fc35531019297f3ba4a39e1c0f20e"))
+ (1733000, uint256S("0x000000020aad80909c26fc60918260f1096897a67d8d0e8e712b5374c04df5f4"))
+ (1734000, uint256S("0x0000000454b30f370832f4f09dcb3cc25347185fe78e6a20f53bc929c1f4f046"))
+ (1735000, uint256S("0x000000031c20ff6b27992f7df1c7852100844745d06eb081f1d7a14f8945a15d"))
+ (1736000, uint256S("0x00000002e8bb07f38fea576318d0daf090360d1c80f22d2c4d5acb18167985d3"))
+ (1737000, uint256S("0x000000029a2c942f291b050a17474b6fc0302911cbe28200133e6da35e282e7d"))
+ (1738000, uint256S("0x00000000ff3a12e66d4ea8356848f5fd4ee9a08793d182c91e805a0783dbb0ad"))
+ (1739000, uint256S("0x0000000141c88040bb76f4a44c42df8bab23b7d8cc582cdd76e7ce76ef56cb1d"))
+ (1740000, uint256S("0x00000001b8e797ff118fa4c0275efc75d8a1c57753b60939bd3365b29f801b7e"))
+ (1741000, uint256S("0x00000003f9d0ab66675f262a3bdcc1a31dcc31726ee7765ab29378d543329e49"))
+ (1742000, uint256S("0x000000002d3600b5c69588493b3129d847bb6e2576c0bc3ff9f6460efd2581f5"))
+ (1743000, uint256S("0x0000000282cadbec2f99e0c8e944b9260f13f7133cc56416870fe38e4848bfff"))
+ (1744000, uint256S("0x000000038e69af50667adef2cb0e9aeee8bccd52bea7e46227294f6a5e0c0438"))
+ (1745000, uint256S("0x000000057c5b7c69c1c10a2d11caecfbe17eb62e9be08bcf70334e25709d85b2"))
+ (1746000, uint256S("0x000000005590217461b08cffd1058091affebbed9715322a924057cbe697e94f"))
+ (1747000, uint256S("0x00000001f6a7c6dcb1984728e353cf24a3bea2e68c73754a916aefcdfb0cf29c"))
+ (1748000, uint256S("0x000000050efca03a20ac1d081f7b237e0187003765c302826c1c5ebb6eb251a2"))
+ (1749000, uint256S("0x000000029dc342a556a0f39de61340bf1913a001f2bedffb2d2fc75e9b2306bd"))
+ (1750000, uint256S("0x000000014c90d5bd41f3bb9cc83e966d17245989901adea24e9fb803a3af796f"))
+ (1751000, uint256S("0x00000002a3ace1b4b93e182cc8ab48c2d5f21d098435e08d6ffa006e66bde526"))
+ (1752000, uint256S("0x000000014717eb5f4d01bfe4a62a0a3cf5767ac1fe61d20782767b9ad38551a4"))
+ (1753000, uint256S("0x0000000165c3cd794a3ad5f5f7cf858228dd7bafea465d89d9ea6bb9d50c9a8b"))
+ (1754000, uint256S("0x0000000425309c3ac83b8f59e0987213c44f9d1a70af1b2df67acef706e37da6"))
+ (1755000, uint256S("0x00000003d788414e454fdf516d768165cd6efd59da056ad9275a2818bbf29dd0"))
+ (1756000, uint256S("0x0000000665956fc396e2c1b42c3932580e37f478ec7c15e28f35a76195a986d5"))
+ (1757000, uint256S("0x00000000dc5ace43a116ccc9358a1a6a1f21b99a4d4b38b939b5dc732578e340"))
+ (1758000, uint256S("0x00000000e2a0b7e090507f4f13e21aa73024fb5f8eb946975c8e18d3fbe5425c"))
+ (1759000, uint256S("0x000000037def7a52163a882e40c5f693d718ee3c9a3ff72765c91e5b6f9af913"))
+ (1760000, uint256S("0x000000045769ff47e8e3f1cb51a9b6ff1378899a231161da2a3b3caa8413b94a"))
+ (1761000, uint256S("0x000000052ffed0ce57ccfad266b64d9a949ad2784af80a066902dca2b2d417c8"))
+ (1762000, uint256S("0x000000010bef4889898cf3e2c3d0cb0ad0cc15a7aa394b6db6949aac4414e9d7"))
+ (1763000, uint256S("0x000000052b4397f24c7be192df7c617a3ec05eea73a9f0a71d294749c0555521"))
+ (1764000, uint256S("0x000000024051d111a516bd779d7a854c658439a0f82664ae7742fb76f2d87a86"))
+ (1765000, uint256S("0x000000054ae9cfdc5678a79671544817cfb5c45c865ce489388c6f4aab2216ee"))
+ (1766000, uint256S("0x00000004221eb0fac5a1340dec575372ca0ea842ac3f13eaeb41e848a9b3d605"))
+ (1767000, uint256S("0x0000000365cfe174006b52e5699397e641be7aaac2e4dd954bdc417dc2077004"))
+ (1768000, uint256S("0x00000003fdc4b4eda17fb6af8ae1551a13fc0d655a6b9559f61f39dc08ba0087"))
+ (1769000, uint256S("0x000000037d29ae542edf0e8fe09b2cf95d36f90d827152d4693244915b3ee456"))
+ (1770000, uint256S("0x00000004c918f544097141d0d6086567f483f707e948b6b9a9de762ed5281205"))
+ (1771000, uint256S("0x0000000436ac22a224104b08bff31869c7ac3102b9e35ae3cc23190809008abb"))
+ (1772000, uint256S("0x00000002385ec38d63ba954913958bc0c973698667f0cf37fe840faf362add07"))
+ (1773000, uint256S("0x00000004b1bd7d5616aaccf2eb556dfcd704c82c60c0b4eebc29f8f640903168"))
+ (1774000, uint256S("0x000000036415ef1337b9120373ccc66e851cf33e77579832eb65983bafeecbec"))
+ (1775000, uint256S("0x00000004c4bab47e83343b2bfce06d1542ebdefe1fddb286ed8f91a6c84769c7"))
+ (1776000, uint256S("0x000000016a5765722d608457aa92632a328ae581a5de599504c0935ca6092e82"))
+ (1777000, uint256S("0x0000000701c4bab1ce3c92668ed4949496b0830cf1d771670bb5631df8c7f643"))
+ (1778000, uint256S("0x000000013d0ff9925033ce0b3162926f200f867ee43efac2a7bdf6a95a56c351"))
+ (1779000, uint256S("0x000000003b272c6520cb8893f29db1e667aacbf40ff6da4da3ac325516c16e57"))
+ (1780000, uint256S("0x000000013df5ab5ff720342b732febd98fa9320bc64ea34714dbf7b4fbcd53aa"))
+ (1781000, uint256S("0x0000000b64be023cbcfcec386c79d708467e466782b835d1e67b486f2e5c2d74"))
+ (1782000, uint256S("0x000000021b2a9cd3cbbba257a3ce503f6fa1e39c6d1804100a14c13744b24363"))
+ (1783000, uint256S("0x00000007cde6f7ef2a41c581b122b24877e4203b3445baf0034d73ed14204ed2"))
+ (1784000, uint256S("0x000000004b37bb794f24abca1c311145c97550199373b17d2c7c07df5ebb9538"))
+ (1785000, uint256S("0x000000047edc917325ce9578a4c94f00a1183cd753c76b12c195e0e820d556f3"))
+ (1786000, uint256S("0x000000025c0177811a33925ddb7c245e56b941a6fbbabad67f300489e98817cf"))
+ (1787000, uint256S("0x0000000459dc750d8d9310ea28c7f88bdc2c2816b185ec45919bffd62153a57d"))
+ (1788000, uint256S("0x000000034ca7412ad71c48d3772d97dc99bbe3418b1c3cdd538b9700936fb199"))
+ (1789000, uint256S("0x000000076f64250f26cd16523a1785b7add386b594ebd457acbff0b7a6aa89cd"))
+ (1790000, uint256S("0x000000060d72c59bb12a1633dce31071cc6a132c626ab16caec774c1c7eb4d35"))
+ (1791000, uint256S("0x00000001515c3d79e4e28cdeaaa4a5b95b94e3a20e54c788bd66c7d79b312a5c"))
+ (1792000, uint256S("0x000000030f57e0c948e41863bda05f6c144ac8c9e0811e3c1844cc417e2ac8f9"))
+ (1793000, uint256S("0x00000005dcbfb0ea2a75b3babdf61fdaa8bc4bb24f08f2aadce4d431a681ad3d"))
+ (1794000, uint256S("0x00000005471c52605a54456a45e70e78f212988a21dbfc2b44329595c9d61dcd"))
+ (1795000, uint256S("0x000000041746a3ea05c2e383917554b8687bedce1c79c59e4d48a9dad86245af"))
+ (1796000, uint256S("0x00000002381f362803c3c533767dfbcb32f9756ae6bf9b7bfbf717751959be15"))
+ (1797000, uint256S("0x000000010a66bfc8280389b9358b7d32df17368c8d207385827ce5dcc26d8928"))
+ (1798000, uint256S("0x00000003170e34e98d6f7465c2aca3ac03fd6838770c639ffaaffdf47b2b5a5e"))
+ (1799000, uint256S("0x0000000d1f702ffae124c4d2ec4094b453f6a730f7d137638e517f377b2699f0"))
+ (1800000, uint256S("0x00000003119096a306aeb83dc7c3fa2c1baecaed090d88fac9751b85c02d5392"))
+ (1801000, uint256S("0x00000005583508df3d48ca3ea7aa8b1790a12b9d68a1537316d3ba83041acb70"))
+ (1802000, uint256S("0x000000060084882a0c69971fa6b1f5b219fe582b715864791c24fbdf779e30ef"))
+ (1803000, uint256S("0x0000000362f4bdac37f39bc886b56518b27ddca7df34c93170b316dc861997b0"))
+ (1804000, uint256S("0x000000052ac5a611ef3aded2989cc41fe7ef76ee95235ddc8904035ea6b41220"))
+ (1805000, uint256S("0x000000053f82b8a019469735d361dfe98b0ede3b7eeb1ea98bd266e4957c2009"))
+ (1806000, uint256S("0x00000002a73fd89ea6c9cc235a70d6d5de89870669b89a96a917f8bf96b9f799"))
+ (1807000, uint256S("0x000000045c45f117de62f01bc283f6170fda3ccc403aef07ad8d1b30eaf11031"))
+ (1808000, uint256S("0x00000004a6be7713af8533717d906be3d0b3df6b845be498591e775b27b570a5"))
+ (1809000, uint256S("0x000000030e95b1540d64d3cc1f596b3b84e21b7211595210d51807f12f784d29"))
+ (1810000, uint256S("0x00000000b00c53c576fc4938e55c3e091eebc59b67007a819d7ac77ab56fd296"))
+ (1811000, uint256S("0x000000008dffebe6bdf334c49df095ac5cfbcd6c81b2737e57f3ae706ee1355d"))
+ (1812000, uint256S("0x00000004870a62faf53b5bc60093537140a2ed830773294dac7fbe7caceac315"))
+ (1813000, uint256S("0x00000001cfa729a10b2978412336e3b8e5e776b79ebae946c23027fd54acae47"))
+ (1814000, uint256S("0x000000041aaaaa85cec731049de070fdc2b307b452cc305e8c75664efe5041bc"))
+ (1815000, uint256S("0x00000002ae8ca8bf637db8f46524c969fb60ec976dee9337c85e12acda1b800a"))
+ (1816000, uint256S("0x000000025cc83efcfa5b31b0a4b547cf5923b2f28344079f50ff09310b4e3149"))
+ (1817000, uint256S("0x000000038d0d1c7c923615fb07937822e313804269fccf884e38e613db802db8"))
+ (1818000, uint256S("0x00000005cdaec2266a5c21932dd2289a0171931aa4bdc39bcdc381d6194f3733"))
+ (1819000, uint256S("0x0000001f9bdedeacacc6602bf223dab9e25944637920fc6799738795c3c7efde"))
+ (1820000, uint256S("0x00000003a5a16120bde4b1a6a784ace30b616be37b8429e4f43eee44ceee0598"))
+ (1821000, uint256S("0x00000001f3c39cbe6a2bc81b0a6e6aa257de0bf13452d9adcaeeb71cc23ad029"))
+ (1822000, uint256S("0x00000004e0bbde4a8783d01581c7a1ba255506e9f967d8c096bc6c9034f70222"))
+ (1823000, uint256S("0x00000004a6d66ca53dbf714c238022cc0a42126540dff2f9cff7c59395a5752a"))
+ (1824000, uint256S("0x000000014b2b5044d0150acb34d993faa9ef0120a0842455e112d78632659c4f"))
+ (1825000, uint256S("0x0000000263a08ebf63abf6bd81764d1215a5a90aaded13d11bd04e2eb5107a05"))
+ (1826000, uint256S("0x000000065c08ecd03aa691178834c112fa5e728ecd82a8927f0e4f49664d5af8"))
+ (1827000, uint256S("0x000000058d8e8b4a7d38afa75d99f5e91b440fc209572ff26a98b1aabbbdbdcd"))
+ (1828000, uint256S("0x00000004480b9a3c0f9c87307804c6278dcb49c3fc362370a9fc424f27bac805"))
+ (1829000, uint256S("0x00000000f0b3cb7e289f48c72af19d62075c3390cd2991447216be87f9d372ae"))
+ (1830000, uint256S("0x000000008cd6ca08f95df6d9fab3faf3ab1ea74570d953fc05dea018f7ab0d95"))
+ (1831000, uint256S("0x0000000434184bdedea630dcdfeb3ff92aa48c46623f9237ee4b965150557c5a"))
+ (1832000, uint256S("0x00000003bf13197e2553f80bb4f1f41a27aafff87829e921fbddbdfa58718c78"))
+ (1833000, uint256S("0x000000037027ca30d184228e7ff663a9c0dde0f8f26f99bd587e0b8a309389fc"))
+ (1834000, uint256S("0x00000002827b9efc26f29c80eb728cb8ecd6cfc1a968b03c3f0e8fdd81625d88"))
+ (1835000, uint256S("0x000000049a0d5128db2dfa0961db2058bf7d153ebf0f4cc6d5054f561736f90c"))
+ (1836000, uint256S("0x00000003f67c56ff4281d35dfa78392f7ca0fe10cca06015e60b4c6ebfa2da7c"))
+ (1837000, uint256S("0x00000007ab31a2d80026cb363b965ed0b43a122b3e03e53b6f6614ed5ad835e6"))
+ (1838000, uint256S("0x00000009024dd6c35f41ebd7b759f8b108fb990c337fb2b764abcf571c731098"))
+ (1839000, uint256S("0x00000004a77cdd4e5130cee8c0ac9ecde7c22b0e342463596275db8b249d235e"))
+ (1840000, uint256S("0x0000000194db82e2be83455d477ba908718dc3c0b1092a4ef62459ad9b75b864"))
+ (1841000, uint256S("0x000000039654d65ddca898e2e13af01982516a542d3ede41163bb5e57c62cfcd"))
+ (1842000, uint256S("0x000000026c7a39b765fd8fab1cbd39bb4acb76e65de4d84996e90b6bc5cbbb8e"))
+ (1843000, uint256S("0x00000004ce2314f45bfeb207e27324783207dccc9a032f4f7560d5b63073d7bc"))
+ (1844000, uint256S("0x0000000830425ecc1282b45f0d9d2496eda51e7d29ffba7900441132c7a49d59"))
+ (1845000, uint256S("0x0000000a2f8f3e74c416dcd911fb06985baafa789066a7d98535fc7ccaf01299"))
+ (1846000, uint256S("0x00000002ac3047bbaf9a6fb3158e1245022251c40ad29c7b7d9e0dc117bae112"))
+ (1847000, uint256S("0x000000048c49382f8e79ae130453614ed621975037119573a8442e0c5674b7d2"))
+ (1848000, uint256S("0x00000007a618116d10d5cd2d61f3a542d44780a951f18b217ae394a95a51f946"))
+ (1849000, uint256S("0x000000053b6032fcd14396e27f966ce552450219e4f77a4bcfc7759362975d2f"))
+ (1850000, uint256S("0x0000000a68b3397504659a4e8eea87fc7c8788b8ce6616148c02addf46fb5a38"))
+ (1851000, uint256S("0x000000095bfe4bbdf20dafff20a5ba564b879595eb543394b789337e5493e766"))
+ (1852000, uint256S("0x000000027befad10df24147b92fc6b0b1310311fbcea57cb0ecb0f20cac43c60"))
+ (1853000, uint256S("0x00000000eb95b25125c7b58b9685242b4e29c4bce0f952b96475971d2b4bac51"))
+ (1854000, uint256S("0x000000035427daf79fdbba6152e558cb835c87817952e16dc83694d74f577dd9"))
+ (1855000, uint256S("0x00000000e86cebd49029f1348ecf3fec3d042fe3ad054040cf809975d676ccab"))
+ (1856000, uint256S("0x00000006d804ca22bbc006e2204ed721e35ca88675a66817f56a5daf3d34aaf3"))
+ (1857000, uint256S("0x000000069547a70ca10c149dc211c92c986800b9a4f74a44a0892f187ddf5042"))
+ (1858000, uint256S("0x00000002ca6303d0b280024eac8b07405dc2cfc86d54f3668074f60180bff21c"))
+ (1859000, uint256S("0x00000009736485bdfbcc7fef9068d2c50690e1331c0063381bb96940ce6740c7"))
+ (1860000, uint256S("0x00000003a9ec571fce90048e4c46586dd0a764a332b9aad36783ebe6ef225ef6"))
+ (1861000, uint256S("0x00000002fba6f836e098c87c71e6fc2fc811ef2c3e4014b8f66ca241c9538370"))
+ (1862000, uint256S("0x0000000458bcae098b9aed006b5f5b71cdfb5f7b73b0217a809d4ab5db2be96b"))
+ (1863000, uint256S("0x00000001e71c2b9725fd5afbb8586d6312200eada7971fdfab2d9c888daaf350"))
+ (1864000, uint256S("0x00000000971b82db5d846116c8bce305134f155730fc61a0f3b1e3fdc75828eb"))
+ (1865000, uint256S("0x00000000e999b3f061a706af846bc212e4e2ce41151a9c5d9ca6504ee7dc9675"))
+ (1866000, uint256S("0x000000003919b6575c4d446f14b00a57c326f282ed2e00cf75f72006d67680e3"))
+ (1867000, uint256S("0x00000001008c08cbae80cbf264f8c4aba686928fd72459df2298f2a6042d074c"))
+ (1868000, uint256S("0x000000000b8c1a48392a319214fefaf0a1aa0ff9c3ec57437fcce5068f2c4789"))
+ (1869000, uint256S("0x0000000758b5ff8f3edf6cf1f3b8c31778595eacc6e9139c3cd7485abf6ac8ac"))
+ (1870000, uint256S("0x00000006c0e18a5966014b683fc2ad66e67233857f870d1dfc3e4ba24c8d8c80"))
+ (1871000, uint256S("0x0000000aca708fa0f28d3c6dd195bce536428919684852372cca706440ce6470"))
+ (1872000, uint256S("0x00000009f1e7e2ee40d6436009ef884d25171058221068e6b561649164b921a3"))
+ (1873000, uint256S("0x000000041205df49ec40c992d36f19bb697f0dd25fd9474a613cdd4aea8cdf9e"))
+ (1874000, uint256S("0x0000000578b693fff37a8603939098aea30340b7c805a98317ced77cc9a9d738"))
+ (1875000, uint256S("0x000000038b9acc3c108412fe3a61bd7f77c4e709e7923fce6730173edc851ff3"))
+ (1876000, uint256S("0x00000002500162bbfcabe7018c43756da89dd5f5dd86b7a59d81b0aab222a4b1"))
+ (1877000, uint256S("0x00000001653423619a040072d21407c8f3e481c5d2da428a8c3aec4ff044ca3a"))
+ (1878000, uint256S("0x00000007c40a0e9e986333cbdabc6d81e100eaa1eea7a983b8bbb78317d05072"))
+ (1879000, uint256S("0x00000000742d5d64baebfca3b564937726ea4d4928f5b14bc5a5e70fd9c72e99"))
+ (1880000, uint256S("0x000000024d22fa0bdfeec3156b14a6ec455e0dccb913d006d701087a962bf692"))
+ (1881000, uint256S("0x000000077867103cbb1befdf33a24850470f1e26d8942a8c694b0cfd736cc8a6"))
+ (1882000, uint256S("0x00000003e31aad71429d93282c80b73903df35d6a762eae880ce7f746e39acb7"))
+ (1883000, uint256S("0x00000007df770a4a295aaed19a510535217663471284c37e62171a0b8b69070e"))
+ (1884000, uint256S("0x00000004f813d155265f3f09d6e0512bd0111e81708bd6c4b5857fa4c85bbf02"))
+ (1885000, uint256S("0x00000006236adc55d27b875af36649c7482b16a33842546bf4e8212805174e76"))
+ (1886000, uint256S("0x000000075757edd65122294031731b6038daefeb2d18e9adacda4b85da530fc0"))
+ (1887000, uint256S("0x000000021f9eaf50778462b2b58aa21b047200697c6c41880b014a14d9883c33"))
+ (1888000, uint256S("0x00000043c363d1126947ebea3156d801ef0922ecc57f2130793526801f11772b"))
+ (1889000, uint256S("0x0000000353d262ed384f346d50d7fa64ac7e513c155f4322386a0f1e33d626d1"))
+ (1890000, uint256S("0x000000029f50b0065af5c1eec4de04b140d847535d5422215dd0e26eed008d35"))
+ (1891000, uint256S("0x00000001f5b6af002a9524a8991426ee891a268f885139001ed6fdef2e1b0cb0"))
+ (1892000, uint256S("0x00000003c7318412f7ebd0a1da5e2809abf6293b2cf6ec519ed91a44a9b5acff"))
+ (1893000, uint256S("0x0000000c0efaacf06f7d9f5ce1a5211671201c24bbbe4fcbd759d17daf07d3f9"))
+ (1894000, uint256S("0x0000000095e2ba9e15c007baca9a01ea50ec64d87bf84f32fa9749d6f3c69f4a"))
+ (1895000, uint256S("0x00000002909536ceb779f4fb3bff8bf68aabcf26d953a6ccf9eac2b012c348fe"))
+ (1896000, uint256S("0x000000099876579cb3995e07b004c5b25304db77604b049c36473bb3be195159"))
+ (1897000, uint256S("0x00000009a267875f480399b16c0aa89f915d7d0a4ae15cf3bef66f9a104219d7"))
+ (1898000, uint256S("0x00000004321a0d47a384e405e4d3d585c7b5e064559b394d9b8517d409b81647"))
+ (1899000, uint256S("0x000000083025e8364786b286eb3d65cc39fa9cad4720ffef5a22da2618c4ddce"))
+ (1900000, uint256S("0x00000003df9302cdceced304405e46e3fe5950e191173e2afc810527d4a45472"))
+ (1901000, uint256S("0x00000001634453c1ad96fc6bae21a1e58c6b48af72ba9633b95fd313f4bf68da"))
+ (1902000, uint256S("0x0000000bc5de5e55f8d89dd1e26125b69767df8b410163d4903cfdc69687c2d7"))
+ (1903000, uint256S("0x0000000425dbba65f46a66a3255fe4c3e446c460970ecc066270abc0ef53ddf4"))
+ (1904000, uint256S("0x00000005cfedd11ec3f788d8c3e6a126c47c6bfffe0d34b821a0a1ebbd2bd0ed"))
+ (1905000, uint256S("0x00000004c602ef20f36b9dcfefe1970f3e008157ffcc8ddde3eb5f304f566618"))
+ (1906000, uint256S("0x00000004051959adaef5d9e0dc2b142351c5a5afc9a01b5c9b333a8f72844902"))
+ (1907000, uint256S("0x000000095bc01b7e1fdefcdc2fdfa5e9a9be8a896fae2d2b0907a5c6fc741fd2"))
+ (1908000, uint256S("0x00000007258940eebc238e5aabd9403c3ad97e88a90e0596a15a50f979c3b7a4"))
+ (1909000, uint256S("0x0000000623a348b65f08632fa073d3226831f677299eaa98afc249c6b7dea056"))
+ (1910000, uint256S("0x00000011f5e9f50fd2aa37b4c1bcb42a3607f4837687300be7cfc0acfe4db976"))
+ (1911000, uint256S("0x00000004bfc1a263d309938f5604f5c8cbc54d7b580c0b2300f6d96a2e6ac4e5"))
+ (1912000, uint256S("0x0000000137671d01cfcefa184b3a3365bce9caa2b8db024101f5c996b9cb2dcf"))
+ (1913000, uint256S("0x00000008b7007ec04ad61ce451f94a3c6fb2adb7426fc6071b2a5ea48c4f9fd8"))
+ (1914000, uint256S("0x0000000243fe84ebc7f9e6464ea68e938c3095e51561d168cac11e02da7dfffc"))
+ (1915000, uint256S("0x0000000463ee472250bc95ddf1403ac7ce518cb52b4570c5bf53c7c055f718e0"))
+ (1916000, uint256S("0x00000007450182fd8b6e17ab04c95182aa33ab281399e590538f3c6a5daff7cc"))
+ (1917000, uint256S("0x0000000a3e34f534cb787befc6520577404e39ddfb8331e587912e3c35f8eee3"))
+ (1918000, uint256S("0x0000000a8377c632f26108c153d2fd1d42e13e7bbfb8e62642d5e80546e2ed62"))
+ (1919000, uint256S("0x000000016e1b54a1aea7c531c47a3cd6aa5e0722d294c8fc0b718a9aa4574792"))
+ (1920000, uint256S("0x00000003e6d1d949658d5852b9319dbe0e75a4c171d2282a091a97aadc301da0"))
+ (1921000, uint256S("0x00000003d37c4d24c50bc32f815a8c089862d2a33f5e5010c0c36cf51f23d430"))
+ (1922000, uint256S("0x00000001de45a81a83b52246f6bdfd8ce4ab49ff209377f348040a2f7a08f540"))
+ (1923000, uint256S("0x00000006ec45bdf0764f20744447b67227cc91330bded5797881616372aa0400"))
+ (1924000, uint256S("0x00000003f57657a30f1fc6107611dc86dff2ea88a58d46a37339a1bc199c8f96"))
+ (1925000, uint256S("0x000000012f56b581239965f384ee45d91f58818781616b24e37b1a0f9ff3d21d"))
+ (1926000, uint256S("0x00000001fac2e82d4b4e4dc95f62625d259c29a16527dcd2ee8f1a5005944269"))
+ (1927000, uint256S("0x00000003ab28525c560ac0f8ba5a5ab32975b87ba1d423bdd1d1a9a675d668c6"))
+ (1928000, uint256S("0x0000001fc650e767800d6e022e173a9d1608ef821c296dfaabc8ac1e4f60f10c"))
+ (1929000, uint256S("0x00000000a297246c427d1d21d43110f0e4561e42ab940c1269d5cca17f0904e1"))
+ (1930000, uint256S("0x00000012f367afa4b2981c51d39b2d5181b076d93f85220a2e6c373be5c3ba13"))
+ (1931000, uint256S("0x0000000195f51b18da7a447e64c29086d9b9239f344592fdc31dd4793f6fb4dc"))
+ (1932000, uint256S("0x0000000a72a3f81eecf15b2b06b37e5d0e5c8be26945be29f7b80242dd8d866d"))
+ (1933000, uint256S("0x0000000602cec0393e21864f1f9de0e9a31c9eaf96d406d976b2932cb076f945"))
+ (1934000, uint256S("0x000000026ae0bfcedd170c1a7ec3c282806d522c714337105a5b9e3c9f75f51f"))
+ (1935000, uint256S("0x000000096c05eb37e98c0ac1e5da953f75c416b1939d05c3a7f38b443075274f"))
+ (1936000, uint256S("0x00000000b366ca6e89b40632b26fe80c14fb549c70484adede899f4b9550594b"))
+ (1937000, uint256S("0x00000002407697e167d3a957bf6e89a3f6ef12448ec37dc077c36541c08d9d9c"))
+ (1938000, uint256S("0x000000010e122ecf450e3f7af854c5d5af48ff297dc9f7b49ee60d7bb26b8744"))
+ (1939000, uint256S("0x00000004ace5ced8a4f052dd1260cccb305f4ec05207d3882b9ef40d11a5fe6b"))
+ (1940000, uint256S("0x00000001e668c7e4bcdee1a9b291e5ecfcad3eeb84ec4cff80eab05ce23109cd"))
+ (1941000, uint256S("0x0000000913631ecaeefb24c9d168a9a0c05df2012f3e988030eed645687a6ec3"))
+ (1942000, uint256S("0x0000000315b6039d0a0c14820f396dc960ad507783847f599b7d5154f88f94e0"))
+ (1943000, uint256S("0x00000005b7bc0112d299c2f0caed3b0cfa6c1bb730c9004e4d6ef2ceeec9efe0"))
+ (1944000, uint256S("0x00000007c64f0a932a8edfebb2d494665e524afc5ab755e2cefec84ce77d259a"))
+ (1945000, uint256S("0x00000006c6a9fe8c05283f310c0dff22a2d92304b605b593fe1c1fdfc1085bb3"))
+ (1946000, uint256S("0x000000054b5c0409f082be6f0b4deac5ef5106fc44173f3422885fb23bd73f7d"))
+ (1947000, uint256S("0x000000069a8e31d32df50f35ef63029bdd3a56d042d34cf6d02f6efc637c8dd1"))
+ (1948000, uint256S("0x0000000885fd68fb764457590ddee9aef3e4256f2ef067388a9c72714fa775b7"))
+ (1949000, uint256S("0x000000064285b903e667a64cb598f7aee2cbcf8a513a681334adef89f58b58c5"))
+ (1950000, uint256S("0x0000000a706ce153f138e155a21da714642ccf0997f9f9229dded6335a59ba07"))
+ (1951000, uint256S("0x00000005a15015e01043f708b242ae79f71694be8546098085f6604c007c40c3"))
+ (1952000, uint256S("0x0000000acf2ac942089d2f1dee9428c42ca89857b4cd412daedc8c68f1ca4b0b"))
+ (1953000, uint256S("0x00000001b11437b9668a1ba11d70af25a2c9c1635604e689d7e846d154af7503"))
+ (1954000, uint256S("0x0000000217414e96a2db88062abb846422f94a5329f9b89545c5c85848b3050f"))
+ (1955000, uint256S("0x0000000007a180128bd24de08bcda9a1f14985facc7836f4e0807c8f35b6f390"))
+ (1956000, uint256S("0x0000000e2a5b0ea6c830770e16614a39704d94224b317a3c82361e5c833e5480"))
+ (1957000, uint256S("0x00000004e224492b153481750f677db156a960d80e046c0a99fd05e3841f7a2d"))
+ (1958000, uint256S("0x000000038b6f492cfe2bbdef289854fb1b095c240dd4166a8f235e9eb8156258"))
+ (1959000, uint256S("0x00000001e59f4c934ef2f778612da7e8574649cce4638a7b4a9d9833ad32b6cc"))
+ (1960000, uint256S("0x0000000dad02b04d06cf33f129c4001eee6a1633281ad1966089287542dbf0d4"))
+ (1961000, uint256S("0x00000003bbbb92d446e92a6ca1c2026ca5acff6ef342ad7f98220e4a9f8e7ea4"))
+ (1962000, uint256S("0x0000000c344d3c9c22450b075f54711dda6d6f31bd4131cd8ace9197bbc79d11"))
+ (1963000, uint256S("0x00000007f00366ec50f4b795574ab91f426e130cd9b03999fb06a72fb4398f65"))
+ (1964000, uint256S("0x00000000bc0ccb4e73a3b1da4c8b9898176658fd67e0be6268e4e6a7d15a910b"))
+ (1965000, uint256S("0x000000037ef51b844eeddc16da9879defc6a3445142281ae34024447c3c8d9c5"))
+ (1966000, uint256S("0x00000001874485237ab2d0f395532fa16907e2cb0f25e5651312be730a2edcb0"))
+ (1967000, uint256S("0x000000054de0e7518f1263b6d0235f1e2430f7dd23cc1620122357a68731eab9"))
+ (1968000, uint256S("0x00000000a63a04fda160827bf347d6a6cd72ba97ae1608a76716cd97926ea88b"))
+ (1969000, uint256S("0x000000063f5c075dc64a67c603d21416c75ec633c1dcd0e7a93fc03bc21c6979"))
+ (1970000, uint256S("0x00000007790e2edf51dbaced8ac240a960dd133cbab4c0c642b93614987aedb5"))
+ (1971000, uint256S("0x00000007158c4e8d7ad061228c7386179ab5bececfc8e9719dc3129c6c441acc"))
+ (1972000, uint256S("0x0000000c1827bbab90381298cb73f55a2e146bbf235dfa57d6bc08632448acd0"))
+ (1973000, uint256S("0x00000005da023a70008ab851ec50b8b900332376f17f99588c91504c26b5b125"))
+ (1974000, uint256S("0x00000002114d8ecee02f6b3be44335ab85df887a86d78992af6a3ce9ba669c56"))
+ (1975000, uint256S("0x0000000a397eb6d899727ca5db6db81c6ad676c58020a0ffb3f391ff6888f3e3"))
+ (1976000, uint256S("0x00000009bbbf4aab09bb73cc6ed628211b1977ae5a3265fc778dcc06391c4c3e"))
+ (1977000, uint256S("0x0000000b7fb944df8a5b894a38b96c17eda331b3d8c406c5921f470d4adeda22"))
+ (1978000, uint256S("0x00000004008b94214bded7d7f14981a445055997d76b92a920dc4d55681066b0"))
+ (1979000, uint256S("0x000000074afc0070f2fe5643ae73e82f9e2a00c2bd10b65c4009f1fa8b9bb447"))
+ (1980000, uint256S("0x000000104f63e7a22c822a5185dfcf3daea94d1dc4eb72cdd1c0d5819b284b2a"))
+ (1981000, uint256S("0x000000056829646eb2ec3e513ae9bce58e55cc76ff9a8cca9ef9ba1665a39010"))
+ (1982000, uint256S("0x00000001519cc29c8c85f9f4aa37226b7d3a8a65f922f0406a9c5d92175c3c3a"))
+ (1983000, uint256S("0x00000017dc2451bb004694edbc90d12fc16aa45b25ac6b7b3d0179527e1c45ab"))
+ (1984000, uint256S("0x000000020d0f451448959d98abbdc7c9d890b8d52257323b551497376a558a1d"))
+ (1985000, uint256S("0x00000002577dcc6f4fe27913c036fb90161d35ce4ad9eec7fc311eaaef60e94a"))
+ (1986000, uint256S("0x0000000202b6fcf0b41f9214f65d5c2180815004d39ec2de27cacd3a92576607"))
+ (1987000, uint256S("0x000000055865f161ff5e3c9761b37505064dc7583ce5e5e592b6721ee6cb5347"))
+ (1988000, uint256S("0x000000080f858e3d234d701da31ef2aa1254fda3150e3ac368cb51e2115e3200"))
+ (1989000, uint256S("0x0000000cfa4d1e2bbdcbb234fe2f082850dcdfa858a32bef37cf89d00c89f396"))
+ (1990000, uint256S("0x0000000a4c621c54b6e3b4a75e9fa4f018960a1200f074de82324f68b294f04d"))
+ (1991000, uint256S("0x00000000cc0f49d2b2448b362e28daf3e57e1bafdb634ba2c85a51bbbec57afb"))
+ (1992000, uint256S("0x00000002ebd4290f45632a9573abcf4d6fc1639b34aa990eef34b6b0935cf14d"))
+ (1993000, uint256S("0x0000000b6d0c384a04f998e996f453058e006cd0d2bc3abdd518804eb3263fab"))
+ (1994000, uint256S("0x00000002c0fcac020a83d330d6e56255c82d0b47b048270dc33d6ce05b18048d"))
+ (1995000, uint256S("0x00000001d0cd3b61e536c43dac7d4f072769ae8e3b9abdd7f934059e5692c6ef"))
+ (1996000, uint256S("0x0000000ac753c7ed5450d7b05b0bd98a29df7059769c8bc07e04a2ca609c346e"))
+ (1997000, uint256S("0x00000004f457ce81972f0eff5cac5a63832b0d043e0ca9fc5ecac6dbdce65240"))
+ (1998000, uint256S("0x0000000b572087155a59cc67ba355d3a3ffaccfd685570ec56778329b27fb9ce"))
+ (1999000, uint256S("0x00000006e4773706c3a83ed448da34fc4e3e737d47df623254e059fd76643a52"))
+ (2000000, uint256S("0x00000006104d9702e1e5347418c213ba31fc3c14e009ab2d802de64f75f5ef8b"))
+ (2001000, uint256S("0x00000003e0ca20ef98823c384607d34fbadd3425f54b75b92a2f7b898386afff"))
+ (2002000, uint256S("0x0000000486c9388c8932401756df96c043e39bdfb52d8d0a147a5b97922b428e"))
+ (2003000, uint256S("0x00000001e639068d2aada8551e23effbea6e281bc8b10a74e8f9fd757a9d7f26"))
+ (2004000, uint256S("0x00000004e6f8077d8cb9adb4b0c4f08e88deb784c57b461167000763c9f7e22c"))
+ (2005000, uint256S("0x0000000381e818c7c3598ce66fceeb3f76538b851a33672b6fb7f63b0ee1376c"))
+ (2006000, uint256S("0x00000005956353cc542e589709ef1d1859c0466ae6590459ac3299513431e935"))
+ (2007000, uint256S("0x00000000efc171f4a2eab03c8ce32dadade866aee3a9c70b430daf051715f900"))
+ (2008000, uint256S("0x0000000120aad6d1c226a6ec15887cbc96135d2237f37c8c076dd20c81122cad"))
+ (2009000, uint256S("0x000000048d5381588a5be440fd9ad45747f76f6f5ce6e0b679ef549e0ab33979"))
+ (2010000, uint256S("0x000000086d9b6cfc665cd910e9d3832cde002278ae7342b1d660141390e81ed9"))
+ (2011000, uint256S("0x000000070b22fa037c6d290ba7811448bea1cf00c8f22aaf70b992a0456aaca0"))
+ (2012000, uint256S("0x00000003b32bf142b85b39c398205f42b3e10fa967fd78db41cec936347fa545"))
+ (2013000, uint256S("0x00000003b5bd355c58956838c927059b221c87af7e8282a5e0027e8c552d082f"))
+ (2014000, uint256S("0x00000001c5f2d5cccc99b43f7a9c1b9e3315eb4feef4bf611c680d6d55a1c395"))
+ (2015000, uint256S("0x00000006f94f71772329e7ebab13a932297c37faef047b4777f276281a6412e6"))
+ (2016000, uint256S("0x0000000421b342cf93513b1d098fc1a50904a1583f11a67b2d1286b4311270aa"))
+ (2017000, uint256S("0x000000035cfdd315adf7eb39f24b1114c316559b7266e28e369bd335332ed26e"))
+ (2018000, uint256S("0x00000004178109bc2e463872fed909113bb4a047722e7d4131f9f5e75e3b5d07"))
+ (2019000, uint256S("0x000000040bee044c9437828ac4569799f69d14527918015b94c6ef9f0ec771a2"))
+ (2020000, uint256S("0x00000002b5a7669c48ab1e6405688bf645062c2098ffaa8784bb6b9e952f32c3"))
+ (2021000, uint256S("0x00000003e7f2248ec7063391c0b8f650f6f02abcea8146025685cce41f1967db"))
+ (2022000, uint256S("0x00000002a3057653ae6c75eecd9f4688f0440b4e44f81af95cfa2072e01cf366"))
+ (2023000, uint256S("0x000000043d0b453924262edf2f2b07419cb1c79a22d2aeb9d0352727b8b95770"))
+ (2024000, uint256S("0x0000000857efe8be5bee7d4949b4a46924a6b16a773267faa47924db46755adc"))
+ (2025000, uint256S("0x00000007e197ec851d99abb18e9bda39af5acd4ebdf1cb284cf24becaa621936"))
+ (2026000, uint256S("0x00000008e7576b9fd21454ee1c241ad5ff86de27b90a2038b17c05174af6aa2b"))
+ (2027000, uint256S("0x00000007852b9d9c07bb4fb396bfcf1651fed5afacf91ac051e6232cc79eaf43"))
+ (2028000, uint256S("0x00000002134827686fa7399d930d28e1379d806c5da307ee8b6420e43e587c95"))
+ (2029000, uint256S("0x000000064d359b9d5968be2e7f2629363f16f14f2e2c23f9f113bb8074219eeb"))
+ (2030000, uint256S("0x0000000b62411c2027634d87f0fe56311f891a2471c2dc59f881e909fa62e21d"))
+ (2031000, uint256S("0x0000000b69aa3c2e0a408071337b0b8e500d7168ae58866008278bd876711b8e"))
+ (2032000, uint256S("0x00000004ce57ce1b210ec68c6d78d3e61b1bb61b15b42829f59adc144243396c"))
+ (2033000, uint256S("0x00000004024fdc3d1fac61b6713ad6013a2f36738d63cc8da836baf294bee671"))
+ (2034000, uint256S("0x000000057861c7bc5314e0da1aec9f1ebc1ffb4faf6955e0b75a892601edff73"))
+ (2035000, uint256S("0x00000010c8a56a05dad2b598c2912c8ea541b4a26f1547d96a653f6a4201bd22"))
+ (2036000, uint256S("0x000000041e11ed9bd926c40d810330fac5a7d68e6eaa363e0bb5c61af322ea65"))
+ (2037000, uint256S("0x0000000a7e65071ac725747967d8fa4c05cf1c3cf707bf32ea3af64b5be1b708"))
+ (2038000, uint256S("0x0000000f2bf661c814dd4c29018d5990125f5b944f8ff32d1dab74c4df96bb22"))
+ (2039000, uint256S("0x00000011646bb384a33b2176522d0b1890c4252e004f6e39a8a24ef23de7d4c6"))
+ (2040000, uint256S("0x000000049927621327cb34f68b8fa4a7a27a8f348284fbbe19a31dfb05796028"))
+ (2041000, uint256S("0x00000012aa50fdd25fa7bec01b4b23bf185028ee9b391ee01f448e3466dde830"))
+ (2042000, uint256S("0x0000001448dbbce0a941d62af80a4802b4125dbb703b8d6afc562f6f6a71c2ce"))
+ (2043000, uint256S("0x00000008425d39caac093da2d3bca16eb6341a5a5c6a0c9c3b29e59b613f19d5"))
+ (2044000, uint256S("0x00000003646c87e167ccec6a46c532299ff95ad0e09d763c77dea1b1f77fa41d"))
+ (2045000, uint256S("0x00000008a305f798f921a659779f2faa0c9b6061654f128bc0288e5ffba5617b"))
+ (2046000, uint256S("0x00000005f13275b498964e0b1b2175e9269c6e72f8d3d4a6c8800866648cc139"))
+ (2047000, uint256S("0x00000001faff2ed7233ac268b0dea48ca095c4221531fd5cb0a717be44fa57f2"))
+ (2048000, uint256S("0x000000096067600fb16cf37ff22348b0f66e81e70b9db5594ec96e55ea2aed3e"))
+ (2049000, uint256S("0x00000004a5c77487e8b9ce874907d1d87a5cc9a233b8200dc29424fc4d05c4ad"))
+ (2050000, uint256S("0x00000000f9e4a246d317efc0058c117518058b90e354fd0832a8aa3f2817ad98"))
+ (2051000, uint256S("0x00000004c25718021a1640d581520087f4b1ca550f60624e4f0165c42811f591"))
+ (2052000, uint256S("0x00000001f1cc162af35f2b78d57ce24699ddade07e9e28a72024eed4ae6d88da"))
+ (2053000, uint256S("0x0000000675cd8c85204a982290cbcee1ce7744883f50e49b42ec19bc3f26a6cd"))
+ (2054000, uint256S("0x000000073ae301de16e3a8ddfc31461abaaa6d0f68dce219e021e60786a87e33"))
+ (2055000, uint256S("0x0000000c3c1403f65d6d949bf47ac6c20ddf1a72a4746d489ac0373d0019ef36"))
+ (2056000, uint256S("0x00000000bbd938ba5199353f4464da3e0548a161b659d4158022c494e5964c53"))
+ (2057000, uint256S("0x00000002ef9613e873ab3e696bc67a854ca0fbd5d2c80ca2813790c7e68f7ca0"))
+ (2058000, uint256S("0x0000000aa352bf7be4811a434ed81b599c8bb75b51c9180ed950ed93025896bc"))
+ (2059000, uint256S("0x00000008758359b387368898cb7a1ab2637e8afcc25be27639c92044b6d38481"))
+ (2060000, uint256S("0x00000007e482f4d5931a4900fea1fe60e9b5272340930740d1daf0ddcb60fba6"))
+ (2061000, uint256S("0x00000002a4cc006f2a4a8dfe6031a8224f13a1653d2d7cb759f6424e973b21bc"))
+ (2062000, uint256S("0x00000002a89e57d8aa5073bbf9b47d3a1406b880d5a10cd04bf4db15b8d52f9f"))
+ (2063000, uint256S("0x00000001c2c88d5d2afd8e5d3ac0a58f75f1233278bad1f509c04bf2de8a0cd7"))
+ (2064000, uint256S("0x00000001e96c132713c76b3b660176376eee4d01aca688ccbd1f052c7e02eab9"))
+ (2065000, uint256S("0x00000009be2a5ecaa562da4b4a89974c63e41fff0d45e67aaef52cd5628832a7"))
+ (2066000, uint256S("0x00000002b9e96ca7a4702ff76b0e8985bd5b8165a844b0ff524118cb73b81b91"))
+ (2067000, uint256S("0x0000000b08dc59f10fbf0be04059d20d0fe8dffa0775a27deddeea31f1aa9c08"))
+ (2068000, uint256S("0x00000004f4bad2cf91e2ca928674dc26219b9fd5d51089b71ffa3a0e40c1a8cb"))
+ (2069000, uint256S("0x000000020ef61abb460f3bf1805208c67ef076169cc3d93feea93a44549e6b01"))
+ (2070000, uint256S("0x0000001933ccfe24b7f15e44ffcd6c70eb07ddd1e5153572c587c71604e037de"))
+ (2071000, uint256S("0x00000000b837126d714857fbefa49ba9b57a5c8e4131bc58a57a8cb72e0db9a7"))
+ (2072000, uint256S("0x00000009fe7c493b1bedea4cbe111dc917f36a5daa7c515efc1b152b5a4f898b"))
+ (2073000, uint256S("0x000000017b1dcba194020efecba83e73dc5c79d61a67909ba9697be7a096fa21"))
+ (2074000, uint256S("0x0000000523d291de6295dccc955ce5ad336f16f7758be2fe806828c577aceb10"))
+ (2075000, uint256S("0x000000000797b81b51747b233de0f2af1996321a91f3e4202b6ec009c084fa40"))
+ (2076000, uint256S("0x00000001e24e43918b04c68bdb3d6f344fa45161d6a83214d33182c266106942"))
+ (2077000, uint256S("0x0000000cd024f9475ad27396e68f77d14f261db3168510b7d5fd985e15317fe7"))
+ (2078000, uint256S("0x0000000098a181b61158deab23686d5fd27124e333c9db07b23144d490e94e21"))
+ (2079000, uint256S("0x00000008530c9cf4c78823bb23f1c12bf06fba66b757e5c0289c49a695d0f0de"))
+ (2080000, uint256S("0x00000006d0cfee04fb90dcbc7a3e97928228f9d49311f0c03ba36ebd91714c0e"))
+ (2081000, uint256S("0x000000061584569c356147479c7b59896050f266971b3ba39f2afd863c9d5da7"))
+ (2082000, uint256S("0x000000038a92b82d08c169edac37a1b6686d32c9b62efb79a1e0120a2e5b980c"))
+ (2083000, uint256S("0x0000000ed590f12cc3b91f450e5d30a317fb745dfd0559640bbd1822be0892cf"))
+ (2084000, uint256S("0x000000033451b003a9784bf72fb2fdf45a39b324efc6b58c5428ce4d06ae9383"))
+ (2085000, uint256S("0x00000006d0106b85a660e384bcf50003fbb3ebf4dc8ea4666745d18aad0ce706"))
+ (2086000, uint256S("0x000000046acf8da7d34ea59dee43aed38d8b174b8d3945223fd302fd43d1da30"))
+ (2087000, uint256S("0x00000005ced9d8c38416be2bf222b4e6bd0c116b8f3f7eb64b6a8979c4d42496"))
+ (2088000, uint256S("0x000000056abb81bb40ce200afa9431ec809a0b32614bc0a222d8f5363457cb1d"))
+ (2089000, uint256S("0x00000007510588a1f76e1bfd1d71302c734296e56654b973633cdd09715ac1b1"))
+ (2090000, uint256S("0x0000000419b70e2eee4092d5a7a6567d4f0f44bd25bb2e0c9c93640c147c8ad7"))
+ (2091000, uint256S("0x00000005a64ce43194676a276f61bc316b122526487eb6446900ecc3128d2b59"))
+ (2092000, uint256S("0x00000008a604ff11b8c78d309b067636a08881d6b67a262c33a35b7103228a8d"))
+ (2093000, uint256S("0x00000005cd8ad1d36831cb219e751d6fdea3c1ef5984106d4267181574abbb7a"))
+ (2094000, uint256S("0x000000084ecece471b2a7c20058821bc00507948c4e2ddda440fbbff20e8f9d0"))
+ (2095000, uint256S("0x00000004febb4db9b9a83945d1e876e6a1df57e9d4b7c7be522c313ca14b0684"))
+ (2096000, uint256S("0x00000000c6b4ad716b1ecdf2941ac5951566349430f4f65ab30a19d4683e06fe"))
+ (2097000, uint256S("0x0000000a69188059da26fcda56fda6616b6a7b910d81fbac0bed9cd2788fe11d"))
+ (2098000, uint256S("0x000000000964c0376b72fd3475fe3e20ebc0f43269d7c7be0c1b3e1ae3b084a2"))
+ (2099000, uint256S("0x000000075489657e7019ba875720ba133610cccbd69873b2409d293973878de6"))
+ (2100000, uint256S("0x000000048bce0d172dc7f21cfdd89cebc1dc8fda33b53ccd483fa77465601469"))
+ (2101000, uint256S("0x0000000d17a5f6802150f5f317617439d1406c1a6c9905360d5b8936f1235bf1"))
+ (2102000, uint256S("0x0000000a2e1dab28ba0b9d381c2a1dfc503dfc3ece2e7382efeef7fc0a9114ee"))
+ (2103000, uint256S("0x0000000af3728cb8cfd44ebba3ad4371affc1b77dded8c1016f6aa1e7533620f"))
+ (2104000, uint256S("0x00000004d3121b000e5fdfb36181921f290f9b0e88bca5e7db73edfe39ad4389"))
+ (2105000, uint256S("0x0000001578e4d7efa6c5071cce3bcb6c313dc20024605fc68ec52373940e2503"))
+ (2106000, uint256S("0x000000091602e3e0e6f2696b637f278878aa9df54b5da697623d3ff15758f530"))
+ (2107000, uint256S("0x0000000b40c4b2d15563ea4a4526618bc7456ae7af75b43564ef0cec35ad938f"))
+ (2108000, uint256S("0x0000000682e77053c4d4bcd7b6c2104e4e3c194154ef857cd05115f02681d81f"))
+ (2109000, uint256S("0x000000035a9bbeba87ba109903ffee9c71fd62a0a6395f1696490ea674e5a658"))
+ (2110000, uint256S("0x0000000547f13c557983f66c18ab0db1a64c9a8892dd84127e04025b5335a816"))
+ (2111000, uint256S("0x00000011342622886386272683f28994966657f559c5a39dbef9aef6c14314f3"))
+ (2112000, uint256S("0x0000000446d090e0f478bcb7d90cbb15142eb585c31229a433f8fb1470252be2"))
+ (2113000, uint256S("0x0000000db1383e1c4ca8e5f29136deb3f65ff989acbca44c94cdd4d431d6e40d"))
+ (2114000, uint256S("0x00000001574baeb58d2999e2ce95b0049ba0d680cc68caf2ee644abe05d17c58"))
+ (2115000, uint256S("0x0000000b784255ee9900040a759883da9cb04d29fd96f2b2bc8fa777377666e3"))
+ (2116000, uint256S("0x00000002598ad558cd93fbc11106615d187c227d80f4b9e30ba480c264bd2345"))
+ (2117000, uint256S("0x00000009d3b9dbbd63b11aa254b53421d55c864578617c5a57addb7b2b058f51"))
+ (2118000, uint256S("0x0000001083f791fdb1d314ac096a510e829d849c51ecfd07b05a97beca0fdc9f"))
+ (2119000, uint256S("0x0000000ef2775f3449c5f473744e92018681e9de74c59695457d4aa6fdd6d74c"))
+ (2120000, uint256S("0x000000044205e969e5d5ce1f297de9fa11fa23e0407dd28b852d48ab5e45f1da"))
+ (2121000, uint256S("0x00000010b04548479daf16dfa9c8e3c0e5b4e5b29876cb8a307d2e407aa3e5ab"))
+ (2122000, uint256S("0x000000052cd0199a56b4f840e6cd06afc7bae1fe5c6b060ad56b25e60037acbb"))
+ (2123000, uint256S("0x000000059972a7dde8caf40947c0e6fad1e85558e6da1e444be6c246589ed617"))
+ (2124000, uint256S("0x00000009eb2cbc8df55758e60fe06d9b38e57e1408caa4e03724519cf2639e7e"))
+ (2125000, uint256S("0x0000000118e98419f9b56c890c77e53298fa478bf0adaa1cd4e9617f575d442c"))
+ (2126000, uint256S("0x0000001168a734074aaeaa042800ebfd7a1283e0fea5ec8a688beed2822983e4"))
+ (2127000, uint256S("0x00000006dc5056e1e4ecd42ab4247ad9aeeb78313d5b00c14038a91c4c18b6dd"))
+ (2128000, uint256S("0x00000000310924a85b39bbd14bcb151d11e450bd69af772276509e007d93bf7e"))
+ (2129000, uint256S("0x00000014a0d1ad70f7e8b9444143cea92f0bbbba8f3490a502ccb26169acc3c3"))
+ (2130000, uint256S("0x000000077bafacdc4d2276cbd5e97b7f303c98570932991935d947c2bdcf6d0e"))
+ (2131000, uint256S("0x0000000af47253f4aea86c4af51be4b34f5aba1c454aa41098c41d84793cfb5f"))
+ (2132000, uint256S("0x0000000d8b0fd244174731a7f03a399597be4b27ea30f82711c5ce5a7b4cb778"))
+ (2133000, uint256S("0x000000096f73526a734ef98d58ceaf9839095180f96b27aa0b68f8e9bc395cc1"))
+ (2134000, uint256S("0x000000135654421fab135971b1654a79dddb59195ccc060a5b19ba80beef5955"))
+ (2135000, uint256S("0x0000000a93e5abb450f1f1aded4f38b808dfd038fd72e4c20b697aa98fa9cfdc"))
+ (2136000, uint256S("0x0000000408c0887a70fe0fa4a43c477426589ce4f552db7d176eb140a9a30fcc"))
+ (2137000, uint256S("0x0000000464a46aa2d5f22f3f4a39803aad1084a22dccd1fcb83f08e29d3e28b2"))
+ (2138000, uint256S("0x000000064a011e9ecef25946fe33f9c18371e051eb246cd3621090f8139ced91"))
+ (2139000, uint256S("0x000000082fa6fc9c1a92ebf29a0ba2eadccd20508a1db83619357894062a5aff"))
+ (2140000, uint256S("0x0000000460f855e76c4d739a4023d17fe1ac6376614a1764141770edb1d687c8"))
+ (2141000, uint256S("0x0000000481247aaabde662576ee0178a48a4f25ddf188eebc95db4ce2c578bb2"))
+ (2142000, uint256S("0x00000011b7aa00475cf8620ccb296970536e0a7e3cd928d5ed05020f95923ff7"))
+ (2143000, uint256S("0x00000004a48dfe4fdf0eec5f130563783c60e56115226c5febfa0a5201ba7b25"))
+ (2144000, uint256S("0x00000013dad0ea792083834d4e02a711a738ccc4f51955fca5852b151e469f05"))
+ (2145000, uint256S("0x000000054ce9776cbf4d7d957865c0b3aed4a6f466459b5f2f395d2b2a2da6f2"))
+ (2146000, uint256S("0x00000001e0aafae6d61db4d7fb1441e1ce8381a3243e8904ff453857d0b3456c"))
+ (2147000, uint256S("0x000000084f0c9ba9b8490ed271747910a4053bc09ec4ec74f399fe7262e822dd"))
+ (2148000, uint256S("0x00000003f7b29fb734195f4ea924862811300096a17367c0334bf74e2f483fdd"))
+ (2149000, uint256S("0x00000002586cd17b50a802cf1a37cbf0ae8c4f165a8b4bb1dbbf0f434832e44f"))
+ (2150000, uint256S("0x0000000234336fc37adb386d4d3ba166106b1888f6b15210b476778e1cdba617"))
+ (2151000, uint256S("0x0000000abd4237926addc45f8aa8e2e8e3dcecc8f9a065538a0d8add0a41adcd"))
+ (2152000, uint256S("0x00000004063fbe8f4cb1c212ebe3c4655744728091e92e219b245fcd5a0c572a"))
+ (2153000, uint256S("0x000000015299ea3f0bbac8c1e87774255918e60405de053e01f468605169721a"))
+ (2154000, uint256S("0x000000009f685faddbdded0d7aa0360e5fd0434672ec0bd7a496ef14f300d9c6"))
+ (2155000, uint256S("0x00000004e2bab8860d90b57285c78d521d0a67826c6b59ee53907a97ebc3e98b"))
+ (2156000, uint256S("0x0000000365fc20fedaf53e4eb761e8b3efa219d6bb5eee72b569d49302b098f6"))
+ (2157000, uint256S("0x0000000ee0631ed6e44c0ad4e2ab99732088a92b17b946afd6782faf8c1039be"))
+ (2158000, uint256S("0x0000000f64d288fff1628defcbfc0ca5c41a45cdffad7ac8b425eb688645090c"))
+ (2159000, uint256S("0x0000000b4b3609b61df88081218a64157546e78be3125f02e0fb9a2ad7dc6fe0"))
+ (2160000, uint256S("0x0000000c658223e9d6a2b966022dfadc8e6b4a54e04710d2ebcded687cead660"))
+ (2161000, uint256S("0x0000001159a41488ff78d7bedca36a0fd79b841dab0e8ab3904d82860baa8b8a"))
+ (2162000, uint256S("0x00000011fecb4f33f5707ebb37badaf7ff933f117e892f58782b4a9a5f3baa63"))
+ (2163000, uint256S("0x0000000f5797242276a9a7a8cd70d8efbc6c225fcec4cb733ddec3c763ca42e4"))
+ (2164000, uint256S("0x0000000886bfacf5c79a53fbd9533b7af09f22e1a340284f9cff2644fe0b4b6b"))
+ (2165000, uint256S("0x0000000ba2f63317611c67307a58afc3f536568cc8a26c3e1a7c96bfeae50d04"))
+ (2166000, uint256S("0x0000000e2cf36af435818846e670e89b01c4204520108b24fd8b7138da9a80fc"))
+ (2167000, uint256S("0x000000015fcddcda4bf66d26410b003fe1f117701d72a85a2ec308db6a88cacc"))
+ (2168000, uint256S("0x000000129c923c361fd4caeee0bfabef70c5358489ca3a64ccb2c0fb74c2d759"))
+ (2169000, uint256S("0x0000000246c65f7233c3319283c4600600ba6bec6ecf33113552762f8bcc82ee"))
+ (2170000, uint256S("0x0000000ac527711a96daa55c309ac6090e0c5e47f4dc43720fffaf3167d9385a"))
+ (2171000, uint256S("0x000000065376b6bdc5dc0bc108400a4749afddde1c1757c17f11476c1d612220"))
+ (2172000, uint256S("0x00000006ca134d446c4e8cbbd1f8c3fa0276a12dfd5419ac83797e01e87a7836"))
+ (2173000, uint256S("0x00000009009d3bb8f190afc32b77661e0081d2c3f5d7e5e3377b4bb53d5c1a9b"))
+ (2174000, uint256S("0x00000010feb7099c8e0a2f0582c653d131123ca678c11965886b7f283438d5b4"))
+ (2175000, uint256S("0x00000011dbb4610eadd4991bd7a29360d2e73e98ac053445639fa63d87df9364"))
+ (2176000, uint256S("0x000000085561ce48c0eac05bc168bf5eb4eec888795be1ce26ad10e9543b9f66"))
+ (2177000, uint256S("0x000000095e48492726b15e24aa78ada0ec58a06f3d8c6588e9d732f377748596"))
+ (2178000, uint256S("0x0000001219fe5ea9287939ddd0e6e5e2f8ad4d6556a52002ad5074de9f53227d"))
+ (2179000, uint256S("0x00000010e3820efc9a0adc4ef3871f03f2f4722c982a77b30f757b3ef9975cb2"))
+ (2180000, uint256S("0x000000081877c0925c42cb866f4100f49eeb17af7ce3527744e10d519a35dc90"))
+ (2181000, uint256S("0x0000000cea4a29dcf89dc3d699ffc9e04aef2e923f4b75ba9af5c89ebffdb9d7"))
+ (2182000, uint256S("0x000000018920865bb9ea4a7458fec9e3b0e9f28c9bef25488ce444f08c58a062"))
+ (2183000, uint256S("0x0000001353c7fdf1416a0d361dcbe669de666166fe645188a26eea4c78ddf03a"))
+ (2184000, uint256S("0x00000007dbbe33596b119695ebd530869646c32e322b5fcd377d48bc31fd8c2b"))
+ (2185000, uint256S("0x000000198ffa20fcd5fcc98d5242f43ed1fad39015885cafd817870237420ee2"))
+ (2186000, uint256S("0x0000000914848d7c0720bf947010055b0a99b1854e305ca5146658181493d4bc"))
+ (2187000, uint256S("0x00000005b671f40e14f57ae18eb2aef37c233be1f6958a8deb25897b0755d88b"))
+ (2188000, uint256S("0x00000010ff6edb5e128fb6c729fdca152931cdd2c85161770833ed0a4021556f"))
+ (2189000, uint256S("0x0000001790079fc71b5cf4c9e28e8c4f7c2ed68db86618fdab844ed92f49869a"))
+ (2190000, uint256S("0x0000001ac858c2579fe6804e17c9a4ffac6f87ad218a42e0023d4f4a937d256a"))
+ (2191000, uint256S("0x0000000657e488ff574b139465409d783d5e7b12275b9a904adc4bdcbec555a6"))
+ (2192000, uint256S("0x0000000f5d7531d2be768b6b077cc1981f3da77065ddac9019c376abd771d2bf"))
+ (2193000, uint256S("0x0000002bf66b350408816e2dcc6166a7438786d28b5dc96eb2be8251c9edd915"))
+ (2194000, uint256S("0x00000006bf224770c8ed65aba45a66e04a484d4e11718586ca367e76d23570c1"))
+ (2195000, uint256S("0x0000000d1a303359ca7cfff975ea261045650efae95a58ec942ae6b65418760d"))
+ (2196000, uint256S("0x0000000c10de971b747e2d8dcf0b435ad911c5c4e650c22c2926317f9737f958"))
+ (2197000, uint256S("0x000000147f6a742c2a6177e3d265a0ebda14d8b065ccb31979e5a98d886136eb"))
+ (2198000, uint256S("0x000000104a69691ae8661a505be930491f1f8e778b66f236fd82238f1ecc55b5"))
+ (2199000, uint256S("0x0000001d15e004f42cb05c998b9bc4dc523be01d38b05b70d6247b7b273b3b1a"))
+ (2200000, uint256S("0x00000008cfb7b2ee0a5efbcaf54fb9343fd45aa0fc15fdf9f793a9ec84b1b3d8"))
+ (2201000, uint256S("0x00000014ffb9bacf3a7cce9172c18acaefb7e37be1622c058239c3903a41b1fb"))
+ (2202000, uint256S("0x000000199098587a246d8326b2bcd3edb13f9a5929164973f3dba9aafc7e2db1"))
+ (2203000, uint256S("0x000000003bbc88abdde6242b28a8f7ad7c80a0a4b2b02f7c13f1e851a87c0531"))
+ (2204000, uint256S("0x0000000b9454d46cdc35e507b9aa0b98f8c6c98bc7473281a5925efa25e7d9f7"))
+ (2205000, uint256S("0x00000003c6742a5eb51b71732d4ad13bddabe1a22a0f9bb1879c726853db4ea0"))
+ (2206000, uint256S("0x00000010ee207e0218f281066a8cb3a208540766a34818d001859a4ff21a9442"))
+ (2207000, uint256S("0x00000011fdbf6ed34b05e960036e4d1bd5087cb10a3fb37edad1847403d0a5fc"))
+ (2208000, uint256S("0x00000017fd1de616ff467b5a6ec399703f232dd5e20021f0325df4cd5066047e"))
+ (2209000, uint256S("0x0000001b0d85a780bc6c1fcf95d775ddf7d11930b8a7d0f30c76e17fe5b91f08"))
+ (2210000, uint256S("0x000000320ac1d0412b54f38d926afd63830f91fcbcc06869b9970f53804c8b05"))
+ (2211000, uint256S("0x0000000e89eb1167ff72252d64de56463e8bb89a546a318100bc1e09b40c75ed"))
+ (2212000, uint256S("0x0000000929563985b806ac74a296d19869e5e74942e73a8769da3380b0be3769"))
+ (2213000, uint256S("0x0000000268c366b226e82917d23c89eebfab13d226388362220b0052cefeda9d"))
+ (2214000, uint256S("0x0000000667ffb02f6dfceba778614abdbf5ae11b73ce4d8e5524d3e77b6d1bf0"))
+ (2215000, uint256S("0x00000009c0432726c9666371c3834e5b500b38caf41080b68869cfbb12af6dc2"))
+ (2216000, uint256S("0x0000000b4a5c376d4fc524ad456c90147206bbd445509be5a191ad9979c51f67"))
+ (2217000, uint256S("0x0000000563e32e4235ab5694177fc53923b9b742d0cb8b6dd654a1b45b5b9e9f"))
+ (2218000, uint256S("0x00000002e16de2a52496ac6caff3454fcc8dda9291b042607ab5b8cb4eb06149"))
+ (2219000, uint256S("0x00000003f615c3a50807128b9eb71dd357782edc581b923f0d97ecb169f00744"))
+ (2220000, uint256S("0x00000005a5d40c3f2239ceab163c6b0065b5c8eb98608a67943c42a7d0efdf06"))
+ (2221000, uint256S("0x000000052f90cdbad630bfc9639680fa20fd40af4448d6222b832b1496f9d611"))
+ (2222000, uint256S("0x0000000a114845b86115b2b7e83999f8745d795b3e712481dd8fcad6b017ad6c"))
+ (2223000, uint256S("0x0000000671f202549cf64821f6a7f9a722cf79054fd415af2c38477ed11f4509"))
+ (2224000, uint256S("0x00000006f8d21a9b3ffca12033f5e27d7a4b45c6254cd3bcfa0a6a7e252ffbdc"))
+ (2225000, uint256S("0x0000000e97a31cd82ec650d23de1d6a505ebc6f752b1bedb9f9295be69840212"))
+ (2226000, uint256S("0x0000000a77b14d5e8aa98dc37bab028d11c999478a344dc2d9eb4db350a8fffb"))
+ (2227000, uint256S("0x0000000886cde6f06d72666d7ed1d85866f8bea788102932c973fe39af80a74a"))
+ (2228000, uint256S("0x00000009af43eb0ed51d153a3462b65d09b4730c277d528016852980e4168752"))
+ (2229000, uint256S("0x00000003f464599aa6386056de225d1cbef006b8da9c0d27cc6fa779089868ca"))
+ (2230000, uint256S("0x0000000c0bd50433b89655bf283daf43856db8d822e996f614397c8b1c393e38"))
+ (2231000, uint256S("0x00000003254820b91ccca295afaa3c9562ec15032953d5ad0782c95f7d4da9fb"))
+ (2232000, uint256S("0x0000000349afb4e98ae708f7dff039c54b1446da2664ad0dddd5f5b94755cbfc"))
+ (2233000, uint256S("0x0000000297526918a57fb1a21b70cd8ed1265547d4a61ecd57302c29d16aba1c"))
+ (2234000, uint256S("0x00000003288ea064a3f6ddc603de61bdb4c0ccfee2a70b621a7fe95f9ad35a8c"))
+ (2235000, uint256S("0x0000000b8a88cee5ac71e4b61ace898cafe7c895c9bf0b5db00b9d71fda173d7"))
+ (2236000, uint256S("0x000000056051307f0119d828d8d621b34ef6f60a06694c569c669ead97b9a00d"))
+ (2237000, uint256S("0x000000001f5aa9e9dbb3be2b01a4ab0b108b85fd375f23a0452930126a00c21c"))
+ (2238000, uint256S("0x00000002daa24ab7db17601826843cef57562ccc1aa80a692daf45435d816cca"))
+ (2239000, uint256S("0x0000000a9a4283412f076a0e1d36e1e02571468ff12d06c0d075e1dfa569af8c"))
+ (2240000, uint256S("0x00000008b78c49c1d514ce9cc583ec04c36023911ed7772d1cf0c50b5ce1f8c8"))
+ (2241000, uint256S("0x0000000cbb3151b62023e1cafa4476d7bf2cf34c13229f3ba510053182133ef2"))
+ ,(int64_t) 1750938666, // time of last checkpointed block
+ (int64_t) 3149424, // total txs
+ (double) 1254 // txs in the last day before block 2241283
};
} else {
- // all other HSC's with no checkpoints
+ // all other HAC's with no checkpoints
checkpointData = //(Checkpoints::CCheckpointData)
{
boost::assign::map_list_of
diff --git a/src/chainparamsseeds.h b/src/chainparamsseeds.h
index dc2b4948c..e562dce9e 100644
--- a/src/chainparamsseeds.h
+++ b/src/chainparamsseeds.h
@@ -11,19 +11,22 @@
// Each line contains a BIP155 serialized address.
//
static const uint8_t chainparams_seed_main[] = {
- 0x01,0x04,0x5b,0xd0,0x7f,0x51,0x00,0x00, // 91.208.127.81
- 0x01,0x04,0x57,0xfb,0x4c,0xa6,0x00,0x00, // 87.251.76.166
- 0x01,0x04,0x2d,0x52,0x44,0xe9,0x00,0x00, // 45.82.68.233
- 0x01,0x04,0x57,0xfb,0x4c,0x21,0x00,0x00, // 87.251.76.33
- 0x01,0x04,0xb2,0xfa,0xbd,0x8d,0x00,0x00, // 178.250.189.141
+ 0x01,0x04,0x67,0x45,0x80,0x94,0x00,0x00, // 103.69.128.148
+ 0x01,0x04,0xc2,0x1d,0x64,0xb3,0x00,0x00, // 194.29.100.179
+ 0x01,0x04,0x2d,0x84,0x4b,0x45,0x00,0x00, // 45.132.75.69
+ 0x01,0x04,0xaa,0xcd,0x27,0x27,0x00,0x00, // 170.205.39.39
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
- 0x04,0x20,0x3d,0x24,0x7a,0xee,0xf5,0x39,0x20,0x7e,0x69,0x92,0xda,0xc7,0xa6,0x9f,0xbd,0xeb,0x29,0x21,0x20,0x93,0x52,0x03,0xf3,0x60,0x41,0xfc,0xb8,0xf9,0x06,0x29,0x96,0x24,0x00,0x00, // hushv3xvheqh42ms3ld2nh555muscietkib7gycb7s4psbrjsysfywqd.onion
- 0x02,0x10,0x2a,0x0c,0xb6,0x41,0x06,0xf1,0x00,0x34,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x00,0x00, // 2a0c:b641:6f1:34::2
- 0x02,0x10,0x2a,0x0c,0xb6,0x41,0x06,0xf1,0x00,0x0c,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x00,0x00, // 2a0c:b641:6f1:c::2
+ 0x01,0x04,0xb2,0xfa,0xbd,0x8d,0x00,0x00, // 178.250.189.141
+ 0x04,0x20,0x0e,0x86,0xb6,0xfd,0x96,0xfe,0x06,0xda,0x39,0xeb,0x97,0x39,0xc9,0xd1,0x17,0xa2,0x4e,0x2b,0x75,0x4d,0xeb,0xb5,0xa1,0x34,0x1e,0x34,0x0a,0xcb,0x68,0xab,0xf0,0xe2,0x00,0x00, // b2dln7mw7ydnuopls444tuixujhcw5kn5o22cna6gqfmw2fl6drb5nad.onion
+ 0x04,0x20,0x1c,0x96,0x10,0x03,0xa6,0xa4,0xfa,0xa0,0x3e,0x13,0x1f,0x38,0xf0,0x9b,0xdd,0x9b,0xd7,0xdc,0x0e,0x40,0x61,0x71,0xed,0x1d,0x21,0x58,0xce,0x59,0x55,0x5e,0xe4,0x25,0x00,0x00, // dslbaa5gut5kapqtd44pbg65tpl5ydsamfy62hjbldhfsvk64qs57pyd.onion
+ 0x04,0x20,0xac,0xa0,0x3a,0x31,0xa7,0xea,0x8e,0x90,0xc7,0x2b,0xbb,0x89,0x41,0x05,0x48,0xa0,0x10,0x29,0x8f,0x38,0x16,0xc9,0x94,0xbe,0xef,0x7e,0x9e,0x7d,0x98,0xb6,0x76,0x9f,0x00,0x00, // vsqdumnh5khjbrzlxoeucbkiuaictdzyc3ezjpxpp2ph3gfwo2ptjmyd.onion
+ 0x02,0x10,0x2a,0x0c,0xb6,0x41,0x06,0xf1,0x01,0x8e,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x00,0x00, // 2a0c:b641:6f1:18e::2
+ 0x02,0x10,0x24,0x06,0xef,0x80,0x00,0x03,0x12,0x69,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00, // 2406:ef80:3:1269::1
+ 0x02,0x10,0x24,0x06,0xef,0x80,0x00,0x02,0x3b,0x59,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00, // 2406:ef80:2:3b59::1
+ 0x02,0x10,0x24,0x06,0xef,0x80,0x00,0x01,0x14,0x6e,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00, // 2406:ef80:1:146e::1
+ 0x02,0x10,0x24,0x06,0xef,0x80,0x00,0x04,0x21,0x32,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00, // 2406:ef80:4:2132::1
0x05,0x20,0xfb,0xa8,0xca,0x3d,0xf4,0xc9,0x83,0x95,0xa8,0x07,0x05,0x6f,0xf8,0x46,0x69,0x6d,0x42,0x75,0x22,0xe9,0x80,0xd8,0x43,0x7c,0xbe,0x29,0xda,0x33,0x14,0xf9,0xfb,0x17,0x00,0x00, // 7oumuppuzgbzlkahavx7qrtjnvbhkixjqdmeg7f6fhndgfhz7mlq.b32.i2p
};
diff --git a/src/clientversion.h b/src/clientversion.h
index 1dd5c958c..c149a7692 100644
--- a/src/clientversion.h
+++ b/src/clientversion.h
@@ -1,6 +1,6 @@
// Copyright (c) 2009-2014 The Bitcoin Core developers
// Copyright (c) 2016-2017 The Zcash developers
-// Copyright (c) 2016-2024 The Hush developers
+// Copyright (c) 2016-2025 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
// What happened to the SuperNET developers, who cared about privacy?
@@ -30,7 +30,7 @@
// Must be kept in sync with configure.ac , ugh!
#define CLIENT_VERSION_MAJOR 3
#define CLIENT_VERSION_MINOR 10
-#define CLIENT_VERSION_REVISION 2
+#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/coins.cpp b/src/coins.cpp
index 82933f026..1e5bff4e3 100644
--- a/src/coins.cpp
+++ b/src/coins.cpp
@@ -557,17 +557,10 @@ CAmount CCoinsViewCache::GetValueIn(int32_t nHeight,int64_t *interestp,const CTr
CAmount value,nResult = 0;
if ( interestp != 0 )
*interestp = 0;
- //if ( tx.IsCoinImport() )
- // return GetCoinImportValue(tx);
if ( tx.IsCoinBase() != 0 )
return 0;
for (unsigned int i = 0; i < tx.vin.size(); i++)
{
- //if (tx.IsPegsImport() && i==0)
- //{
- // nResult = GetCoinImportValue(tx);
- // continue;
- //}
value = GetOutputFor(tx.vin[i]).nValue;
nResult += value;
}
@@ -599,7 +592,7 @@ bool CCoinsViewCache::HaveInputs(const CTransaction& tx) const
{
if (!tx.IsMint()) {
for (unsigned int i = 0; i < tx.vin.size(); i++) {
- if (tx.IsPegsImport() && i==0) continue;
+ //if (tx.IsPegsImport() && i==0) continue;
const COutPoint &prevout = tx.vin[i].prevout;
const CCoins* coins = AccessCoins(prevout.hash);
if (!coins || !coins->IsAvailable(prevout.n)) {
@@ -621,7 +614,7 @@ double CCoinsViewCache::GetPriority(const CTransaction &tx, int nHeight) const
// use the maximum priority for all (partially or fully) shielded transactions.
// (Note that coinbase transactions cannot contain Sapling shielded Spends or Outputs.)
- if (tx.vShieldedSpend.size() > 0 || tx.vShieldedOutput.size() > 0 || tx.IsCoinImport() || tx.IsPegsImport()) {
+ if (tx.vShieldedSpend.size() > 0 || tx.vShieldedOutput.size() > 0 ) {
return MAX_PRIORITY;
}
diff --git a/src/crypto/common.h b/src/crypto/common.h
index bfc43d8bc..64c144848 100644
--- a/src/crypto/common.h
+++ b/src/crypto/common.h
@@ -1,4 +1,3 @@
-// Copyright (c) 2016-2024 The Hush developers
// Copyright (c) 2014 The Bitcoin Core developers
// Copyright (c) 2016-2024 The Hush developers
// Released under the GPLv3
diff --git a/src/dragonxd b/src/dragonxd
index 7e6320ba5..076ce94dc 100755
--- a/src/dragonxd
+++ b/src/dragonxd
@@ -13,4 +13,4 @@ cd $DIR
SEEDNODE=176.126.87.241
# Remember Remember the 5th November for freedom of speech is not free!!
-./hush-smart-chain -ac_name=DRAGONX -ac_algo=randomx -ac_halving=3500000 -ac_reward=300000000 -ac_blocktime=36 -ac_private=1 -addnode=$SEEDNODE $@
+./hush-arrakis-chain -ac_name=DRAGONX -ac_algo=randomx -ac_halving=3500000 -ac_reward=300000000 -ac_blocktime=36 -ac_private=1 -addnode=$SEEDNODE $@
diff --git a/src/hush-smart-chain b/src/hush-arrakis-chain
similarity index 100%
rename from src/hush-smart-chain
rename to src/hush-arrakis-chain
diff --git a/src/hush-smart-chain.bat b/src/hush-arrakis-chain.bat
similarity index 100%
rename from src/hush-smart-chain.bat
rename to src/hush-arrakis-chain.bat
diff --git a/src/hush/tlsmanager.cpp b/src/hush/tlsmanager.cpp
index ee1329dd7..8b03445ce 100644
--- a/src/hush/tlsmanager.cpp
+++ b/src/hush/tlsmanager.cpp
@@ -10,6 +10,8 @@
#include "tlsmanager.h"
#include "utiltls.h"
+extern bool ShutdownRequested();
+
using namespace std;
// store our preferred cipherlist so we can use it for debug/etc later on
std::string TLS_CIPHERLIST;
@@ -85,6 +87,10 @@ int TLSManager::waitFor(SSLConnectionRoutine eRoutine, SOCKET hSocket, WOLFSSL*
while (true)
{
+ if(ShutdownRequested()) {
+ LogPrintf("%s: shutdown requested, exiting\n", __func__);
+ return retOp;
+ }
// clear the current thread's error queue
wolfSSL_ERR_clear_error();
diff --git a/src/hush_bitcoind.h b/src/hush_bitcoind.h
index 57eb1c8f3..218f09db7 100644
--- a/src/hush_bitcoind.h
+++ b/src/hush_bitcoind.h
@@ -24,6 +24,19 @@
#include "cc/CCinclude.h"
#include "sietch.h"
+// This is the address for pubkey = 0x000000000000000000000000000000000 (33 bytes)
+// Funds sent to a burn address can never be spent because the pubkey is invalid
+// because it is not a point on the elliptic curve we use (secp256k1, like all other
+// Bitcoin-derived codebases). secp256k1 is defined by the equation y^2 = x^3 + 7 .
+// Using pubkey=0 also implies privkey=0 and the (pubkey,privkey) pair are the same
+// as the (x,y) pair in the equation. If you plug in (0,0) to the equation you get
+// 0^2 = 0^3 + 7 or 0=7 which is false. This means that (0,0) is not a valid point
+// on the secp256k1 curve. Therefore there is no valid signature to spend the funds
+// sent to the burn address, because a valid signature must use a valid point on the
+// elliptic curve being used. For these reasons, we can prove that the burn address
+// receives funds which can never be spent.
+#define BURN_ADDRESS "RD6GgnrMpPaTSMn8vai6yiGA7mN4QGPVMY"
+
int32_t hush_notaries(uint8_t pubkeys[64][33],int32_t height,uint32_t timestamp);
int32_t hush_findnotary(int32_t *numnotariesp,uint8_t *pubkey33,int32_t height,uint32_t timestamp);
int32_t hush_voutupdate(bool fJustCheck,int32_t *isratificationp,int32_t notaryid,uint8_t *scriptbuf,int32_t scriptlen,int32_t height,uint256 txhash,int32_t i,int32_t j,uint64_t *voutmaskp,int32_t *specialtxp,int32_t *notarizedheightp,uint64_t value,int32_t notarized,uint64_t signedmask,uint32_t timestamp);
@@ -948,7 +961,7 @@ CAmount GetBlockSubsidy(int nHeight, const Consensus::Params& consensusParams);
// This function defines the Hush Founders Reward (AKA Dev Tax)
// 10% of all block rewards go towards Hush core team
// If you do not like this, you are encouraged to fork the chain
-// or start your own Hush Smart Chain: https://git.hush.is/hush/hush-smart-chains
+// or start your own Hush Arrakis Chain: https://git.hush.is/hush/hush-arrakis-chains
// HUSH supply curve cannot be exactly represented via CLI args, so we do it ourselves.
// You specify the BR, and the FR % gets added so 10% of 12.5 is 1.25
// but to tell the AC params, I need to say "11% of 11.25" is 1.25
@@ -1798,15 +1811,15 @@ int64_t hush_newcoins(int64_t *zfundsp,int32_t nHeight,CBlock *pblock)
{
for (j=0; j %s\n",dstr(tx.vout[j].nValue),CBitcoinAddress(address).ToString().c_str());
}
script = (uint8_t *)&tx.vout[j].scriptPubKey[0];
if ( script == 0 || script[0] != 0x6a )
{
- if ( ExtractDestination(tx.vout[j].scriptPubKey,address) != 0 && strcmp("RD6GgnrMpPaTSMn8vai6yiGA7mN4QGPVMY",CBitcoinAddress(address).ToString().c_str()) != 0 )
+ if ( ExtractDestination(tx.vout[j].scriptPubKey,address) != 0 && strcmp(BURN_ADDRESS,CBitcoinAddress(address).ToString().c_str()) != 0 )
voutsum += tx.vout[j].nValue;
}
}
diff --git a/src/hush_defs.h b/src/hush_defs.h
index 25ac80f22..720fa70b5 100644
--- a/src/hush_defs.h
+++ b/src/hush_defs.h
@@ -63,7 +63,7 @@ const uint32_t nHushHardforkHeight4 = 1605555;
const uint32_t nHushHardforkTimestamp = 1580303652; // Jan 29nd 1pm GMT
const uint32_t nHushHardforkTimestamp2 = 1594425600; // Jul 11th 12a GMT
-// Used by HSCs
+// Used by HACs
static const uint32_t HUSH_SEASON_TIMESTAMPS[NUM_HUSH_SEASONS] = {1525132800, 1563148800, nHushHardforkTimestamp, nHushHardforkTimestamp2, nHushHardforkTimestamp2*5, nHushHardforkTimestamp2*6, nHushHardforkTimestamp2*7};
// Used by HUSH3+TUSH
diff --git a/src/hush_globals.h b/src/hush_globals.h
index d31846ee9..128d719da 100644
--- a/src/hush_globals.h
+++ b/src/hush_globals.h
@@ -50,6 +50,8 @@ int32_t HUSH_INSYNC,HUSH_LASTMINED,prevHUSH_LASTMINED,HUSH_CCACTIVATE;
std::string NOTARY_PUBKEY,ASSETCHAINS_NOTARIES,ASSETCHAINS_OVERRIDE_PUBKEY,DONATION_PUBKEY,ASSETCHAINS_SCRIPTPUB,NOTARY_ADDRESS,ASSETCHAINS_SELFIMPORT,ASSETCHAINS_CCLIB;
uint8_t NOTARY_PUBKEY33[33],ASSETCHAINS_OVERRIDE_PUBKEY33[33],ASSETCHAINS_OVERRIDE_PUBKEYHASH[20],ASSETCHAINS_PUBLIC,ASSETCHAINS_PRIVATE,ASSETCHAINS_TXPOW,ASSETCHAINS_MARMARA;
int8_t ASSETCHAINS_ADAPTIVEPOW;
+uint8_t ASSETCHAINS_BURN = 0;
+uint32_t ASSETCHAINS_MINOPRETURNFEE = 0;
std::vector Mineropret;
std::vector vAllowListAddress;
char NOTARYADDRS[64][64];
diff --git a/src/hush_nSPV_fullnode.h b/src/hush_nSPV_fullnode.h
index 2cf9cc9f5..f0f2176cf 100644
--- a/src/hush_nSPV_fullnode.h
+++ b/src/hush_nSPV_fullnode.h
@@ -233,64 +233,6 @@ public:
DefaultCCChecker() { }
virtual bool checkCC(uint256 txid, const std::vector &vouts, int32_t nvout, uint8_t evalcode, std::string funcids, uint256 filtertxid)
{
- CScript opret, dummy;
- std::vector< vscript_t > vParams;
- vscript_t vopret;
-
- if (nvout < vouts.size())
- {
- // first check if it is cc vout
- if (vouts[nvout].scriptPubKey.IsPayToCryptoCondition(&dummy, vParams))
- {
- // try to find cc opret
- if (vParams.size() > 0)
- {
- COptCCParams p(vParams[0]); // parse vout data
- if (p.vData.size() > 0)
- {
- vopret = p.vData[0]; // get opret data
- }
- }
- // if no cc opret check last vout opret
- if (vopret.size() == 0)
- {
- GetOpReturnData(vouts.back().scriptPubKey, vopret);
- }
- if (vopret.size() > 2)
- {
- uint8_t opretEvalcode, opretFuncid;
- uint256 opretTxid;
- bool isEof = true;
- bool isCreateTx = false;
-
- // parse opret first 3 fields:
- bool parseOk = E_UNMARSHAL(vopret,
- ss >> opretEvalcode;
- ss >> opretFuncid;
- if (funcids.size() > 0 && opretFuncid == funcids[0]) // this means that we check txid only for second+ funcid in array (considering that the first funcid is the creation txid itself like tokens)
- {
- isCreateTx = true;
- }
- else
- {
- ss >> opretTxid;
- isCreateTx = false;
- }
- isEof = ss.eof(); );
-
- opretTxid = revuint256(opretTxid);
- std::cerr << __func__ << " " << "opretEvalcode=" << opretEvalcode << " opretFuncid=" << (char)opretFuncid << " isCreateTx=" << isCreateTx << " opretTxid=" << opretTxid.GetHex() << std::endl;
- if( parseOk /*parseOk=true if eof reached*/|| !isEof /*more data means okay*/)
- {
- if (evalcode == opretEvalcode && std::find(funcids.begin(), funcids.end(), (char)opretFuncid) != funcids.end() &&
- (isCreateTx && filtertxid == txid || !isCreateTx && filtertxid == opretTxid))
- {
- return true;
- }
- }
- }
- }
- }
return false;
}
};
@@ -352,69 +294,9 @@ int32_t NSPV_mempoolfuncs(bits256 *satoshisp,int32_t *vindexp,std::vector vopret; char destaddr[64];
*vindexp = -1;
memset(satoshisp,0,sizeof(*satoshisp));
- /*
- if ( funcid == NSPV_CC_TXIDS)
- {
- std::vector > tmp_txids; uint256 tmp_txid,hashBlock;
- int32_t n=0,skipcount=vout>>16; uint8_t eval=(vout>>8)&0xFF, func=vout&0xFF;
-
- CTransaction tx;
- SetCCtxids(tmp_txids,coinaddr,isCC);
- if ( skipcount < 0 ) skipcount = 0;
- if ( skipcount >= tmp_txids.size() )
- skipcount = tmp_txids.size()-1;
- if ( tmp_txids.size()-skipcount > 0 )
- {
- for (std::vector >::const_iterator it=tmp_txids.begin(); it!=tmp_txids.end(); it++)
- {
- if (txid!=zeroid || func!=0)
- {
- myGetTransaction(it->first.txhash,tx,hashBlock);
- std::vector> oprets; uint256 tokenid,txid;
- std::vector vopret,vOpretExtra; uint8_t *script,e,f,tokenevalcode;
- std::vector pubkeys;
-
- if (DecodeTokenOpRet(tx.vout[tx.vout.size()-1].scriptPubKey,tokenevalcode,tokenid,pubkeys,oprets)!=0 && GetOpretBlob(oprets, OPRETID_CHANNELSDATA, vOpretExtra) && tokenevalcode==EVAL_TOKENS && vOpretExtra.size()>0)
- {
- vopret=vOpretExtra;
- }
- else GetOpReturnData(tx.vout[tx.vout.size()-1].scriptPubKey, vopret);
- script = (uint8_t *)vopret.data();
- if ( vopret.size() > 2 && script[0]==eval )
- {
- switch (eval)
- {
- case EVAL_CHANNELS:EVAL_PEGS:EVAL_ORACLES:EVAL_GAMES:EVAL_IMPORTGATEWAY:EVAL_ROGUE:
- E_UNMARSHAL(vopret,ss >> e; ss >> f; ss >> tmp_txid;);
- if (e!=eval || (txid!=zeroid && txid!=tmp_txid) || (func!=0 && f!=func)) continue;
- break;
- case EVAL_TOKENS:EVAL_DICE:EVAL_DILITHIUM:EVAL_FAUCET:EVAL_LOTO:EVAL_PAYMENTS:EVAL_REWARDS:
- E_UNMARSHAL(vopret,ss >> e; ss >> f;);
- if (e!=eval || (func!=0 && f!=func)) continue;
- break;
- default:
- break;
- }
- }
- }
- if ( n >= skipcount ) txids.push_back(it->first.txhash);
- n++;
- }
- return (n-skipcount);
- }
- return (0);
- }
- */
if ( mempool.size() == 0 )
return(0);
- /*
- if ( funcid == NSPV_MEMPOOL_CCEVALCODE )
- {
- isCC = true;
- evalcode = vout & 0xff;
- func = (vout >> 8) & 0xff;
- }
- */
+
LOCK(mempool.cs);
BOOST_FOREACH(const CTxMemPoolEntry &e,mempool.mapTx)
{
diff --git a/src/hush_nSPV_wallet.h b/src/hush_nSPV_wallet.h
index 5e329aa2a..85075e29f 100644
--- a/src/hush_nSPV_wallet.h
+++ b/src/hush_nSPV_wallet.h
@@ -322,31 +322,14 @@ UniValue NSPV_spend(char *srcaddr,char *destaddr,int64_t satoshis) // what its a
}
else if ( bitcoin_base58decode(rmd160,destaddr) != 25 )
{
- if ( (len= is_hexstr(destaddr,0)) > 0 )
- {
- len >>= 1;
- data.resize(len);
- decode_hex(&data[0],len,destaddr);
- if ( data[len-1] == OP_CHECKCRYPTOCONDITION )
- {
- data.resize(--len);
- scriptPubKey = CScript() << data << OP_CHECKCRYPTOCONDITION;
- }
- else
- {
- result.push_back(Pair("result","error"));
- result.push_back(Pair("error","only CC hex allowed for now"));
- return(result); }
- }
- else
- {
+ if ( (len= is_hexstr(destaddr,0)) > 0 ) {
+ result.push_back(Pair("result","error"));
+ return(result);
+ } else {
result.push_back(Pair("result","error"));
- result.push_back(Pair("error","invalid destaddr/CCvout hex"));
return(result);
}
- }
- else
- {
+ } else {
data.resize(20);
memcpy(&data[0],&rmd160[1],20);
scriptPubKey = (CScript() << OP_DUP << OP_HASH160 << ParseHex(HexStr(data)) << OP_EQUALVERIFY << OP_CHECKSIG);
diff --git a/src/hush_notary.h b/src/hush_notary.h
index 2f877c3cb..50335c349 100644
--- a/src/hush_notary.h
+++ b/src/hush_notary.h
@@ -102,7 +102,7 @@ int32_t hush_notaries(uint8_t pubkeys[64][33],int32_t height,uint32_t timestamp)
int32_t i,htind,n; uint64_t mask = 0; struct knotary_entry *kp,*tmp;
static uint8_t hush_pubkeys[NUM_HUSH_SEASONS][64][33],didinit[NUM_HUSH_SEASONS];
- //HUSH3+TUSH use block heights, HSCs use timestamps
+ //HUSH3+TUSH use block heights, HACs use timestamps
if ( timestamp == 0 && SMART_CHAIN_SYMBOL[0] != 0 ) {
timestamp = hush_heightstamp(height);
} else if ( SMART_CHAIN_SYMBOL[0] == 0 ) {
@@ -113,7 +113,7 @@ int32_t hush_notaries(uint8_t pubkeys[64][33],int32_t height,uint32_t timestamp)
int32_t hush_season = 0;
bool ishush3 = strncmp(SMART_CHAIN_SYMBOL, "HUSH3",5) == 0 ? true : false;
bool istush = strncmp(SMART_CHAIN_SYMBOL, "TUSH",4) == 0 ? true : false;
- // TUSH uses height activation like HUSH3, other HSCs use timestamps
+ // TUSH uses height activation like HUSH3, other HACs use timestamps
hush_season = (ishush3 || istush) ? gethushseason(height) : getacseason(timestamp);
if(IS_HUSH_NOTARY) {
diff --git a/src/hush_utils.h b/src/hush_utils.h
index 7b9269f0b..f1bb80697 100644
--- a/src/hush_utils.h
+++ b/src/hush_utils.h
@@ -1611,7 +1611,7 @@ uint64_t hush_block_subsidy(int height)
return subsidy;
}
-// wrapper for more general supply curves of Hush Smart Chains
+// wrapper for more general supply curves of Hush Arrakis Chains
uint64_t hush_sc_block_subsidy(int nHeight)
{
// Find current era, start from beginning reward, and determine current subsidy
@@ -1796,29 +1796,49 @@ void hush_args(char *argv0)
fprintf(stderr,".oO Starting %s Full Node (Extreme Privacy!) with genproc=%d notary=%d\n",name.c_str(),HUSH_MININGTHREADS, IS_HUSH_NOTARY);
vector HUSH_nodes = {};
+ vector DRAGONX_nodes = {};
// Only HUSH3 and DRAGONX connect to these by default, other HACs must opt-in via -connect/-addnode
const bool ishush3 = strncmp(name.c_str(), "HUSH3",5) == 0 ? true : false;
const bool isdragonx = strncmp(name.c_str(), "DRAGONX",7) == 0 ? true : false;
LogPrint("net", "%s: ishush3=%d isdragonx=%d\n", __func__, ishush3, isdragonx);
- if (ishush3 || isdragonx) {
+ if (ishush3) {
HUSH_nodes = {"node1.hush.is","node2.hush.is","node3.hush.is",
"node4.hush.is","node5.hush.is","node6.hush.is",
- "node7.hush.is","node8.hush.is","node1.hush.land",
- "node2.hush.land", "node3.hush.land",
- "node4.hush.land", "node5.hush.land"};
+ "node7.hush.is","node8.hush.is",
+ "178.250.189.141",
+ "31.202.19.157",
+ "45.132.75.69",
+ "45.63.58.167",
+ "b2dln7mw7ydnuopls444tuixujhcw5kn5o22cna6gqfmw2fl6drb5nad.onion",
+ "dslbaa5gut5kapqtd44pbg65tpl5ydsamfy62hjbldhfsvk64qs57pyd.onion",
+ "vsqdumnh5khjbrzlxoeucbkiuaictdzyc3ezjpxpp2ph3gfwo2ptjmyd.onion",
+ "plrobkepqjxs2cmig273mxnqh3qhuhdaioyb2n5kafn264ramb7tqxid.onion"
+ };
+
+ }
+
+ if (isdragonx) {
+ DRAGONX_nodes = {"node1.dragonx.is","node2.dragonx.is","node3.dragonx.is",
+ "node4.dragonx.is","node5.dragonx.is","node6.dragonx.is"
+ };
}
vector more_nodes = mapMultiArgs["-addnode"];
if (more_nodes.size() > 0) {
fprintf(stderr,"%s: Adding %lu more nodes via custom -addnode arguments\n", __func__, more_nodes.size() );
}
- // Add default HUSH nodes after custom addnodes, if applicable
+ // Add default HUSH and DRAGONX nodes after custom addnodes, if applicable
if(HUSH_nodes.size() > 0) {
- LogPrint("net", "%s: adding %d hostname-based nodes\n", __func__, HUSH_nodes.size() );
+ LogPrint("net", "%s: adding %d HUSH3 hostname-based nodes\n", __func__, HUSH_nodes.size() );
more_nodes.insert( more_nodes.end(), HUSH_nodes.begin(), HUSH_nodes.end() );
}
+ if(DRAGONX_nodes.size() > 0) {
+ LogPrint("net", "%s: adding %d DRAGONX hostname-based nodes\n", __func__, DRAGONX_nodes.size() );
+ more_nodes.insert( more_nodes.end(), DRAGONX_nodes.begin(), DRAGONX_nodes.end() );
+ }
+
mapMultiArgs["-addnode"] = more_nodes;
HUSH_STOPAT = GetArg("-stopat",0);
MAX_REORG_LENGTH = GetArg("-maxreorg",MAX_REORG_LENGTH);
@@ -1832,7 +1852,9 @@ void hush_args(char *argv0)
HUSH_SNAPSHOT_INTERVAL = GetArg("-ac_snapshot",0);
Split(GetArg("-ac_nk",""), sizeof(ASSETCHAINS_NK)/sizeof(*ASSETCHAINS_NK), ASSETCHAINS_NK, 0);
-
+ ASSETCHAINS_BURN = GetArg("-ac_burn", 0);
+ ASSETCHAINS_MINOPRETURNFEE = GetArg("-ac_minopreturnfee", 0);
+
// -ac_ccactivateht=evalcode,height,evalcode,height,evalcode,height....
Split(GetArg("-ac_ccactivateht",""), sizeof(ccEnablesHeight)/sizeof(*ccEnablesHeight), ccEnablesHeight, 0);
// fill map with all eval codes and activation height of 0.
@@ -1848,7 +1870,7 @@ void hush_args(char *argv0)
fprintf(stderr, "ac_ccactivateht: invalid evalcode.%i must be between 0 and 256.\n", ecode);
else if ( ht > 0 )
{
- // update global map.
+ // update global map.
mapHeightEvalActivate[ecode] = ht;
fprintf(stderr, "ac_ccactivateht: ecode.%i activates at height.%i\n", ecode, mapHeightEvalActivate[ecode]);
}
@@ -2158,7 +2180,7 @@ void hush_args(char *argv0)
}
}
- if ( ASSETCHAINS_ENDSUBSIDY[0] != 0 || ASSETCHAINS_REWARD[0] != 0 || ASSETCHAINS_HALVING[0] != 0 || ASSETCHAINS_DECAY[0] != 0 || ASSETCHAINS_COMMISSION != 0 || ASSETCHAINS_PUBLIC != 0 || ASSETCHAINS_PRIVATE != 0 || ASSETCHAINS_TXPOW != 0 || ASSETCHAINS_FOUNDERS != 0 || ASSETCHAINS_SCRIPTPUB.size() > 1 || ASSETCHAINS_SELFIMPORT.size() > 0 || ASSETCHAINS_OVERRIDE_PUBKEY33[0] != 0 || ASSETCHAINS_TIMELOCKGTE != _ASSETCHAINS_TIMELOCKOFF|| ASSETCHAINS_ALGO != ASSETCHAINS_EQUIHASH || ASSETCHAINS_LWMAPOS != 0 || ASSETCHAINS_LASTERA > 0 || ASSETCHAINS_BEAMPORT != 0 || ASSETCHAINS_CODAPORT != 0 || ASSETCHAINS_MARMARA != 0 || nonz > 0 || ASSETCHAINS_CCLIB.size() > 0 || ASSETCHAINS_FOUNDERS_REWARD != 0 || ASSETCHAINS_NOTARY_PAY[0] != 0 || ASSETCHAINS_BLOCKTIME != 60 || ASSETCHAINS_CBOPRET != 0 || Mineropret.size() != 0 || (ASSETCHAINS_NK[0] != 0 && ASSETCHAINS_NK[1] != 0) || HUSH_SNAPSHOT_INTERVAL != 0 || ASSETCHAINS_EARLYTXIDCONTRACT != 0 || ASSETCHAINS_CBMATURITY != 0 || ASSETCHAINS_ADAPTIVEPOW != 0 )
+ if ( ASSETCHAINS_ENDSUBSIDY[0] != 0 || ASSETCHAINS_REWARD[0] != 0 || ASSETCHAINS_HALVING[0] != 0 || ASSETCHAINS_DECAY[0] != 0 || ASSETCHAINS_COMMISSION != 0 || ASSETCHAINS_PUBLIC != 0 || ASSETCHAINS_PRIVATE != 0 || ASSETCHAINS_TXPOW != 0 || ASSETCHAINS_FOUNDERS != 0 || ASSETCHAINS_SCRIPTPUB.size() > 1 || ASSETCHAINS_SELFIMPORT.size() > 0 || ASSETCHAINS_OVERRIDE_PUBKEY33[0] != 0 || ASSETCHAINS_TIMELOCKGTE != _ASSETCHAINS_TIMELOCKOFF|| ASSETCHAINS_ALGO != ASSETCHAINS_EQUIHASH || ASSETCHAINS_LWMAPOS != 0 || ASSETCHAINS_LASTERA > 0 || ASSETCHAINS_BEAMPORT != 0 || ASSETCHAINS_CODAPORT != 0 || ASSETCHAINS_MARMARA != 0 || nonz > 0 || ASSETCHAINS_CCLIB.size() > 0 || ASSETCHAINS_FOUNDERS_REWARD != 0 || ASSETCHAINS_NOTARY_PAY[0] != 0 || ASSETCHAINS_BLOCKTIME != 60 || ASSETCHAINS_CBOPRET != 0 || Mineropret.size() != 0 || (ASSETCHAINS_NK[0] != 0 && ASSETCHAINS_NK[1] != 0) || HUSH_SNAPSHOT_INTERVAL != 0 || ASSETCHAINS_EARLYTXIDCONTRACT != 0 || ASSETCHAINS_CBMATURITY != 0 || ASSETCHAINS_ADAPTIVEPOW != 0 || ASSETCHAINS_BURN != 0 || ASSETCHAINS_MINOPRETURNFEE)
{
if(fDebug)
fprintf(stderr,"perc %.4f%% ac_pub=[%02x%02x%02x...] acsize.%d\n",dstr(ASSETCHAINS_COMMISSION)*100,ASSETCHAINS_OVERRIDE_PUBKEY33[0],ASSETCHAINS_OVERRIDE_PUBKEY33[1],ASSETCHAINS_OVERRIDE_PUBKEY33[2],(int32_t)ASSETCHAINS_SCRIPTPUB.size());
@@ -2318,6 +2340,16 @@ void hush_args(char *argv0)
}
if ( ASSETCHAINS_ADAPTIVEPOW != 0 )
extraptr[extralen++] = ASSETCHAINS_ADAPTIVEPOW;
+
+ if ( ASSETCHAINS_BURN != 0 )
+ {
+ extralen += dragon_rwnum(1,&extraptr[extralen],sizeof(ASSETCHAINS_BURN),(void *)&ASSETCHAINS_BURN);
+ }
+
+ if ( ASSETCHAINS_MINOPRETURNFEE != 0 )
+ {
+ extralen += dragon_rwnum(1,&extraptr[extralen],sizeof(ASSETCHAINS_MINOPRETURNFEE),(void *)&ASSETCHAINS_MINOPRETURNFEE);
+ }
}
addn = GetArg("-seednode","");
diff --git a/src/init.cpp b/src/init.cpp
index 89b3a3a12..2877dd288 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -429,8 +429,10 @@ std::string HelpMessage(HelpMessageMode mode)
strUsage += HelpMessageOpt("-i2psam=", strprintf(_("I2P SAM proxy to reach I2P peers and accept I2P connections (default: none)")));
strUsage += HelpMessageOpt("-i2pacceptincoming", strprintf(_("If set and -i2psam is also set then incoming I2P connections are accepted via the SAM proxy. If this is not set but -i2psam is set then only outgoing connections will be made to the I2P network. Ignored if -i2psam is not set. Listening for incoming I2P connections is done through the SAM proxy, not by binding to a local address and port (default: 1)")));
strUsage += HelpMessageOpt("-onlynet=", _("Only connect to nodes in network (ipv4, ipv6, onion or i2p)"));
- strUsage += HelpMessageOpt("-disableipv4", _("Disable Ipv4 network connections") + " " + _("(default: 0)"));
- strUsage += HelpMessageOpt("-disableipv6", _("Disable Ipv6 network connections") + " " + _("(default: 0)"));
+ strUsage += HelpMessageOpt("-disableipv4", _("Disable Ipv4 network connections") + " " + strprintf(_("(default: %u)"), DEFAULT_DISABLE_IPV4));
+ strUsage += HelpMessageOpt("-disableipv6", _("Disable Ipv6 network connections") + " " + strprintf(_("(default: %u)"), DEFAULT_DISABLE_IPV6));
+
+ strUsage += HelpMessageOpt("-clearnet", _("Enable clearnet connections. Setting to 0 will disable clearnet and use sane defaults for Tor/i2p") + " " + strprintf(_("(default: %u)"), DEFAULT_CLEARNET));
strUsage += HelpMessageOpt("-permitbaremultisig", strprintf(_("Relay non-P2SH multisig (default: %u)"), 1));
strUsage += HelpMessageOpt("-peerbloomfilters", strprintf(_("Support filtering of blocks and transaction with Bloom filters (default: %u)"), 1));
@@ -479,7 +481,6 @@ std::string HelpMessage(HelpMessageMode mode)
if (showDebug)
strUsage += HelpMessageOpt("-mintxfee=", strprintf("Fees (in %s/kB) smaller than this are considered zero fee for transaction creation (default: %s)",
CURRENCY_UNIT, FormatMoney(CWallet::minTxFee.GetFeePerK())));
- strUsage += HelpMessageOpt("-opretmintxfee=", strprintf(_("Minimum fee (in %s/kB) to allow for OP_RETURN transactions (default: %s)"), CURRENCY_UNIT, 400000 ));
strUsage += HelpMessageOpt("-paytxfee=", strprintf(_("Fee (in %s/kB) to add to transactions you send (default: %s)"), CURRENCY_UNIT, FormatMoney(payTxFee.GetFeePerK())));
// If this is used incorrectly (-rescanheight too large), then the local wallet may attempt to spend funds which it does not have witness data about
// which will cause a "missing inputs" error when added to the mempool. Rescanning from correct height will fix this.
@@ -602,6 +603,8 @@ std::string HelpMessage(HelpMessageMode mode)
strUsage += HelpMessageOpt("-ac_algo", _("Choose PoW mining algorithm, either 'equihash' or 'randomx'. default is Equihash (200,9)"));
strUsage += HelpMessageOpt("-ac_blocktime", _("Block time in seconds, default is 60"));
strUsage += HelpMessageOpt("-ac_beam", _("BEAM integration"));
+ strUsage += HelpMessageOpt("-ac_burn", _("Allow sending funds to the transparent burn address when -ac_private=1"));
+ strUsage += HelpMessageOpt("-ac_minopreturnfee", _("OP_RETURN minimum fee per tx, regardless of tx size, default is 1 coin"));
strUsage += HelpMessageOpt("-ac_coda", _("CODA integration"));
strUsage += HelpMessageOpt("-ac_decay", _("Percentage of block reward decrease at each halving"));
strUsage += HelpMessageOpt("-ac_end", _("Block height at which block rewards will end"));
@@ -1085,6 +1088,13 @@ bool AppInit2(boost::thread_group& threadGroup, CScheduler& scheduler)
LogPrintf("\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n");
LogPrintf("Hush version %s (%s)\n", FormatFullVersion());
+
+#ifdef DEBUG_LOCKORDER
+ LogPrintf("DEBUG_LOCKORDER enabled\n");
+#else
+ LogPrintf("DEBUG_LOCKORDER disabled\n");
+#endif
+
// when specifying an explicit binding address, you want to listen on it
// even when -connect or -proxy is specified
if (mapArgs.count("-bind")) {
@@ -1128,7 +1138,7 @@ bool AppInit2(boost::thread_group& threadGroup, CScheduler& scheduler)
LogPrintf("%s: parameter interaction: -externalip set -> setting -discover=0\n", __func__);
}
- // Read asmap file by default for HUSH3 and all Hush Smart Chains
+ // Read asmap file by default for HUSH3 and all Hush Arrakis Chains
if (GetArg("-asmap",1)) {
fs::path asmap_path = fs::path(GetArg("-asmap", ""));
@@ -1637,12 +1647,38 @@ bool AppInit2(boost::thread_group& threadGroup, CScheduler& scheduler)
}
//fprintf(stderr,"%s tik18\n", __FUNCTION__);
+ // Disable clearnet peers if -clearnet=0
+ if (!GetBoolArg("-clearnet", DEFAULT_CLEARNET)) {
+#ifdef ENABLE_MINING
+ // mining to the same taddr links different txs together as from the same owner
+ // and if using -clearnet=0 that can be used to link together different .onions
+ // as being the same entity, because they are mining to the same taddr
+ if (mapArgs.count("-mineraddress")) {
+ return InitError(_("-mineraddress and -clearnet=0 cannot be used together because it would reduce your privacy!"));
+ }
+#endif
+ SoftSetBoolArg("-disableipv4", true);
+ SoftSetBoolArg("-disableipv6", true);
+ SoftSetBoolArg("-dns", false);
+ SoftSetBoolArg("-dnsseed", false);
+ SoftSetArg("-bind", "127.0.0.1");
+ SoftSetArg("-onlynet", "onion");
+ SoftSetArg("-onlynet", "i2p");
+ SoftSetArg("-onion", "127.0.0.1:9050");
+ SoftSetArg("-i2psam", "127.0.0.1:7656");
+ }
+
if (mapArgs.count("-onlynet")) {
std::set nets;
BOOST_FOREACH(const std::string& snet, mapMultiArgs["-onlynet"]) {
enum Network net = ParseNetwork(snet);
- if (net == NET_UNROUTABLE)
+ if (net == NET_UNROUTABLE) {
return InitError(strprintf(_("Unknown network specified in -onlynet: '%s'"), snet));
+ } else if (net == NET_IPV4 && GetBoolArg("-disableipv4", DEFAULT_DISABLE_IPV4)) {
+ return InitError(strprintf(_("-onlynet=ipv4 is incompatible with -disableipv4 !")));
+ } else if (net == NET_IPV6 && GetBoolArg("-disableipv6", DEFAULT_DISABLE_IPV4)) {
+ return InitError(strprintf(_("-onlynet=ipv6 is incompatible with -disableipv6 !")));
+ }
nets.insert(net);
}
for (int n = 0; n < NET_MAX; n++) {
@@ -1652,6 +1688,22 @@ bool AppInit2(boost::thread_group& threadGroup, CScheduler& scheduler)
}
}
+ if(mapMultiArgs["-disableipv6"].size() > 1) {
+ return InitError("-disableipv6 can only be used once");
+ }
+
+ if(mapMultiArgs["-disableipv4"].size() > 1) {
+ return InitError("-disableipv4 can only be used once");
+ }
+
+ if (GetBoolArg("-disableipv6", DEFAULT_DISABLE_IPV6)) {
+ SetReachable(NET_IPV6, false);
+ }
+
+ if (GetBoolArg("-disableipv4", DEFAULT_DISABLE_IPV4)) {
+ SetReachable(NET_IPV4, false);
+ }
+
//fprintf(stderr,"%s tik19\n", __FUNCTION__);
if (mapArgs.count("-allowlist")) {
BOOST_FOREACH(const std::string& net, mapMultiArgs["-allowlist"]) {
diff --git a/src/main.cpp b/src/main.cpp
index bfcd3c538..ff3c3ea64 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -33,6 +33,7 @@
#include "net.h"
#include "netmessagemaker.h"
#include "pow.h"
+#include "time.h"
#include "script/interpreter.h"
#include "txdb.h"
#include "txmempool.h"
@@ -106,7 +107,7 @@ size_t nCoinCacheUsage = 5000 * 300;
uint64_t nPruneTarget = 0;
// If the tip is older than this (in seconds), the node is considered to be in initial block download.
int64_t nMaxTipAge = DEFAULT_MAX_TIP_AGE;
-bool ishush3 = strncmp(SMART_CHAIN_SYMBOL, "HUSH3",5) == 0 ? true : false;
+const bool ishush3 = strncmp(SMART_CHAIN_SYMBOL, "HUSH3",5) == 0 ? true : false;
int32_t nFirstHalvingHeight = 340000;
unsigned int expiryDelta = DEFAULT_TX_EXPIRY_DELTA;
@@ -815,8 +816,8 @@ bool hush_dailysnapshot(int32_t height)
for (unsigned int j = tx.vin.size(); j-- > 0;)
{
uint256 blockhash; CTransaction txin;
- if (tx.IsPegsImport() && j==0) continue;
- if ( !tx.IsCoinImport() && !tx.IsCoinBase() && myGetTransaction(tx.vin[j].prevout.hash,txin,blockhash) )
+ //if (tx.IsPegsImport() && j==0) continue;
+ if ( !tx.IsCoinBase() && myGetTransaction(tx.vin[j].prevout.hash,txin,blockhash) )
{
int vout = tx.vin[j].prevout.n;
if ( ExtractDestination(txin.vout[vout].scriptPubKey, vDest) )
@@ -993,11 +994,10 @@ bool IsStandardTx(const CTransaction& tx, string& reason, const int nHeight)
}
nDataOut++;
//fprintf(stderr,"is OP_RETURN\n");
- }
- else if ((whichType == TX_MULTISIG) && (!fIsBareMultisigStd)) {
+ } else if ((whichType == TX_MULTISIG) && (!fIsBareMultisigStd)) {
reason = "bare-multisig";
return false;
- } else if (whichType != TX_CRYPTOCONDITION && txout.IsDust(::minRelayTxFee)) {
+ } else if (txout.IsDust(::minRelayTxFee)) {
reason = "dust";
return false;
}
@@ -1102,12 +1102,12 @@ bool AreInputsStandard(const CTransaction& tx, const CCoinsViewCache& mapInputs,
if (tx.IsCoinBase())
return true; // Coinbases don't use vin normally
- if (tx.IsCoinImport())
- return tx.vin[0].scriptSig.IsCoinImport();
+ //if (tx.IsCoinImport())
+ // return tx.vin[0].scriptSig.IsCoinImport();
for (unsigned int i = 0; i < tx.vin.size(); i++)
{
- if (tx.IsPegsImport() && i==0) continue;
+ //if (tx.IsPegsImport() && i==0) continue;
const CTxOut& prev = mapInputs.GetOutputFor(tx.vin[i]);
vector > vSolutions;
@@ -1179,13 +1179,13 @@ unsigned int GetLegacySigOpCount(const CTransaction& tx)
unsigned int GetP2SHSigOpCount(const CTransaction& tx, const CCoinsViewCache& inputs)
{
- if (tx.IsCoinBase() || tx.IsCoinImport())
+ if (tx.IsCoinBase())
return 0;
unsigned int nSigOps = 0;
for (unsigned int i = 0; i < tx.vin.size(); i++)
{
- if (tx.IsPegsImport() && i==0) continue;
+ //if (tx.IsPegsImport() && i==0) continue;
const CTxOut &prevout = inputs.GetOutputFor(tx.vin[i]);
if (prevout.scriptPubKey.IsPayToScriptHash())
nSigOps += prevout.scriptPubKey.GetSigOpCount(tx.vin[i].scriptSig);
@@ -1222,16 +1222,6 @@ bool ContextualCheckTransaction(int32_t slowflag,const CBlock *block, CBlockInde
{
const bool overwinterActive = nHeight >=1 ? true : false; //NetworkUpgradeActive(nHeight, Params().GetConsensus(), Consensus::UPGRADE_OVERWINTER);
const bool saplingActive = nHeight >=1 ? true : false; //NetworkUpgradeActive(nHeight, Params().GetConsensus(), Consensus::UPGRADE_SAPLING);
- const bool isSprout = false; //!overwinterActive;
-
- /*
- // If Sprout rules apply, reject transactions which are intended for Overwinter and beyond
- if (isSprout && tx.fOverwintered) {
- int32_t ht = Params().GetConsensus().vUpgrades[Consensus::UPGRADE_OVERWINTER].nActivationHeight;
- return state.DoS((ht < 0 || nHeight < ht) ? 0 : dosLevel,error("ContextualCheckTransaction(): ht.%d activates.%d dosLevel.%d overwinter is not active yet",nHeight, Params().GetConsensus().vUpgrades[Consensus::UPGRADE_OVERWINTER].nActivationHeight, dosLevel),REJECT_INVALID, "tx-overwinter-not-active");
- //return state.DoS(isInitBlockDownload() ? 0 : dosLevel,error("ContextualCheckTransaction(): ht.%d activates.%d dosLevel.%d overwinter is not active yet",nHeight, Params().GetConsensus().vUpgrades[Consensus::UPGRADE_OVERWINTER].nActivationHeight, dosLevel),REJECT_INVALID, "tx-overwinter-not-active");
- }
- */
if (saplingActive) {
// Reject transactions with valid version but missing overwintered flag
@@ -1428,7 +1418,7 @@ int32_t hush_isnotaryvout(char *coinaddr,uint32_t tiptime) {
bool istush = strncmp(SMART_CHAIN_SYMBOL, "TUSH",4) == 0 ? true : false;
int32_t height = chainActive.LastTip()->GetHeight();
int32_t season = (ishush3 || istush) ? gethushseason(height) : getacseason(tiptime);
- fprintf(stderr,"%s: season=%d, tiptime=%d\n", __func__, season,tiptime);
+ fprintf(stderr,"%s: coinaddr=%s season=%d, tiptime=%d\n", __func__, coinaddr, season,tiptime);
if ( NOTARY_ADDRESSES[season-1][0][0] == 0 ) {
uint8_t pubkeys[64][33];
hush_notaries(pubkeys,0,tiptime);
@@ -1530,11 +1520,20 @@ bool CheckTransactionWithoutProofVerification(uint32_t tiptime,const CTransactio
{
char destaddr[65];
Getscriptaddress(destaddr,txout.scriptPubKey);
+
if ( hush_isnotaryvout(destaddr,tiptime) == 0 )
{
- invalid_private_taddr = 1;
- fprintf(stderr,"%s: invalid taddr %s on private chain!\n", __func__, destaddr);
- //return state.DoS(100, error("CheckTransaction(): this is a private chain, no public allowed"),REJECT_INVALID, "bad-txns-acprivacy-chain");
+ const bool isburn = (strcmp(destaddr,BURN_ADDRESS) == 0);
+ if ((ASSETCHAINS_BURN == 1) && isburn && tx.vin.empty()) {
+ // -ac_burn=1 means only zaddrs can send to the burn address
+ fprintf(stderr,"%s: allowing zaddr to send to burn address %s on private chain because ac_burn=1\n", __func__, destaddr);
+ } else if ((ASSETCHAINS_BURN == 2) && isburn) {
+ // -ac_burn=2 allows notary taddrs to send directly to the burn address
+ fprintf(stderr,"%s: allowing burn address %s on private chain because ac_burn=2\n", __func__, destaddr);
+ } else {
+ invalid_private_taddr = 1;
+ fprintf(stderr,"%s: invalid taddr %s on private chain!\n", __func__, destaddr);
+ }
}
}
}
@@ -1731,22 +1730,6 @@ bool AcceptToMemoryPool(CTxMemPool& pool, CValidationState &state, const CTransa
tiptime = (uint32_t)time(NULL);
else tiptime = (uint32_t)chainActive.LastTip()->nTime;
- /*
- // Node operator can choose to reject tx by number of transparent inputs
- static_assert(std::numeric_limits::max() >= std::numeric_limits::max(), "size_t too small");
- const size_t limit = 0; //(size_t) GetArg("-mempooltxinputlimit", 0);
- // Limit is ignored if Overwinter is active, which is the case on HUSH3 and all HAC's
- if (NetworkUpgradeActive(nextBlockHeight, Params().GetConsensus(), Consensus::UPGRADE_OVERWINTER)) {
- limit = 0;
- }
- if (limit > 0) {
- size_t n = tx.vin.size();
- if (n > limit) {
- LogPrint("mempool", "Dropping txid %s : too many transparent inputs %zu > limit %zu\n", tx.GetHash().ToString(), n, limit );
- return false;
- }
- }
- */
auto verifier = libzcash::ProofVerifier::Strict();
if (!CheckTransaction(tiptime,tx, state, verifier, 0, 0))
@@ -1853,11 +1836,6 @@ bool AcceptToMemoryPool(CTxMemPool& pool, CValidationState &state, const CTransa
return state.Invalid(false, REJECT_DUPLICATE, "already have coins");
}
- //if (tx.IsCoinImport() || tx.IsPegsImport()) {
- // // Inverse of normal case; if input exists, it's been spent
- // if (ExistsImportTombstone(tx, view))
- // return state.Invalid(false, REJECT_DUPLICATE, "import tombstone exists");
- //} else
{
// do all inputs exist?
// Note that this does not check for the presence of actual outputs (see the next check for that),
@@ -1919,13 +1897,11 @@ bool AcceptToMemoryPool(CTxMemPool& pool, CValidationState &state, const CTransa
// Keep track of transactions that spend a coinbase, which we re-scan
// during reorgs to ensure COINBASE_MATURITY is still met.
bool fSpendsCoinbase = false;
- if (!tx.IsCoinImport() && !tx.IsPegsImport()) {
- BOOST_FOREACH(const CTxIn &txin, tx.vin) {
- const CCoins *coins = view.AccessCoins(txin.prevout.hash);
- if (coins->IsCoinBase()) {
- fSpendsCoinbase = true;
- break;
- }
+ BOOST_FOREACH(const CTxIn &txin, tx.vin) {
+ const CCoins *coins = view.AccessCoins(txin.prevout.hash);
+ if (coins->IsCoinBase()) {
+ fSpendsCoinbase = true;
+ break;
}
}
// Grab the branch ID we expect this transaction to commit to. We don't
@@ -1957,7 +1933,7 @@ bool AcceptToMemoryPool(CTxMemPool& pool, CValidationState &state, const CTransa
// Continuously rate-limit free (really, very-low-fee) transactions
// This mitigates 'penny-flooding' -- sending thousands of free transactions just to
// be annoying or make others' transactions take longer to confirm.
- if (fLimitFree && nFees < ::minRelayTxFee.GetFee(nSize) && !tx.IsCoinImport() && !tx.IsPegsImport())
+ if (fLimitFree && nFees < ::minRelayTxFee.GetFee(nSize) )
{
static CCriticalSection csFreeLimiter;
static double dFreeCount;
@@ -1980,7 +1956,17 @@ bool AcceptToMemoryPool(CTxMemPool& pool, CValidationState &state, const CTransa
dFreeCount += nSize;
}
- if (!tx.IsCoinImport() && !tx.IsPegsImport() && fRejectAbsurdFee && nFees > ::minRelayTxFee.GetFee(nSize) * 10000 && nFees > nValueOut/19)
+ fRejectAbsurdFee = false;
+
+ if ( fRejectAbsurdFee && nFees > ::minRelayTxFee.GetFee(nSize) * 10000 && nFees > nValueOut/19)
+ // Disable checks for absurd fees when adding to the mempool. Instead, this check is done
+ // when a user attempts to make a transaction with an absurd fee and only rejects absurd
+ // fees when OP_RETURN data is NOT being used. This means users making normal financial
+ // transactions (z2z) are protected from absurd fees, it is only users who are storing
+ // arbitrary data via a z2t transaction are allowed to (or potentially required) to pay high fees
+ // It would be nice to detect the use of OP_RETURN right here but it seems to only be known
+ // inside of IsStandard() inside of IsStandardTx() and we want to avoid doing expensive checks
+ // multiple times.
{
string errmsg = strprintf("absurdly high fees %s, %d > %d",
hash.ToString(),
@@ -1988,7 +1974,7 @@ bool AcceptToMemoryPool(CTxMemPool& pool, CValidationState &state, const CTransa
LogPrint("mempool", errmsg.c_str());
return state.Error("AcceptToMemoryPool: " + errmsg);
}
-//fprintf(stderr,"addmempool 6\n");
+ //fprintf(stderr,"addmempool 6\n");
// Check against previous transactions
// This is done last to help prevent CPU exhaustion denial-of-service attacks.
@@ -2028,17 +2014,15 @@ bool AcceptToMemoryPool(CTxMemPool& pool, CValidationState &state, const CTransa
LOCK(pool.cs);
// Store transaction in memory
pool.addUnchecked(hash, entry, !IsInitialBlockDownload());
- if (!tx.IsCoinImport())
- {
- // Add memory address index
- if (fAddressIndex) {
- pool.addAddressIndex(entry, view);
- }
- // Add memory spent index
- if (fSpentIndex) {
- pool.addSpentIndex(entry, view);
- }
+ // Add memory address index
+ if (fAddressIndex) {
+ pool.addAddressIndex(entry, view);
+ }
+
+ // Add memory spent index
+ if (fSpentIndex) {
+ pool.addSpentIndex(entry, view);
}
}
}
@@ -2579,7 +2563,7 @@ void UpdateCoins(const CTransaction& tx, CCoinsViewCache& inputs, CTxUndo &txund
{
txundo.vprevout.reserve(tx.vin.size());
BOOST_FOREACH(const CTxIn &txin, tx.vin) {
- if (tx.IsPegsImport() && txin.prevout.n==10e8) continue;
+ //if (tx.IsPegsImport() && txin.prevout.n==10e8) continue;
CCoinsModifier coins = inputs.ModifyCoins(txin.prevout.hash);
unsigned nPos = txin.prevout.n;
@@ -2601,12 +2585,6 @@ void UpdateCoins(const CTransaction& tx, CCoinsViewCache& inputs, CTxUndo &txund
inputs.SetNullifiers(tx, true);
inputs.ModifyCoins(tx.GetHash())->FromTx(tx, nHeight); // add outputs
-
- // Unorthodox state
- //if (tx.IsCoinImport() || tx.IsPegsImport()) {
- // // add a tombstone for the burnTx
- // AddImportTombstone(tx, inputs, nHeight);
- //}
}
void UpdateCoins(const CTransaction& tx, CCoinsViewCache& inputs, int nHeight)
@@ -2647,13 +2625,6 @@ namespace Consensus {
CAmount nFees = 0;
for (unsigned int i = 0; i < tx.vin.size(); i++)
{
- /*
- if (tx.IsPegsImport() && i==0)
- {
- nValueIn=GetCoinImportValue(tx);
- continue;
- }
- */
const COutPoint &prevout = tx.vin[i].prevout;
const CCoins *coins = inputs.AccessCoins(prevout.hash);
assert(coins);
@@ -2707,6 +2678,31 @@ namespace Consensus {
if (!MoneyRange(nFees))
return state.DoS(100, error("CheckInputs(): nFees out of range"),
REJECT_INVALID, "bad-txns-fee-outofrange");
+
+ //NOTE: Since we have access to fee here, verify that opreturn pays
+ //required minimum fee, even though this is a check on outputs not
+ //inputs. If we don't do it here we would need to duplicate already
+ //done work somewhere else
+
+ if ( ASSETCHAINS_MINOPRETURNFEE > 0 ) {
+ BOOST_FOREACH(const CTxOut& txout, tx.vout) {
+ const bool isopret = txout.scriptPubKey.IsOpReturn();
+
+ // HUSH+DRGX do not use -ac_minopreturnfee so this does not (yet)
+ // affect those chains, they will need a height activated consensus
+ // change
+
+ if ( isopret ) {
+ // Is there any difference between nTxFee and nFees ?
+ // They seem to be 2 vars with the same value
+ fprintf(stderr,"%s: opreturn=1 nFees=%ld nTxFee=%ld\n", __func__, nFees, nTxFee);
+ if (nTxFee < ASSETCHAINS_MINOPRETURNFEE) {
+ return state.DoS(100,error("CheckInputs(): tx does not have required mininum fee for OP_RETURN"), REJECT_INVALID, "bad-txns-minopreturnfee");
+ }
+ }
+ }
+ }
+
return true;
}
}// namespace Consensus
@@ -2741,7 +2737,7 @@ bool ContextualCheckInputs(
// still computed and checked, and any change will be caught at the next checkpoint.
if (fScriptChecks) {
for (unsigned int i = 0; i < tx.vin.size(); i++) {
- if (tx.IsPegsImport() && i==0) continue;
+ //if (tx.IsPegsImport() && i==0) continue;
const COutPoint &prevout = tx.vin[i].prevout;
const CCoins* coins = inputs.AccessCoins(prevout.hash);
assert(coins);
@@ -2777,15 +2773,6 @@ bool ContextualCheckInputs(
}
}
- /*
- if (tx.IsCoinImport() || tx.IsPegsImport())
- {
- LOCK(cs_main);
- ServerTransactionSignatureChecker checker(&tx, 0, 0, false, txdata);
- return VerifyCoinImport(tx.vin[0].scriptSig, checker, state);
- }
- */
-
return true;
}
@@ -2941,10 +2928,6 @@ int8_t GetAddressType(const CScript &scriptPubKey, CTxDestination &vDest, txnout
{
keyType = 2;
}
- else if (txType == TX_CRYPTOCONDITION )
- {
- keyType = 3;
- }
}
return keyType;
}
@@ -3021,11 +3004,11 @@ bool DisconnectBlock(CBlock& block, CValidationState& state, CBlockIndex* pindex
// restore inputs
if (!tx.IsMint()) {
CTxUndo &txundo = blockUndo.vtxundo[i-1];
- if (tx.IsPegsImport()) txundo.vprevout.insert(txundo.vprevout.begin(),CTxInUndo());
+ //if (tx.IsPegsImport()) txundo.vprevout.insert(txundo.vprevout.begin(),CTxInUndo());
if (txundo.vprevout.size() != tx.vin.size())
return error("DisconnectBlock(): transaction and undo data inconsistent");
for (unsigned int j = tx.vin.size(); j-- > 0;) {
- if (tx.IsPegsImport() && j==0) continue;
+ //if (tx.IsPegsImport() && j==0) continue;
const COutPoint &out = tx.vin[j].prevout;
const CTxInUndo &undo = txundo.vprevout[j];
if (!ApplyTxInUndo(undo, view, out))
@@ -3059,12 +3042,6 @@ bool DisconnectBlock(CBlock& block, CValidationState& state, CBlockIndex* pindex
}
}
}
- /*
- else if (tx.IsCoinImport() || tx.IsPegsImport())
- {
- RemoveImportTombstone(tx, view);
- }
- */
}
// set the old best Sprout anchor back
@@ -3372,7 +3349,7 @@ bool ConnectBlock(const CBlock& block, CValidationState& state, CBlockIndex* pin
{
for (size_t j = 0; j < tx.vin.size(); j++)
{
- if (tx.IsPegsImport() && j==0) continue;
+ //if (tx.IsPegsImport() && j==0) continue;
const CTxIn input = tx.vin[j];
const CTxOut &prevout = view.GetOutputFor(tx.vin[j]);
@@ -4333,7 +4310,15 @@ bool ActivateBestChain(bool fSkipdpow, CValidationState &state, CBlock *pblock)
CBlockIndex *pindexMostWork = NULL;
const CChainParams& chainParams = Params();
do {
- boost::this_thread::interruption_point();
+ // Sleep briefly to allow other threads a chance at grabbing cs_main if
+ // we are connecting a long chain of blocks and would otherwise hold the
+ // lock almost continuously. This helps
+ // the internal wallet, if it is enabled, to keep up with the connected
+ // blocks, reducing the overall time until the node becomes usable.
+ //
+ // This is defined to be an interruption point.
+ //
+ boost::this_thread::sleep_for(boost::chrono::microseconds(200));
if (ShutdownRequested())
break;
@@ -6886,7 +6871,7 @@ bool static ProcessMessage(CNode* pfrom, string strCommand, CDataStream& vRecv,
LogPrintf("dropmessagestest DROPPING RECV MESSAGE\n");
return true;
}
- auto p2pdebug = GetArg("-p2pdebug",0);
+ const bool p2pdebug = GetArg("-p2pdebug",0);
if(p2pdebug)
fprintf(stderr,"%s: netmsg: %s from %s\n", __func__, strCommand.c_str(), pfrom->addr.ToString().c_str() );
@@ -6913,10 +6898,9 @@ bool static ProcessMessage(CNode* pfrom, string strCommand, CDataStream& vRecv,
CAddress addrFrom;
uint64_t nNonce = 1;
int nVersion; // use temporary for version, don't set version number until validated as connected
- int minVersion = MIN_PEER_PROTO_VERSION;
+ const int minVersion = ishush3 ? MIN_HUSH_PEER_PROTO_VERSION : MIN_PEER_PROTO_VERSION;
vRecv >> nVersion >> pfrom->nServices >> nTime >> addrMe;
- if (nVersion == 10300)
- nVersion = 300;
+
if (nVersion < minVersion)
{
// disconnect from peers older than this proto version
diff --git a/src/miner.cpp b/src/miner.cpp
index 95797c684..fce0179bb 100644
--- a/src/miner.cpp
+++ b/src/miner.cpp
@@ -118,6 +118,7 @@ public:
extern int8_t ASSETCHAINS_ADAPTIVEPOW;
extern uint32_t ASSETCHAINS_RANDOMX;
+extern uint32_t ASSETCHAINS_MINOPRETURNFEE;
extern bool fRandomXDebug;
extern std::string devtax_scriptpub_for_height(uint32_t nHeight);
@@ -200,19 +201,20 @@ CBlockTemplate* CreateNewBlock(CPubKey _pk,const CScript& _scriptPubKeyIn, int32
//fprintf(stderr,"%s: added dummy coinbase\n", __func__);
// Largest block you're willing to create:
- unsigned int nBlockMaxSize = GetArg("-blockmaxsize", MAX_BLOCK_SIZE(chainActive.LastTip()->GetHeight()+1));
+ unsigned int nBlockMaxSize = GetArg("-blockmaxsize", MAX_BLOCK_SIZE(1)); // MAX_BLOCK_SIZE(chainActive.LastTip()->GetHeight()+1));
// Limit to betweeen 1K and MAX_BLOCK_SIZE-1K for sanity:
- nBlockMaxSize = std::max((unsigned int)1000, std::min((unsigned int)(MAX_BLOCK_SIZE(chainActive.LastTip()->GetHeight()+1)-1000), nBlockMaxSize));
+ nBlockMaxSize = std::max((unsigned int)1000, std::min((unsigned int)(MAX_BLOCK_SIZE(1)-1000), nBlockMaxSize));
+ //nBlockMaxSize = std::max((unsigned int)1000, std::min((unsigned int)(MAX_BLOCK_SIZE(chainActive.LastTip()->GetHeight()+1)-1000), nBlockMaxSize));
// How much of the block should be dedicated to high-priority transactions,
// included regardless of the fees they pay
- unsigned int nBlockPrioritySize = GetArg("-blockprioritysize", DEFAULT_BLOCK_PRIORITY_SIZE);
- nBlockPrioritySize = std::min(nBlockMaxSize, nBlockPrioritySize);
+ const unsigned int nBlockPrioritySize = std::min( nBlockMaxSize, (unsigned int) GetArg("-blockprioritysize", DEFAULT_BLOCK_PRIORITY_SIZE) );
+ // nBlockPrioritySize = std::min(nBlockMaxSize, nBlockPrioritySize);
// Minimum block size you want to create; block will be filled with free transactions
// until there are no more or the block reaches this size:
- unsigned int nBlockMinSize = GetArg("-blockminsize", DEFAULT_BLOCK_MIN_SIZE);
- nBlockMinSize = std::min(nBlockMaxSize, nBlockMinSize);
+ const unsigned int nBlockMinSize = std::min(nBlockMaxSize, (unsigned int) GetArg("-blockminsize", DEFAULT_BLOCK_MIN_SIZE));
+ // nBlockMinSize = std::min(nBlockMaxSize, nBlockMinSize);
//fprintf(stderr,"%s: nBlockMaxSize=%u, nBlockPrioritySize=%u, nBlockMinSize=%u\n", __func__, nBlockMaxSize, nBlockPrioritySize, nBlockMinSize);
@@ -308,12 +310,7 @@ CBlockTemplate* CreateNewBlock(CPubKey _pk,const CScript& _scriptPubKeyIn, int32
bool fMissingInputs = false;
bool fNotarization = false;
std::vector TMP_NotarizationNotaries;
- //if (tx.IsCoinImport())
- //{
- // CAmount nValueIn = GetCoinImportValue(tx); // burn amount
- // nTotalIn += nValueIn;
- // dPriority += (double)nValueIn * 1000; // flat multiplier... max = 1e16.
- //} else
+
{
TMP_NotarizationNotaries.clear();
bool fToCryptoAddress = false;
@@ -322,15 +319,6 @@ CBlockTemplate* CreateNewBlock(CPubKey _pk,const CScript& _scriptPubKeyIn, int32
BOOST_FOREACH(const CTxIn& txin, tx.vin)
{
- /*
- if (tx.IsPegsImport() && txin.prevout.n==10e8)
- {
- CAmount nValueIn = GetCoinImportValue(tx); // burn amount
- nTotalIn += nValueIn;
- dPriority += (double)nValueIn * 1000; // flat multiplier... max = 1e16.
- continue;
- }
- */
// Read prev transaction
if (!view.HaveCoins(txin.prevout.hash))
{
@@ -488,38 +476,6 @@ CBlockTemplate* CreateNewBlock(CPubKey _pk,const CScript& _scriptPubKeyIn, int32
unsigned int nTxSize = ::GetSerializeSize(tx, SER_NETWORK, PROTOCOL_VERSION);
// fprintf(stderr,"%s: nTxSize = %u\n", __func__, nTxSize);
- // Opret spam limits
- if (mapArgs.count("-opretmintxfee"))
- {
- CAmount n = 0;
- CFeeRate opretMinFeeRate;
- if (ParseMoney(mapArgs["-opretmintxfee"], n) && n > 0)
- opretMinFeeRate = CFeeRate(n);
- else
- opretMinFeeRate = CFeeRate(400000); // default opretMinFeeRate (1 HUSH per 250 Kb = 0.004 per 1 Kb = 400000 puposhis per 1 Kb)
-
- bool fSpamTx = false;
- unsigned int nTxSize = ::GetSerializeSize(tx, SER_NETWORK, PROTOCOL_VERSION);
- unsigned int nTxOpretSize = 0;
-
- // calc total oprets size
- BOOST_FOREACH(const CTxOut& txout, tx.vout) {
- if (txout.scriptPubKey.IsOpReturn()) {
- CScript::const_iterator it = txout.scriptPubKey.begin() + 1;
- opcodetype op;
- std::vector opretData;
- if (txout.scriptPubKey.GetOp(it, op, opretData)) {
- //std::cerr << HexStr(opretData.begin(), opretData.end()) << std::endl;
- nTxOpretSize += opretData.size();
- }
- }
- }
-
- if ((nTxOpretSize > 256) && (feeRate < opretMinFeeRate)) fSpamTx = true;
- // std::cerr << tx.GetHash().ToString() << " nTxSize." << nTxSize << " nTxOpretSize." << nTxOpretSize << " feeRate." << feeRate.ToString() << " opretMinFeeRate." << opretMinFeeRate.ToString() << " fSpamTx." << fSpamTx << std::endl;
- if (fSpamTx) continue;
- // std::cerr << tx.GetHash().ToString() << " vecPriority.size() = " << vecPriority.size() << std::endl;
- }
if (nBlockSize + nTxSize >= nBlockMaxSize-512) // room for extra autotx
{
@@ -563,6 +519,40 @@ CBlockTemplate* CreateNewBlock(CPubKey _pk,const CScript& _scriptPubKeyIn, int32
}
CAmount nTxFees = view.GetValueIn(chainActive.LastTip()->GetHeight(),&interest,tx,chainActive.LastTip()->nTime)-tx.GetValueOut();
+ // Opret spam limits
+ CAmount opretMinFee = 1 * COIN;
+
+ // Set with -ac_minopreturnfee
+ if (ASSETCHAINS_MINOPRETURNFEE > 0) {
+ opretMinFee = ASSETCHAINS_MINOPRETURNFEE;
+ }
+
+ {
+ bool fSpamTx = false;
+ unsigned int nTxSize = ::GetSerializeSize(tx, SER_NETWORK, PROTOCOL_VERSION);
+ unsigned int nTxOpretSize = 0;
+
+ // calc total oprets size
+ BOOST_FOREACH(const CTxOut& txout, tx.vout) {
+ if (txout.scriptPubKey.IsOpReturn()) {
+ CScript::const_iterator it = txout.scriptPubKey.begin() + 1;
+ opcodetype op;
+ std::vector opretData;
+ if (txout.scriptPubKey.GetOp(it, op, opretData)) {
+ //std::cerr << HexStr(opretData.begin(), opretData.end()) << std::endl;
+ nTxOpretSize += opretData.size();
+ }
+ }
+ }
+
+ if (nTxOpretSize > 0 && nTxFees < opretMinFee) {
+ fSpamTx = true;
+ std::cerr << __func__ << ": " << tx.GetHash().ToString() << " nTxSize=" << nTxSize << " nTxOpretSize=" << nTxOpretSize << " feeRate=" << feeRate.ToString() << " opretMinFee=" << opretMinFee << " nTxFees=" << nTxFees <<" fSpamTx=" << fSpamTx << std::endl;
+ continue;
+ }
+ // std::cerr << tx.GetHash().ToString() << " vecPriority.size() = " << vecPriority.size() << std::endl;
+ }
+
nTxSigOps += GetP2SHSigOpCount(tx, view);
if (nBlockSigOps + nTxSigOps >= MAX_BLOCK_SIGOPS-1)
{
@@ -711,7 +701,7 @@ CBlockTemplate* CreateNewBlock(CPubKey _pk,const CScript& _scriptPubKeyIn, int32
if ( totalsats == 0 )
{
fprintf(stderr, "Could not create notary payment, trying again.\n");
- if ( SMART_CHAIN_SYMBOL[0] == 0 || (SMART_CHAIN_SYMBOL[0] != 0 && !isStake) )
+ if ( !isStake )
{
LEAVE_CRITICAL_SECTION(cs_main);
LEAVE_CRITICAL_SECTION(mempool.cs);
@@ -749,59 +739,21 @@ CBlockTemplate* CreateNewBlock(CPubKey _pk,const CScript& _scriptPubKeyIn, int32
pblock->hashFinalSaplingRoot = sapling_tree.root();
// all PoS chains need this data in the block at all times
- if ( ASSETCHAINS_LWMAPOS || ASSETCHAINS_STAKED == 0 || HUSH_MININGTHREADS > 0 )
+ if ( ASSETCHAINS_LWMAPOS || HUSH_MININGTHREADS > 0 )
{
UpdateTime(pblock, Params().GetConsensus(), pindexPrev);
pblock->nBits = GetNextWorkRequired(pindexPrev, pblock, Params().GetConsensus());
}
pblock->nSolution.clear();
pblocktemplate->vTxSigOps[0] = GetLegacySigOpCount(pblock->vtx[0]);
- /*
- if ( SMART_CHAIN_SYMBOL[0] == 0 && IS_HUSH_NOTARY != 0 && My_notaryid >= 0 )
- {
- uint32_t r; CScript opret; void **ptr=0;
- CMutableTransaction txNotary = CreateNewContextualCMutableTransaction(Params().GetConsensus(), chainActive.Height() + 1);
- if ( pblock->nTime < pindexPrev->nTime+60 )
- pblock->nTime = pindexPrev->nTime + 60;
- if ( gpucount < 33 )
- {
- uint8_t tmpbuffer[40]; uint32_t r; int32_t n=0; uint256 randvals;
- memcpy(&tmpbuffer[n],&My_notaryid,sizeof(My_notaryid)), n += sizeof(My_notaryid);
- memcpy(&tmpbuffer[n],&Mining_height,sizeof(Mining_height)), n += sizeof(Mining_height);
- memcpy(&tmpbuffer[n],&pblock->hashPrevBlock,sizeof(pblock->hashPrevBlock)), n += sizeof(pblock->hashPrevBlock);
- vcalc_sha256(0,(uint8_t *)&randvals,tmpbuffer,n);
- memcpy(&r,&randvals,sizeof(r));
- pblock->nTime += (r % (33 - gpucount)*(33 - gpucount));
- }
- if ( hush_notaryvin(txNotary,NOTARY_PUBKEY33,ptr) > 0 )
- {
- CAmount txfees = 5000;
- pblock->vtx.push_back(txNotary);
- pblocktemplate->vTxFees.push_back(txfees);
- pblocktemplate->vTxSigOps.push_back(GetLegacySigOpCount(txNotary));
- nFees += txfees;
- pblocktemplate->vTxFees[0] = -nFees;
- //*(uint64_t *)(&pblock->vtx[0].vout[0].nValue) += txfees;
- //fprintf(stderr,"added notaryvin\n");
- } else {
- fprintf(stderr,"error adding notaryvin, need to create 0.0001 utxos\n");
- if ( SMART_CHAIN_SYMBOL[0] == 0 || (SMART_CHAIN_SYMBOL[0] != 0 && !isStake) )
- {
- LEAVE_CRITICAL_SECTION(cs_main);
- LEAVE_CRITICAL_SECTION(mempool.cs);
- }
- return(0);
- }
- } else */
-
- if ( ASSETCHAINS_CC == 0 && pindexPrev != 0 && ASSETCHAINS_STAKED == 0 && (SMART_CHAIN_SYMBOL[0] != 0 || IS_HUSH_NOTARY == 0 || My_notaryid < 0) )
+ if ( ASSETCHAINS_CC == 0 && pindexPrev != 0 && (IS_HUSH_NOTARY == 0 || My_notaryid < 0) )
{
CValidationState state;
//fprintf(stderr,"%s: check validity\n", __func__);
if ( !TestBlockValidity(state, *pblock, pindexPrev, false, false)) // invokes CC checks
{
- if ( (SMART_CHAIN_SYMBOL[0] != 0 && !isStake) )
+ if ( !isStake )
{
LEAVE_CRITICAL_SECTION(cs_main);
LEAVE_CRITICAL_SECTION(mempool.cs);
@@ -813,11 +765,10 @@ CBlockTemplate* CreateNewBlock(CPubKey _pk,const CScript& _scriptPubKeyIn, int32
//fprintf(stderr,"valid\n");
}
}
- if ( (SMART_CHAIN_SYMBOL[0] != 0 && !isStake) )
- {
- LEAVE_CRITICAL_SECTION(cs_main);
- LEAVE_CRITICAL_SECTION(mempool.cs);
- }
+
+ LEAVE_CRITICAL_SECTION(cs_main);
+ LEAVE_CRITICAL_SECTION(mempool.cs);
+
// fprintf(stderr,"%s: done\n", __func__);
return pblocktemplate.release();
}
@@ -837,7 +788,7 @@ void IncrementExtraNonce(CBlock* pblock, CBlockIndex* pindexPrev, unsigned int&
hashPrevBlock = pblock->hashPrevBlock;
}
++nExtraNonce;
- unsigned int nHeight = pindexPrev->GetHeight()+1; // Height first in coinbase required for block.version=2
+ const unsigned int nHeight = pindexPrev->GetHeight()+1; // Height first in coinbase required for block.version=2
CMutableTransaction txCoinbase(pblock->vtx[0]);
txCoinbase.vin[0].scriptSig = (CScript() << nHeight << CScriptNum(nExtraNonce)) + COINBASE_FLAGS;
assert(txCoinbase.vin[0].scriptSig.size() <= 100);
@@ -931,6 +882,7 @@ static bool ProcessBlockFound(CBlock* pblock)
// Found a solution
{
+ LOCK(cs_main);
if (pblock->hashPrevBlock != chainActive.LastTip()->GetBlockHash())
{
uint256 hash; int32_t i;
@@ -1128,15 +1080,15 @@ void static RandomXMiner()
char randomxHash[RANDOMX_HASH_SIZE];
rxdebug("%s: created randomxHash of size %d\n", RANDOMX_HASH_SIZE);
char randomxKey[82]; // randomx spec says keysize of >60 bytes is implementation-specific
- // initial randomx key is unique to every Hush Smart Chain, and has at least 9 bytes (2^9=128 bits) of entropy
+ // initial randomx key is unique to every Hush Arrakis Chain, and has at least 9 bytes (2^9=128 bits) of entropy
// since magic is 4 bytes, rpc port is 4 bytes and smart chain symbol must be at least 1 character long
snprintf(randomxKey, 81, "%08x%s%08x", ASSETCHAINS_MAGIC, SMART_CHAIN_SYMBOL, ASSETCHAINS_RPCPORT);
// With the defaults of 1024 and 64
// the key block will change every ~21.3 hours with a 75s block time
- // and every ~17 hours with the default 60s block time for HSCs
+ // and every ~17 hours with the default 60s block time for HACs
static int randomxInterval = GetRandomXInterval();
- // This lag is 80 mins for 75s blocktime and 64 mins for 60s (default) blocktime for HSCs
+ // This lag is 80 mins for 75s blocktime and 64 mins for 60s (default) blocktime for HACs
static int randomxBlockLag = GetRandomXBlockLag();
randomx_vm *myVM = nullptr;
@@ -1174,7 +1126,11 @@ void static RandomXMiner()
// Create new block
unsigned int nTransactionsUpdatedLast = mempool.GetTransactionsUpdated();
- CBlockIndex* pindexPrev = chainActive.LastTip();
+ CBlockIndex* pindexPrev;
+ {
+ LOCK(cs_main);
+ pindexPrev = chainActive.LastTip();
+ }
// If we don't have a valid chain tip to work from, wait and try again.
if (pindexPrev == nullptr) {
@@ -1198,7 +1154,7 @@ void static RandomXMiner()
} else {
rxdebug("%s: calculating keyHeight with randomxInterval=%d\n", randomxInterval);
// At heights between intervals, we use the same block key and wait randomxBlockLag blocks until changing
- int keyHeight = ((Mining_height - randomxBlockLag) / randomxInterval) * randomxInterval;
+ const int keyHeight = ((Mining_height - randomxBlockLag) / randomxInterval) * randomxInterval;
uint256 randomxBlockKey = chainActive[keyHeight]->GetBlockHash();
randomx_init_cache(randomxCache, &randomxBlockKey, sizeof randomxBlockKey);
@@ -1210,10 +1166,10 @@ void static RandomXMiner()
rxdebug("%s: initializing dataset with %d threads\n", initThreadCount);
std::vector threads;
uint32_t startItem = 0;
- auto perThread = datasetItemCount / initThreadCount;
- auto remainder = datasetItemCount % initThreadCount;
+ const auto perThread = datasetItemCount / initThreadCount;
+ const auto remainder = datasetItemCount % initThreadCount;
for (int i = 0; i < initThreadCount; ++i) {
- auto count = perThread + (i == initThreadCount - 1 ? remainder : 0);
+ const auto count = perThread + (i == initThreadCount - 1 ? remainder : 0);
threads.push_back(std::thread(&randomx_init_dataset, randomxDataset, randomxCache, startItem, count));
startItem += count;
}
@@ -1252,7 +1208,7 @@ void static RandomXMiner()
return;
}
static uint32_t counter;
- if ( counter++ < 10 && ASSETCHAINS_STAKED == 0 )
+ if ( counter++ < 10 )
fprintf(stderr,"RandomXMiner: created illegal blockB, retry with counter=%u\n", counter);
sleep(1);
continue;
@@ -1367,6 +1323,7 @@ void static RandomXMiner()
}
CValidationState state;
+ //{ LOCK(cs_main);
if ( !TestBlockValidity(state,B, chainActive.LastTip(), true, false))
{
h = UintToArith256(B.GetHash());
@@ -1377,6 +1334,7 @@ void static RandomXMiner()
fprintf(stderr,"\n");
return(false);
}
+ //}
SetThreadPriority(THREAD_PRIORITY_NORMAL);
LogPrintf("HushRandomXMiner:\n");
LogPrintf("proof-of-work found \n hash: %s \ntarget: %s\n", B.GetHash().GetHex(), HASHTarget.GetHex());
@@ -1444,10 +1402,8 @@ void static RandomXMiner()
rxdebug("%s: going to destroy rx VM\n");
randomx_destroy_vm(myVM);
rxdebug("%s: destroyed VM\n");
-
}
-
} catch (const boost::thread_interrupted&) {
miningTimer.stop();
c.disconnect();
@@ -1735,6 +1691,8 @@ void static BitcoinMiner()
fprintf(stderr," mined %s block %d!\n",SMART_CHAIN_SYMBOL,Mining_height);
}
CValidationState state;
+
+ //{ LOCK(cs_main);
if ( !TestBlockValidity(state,B, chainActive.LastTip(), true, false))
{
h = UintToArith256(B.GetHash());
@@ -1744,6 +1702,8 @@ void static BitcoinMiner()
gotinvalid = 1;
return(false);
}
+
+ //}
HUSH_CHOSEN_ONE = 1;
// Found a solution
SetThreadPriority(THREAD_PRIORITY_NORMAL);
diff --git a/src/net.cpp b/src/net.cpp
index 1223e252f..4b52c796d 100644
--- a/src/net.cpp
+++ b/src/net.cpp
@@ -50,6 +50,9 @@ extern int32_t HUSH_TESTNODE;
// Satoshi originally used 10 seconds(!), did they know something Peter Wuille didn't?
#define DUMP_ADDRESSES_INTERVAL 300
+// Run asmap health check every 24hr by default
+#define ASMAP_HEALTHCHECK_INTERVAL 24*60*60
+
// This is every 2 blocks, on avg, on HUSH3
#define DUMP_ZINDEX_INTERVAL 150
@@ -1648,6 +1651,35 @@ int64_t PoissonNextSend(int64_t now, int average_interval_seconds)
return now + (int64_t)(log1p(GetRand(1ULL << 48) * -0.0000000000000035527136788 /* -1/2^48 */) * average_interval_seconds * -1000000.0 + 0.5);
}
+void ASMapHealthCheck() {
+ // No health check if clearnet is disabled
+ if (!GetBoolArg("-clearnet", DEFAULT_CLEARNET)) {
+ return;
+ }
+
+ std::set clearnet_asns{};
+ int unmapped_count{0};
+ LOCK(cs_vNodes);
+
+ for (const auto& pnode : vNodes) {
+ auto address = pnode->addr;
+ if(address.IsTor() || address.IsI2P() || address.IsCJDNS()) {
+ // These networks do not have ASNs, skip them
+ continue;
+ }
+ uint32_t asn = address.GetMappedAS(addrman.m_asmap);
+ if (asn == 0) {
+ ++unmapped_count;
+ continue;
+ }
+ clearnet_asns.insert(asn);
+ }
+
+ LogPrintf("ASMap Health Check: %i clearnet peers are mapped to %i ASNs with %i peers being unmapped\n", vNodes.size(), clearnet_asns.size(), unmapped_count);
+}
+
+
+
void ThreadOpenConnections()
{
// Connect to specific addresses
@@ -1753,7 +1785,7 @@ void ThreadOpenConnections()
int64_t nNow = GetTime();
int nTries = 0;
- LogPrint("net", "Resolving addrman collisions\n");
+ LogPrint("net", "Resolving addrman collisions\n");
addrman.ResolveCollisions();
while (true) {
@@ -2378,10 +2410,14 @@ void StartNode(boost::thread_group& threadGroup, CScheduler& scheduler)
scheduler.scheduleEvery(&DumpZindexStats, DUMP_ZINDEX_INTERVAL);
}
- // Dump network addresses
- scheduler.scheduleEvery(&DumpAddresses, DUMP_ADDRESSES_INTERVAL);
-
+ // Look for ~/.hush/AC_NAME/plz_stop
scheduler.scheduleEvery(&CheckIfWeShouldStop, CHECK_PLZ_STOP_INTERVAL);
+
+ // Schedule ASMap Health check to run regularly
+ scheduler.scheduleEvery(&ASMapHealthCheck, ASMAP_HEALTHCHECK_INTERVAL);
+
+ // and schedule it to run once in 5 mins when we hopefully have peers connected
+ scheduler.scheduleFromNow(&ASMapHealthCheck, 300);
}
bool StopNode()
@@ -2470,7 +2506,9 @@ void RelayTransaction(const CTransaction& tx, const CDataStream& ss)
// If we have no nodes to relay to, there is nothing to do
if(vNodes.size() == 0) {
- fprintf(stderr, "%s: No nodes to relay to!\n", __func__ );
+ if (HUSH_TESTNODE==0) {
+ fprintf(stderr, "%s: No nodes to relay to!\n", __func__ );
+ }
return;
}
@@ -2733,7 +2771,7 @@ bool CNode::GetTlsValidate()
{
if (tlsValidate == eTlsOption::FALLBACK_UNSET)
{
- // This is useful for private Hush Smart Chains, that want to exist
+ // This is useful for private Hush Arrakis Chains, that want to exist
// on a closed VPN with an internal CA or trusted cert system, or
// various other use cases
if ( GetBoolArg("-tlsvalidate", false)) {
@@ -2927,6 +2965,7 @@ void SetNetworkActive(bool active)
if (!fNetworkActive) {
LOCK(cs_vNodes);
// Close sockets to all nodes
+ LogPrint("net", "%s: closing sockets to all nodes\n", __func__);
for (CNode* pnode : vNodes) {
pnode->CloseSocketDisconnect();
}
diff --git a/src/net.h b/src/net.h
index f7df49aa7..937f07ef1 100644
--- a/src/net.h
+++ b/src/net.h
@@ -85,6 +85,15 @@ static const unsigned int MAX_PROTOCOL_MESSAGE_LENGTH = (_MAX_BLOCK_SIZE + 24);
static const unsigned int MAX_SUBVERSION_LENGTH = 256;
/** -listen default */
static const bool DEFAULT_LISTEN = true;
+
+/** -clearnet default */
+static const bool DEFAULT_CLEARNET = true;
+
+/** -disableipv4 default */
+static const bool DEFAULT_DISABLE_IPV4 = false;
+/** -disableipv6 default */
+static const bool DEFAULT_DISABLE_IPV6 = false;
+
/** The maximum number of entries in mapAskFor */
static const size_t MAPASKFOR_MAX_SZ = MAX_INV_SZ;
/** The maximum number of entries in setAskFor (larger due to getdata latency)*/
diff --git a/src/pow.cpp b/src/pow.cpp
index ac5bbb1f8..4aa00b094 100644
--- a/src/pow.cpp
+++ b/src/pow.cpp
@@ -511,7 +511,7 @@ unsigned int GetNextWorkRequired(const CBlockIndex* pindexLast, const CBlockHead
// Changing this requires changing many other things and
// might change consensus. Have fun -- Duke
-// NOTE: Ony HUSH3 mainnet should use this function, all HSC's should use params.AveragigWindowTimespan()
+// NOTE: Ony HUSH3 mainnet should use this function, all HAC's should use params.AveragigWindowTimespan()
int64_t AveragingWindowTimespan() {
// used in const methods, beware!
// This is the correct AWT for 75s blocktime, before block 340k
@@ -578,7 +578,7 @@ unsigned int CalculateNextWorkRequired(arith_uint256 bnAvg,
return bnNew.GetCompact();
}
-// HUSH does not use these functions but Hush Smart Chains can opt-in to using more bleeding edge DAA's
+// HUSH does not use these functions but Hush Arrakis Chains can opt-in to using more bleeding edge DAA's
// ASIC chains do not need these protections as much -- Duke Leto
unsigned int lwmaGetNextWorkRequired(const CBlockIndex* pindexLast, const CBlockHeader *pblock, const Consensus::Params& params)
{
diff --git a/src/primitives/transaction.h b/src/primitives/transaction.h
index 3741e0d96..a2584ca64 100644
--- a/src/primitives/transaction.h
+++ b/src/primitives/transaction.h
@@ -693,7 +693,7 @@ public:
bool IsMint() const
{
- return IsCoinImport() || IsCoinBase();
+ return IsCoinBase(); // || IsCoinImport();
}
bool IsCoinBase() const
@@ -705,7 +705,8 @@ public:
bool IsCoinImport() const
{
- return (vin.size() == 1 && vin[0].prevout.n == 10e8);
+ return false;
+ //return (vin.size() == 1 && vin[0].prevout.n == 10e8);
}
bool IsPegsImport() const
diff --git a/src/rpc/blockchain.cpp b/src/rpc/blockchain.cpp
index 6b5f2e6b3..d0029b73e 100644
--- a/src/rpc/blockchain.cpp
+++ b/src/rpc/blockchain.cpp
@@ -242,7 +242,7 @@ UniValue blockToDeltasJSON(const CBlock& block, const CBlockIndex* blockindex)
vector hashBytes(out.scriptPubKey.begin()+3, out.scriptPubKey.begin()+23);
delta.push_back(Pair("address", CBitcoinAddress(CKeyID(uint160(hashBytes))).ToString()));
}
- else if (out.scriptPubKey.IsPayToPublicKey() || out.scriptPubKey.IsPayToCryptoCondition()) {
+ else if (out.scriptPubKey.IsPayToPublicKey()) {
CTxDestination address;
if (ExtractDestination(out.scriptPubKey, address))
{
@@ -639,12 +639,6 @@ UniValue getblockhash(const UniValue& params, bool fHelp, const CPubKey& mypk)
return pblockindex->GetBlockHash().GetHex();
}
-UniValue getlastsegidstakes(const UniValue& params, bool fHelp, const CPubKey& mypk)
-{
- UniValue ret(UniValue::VOBJ);
- return ret;
-}
-
UniValue getblockheader(const UniValue& params, bool fHelp, const CPubKey& mypk)
{
if (fHelp || params.size() < 1 || params.size() > 2)
@@ -862,7 +856,7 @@ UniValue getblockmerkletree(const UniValue& params, bool fHelp, const CPubKey& m
if (fHelp || params.size() != 1 )
throw runtime_error(
"getblockmerkletree height\n"
- "\nGet full merkletree for a given Hush or HSC block height.\n"
+ "\nGet full merkletree for a given Hush or HAC block height.\n"
"\nArguments:\n"
"1. height (int, required) block height\n"
"\nResult:\n"
@@ -877,7 +871,7 @@ UniValue getblockmerkletree(const UniValue& params, bool fHelp, const CPubKey& m
int nHeight = params[0].get_int();
if ( (nHeight < 1) || (nHeight > chainActive.LastTip()->GetHeight()) ) {
- throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid Hush or HSC block height parameter");
+ throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid Hush or HAC block height parameter");
}
phushblockindex = chainActive[nHeight];
@@ -1620,12 +1614,12 @@ UniValue getchaintxstats(const UniValue& params, bool fHelp, const CPubKey& mypk
throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid block count: should be between 0 and the block's height - 1");
}
}
- LogPrintf("%s: blockcount = %d\n", __func__, blockcount);
+ // LogPrintf("%s: blockcount = %d\n", __func__, blockcount);
const CBlockIndex* pindexPast = pindex->GetAncestor(pindex->GetHeight() - blockcount);
int nTimeDiff = pindex->GetMedianTimePast() - pindexPast->GetMedianTimePast();
int nTxDiff = pindex->nChainTx - pindexPast->nChainTx;
- LogPrintf("%s: pindexPast.height = %d, pindex.height = %d\n", __func__, pindexPast->GetHeight(), pindex->GetHeight() );
+ // LogPrintf("%s: pindexPast.height = %d, pindex.height = %d\n", __func__, pindexPast->GetHeight(), pindex->GetHeight() );
UniValue ret(UniValue::VOBJ);
ret.pushKV("time", (int64_t)pindex->nTime);
@@ -1657,7 +1651,7 @@ UniValue getchaintxstats(const UniValue& params, bool fHelp, const CPubKey& mypk
ret.pushKV("window_tx_count", nTxDiff);
ret.pushKV("window_interval", nTimeDiff);
int64_t nPaymentsDiff = pindex->nChainPayments - pindexPast->nChainPayments;
- LogPrintf("%s: pindexPast.nChainPayments = %d, pindex.nChainPayments = %d\n", __func__, pindexPast->nChainPayments, pindex->nChainPayments );
+ //LogPrintf("%s: pindexPast.nChainPayments = %d, pindex.nChainPayments = %d\n", __func__, pindexPast->nChainPayments, pindex->nChainPayments );
int64_t nShieldedTxDiff = pindex->nChainShieldedTx - pindexPast->nChainShieldedTx;
int64_t nShieldingTxDiff = pindex->nChainShieldingTx - pindexPast->nChainShieldingTx;
int64_t nDeshieldingTxDiff = pindex->nChainDeshieldingTx - pindexPast->nChainDeshieldingTx;
diff --git a/src/rpc/client.cpp b/src/rpc/client.cpp
index 517f254c1..132362a88 100644
--- a/src/rpc/client.cpp
+++ b/src/rpc/client.cpp
@@ -90,10 +90,8 @@ static const CRPCConvertParam vRPCConvertParams[] =
{ "getblock", 1 },
{ "getblockheader", 1 },
{ "getchaintxstats", 0 },
- { "getlastsegidstakes", 0 },
{ "gettransaction", 1 },
{ "getrawtransaction", 1 },
- { "getlastsegidstakes", 0 },
{ "createrawtransaction", 0 },
{ "createrawtransaction", 1 },
{ "createrawtransaction", 2 },
diff --git a/src/rpc/misc.cpp b/src/rpc/misc.cpp
index 5273d40d8..c048b305d 100644
--- a/src/rpc/misc.cpp
+++ b/src/rpc/misc.cpp
@@ -231,11 +231,12 @@ UniValue getinfo(const UniValue& params, bool fHelp, const CPubKey& mypk)
+ HelpExampleCli("getinfo", "")
+ HelpExampleRpc("getinfo", "")
);
- //#ifdef ENABLE_WALLET
- // LOCK2(cs_main, pwalletMain ? &pwalletMain->cs_wallet : NULL);
- //#else
+
+#ifdef ENABLE_WALLET
+ LOCK2(cs_main, pwalletMain ? &pwalletMain->cs_wallet : NULL);
+#else
LOCK(cs_main);
- //#endif
+#endif
proxyType proxy;
GetProxy(NET_IPV4, proxy);
@@ -482,13 +483,13 @@ UniValue validateaddress(const UniValue& params, bool fHelp, const CPubKey& mypk
if (fHelp || params.size() != 1)
throw runtime_error(
"validateaddress \"addr\"\n"
- "\nReturn information about the given Hush or Hush Smart Chain (HSC) address.\n"
+ "\nReturn information about the given Hush or Hush Arrakis Chain (HAC) address.\n"
"\nArguments:\n"
"1. \"addr\" (string, required) The address to validate\n"
"\nResult:\n"
"{\n"
" \"isvalid\" : true|false, (boolean) If the address is valid or not. If not, this is the only property returned.\n"
- " \"address\" : \"addr\", (string) The Hush or HSC address validated\n"
+ " \"address\" : \"addr\", (string) The Hush or HAC address validated\n"
" \"scriptPubKey\" : \"hex\", (string) The hex encoded scriptPubKey generated by the address\n"
" \"ismine\" : true|false, (boolean) If the address is yours or not\n"
" \"isscript\" : true|false, (boolean) If the key is a script\n"
diff --git a/src/rpc/net.cpp b/src/rpc/net.cpp
index de61c3eff..096f7b558 100644
--- a/src/rpc/net.cpp
+++ b/src/rpc/net.cpp
@@ -31,6 +31,8 @@
#include
#include
+extern uint16_t ASSETCHAINS_P2PPORT,ASSETCHAINS_RPCPORT;
+
using namespace std;
using namespace hush;
@@ -276,8 +278,8 @@ UniValue addnode(const UniValue& params, bool fHelp, const CPubKey& mypk)
"1. \"node\" (string, required) The node (see getpeerinfo for nodes)\n"
"2. \"command\" (string, required) 'add' to add a node to the list, 'remove' to remove a node from the list, 'onetry' to try a connection to the node once\n"
"\nExamples:\n"
- + HelpExampleCli("addnode", "\"192.168.0.6:18030\" \"onetry\"")
- + HelpExampleRpc("addnode", "\"192.168.0.6:18030\", \"onetry\"")
+ + HelpExampleCli("addnode", "\"192.168.0.6:" + to_string(ASSETCHAINS_P2PPORT) + "\" \"onetry\"")
+ + HelpExampleRpc("addnode", "\"192.168.0.6:" + to_string(ASSETCHAINS_P2PPORT) + "\", \"onetry\"")
);
string strNode = params[0].get_str();
@@ -320,8 +322,8 @@ UniValue disconnectnode(const UniValue& params, bool fHelp, const CPubKey& mypk)
"\nArguments:\n"
"1. \"node\" (string, required) The node (see getpeerinfo for nodes)\n"
"\nExamples:\n"
- + HelpExampleCli("disconnectnode", "\"192.168.0.6:18030\"")
- + HelpExampleRpc("disconnectnode", "\"192.168.0.6:18030\"")
+ + HelpExampleCli("disconnectnode", "\"192.168.0.6:" + to_string(ASSETCHAINS_P2PPORT) + "\"")
+ + HelpExampleRpc("disconnectnode", "\"192.168.0.6:" + to_string(ASSETCHAINS_P2PPORT) + "\"")
);
CNode* pNode = FindNode(params[0].get_str());
diff --git a/src/rpc/rawtransaction.cpp b/src/rpc/rawtransaction.cpp
index 4de29bd4c..4c9de7c95 100644
--- a/src/rpc/rawtransaction.cpp
+++ b/src/rpc/rawtransaction.cpp
@@ -146,31 +146,7 @@ void TxToJSONExpanded(const CTransaction& tx, const uint256 hashBlock, UniValue&
UniValue in(UniValue::VOBJ);
if (tx.IsCoinBase()) {
in.push_back(Pair("coinbase", HexStr(txin.scriptSig.begin(), txin.scriptSig.end())));
- }
- /* else if (tx.IsCoinImport() && txin.prevout.n==10e8) {
- in.push_back(Pair("is_import", "1"));
- ImportProof proof; CTransaction burnTx; std::vector payouts; CTxDestination importaddress;
- if (UnmarshalImportTx(tx, proof, burnTx, payouts))
- {
- if (burnTx.vout.size() == 0)
- continue;
- in.push_back(Pair("txid", burnTx.GetHash().ToString()));
- in.push_back(Pair("value", ValueFromAmount(burnTx.vout.back().nValue)));
- in.push_back(Pair("valueSat", burnTx.vout.back().nValue));
- // extract op_return to get burn source chain.
- std::vector burnOpret; std::string targetSymbol; uint32_t targetCCid; uint256 payoutsHash; std::vectorrawproof;
- if (UnmarshalBurnTx(burnTx, targetSymbol, &targetCCid, payoutsHash, rawproof))
- {
- if (rawproof.size() > 0)
- {
- std::string sourceSymbol;
- E_UNMARSHAL(rawproof, ss >> sourceSymbol);
- in.push_back(Pair("address", "IMP-" + sourceSymbol + "-" + burnTx.GetHash().ToString()));
- }
- }
- }
- } */
- else {
+ } else {
in.push_back(Pair("txid", txin.prevout.hash.GetHex()));
in.push_back(Pair("vout", (int64_t)txin.prevout.n));
{
diff --git a/src/rpc/server.cpp b/src/rpc/server.cpp
index d98332447..6373d554d 100644
--- a/src/rpc/server.cpp
+++ b/src/rpc/server.cpp
@@ -320,7 +320,6 @@ static const CRPCCommand vRPCCommands[] =
{ "blockchain", "getblockhashes", &getblockhashes, true },
{ "blockchain", "getblockhash", &getblockhash, true },
{ "blockchain", "getblockheader", &getblockheader, true },
- { "blockchain", "getlastsegidstakes", &getlastsegidstakes, true },
{ "blockchain", "getchaintips", &getchaintips, true },
{ "blockchain", "getdifficulty", &getdifficulty, true },
{ "blockchain", "getmempoolinfo", &getmempoolinfo, true },
@@ -431,7 +430,6 @@ static const CRPCCommand vRPCCommands[] =
{ "wallet", "getbalance", &getbalance, false },
{ "wallet", "getbalance64", &getbalance64, false },
{ "wallet", "getnewaddress", &getnewaddress, true },
-// { "wallet", "getnewaddress64", &getnewaddress64, true },
{ "wallet", "getrawchangeaddress", &getrawchangeaddress, true },
{ "wallet", "getreceivedbyaccount", &getreceivedbyaccount, false },
{ "wallet", "getreceivedbyaddress", &getreceivedbyaddress, false },
diff --git a/src/rpc/server.h b/src/rpc/server.h
index 4f3577719..9a66fea43 100644
--- a/src/rpc/server.h
+++ b/src/rpc/server.h
@@ -245,7 +245,6 @@ extern UniValue cclibinfo(const UniValue& params, bool fHelp, const CPubKey& myp
extern UniValue cclib(const UniValue& params, bool fHelp, const CPubKey& mypk);
extern UniValue getnewaddress(const UniValue& params, bool fHelp, const CPubKey& mypk); // in rpcwallet.cpp
-//extern UniValue getnewaddress64(const UniValue& params, bool fHelp, const CPubKey& mypk); // in rpcwallet.cpp
extern UniValue getaccountaddress(const UniValue& params, bool fHelp, const CPubKey& mypk);
extern UniValue getrawchangeaddress(const UniValue& params, bool fHelp, const CPubKey& mypk);
extern UniValue setaccount(const UniValue& params, bool fHelp, const CPubKey& mypk);
@@ -286,7 +285,6 @@ extern UniValue getdragonjson(const UniValue& params, bool fHelp, const CPubKey&
extern UniValue getnotarysendmany(const UniValue& params, bool fHelp, const CPubKey& mypk);
extern UniValue geterablockheights(const UniValue& params, bool fHelp, const CPubKey& mypk);
extern UniValue setpubkey(const UniValue& params, bool fHelp, const CPubKey& mypk);
-extern UniValue setstakingsplit(const UniValue& params, bool fHelp, const CPubKey& mypk);
extern UniValue getwalletinfo(const UniValue& params, bool fHelp, const CPubKey& mypk);
extern UniValue getblockchaininfo(const UniValue& params, bool fHelp, const CPubKey& mypk);
extern UniValue getnetworkinfo(const UniValue& params, bool fHelp, const CPubKey& mypk);
@@ -316,7 +314,6 @@ extern UniValue getblockhashes(const UniValue& params, bool fHelp, const CPubKey
extern UniValue getblockdeltas(const UniValue& params, bool fHelp, const CPubKey& mypk);
extern UniValue getblockhash(const UniValue& params, bool fHelp, const CPubKey& mypk);
extern UniValue getblockheader(const UniValue& params, bool fHelp, const CPubKey& mypk);
-extern UniValue getlastsegidstakes(const UniValue& params, bool fHelp, const CPubKey& mypk);
extern UniValue getblock(const UniValue& params, bool fHelp, const CPubKey& mypk);
extern UniValue gettxoutsetinfo(const UniValue& params, bool fHelp, const CPubKey& mypk);
extern UniValue gettxout(const UniValue& params, bool fHelp, const CPubKey& mypk);
diff --git a/src/sc/koolaid b/src/sc/koolaid
index 9db2e58ce..a46b71aeb 100755
--- a/src/sc/koolaid
+++ b/src/sc/koolaid
@@ -1,3 +1,3 @@
#!/usr/bin/env bash
# Copyright (c) 2018-2024 The Hush developers
-./hush-smart-chain -ac_name=KOOLAID $@
+./hush-arrakis-chain -ac_name=KOOLAID $@
diff --git a/src/sc/kush b/src/sc/kush
index bb8a34893..a5349a6a3 100755
--- a/src/sc/kush
+++ b/src/sc/kush
@@ -1,3 +1,3 @@
#!/usr/bin/env bash
# Copyright (c) 2018-2024 The Hush developers
-./hush-smart-chain -ac_name=KUSH $@
+./hush-arrakis-chain -ac_name=KUSH $@
diff --git a/src/sc/zex b/src/sc/zex
index 12ffea170..55b4640ef 100755
--- a/src/sc/zex
+++ b/src/sc/zex
@@ -1,3 +1,3 @@
#!/usr/bin/env bash
# Copyright (c) 2018-2024 The Hush developers
-./hush-smart-chain -ac_name=ZEX $@
+./hush-arrakis-chain -ac_name=ZEX $@
diff --git a/src/script/interpreter.cpp b/src/script/interpreter.cpp
index a8d5fa6ce..68930a5b5 100644
--- a/src/script/interpreter.cpp
+++ b/src/script/interpreter.cpp
@@ -957,37 +957,6 @@ bool EvalScript(
}
break;
- /*
- case OP_CHECKCRYPTOCONDITION:
- case OP_CHECKCRYPTOCONDITIONVERIFY:
- {
- if (!IsCryptoConditionsEnabled()) {
- goto INTERPRETER_DEFAULT;
- }
-
- if (stack.size() < 2)
- return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
- //fprintf(stderr,"check cryptocondition\n");
- int fResult = checker.CheckCryptoCondition(stacktop(-1), stacktop(-2), script, consensusBranchId);
- if (fResult == -1) {
- return set_error(serror, SCRIPT_ERR_CRYPTOCONDITION_INVALID_FULFILLMENT);
- }
-
- popstack(stack);
- popstack(stack);
-
- stack.push_back(fResult == 1 ? vchTrue : vchFalse);
-
- if (opcode == OP_CHECKCRYPTOCONDITIONVERIFY)
- {
- if (fResult == 1)
- popstack(stack);
- else
- return set_error(serror, SCRIPT_ERR_CRYPTOCONDITION_VERIFY);
- }
- }
- break;
- */
INTERPRETER_DEFAULT:
default:
@@ -1356,15 +1325,6 @@ bool TransactionSignatureChecker::CheckSig(
}
-int TransactionSignatureChecker::CheckCryptoCondition(
- const std::vector& condBin,
- const std::vector& ffillBin,
- const CScript& scriptCode,
- uint32_t consensusBranchId) const
-{
- return 0;
-}
-
bool TransactionSignatureChecker::CheckLockTime(const CScriptNum& nLockTime) const
{
// There are two times of nLockTime: lock-by-blockheight
@@ -1407,38 +1367,6 @@ bool TransactionSignatureChecker::CheckLockTime(const CScriptNum& nLockTime) con
return true;
}
-
-/*
- * Allow larger opcode in case of crypto condition scriptSig
- */
-bool EvalCryptoConditionSig(
- vector >& stack,
- const CScript& scriptSig,
- ScriptError* serror)
-{
- CScript::const_iterator pc = scriptSig.begin();
- opcodetype opcode;
- valtype vchPushValue;
- set_error(serror, SCRIPT_ERR_UNKNOWN_ERROR);
-
- if (!scriptSig.GetOp(pc, opcode, vchPushValue))
- return set_error(serror, SCRIPT_ERR_BAD_OPCODE);
-
- if (opcode == 0 || opcode > OP_PUSHDATA4)
- return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
-
- if (pc != scriptSig.end())
- return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
-
- if (vchPushValue.size() > MAX_SCRIPT_CRYPTOCONDITION_FULFILLMENT_SIZE)
- return set_error(serror, SCRIPT_ERR_PUSH_SIZE);
-
- stack.push_back(vchPushValue);
-
- return true;
-}
-
-
bool VerifyScript(
const CScript& scriptSig,
const CScript& scriptPubKey,
@@ -1454,12 +1382,7 @@ bool VerifyScript(
}
vector > stack, stackCopy;
- if (IsCryptoConditionsEnabled() && scriptPubKey.IsPayToCryptoCondition()) {
- if (!EvalCryptoConditionSig(stack, scriptSig, serror))
- // serror is set
- return false;
- }
- else if (!EvalScript(stack, scriptSig, flags, checker, consensusBranchId, serror))
+ if (!EvalScript(stack, scriptSig, flags, checker, consensusBranchId, serror))
// serror is set
return false;
if (flags & SCRIPT_VERIFY_P2SH)
diff --git a/src/script/interpreter.h b/src/script/interpreter.h
index a1be175ac..2c110a57e 100644
--- a/src/script/interpreter.h
+++ b/src/script/interpreter.h
@@ -147,15 +147,6 @@ public:
return false;
}
- virtual int CheckCryptoCondition(
- const std::vector& condBin,
- const std::vector& ffillBin,
- const CScript& scriptCode,
- uint32_t consensusBranchId) const
- {
- return false;
- }
-
virtual ~BaseSignatureChecker() {}
};
@@ -174,11 +165,6 @@ public:
TransactionSignatureChecker(const CTransaction* txToIn, unsigned int nInIn, const CAmount& amountIn, const PrecomputedTransactionData& txdataIn) : txTo(txToIn), nIn(nInIn), amount(amountIn), txdata(&txdataIn) {}
bool CheckSig(const std::vector& scriptSig, const std::vector& vchPubKey, const CScript& scriptCode, uint32_t consensusBranchId) const;
bool CheckLockTime(const CScriptNum& nLockTime) const;
- int CheckCryptoCondition(
- const std::vector& condBin,
- const std::vector& ffillBin,
- const CScript& scriptCode,
- uint32_t consensusBranchId) const;
};
class MutableTransactionSignatureChecker : public TransactionSignatureChecker
diff --git a/src/script/script.cpp b/src/script/script.cpp
index afae6f1d6..09b876ed9 100644
--- a/src/script/script.cpp
+++ b/src/script/script.cpp
@@ -156,9 +156,6 @@ const char* GetOpName(opcodetype opcode)
case OP_CHECKSIGVERIFY : return "OP_CHECKSIGVERIFY";
case OP_CHECKMULTISIG : return "OP_CHECKMULTISIG";
case OP_CHECKMULTISIGVERIFY : return "OP_CHECKMULTISIGVERIFY";
- case OP_CHECKCRYPTOCONDITION : return "OP_CHECKCRYPTOCONDITION";
- case OP_CHECKCRYPTOCONDITIONVERIFY
- : return "OP_CHECKCRYPTOCONDITIONVERIFY";
// expansion
case OP_NOP1 : return "OP_NOP1";
@@ -382,12 +379,6 @@ bool CScript::MayAcceptCryptoCondition() const
bool CScript::IsCoinImport() const
{
- const_iterator pc = this->begin();
- vector data;
- opcodetype opcode;
- if (this->GetOp(pc, opcode, data))
- if (opcode > OP_0 && opcode <= OP_PUSHDATA4)
- return data.begin()[0] == EVAL_IMPORTCOIN;
return false;
}
diff --git a/src/script/script.h b/src/script/script.h
index cc35f0364..b3d1d203f 100644
--- a/src/script/script.h
+++ b/src/script/script.h
@@ -40,9 +40,6 @@
static const unsigned int MAX_SCRIPT_ELEMENT_SIZE = 520; // bytes
-// Max size of pushdata in a CC sig in bytes
-static const unsigned int MAX_SCRIPT_CRYPTOCONDITION_FULFILLMENT_SIZE = 2048;
-
// Maximum script length in bytes
static const int MAX_SCRIPT_SIZE = 10000;
@@ -178,8 +175,6 @@ enum opcodetype
OP_CHECKSIGVERIFY = 0xad,
OP_CHECKMULTISIG = 0xae,
OP_CHECKMULTISIGVERIFY = 0xaf,
- OP_CHECKCRYPTOCONDITION = 0xcc,
- OP_CHECKCRYPTOCONDITIONVERIFY = 0xcd,
// expansion
OP_NOP1 = 0xb0,
@@ -200,7 +195,6 @@ enum opcodetype
OP_PUBKEYS = 0xfb,
OP_PUBKEYHASH = 0xfd,
OP_PUBKEY = 0xfe,
- OP_CRYPTOCONDITION = 0xfc,
OP_INVALIDOPCODE = 0xff,
};
diff --git a/src/script/script_error.cpp b/src/script/script_error.cpp
index cd1989e44..5529362d6 100644
--- a/src/script/script_error.cpp
+++ b/src/script/script_error.cpp
@@ -83,8 +83,6 @@ const char* ScriptErrorString(const ScriptError serror)
return "NOPx reserved for soft-fork upgrades";
case SCRIPT_ERR_PUBKEYTYPE:
return "Public key is neither compressed or uncompressed";
- case SCRIPT_ERR_CRYPTOCONDITION_INVALID_FULFILLMENT:
- return "Crypto-Condition payload is invalid";
case SCRIPT_ERR_UNKNOWN_ERROR:
case SCRIPT_ERR_ERROR_COUNT:
default: break;
diff --git a/src/script/script_error.h b/src/script/script_error.h
index d34e715a6..278852f6e 100644
--- a/src/script/script_error.h
+++ b/src/script/script_error.h
@@ -70,9 +70,6 @@ typedef enum ScriptError_t
SCRIPT_ERR_ERROR_COUNT,
- /* crypto-condition script errors */
- SCRIPT_ERR_CRYPTOCONDITION_VERIFY,
- SCRIPT_ERR_CRYPTOCONDITION_INVALID_FULFILLMENT
} ScriptError;
#define SCRIPT_ERR_LAST SCRIPT_ERR_ERROR_COUNT
diff --git a/src/script/sign.cpp b/src/script/sign.cpp
index 245806733..afc778d4b 100644
--- a/src/script/sign.cpp
+++ b/src/script/sign.cpp
@@ -128,29 +128,6 @@ static bool SignN(const vector& multisigdata, const BaseSignatureCreato
return nSigned==nRequired;
}
-std::vector &GetCryptoConditions()
-{
- static bool initialized = false;
- static std::vector vCC = std::vector();
- CCcontract_info C;
-
- if (!initialized)
- {
- // this should initialize any desired auto-signed crypto-conditions
- }
- return vCC;
-}
-
-bool GetCCByUnspendableAddress(struct CCcontract_info *cp, char *addrstr)
-{
- return false;
-}
-
-bool CCinitLite(struct CCcontract_info *cp, uint8_t evalcode)
-{
- return false;
-}
-
bool _Getscriptaddress(char *destaddr, const CScript &scriptPubKey)
{
CTxDestination address;
@@ -239,9 +216,6 @@ static bool SignStep(const BaseSignatureCreator& creator, const CScript& scriptP
}
return false;
- case TX_CRYPTOCONDITION:
- return SignStepCC(creator, scriptPubKey, vSolutions, ret, consensusBranchId);
-
case TX_MULTISIG:
ret.push_back(valtype()); // workaround CHECKMULTISIG bug
return (SignN(vSolutions, creator, scriptPubKey, ret, consensusBranchId));
@@ -429,11 +403,6 @@ static Stacks CombineSignatures(const CScript& scriptPubKey, const BaseSignature
return sigs2;
case TX_PUBKEY:
case TX_PUBKEYHASH:
- case TX_CRYPTOCONDITION:
- // Signatures are bigger than placeholders or empty scripts:
- if (sigs1.script.empty() || sigs1.script[0].empty())
- return sigs2;
- return sigs1;
case TX_SCRIPTHASH:
if (sigs1.script.empty() || sigs1.script.back().empty())
return sigs2;
diff --git a/src/script/standard.cpp b/src/script/standard.cpp
index 1ace50bc1..637da08ec 100644
--- a/src/script/standard.cpp
+++ b/src/script/standard.cpp
@@ -143,7 +143,6 @@ const char* GetTxnOutputType(txnouttype t)
case TX_SCRIPTHASH: return "scripthash";
case TX_MULTISIG: return "multisig";
case TX_NULL_DATA: return "nulldata";
- case TX_CRYPTOCONDITION: return "cryptocondition";
default: return "invalid";
}
return NULL;
@@ -183,40 +182,6 @@ bool Solver(const CScript& scriptPubKey, txnouttype& typeRet, vector> vParams;
- if (scriptPubKey.IsPayToCryptoCondition(&ccSubScript, vParams))
- {
- if (scriptPubKey.MayAcceptCryptoCondition())
- {
- typeRet = TX_CRYPTOCONDITION;
- vector hashBytes; uint160 x; int32_t i; uint8_t hash20[20],*ptr;;
- x = Hash160(ccSubScript);
- memcpy(hash20,&x,20);
- hashBytes.resize(20);
- ptr = hashBytes.data();
- for (i=0; i<20; i++)
- ptr[i] = hash20[i];
- vSolutionsRet.push_back(hashBytes);
- if (vParams.size())
- {
- COptCCParams cp = COptCCParams(vParams[0]);
- if (cp.IsValid())
- {
- for (auto k : cp.vKeys)
- {
- vSolutionsRet.push_back(std::vector(k.begin(), k.end()));
- }
- }
- }
- return true;
- }
- return false;
- }
- }
-
// Scan templates
const CScript& script1 = scriptPubKey;
BOOST_FOREACH(const PAIRTYPE(txnouttype, CScript)& tplate, mTemplates)
@@ -328,8 +293,6 @@ int ScriptSigArgsExpected(txnouttype t, const std::vector 1)
- {
- CPubKey pk = CPubKey((vSolutions[1]));
- addressRet = pk;
- return pk.IsValid();
- }
- else
- {
- addressRet = CKeyID(uint160(vSolutions[0]));
- }
- return true;
- }
// Multisig txns have more than one address...
return false;
}
@@ -464,30 +412,7 @@ bool ExtractDestinations(const CScript& scriptPubKey, txnouttype& typeRet, vecto
if (addressRet.empty())
return false;
- }
- // Removed to get CC address printed in getrawtransaction and decoderawtransaction
- // else if (IsCryptoConditionsEnabled() != 0 && typeRet == TX_CRYPTOCONDITION)
- // {
- // nRequiredRet = vSolutions.front()[0];
- // for (unsigned int i = 1; i < vSolutions.size()-1; i++)
- // {
- // CTxDestination address;
- // if (vSolutions[i].size() == 20)
- // {
- // address = CKeyID(uint160(vSolutions[i]));
- // }
- // else
- // {
- // address = CPubKey(vSolutions[i]);
- // }
- // addressRet.push_back(address);
- // }
-
- // if (addressRet.empty())
- // return false;
- // }
- else
- {
+ } else {
nRequiredRet = 1;
CTxDestination address;
if (!ExtractDestination(scriptPubKey, address))
diff --git a/src/script/standard.h b/src/script/standard.h
index fa30be959..3da0d51c8 100644
--- a/src/script/standard.h
+++ b/src/script/standard.h
@@ -75,7 +75,6 @@ enum txnouttype
TX_PUBKEYHASH,
TX_SCRIPTHASH,
TX_MULTISIG,
- TX_CRYPTOCONDITION,
TX_NULL_DATA,
};
diff --git a/src/sietch.h b/src/sietch.h
index fe6352072..4194e19eb 100644
--- a/src/sietch.h
+++ b/src/sietch.h
@@ -29,8 +29,8 @@ SendManyRecipient newSietchRecipient(string zaddr) {
// Sietch zouts have random data in their memos so they are indistinguishable from
// encrypted data being stored in the memo field
char hex[] = {'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'};
- // memo field is 512 bytes or 1024 hex chars
- char str[1024];
+ // memo field is 512 bytes or 1024 hex chars plus a null byte
+ char str[1025];
for(int i=0;i<1024;i++) {
str[i] = hex[GetRandInt(16)];
}
diff --git a/src/smartchains b/src/smartchains
index ce46c8f18..e48482da2 100755
--- a/src/smartchains
+++ b/src/smartchains
@@ -6,7 +6,7 @@ set -eo pipefail
source pubkey.txt
overide_args="$@"
seed_ip=$(SEEDNODE)
-hsc='./hush-smart-chain'
+hsc='./hush-arrakis-chain'
if [ -z "$delay" ]; then delay=20; fi
diff --git a/src/smartchains.old b/src/smartchains.old
deleted file mode 100755
index 4df00be85..000000000
--- a/src/smartchains.old
+++ /dev/null
@@ -1,17 +0,0 @@
-#!/usr/bin/env bash
-# Copyright (c) 2018-2024 The Hush developers
-set -x
-delay=60
-source pubkey.txt
-echo $pubkey
-echo "jl777 is a traitor to his village of cypherpunks, ca333 is his obedient servant"
-
-hsc="./hush-smart-chain"
-ip=$(HUSHDEX_SEEDNODE)
-
-# this chain helps power HushDEX
-$hsc -pubkey=$pubkey -ac_name=ZEX -ac_supply=100000000 -addnode=$ip $@ &
-
-# these are testcoins, like ARRR
-$hsc -pubkey=$pubkey -ac_name=ZUSH -ac_supply=100000000 -addnode=$ip $@ &
-$hsc -pubkey=$pubkey -ac_name=KOOLAID -ac_supply=100000000 -addnode=$ip $@ &
diff --git a/src/sync.cpp b/src/sync.cpp
index 4b7dd899b..16c4c86a2 100644
--- a/src/sync.cpp
+++ b/src/sync.cpp
@@ -25,6 +25,15 @@
#include
#include
+#ifdef _WIN32
+#include
+#include
+#else
+#include /* backtrace, backtrace_symbols_fd */
+#endif
+
+#include /* STDOUT_FILENO */
+
#ifdef DEBUG_LOCKCONTENTION
void PrintLockContention(const char* pszName, const char* pszFile, int nLine)
{
@@ -177,12 +186,23 @@ std::string LocksHeld()
return result;
}
+void print_stacktrace(void) {
+ size_t size;
+ enum Constexpr { MAX_SIZE = 1024 };
+ void *array[MAX_SIZE];
+ size = backtrace(array, MAX_SIZE);
+ backtrace_symbols_fd(array, size, STDERR_FILENO);
+}
+
void AssertLockHeldInternal(const char* pszName, const char* pszFile, int nLine, void* cs)
{
BOOST_FOREACH (const PAIRTYPE(void*, CLockLocation) & i, *lockstack)
if (i.first == cs)
return;
fprintf(stderr, "Assertion failed: lock %s not held in %s:%i; locks held:\n%s", pszName, pszFile, nLine, LocksHeld().c_str());
+
+ print_stacktrace();
+
abort();
}
diff --git a/src/testdragonxd b/src/testdragonxd
index 640152196..953ffd4ae 100755
--- a/src/testdragonxd
+++ b/src/testdragonxd
@@ -14,4 +14,4 @@ BLOCKTIME=18
SUPPLY=0
# Remember Remember the 5th November for freedom of speech is not free!!
-./hush-smart-chain -ac_name=TESTDRAGONX -ac_algo=randomx -ac_halving=3500000 -ac_reward=300000000 -ac_blocktime=$BLOCKTIME -ac_private=1 -ac_supply=$SUPPLY -debug=randomx $@
+./hush-arrakis-chain -ac_name=TESTDRAGONX -ac_algo=randomx -ac_halving=3500000 -ac_reward=300000000 -ac_blocktime=$BLOCKTIME -ac_private=1 -ac_supply=$SUPPLY -debug=randomx $@
diff --git a/src/testequihashd b/src/testequihashd
index 3de539bd9..5e46cddc1 100755
--- a/src/testequihashd
+++ b/src/testequihashd
@@ -15,4 +15,4 @@ SUPPLY=0
# same as TESTDRAGONX except equihash and different ac_name
# and debug=pow which is the equivalent of debug=randomx for equihash mining
-./hush-smart-chain -ac_name=TESTEQUIHASH -ac_halving=3500000 -ac_reward=300000000 -ac_blocktime=$BLOCKTIME -ac_private=1 -ac_supply=$SUPPLY -debug=pow $@
+./hush-arrakis-chain -ac_name=TESTEQUIHASH -ac_halving=3500000 -ac_reward=300000000 -ac_blocktime=$BLOCKTIME -ac_private=1 -ac_supply=$SUPPLY -debug=pow $@
diff --git a/src/timedata.cpp b/src/timedata.cpp
index cfffcf667..0ffb66e0a 100644
--- a/src/timedata.cpp
+++ b/src/timedata.cpp
@@ -71,11 +71,11 @@ void CTimeWarning::Warn(size_t peersAhead, size_t peersBehind)
{
std::string strMessage;
if (peersBehind >= TIMEDATA_WARNING_MAJORITY) {
- strMessage = _("Warning: Your computer's date and time may be ahead of the rest of the network! If your clock is wrong Hush will not work properly.");
+ strMessage = _("Warning: Your computer's date and time may be ahead of the rest of the network! If your clock is wrong this node will not work properly.");
} else if (peersAhead >= TIMEDATA_WARNING_MAJORITY) {
- strMessage = _("Warning: Your computer's date and time may be behind the rest of the network! If your clock is wrong Hush will not work properly.");
+ strMessage = _("Warning: Your computer's date and time may be behind the rest of the network! If your clock is wrong this node will not work properly.");
} else {
- strMessage = _("Warning: Please check that your computer's date and time are correct! If your clock is wrong Hush will not work properly.");
+ strMessage = _("Warning: Please check that your computer's date and time are correct! If your clock is wrong this node will not work properly.");
}
LogPrintf("*** %s\n", strMessage);
uiInterface.ThreadSafeMessageBox(strMessage, "", CClientUIInterface::MSG_WARNING);
diff --git a/src/txdb.cpp b/src/txdb.cpp
index 286919bb7..6a6f7c086 100644
--- a/src/txdb.cpp
+++ b/src/txdb.cpp
@@ -456,7 +456,7 @@ uint32_t hush_segid32(char *coinaddr);
bool CBlockTreeDB::Snapshot2(std::map &addressAmounts, UniValue *ret)
{
int64_t total = 0; int64_t totalAddresses = 0; std::string address;
- int64_t utxos = 0; int64_t ignoredAddresses = 0, cryptoConditionsUTXOs = 0, cryptoConditionsTotals = 0;
+ int64_t utxos = 0; int64_t ignoredAddresses = 0;
DECLARE_IGNORELIST
boost::scoped_ptr iter(NewIterator());
//std::map addressAmounts;
@@ -479,13 +479,7 @@ bool CBlockTreeDB::Snapshot2(std::map &addressAmounts, Un
if ( nValue == 0 )
continue;
getAddressFromIndex(indexKey.type, indexKey.hashBytes, address);
- if ( indexKey.type == 3 )
- {
- cryptoConditionsUTXOs++;
- cryptoConditionsTotals += nValue;
- total += nValue;
- continue;
- }
+
std::map ::iterator ignored = ignoredMap.find(address);
if (ignored != ignoredMap.end())
{
@@ -540,12 +534,6 @@ bool CBlockTreeDB::Snapshot2(std::map &addressAmounts, Un
ret->push_back(make_pair("total_addresses", totalAddresses ));
// Total number of ignored addresses in this snaphot
ret->push_back(make_pair("ignored_addresses", ignoredAddresses));
- // Total number of crypto condition utxos we skipped
- ret->push_back(make_pair("skipped_cc_utxos", cryptoConditionsUTXOs));
- // Total value of skipped crypto condition utxos
- ret->push_back(make_pair("cc_utxo_value", (double) cryptoConditionsTotals / COIN));
- // total of all the address's, does not count coins in CC vouts.
- ret->push_back(make_pair("total_includeCCvouts", (double) (total+cryptoConditionsTotals)/ COIN ));
// The snapshot finished at this block height
ret->push_back(make_pair("ending_height", chainActive.Height()));
}
diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index 22d3ef055..fb473158c 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -120,13 +120,12 @@ bool CTxMemPool::addUnchecked(const uint256& hash, const CTxMemPoolEntry &entry,
const CTransaction& tx = mapTx.find(hash)->GetTx();
mapRecentlyAddedTx[tx.GetHash()] = &tx;
nRecentlyAddedSequence += 1;
- if (!tx.IsCoinImport()) {
- for (unsigned int i = 0; i < tx.vin.size(); i++)
- {
- if (tx.IsPegsImport() && i==0) continue;
- mapNextTx[tx.vin[i].prevout] = CInPoint(&tx, i);
- }
+
+ for (unsigned int i = 0; i < tx.vin.size(); i++)
+ {
+ mapNextTx[tx.vin[i].prevout] = CInPoint(&tx, i);
}
+
for (const SpendDescription &spendDescription : tx.vShieldedSpend) {
mapSaplingNullifiers[spendDescription.nullifier] = &tx;
}
@@ -146,7 +145,7 @@ void CTxMemPool::addAddressIndex(const CTxMemPoolEntry &entry, const CCoinsViewC
uint256 txhash = tx.GetHash();
for (unsigned int j = 0; j < tx.vin.size(); j++) {
- if (tx.IsPegsImport() && j==0) continue;
+ //if (tx.IsPegsImport() && j==0) continue;
const CTxIn input = tx.vin[j];
const CTxOut &prevout = view.GetOutputFor(input);
@@ -157,14 +156,6 @@ void CTxMemPool::addAddressIndex(const CTxMemPoolEntry &entry, const CCoinsViewC
CTxDestination vDest;
if (Solver(prevout.scriptPubKey, txType, vSols) || ExtractDestination(prevout.scriptPubKey, vDest))
{
- if (vDest.which())
- {
- uint160 hashBytes;
- if (CBitcoinAddress(vDest).GetIndexKey(hashBytes, keyType, prevout.scriptPubKey.IsPayToCryptoCondition()))
- {
- vSols.push_back(vector(hashBytes.begin(), hashBytes.end()));
- }
- }
if (txType == TX_SCRIPTHASH)
{
keyType = 2;
@@ -191,11 +182,6 @@ void CTxMemPool::addAddressIndex(const CTxMemPoolEntry &entry, const CCoinsViewC
// if we failed to solve, and got a vDest, assume P2PKH or P2PK address returned
if (vDest.which())
{
- uint160 hashBytes;
- if (CBitcoinAddress(vDest).GetIndexKey(hashBytes, keyType, out.scriptPubKey.IsPayToCryptoCondition()))
- {
- vSols.push_back(vector(hashBytes.begin(), hashBytes.end()));
- }
}
else if (txType == TX_SCRIPTHASH)
{
@@ -252,7 +238,7 @@ void CTxMemPool::addSpentIndex(const CTxMemPoolEntry &entry, const CCoinsViewCac
uint256 txhash = tx.GetHash();
for (unsigned int j = 0; j < tx.vin.size(); j++) {
- if (tx.IsPegsImport() && j==0) continue;
+ //if (tx.IsPegsImport() && j==0) continue;
const CTxIn input = tx.vin[j];
const CTxOut &prevout = view.GetOutputFor(input);
diff --git a/src/util.cpp b/src/util.cpp
index 20bf79858..45f105a89 100644
--- a/src/util.cpp
+++ b/src/util.cpp
@@ -1,6 +1,6 @@
// Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-2014 The Bitcoin Core developers
-// Copyright (c) 2016-2024 The Hush developers
+// Copyright (c) 2016-2025 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
@@ -438,6 +438,7 @@ bool SoftSetArg(const std::string& strArg, const std::string& strValue)
if (mapArgs.count(strArg))
return false;
mapArgs[strArg] = strValue;
+ mapMultiArgs[strArg].push_back(strValue);
return true;
}
diff --git a/src/util.h b/src/util.h
index eeef26f86..ccc3f0486 100644
--- a/src/util.h
+++ b/src/util.h
@@ -47,6 +47,8 @@ static const bool DEFAULT_LOGTIMEMICROS = false;
static const bool DEFAULT_LOGIPS = false;
static const bool DEFAULT_LOGTIMESTAMPS = true;
+void CheckIfWeShouldStop();
+
/** Signals for translation. */
class CTranslationInterface
{
@@ -272,14 +274,17 @@ template void TraceThread(const char* name, Callable func)
catch (const boost::thread_interrupted&)
{
LogPrintf("%s thread interrupt\n", name);
+ CheckIfWeShouldStop();
throw;
}
catch (const std::exception& e) {
PrintExceptionContinue(&e, name);
+ CheckIfWeShouldStop();
throw;
}
catch (...) {
PrintExceptionContinue(NULL, name);
+ CheckIfWeShouldStop();
throw;
}
}
diff --git a/src/version.h b/src/version.h
index 74a686bd1..27553d45d 100644
--- a/src/version.h
+++ b/src/version.h
@@ -1,5 +1,5 @@
// Copyright (c) 2012-2014 The Bitcoin Core developers
-// Copyright (c) 2016-2024 The Hush developers
+// Copyright (c) 2016-2025 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
/******************************************************************************
@@ -21,13 +21,18 @@
#define HUSH_VERSION_H
// network protocol versioning
-static const int PROTOCOL_VERSION = 1987426;
+static const int PROTOCOL_VERSION = 1987428;
//! initial proto version, to be increased after version/verack negotiation
static const int INIT_PROTO_VERSION = 209;
//! In this version, 'getheaders' was introduced.
static const int GETHEADERS_VERSION = 31800;
-//! disconnect from peers older than this proto version
+
+//! disconnect from peers older than this proto version (HUSH mainnet)
+static const int MIN_HUSH_PEER_PROTO_VERSION = 1987426;
+
+//! disconnect from peers older than this proto version (HACs)
static const int MIN_PEER_PROTO_VERSION = 1987420;
+
//! nTime field added to CAddress, starting with this version;
//! if possible, avoid requesting addresses nodes older than this
static const int CADDR_TIME_VERSION = 31402;
diff --git a/src/wallet/asyncrpcoperation_sendmany.cpp b/src/wallet/asyncrpcoperation_sendmany.cpp
index f754158e3..311fc217c 100644
--- a/src/wallet/asyncrpcoperation_sendmany.cpp
+++ b/src/wallet/asyncrpcoperation_sendmany.cpp
@@ -363,7 +363,7 @@ bool AsyncRPCOperation_sendmany::main_impl() {
/**
- * SCENARIO #0 (All HUSH and Hush Smart Chains)
+ * SCENARIO #0 (All HUSH and Hush Arrakis Chains)
* Sprout not involved, so we just use the TransactionBuilder and we're done.
* We added the transparent inputs to the builder earlier.
*/
diff --git a/src/wallet/rpcwallet.cpp b/src/wallet/rpcwallet.cpp
index 51273a754..e86bcdd59 100644
--- a/src/wallet/rpcwallet.cpp
+++ b/src/wallet/rpcwallet.cpp
@@ -629,7 +629,7 @@ UniValue kvupdate(const UniValue& params, bool fHelp, const CPubKey& mypk)
if (fHelp || params.size() < 3 )
throw runtime_error(
"kvupdate key \"value\" days passphrase\n"
- "\nStore a key value. This feature is only available for asset chains.\n"
+ "\nStore a key value. This feature is only available for non-z2z chains.\n"
"\nArguments:\n"
"1. key (string, required) key\n"
"2. \"value\" (string, required) value\n"
@@ -654,8 +654,11 @@ UniValue kvupdate(const UniValue& params, bool fHelp, const CPubKey& mypk)
);
if (!EnsureWalletIsAvailable(fHelp))
return 0;
- if ( SMART_CHAIN_SYMBOL[0] == 0 )
- return(0);
+
+ if (ASSETCHAINS_PRIVATE) {
+ throw JSONRPCError(RPC_TYPE_ERROR, "This RPC is only available on non z2z chains");
+ }
+
haveprivkey = 0;
memset(&sig,0,sizeof(sig));
memset(&privkey,0,sizeof(privkey));
@@ -5000,9 +5003,9 @@ UniValue z_sendmany(const UniValue& params, bool fHelp, const CPubKey& mypk)
if (!EnsureWalletIsAvailable(fHelp))
return NullUniValue;
- if (fHelp || params.size() < 2 || params.size() > 4)
+ if (fHelp || params.size() < 2 || params.size() > 5)
throw runtime_error(
- "z_sendmany \"fromaddress\" [{\"address\":... ,\"amount\":...},...] ( minconf ) ( fee )\n"
+ "z_sendmany \"fromaddress\" [{\"address\":... ,\"amount\":...},...] ( minconf ) ( fee ) (opreturn)\n"
"\nSend multiple times. Amounts are decimal numbers with at most 8 digits of precision."
"\nChange generated from a taddr flows to a new taddr address, while change generated from a zaddr returns to itself."
"\nWhen sending coinbase UTXOs to a zaddr, change is not allowed. The entire value of the UTXO(s) must be consumed."
@@ -5018,6 +5021,7 @@ UniValue z_sendmany(const UniValue& params, bool fHelp, const CPubKey& mypk)
"3. minconf (numeric, optional, default=1) Only use funds confirmed at least this many times.\n"
"4. fee (numeric, optional, default="
+ strprintf("%s", FormatMoney(ASYNC_RPC_OPERATION_DEFAULT_MINERS_FEE)) + ") The fee amount to attach to this transaction.\n"
+ "5. opreturn (string, optional) Hex encoded data for OP_RETURN. Or a utf8 string prefixed with 'utf8:' which will be automatically converted to hex\n"
"\nResult:\n"
"\"operationid\" (string) An operationid to pass to z_getoperationstatus to get the result of the operation.\n"
"\nExamples:\n"
@@ -5025,6 +5029,8 @@ UniValue z_sendmany(const UniValue& params, bool fHelp, const CPubKey& mypk)
+ HelpExampleRpc("z_sendmany", "\"RD6GgnrMpPaTSMn8vai6yiGA7mN4QGPV\", [{\"address\": \"zs14d8tc0hl9q0vg5l28uec5vk6sk34fkj2n8s7jalvw5fxpy6v39yn4s2ga082lymrkjk0x2nqg37\" ,\"amount\": 5.0}]")
+ HelpExampleCli("z_sendmany", "\"zs14d8tc0hl9q0vg5l28uec5vk6sk34fkj2n8s7jalvw5fxpy6v39yn4s2ga082lymrkjk0x2nqg37\" '[{\"address\": \"zs14d8tc0hl9q0vg5l28uec5vk6sk34fkj2n8s7jalvw5fxpy6v39yn4s2ga082lymrkjk0x2nqg37\" ,\"amount\": 3.14}]'")
+ HelpExampleRpc("z_sendmany", "\"zs14d8tc0hl9q0vg5l28uec5vk6sk34fkj2n8s7jalvw5fxpy6v39yn4s2ga082lymrkjk0x2nqg37\", [{\"address\": \"zs14d8tc0hl9q0vg5l28uec5vk6sk34fkj2n8s7jalvw5fxpy6v39yn4s2ga082lymrkjk0x2nqg37\" ,\"amount\": 3.14}]")
+ + HelpExampleCli("z_sendmany", "\"zs14d8tc0hl9q0vg5l28uec5vk6sk34fkj2n8s7jalvw5fxpy6v39yn4s2ga082lymrkjk0x2nqg37\" '[{\"address\": \"zs14d8tc0hl9q0vg5l28uec5vk6sk34fkj2n8s7jalvw5fxpy6v39yn4s2ga082lymrkjk0x2nqg37\" ,\"amount\": 3.14}]' 1 0.0001 \"utf8: this will be converted to hex")
+ + HelpExampleRpc("z_sendmany", "\"zs14d8tc0hl9q0vg5l28uec5vk6sk34fkj2n8s7jalvw5fxpy6v39yn4s2ga082lymrkjk0x2nqg37\" '[{\"address\": \"zs14d8tc0hl9q0vg5l28uec5vk6sk34fkj2n8s7jalvw5fxpy6v39yn4s2ga082lymrkjk0x2nqg37\" ,\"amount\": 3.14}]' 1 0.0001 \"utf8: this will be converted to hex")
);
LOCK2(cs_main, pwalletMain->cs_wallet);
@@ -5143,18 +5149,34 @@ UniValue z_sendmany(const UniValue& params, bool fHelp, const CPubKey& mypk)
}
}
- // Keep track of addresses to spot duplicates
- set setAddress;
-
// Recipients
std::vector taddrRecipients;
std::vector zaddrRecipients;
CAmount nTotalOut = 0;
// Optional OP_RETURN data
CScript opret;
+ UniValue opretValue;
+ if(params.size() == 5) {
+ opretValue = params[4].get_str();
+
+ // Support a prefix "utf8:" which allows giving utf8 text instead of hex
+ if(opretValue.get_str().substr(0,5) == "utf8:") {
+ auto str = opretValue.get_str().substr(5);
+ if (utf8::is_valid(str)) {
+ opretValue = HexStr(str);
+ } else {
+ throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid utf8 in opreturn");
+ }
+ }
+ }
bool containsSaplingOutput = false;
+ // Create the CScript representation of the OP_RETURN
+ if (!opretValue.isNull()) {
+ opret << OP_RETURN << ParseHex(opretValue.get_str().c_str());
+ }
+
for (const UniValue& o : outputs.getValues()) {
if (!o.isObject())
throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, expected object");
@@ -5162,7 +5184,7 @@ 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" && s!="opreturn") {
+ if (s != "address" && s != "amount" && s!="memo") {
throw JSONRPCError(RPC_INVALID_PARAMETER, string("Invalid parameter, unknown key: ")+s);
}
}
@@ -5181,26 +5203,22 @@ UniValue z_sendmany(const UniValue& params, bool fHelp, const CPubKey& mypk)
// throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Extreme Privacy! You must send to a zaddr");
//}
- // Allowing duplicate receivers helps various HushList protocol operations
- //if (setAddress.count(address))
- // 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()) {
memo = memoValue.get_str();
if (!isZaddr) {
throw JSONRPCError(RPC_INVALID_PARAMETER, "Memo cannot be used with a taddr. It can only be used with a zaddr.");
+ } else if(memo.substr(0,5) == "utf8:") {
+ // Support a prefix "utf8:" which allows giving utf8 text instead of hex
+ auto str = memo.substr(5);
+ if (utf8::is_valid(str)) {
+ memo = HexStr(str);
+ } else {
+ throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid utf8 in memo");
+ }
} else if (!IsHex(memo)) {
- throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, expected memo data in hexadecimal format.");
+ throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, expected memo data in hexadecimal format or to use 'utf8:' prefix.");
}
if (memo.length() > HUSH_MEMO_SIZE*2) {
throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Invalid parameter, size of memo is larger than maximum allowed %d", HUSH_MEMO_SIZE ));
@@ -5311,7 +5329,7 @@ UniValue z_sendmany(const UniValue& params, bool fHelp, const CPubKey& mypk)
}
txsize += CTXOUT_REGULAR_SIZE * taddrRecipients.size();
if (txsize > max_tx_size) {
- throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Too many outputs, size of raw transaction would be larger than limit of %d bytes", max_tx_size ));
+ throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Size of raw transaction %d would be larger than limit of %d bytes", txsize, max_tx_size ));
}
// Minimum confirmations
@@ -5339,12 +5357,18 @@ UniValue z_sendmany(const UniValue& params, bool fHelp, const CPubKey& mypk)
// or anything less than nDefaultFee instead of being forced to use a custom fee and leak metadata
if (nTotalOut < nDefaultFee) {
if (nFee > nDefaultFee) {
- throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Small transaction amount %s has fee %s that is greater than the default fee %s", FormatMoney(nTotalOut), FormatMoney(nFee), FormatMoney(nDefaultFee)));
+ // Allow large fees if OP_RETURN is being used
+ if( opretValue.isNull() ) {
+ throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Small transaction amount %s has fee %s that is greater than the default fee %s", FormatMoney(nTotalOut), FormatMoney(nFee), FormatMoney(nDefaultFee)));
+ }
}
} else {
// Check that the user specified fee is not absurd.
if (nFee > nTotalOut) {
- throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Fee %s is greater than the sum of outputs %s and also greater than the default fee", FormatMoney(nFee), FormatMoney(nTotalOut)));
+ // Allow large fees if OP_RETURN is being used
+ if( opretValue.isNull() ) {
+ throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Fee %s is greater than the sum of outputs %s and also greater than the default fee", FormatMoney(nFee), FormatMoney(nTotalOut)));
+ }
}
}
}
@@ -5424,6 +5448,8 @@ UniValue z_shieldcoinbase(const UniValue& params, bool fHelp, const CPubKey& myp
"\nExamples:\n"
+ HelpExampleCli("z_shieldcoinbase", "\"RD6GgnrMpPaTSMn8vai6yiGA7mN4QGPV\" \"zs14d8tc0hl9q0vg5l28uec5vk6sk34fkj2n8s7jalvw5fxpy6v39yn4s2ga082lymrkjk0x2nqg37\"")
+ HelpExampleRpc("z_shieldcoinbase", "\"RD6GgnrMpPaTSMn8vai6yiGA7mN4QGPV\", \"zs14d8tc0hl9q0vg5l28uec5vk6sk34fkj2n8s7jalvw5fxpy6v39yn4s2ga082lymrkjk0x2nqg37\"")
+ + HelpExampleCli("z_shieldcoinbase", "'*'\", \"zs14d8tc0hl9q0vg5l28uec5vk6sk34fkj2n8s7jalvw5fxpy6v39yn4s2ga082lymrkjk0x2nqg37\"")
+ + HelpExampleRpc("z_shieldcoinbase", "'*'\", \"zs14d8tc0hl9q0vg5l28uec5vk6sk34fkj2n8s7jalvw5fxpy6v39yn4s2ga082lymrkjk0x2nqg37\"")
);
LOCK2(cs_main, pwalletMain->cs_wallet);
diff --git a/src/wallet/wallet.cpp b/src/wallet/wallet.cpp
index 37b31ec85..1017bb3df 100644
--- a/src/wallet/wallet.cpp
+++ b/src/wallet/wallet.cpp
@@ -507,7 +507,7 @@ void CWallet::ChainTip(const CBlockIndex *pindex,
}
void CWallet::RunSaplingSweep(int blockHeight) {
- // Sapling is always active since height=1 of HUSH+HSCs
+ // Sapling is always active since height=1 of HUSH+HACs
// if (!NetworkUpgradeActive(blockHeight, Params().GetConsensus(), Consensus::UPGRADE_SAPLING)) {
// return;
// }
@@ -551,7 +551,7 @@ void CWallet::RunSaplingSweep(int blockHeight) {
}
void CWallet::RunSaplingConsolidation(int blockHeight) {
- // Sapling is always active on HUSH+HSCs
+ // Sapling is always active on HUSH+HACs
//if (!NetworkUpgradeActive(blockHeight, Params().GetConsensus(), Consensus::UPGRADE_SAPLING)) {
// return;
//}
@@ -887,6 +887,7 @@ bool CWallet::IsSaplingSpent(const uint256& nullifier) const {
}
unsigned int CWallet::GetSaplingSpendDepth(const uint256& nullifier) const {
+
pair range;
range = mapTxSaplingNullifiers.equal_range(nullifier);
@@ -977,10 +978,10 @@ void CWallet::ClearNoteWitnessCache()
void CWallet::DecrementNoteWitnesses(const CBlockIndex* pindex)
{
- LOCK(cs_wallet);
-
extern int32_t HUSH_REWIND;
+ LOCK2(cs_main, cs_wallet);
+
for (std::pair& wtxItem : mapWallet) {
//Sapling
for (auto& item : wtxItem.second.mapSaplingNoteData) {
@@ -1976,17 +1977,6 @@ isminetype CWallet::IsMine(const CTransaction& tx, uint32_t voutNum)
case TX_NULL_DATA:
break;
- case TX_CRYPTOCONDITION:
- // for now, default is that the first value returned will be the script, subsequent values will be
- // pubkeys. if we have the first pub key in our wallet, we consider this spendable
- if (vSolutions.size() > 1)
- {
- keyID = CPubKey(vSolutions[1]).GetID();
- if (this->HaveKey(keyID))
- return ISMINE_SPENDABLE;
- }
- break;
-
case TX_PUBKEY:
keyID = CPubKey(vSolutions[0]).GetID();
if (this->HaveKey(keyID))
@@ -2790,7 +2780,7 @@ int CWallet::ScanForWalletTransactions(CBlockIndex* pindexStart, bool fUpdate)
// This should never fail: we should always be able to get the tree
// state on the path to the tip of our chain
if (pindex->pprev) {
- const bool sapling = true;
+ const bool sapling = pindex->GetHeight() >= 2 ? true : false;
if (sapling) { // NetworkUpgradeActive(pindex->pprev->GetHeight(), Params().GetConsensus(), Consensus::UPGRADE_SAPLING)) {
assert(pcoinsTip->GetSaplingAnchorAt(pindex->pprev->hashFinalSaplingRoot, saplingTree));
}
diff --git a/src/wallet/wallet_ismine.cpp b/src/wallet/wallet_ismine.cpp
index c80e37d9a..5897f2bbf 100644
--- a/src/wallet/wallet_ismine.cpp
+++ b/src/wallet/wallet_ismine.cpp
@@ -78,16 +78,6 @@ isminetype IsMine(const CKeyStore &keystore, const CScript& _scriptPubKey)
case TX_NONSTANDARD:
case TX_NULL_DATA:
break;
- case TX_CRYPTOCONDITION:
- // for now, default is that the first value returned will be the script, subsequent values will be
- // pubkeys. if we have the first pub key in our wallet, we consider this spendable
- if (vSolutions.size() > 1)
- {
- keyID = CPubKey(vSolutions[1]).GetID();
- if (keystore.HaveKey(keyID))
- return ISMINE_SPENDABLE;
- }
- break;
case TX_PUBKEY:
keyID = CPubKey(vSolutions[0]).GetID();
if (keystore.HaveKey(keyID))
diff --git a/test_antispam b/test_antispam
deleted file mode 100755
index 5ccfb4752..000000000
--- a/test_antispam
+++ /dev/null
@@ -1,10 +0,0 @@
-#!/usr/bin/env bash
-
-# any CLI args given to this script will be passed along
-# example: ./test_antispam -debug=blah
-#./src/hushd -ac_name=ANTISPAM -ac_private=1 -ac_blocktime=180 -ac_reward=500000000 -ac_supply=55555 -gen=1 -genproclimit=1 -testnode=1 $@
-
-./src/hushd -ac_name=ANTISPAM -ac_private=1 -ac_blocktime=180 -ac_reward=500000000 -ac_supply=55555 $@
-# to run via the debugger
-# type "run" when gdb prompt appears
-#gdb --args ./src/hushd -- -ac_algo=randomx -ac_name=ANTISPAM -ac_private=1 -ac_blocktime=180 -ac_reward=500000000 -ac_supply=55555 -gen=1 -genproclimit=1 -testnode=1
diff --git a/util/build-debian-package.sh b/util/build-debian-package.sh
index c9719fd18..e277b8725 100755
--- a/util/build-debian-package.sh
+++ b/util/build-debian-package.sh
@@ -6,6 +6,14 @@
## ./util/build-debian-package.sh # build amd64 package
## ./util/build-debian-package.sh aarch64 # build package for specific archiecture
+# Check if running on Debian and exit if it is not
+if grep -qi "Debian" /etc/os-release; then
+ :
+else
+ echo -e "NOT RUNNING THIS SCRIPT ON DEBIAN! Try again with Debian." >&2
+ exit 1
+fi
+
ARCH=${1:-amd64}
echo "Let There Be Hush Debian Packages"
@@ -77,8 +85,8 @@ strip $DEB_BIN/hush-tx
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_PATH/src/hush-arrakis-chain $DEB_BIN
+cp $SRC_DEB/changelog $DEB_DOC
cp $SRC_DEB/copyright $DEB_DOC
cp -r $SRC_DEB/examples $DEB_DOC
# Copy manpages
diff --git a/util/build.sh b/util/build.sh
index cbcd9a416..6bf7a6d69 100755
--- a/util/build.sh
+++ b/util/build.sh
@@ -17,6 +17,18 @@ if ! [ -x "$(command -v autoreconf)" ]; then
exit 1
fi
+if ! [ -x "$(command -v as)" ]; then
+ echo 'Error: as is not installed. Install as and try again.' >&2
+ echo 'On Debian-like systems: apt install binutils' >&2
+ exit 1
+fi
+
+if ! [ -x "$(command -v ld)" ]; then
+ echo 'Error: ld is not installed. Install ld and try again.' >&2
+ echo 'On Debian-like systems: apt install binutils' >&2
+ exit 1
+fi
+
function cmd_pref() {
if type -p "$2" > /dev/null; then
eval "$1=$2"
diff --git a/util/debug-build.sh b/util/debug-build.sh
new file mode 100755
index 000000000..a47681506
--- /dev/null
+++ b/util/debug-build.sh
@@ -0,0 +1,143 @@
+#!/usr/bin/env bash
+# Copyright (c) 2016-2024 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
+
+set -eu -o pipefail
+
+# Check if cmake, a new dependency for randomx support, is installed on system and exits if it is not
+if ! [ -x "$(command -v cmake)" ]; then
+ echo 'Error: cmake is not installed. Install cmake and try again.' >&2
+ 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"
+ else
+ eval "$1=$3"
+ fi
+}
+cat <<'EOF'
+ .~~~~~~~~~~~~~~~~.
+{{ Building Hush!! }}
+ `~~~~~~~~~~~~~~~~`
+ \ ^__^
+ \ (@@)\_______
+ (__)\ HUSH )\/\ $
+ z zz ||----w | z |
+zz zz z || z ||xxx z z|z zz
+zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz
+zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz
+EOF
+
+# If a g-prefixed version of the command exists, use it preferentially.
+function gprefix() {
+ cmd_pref "$1" "g$2" "$2"
+}
+
+gprefix READLINK readlink
+cd "$(dirname "$("$READLINK" -f "$0")")/.."
+
+# Allow user overrides to $MAKE. Typical usage for users who need it:
+# MAKE=gmake ./util/build.sh -j$(nproc)
+if [[ -z "${MAKE-}" ]]; then
+ MAKE=make
+fi
+
+# Allow overrides to $BUILD and $HOST for porters. Most users will not need it.
+# BUILD=i686-pc-linux-gnu ./util/build.sh
+if [[ -z "${BUILD-}" ]]; then
+ BUILD="$(./depends/config.guess)"
+fi
+if [[ -z "${HOST-}" ]]; then
+ HOST="$BUILD"
+fi
+
+# Allow users to set arbitrary compile flags. Most users will not need this.
+if [[ -z "${CONFIGURE_FLAGS-}" ]]; then
+ CONFIGURE_FLAGS=""
+fi
+
+if [ "x$*" = 'x--help' ]
+then
+ cat ./util/dragon.txt
+ cat <