update README

ringct: fix trunc_amount field name change
Caused in commit 05231400cebfeedbbc0a5386f38a033bba6314b3, PR #9035.
2024-03-15 11:13:11 +03:00 · 2024-03-15 10:22:41 +03:00 · 2024-03-15 10:22:07 +03:00 · 2024-03-15 10:21:48 +03:00 · 2024-03-10 11:57:34 +03:00 · 2024-03-10 00:06:15 +03:00
165 changed files with 5838 additions and 2679 deletions
--- a/.gitmodules
+++ b/.gitmodules
@ -5,12 +5,15 @@
 	path = external/rapidjson
 	url = https://github.com/Tencent/rapidjson
 [submodule "external/trezor-common"]
+	active = false
 	path = external/trezor-common
 	url = https://github.com/trezor/trezor-common.git
-[submodule "external/randomx"]
-	path = external/randomx
-	url = https://github.com/tevador/RandomX
 [submodule "external/supercop"]
 	path = external/supercop
 	url = https://github.com/monero-project/supercop
 	branch = monero
+[submodule "external/randomwow"]
+	path = external/randomwow
+	url = https://git.wownero.com/wownero/RandomWOW
+        branch = 1.2.1-wow
+
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -359,15 +359,16 @@ if(NOT MANUAL_SUBMODULES)
      if (upToDate)
        message(STATUS "Submodule '${relative_path}' is up-to-date")
      else()
-        message(FATAL_ERROR "Submodule '${relative_path}' is not up-to-date. Please update all submodules with\ngit submodule update --init --force\nor run cmake with -DMANUAL_SUBMODULES=1\n")
+        message(STATUS "Initializing submodules")
+        execute_process(COMMAND git "submodule" "update" "--init" "--recursive" WORKING_DIRECTORY ${CMAKE_SOURCE_DIR})
      endif()
    endfunction ()
    
    message(STATUS "Checking submodules")
    check_submodule(external/miniupnp)
    check_submodule(external/rapidjson)
-    check_submodule(external/trezor-common)
-    check_submodule(external/randomx)
+    #check_submodule(external/trezor-common)
+    check_submodule(external/randomwow)
    check_submodule(external/supercop)
  endif()
 endif()
@ -405,7 +406,7 @@ option(BOOST_IGNORE_SYSTEM_PATHS "Ignore boost system paths for local boost inst
 set_property(GLOBAL PROPERTY USE_FOLDERS ON)
 enable_testing()

-option(BUILD_DOCUMENTATION "Build the Doxygen documentation." ON)
+option(BUILD_DOCUMENTATION "Build the Doxygen documentation." OFF)
 option(BUILD_TESTS "Build tests." OFF)
 if (CMAKE_BUILD_TYPE STREQUAL "Debug")
  set(DEFAULT_BUILD_DEBUG_UTILITIES ON)
--- a/26
+++ b/26
@ -41,26 +41,26 @@ RUN set -ex && \
    rm -rf /var/lib/apt
 COPY --from=builder /src/build/x86_64-linux-gnu/release/bin /usr/local/bin/

-# Create monero user
-RUN adduser --system --group --disabled-password monero && \
-	mkdir -p /wallet /home/monero/.bitmonero && \
-	chown -R monero:monero /home/monero/.bitmonero && \
-	chown -R monero:monero /wallet
+# Create wownero user
+RUN adduser --system --group --disabled-password wownero && \
+	mkdir -p /wallet /home/wownero/.wownero && \
+	chown -R wownero:wownero /home/wownero/.wownero && \
+	chown -R wownero:wownero /wallet

 # Contains the blockchain
-VOLUME /home/monero/.bitmonero
+VOLUME /home/wownero/.wownero

 # Generate your wallet via accessing the container and run:
 # cd /wallet
-# monero-wallet-cli
+# wownero-wallet-cli
 VOLUME /wallet

-EXPOSE 18080
-EXPOSE 18081
+EXPOSE 34567
+EXPOSE 34568

-# switch to user monero
-USER monero
+# switch to user wownero
+USER wownero

-ENTRYPOINT ["monerod"]
-CMD ["--p2p-bind-ip=0.0.0.0", "--p2p-bind-port=18080", "--rpc-bind-ip=0.0.0.0", "--rpc-bind-port=18081", "--non-interactive", "--confirm-external-bind"]
+ENTRYPOINT ["wownerod"]
+CMD ["--p2p-bind-ip=0.0.0.0", "--p2p-bind-port=34567", "--rpc-bind-ip=0.0.0.0", "--rpc-bind-port=34568", "--non-interactive", "--confirm-external-bind"]

--- a/4
+++ b/4
@ -100,11 +100,11 @@ release-test:

 release-all:
 	mkdir -p $(builddir)/release
-	cd $(builddir)/release && cmake -D BUILD_TESTS=ON -D CMAKE_BUILD_TYPE=Release $(topdir) && $(MAKE)
+	cd $(builddir)/release && cmake -D BUILD_TESTS=OFF -D USE_DEVICE_TREZOR=OFF -D CMAKE_BUILD_TYPE=Release $(topdir) && $(MAKE)

 release-static:
 	mkdir -p $(builddir)/release
-	cd $(builddir)/release && cmake -D STATIC=ON -D ARCH="x86-64" -D BUILD_64=ON -D CMAKE_BUILD_TYPE=Release $(topdir) && $(MAKE)
+	cd $(builddir)/release && cmake -D BUILD_TESTS=OFF -D USE_DEVICE_TREZOR=OFF -D STATIC=ON -D BUILD_64=ON -D CMAKE_BUILD_TYPE=Release $(topdir) && $(MAKE)

 coverage:
 	mkdir -p $(builddir)/debug
--- a/README.md
+++ b/README.md
--- a/contrib/depends/funcs.mk
+++ b/contrib/depends/funcs.mk
@ -145,7 +145,7 @@ $(1)_build_env+=PATH="$(build_prefix)/bin:$(PATH)"
 $(1)_stage_env+=PATH="$(build_prefix)/bin:$(PATH)"
 $(1)_autoconf=./configure --host=$($($(1)_type)_host) --prefix=$($($(1)_type)_prefix) $$($(1)_config_opts) CC="$$($(1)_cc)" CXX="$$($(1)_cxx)"

-ifneq ($(1),libusb)
+ifeq ($(filter $(1),libusb unbound),)
 $(1)_autoconf += --disable-dependency-tracking
 endif
 ifneq ($($(1)_nm),)
--- a/contrib/depends/packages/expat.mk
+++ b/contrib/depends/packages/expat.mk
@ -1,12 +1,12 @@
 package=expat
-$(package)_version=2.4.1
-$(package)_download_path=https://github.com/libexpat/libexpat/releases/download/R_2_4_1
+$(package)_version=2.6.0
+$(package)_download_path=https://github.com/libexpat/libexpat/releases/download/R_$(subst .,_,$($(package)_version))/
 $(package)_file_name=$(package)-$($(package)_version).tar.bz2
-$(package)_sha256_hash=2f9b6a580b94577b150a7d5617ad4643a4301a6616ff459307df3e225bcfbf40
+$(package)_sha256_hash=ff60e6a6b6ce570ae012dc7b73169c7fdf4b6bf08c12ed0ec6f55736b78d85ba

 define $(package)_set_vars
-$(package)_config_opts=--enable-static
-$(package)_config_opts=--disable-shared
+$(package)_config_opts=--disable-shared --without-docbook --without-tests --without-examples
+$(package)_config_opts+=--enable-option-checking --without-xmlwf --with-pic
 $(package)_config_opts+=--prefix=$(host_prefix)
 endef

@ -23,6 +23,6 @@ define $(package)_stage_cmds
 endef

 define $(package)_postprocess_cmds
-  rm lib/*.la
+  rm -rf share lib/cmake lib/*.la
 endef

--- a/contrib/depends/packages/openssl.mk
+++ b/contrib/depends/packages/openssl.mk
@ -1,20 +1,19 @@
 package=openssl
-$(package)_version=1.1.1u
+$(package)_version=3.0.13
 $(package)_download_path=https://www.openssl.org/source
 $(package)_file_name=$(package)-$($(package)_version).tar.gz
-$(package)_sha256_hash=e2f8d84b523eecd06c7be7626830370300fbcc15386bf5142d72758f6963ebc6
+$(package)_sha256_hash=88525753f79d3bec27d2fa7c66aa0b92b3aa9498dafd93d7cfa4b3780cdae313

 define $(package)_set_vars
 $(package)_config_env=AR="$($(package)_ar)" ARFLAGS=$($(package)_arflags) RANLIB="$($(package)_ranlib)" CC="$($(package)_cc)"
-$(package)_config_env_android=ANDROID_NDK_HOME="$(host_prefix)/native" PATH="$(host_prefix)/native/bin" CC=clang AR=ar RANLIB=ranlib
-$(package)_build_env_android=ANDROID_NDK_HOME="$(host_prefix)/native"
-$(package)_config_opts=--prefix=$(host_prefix) --openssldir=$(host_prefix)/etc/openssl
+$(package)_config_env_android=ANDROID_NDK_ROOT="$(host_prefix)/native" PATH="$(host_prefix)/native/bin" CC=clang AR=ar RANLIB=ranlib
+$(package)_build_env_android=ANDROID_NDK_ROOT="$(host_prefix)/native"
+$(package)_config_opts=--prefix=$(host_prefix) --openssldir=$(host_prefix)/etc/openssl --libdir=$(host_prefix)/lib
 $(package)_config_opts+=no-capieng
 $(package)_config_opts+=no-dso
 $(package)_config_opts+=no-dtls1
 $(package)_config_opts+=no-ec_nistp_64_gcc_128
 $(package)_config_opts+=no-gost
-$(package)_config_opts+=no-heartbeats
 $(package)_config_opts+=no-md2
 $(package)_config_opts+=no-rc5
 $(package)_config_opts+=no-rdrand
@ -22,8 +21,8 @@ $(package)_config_opts+=no-rfc3779
 $(package)_config_opts+=no-sctp
 $(package)_config_opts+=no-shared
 $(package)_config_opts+=no-ssl-trace
-$(package)_config_opts+=no-ssl2
 $(package)_config_opts+=no-ssl3
+$(package)_config_opts+=no-tests
 $(package)_config_opts+=no-unit-test
 $(package)_config_opts+=no-weak-ssl-ciphers
 $(package)_config_opts+=no-zlib
@ -49,7 +48,7 @@ $(package)_config_opts_x86_64_freebsd=BSD-x86_64
 endef

 define $(package)_preprocess_cmds
-  sed -i.old 's|"engines", "apps", "test", "util", "tools", "fuzz"|"engines", "tools"|' Configure
+  sed -i.old 's|crypto ssl apps util tools fuzz providers doc|crypto ssl util tools providers|' build.info
 endef

 define $(package)_config_cmds
--- a/contrib/depends/packages/unbound.mk
+++ b/contrib/depends/packages/unbound.mk
@ -1,17 +1,21 @@
 package=unbound
-$(package)_version=1.15.0
+$(package)_version=1.19.1
 $(package)_download_path=https://www.nlnetlabs.nl/downloads/$(package)/
 $(package)_file_name=$(package)-$($(package)_version).tar.gz
-$(package)_sha256_hash=a480dc6c8937447b98d161fe911ffc76cfaffa2da18788781314e81339f1126f
+$(package)_sha256_hash=bc1d576f3dd846a0739adc41ffaa702404c6767d2b6082deb9f2f97cbb24a3a9
 $(package)_dependencies=openssl expat
 $(package)_patches=disable-glibc-reallocarray.patch


 define $(package)_set_vars
-  $(package)_config_opts=--disable-shared --enable-static --without-pyunbound --prefix=$(host_prefix) --with-libexpat=$(host_prefix) --with-ssl=$(host_prefix) --with-libevent=no --without-pythonmodule --disable-flto --with-pthreads --with-libunbound-only
+  $(package)_config_opts=--disable-shared --enable-static --without-pyunbound --prefix=$(host_prefix)
+  $(package)_config_opts+=--with-libexpat=$(host_prefix) --with-ssl=$(host_prefix) --with-libevent=no
+  $(package)_config_opts+=--without-pythonmodule --disable-flto --with-pthreads --with-libunbound-only
  $(package)_config_opts_linux=--with-pic
  $(package)_config_opts_w64=--enable-static-exe --sysconfdir=/etc --prefix=$(host_prefix) --target=$(host_prefix)
+  $(package)_config_opts_x86_64_darwin=ac_cv_func_SHA384_Init=yes
  $(package)_build_opts_mingw32=LDFLAGS="$($(package)_ldflags) -lpthread"
+  $(package)_cflags_mingw32+="-D_WIN32_WINNT=0x600"
 endef

 define $(package)_preprocess_cmds
@ -30,6 +34,3 @@ endef
 define $(package)_stage_cmds
  $(MAKE) DESTDIR=$($(package)_staging_dir) install
 endef
-
-define $(package)_postprocess_cmds
-endef
--- a/contrib/depends/toolchain.cmake.in
+++ b/contrib/depends/toolchain.cmake.in
@ -144,8 +144,11 @@ elseif(ARCHITECTURE STREQUAL "aarch64")
 endif()

 if(ARCHITECTURE STREQUAL "riscv64")
-    set(NO_AES ON)
-    set(ARCH "rv64imafdc")
+  if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
+    set(BUILD_TAG "linux-riscv64")
+  endif()
+  set(ARCH_ID "riscv64")
+  set(ARCH "rv64gc")
 endif()

 if(ARCHITECTURE STREQUAL "i686")
--- a/contrib/epee/src/mlog.cpp
+++ b/contrib/epee/src/mlog.cpp
@ -338,11 +338,21 @@ bool is_stdout_a_tty()
  return is_a_tty.load(std::memory_order_relaxed);
 }

+static bool is_nocolor()
+{
+  static const char *no_color_var = getenv("NO_COLOR");
+  static const bool no_color = no_color_var && *no_color_var; // apparently, NO_COLOR=0 means no color too (as per no-color.org)
+  return no_color;
+}
+
 void set_console_color(int color, bool bright)
 {
  if (!is_stdout_a_tty())
    return;

+  if (is_nocolor())
+    return;
+
  switch(color)
  {
  case console_color_default:
@ -461,6 +471,9 @@ void reset_console_color() {
  if (!is_stdout_a_tty())
    return;

+  if (is_nocolor())
+    return;
+
 #ifdef WIN32
  HANDLE h_stdout = GetStdHandle(STD_OUTPUT_HANDLE);
  SetConsoleTextAttribute(h_stdout, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
--- a/contrib/epee/src/readline_buffer.cpp
+++ b/contrib/epee/src/readline_buffer.cpp
@ -238,6 +238,10 @@ static char** attempted_completion(const char* text, int start, int end)

 static void install_line_handler()
 {
+#if RL_READLINE_VERSION >= 0x0801
+  rl_variable_bind("enable-bracketed-paste", "off");
+#endif
+
  rl_attempted_completion_function = attempted_completion;
  rl_callback_handler_install("", handle_line);
  stifle_history(500);
--- a/contrib/gitian/DOCKRUN.md
+++ b/contrib/gitian/DOCKRUN.md
@ -57,7 +57,7 @@ The dockrun.sh script will do everything to build the binaries. Just specify the
 version to build as its only argument, e.g.

 ```bash
-VERSION=v0.18.3.0
+VERSION=v0.18.3.2
 ./dockrun.sh $VERSION
 ```

--- a/contrib/gitian/README.md
+++ b/contrib/gitian/README.md
@ -133,7 +133,7 @@ Common setup part:
 su - gitianuser

 GH_USER=YOUR_GITHUB_USER_NAME
-VERSION=v0.18.3.0
+VERSION=v0.18.3.2
 ```

 Where `GH_USER` is your GitHub user name and `VERSION` is the version tag you want to build. 
--- a/contrib/gitian/dockrun.sh
+++ b/contrib/gitian/dockrun.sh
@ -41,10 +41,10 @@ RUN useradd -ms /bin/bash -U ubuntu -G docker
 USER ubuntu:docker
 WORKDIR $WORKDIR

-RUN	git clone https://github.com/monero-project/gitian.sigs.git sigs; \
+RUN	git clone https://git.wownero.com/wownero/gitian.sigs.git sigs; \
  git clone https://github.com/devrandom/gitian-builder.git builder; \
  cd builder; git checkout c0f77ca018cb5332bfd595e0aff0468f77542c23; mkdir -p inputs var; cd inputs; \
-  git clone https://github.com/monero-project/monero
+  git clone https://git.wownero.com/wownero/wownero

 CMD ["sleep", "infinity"]
 EOF
@ -109,7 +109,7 @@ if [ "$check" != "sign" ]; then
 fi

 if [ ! -d sigs ]; then
-	git clone https://github.com/monero-project/gitian.sigs.git sigs
+	git clone https://git.wownero.com/wownero/gitian.sigs.git sigs
 	cd sigs
 	git remote add $GH_USER git@github.com:$GH_USER/gitian.sigs.git
 	cd ..
--- a/contrib/gitian/gitian-android.yml
+++ b/contrib/gitian/gitian-android.yml
@ -1,5 +1,5 @@
 ---
-name: "monero-android-0.18"
+name: "wownero-android-0.11"
 enable_cache: true
 suites:
 - "bionic"
@ -26,8 +26,8 @@ packages:
 - "cmake"
 - "unzip"
 remotes:
- "url": "https://github.com/monero-project/monero.git"
-  "dir": "monero"
+- "url": "https://git.wownero.com/wownero/wownero.git"
+  "dir": "wownero"
 files: []
 script: |

@ -70,7 +70,7 @@ script: |
    then
      ABI=$i"eabi"
    fi
-    NDKDIR="${BUILD_DIR}/monero/contrib/depends/$i/native/bin"
+    NDKDIR="${BUILD_DIR}/wownero/contrib/depends/$i/native/bin"
    for prog in ${FAKETIME_HOST_PROGS}; do
        WRAPPER=${WRAP_DIR}/${ABI}-${prog}
        echo '#!/usr/bin/env bash' > ${WRAPPER}
@ -92,7 +92,7 @@ script: |
  export SOURCE_DATE_EPOCH=`date -d 2000-01-01T12:00:00 +%s`

  git config --global core.abbrev 9
-  cd monero
+  cd wownero
  # Set the version string that gets added to the tar archive name
  version="`git describe`"
  if [[ $version == *"-"*"-"* ]]; then
@ -120,9 +120,9 @@ script: |
    cmake .. -DCMAKE_TOOLCHAIN_FILE=${BASEPREFIX}/${i}/share/toolchain.cmake -DCMAKE_BUILD_TYPE=Release
    make ${MAKEOPTS}
    chmod 755 bin/*
-    cp ../LICENSE ../README.md ../docs/ANONYMITY_NETWORKS.md bin
-    chmod 644 bin/LICENSE bin/*.md
-    DISTNAME=monero-${i}-${version}
+    cp ../utils/conf/wow.conf bin
+    chmod 644 bin/wow.conf
+    DISTNAME=wownero-${i}-${version}
    mv bin ${DISTNAME}
    find ${DISTNAME}/ | sort | tar --no-recursion --owner=0 --group=0 -c -T - | bzip2 -9 > ${OUTDIR}/${DISTNAME}.tar.bz2
    cd ..
--- a/contrib/gitian/gitian-build.py
+++ b/contrib/gitian/gitian-build.py
@ -5,7 +5,7 @@ import os
 import subprocess
 import sys

-gsigs = 'https://github.com/monero-project/gitian.sigs.git'
+gsigs = 'https://git.wownero.com/wownero/gitian.sigs.git'
 gbrepo = 'https://github.com/devrandom/gitian-builder.git'

 platforms = {'l': ['Linux', 'linux', 'tar.bz2'],
@ -31,10 +31,10 @@ def setup():
    subprocess.check_call(['git', 'checkout', 'c0f77ca018cb5332bfd595e0aff0468f77542c23'])
    os.makedirs('inputs', exist_ok=True)
    os.chdir('inputs')
-    if os.path.isdir('monero'):
-        # Remove the potentially stale monero dir. Otherwise you might face submodule mismatches.
-        subprocess.check_call(['rm', 'monero', '-fR'])
-    subprocess.check_call(['git', 'clone', args.url, 'monero'])
+    if os.path.isdir('wownero'):
+        # Remove the potentially stale wownero dir. Otherwise you might face submodule mismatches.
+        subprocess.check_call(['rm', 'wownero', '-fR'])
+    subprocess.check_call(['git', 'clone', args.url, 'wownero'])
    os.chdir('..')
    make_image_prog = ['bin/make-base-vm', '--suite', 'bionic', '--arch', 'amd64']
    if args.docker:
@ -66,10 +66,10 @@ def rebuild():
        suffix = platforms[i][2]

        print('\nCompiling ' + args.version + ' ' + os_name)
-        infile = 'inputs/monero/contrib/gitian/gitian-' + tag_name + '.yml'
-        subprocess.check_call(['bin/gbuild', '-j', args.jobs, '-m', args.memory, '--commit', 'monero='+args.commit, '--url', 'monero='+args.url, infile])
+        infile = 'inputs/wownero/contrib/gitian/gitian-' + tag_name + '.yml'
+        subprocess.check_call(['bin/gbuild', '-j', args.jobs, '-m', args.memory, '--commit', 'wownero='+args.commit, '--url', 'wownero='+args.url, infile])
        subprocess.check_call(['bin/gsign', '-p', args.sign_prog, '--signer', args.signer, '--release', args.version+'-'+tag_name, '--destination', '../sigs/', infile])
-        subprocess.check_call('mv build/out/monero-*.' + suffix + ' ../out/'+args.version, shell=True)
+        subprocess.check_call('mv build/out/wownero-*.' + suffix + ' ../out/'+args.version, shell=True)
        print('Moving var/install.log to var/install-' + tag_name + '.log')
        subprocess.check_call('mv var/install.log var/install-' + tag_name + '.log', shell=True)
        print('Moving var/build.log to var/build-' + tag_name + '.log')
@ -93,7 +93,7 @@ def build():
    os.chdir('builder')
    os.makedirs('inputs', exist_ok=True)

-    subprocess.check_call(['make', '-C', 'inputs/monero/contrib/depends', 'download', 'SOURCES_PATH=' + os.getcwd() + '/cache/common'])
+    subprocess.check_call(['make', '-C', 'inputs/wownero/contrib/depends', 'download', 'SOURCES_PATH=' + os.getcwd() + '/cache/common'])

    rebuild()

@ -104,7 +104,7 @@ def verify():

    for i, v in platforms:
        print('\nVerifying v'+args.version+' '+v[0]+'\n')
-        subprocess.check_call(['bin/gverify', '-v', '-d', '../sigs/', '-r', args.version+'-'+v[1], 'inputs/monero/contrib/gitian/gitian-'+v[1]+'.yml'])
+        subprocess.check_call(['bin/gverify', '-v', '-d', '../sigs/', '-r', args.version+'-'+v[1], 'inputs/wownero/contrib/gitian/gitian-'+v[1]+'.yml'])
    os.chdir(workdir)

 def main():
@ -113,7 +113,7 @@ def main():
    parser = argparse.ArgumentParser(description='Script for running full Gitian builds.', usage='%(prog)s [options] signer version')
    parser.add_argument('-c', '--commit', action='store_true', dest='commit', help='Indicate that the version argument is for a commit or branch')
    parser.add_argument('-p', '--pull', action='store_true', dest='pull', help='Indicate that the version argument is the number of a github repository pull request')
-    parser.add_argument('-u', '--url', dest='url', default='https://github.com/monero-project/monero', help='Specify the URL of the repository. Default is %(default)s')
+    parser.add_argument('-u', '--url', dest='url', default='https://git.wownero.com/wownero/wownero', help='Specify the URL of the repository. Default is %(default)s')
    parser.add_argument('-v', '--verify', action='store_true', dest='verify', help='Verify the Gitian build')
    parser.add_argument('-b', '--build', action='store_true', dest='build', help='Do a Gitian build')
    parser.add_argument('-B', '--buildsign', action='store_true', dest='buildsign', help='Build both signed and unsigned binaries')
@ -178,8 +178,8 @@ def main():
    if args.setup:
        setup()

-    os.makedirs('builder/inputs/monero', exist_ok=True)
-    os.chdir('builder/inputs/monero')
+    os.makedirs('builder/inputs/wownero', exist_ok=True)
+    os.chdir('builder/inputs/wownero')
    if args.pull:
        subprocess.check_call(['git', 'fetch', args.url, 'refs/pull/'+args.version+'/merge'])
        args.commit = subprocess.check_output(['git', 'show', '-s', '--format=%H', 'FETCH_HEAD'], universal_newlines=True).strip()
--- a/contrib/gitian/gitian-freebsd.yml
+++ b/contrib/gitian/gitian-freebsd.yml
@ -1,5 +1,5 @@
 ---
-name: "monero-freebsd-0.18"
+name: "wownero-freebsd-0.11"
 enable_cache: true
 suites:
 - "bionic"
@ -26,8 +26,8 @@ packages:
 - "python"
 - "cmake"
 remotes:
- "url": "https://github.com/monero-project/monero.git"
-  "dir": "monero"
+- "url": "https://git.wownero.com/wownero/wownero.git"
+  "dir": "wownero"
 files: []
 script: |

@ -87,7 +87,7 @@ script: |
  export SOURCE_DATE_EPOCH=`date -d 2000-01-01T12:00:00 +%s`

  git config --global core.abbrev 9
-  cd monero
+  cd wownero
  # Set the version string that gets added to the tar archive name
  version="`git describe`"
  if [[ $version == *"-"*"-"* ]]; then
@ -117,9 +117,9 @@ script: |
    cmake .. -DCMAKE_TOOLCHAIN_FILE=${BASEPREFIX}/${i}/share/toolchain.cmake -DCMAKE_BUILD_TYPE=Release -DCMAKE_SKIP_RPATH=ON
    make ${MAKEOPTS}
    chmod 755 bin/*
-    cp ../LICENSE ../README.md ../docs/ANONYMITY_NETWORKS.md bin
-    chmod 644 bin/LICENSE bin/*.md
-    DISTNAME=monero-${i}-${version}
+    cp ../utils/conf/wow.conf bin
+    chmod 644 bin/wow.conf
+    DISTNAME=wownero-${i}-${version}
    mv bin ${DISTNAME}
    find ${DISTNAME}/ | sort | tar --no-recursion --owner=0 --group=0 -c -T - | bzip2 -9 > ${OUTDIR}/${DISTNAME}.tar.bz2
    cd ..
--- a/contrib/gitian/gitian-linux.yml
+++ b/contrib/gitian/gitian-linux.yml
@ -1,5 +1,5 @@
 ---
-name: "monero-linux-0.18"
+name: "wownero-linux-0.11"
 enable_cache: true
 suites:
 - "bionic"
@ -21,6 +21,7 @@ packages:
 - "g++-7-arm-linux-gnueabihf"
 - "gcc-arm-linux-gnueabihf"
 - "g++-arm-linux-gnueabihf"
+- "g++-riscv64-linux-gnu"
 - "g++-7-multilib"
 - "gcc-7-multilib"
 - "binutils-arm-linux-gnueabihf"
@ -37,13 +38,13 @@ packages:
 - "python"
 - "cmake"
 remotes:
- "url": "https://github.com/monero-project/monero.git"
-  "dir": "monero"
+- "url": "https://git.wownero.com/wownero/wownero.git"
+  "dir": "wownero"
 files: []
 script: |

  WRAP_DIR=$HOME/wrapped
-  HOSTS="x86_64-linux-gnu arm-linux-gnueabihf aarch64-linux-gnu i686-linux-gnu"
+  HOSTS="x86_64-linux-gnu arm-linux-gnueabihf aarch64-linux-gnu i686-linux-gnu riscv64-linux-gnu"
  FAKETIME_HOST_PROGS=""
  FAKETIME_PROGS="date"
  HOST_CFLAGS="-O2 -g"
@ -115,7 +116,7 @@ script: |
  export SOURCE_DATE_EPOCH=`date -d 2000-01-01T12:00:00 +%s`

  git config --global core.abbrev 9
-  cd monero
+  cd wownero
  # Set the version string that gets added to the tar archive name
  version="`git describe`"
  if [[ $version == *"-"*"-"* ]]; then
@ -159,12 +160,18 @@ script: |
    fi
    export C_INCLUDE_PATH="$EXTRA_INCLUDES"
    export CPLUS_INCLUDE_PATH="$EXTRA_INCLUDES"
-    cmake .. -DCMAKE_TOOLCHAIN_FILE=${BASEPREFIX}/${i}/share/toolchain.cmake -DBACKCOMPAT=ON -DCMAKE_SKIP_RPATH=ON
+    #  glibc only added riscv support in 2.27, disable backwards compatibility
+    if [ "$i" == "riscv64-linux-gnu" ]; then
+      BACKCOMPAT_OPTION=OFF
+    else
+      BACKCOMPAT_OPTION=ON
+    fi
+    cmake .. -DCMAKE_TOOLCHAIN_FILE=${BASEPREFIX}/${i}/share/toolchain.cmake -DBACKCOMPAT=${BACKCOMPAT_OPTION} -DCMAKE_SKIP_RPATH=ON
    make ${MAKEOPTS}
    chmod 755 bin/*
-    cp ../LICENSE ../README.md ../docs/ANONYMITY_NETWORKS.md bin
-    chmod 644 bin/LICENSE bin/*.md
-    DISTNAME=monero-${i}-${version}
+    cp ../utils/conf/wow.conf bin
+    chmod 644 bin/wow.conf
+    DISTNAME=wownero-${i}-${version}
    mv bin ${DISTNAME}
    find ${DISTNAME}/ | sort | tar --no-recursion --owner=0 --group=0 -c -T - | bzip2 -9 > ${OUTDIR}/${DISTNAME}.tar.bz2
    cd ..
--- a/contrib/gitian/gitian-osx.yml
+++ b/contrib/gitian/gitian-osx.yml
@ -1,5 +1,5 @@
 ---
-name: "monero-osx-0.18"
+name: "wownero-osx-0.11"
 enable_cache: true
 suites:
 - "bionic"
@ -24,8 +24,8 @@ packages:
 - "python-dev"
 - "python-setuptools"
 remotes:
- "url": "https://github.com/monero-project/monero.git"
-  "dir": "monero"
+- "url": "https://git.wownero.com/wownero/wownero.git"
+  "dir": "wownero"
 files: []
 script: |
  WRAP_DIR=$HOME/wrapped
@ -77,7 +77,7 @@ script: |
  export PATH=${WRAP_DIR}:${PATH}

  git config --global core.abbrev 9
-  cd monero
+  cd wownero
  # Set the version string that gets added to the tar archive name
  version="`git describe`"
  if [[ $version == *"-"*"-"* ]]; then
@ -108,9 +108,9 @@ script: |
    cmake .. -DCMAKE_TOOLCHAIN_FILE=${BASEPREFIX}/${i}/share/toolchain.cmake
    make ${MAKEOPTS}
    chmod 755 bin/*
-    cp ../LICENSE ../README.md ../docs/ANONYMITY_NETWORKS.md bin
-    chmod 644 bin/LICENSE bin/*.md
-    DISTNAME=monero-${i}-${version}
+    cp ../utils/conf/wow.conf bin
+    chmod 644 bin/wow.conf
+    DISTNAME=wownero-${i}-${version}
    mv bin ${DISTNAME}
    find ${DISTNAME}/ | sort | tar --no-recursion --owner=0 --group=0 -c -T - | bzip2 -9 > ${OUTDIR}/${DISTNAME}.tar.bz2
    cd ..
--- a/contrib/gitian/gitian-win.yml
+++ b/contrib/gitian/gitian-win.yml
@ -1,5 +1,5 @@
 ---
-name: "monero-win-0.18"
+name: "wownero-win-0.11"
 enable_cache: true
 suites:
 - "bionic"
@ -35,8 +35,8 @@ alternatives:
  package: "x86_64-w64-mingw32-gcc"
  path: "/usr/bin/x86_64-w64-mingw32-gcc-posix"
 remotes:
- "url": "https://github.com/monero-project/monero.git"
-  "dir": "monero"
+- "url": "https://git.wownero.com/wownero/wownero.git"
+  "dir": "wownero"
 files: []
 script: |
  WRAP_DIR=$HOME/wrapped
@ -91,7 +91,7 @@ script: |
  export SOURCE_DATE_EPOCH=`date -d 2000-01-01T12:00:00 +%s`

  git config --global core.abbrev 9
-  cd monero
+  cd wownero
  # Set the version string that gets added to the tar archive name
  version="`git describe`"
  if [[ $version == *"-"*"-"* ]]; then
@ -127,8 +127,8 @@ script: |
    mkdir build && cd build
    cmake .. -DCMAKE_TOOLCHAIN_FILE=${BASEPREFIX}/${i}/share/toolchain.cmake
    make ${MAKEOPTS}
-    cp ../LICENSE ../README.md ../docs/ANONYMITY_NETWORKS.md bin
-    DISTNAME=monero-${i}-${version}
+    cp ../utils/conf/wow.conf bin
+    DISTNAME=wownero-${i}-${version}
    mv bin ${DISTNAME}
    find ${DISTNAME}/ | sort | zip -X@ ${OUTDIR}/${DISTNAME}.zip
    cd .. && rm -rf build
--- a/docs/ANONYMITY_NETWORKS.md
+++ b/docs/ANONYMITY_NETWORKS.md
@ -71,13 +71,13 @@ type, and max connections:

 ```
 --anonymous-inbound rveahdfho7wo4b2m.onion:28083,127.0.0.1:28083,25
--anonymous-inbound cmeua5767mz2q5jsaelk2rxhf67agrwuetaso5dzbenyzwlbkg2q.b32.i2p:5000,127.0.0.1:30000
+--anonymous-inbound cmeua5767mz2q5jsaelk2rxhf67agrwuetaso5dzbenyzwlbkg2q.b32.i2p,127.0.0.1:30000
 ```

 which tells `monerod` that a max of 25 inbound Tor connections are being
 received at address "rveahdfho7wo4b2m.onion:28083" and forwarded to `monerod`
 localhost port 28083, and a default max I2P connections are being received at
-address "cmeua5767mz2q5jsaelk2rxhf67agrwuetaso5dzbenyzwlbkg2q.b32.i2p:5000" and
+address "cmeua5767mz2q5jsaelk2rxhf67agrwuetaso5dzbenyzwlbkg2q.b32.i2p" and
 forwarded to `monerod` localhost port 30000.
 These addresses will be shared with outgoing peers, over the same network type,
 otherwise the peer will not be notified of the peer address by the proxy.
--- a/external/CMakeLists.txt
+++ b/external/CMakeLists.txt
@ -69,4 +69,4 @@ endif()
 add_subdirectory(db_drivers)
 add_subdirectory(easylogging++)
 add_subdirectory(qrcodegen)
-add_subdirectory(randomx EXCLUDE_FROM_ALL)
+add_subdirectory(randomwow EXCLUDE_FROM_ALL)
--- a/external/easylogging++/easylogging++.cc
+++ b/external/easylogging++/easylogging++.cc
@ -149,6 +149,11 @@ static el::Color colorFromLevel(el::Level level)

 static void setConsoleColor(el::Color color, bool bright)
 {
+  static const char *no_color_var = getenv("NO_COLOR");
+  static const bool no_color = no_color_var && *no_color_var; // apparently, NO_COLOR=0 means no color too (as per no-color.org)
+  if (no_color)
+    return;
+
 #if ELPP_OS_WINDOWS
  HANDLE h_stdout = GetStdHandle(STD_OUTPUT_HANDLE);
  switch (color)
--- a/external/randomwow
+++ b/external/randomwow
@ -0,0 +1 @@
+Subproject commit 27b099b6dd6fef6e17f58c6dfe00009e9c5df587
--- a/external/randomx
+++ b/external/randomx
@ -1 +0,0 @@
-Subproject commit 261d58c77fc5547c0aa7fdfeb58421ba7e0e6e1c
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@ -106,15 +106,15 @@ endif()
 add_subdirectory(cryptonote_protocol)
 if(NOT IOS)
  add_subdirectory(simplewallet)
-  add_subdirectory(gen_multisig)
-  add_subdirectory(gen_ssl_cert)
  add_subdirectory(daemonizer)
  add_subdirectory(daemon)
-  add_subdirectory(blockchain_utilities)
 endif()

 if(BUILD_DEBUG_UTILITIES)
  add_subdirectory(debug_utilities)
+  add_subdirectory(blockchain_utilities)
+  add_subdirectory(gen_multisig)
+  add_subdirectory(gen_ssl_cert)
 endif()

 if(PER_BLOCK_CHECKPOINT)
--- a/src/blockchain_db/blockchain_db.cpp
+++ b/src/blockchain_db/blockchain_db.cpp
@ -241,8 +241,15 @@ void BlockchainDB::add_transaction(const crypto::hash& blk_hash, const std::pair
    }
    else
    {
+      rct::key commitment;
+      if (tx.version > 1)
+      {
+        commitment = tx.rct_signatures.outPk[i].mask;
+        if (rct::is_rct_bulletproof_plus(tx.rct_signatures.type))
+          commitment = rct::scalarmult8(commitment);
+      }
      amount_output_indices[i] = add_output(tx_hash, tx.vout[i], i, tx.unlock_time,
-        tx.version > 1 ? &tx.rct_signatures.outPk[i].mask : NULL);
+        tx.version > 1 ? &commitment : NULL);
    }
  }
  add_tx_amount_output_indices(tx_id, amount_output_indices);
@ -446,582 +453,7 @@ void BlockchainDB::fixup()
    LOG_PRINT_L1("Database is opened read only - skipping fixup check");
    return;
  }
-
-  // There was a bug that would cause key images for transactions without
-  // any outputs to not be added to the spent key image set. There are two
-  // instances of such transactions, in blocks 202612 and 685498.
-  // The key images below are those from the inputs in those transactions.
-  // On testnet, there are no such transactions
-  // See commit 533acc30eda7792c802ea8b6417917fa99b8bc2b for the fix
-  static const char * const mainnet_genesis_hex = "418015bb9ae982a1975da7d79277c2705727a56894ba0fb246adaabb1f4632e3";
-  crypto::hash mainnet_genesis_hash;
-  epee::string_tools::hex_to_pod(mainnet_genesis_hex, mainnet_genesis_hash );
  set_batch_transactions(true);
-  batch_start();
-
-  if (get_block_hash_from_height(0) == mainnet_genesis_hash)
-  {
-    // block 202612 (511 key images in 511 transactions)
-    static const char * const key_images_202612[] =
-    {
-      "51fc647fb27439fbb3672197d2068e4110391edf80d822f58607bd5757cba7f3",
-      "d8cf1c1bd41f13c4553186e130e6e2c1cd80135ddb418f350088926997a95ca9",
-      "95d2556c8acd1457dce7bfd9c83b1d82b821a55a9c9588b04b7b5cf562a65949",
-      "4b5d987fee1bb563a162d23e41741ad73560c003e26a09b6655f09496538daac",
-      "1d25ea86323d1578579d3894a54b99ea1c3e2dca547c6726c44aef67db958b02",
-      "92e46fb70be5d9df39ca83c4fc6ae26c594118314bb75502a9c9752a781d0b33",
-      "924d0cb9060d429be7e59d164a0f80a4dabc3607d44401b26fb93e7182ab435d",
-      "f63e4a23fec860fd4c3734623891330ac1ff5af251e83a0e6247287818b8a72f",
-      "5b14c5ef13738d015619b61dacefc2ade3660d25b35ef96330a8f4e2afc26526",
-      "d5016b012a2fb6ca23fd56ece544d847962264b4aee15efe1465805fd824a8fb",
-      "0a7f3da1d9dd341cd96829e484b07163099763ac7bd60603b7ee14f7dbcb278d",
-      "d716c03d7447d2b693f6f61b6ad36bd57344033fc1a11feaf60d569f40014530",
-      "23154a812e99ce226f6a87087e0812f419aed51289f1c0c359b0b61303b53a36",
-      "03940341e1a99d5b0c68eacfdf5a20df90d7d0a3d6089d39709cdd964490755c",
-      "ef09648814cfe071f5d8e9cfde57247ad09409265c4b6c84697bbb046809bd7e",
-      "8843ec52b0496ca4e895813cfe00bb18ea777d3618e9bd2e200287e888e2f5c7",
-      "8558bf39baf3df62b5d33cdf97163a365e6c44f4d6deef920730b4982b66449f",
-      "504d9380ce581de0af97d5800d5ca9e61d78df368907151ab1e567eb6445332a",
-      "673797763593c23b3ee07b43bd8760365e2c251a8a60a275528ff34a477110cc",
-      "25178c95e4d402c58d79c160d2c52dd3c45db2c78e6aaa8d24d35c64f19d4957",
-      "407c3a05dcc8bdcb0446b5d562cf05b4536fc7337344765215130d5f1e7ee906",
-      "4e7fa771a5455d8ee8295f01181a360cdc6467cc185c2834c7daf9fbf85b6f1d",
-      "6beb64cb024f9c5c988f942177fc9c1ec5ecfa85b7db0f13a17f9f98e8e46fe7",
-      "6406bfc4e486e64c889ea15577d66e5835c65c6a39ec081af8ac5acdc153b4b5",
-      "1b1da638709f9f85898af70ffaa5b88d5a4c9f2663ca92113c400ab25caf553c",
-      "da49407a9e1ed27abd28076a647177157c42517e2542e9b6a4921fdadf4e8742",
-      "3c3fdba2a792fddaeb033605163991a09933e8f05c6c934d718e50a613b64d69",
-      "82c60429171173739fa67c4807cab359620299e6ed2a9da80139b5b1e23c5456",
-      "0a19e5767e1381ac16f57cfa5aabd8463551d19f069f7f3465c11a8583253f3e",
-      "d0fae6ffdd4818399eae6224978f170f696150eaf699f2f218abc00c68530f96",
-      "0937889aeb3af5c64608d9a9f88229a068e53417448f00f9aa5e28c570cca8f8",
-      "d6072d269753020912524961ce8c6930cf35abe5c4b2bdc7fd678338d20a68fb",
-      "0e8bc9b06fcc842bdaa7df029bfd1f252d5defc014d58a006c10ab678ecf543f",
-      "9d42f90520f02c9258be53b123d69ddbce5f33f92a903d3fb4cf3358ff0e07b5",
-      "1cc05416b12cbe719617158773c3e6173435fc64e1ee44310dc696baecaeaa95",
-      "266b15222913c11ef6403ee15dc42c8c0e16bc5fa2f49110447802236e045797",
-      "791b123af3b71ac9497a010610f72207ff8ec642969b5cf0d2891b21e7eee562",
-      "946d4d7b084dc32495f22b35fc30394144c8e0ba04f3ad6e2c2bfb0173a2266d",
-      "2c015cb990c1583228d08b2d5de9227b950c3f57364fc1033bca5c0fbfd08c58",
-      "13fdc41862fd85507f579c69accb9cc6a40f5971bfa41e3caff598a3dcffd2fc",
-      "64b06d9874a83917c583c9439d1c736083377d67fda2961b623f7124663134c3",
-      "2fa49cd19e0aa02989991a4c3760f44be800fe8fb4d58b23aca382e10dc0d2d6",
-      "377628f265f799772e9fb6065be8b6eee200c329f729fe36c25ee179e4d20df9",
-      "ba94fa79134ce383b6a98b04dc6ad3d1b950e410d50a292bc770f9685e59fe91",
-      "875c924329f0733e31fe8d8aed70dc1906335b8a9984932b6368ea24edb39765",
-      "f31f4abb3f5ee42a5aae86d70b3bd9a9c1934933641893864dd333f89719d608",
-      "2bcd629e125514a780f568d3c2e8b12a2e7fbbee06e652bbeed3e7825508e31c",
-      "918b43581163ca1963de21bb9ac401756e75c3f00ac8dcfafc139f1ad5d7d998",
-      "5730dd57fa52749a0d6502b11c9d802ac495875542431310c674a65655b7c2a3",
-      "03f84b990683e569e2f6143bb963a2a8de411e7c4b7923117b94c7afcb4b43ea",
-      "b298c8510d35bd2be0ff0753ad7d98d480f4c6490bb67fb93cd4632ea726e8a7",
-      "0a771afbf9be104c01b89eaeb57073297d35ac8fbbcc0816820fdb9a29d26625",
-      "713d90d6ca1be1a4e05a5f8441dc528c699caa09eda49c09072f5f8291354c2e",
-      "988827f45c19330d9404309f63d536a447803cca7cb182ef005b074def09ab7d",
-      "9dcaa105b4def895f3faee704c250bdc924316f153cb972f3fb565beec0b7942",
-      "1c06c30afe65b59e9e22d6bb454e4209a03efe53cdbf27b3945d5d75b1b90427",
-      "49e08c13d1da209ec1aea7b7fbe0daa648e30febeb2aa5ffbaaabdd71a278ac2",
-      "e1c2e49ab7b829854c46a64772ded35459908e0f563edbcf5c612913b7767046",
-      "e08bb7d133490ca85a6325d46807170cd07618b6a5f6e1d069e44890cc366fab",
-      "5c73ca0691cde2f35b7933d6db33f0b642ec70d0bd3f2b0ebbd97754ca67e248",
-      "6404399151872a521dae767311712225dba65d810ba2feba209204221b5d772d",
-      "4a0c3aa6cef36f44edf08ad8fb1533d7e1186e317da8a3afb3d81af072043233",
-      "104b3e1af37cf10b663a7ec8452ea882082018c4d5be4cd49e7f532e2fea64e5",
-      "e723a46bf9684b4476c3005eb5c26511c58b7eb3c708ddf7470ee30a40834b32",
-      "18e6f0fa3aa779a73ceefabea27bff3202003fd2c558ec5f5d07920528947d57",
-      "c97e73eb593ff39e63307220796cc64974c0c8adac860a2559ab47c49bc0c860",
-      "13c363a962955b00db6d5a68b8307cd900ae9202d9b2deb357b8d433545244ac",
-      "76a488865151fab977d3639bac6cba4ba9b52aa17d28ac3580775ed0bff393e4",
-      "a14de587c9f4cd50bb470ecffd10026de97b9b5e327168a0a8906891d39d4319",
-      "b1d38ee1c4ca8ae2754a719706e6f71865e8c512310061b8d26438fedf78707e",
-      "772bb8a3f74be96fa84be5fa8f9a8ef355e2df54869c2e8ae6ad2bf54ed5057e",
-      "3083a7011da36be63e3f7cacd70ab52e364dd58783302f1cb07535a66b5735f5",
-      "2b1d892e3002aa3201deb4ffe28c0c43b75b8f30c96b5d43f6d5829049ecbd94",
-      "cb738aabe44c6fb17ade284bf27db0169e309bf8cf9c91c4e4e62856619a4c64",
-      "1707e04b792f4953f460f217b9bb94c84cef60736a749fb01277cfe0eaaa48c7",
-      "ab8b6bac9b8a4f00b78acb4bd50ed2758e0fa100964b6f298d2a943eb2af2b30",
-      "dd317193fef72490f3be01293b29e9c2f94eda10824a76ca74bf39dd7cb40ab2",
-      "4fb3d995b087af7517fcb79e71f43bac0c4fbda64d89417a40ca4a708f2e8bc1",
-      "549ba38c31bf926b2cb7e8f7f15d15df6388dce477a3aff0245caa44606849fc",
-      "7585c14ab9abbffb89d0fa9f00c78ecae9f7c9062e5d4f1fae8453b3951fc60b",
-      "953f855323f72461b7167e3df0f4fd746a06f5a7f98aa42acdce2eef822a0b2f",
-      "0931932d57dde94dcfb017179a5a0954b7d671422149738260a365ca44f50eb8",
-      "a3d179d16a4a275a3bb0f260cee9284db243abad637a9dbe92d02940f1c7ee8c",
-      "959843f1e76ff0785dafe312c2ea66380fdc32b9d6180920f05f874c74599a80",
-      "fbc36b3e1718fe6c338968b04caa01a7adb315d206abc63e56768d69e008a65d",
-      "f054de7eac5e2ea48072e7fb4db93594c5f5d2dfa0afe8266042b6adc80dfdca",
-      "39dfc68dc6ba8c457b2995562c867cef2f2cf994e8d6776a6b20869e25053f70",
-      "19ad7ca7629758c22ac83643605c8a32a6665bae8e35dbc9b4ad90343756ebb3",
-      "e89e80ea5c64cf7840f614f26e35a12c9c3091fa873e63b298835d9eda31a9ea",
-      "572c1b9a83c947f62331b83009cc2ec9e62eab7260b49929388e6500c45cd917",
-      "df0b21f679e6c0bf97f7b874e9f07c93c3467b092f3d9e1484e5646fda6eca5f",
-      "8f3b7c0f4b403af62fe83d3cfac3f1e2572af8afa4cea3f3e2e04291efe84cf6",
-      "aae8b8db243009d021d8c9897d52ee8125a17212f0a8b85f681ad8950ae45f0e",
-      "3d45a4957d27447dea83d9ae2ef392a3a86619bfcf8dda2db405a7b304997797",
-      "a5b0a619a8e3030b691bdba1ed951cd54e4bc2063602eae26d9791fb18e60301",
-      "14650df217dd64a2905cd058114e761502dff37d40e80789200bc53af29b265f",
-      "fd6a245ab5e4e6e18d7ba9b37478ce38248f0ab864e5511d2208ae3d25017e5f",
-      "fbe0be6dd42a11feb5db5ae56fcbbac41041ab04a35f1df075580e960c8eeab0",
-      "72f3f1213d9bec92ba9705b447d99cd0a6a446e37a3c1c50bb8ece1090bfe56e",
-      "20df836554e1534f62b2a6df9ce58e11c1b9b4746ce8ee3c462300a8c01f5e76",
-      "5c3d2a81b7331c86420ad32b6e9a212b73b1c3413724a0f91bf073eba18e2f1f",
-      "63264ddfb29cd36fc18f3ee6614c4101ba7229bc5ac375f912590d3f0df982f4",
-      "5ec4eb637761c1c9dbc6aa6649d4410508ef8d25d61ad6caa40c6ee3236d5515",
-      "270c70940536017915e1cdbc003de7279ec1c94cba1ef6130f4236f7e306e4f0",
-      "c1d1d57a7c03f6ddeeab5230a4910db8355e2143f473dea6e1d57c2f8d882b76",
-      "218c030a7fdc9917e9f87e2921e258d34d7740a68b5bee48a392b8a2acf1f347",
-      "ac47861c01c89ea64abee14cf6e1f317859ed56b69ae66377dc63e6575b7b1eb",
-      "23bf549c8a03f9870983c8098e974308ec362354b0dcf636c242a88f24fc2718",
-      "a3ce8b817e5212c851c6b95e693849a396c79b0d04b2a554de9b78933fbea2b7",
-      "7310120c1cc1961b0d3fce13743c8a7075ae426fe6cccaf83600f24cee106236",
-      "8fa0630f193777dcc4f5eccd1ad9ceacf80acdf65e52e4e01bf3a2b2fdd0dac6",
-      "4a5f5c87f67d573d0673f01abaebc26eaa62e6d04627588549cc9e6c142dc994",
-      "78971cccacc645116f9d380c167f955d54b386a22af112233f7de004fc0c8316",
-      "badc67216868e1de1bbe044bf0e6070e6ee0353d05c13fa0c43b1897db5219a2",
-      "c45b2a168bc51cbb615a79f97432cc4bb6b104da9cdc1fc640c930657452f71b",
-      "c17eda13541d14554c5db542155b08b6bf9cb403d425745b662ebc2b2b9b3a3b",
-      "313210cd9d2efc1603f07859bae7bd5fb5914f4a631b943f2f6ff5927a4e681a",
-      "6ee94ec8af4e6828f9b46c590ea55da640ef50e810a247d3e8cdf4b91c42d2c2",
-      "505b7a4d9f1ba6577aa2a941843f86c205b23b1ea21035925e587022e2f0aeed",
-      "98e6a7cd687e8192e300a8202999ec31ad57bc34f656f2ae90d148607ff6d29f",
-      "1be5db002c0a446cc2c1da363e5d08ae045cd8f5e76c8cccd65d5166393c0bdf",
-      "17c02ac6d390c5c735e1e873c40294220e89071fca08a5da396a131fa1ba8670",
-      "2540507c39ae6fdcd90de826077f0ca390da126166a25c15c048a60606a27367",
-      "5ab9328e525c7a017ef4f591d995ad4595d74cbf8ff4112af33b08c70661a304",
-      "9c105587a96c51d81422f64e46016564d22329760648c95dcac7218f3733f915",
-      "525afb1b94a75f1edc2b55c700071e14a2166acda003370047c30dba8ea80278",
-      "745d4a5d9f95ca4efa6261b6bcd4ecacd504b5b901a2ce1353c522a5c0c15dcc",
-      "5a5a568cd87ba34252ba254e6a320e1a7f52f13e7451bb887efb34ff881785f2",
-      "1ec50a80198cd830b51f4f7a0222015a268d9b40f04e7f838c7b8dc7abf63b01",
-      "68836b662d79349cb42f5cef54e6a066157d398cc87d3b13f29fc04e5cf364a5",
-      "658db317f355a9cbd86f673775cac0c308fe14967428fd283a36e300a6a53b2f",
-      "677d79a8c467dd9db38f0ef45c2787dd368f701a6b47bf7a5f06112c38da643e",
-      "2baa455d4066f5d628f9ecd315cb57deca71069db5d0d112ae0aa18a84b6f0d7",
-      "5e7b0889f351560081360ac2b1429b48b2f7d886227f144e3b198e2f1fa56ed9",
-      "c3d317fbf26e15add8b4f8f93df9de9b22297b8e4945ebab9ee249d4f72f4e45",
-      "3c0b705a5c1e31abc7e46d8ff3c148a033f6875454cfb67f8d2a2b9a57a5ba7e",
-      "a0ab74663561af2adc2d38be3569fbe7aa2454346416ac96e5eb26b1e01b1e2f",
-      "53526cffdb74327670566c1dacacffb7d30a43a7f1862ff8bab87737bfa5edb6",
-      "24c5d36ab98d88f87b2c71afb4ea8562e05c7aa0b50f3bc0f9ed50a4cd52989b",
-      "c3ce4de5f94dff65d11e33a865855a4404259cf45263914c884f79db4f35169d",
-      "f1009b6dcf30030cff872d636fb96ed233eb6ecb8ffed003c7da64e4f5a02f4c",
-      "e3729f58614d3b42450d1599d863983ab7e3e5c29fb57aad7958c8923a2627c4",
-      "31cf4792f7b5ce01b217ec80184edd2a7c49c0b21701f5494ee2c9bac67c28ca",
-      "b42a5c9c92a656c5bb2b759ce160fdfd245243aeb1786338faea63b62e9a60ce",
-      "a1efc8d5d0855933d5ac8fe5960c7acacb92fcb09bfbc929e5002f168251e648",
-      "c4322c7f3682ec94b0dcb42f13b498c36cf575d505aacc8ec8bf67a6a2abf4c9",
-      "684ee5aa3c98357aeaddcc30c6620939b52aeef729e24b4a46ccafc44f24d831",
-      "36180f2ae11d105e0efbfbddb94e6b45b08609a383e4e1a8fa3b06d7a8051de9",
-      "96c2d183eacc87581a0b17b8d07878bc10d436728510715109a7565d9972f8b5",
-      "3068c9d04d561c7e29e3f621280b61a61885de0e9ec35a66a3116ca7a9e09627",
-      "2eb94b9673ad6f8f88288fddfceae4baaeccb37bed88a35611d826ba06a5363b",
-      "fc8cd5fae8b81121001f7767dcd5f185c0fdcc88cce1fbb184ddbcfad697ba54",
-      "51521da1ecedea6d588d774eb155d936b32a14913c2f11d989bcc5116e65bf41",
-      "3d23542e597a83dd6307700d79058b920f281c65f832333734d8a0adec510495",
-      "11d2e01913ff0d4bd21970d709d88e63289492c0bbad7bff99c0d36858a841ca",
-      "de674f1eee3068d2bc8c2f2897d8556e5deb872869652f7d3a4e5dbc6f1063c8",
-      "e722d7f728526110c0921791b417afde4af1e87ae48ccc01911786197843104b",
-      "aaba3a4e2a7d20ab76edfbcccefc27acfd509db3638582c28230e73ffd71d340",
-      "1385a7209dafb9622dd4274179832e40c7fae19445383c34ef79adb0e4de0c98",
-      "108408531fca288d74de4a2c596eab8569e355d9ab2f8380f4d24073a6b3fa95",
-      "294476a86fcd39351ae452cdb8af9584067ec4501ec6182d0062bb154559fed3",
-      "e64b175e0284c5cb69c8db46344ed43b5ced8abfe3cbf0c197103cfd116944cd",
-      "cdd73a0f1fa7c14ed2177ae2163035333718847e49dd5cca6775bd20fc7553ad",
-      "d423d2a374bc66a4587a5e3affa327ca75b8116051320759a3b88a868a7b80d4",
-      "f13ad1e5b1315557d5497b58516eb3b0759d909725ddd0eb8a0dee439c6c0a48",
-      "3a600b547a6061186a54e491344fd50cc7d4f0566a386a40aba6545254773728",
-      "37a6f3f221fe17cc04a65aa544d5135e8297ecaf0853ba784dffacb74feb481b",
-      "0ca42d67d0f84b28861d63e919e6ce5ad527447fdc53a03d8497a0241bee9376",
-      "c7dbda42459e6fadb92c416eaef3e04674fc57915a93f3be4e656634c9654075",
-      "0e34d728ae4fe347a5afecdf886fbd4d48a65c5d0dfab807da6ae95b6b2d7a3a",
-      "f1bc69257ed510db5b2ed370010b037f452a29c49e36337264b3011ce2516216",
-      "33f98f6b8a8e202463955998fba3b790199daa893e5471554826cfd9daa5c02f",
-      "f8a0a37a2c9ebd7022d7cded1ee0318fd363020070b4cdaea800e44dcc1300d2",
-      "6862714daedb908a4d86a3a3f1e65ec2c29ae61501b4ddcaf184243dd095d71b",
-      "555cd19a6d21941c1174129b8bbcc70edcf0d6874262ce9e1e542351990d523d",
-      "2cd6b44326828f23a2aa33699754bfa072c4883f39d53616f6a6b74149b664b6",
-      "127f45d2eacb565c21c1030fe8054fd0a3a75705bc368924712aa145d414fa47",
-      "19225e2dae6e1166f21cdab1290194470ded09df9b66f3faad3c1cc9ebcf340f",
-      "b7b3f53f0539b2b4837b8bb9dae0ccbd200c8d36126d9f50199d68a4293a46d3",
-      "6b6323be01f27d6d759d9670825e8ebb9c4cd8016351702328df91cef36cfec8",
-      "020c31cfdfc5b22b10235745b89b311d271cf82f2ba16d03fdf7a8bc8538694b",
-      "62573218530182b79e40d0113b7d281dace6da33bfcd0f9318558de5e5c76f08",
-      "37d928416b15982f5bb8be40c5b62fae0b664e412c25891f8860c4242927e610",
-      "b07ad11134a5c0542d2b418ef3863e8ea8477de68d9310681818ddd40825fdb0",
-      "4af77cb76bab845b56470c95ce7b8cd84ce49a095984c1f3eed67b0ee344316e",
-      "e3fdd4668d8726ba6adc401ac662c0cf6b5c1872082c488ed7da966d425fb1c0",
-      "3dec71c81c7e78e879abc8da8b30e2446edbe98eeb8df9dafe9201ebb4c6a834",
-      "7105467d9c5e855f1362fbddf820ed5e757997862efc9000317d3830a2f60ef3",
-      "2821df94b021d3e77e8d9c0f3972340210f5ea2c0935cbf125cfc578d4d6722f",
-      "114e5807accc337a22598bded30ebf3e0cfd75877e239f10cb043f829c315ab5",
-      "d658a1c0354628cd7312593ab25d5b9083de8f0def6e8425f188101d256cd136",
-      "4818d3be9b2a38fcc8c85d6c46f69b502943f79cf2462dfb0b6499e761bcc836",
-      "92b8c943cb017b5f2d39264640c069f1ecced1d3ce9b3fd755d6df2fddb99458",
-      "6edbd0fdf064fcbccd4a9e7a8ea520b87cb7faf867f7fe8a5f53625beb575119",
-      "bf3b49c477dafb06af65bf09851c0fbef9dbc3152a7268d31b55a8e7a9a95860",
-      "0e234dbadfda1393be2f068182615dbb83736f84f87710b5c7965bdce9f4a26a",
-      "df5ceae34429e47b92bbd5505ba27666552e0eb619997f359c55699c3252b1ff",
-      "08c1c7d940d699a91a83249bd578772e8958ffe23179e6150f07b96f1b47ce1e",
-      "6f919a429270da0022d70062537bdc1b21c43a8abc552d8e366647e5b719d310",
-      "63c66e5fd5d27f6fda87912ce46fa91a5e5b3634ed147fa2986330fc2696d3fa",
-      "bde070b75296bca3aa494e7f549cd2bd1ff003776712bc98a3164b139b2054ab",
-      "66694196dac5b60cf5e0ae05db8f3894fe04d65910686806551f471a0a0472e9",
-      "0d2e97524b7ce4cf30b54e61b2689df036d099c53d42e2977b1671834bac39e7",
-      "e081af76e923455f408127862be5c9baf7de6b19b952aa2a1da997d4dfe594c0",
-      "121bf6ae1596983b703d62fecf60ea7dd3c3909acf1e0911652e7dadb420ed12",
-      "a25e7b17464df71cd84ad08b17c5268520923bc33fe78c21b756f17353ea39a0",
-      "e985f078fb44dbfdf3f4f34388f0f233a4e413e02297ee9a7dcc3fcceacd44f9",
-      "b9184cf45e6e6b112cd863b1719de1bcab2137eb957e8028edca3a204a9ebb96",
-      "157d177d5e4bcce0040eb4bddb681eacf9e2942e1c542a57ce851b4742a9cc4f",
-      "0823e06635c9a1a69fd8833d1e48df98d711c1c47c06f27bb384932db1bbe9ee",
-      "8beeec1fd1bcdecba235b449cc49abca69b6486ed1c0861a2bfb6a43c970b86f",
-      "349f61a1cfc9112e537522858a0edae732a2f8434cf4780d3d2ec1e96f581cca",
-      "587cdf72b5914d364f7e214a70481cf1131ee4a09e6b43e52428d2e56b000c13",
-      "a6aa0c179316534c7b9ffb5f42a2af98d1d3a166bfb413199579f259c7b5e6df",
-      "f9f3bb1ba8da5899b79186008ecfbd416b49f3b86d94045b91e34a40e41d5cff",
-      "0cdda65a60b7b4d94e794c9397e01f69fb29309ce4fac83e7392dbba6bc497f9",
-      "8fa5fce5ad09d43af7218ea5724cff2c4849a59ff73caf3bbca466e3c8538ba8",
-      "8874ef46008753fcc0b77eb7a4a8560e35966bf5a12bcad4203ad2b4c1f8bfbe",
-      "a8ee9a3aa2d0c08a951439ffb0e6d10315fc4776997b275de1ec19663e88c2c2",
-      "9c184cbbff464ab4d5f6bfa78c39bf0880fb93b1574139306a97acb940d415c9",
-      "5493a38c255c91ca49b958ed417f6c57e5bc444779d8f536f290596a31bc63d3",
-      "3e1e82b96cc599d9fc55ae74330692ccbfb538a4cc923975fd8876efe4b81552",
-      "16aaaf820c24c2726e349b0e49bbab72ca6eef7b3a2835de88d0cececa4da684",
-      "7fa52ba349f7203c3dbc2249f9881101a3318d21869dd59f17abf953d234db65",
-      "713d8018bb9ba3ab55c3a110120b9d7593514111075ef05f0fdb233ff2ceddc8",
-      "56063afb495759a0942f1c33f28a4fb8320c6d376cb3c9513249453e45f24a04",
-      "f9a6bacd9e055749b45174ecf3c3db18b78f3474761948a68adf601f54e59660",
-      "7ddd7c6d41572f93fe07c0300c34e455b6d1f4372204933bf45035241c8b060c",
-      "f81021b893a36b201de71330a2ea050b59dbf7560c62fa9cbea9261ab47a0ba2",
-      "a01fbe4114c18fd534ae1621404d25c08e3b6775a2631ff40279bafd8c9304f4",
-      "350fad8ebc938c6eb508a1483f385f577794a002bc1229db70a1b0131d174b9d",
-      "570cb8bce87f532c5051d8c4c864012408e672a7d492669e660251fb1e066bec",
-      "8cb6efbb129c84eba26d894c4293b476a6e9a1fe969c6ad18b554d2a57885f36",
-      "f384a98467bf7f084ca31bea121a4ec76e530f523d3225c21ed25a18544a9916",
-      "da127ab58ce557c2c95c20d6a291c2e5d880fff09dc28927b7bdfec97b995d72",
-      "a4d95b4f74366ec920d0a0c5d81265688cc18733ffc444cac9b01ae2431568aa",
-      "5ae2a71470570733422468bb733d53c85b1c8a6e7e6df5c05941556bcf342d1a",
-      "65a2d161ff0e095d3afe37584dbbe649f1e9cd440755b5a3c5b2a252d5c0b8bc",
-      "25ef70a8e41bb422ed7996a41160294e33238d6af17a532232f0a50b123431a2",
-      "f1f0f76ee901664a65b97104296babb9c7422370e99bb677ae07c2ee420e7f40",
-      "c3c66dda180b0330e75c8139b9f315a8c6b937f55d87d7be42e172bbac60d71e",
-      "5881786695a9e58e19d79f790c7d9243a847c0269c5770bdd01f5149c2a62a88",
-      "f2f816d3c8ebc7df06ab68d39223181aacc7be04364d1d4e69a56c33949bb983",
-      "80a1c3b6b2778d4846ad9fe0bb2dd5afd99aa897f8231bfaac45fde43d602d9f",
-      "72ad67cb043aa5df0c3dcc2464953a66893259d81c9cc7778c12bca3447fbd58",
-      "ad72420a7963b8d4536d8eba00b4b989992247cd8c01660e242a8e71edaf0e19",
-      "999d603d1cf6068e3bb6abe1bca976fa0ab84c4660b29ea8973de8b5cf5fd283",
-      "e137a5910f02a764c3a3d8f1579ac0c7e3cc34e58933216868efe010332c1e6e",
-      "10e0fa2362f59317626ae989bd1f962c583339d8d74d76c3e585243d152b91e8",
-      "1951c652704962f5c6e33a4d4aadfee5d53ce2253644d1ed542da3e278524a07",
-      "c938bccb7ba6c0217d8ba35ed91502aee051c8ae5bff05e88aab3b322aec936f",
-      "4d6386c689785edd5beb55911a3a9fc8914838c8192184199589beef8b6ddf9f",
-      "26f6f45a6468bc4b1f085fd28d63c264ee17564f9e247fc03ee179a0b579dcda",
-      "235b7bb82b72c61acd5979ca5f2ca740aee805a780ba22e11aae5cd34f6ec760",
-      "c027ffb585a1e4844b4907490b621b08c7e40a5e6f93e97bd4bb1b615bba9908",
-      "aa77fc8053d139b998577319de29457b78b1cc8b35a5f3526c0621eaa42ce6e8",
-      "afd0af9a11c5ae2a7c4a4571ce39ad57d8df70ef146ed83ad8eaff97b2387fb8",
-      "a1f8fee9f1da9a2b306489d00edf754187b55e97f4fe6f249432fe6c7f44d6be",
-      "4f12e8a123465a862060efb656299e6bef732e5954b02194308817b243e84d32",
-      "6a1ca62f7d6952ad2eba1c64035260319baf03deabf856ca860744fc886b3d3a",
-      "c72dd1fe890d6e4c1f7325a4f224e85aef6cdca8bf9441d228efaf126e02ba63",
-      "2f6ddcea18d891ef4252e657989de68adcc43c2175d49c0c059c5e49b9dd5aed",
-      "24efac0f240ed183c30398ee40307623f52113598f66c5864c90fc62643a2aec",
-      "6ba3ebc935e7cf7fbb446e7f5c12b19c4455e6894412b0eedee4fc945e429e9a",
-      "3519d6e5bc9649f97d07a07ef5471a553ffce35c7619f4f63e91a2ba38cbb729",
-      "65e073df352fa9917e5c2475167e6c523b68c1406e1b6e81109e2d4cc87c740d",
-      "d73bf816c3648a7d53d34be938c454e515efb0c974d5a225f33635540b2db90d",
-      "bce167790fc86a273db011757d09e2d1148521ce242c2ded58f26cc49993aacb",
-      "2d4286ed4039916f29602e86f47ea4c5b05998c0198509ca7799fcadfb337e8d",
-      "9837c495b1af4f76b09177514a0f3e1dceb509c52b91712f3c7d29dc1b91d09b",
-      "5c848b8291f39759903ce77f151acf40f3ab5afa2d4a45af62b320371c29a697",
-      "b92df5016ee947ce6a21365d3361977f7f2f6c14025a983c44e13d3e8cc72152",
-      "71d2f57222a39b1a7ed2df5e6fb23a964439b5a8e7d49b49d87e5cd5354baa75",
-      "88b44d0198fb15b0c20a97f87e021c744606bfd35eae2874f35c447aa4ac3cd4",
-      "29bb4c2557714119cd684da2867e689e37e3ca9c912db83ab84746816f6092ab",
-      "b1836d98a288752675b133b9018fa1edf174f311921d01926c1e1a5900c21029",
-      "a00645e090c7d96f3155ffbcfc41e526a763b0f53a98151ac4a7d4a5b14066b6",
-      "78aab09919d17773b0d62799b37bd2e2970f72f5d1eb6472489c367b6135374f",
-      "eb6123aeb28608f1c97b2bf62ef69f977cd0658a0ab491deebb1e972caa938c5",
-      "8dd7ef1650b1b30cdf7814ae4d61a237eb0acc3ec3ce0f72b1c25780329c2d7d",
-      "b1998419be3172858b990eea84fe10bb24b76c219cde277cb4305955fc7e0b65",
-      "1b10560016c4bc506eef9056dedc2943a17179081e6eaf85b48d37dc20eac3cc",
-      "1fb1d9d4d408a6734234910f554d272739a0d6fa401918d79b57be62c3f23ba2",
-      "dec878f54ce36788289b61d32de0d9539032aba22cd15522752f729659c7cc5c",
-      "fdbfd0773f5a66637b093dabf812197940d1134619a7e60a931b19915b7dab0a",
-      "21bd2c9aae052a1c187947d2964f2be4afa7b30248409c41a75522e88a4e7977",
-      "59326adab03416ec1d36699c18e5e4fa13ca1f2212d48c23bfdecb0be7263616",
-      "bcf263d39457c0aef8ef42fd98f8131198ec4fb203155dd5bcd759e499a9ca5c",
-      "f1ad083bcd8c7630eef93336d8a971ae8ae37166a6a00ac39684420c5f9afef8",
-      "d82ee2ac41b36e3c1787a01835bf054070486dc20f6565efedbbc37cd3bf5fa5",
-      "eba91a0dcbd3986299b0a3e66c116f77bd3421829291fd769522f01da26f107b",
-      "11016558b7e8c6386c6a3e862691dcba47e33e257f0e7df38901ea7c0eba894c",
-      "04f02795e34a0030e5186c8e700da8a46b1aa6bc0abed6b35c9c1cd6a73776b9",
-      "2628dc8ad7fb731d59456b2755a99c6701467125fa69816c21bfccabc31edf6b",
-      "9b7ca249ee5b45cd264492f30df09f708a7d9caed7beb9a5c6292f22e4c31f85",
-      "5c42e7caedf382092faaf392174792b3cf5f2fe29cb586387ee55611af0617c9",
-      "373f2fd5940a01feb79659c8b9099477f6d3e7b570ebb749c2ac336ea4be583d",
-      "fea22887147adc3a659a14902080b03e86b4b8b16985fdf0bbacaed00d812422",
-      "6a3e51a1443cff62af9fa12fafc8ea78ae74dac7792c9ae0f436f570ab33eb71",
-      "796be21e213d6d0cd6fbe2de1555fb73d1cf9edc041a9f1ff1ad583c4ca92460",
-      "03fcbcb31d3fd17f0eedb45ac5a51678c7c8b2b8498225d05f74e2892f017f72",
-      "d28da07c6c22daf9ae987b3033c33d3140e5a56fa1ffd7dc5c7853d55a45bcc7",
-      "fbb0ce02f50018741a12fc08eea80a18067d7bb0fcd96153d40bb8c808473aae",
-      "2bf7c05a0209b4ea31314f04bd754cd01c58102d7cde8c496c655b6494924354",
-      "1968a9e6e14ae86a1e02e6078fc4631851fce5dbac6aa34f860defd1ccfd0ded",
-      "d886181329c9e06462a1407f547d77b38ff2c868b86d8976aa478e1cbb3d66d4",
-      "0d465e02ff2f8eb0b5fb2fa9a38579c5d66337d4a16b58f8ed28d2d89fc02392",
-      "3196419015289807880ef24b6781734822d654dc260c0560d00bac65eacd5219",
-      "fa08390ddc333a2a12248d5ec3e51fff9b782227069fe5a0afbd8eba967ae8d1",
-      "49ae36a791cb84516688d59a1ed3e5112851d65f265078aa2d433b45fa984c8a",
-      "35daa428e12c59da6730760979aca3444d8b31149c6febd99fbfefa4b2372082",
-      "5ef1d697beba612ff31d1dc139817c313a4e2ad3977775943b635c141ef0f2a1",
-      "674256037ec00edb66b9355fb1d33a30a47a5d1f4bce2dd5475d89f1ea6502db",
-      "7b6f017bc550933af91eec32a79464f540c5e0c208703e175843ee4e9ffc0a50",
-      "bf0eb91da1d18dbb18fd9ff36c837387887ba142961176a44889718b2becb9dc",
-      "3e5ac43a05164b074a2ff6353e9882917c5a3dbe168c2695de895f7decf1a56c",
-      "35e8f004965347c2b18a000a83dd3a8084b8a4bf00522061ed1179aa1107c413",
-      "fccb0fff3a24e555ec96f702ec11d420338910d148fc7b039d67568ad3a0e032",
-      "5cab231048032dbf921b4fafa1951dd2da93bc3740667f31d5a1d5665b141261",
-      "ffedb24be73441fbcd069f7785ebb865870e0f3ed228190732e4ffd5962bb82d",
-      "a4fcfec18adf92f4ed822f64d2da9f5ae630885a1bfa626530f641db99aa7a30",
-      "f98bcee41b0e3deafa1efaa1863750dbfd9bd7430b82529b670867d852230b5d",
-      "8ab8d5fca047a52364a737c1af57bf656c9ad5049f08ef4c5aa252e61aa72123",
-      "91318b39ad94c1d58143586b6d90dd6092a9d7487e321f4976967b6ac445ff43",
-      "fabfbd4569ab018e12d5ffa9b1a40ca8eb2ca60a685817351d90eaa770d5eccb",
-      "bbc5ef34428d980e2401942ceecfe07cdf21bfb1acae0596ea1d43fccf504f69",
-      "26943e4201ea407a5667103fe07ca6e08ef76940f274349b0e2e776bcfb0acb6",
-      "e3b305ffe33e72841f8e2a8688cc5cc27d42aee7624b33b7b6399b42db392437",
-      "17c5a763dd57e6bcc7c4cf2db0eb5cf3e97116b67fe0dd519c97e4a4d55d5a62",
-      "bbd260216879ce86af8318ffcf73c9e063ca76dd8bc35d3b6be45b2b4184888b",
-      "41285591d0595bc42ab663051b410d51af39fe1720592e27acb1a8af72360a76",
-      "f29acd6068ce494d0c0fe294cad91bb8968e3fff3f595a113227ab545c3ca3e6",
-      "ec9013c6394528e7dd788ce7cc085ca79fcdfbb37565999d5b4b5a4e39452ecc",
-      "27829bd7f1a8fcddcad0cc34a3b3fc67d62a2f3e09f8e75d35035c2281e83afd",
-      "666bea9db4e15087204d076294d221d4cf5864f5d94de38f29132b1934a17ace",
-      "a3a30924cad3dbda3446e5a6324e0a1390c70f795d5ecfe17ee5c70b14f7d87d",
-      "19567fe5fdb10711d60aa4d9843e1c49c2a6d2fd1b5cf662e2105606bb7815d3",
-      "b139f1c3a2f15596b9320334e37e4184d5d584c4a81e72d821a7edcad3aa62d5",
-      "08f1531e0e3e8f8bae313b2c60a72d5601bf8b60d7a4d2f60e8481650340d250",
-      "c5895669e1ff182bf1dd6c00dc955265e08ded0952b8ca62a1c63ba11c99f4ca",
-      "84d1c28153f66c1a4eb5fa0df695e936d83294df31a08d8d8e2d4798d19d8ce0",
-      "b8699f6af853fdbe897848feb46a05d733363f304eac4c8c1932e6ea4bc062cb",
-      "10eb3f6c1d0661468d9ed83593e5e9c0b43c6feec6a5405a498194905ea6ed48",
-      "509e215a600d9cadcbf5d62632ba321d7314764218db00ce8c907e425fccc445",
-      "e62119b7be84c8eaad41ba7f4a35da403f4ed96b967a3134e89ee8b78f8792c2",
-      "f790754a95d59ea5ffe6b9b5cc386c600a9e19e8bec997c192764365f1d05376",
-      "990121b5aa4d6badfb7154db4cdbb4512124bc2f442bebac71ea90b5cc86f203",
-      "b6983dedaa891eb14c964d84461e5cd37ed27b61771c64978ba83e3ecea194fa",
-      "00fba1ceaa6aa1e378cd5b22a771d6070250ac37f4e17d7bf1a70b3139e9a860",
-      "429854e7738abf2ecf46909454039e2fc5a080eb9a3c0c5ea13b07426dac3ad9",
-      "ceb3e017944b0dd787be219d8629930b3f2e20e22b12dc88fd838488ebb896f3",
-      "eb9e5d14424c63e675fe771b73ca865f7d38cf334d65e2426e12a0b88c1a2236",
-      "556ee713449e6e59ac4b8b2e8310180c8f6280484e9db23456526cceb9216168",
-      "bc89c3aa889e0144ac526a1f861227430dde7e439cc6a7e9b25c9a049c3ca7b3",
-      "56d070c62ea99be66fff741a8e45fafda5f9ff783e84d5395b251f356ce4e16f",
-      "ace15859c399e5ecd13b1420d3c3703c6a88dfb4a084f7225e7ba40a4b444fc8",
-      "f03f1261ab6eb879fe9c5b0028cd400b3ffdfac4344e4c75f6cde3c05ded1f26",
-      "955b2fda8d0068226f89270028b316b5adac871f1c1c85435479aba14a381b0f",
-      "422509a98d7461a6b8ec87cbb173b2486577b59ea9b269e01c20567b38b3b3b2",
-      "007d4de62ad89a4f5985f0cd9b76a7293acf383b4e9e734e813b9df1d57f986f",
-      "13a04e32948225b7e22aa0137341ebbb811e0743032fac16be9d691a652db2eb",
-      "8244b11d880a52f9f9e1830a822e6eeeaf0b12fc759f8261bc2f490cb0794f3b",
-      "27d3415f8f8fd3048a1ee0d9487256dd1b0f9e31be663778efa5b3add63868ec",
-      "0053f888db916a8905320e253fe2f0666355e6fb6de36f897231920a3edfe39f",
-      "0bc5c0a2ea47fa3bb8be107e3b9d6b7226b1c8bd16ca1bab8f51b8e1de08aa8b",
-      "4ca13aaa161c79025b5cd6c9a8ac33554f5ceb479fe293d9a342c865cd9c9948",
-      "333afbe82e2a3df38bd1ef998f39c5feef2554697aa21b5410c0e95ef9156249",
-      "587c4fcabd18ff890064171fce3d5be0c4aa1bba46893fb6a827a85ab54d20f3",
-      "964328e4d51d67c4e2f1fd102a66b861d98199f81d18d660b1b4b52504cd772a",
-      "196aad5594651efd679d30b9feb0f0d172cf977b4f89aa670ec741a8bf21e669",
-      "9137bfd66bbf47bfa0bfcbb9f6e71b6eb3fd9776530e9fd30d3dab19e182f35d",
-      "8217392c4ed2313188f295d94148a027a7f43824a5f5fba33a0b8c1045d509b4",
-      "be9e12761519a4836e73015544163254877e1c4912fcea67a10e7026421dde75",
-      "7b5220421a520b876cc6cdba0d3895104d7fac914dca5b93f9fe8b226566b71e",
-      "5c83fccfeb4bf0eb8a94d43ebc84a81639a32f26c7ef77d0a2b626b7de7befdb",
-      "132fd6c92cf176f975efdb5ded53470b462a48a2815c6f54a93ce4f935784cc7",
-      "46a3dba364022d11aa616a2bc20e3be5c4390f38b9446edfa464d90d9af5d48f",
-      "34b3f3fd8a83905a37762060f51d0b116377b4820b031b8e668e16f46c5b0285",
-      "f0e397e033dabec859a4b9a9043c5f1fb0dba504764d6bcf2fe9bf2ffd318474",
-      "85ecf59c7dd3b24ad17f591bc4737f32f1384c370a7a6f2add06a811dc824b6c",
-      "4d03cdb1e6ad8e066a83654626d8c221433e8d4fd901c671300af37e000177f2",
-      "61cb9c651893e6401b25f2bdf79c9f3ddc9ffe69cf6c791c420462bd73e347e1",
-      "85f2686a42158cd5ad327781ecccd1bdcd346941dd4b4edc45f717de6a011800",
-      "92de2ab82cac528e6d4ccd61e5b7c79591dcad9909c8ad3c8276ece6d48c0f08",
-      "23a878a06bb94bff33083349149f3c860f2b00bc3fb28f04cbaf717c08af19a3",
-      "1b1cce18ff0323566b192885d7ced30f9a9531a2580240f2c593a7d5b8580974",
-      "08fcdec7ea1376d84f3b13a47a4b73c7781c9c7890bb28f712b58af4fd3f24fe",
-      "03cc08fc4ece807c6495272c412be23b045622cc6b786ed8d5c94156ae678a0e",
-      "c4d8a61dc3f5dcf4b83f27a90cbc37e816cf4754e12309626ec5679c99087c46",
-      "b29d00681e29001cdd63c4bc50e5e25715faef692aeebb678c8050e1c095e888",
-      "ac154617e93f2bb1afa232675f2135437a9cc9700c14c51c40084946596ba11a",
-      "ce9549de8e68ae89f424dd9e1cde8a4eea2069da667cfcfbe837691d37366668",
-      "426c45a98e2af35cc9708149f6c086ff5a3972e77d62c627d5e20de5d731cad8",
-      "7e21bfe240a3d9b77a129c734a1d428dbc890379fbaf862853f48b2f7470b2b0",
-      "fa090a71f77223a7210de6db18d9aa809e89fb15253aea28131df6c5a7639140",
-      "7094ad044c5ab025e088b43aa0b947601fabe58ed700a412fd96e4b917ced0c8",
-      "936d5cdc4f081b6fe36c356af4378d472cd7990303f2ea44da645afd7d5d7f9c",
-      "05342037d3b69349dce7b95529d4b2a63ceb9d9393217a68f7cc8c958a96c3ea",
-      "ff9e1c414ef27b1178b1de296526f50520b7ddb06286bf9c47792bfb449e40b6",
-      "2f2b7bedb34d2854b17ccb702cddd8bc0157e39721d58be0b2ad54ee291fc9f1",
-      "0d8db1f34140bbf7eb809137018a74af08cb3345b8a3e368cdda8521dab45791",
-      "b109e4bfabcfe4a1c38be1156d9ca851c75e6aa2e57c0869e40cd9056f571e07",
-      "5cb363547ca077c806fc69bc8c2006831ab89e72fd778ac1a48fa810934e350e",
-      "85ee928bb110fd64eae54a91fc8548883e7fc4c60a3c61b505c31cea2d295c86",
-      "1ec3df7d10ee6fd5f0532ad4fe771e6befc28b0bed0250bf523695d6d49a8246",
-      "de9db2fc07c866bd7b885fb41522b63d550d0ce2e8ac5e14464a41733c2319e6",
-      "9a27136422a8f56768db29ba172a7ba26c3c7aa910324e78e5ab3a3268ac3674",
-      "60213c315119bf9005cb533d1a5b403b4a13c59982fe7773d30fdd8f519f4205",
-      "40eb61ef1812eb8a4d389599bf449fc86653b2c4986061b952f46fc049de53f4",
-      "658ef0d8140162b5f04591be13b47456245f531208bbca3260b857ca09b803c5",
-      "02270fa66255048d724894e2206b4e773cc6a7b6d17ca090cdc25f317d5f53b9",
-      "2ec6a0147f419161f7198d05be5f93152d9ccc10672db0ea47ff1687c0f0dd15",
-      "4be1d8ceb96eb80ef7ce30079ded31163272aeccff5c18fe3aaa32ea2f5bed9d",
-      "04ecaf48f44de87243b17b4c71ebff00020738639336010fa57435a54b623798",
-      "e313a9feb7cfd1d56ec87b1f1062ff9a80da498f7b761af4bef0cecd1b4c385b",
-      "ede3748f971f22341f7f5844dc60fc03cdb30c7cc720ebe13ae588c17a78aa94",
-      "d90c0faa70e39b7c0a8c55457ed6e6478a4e4bf3707b08104326a1ee8377c3ab",
-      "c79ffd0bbc8d004cc542e212990df6498abddd3deb50fd00ed00a2ff690974d6",
-      "35c37d88cf73a89c4124b0ee537347c37fdb47156c8b0ecc509efc58236ed3f0",
-      "a99182f343ccf05e557ffa6df71f03688b2afcf314c59daa774fe78db6f47add",
-      "01115397a78af8a4ae2727ca7a01843235b626bd3db80888d3dfd0020d4135e2",
-      "4a55aced578470d2f7280096d7fe8095f294095fba4778d1977d6db9270472f0",
-      "4624adf8a5633f65b213b8ca46b55cb0ee36c41495f39b1ae70cbd545779b1a0",
-      "d72bcd5b57a9c47e7bd5e9a1103657d10beb7b6c6d41f2b2985bc3bd3cc74860",
-      "48baadb9a46293c92f29e7617846171356a42c3b5d18d49a05a7e173993785f7",
-      "3da927737af8cb0e1c77097e35c54158d18aabfb3051c45bcc7ddfe00b157b1f",
-      "b4a24bfdb2cb802c8d48a3a18fbfe18622a767fe7eddfca57d4555550ccd1643",
-      "c58f82ac7c49dcba1721a88358f07636c9df60d3fd383e5789b808dc57a1dc9d",
-      "5e1f756eff5155df073d30f4452bdafc4adaf4f35960771bf2c1e30137fd7a79",
-      "be4a332f289338d67bd4834eae3128c488a61d255e972da484b6252b67a46b89",
-      "d496e4a36238d03a83d8b45cf33d9388aa7568a279b034d1cdd87b457356cc5b",
-      "a1c5212730ccda34de393210e276bbd44720dda777bcfd602315a3eee582f7dc",
-      "08914ec63f6ef7fe1d678937dc0f6178883440b26b4aca29fce79068947e8397",
-      "49e2cd2bd9b974074d9814f93eed371620bd4ea5fbf97a625065704e8fb382d7",
-      "047c194111818b48ce93a4b006e4a09b9a2650757a87357111796e11e847bf23",
-      "5955b0baa8265341f35a6f24fdc79066ba3ca9c5354c69b6b37a9ef3a26be556",
-      "d7c962f3ea1938c5267cca4072548acf3afcce4d438ed62027caa211a5f98e8b",
-      "c8cfba67cb4ce7e291b35154a50476d9a5c6bbb5d6cbaaa5d2408547fea7b02b",
-      "de8a940d8a69a64ce264d2ab7320662aef2e391c587cb2aae22a86718d5dffbb",
-      "94176f1310b26e54d4de48f87b74aa0b60532f184a2268508dece86dd7f85d36",
-      "9ce6ee3fca56c9256a69df404782301300a6e5e7f5a25a1f6d68c0e9e42584c9",
-      "7c423c4a220c6ff43ab6432f92b166323c58ee77f8c096ba0b00d52d7bd507e8",
-      "0b62b9c1ae4d4988720e8d41d980b334458189de0a3dd01699338d7b07c3894e",
-      "64f45f6f75110624506c53716f2fc1d5fe5f88f82a5bc6a7459ce70eae56dbb3",
-      "12ffbeb8e52fed161af4d8a015d1a5c45dcb8240e5c8933ce3a88ba2c58f97e8",
-      "2ee6b7b96043c8ded9fb52f87cdd0d0580ca6f8cef183c8a656394a11c0aa393",
-      "aaef26b1f5726258bf9ce305a3e54bca65cf68779f90f9d24287245c27362e27",
-      "ef59588dce57c35d010bea4d209f44c62f0b7c7e65bc0226c0e4971934da9435",
-      "0e606c2f6f8dcd579faf4739312bd7327ac7796fa44a81780fe0d66fc7761fb9",
-      "2f307198afdbde5f95989a17e06ce1bb9ff36c441cf3b2248431534fe13bb9fe",
-      "51418e6df23d450aaacc74ef2df53a6b1693727b70bda9ebc43acfc23d8fb5ea",
-      "6e9e3ac46705ed80520695b924435b00d2b3079598bf7faca7fd1524be777e5e",
-      "1e96241e2876aad29ce64f5d7e7fbb8db7265449df816c0d30a96633778c5cb6",
-      "81788f00eb72696d811f946e65d2c96528c45590874a1defdd46651e9b79a3a1",
-      "d9aa5a9f1df50e933d7105a5d72b5fe96bfbb9fd4b5b0eaa5e80af12e72d497a",
-      "e1b6976a732d27fc5d6a96b6d3d0d1d5eaa6ec46bae4665f17e7a43aefc75280",
-      "9151c75edcec1cc90aa2d2c240ff657b0eef3f5f1ec37418c8854b2493114f1d",
-      "3e7c12d0132421f08ea0a390cfa325e422a6b35120fb2eb650f108a165237934",
-      "1ee0e85c7d8a91089c03f37318cdc9127026bf789e3ce4b75046eaa3eebd3458",
-      "4ae64a3ef66cad847409ce175bd5365c9097fd21647a05730ac6b45841add3c8",
-      "f0ea0f334cf1d64678a6dab08c07e2f94f339e8389bd17ebc882b5c8b736cbf2",
-      "da904db96060546ff69e28993ce8183766da9402ac10fae9fc1f1d67ebd83c90",
-      "db11820615f7b5e47778c45d2e083e77f49b608b587dc09ec26f077aba07a242",
-      "ff5c726a83bd785484de75bb03b421f9e8e382bf2740120a2fcf72326aa01c75",
-      "f8643a7efd6304980db323303ab73a6fd4f4ee1047520d39d571580395b97f21",
-      "8facf9737d07838aedf6030593bfb247d8c29fe8d9b18b2913408627a4424d7e",
-      "f0672964aa6e4c7dd4768e18827023787386927f4db89fd661444979afb43c18",
-      "6fd3649c8401f2704ed2be18518b870eb6bf2b9a6689d1b336f05bd8b49017f6",
-      "ed172dac7de827493e0c0fdd8d3299333acb678e72ed499e0224b389cc1e0fba",
-      "7f9a8a8cc8e34add11934a1a5882be5978a6d28405cb0a053ec5699a502b1cef",
-      "6ca829ebd2a0a40994f68c1db7978ec274b45c46e9b351df869a2bfe0630bbd4",
-      "0bbb017c437573a55db88258a9d9a01188bdd23bb6b26903b137814871661f47",
-      "9a6358d2541f46b6d05b80fe25a2cb025fbe9e4b227a6275908d5ee31c948569",
-      "a75d26c6d4ce944024f10e6d23e8b5b888d680120e15dc0e4fee8d8833ee0c6a",
-      "1d43d33556699b42c124b46e41243abf48727fe488428056fdd174a3861c1e3c",
-      "7b5bd3fecbaa093f005c4f806ea67846c0df6b04df7729925cb14724f6a8b582",
-      "6bdf2b54f2f5ab90191261d33dee80fede75896994016422b28db8ba62327d82",
-      "1a16181b250085a91ccecc118473fa2ab98515e894a7b63b347c24b5be560c7a",
-      "22d24891755910b48ad632358c26245bdcc375abc41f7e2c9fb3c7773dbf4e22",
-      "5b70c5d4a373d541619c944fcc3b61259550b0e9fba3eca16f0879e5845b43b9",
-      "b78f9098c9d76987b7409e63426a8d49972bb4e75289576c680cf96513d44b6d",
-      "916b53b8e85eb7e0a2a76d6fc8d2163430e7183ccb103d6705f54af4bb070907",
-      "dc3d78f43110d2aa9df83c5485ec33663ad5452b8cdeb1aeeac9d6b1487fb781",
-      "3975539ed5402cb9f5ab503584524dd141cc4296b666ec66d807f94f62b1c026",
-      "bd1f97fd89183643423073f22733880616456ca41960699f18e868cb9ac35508",
-      "90b468ff0f83460c3dd8cfe778c39d32c6bb1eeff9ac5de7804a4050d3b8073e",
-      "0e886d49d88b82c9f8dbdd2f38a535992f35ab16629724d746394db3898235fa",
-      "76c22e965242d1ca5614e829d9028dcad9c4b09393bcbdd318b0365557335fb9",
-      "59b168488ec8629f820a1efd8fc5a0c2adec4253e61d6a2945a68a9a43be9035",
-      "ff172b42854eaf2865caa985d2fb6283c5ab19574126623ffd615a761a5bce72",
-      "cb46ac9ccc024ee74c96e3cf1c13a6949a432e855dfa881b6a307c0e6daac59e",
-      "9971574924c0f413bf4c0f96bb9c2fbdfea8f475e33a8fb6f15fa40903b63444",
-      "1a95567deb0f45a8941e2248f33286485984a5e9d86d16c37d42169ad864dc36",
-      "205fc7f7ec7a83f0bc22d5269c91762cd00adc7428456d799be5a0cd76f08b0f",
-      "849dd41ef59a722901b7a0deb2c1fd3c110a91a726120a0a119cb7a15cf98438",
-      "a32880917c714612101af95e5c8d8eb5fb046fdcc68bae76c05b829b3fa73c2e",
-      "70b38d6d510d13b359dffa910329952c620a4bce4ee7a8552b9bb3a14572394d",
-      "ef257ab2f4226faa6ba288a6793f026609068effb866c18496a847e8b60b102d",
-      "e5196ab42ff53c8352288bde6b6b7312cd6f39f7d21b556b0db178d8470d5790",
-      "ca98f128bf085f2b718f2b3c12da7c4d98887cc94251a2b1705b637611bd83bb",
-      "79508f0b93a49ec19c5cb05906ca1ba3d3db8ed4f9c6884873d0d7e3e985ea51",
-      "9088be3f47f9debc63e928739f7163182b49eab044518b151f0b89f6b6aefdd0",
-      "46b2782fd669b6288a4d7348cf6671360277ba4864cc69bce3497369ac2ec31e",
-      "0fa5131557db67b430d516530be939ff25882adf68a076602f3dfad8c77c963a",
-      "3404302cc097d5457244453a4c9990804201ee8161188df811bcb32404998c71",
-      "856939710dbb90a8eeda875a31f9a52af759bd932b88e7b08df35414c54d4721",
-      "72569573b9b41d0ac5ce17764a139c6b8b36ef3ca6d92cec625dbcdae758ba22",
-      "9746da344e435a008d6acb4847211bb676376ecc76c825b5d44a28b89ceeb40e",
-      "3eafded1595516f032e33ec975f4c9c3a1055d13aa5575cf8a801d6103fdbeb4",
-      "e88a6d2daa863c0787cc523a2cab45c546fad788951b10d75e2b0954db24cca7",
-      "38f531e67f88f66de44d3357c8e8f2db456160ca31dd2024c9562f6afd260278",
-    };
-    // block 685498 (13 key images in one transaction)
-    static const char * const key_images_685498[] =
-    {
-      "749b7277aa21c70c417f255fb181c3a30b44277edf657eaaebf28a2709dd2a90",
-      "5a9b3e1a87332d735cedaa2b5623a6a5e99d99f5a2887c8fc84293577e8bf25c",
-      "bea438768445eb3650cf619bf6758e94035abfe0ccda91d4a58c582df143d835",
-      "376e237ff4da5e5cbd6e1bba4b01412fa751f2959c0c57006589f382413df429",
-      "14ac2f2e044f8635a3a42ecb46c575424073c1f6e5ed5e905f516d57f63184b5",
-      "2d1d2ecb77b69a2901de00897d0509c1b7855a3b2f8eb1afe419008fc03cd15a",
-      "ea01658f0972b77ae9112d525ec073e3ec5c3b98d5ad912d95ab2636354b70b6",
-      "d3934864a46101d8c242415282e7fc9ee73ad16cd40355535d226ab45ecdb61a",
-      "ee379b05c5d02432330ebd4ea9c4f1c87d14c388568d526a0f8a22649a14e453",
-      "aeb7b842b410b13ca4af7a5ffd5ae6caddc8bfec653df1b945e478839a2e0057",
-      "451806929d9f5c3a7f365472703871abadc25b2a5a2d75472a45e86cd76c610b",
-      "272d9b9fcc9e253c08da9caf8233471150019582eaefef461c1f9ceff7e2c337",
-      "633cdedeb3b96ec4f234c670254c6f721e0b368d00b48c6b26759db7d62cf52d",
-    };
-
-    if (height() > 202612)
-    {
-      for (const auto &kis: key_images_202612)
-      {
-        crypto::key_image ki;
-        epee::string_tools::hex_to_pod(kis, ki);
-        if (!has_key_image(ki))
-        {
-          LOG_PRINT_L1("Fixup: adding missing spent key " << ki);
-          add_spent_key(ki);
-        }
-      }
-    }
-    if (height() > 685498)
-    {
-      for (const auto &kis: key_images_685498)
-      {
-        crypto::key_image ki;
-        epee::string_tools::hex_to_pod(kis, ki);
-        if (!has_key_image(ki))
-        {
-          LOG_PRINT_L1("Fixup: adding missing spent key " << ki);
-          add_spent_key(ki);
-        }
-      }
-    }
-  }
-  batch_stop();
 }

 bool BlockchainDB::txpool_tx_matches_category(const crypto::hash& tx_hash, relay_category category)
--- a/src/blockchain_db/lmdb/db_lmdb.cpp
+++ b/src/blockchain_db/lmdb/db_lmdb.cpp
@ -820,7 +820,7 @@ void BlockchainLMDB::add_block(const block& blk, size_t block_weight, uint64_t l
  bi.bi_diff_lo = (cumulative_difficulty & 0xffffffffffffffff).convert_to<uint64_t>();
  bi.bi_hash = blk_hash;
  bi.bi_cum_rct = num_rct_outs;
-  if (blk.major_version >= 4)
+  if (m_height > 0 && blk.major_version >= 4)
  {
    uint64_t last_height = m_height-1;
    MDB_val_set(h, last_height);
@ -1351,7 +1351,7 @@ void BlockchainLMDB::open(const std::string& filename, const int db_flags)
  if (is_hdd_result)
  {
    if (is_hdd_result.value())
-        MCLOG_RED(el::Level::Warning, "global", "The blockchain is on a rotating drive: this will be very slow, use an SSD if possible");
+        MCLOG_RED(el::Level::Debug, "global", "The blockchain is on a rotating drive: this will be very slow, use an SSD if possible");
  }

  m_folder = filename;
@ -1504,7 +1504,7 @@ void BlockchainLMDB::open(const std::string& filename, const int db_flags)
        mdb_env_close(m_env);
        m_open = false;
        MFATAL("Existing lmdb database needs to be converted, which cannot be done on a read-only database.");
-        MFATAL("Please run monerod once to convert the database.");
+        MFATAL("Please run wownerod once to convert the database.");
        return;
      }
      // Note that there was a schema change within version 0 as well.
--- a/src/blockchain_utilities/CMakeLists.txt
+++ b/src/blockchain_utilities/CMakeLists.txt
@ -157,7 +157,7 @@ endif()

 set_property(TARGET blockchain_import
 	PROPERTY
-	OUTPUT_NAME "monero-blockchain-import")
+	OUTPUT_NAME "wownero-blockchain-import")
 install(TARGETS blockchain_import DESTINATION bin)

 monero_add_executable(blockchain_export
@ -178,7 +178,7 @@ target_link_libraries(blockchain_export

 set_property(TARGET blockchain_export
 	PROPERTY
-	OUTPUT_NAME "monero-blockchain-export")
+	OUTPUT_NAME "wownero-blockchain-export")
 install(TARGETS blockchain_export DESTINATION bin)

 monero_add_executable(blockchain_blackball
@ -200,7 +200,7 @@ target_link_libraries(blockchain_blackball

 set_property(TARGET blockchain_blackball
 	PROPERTY
-	OUTPUT_NAME "monero-blockchain-mark-spent-outputs")
+	OUTPUT_NAME "wownero-blockchain-mark-spent-outputs")
 install(TARGETS blockchain_blackball DESTINATION bin)


@ -222,7 +222,7 @@ target_link_libraries(blockchain_usage

 set_property(TARGET blockchain_usage
 	PROPERTY
-	OUTPUT_NAME "monero-blockchain-usage")
+	OUTPUT_NAME "wownero-blockchain-usage")
 install(TARGETS blockchain_usage DESTINATION bin)

 monero_add_executable(blockchain_ancestry
@ -243,7 +243,7 @@ target_link_libraries(blockchain_ancestry

 set_property(TARGET blockchain_ancestry
 	PROPERTY
-	OUTPUT_NAME "monero-blockchain-ancestry")
+	OUTPUT_NAME "wownero-blockchain-ancestry")
 install(TARGETS blockchain_ancestry DESTINATION bin)

 monero_add_executable(blockchain_depth
@ -264,7 +264,7 @@ target_link_libraries(blockchain_depth

 set_property(TARGET blockchain_depth
 	PROPERTY
-	OUTPUT_NAME "monero-blockchain-depth")
+	OUTPUT_NAME "wownero-blockchain-depth")
 install(TARGETS blockchain_depth DESTINATION bin)

 monero_add_executable(blockchain_stats
@ -285,7 +285,7 @@ target_link_libraries(blockchain_stats

 set_property(TARGET blockchain_stats
 	PROPERTY
-	OUTPUT_NAME "monero-blockchain-stats")
+	OUTPUT_NAME "wownero-blockchain-stats")
 install(TARGETS blockchain_stats DESTINATION bin)

 monero_add_executable(blockchain_prune_known_spent_data
@ -307,7 +307,7 @@ target_link_libraries(blockchain_prune_known_spent_data

 set_property(TARGET blockchain_prune_known_spent_data
 	PROPERTY
-	OUTPUT_NAME "monero-blockchain-prune-known-spent-data")
+	OUTPUT_NAME "wownero-blockchain-prune-known-spent-data")
 install(TARGETS blockchain_prune_known_spent_data DESTINATION bin)

 monero_add_executable(blockchain_prune
@ -316,7 +316,7 @@ monero_add_executable(blockchain_prune

 set_property(TARGET blockchain_prune
 	PROPERTY
-	OUTPUT_NAME "monero-blockchain-prune")
+	OUTPUT_NAME "wownero-blockchain-prune")
 install(TARGETS blockchain_prune DESTINATION bin)

 target_link_libraries(blockchain_prune
--- a/src/blockchain_utilities/blockchain_ancestry.cpp
+++ b/src/blockchain_utilities/blockchain_ancestry.cpp
@ -386,12 +386,12 @@ int main(int argc, char* argv[])

  if (command_line::get_arg(vm, command_line::arg_help))
  {
-    std::cout << "Monero '" << MONERO_RELEASE_NAME << "' (v" << MONERO_VERSION_FULL << ")" << ENDL << ENDL;
+    std::cout << "Wownero '" << MONERO_RELEASE_NAME << "' (v" << MONERO_VERSION_FULL << ")" << ENDL << ENDL;
    std::cout << desc_options << std::endl;
    return 1;
  }

-  mlog_configure(mlog_get_default_log_path("monero-blockchain-ancestry.log"), true);
+  mlog_configure(mlog_get_default_log_path("wownero-blockchain-ancestry.log"), true);
  if (!command_line::is_arg_defaulted(vm, arg_log_level))
    mlog_set_log(command_line::get_arg(vm, arg_log_level).c_str());
  else
--- a/src/blockchain_utilities/blockchain_blackball.cpp
+++ b/src/blockchain_utilities/blockchain_blackball.cpp
@ -132,7 +132,7 @@ static std::string get_default_db_path()
  boost::filesystem::path dir = tools::get_default_data_dir();
  // remove .bitmonero, replace with .shared-ringdb
  dir = dir.remove_filename();
-  dir /= ".shared-ringdb";
+  dir /= ".wow-shared-ringdb";
  return dir.string();
 }

@ -1176,7 +1176,7 @@ int main(int argc, char* argv[])
  const command_line::arg_descriptor<bool> arg_rct_only  = {"rct-only", "Only work on ringCT outputs", false};
  const command_line::arg_descriptor<bool> arg_check_subsets  = {"check-subsets", "Check ring subsets (very expensive)", false};
  const command_line::arg_descriptor<bool> arg_verbose  = {"verbose", "Verbose output)", false};
-  const command_line::arg_descriptor<std::vector<std::string> > arg_inputs = {"inputs", "Path to Monero DB, and path to any fork DBs"};
+  const command_line::arg_descriptor<std::vector<std::string> > arg_inputs = {"inputs", "Path to Wownero DB, and path to any fork DBs"};
  const command_line::arg_descriptor<std::string> arg_db_sync_mode = {
    "db-sync-mode"
  , "Specify sync option, using format [safe|fast|fastest]:[nrecords_per_sync]." 
@ -1219,12 +1219,12 @@ int main(int argc, char* argv[])

  if (command_line::get_arg(vm, command_line::arg_help))
  {
-    std::cout << "Monero '" << MONERO_RELEASE_NAME << "' (v" << MONERO_VERSION_FULL << ")" << ENDL << ENDL;
+    std::cout << "Wownero '" << MONERO_RELEASE_NAME << "' (v" << MONERO_VERSION_FULL << ")" << ENDL << ENDL;
    std::cout << desc_options << std::endl;
    return 1;
  }

-  mlog_configure(mlog_get_default_log_path("monero-blockchain-mark-spent-outputs.log"), true);
+  mlog_configure(mlog_get_default_log_path("wownero-blockchain-mark-spent-outputs.log"), true);
  if (!command_line::is_arg_defaulted(vm, arg_log_level))
    mlog_set_log(command_line::get_arg(vm, arg_log_level).c_str());
  else
--- a/src/blockchain_utilities/blockchain_depth.cpp
+++ b/src/blockchain_utilities/blockchain_depth.cpp
@ -88,12 +88,12 @@ int main(int argc, char* argv[])

  if (command_line::get_arg(vm, command_line::arg_help))
  {
-    std::cout << "Monero '" << MONERO_RELEASE_NAME << "' (v" << MONERO_VERSION_FULL << ")" << ENDL << ENDL;
+    std::cout << "Wownero '" << MONERO_RELEASE_NAME << "' (v" << MONERO_VERSION_FULL << ")" << ENDL << ENDL;
    std::cout << desc_options << std::endl;
    return 1;
  }

-  mlog_configure(mlog_get_default_log_path("monero-blockchain-depth.log"), true);
+  mlog_configure(mlog_get_default_log_path("wownero-blockchain-depth.log"), true);
  if (!command_line::is_arg_defaulted(vm, arg_log_level))
    mlog_set_log(command_line::get_arg(vm, arg_log_level).c_str());
  else
--- a/src/blockchain_utilities/blockchain_export.cpp
+++ b/src/blockchain_utilities/blockchain_export.cpp
@ -90,12 +90,12 @@ int main(int argc, char* argv[])

  if (command_line::get_arg(vm, command_line::arg_help))
  {
-    std::cout << "Monero '" << MONERO_RELEASE_NAME << "' (v" << MONERO_VERSION_FULL << ")" << ENDL << ENDL;
+    std::cout << "Wownero '" << MONERO_RELEASE_NAME << "' (v" << MONERO_VERSION_FULL << ")" << ENDL << ENDL;
    std::cout << desc_options << std::endl;
    return 1;
  }

-  mlog_configure(mlog_get_default_log_path("monero-blockchain-export.log"), true);
+  mlog_configure(mlog_get_default_log_path("wownero-blockchain-export.log"), true);
  if (!command_line::is_arg_defaulted(vm, arg_log_level))
    mlog_set_log(command_line::get_arg(vm, arg_log_level).c_str());
  else
--- a/src/blockchain_utilities/blockchain_import.cpp
+++ b/src/blockchain_utilities/blockchain_import.cpp
@ -637,7 +637,7 @@ int main(int argc, char* argv[])

  if (command_line::get_arg(vm, command_line::arg_help))
  {
-    std::cout << "Monero '" << MONERO_RELEASE_NAME << "' (v" << MONERO_VERSION_FULL << ")" << ENDL << ENDL;
+    std::cout << "Wownero '" << MONERO_RELEASE_NAME << "' (v" << MONERO_VERSION_FULL << ")" << ENDL << ENDL;
    std::cout << desc_options << std::endl;
    return 1;
  }
@ -674,7 +674,7 @@ int main(int argc, char* argv[])
  }
  m_config_folder = command_line::get_arg(vm, cryptonote::arg_data_dir);

-  mlog_configure(mlog_get_default_log_path("monero-blockchain-import.log"), true);
+  mlog_configure(mlog_get_default_log_path("wownero-blockchain-import.log"), true);
  if (!command_line::is_arg_defaulted(vm, arg_log_level))
    mlog_set_log(command_line::get_arg(vm, arg_log_level).c_str());
  else
--- a/src/blockchain_utilities/blockchain_prune.cpp
+++ b/src/blockchain_utilities/blockchain_prune.cpp
@ -483,12 +483,12 @@ int main(int argc, char* argv[])

  if (command_line::get_arg(vm, command_line::arg_help))
  {
-    std::cout << "Monero '" << MONERO_RELEASE_NAME << "' (v" << MONERO_VERSION_FULL << ")" << ENDL << ENDL;
+    std::cout << "Wownero '" << MONERO_RELEASE_NAME << "' (v" << MONERO_VERSION_FULL << ")" << ENDL << ENDL;
    std::cout << desc_options << std::endl;
    return 1;
  }

-  mlog_configure(mlog_get_default_log_path("monero-blockchain-prune.log"), true);
+  mlog_configure(mlog_get_default_log_path("wownero-blockchain-prune.log"), true);
  if (!command_line::is_arg_defaulted(vm, arg_log_level))
    mlog_set_log(command_line::get_arg(vm, arg_log_level).c_str());
  else
--- a/src/blockchain_utilities/blockchain_prune_known_spent_data.cpp
+++ b/src/blockchain_utilities/blockchain_prune_known_spent_data.cpp
@ -137,12 +137,12 @@ int main(int argc, char* argv[])

  if (command_line::get_arg(vm, command_line::arg_help))
  {
-    std::cout << "Monero '" << MONERO_RELEASE_NAME << "' (v" << MONERO_VERSION_FULL << ")" << ENDL << ENDL;
+    std::cout << "Wownero '" << MONERO_RELEASE_NAME << "' (v" << MONERO_VERSION_FULL << ")" << ENDL << ENDL;
    std::cout << desc_options << std::endl;
    return 1;
  }

-  mlog_configure(mlog_get_default_log_path("monero-blockchain-prune-known-spent-data.log"), true);
+  mlog_configure(mlog_get_default_log_path("wownero-blockchain-prune-known-spent-data.log"), true);
  if (!command_line::is_arg_defaulted(vm, arg_log_level))
    mlog_set_log(command_line::get_arg(vm, arg_log_level).c_str());
  else
--- a/src/blockchain_utilities/blockchain_stats.cpp
+++ b/src/blockchain_utilities/blockchain_stats.cpp
@ -175,12 +175,12 @@ int main(int argc, char* argv[])

  if (command_line::get_arg(vm, command_line::arg_help))
  {
-    std::cout << "Monero '" << MONERO_RELEASE_NAME << "' (v" << MONERO_VERSION_FULL << ")" << ENDL << ENDL;
+    std::cout << "Wownero '" << MONERO_RELEASE_NAME << "' (v" << MONERO_VERSION_FULL << ")" << ENDL << ENDL;
    std::cout << desc_options << std::endl;
    return 1;
  }

-  mlog_configure(mlog_get_default_log_path("monero-blockchain-stats.log"), true);
+  mlog_configure(mlog_get_default_log_path("wownero-blockchain-stats.log"), true);
  if (!command_line::is_arg_defaulted(vm, arg_log_level))
    mlog_set_log(command_line::get_arg(vm, arg_log_level).c_str());
  else
--- a/src/blockchain_utilities/blockchain_usage.cpp
+++ b/src/blockchain_utilities/blockchain_usage.cpp
@ -120,12 +120,12 @@ int main(int argc, char* argv[])

  if (command_line::get_arg(vm, command_line::arg_help))
  {
-    std::cout << "Monero '" << MONERO_RELEASE_NAME << "' (v" << MONERO_VERSION_FULL << ")" << ENDL << ENDL;
+    std::cout << "Wownero '" << MONERO_RELEASE_NAME << "' (v" << MONERO_VERSION_FULL << ")" << ENDL << ENDL;
    std::cout << desc_options << std::endl;
    return 1;
  }

-  mlog_configure(mlog_get_default_log_path("monero-blockchain-usage.log"), true);
+  mlog_configure(mlog_get_default_log_path("wownero-blockchain-usage.log"), true);
  if (!command_line::is_arg_defaulted(vm, arg_log_level))
    mlog_set_log(command_line::get_arg(vm, arg_log_level).c_str());
  else
--- a/src/blocks/CMakeLists.txt
+++ b/src/blocks/CMakeLists.txt
@ -41,7 +41,7 @@ const size_t ${BLOB_NAME}_len = sizeof(${BLOB_NAME});
 "
 )
 ]=])
-foreach(BLOB_NAME checkpoints testnet_blocks stagenet_blocks)
+foreach(BLOB_NAME checkpoints)
    set(OUTPUT_C_SOURCE "generated_${BLOB_NAME}.c")
    list(APPEND GENERATED_SOURCES ${OUTPUT_C_SOURCE})
    set(INPUT_DAT_FILE "${BLOB_NAME}.dat")
--- a/src/blocks/blocks.cpp
+++ b/src/blocks/blocks.cpp
@ -4,18 +4,12 @@

 extern const unsigned char checkpoints[];
 extern const size_t checkpoints_len;
-extern const unsigned char stagenet_blocks[];
-extern const size_t stagenet_blocks_len;
-extern const unsigned char testnet_blocks[];
-extern const size_t testnet_blocks_len;

 namespace blocks
 {

  const std::unordered_map<cryptonote::network_type, const epee::span<const unsigned char>, std::hash<size_t>> CheckpointsByNetwork = {
-    {cryptonote::network_type::MAINNET, {checkpoints, checkpoints_len}},
-    {cryptonote::network_type::STAGENET, {stagenet_blocks, stagenet_blocks_len}},
-    {cryptonote::network_type::TESTNET, {testnet_blocks, testnet_blocks_len}}
+    {cryptonote::network_type::MAINNET, {checkpoints, checkpoints_len}}
  };

  const epee::span<const unsigned char> GetCheckpointsData(cryptonote::network_type network)
--- a/src/blocks/checkpoints.dat
+++ b/src/blocks/checkpoints.dat
--- a/src/blocks/stagenet_blocks.dat
+++ b/src/blocks/stagenet_blocks.dat
--- a/src/blocks/testnet_blocks.dat
+++ b/src/blocks/testnet_blocks.dat
--- a/src/checkpoints/checkpoints.cpp
+++ b/src/checkpoints/checkpoints.cpp
@ -197,56 +197,50 @@ namespace cryptonote
      ADD_CHECKPOINT2(550000,  "409f68cddd8e74b37469b41c1e61250d81c5776b42264f416d5d27c4626383ed", "0x5f3d4d03e");
      return true;
    }
-    ADD_CHECKPOINT2(1,     "771fbcd656ec1464d3a02ead5e18644030007a0fc664c0a964d30922821a8148", "0x2");
-    ADD_CHECKPOINT2(10,    "c0e3b387e47042f72d8ccdca88071ff96bff1ac7cde09ae113dbb7ad3fe92381", "0x2a974");
-    ADD_CHECKPOINT2(100,   "ac3e11ca545e57c49fca2b4e8c48c03c23be047c43e471e1394528b1f9f80b2d", "0x35d14b");
-    ADD_CHECKPOINT2(1000,  "5acfc45acffd2b2e7345caf42fa02308c5793f15ec33946e969e829f40b03876", "0x36a0373");
-    ADD_CHECKPOINT2(10000, "c758b7c81f928be3295d45e230646de8b852ec96a821eac3fea4daf3fcac0ca2", "0x60a91390");
-    ADD_CHECKPOINT2(22231, "7cb10e29d67e1c069e6e11b17d30b809724255fee2f6868dc14cfc6ed44dfb25", "0x1e288793d");
-    ADD_CHECKPOINT2(29556, "53c484a8ed91e4da621bb2fa88106dbde426fe90d7ef07b9c1e5127fb6f3a7f6", "0x71f64cce8");
-    ADD_CHECKPOINT2(50000, "0fe8758ab06a8b9cb35b7328fd4f757af530a5d37759f9d3e421023231f7b31c", "0x893044b400");
-    ADD_CHECKPOINT2(80000, "a62dcd7b536f22e003ebae8726e9e7276f63d594e264b6f0cd7aab27b66e75e3", "0x5cc113f1076");
-    ADD_CHECKPOINT2(202612, "bbd604d2ba11ba27935e006ed39c9bfdd99b76bf4a50654bc1e1e61217962698", "0x73310a259eb2");
-    ADD_CHECKPOINT2(202613, "e2aa337e78df1f98f462b3b1e560c6b914dec47b610698b7b7d1e3e86b6197c2", "0x733154039b97");
-    ADD_CHECKPOINT2(202614, "c29e3dc37d8da3e72e506e31a213a58771b24450144305bcba9e70fa4d6ea6fb", "0x73319dc90cb6");
-    ADD_CHECKPOINT2(205000, "5d3d7a26e6dc7535e34f03def711daa8c263785f73ec1fadef8a45880fde8063", "0x75fcc3d85123");
-    ADD_CHECKPOINT2(220000, "9613f455933c00e3e33ac315cc6b455ee8aa0c567163836858c2d9caff111553", "0x89cfed0cae3c");
-    ADD_CHECKPOINT2(230300, "bae7a80c46859db355556e3a9204a337ae8f24309926a1312323fdecf1920e61", "0x967d13e5baa9");
-    ADD_CHECKPOINT2(230700, "93e631240ceac831da1aebfc5dac8f722c430463024763ebafa888796ceaeedf", "0x96fb9663ebe7");
-    ADD_CHECKPOINT2(231350, "b5add137199b820e1ea26640e5c3e121fd85faa86a1e39cf7e6cc097bdeb1131", "0x97b9919177bf");
-    ADD_CHECKPOINT2(232150, "955de8e6b6508af2c24f7334f97beeea651d78e9ade3ab18fec3763be3201aa8", "0x98a038b612e8");
-    ADD_CHECKPOINT2(249380, "654fb0a81ce3e5caf7e3264a70f447d4bd07586c08fa50f6638cc54da0a52b2d", "0xac9739634e6d");
-    ADD_CHECKPOINT2(460000, "75037a7aed3e765db96c75bcf908f59d690a5f3390baebb9edeafd336a1c4831", "0x167799549bdda");
-    ADD_CHECKPOINT2(500000, "2428f0dbe49796be05ed81b347f53e1f7f44aed0abf641446ec2b94cae066b02", "0x188ce145e4ba9");
-    ADD_CHECKPOINT2(600000, "f5828ebf7d7d1cb61762c4dfe3ccf4ecab2e1aad23e8113668d981713b7a54c5", "0x1d9f3759e1554");
-    ADD_CHECKPOINT2(700000, "12be9b3d210b93f574d2526abb9c1ab2a881b479131fd0d4f7dac93875f503cd", "0x2201e4ee39c2c");
-    ADD_CHECKPOINT2(825000, "56503f9ad766774b575be3aff73245e9d159be88132c93d1754764f28da2ff60", "0x27565a442d5df");
-    ADD_CHECKPOINT2(900000, "d9958d0e7dcf91a5a7b11de225927bf7efc6eb26240315ce12372be902cc1337", "0x2a6334031546e");
-    ADD_CHECKPOINT2(913193, "5292d5d56f6ba4de33a58d9a34d263e2cb3c6fee0aed2286fd4ac7f36d53c85f", "0x2aefe7f40f5ea");
-    ADD_CHECKPOINT2(1000000, "a886ef5149902d8342475fee9bb296341b891ac67c4842f47a833f23c00ed721", "0x2edd71370f0e5");
-    ADD_CHECKPOINT2(1100000, "3fd720c5c8b3072fc1ccda922dec1ef25f9ed88a1e6ad4103d0fe00b180a5903", "0x390eb0035c53a");
-    ADD_CHECKPOINT2(1150000, "1dd16f626d18e1e988490dfd06de5920e22629c972c58b4d8daddea0038627b2", "0x422d5662e9e37");
-    ADD_CHECKPOINT2(1200000, "fa7d13a90850882060479d100141ff84286599ae39c3277c8ea784393f882d1f", "0x4c73503fc4aa3");
-    ADD_CHECKPOINT2(1300000, "31b34272343a44a9f4ac7de7a8fcf3b7d8a3124d7d6870affd510d2f37e74cd0", "0x723f49bc249d5");
-    ADD_CHECKPOINT2(1390000, "a8f5649dd4ded60eedab475f2bec8c934681c07e3cf640e9be0617554f13ff6c", "0xb4bba65e2841b");
-    ADD_CHECKPOINT2(1450000, "ac94e8860093bc7c83e4e91215cba1d663421ecf4067a0ae609c3a8b52bcfac2", "0x11a4aabdca9511");
-    ADD_CHECKPOINT2(1530000, "01759bce497ec38e63c78b1038892169203bb78f87e488172f6b854fcd63ba7e", "0x2819ce9f9e91e5");
-    ADD_CHECKPOINT2(1579000, "7d0d7a2346373afd41ed1e744a939fc5d474a7dbaa257be5c6fff4009e789241", "0x357a590e7dda83");
-    ADD_CHECKPOINT2(1668900, "ac2dcaf3d2f58ffcf8391639f0f1ebafcb8eac43c49479c7c37f611868d07568", "0x474226e475cc3b");
-    ADD_CHECKPOINT2(1775600, "1c6e01c661dc22cab939e79ec6a5272190624ce8356d2f7b958e4f9a57fdb05e", "0x5e3b9d206a27c6");
-    ADD_CHECKPOINT2(1856000, "9b57f17f29c71a3acd8a7904b93c41fa6eb8d2b7c73936ce4f1702d14880ba29", "0x6bde5e1caccee1");
-    ADD_CHECKPOINT2(1958000, "98a5d6e51afdf3146e0eefb10a66e8648d8d4d5c2742be8835e976ba217c9bb2", "0x79dd46d2a0971a");
-    ADD_CHECKPOINT2(2046000, "5e867f0b8baefed9244a681df97fc885d8ab36c3dfcd24c7a3abf3b8ac8b8314", "0x9cb8b6ff2978c6");
-    ADD_CHECKPOINT2(2092500, "c4e00820c9c7989b49153d5e90ae095a18a11d990e82fcc3be54e6ed785472b5", "0xb4e585a31369cb");
-    ADD_CHECKPOINT2(2182500, "0d22b5f81982eff21d094af9e821dc2007e6342069e3b1a37b15d97646353124", "0xead4a874083492");
-    ADD_CHECKPOINT2(2661600, "41c9060e8426012238e8a26da26fcb90797436896cc70886a894c2c560bcccf2", "0x2e0d87526ff161f");
-    ADD_CHECKPOINT2(2677000, "1b9fee6246eeb176bd17d637bf252e9af54a4218675f01b4449cc0901867f9eb", "0x2f165bc1a5163ba");
-    ADD_CHECKPOINT2(2706000, "d8eb144c5e1fe6b329ecc900ec95e7792fccff84175fb23a25ed59d7299a511c", "0x310f7d89372f705");
-    ADD_CHECKPOINT2(2720000, "b19fb41dff15bd1016afbee9f8469f05aab715c9e5d1b974466a11fd58ecbb86", "0x3216b5851ddbb61");
-    ADD_CHECKPOINT2(2817000, "39726d19ccaac01d150bec827b877ffae710b516bd633503662036ef4422e577", "0x3900669561954c1");
-    ADD_CHECKPOINT2(2844000, "28fc7b446dfef5b469f5778eb72ddf32a307a5f5a9823d1c394e772349e05d40", "0x3af384ec0e97d12");
-    ADD_CHECKPOINT2(2851000, "5bf0e47fc782263191a33f63a67db6c711781dc2a3c442e17ed901ec401be5c9", "0x3b6cd8a8ed610e8");
-    ADD_CHECKPOINT2(2971000, "3d4cac5ac515eeabd18769ab943af85f36db51d28720def0d0e6effc2c8f5ce3", "0x436e532738b8b5b");
+    ADD_CHECKPOINT2(1,       "97f4ce4d7879b3bea54dcec738cd2ebb7952b4e9bb9743262310cd5fec749340", "0x2");
+    ADD_CHECKPOINT2(6969,    "aa7b66e8c461065139b55c29538a39c33ceda93e587f84d490ed573d80511c87", "0x118eef693fd");  //Hard fork to v8
+    ADD_CHECKPOINT2(53666,   "3f43f56f66ef0c43cf2fd14d0d28fa2aae0ef8f40716773511345750770f1255", "0xb677d6405ae");  //Hard fork to v9
+    ADD_CHECKPOINT2(63469,   "4e33a9343fc5b86661ec0affaeb5b5a065290602c02d817337e4a979fe5747d8", "0xe7cd9819062");  //Hard fork to v10
+    ADD_CHECKPOINT2(81769,   "41db9fef8d0ccfa78b570ee9525d4f55de77b510c3ae4b08a1d51b9aec9ade1d", "0x150066455b88"); //Hard fork to v11
+    ADD_CHECKPOINT2(82069,   "fdea800d23d0b2eea19dec8af31e453e883e8315c97e25c8bb3e88ca164f8369", "0x15079b5fdaa8"); //Hard fork to v12
+    ADD_CHECKPOINT2(114969,  "b48245956b87f243048fd61021f4b3e5443e57eee7ff8ba4762d18926e80b80c", "0x1ca552b3ec68"); //Hard fork to v13
+    ADD_CHECKPOINT2(115257,  "338e056551087fe23d6c4b4280244bc5362b004716d85ec799a775f190f9fea9", "0x1cb25f5d4628"); //Hard fork to v14
+    ADD_CHECKPOINT2(160777,  "9496690579af21f38f00e67e11c2e85a15912fe4f412aad33d1162be1579e755", "0x5376eaa196a8"); //Hard fork to v15
+    ADD_CHECKPOINT2(253999,  "755a289fe8a68e96a0f69069ba4007b676ec87dce2e47dfb9647fe5691f49883", "0x172d026ef7fe8"); //Hard fork to v16
+    ADD_CHECKPOINT2(254287,  "b37cb55abe73965b424f8028bf71bef98d069645077ffa52f0c134907b7734e3", "0x1746622f56668"); //Hard fork to v17
+    ADD_CHECKPOINT2(256700,  "389a8ab95a80e84ec74639c1078bc67b33af208ef00f53bd9609cfc40efa7059", "0x185ace3c1bd68");
+    ADD_CHECKPOINT2(271600,  "9597cdbdc52ca57d7dbd8f9c0a23a73194ef2ebbcfdc75c21992672706108d43", "0x1e2d2d6a2a9e8");
+    ADD_CHECKPOINT2(278300,  "b10dcdf7a51651f60fbcc0447409773eef1458d2c706d9a61daf467571ac19c9", "0x20a83a16d3968");
+    ADD_CHECKPOINT2(282700,  "79c06cafd7cb5f76bcebbf8f1ae16203bb41fd75b284bcd0eb0b457991ab7d4a", "0x22e3baf142de8");
+    ADD_CHECKPOINT2(307686,  "dfd056b2739c132a07629409a59a028cb7414fac23e3419e79d2f49d66fc3af5", "0x305ba542e3ea8"); // "difficulty": 25800000
+    ADD_CHECKPOINT2(307692,  "d822cd72037f62824ec87c9dc11768b45dc2632f697fa372e1885789c90f37fc", "0x305e124633878"); // "difficulty": 1890000
+    ADD_CHECKPOINT2(307735,  "60970378aecdc0a78ccf5154edcc56f23aad8554b49e4716f820461a7588bfdc", "0x3070771b9ba58"); // "difficulty": 17900000
+    ADD_CHECKPOINT2(307742,  "0ed835bc9fcd949b5a184cf607dcc62ac4268c9e4cf220f8b09bcce58f10916b", "0x30732f1248978"); // "difficulty": 21300000
+    ADD_CHECKPOINT2(307750,  "7bcafbc757237125b70f569b181eb1b66c530b10d817d7b940f7a73dc827211c", "0x30766666b3d98"); // "difficulty": 10900000
+    ADD_CHECKPOINT2(307766,  "02fd6c7d6bae710cfa3efb08f50e4bc9a590f6ab61eabd87e5e951338c0c36f6", "0x307d2d47a7918"); // "difficulty": 2960000
+    ADD_CHECKPOINT2(307800,  "3594894b4231cfdfe911afed6552f9fb4cfe6048bacd0973a3a98623ec8548ce", "0x308b305ca7618");
+    ADD_CHECKPOINT2(307880,  "659274b698f680c6cae2716cbd4e15ad5def23b5de98e53734c4af2c2e74bb7a", "0x30af6e91e8018");
+    ADD_CHECKPOINT2(307883,  "9a8c35cd10963a14bba8a9628d1776df92fee5e3153b7249f5d15726efafaaea", "0x30b0965ba5a18");
+    ADD_CHECKPOINT2(312130,  "e0da085bd273fff9f5f8e604fce0e91908bc62b6b004731a93e16e89cb9b1f54", "0x3cfe7148f2e18");
+    ADD_CHECKPOINT2(324600,  "b24cd1ed7c192bbcf3d5b15729f2b032566687f96bda6f8cb73a5b16df4c6e6b", "0x69caecbe78718");
+    ADD_CHECKPOINT2(327700,  "f113c8cbe077aab9296ecbfb41780c147aeb54edfece7e4b9946b8abd0f06de7", "0x732431429c818");
+    ADD_CHECKPOINT2(331170,  "05243fba853fe375c671a6783eecac28777bca51f5977d5285c235424e52bb69", "0x7c3469310d218"); //Hard fork to v18
+    ADD_CHECKPOINT2(331458,  "f79a664a5e4bc11fa7d804be2c3c72db50c87a27f1f540f337564cbb6314e4cd", "0x7c34d47adf218"); //Hard fork to v19
+    ADD_CHECKPOINT2(331891,  "faceea4b4ab33fc962c24dfa2f98c2aeda4788f67c1e0044c62419912c1a64fe", "0x7c359086aeb58"); // restart DIFFICULTY_WINDOW
+    ADD_CHECKPOINT2(332100,  "d32c409058c1eceb9a105190c7a5f480b2d6f49f318b18652b49ae971c710124", "0x7c538441cca36");
+    ADD_CHECKPOINT2(334000,  "17d3b15f8e1a73e1c61335ee7979e9e3d211b9055e8a7fb2481e5f49a51b1c22", "0x7ddd5a79d69c4");
+    ADD_CHECKPOINT2(348500,  "2d43a157f369e2aa26a329b56456142ecd1361f5808c688d97112a2e3bbd23f4", "0x90889ed877ada");
+    ADD_CHECKPOINT2(489400,  "b14f49eae77398117ea93435676100d8b655a804689f73a5a4d0d5e71160d603", "0x1123c39bb52f7e");
+    ADD_CHECKPOINT2(491200,  "cedba73ad35ce7f51aaca2beb36dc32d79ecc716d146eb8211e6a815f3666c4a", "0x11334734abbd17");
+    ADD_CHECKPOINT2(497100,  "2c4c70ac1ada94151f19d67ccf1aa4e846e6067f49f67c85cc03f78e768ea42b", "0x116906bc97a751");
+    ADD_CHECKPOINT2(500000,  "f4f771261b8c13cd83a9d8fa22e3cfe988564ad4b57dd90e79d5c0e77d61cf6a", "0x1185e7f2357a03");
+    ADD_CHECKPOINT2(503500,  "776f36a17056c3e22bbfb51d5aeabb58000731e9ad549f0f2f8ad1e1bcedf312", "0x11a4884467f53d");
+    ADD_CHECKPOINT2(509900,  "59520faa272fc68e0426c827a38b21cdc1df8f5a37c5fdcbbe00350fece5f3ae", "0x11dc780bd1b580");
+    ADD_CHECKPOINT2(514000,  "1569e712750f19e57aee3f73cc3091a0eea392740bd396ad3570bc96e0e6ffb5", "0x11fff58abe0a82"); //Hard fork to v20
+    ADD_CHECKPOINT2(516700,  "0443c47c5a4e344c3f68a491a3b2f6b78a769cdf9076249c93f187ececf9cc7c", "0x12128a532a59a6");
+    ADD_CHECKPOINT2(522000,  "8c15ae514063bf05e7662ab33b86a4131aa89df0784ce3da7876c5339bc1de3d", "0x123d9c604a7be6");
+    ADD_CHECKPOINT2(566000,  "136e37f5f130dd2dc2d8d30e46e16d74377cb834b7c5be32cd09ee6ad402556c", "0x1318d703b1bff7");
+    ADD_CHECKPOINT2(611300,  "34fd2ff914ad34edc2dabb0fe38f15b2ac6a301dc501bdfec15d2108b304a455", "0x13b61f061add9d");
    return true;
  }

@ -291,22 +285,13 @@ namespace cryptonote
    std::vector<std::string> records;

    // All four MoneroPulse domains have DNSSEC on and valid
-    static const std::vector<std::string> dns_urls = { "checkpoints.moneropulse.se"
-						     , "checkpoints.moneropulse.org"
-						     , "checkpoints.moneropulse.net"
-						     , "checkpoints.moneropulse.co"
+    static const std::vector<std::string> dns_urls = {
    };

-    static const std::vector<std::string> testnet_dns_urls = { "testpoints.moneropulse.se"
-							     , "testpoints.moneropulse.org"
-							     , "testpoints.moneropulse.net"
-							     , "testpoints.moneropulse.co"
+    static const std::vector<std::string> testnet_dns_urls = {
    };

-    static const std::vector<std::string> stagenet_dns_urls = { "stagenetpoints.moneropulse.se"
-                   , "stagenetpoints.moneropulse.org"
-                   , "stagenetpoints.moneropulse.net"
-                   , "stagenetpoints.moneropulse.co"
+    static const std::vector<std::string> stagenet_dns_urls = {
    };

    if (!tools::dns_utils::load_txt_records_from_dns(records, nettype == TESTNET ? testnet_dns_urls : nettype == STAGENET ? stagenet_dns_urls : dns_urls))
--- a/src/common/dns_utils.cpp
+++ b/src/common/dns_utils.cpp
@ -295,7 +295,7 @@ DNSResolver::DNSResolver() : m_data(new DNSResolverData())
    // should be a valid DNSSEC record, and switch to known good
    // DNSSEC resolvers if verification fails
    bool available, valid;
-    static const char *probe_hostname = "updates.moneropulse.org";
+    static const char *probe_hostname = "";
    auto records = get_txt_record(probe_hostname, available, valid);
    if (!valid)
    {
@ -419,7 +419,7 @@ namespace dns_utils
 std::string address_from_txt_record(const std::string& s)
 {
  // make sure the txt record has "oa1:xmr" and find it
-  auto pos = s.find("oa1:xmr");
+  auto pos = s.find("oa1:wow");
  if (pos == std::string::npos)
    return {};
  // search from there to find "recipient_address="
@ -432,13 +432,13 @@ std::string address_from_txt_record(const std::string& s)
  if (pos2 != std::string::npos)
  {
    // length of address == 95, we can at least validate that much here
-    if (pos2 - pos == 95)
+    if (pos2 - pos == 97)
    {
-      return s.substr(pos, 95);
+      return s.substr(pos, 97);
    }
-    else if (pos2 - pos == 106) // length of address == 106 --> integrated address
+    else if (pos2 - pos == 108) // length of address == 106 --> integrated address
    {
-      return s.substr(pos, 106);
+      return s.substr(pos, 108);
    }
  }
  return {};
@ -554,7 +554,7 @@ bool load_txt_records_from_dns(std::vector<std::string> &good_records, const std

  if (num_valid_records < 2)
  {
-    LOG_PRINT_L0("WARNING: no two valid DNS TXT records were received");
+    LOG_PRINT_L2("WARNING: no two valid DNS TXT records were received");
    return false;
  }

--- a/src/common/updates.cpp
+++ b/src/common/updates.cpp
@ -46,13 +46,6 @@ namespace tools

    // All four MoneroPulse domains have DNSSEC on and valid
    static const std::vector<std::string> dns_urls = {
-        "updates.moneropulse.org",
-        "updates.moneropulse.net",
-        "updates.moneropulse.fr",
-        "updates.moneropulse.de",
-        "updates.moneropulse.no",
-        "updates.moneropulse.ch",
-        "updates.moneropulse.se"
    };

    if (!tools::dns_utils::load_txt_records_from_dns(records, dns_urls))
@ -102,11 +95,11 @@ namespace tools

  std::string get_update_url(const std::string &software, const std::string &subdir, const std::string &buildtag, const std::string &version, bool user)
  {
-    const char *base = user ? "https://downloads.getmonero.org/" : "https://updates.getmonero.org/";
+    const char *base = user ? "" : "";
 #ifdef _WIN32
    static const char *extension = strncmp(buildtag.c_str(), "source", 6) ? (strncmp(buildtag.c_str(), "install-", 8) ? ".zip" : ".exe") : ".tar.bz2";
 #elif defined(__APPLE__)
-    static const char *extension = strncmp(software.c_str(), "monero-gui", 10) ? ".tar.bz2" : ".dmg";
+    static const char *extension = strncmp(software.c_str(), "wownero-gui", 10) ? ".tar.bz2" : ".dmg";
 #else
    static const char extension[] = ".tar.bz2";
 #endif
--- a/src/common/util.cpp
+++ b/src/common/util.cpp
@ -676,7 +676,7 @@ std::string get_nix_version_display_string()
  {
    ub_ctx *ctx = ub_ctx_create();
    if (!ctx) return false; // cheat a bit, should not happen unless OOM
-    char *monero = strdup("monero"), *unbound = strdup("unbound");
+    char *monero = strdup("wownero"), *unbound = strdup("unbound");
    ub_ctx_zone_add(ctx, monero, unbound); // this calls ub_ctx_finalize first, then errors out with UB_SYNTAX
    free(unbound);
    free(monero);
--- a/src/crypto/hash-ops.h
+++ b/src/crypto/hash-ops.h
@ -92,7 +92,7 @@ bool tree_branch(const char (*hashes)[HASH_SIZE], size_t count, const char *hash
 bool tree_branch_hash(const char hash[HASH_SIZE], const char (*branch)[HASH_SIZE], size_t depth, uint32_t path, char root[HASH_SIZE]);
 bool is_branch_in_tree(const char hash[HASH_SIZE], const char root[HASH_SIZE], const char (*branch)[HASH_SIZE], size_t depth, uint32_t path);

-#define RX_BLOCK_VERSION	12
+#define RX_BLOCK_VERSION	13
 void rx_slow_hash_allocate_state(void);
 void rx_slow_hash_free_state(void);
 uint64_t rx_seedheight(const uint64_t height);
--- a/src/crypto/jh.c
+++ b/src/crypto/jh.c
@ -34,7 +34,7 @@ typedef struct {
 	unsigned long long databitlen;    /*the message size in bits*/
 	unsigned long long datasize_in_buffer;      /*the size of the message remained in buffer; assumed to be multiple of 8bits except for the last partial block at the end of the message*/
 	DATA_ALIGN16(uint64 x[8][2]);     /*the 1024-bit state, ( x[i][0] || x[i][1] ) is the ith row of the state in the pseudocode*/
-	unsigned char buffer[64];         /*the 512-bit message block to be hashed;*/
+	DATA_ALIGN16(unsigned char buffer[64]);         /*the 512-bit message block to be hashed;*/
 } hashState;


@ -213,16 +213,24 @@ static void E8(hashState *state)
 /*The compression function F8 */
 static void F8(hashState *state)
 {
-      uint64  i;
+      uint64_t* x = (uint64_t*)state->x;

      /*xor the 512-bit message with the fist half of the 1024-bit hash state*/
-      for (i = 0; i < 8; i++)  state->x[i >> 1][i & 1] ^= ((uint64*)state->buffer)[i];
+      for (int i = 0; i < 8; ++i) {
+            uint64 b;
+            memcpy(&b, &state->buffer[i << 3], sizeof(b));
+            x[i] ^= b;
+      }

      /*the bijective function E8 */
      E8(state);

      /*xor the 512-bit message with the second half of the 1024-bit hash state*/
-      for (i = 0; i < 8; i++)  state->x[(8+i) >> 1][(8+i) & 1] ^= ((uint64*)state->buffer)[i];
+      for (int i = 0; i < 8; ++i) {
+            uint64 b;
+            memcpy(&b, &state->buffer[i << 3], sizeof(b));
+            x[i + 8] ^= b;
+      }
 }

 /*before hashing a message, initialize the hash state as H0 */
@ -240,6 +248,7 @@ static HashReturn Init(hashState *state, int hashbitlen)
            case 224: memcpy(state->x,JH224_H0,128); break;
            case 256: memcpy(state->x,JH256_H0,128); break;
            case 384: memcpy(state->x,JH384_H0,128); break;
+            default:
            case 512: memcpy(state->x,JH512_H0,128); break;
      }

--- a/src/crypto/variant4_random_math.h
+++ b/src/crypto/variant4_random_math.h
@ -200,7 +200,6 @@ static inline int v4_random_math_init(struct V4_Instruction* code, const uint64_
 	memset(data, 0, sizeof(data));
 	uint64_t tmp = SWAP64LE(height);
 	memcpy(data, &tmp, sizeof(uint64_t));
-	data[20] = -38; // change seed

 	// Set data_index past the last byte in data
 	// to trigger full data update with blake hash
@ -211,10 +210,9 @@ static inline int v4_random_math_init(struct V4_Instruction* code, const uint64_

 	// There is a small chance (1.8%) that register R8 won't be used in the generated program
 	// So we keep track of it and try again if it's not used
-	bool r8_used;
 	do {
-		int latency[9];
-		int asic_latency[9];
+		int latency[8];
+		int asic_latency[8];

 		// Tracks previous instruction and value of the source operand for registers R0-R3 throughout code execution
 		// byte 0: current value of the destination register
@ -223,7 +221,7 @@ static inline int v4_random_math_init(struct V4_Instruction* code, const uint64_
 		//
 		// Registers R4-R8 are constant and are treated as having the same value because when we do
 		// the same operation twice with two constant source registers, it can be optimized into a single operation
-		uint32_t inst_data[9] = { 0, 1, 2, 3, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF };
+		uint32_t inst_data[8] = { 0, 1, 2, 3, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF };

 		bool alu_busy[TOTAL_LATENCY + 1][ALU_COUNT];
 		bool is_rotation[V4_INSTRUCTION_COUNT];
@ -242,7 +240,6 @@ static inline int v4_random_math_init(struct V4_Instruction* code, const uint64_
 		code_size = 0;

 		int total_iterations = 0;
-		r8_used = false;

 		// Generate random code to achieve minimal required latency for our abstract CPU
 		// Try to get this latency for all 4 registers
@ -287,8 +284,8 @@ static inline int v4_random_math_init(struct V4_Instruction* code, const uint64_
 			if (((opcode == ADD) || (opcode == SUB) || (opcode == XOR)) && (a == b))
 			{
 				// Use register R8 as source instead
-				b = 8;
-				src_index = 8;
+				b = a + 4;
+				src_index = b;
 			}

 			// Don't do rotation with the same destination twice because it's equal to a single rotation
@ -368,10 +365,6 @@ static inline int v4_random_math_init(struct V4_Instruction* code, const uint64_
 				code[code_size].src_index = src_index;
 				code[code_size].C = 0;

-				if (src_index == 8)
-				{
-					r8_used = true;
-				}

 				if (opcode == ADD)
 				{
@ -402,7 +395,7 @@ static inline int v4_random_math_init(struct V4_Instruction* code, const uint64_
 		// We need to add a few more MUL and ROR instructions to achieve minimal required latency for ASIC
 		// Get this latency for at least 1 of the 4 registers
 		const int prev_code_size = code_size;
-		while ((code_size < NUM_INSTRUCTIONS_MAX) && (asic_latency[0] < TOTAL_LATENCY) && (asic_latency[1] < TOTAL_LATENCY) && (asic_latency[2] < TOTAL_LATENCY) && (asic_latency[3] < TOTAL_LATENCY))
+		while ((asic_latency[0] < TOTAL_LATENCY) && (asic_latency[1] < TOTAL_LATENCY) && (asic_latency[2] < TOTAL_LATENCY) && (asic_latency[3] < TOTAL_LATENCY))
 		{
 			int min_idx = 0;
 			int max_idx = 0;
@ -426,7 +419,7 @@ static inline int v4_random_math_init(struct V4_Instruction* code, const uint64_

 	// There is ~98.15% chance that loop condition is false, so this loop will execute only 1 iteration most of the time
 	// It never does more than 4 iterations for all block heights < 10,000,000
-	}  while (!r8_used || (code_size < NUM_INSTRUCTIONS_MIN) || (code_size > NUM_INSTRUCTIONS_MAX));
+	}  while (code_size < NUM_INSTRUCTIONS_MIN);

 	// It's guaranteed that NUM_INSTRUCTIONS_MIN <= code_size <= NUM_INSTRUCTIONS_MAX here
 	// Add final instruction to stop the interpreter
--- a/src/cryptonote_basic/cryptonote_basic.h
+++ b/src/cryptonote_basic/cryptonote_basic.h
@ -461,6 +461,8 @@ namespace cryptonote
    uint64_t timestamp;
    crypto::hash  prev_id;
    uint32_t nonce;
+    crypto::signature signature;
+    uint16_t vote;

    BEGIN_SERIALIZE()
      VARINT_FIELD(major_version)
@ -468,6 +470,11 @@ namespace cryptonote
      VARINT_FIELD(timestamp)
      FIELD(prev_id)
      FIELD(nonce)
+      if (major_version >= HF_VERSION_BLOCK_HEADER_MINER_SIG)
+      {
+          FIELD(signature)
+          FIELD(vote)
+      }
    END_SERIALIZE()
  };

--- a/src/cryptonote_basic/cryptonote_boost_serialization.h
+++ b/src/cryptonote_basic/cryptonote_boost_serialization.h
@ -196,6 +196,11 @@ namespace boost
    a & b.timestamp;
    a & b.prev_id;
    a & b.nonce;
+    if (b.major_version >= HF_VERSION_BLOCK_HEADER_MINER_SIG)
+    {
+      a & b.signature;
+      a & b.vote;
+    }
    //------------------
    a & b.miner_tx;
    a & b.tx_hashes;
@ -330,7 +335,7 @@ namespace boost
    a & x.type;
    if (x.type == rct::RCTTypeNull)
      return;
-    if (x.type != rct::RCTTypeFull && x.type != rct::RCTTypeSimple && x.type != rct::RCTTypeBulletproof && x.type != rct::RCTTypeBulletproof2 && x.type != rct::RCTTypeCLSAG && x.type != rct::RCTTypeBulletproofPlus)
+    if (x.type != rct::RCTTypeFull && x.type != rct::RCTTypeSimple && x.type != rct::RCTTypeBulletproof && x.type != rct::RCTTypeBulletproof2 && x.type != rct::RCTTypeFullBulletproof && x.type != rct::RCTTypeSimpleBulletproof && x.type != rct::RCTTypeCLSAG && x.type != rct::RCTTypeBulletproofPlus)
      throw boost::archive::archive_exception(boost::archive::archive_exception::other_exception, "Unsupported rct type");
    // a & x.message; message is not serialized, as it can be reconstructed from the tx data
    // a & x.mixRing; mixRing is not serialized, as it can be reconstructed from the offsets
@ -364,7 +369,7 @@ namespace boost
    a & x.type;
    if (x.type == rct::RCTTypeNull)
      return;
-    if (x.type != rct::RCTTypeFull && x.type != rct::RCTTypeSimple && x.type != rct::RCTTypeBulletproof && x.type != rct::RCTTypeBulletproof2 && x.type != rct::RCTTypeCLSAG && x.type != rct::RCTTypeBulletproofPlus)
+    if (x.type != rct::RCTTypeFull && x.type != rct::RCTTypeSimple && x.type != rct::RCTTypeBulletproof && x.type != rct::RCTTypeBulletproof2 && x.type != rct::RCTTypeFullBulletproof && x.type != rct::RCTTypeSimpleBulletproof && x.type != rct::RCTTypeCLSAG && x.type != rct::RCTTypeBulletproofPlus)
      throw boost::archive::archive_exception(boost::archive::archive_exception::other_exception, "Unsupported rct type");
    // a & x.message; message is not serialized, as it can be reconstructed from the tx data
    // a & x.mixRing; mixRing is not serialized, as it can be reconstructed from the offsets
@ -384,7 +389,7 @@ namespace boost
    a & x.p.MGs;
    if (ver >= 1u)
      a & x.p.CLSAGs;
-    if (x.type == rct::RCTTypeBulletproof || x.type == rct::RCTTypeBulletproof2 || x.type == rct::RCTTypeCLSAG || x.type == rct::RCTTypeBulletproofPlus)
+    if (x.type == rct::RCTTypeBulletproof || x.type == rct::RCTTypeBulletproof2 || x.type == rct::RCTTypeSimpleBulletproof || x.type == rct::RCTTypeCLSAG || x.type == rct::RCTTypeBulletproofPlus)
      a & x.p.pseudoOuts;
  }

--- a/src/cryptonote_basic/cryptonote_format_utils.cpp
+++ b/src/cryptonote_basic/cryptonote_format_utils.cpp
@ -190,9 +190,9 @@ namespace cryptonote
          CHECK_AND_ASSERT_MES(n_amounts == rv.outPk.size(), false, "Internal error filling out V");
          rv.p.bulletproofs_plus[0].V.resize(n_amounts);
          for (size_t i = 0; i < n_amounts; ++i)
-            rv.p.bulletproofs_plus[0].V[i] = rct::scalarmultKey(rv.outPk[i].mask, rct::INV_EIGHT);
+            rv.p.bulletproofs_plus[0].V[i] = rv.outPk[i].mask;
        }
-        else if (bulletproof)
+        if (rct::is_rct_new_bulletproof(rv.type))
        {
          if (rv.p.bulletproofs.size() != 1)
          {
@ -205,7 +205,7 @@ namespace cryptonote
            return false;
          }
          const size_t max_outputs = 1 << (rv.p.bulletproofs[0].L.size() - 6);
-          if (max_outputs < tx.vout.size())
+          if (max_outputs < tx.vout.size() && rv.type == rct::RCTTypeBulletproof)
          {
            LOG_PRINT_L1("Failed to parse transaction from blob, bad bulletproofs max outputs in tx " << get_transaction_hash(tx));
            return false;
@ -216,6 +216,26 @@ namespace cryptonote
          for (size_t i = 0; i < n_amounts; ++i)
            rv.p.bulletproofs[0].V[i] = rct::scalarmultKey(rv.outPk[i].mask, rct::INV_EIGHT);
        }
+        else if (bulletproof)
+        {
+          if (rct::n_bulletproof_v1_amounts(rv.p.bulletproofs) != tx.vout.size())
+          {
+            LOG_PRINT_L1("Failed to parse transaction from blob, bad bulletproofs size in tx " << get_transaction_hash(tx));
+            return false;
+          }
+          size_t idx = 0;
+          for (size_t n = 0; n < rv.outPk.size(); ++n)
+          {
+            //rv.p.bulletproofs[n].V.resize(1);
+            //rv.p.bulletproofs[n].V[0] = rv.outPk[n].mask;
+            CHECK_AND_ASSERT_MES(rv.p.bulletproofs[n].L.size() >= 6, false, "Bad bulletproofs L size"); // at least 64 bits
+            const size_t n_amounts = rct::n_bulletproof_v1_amounts(rv.p.bulletproofs[n]);
+            CHECK_AND_ASSERT_MES(idx + n_amounts <= rv.outPk.size(), false, "Internal error filling out V");
+            rv.p.bulletproofs[n].V.resize(n_amounts);
+            for (size_t i = 0; i < n_amounts; ++i)
+              rv.p.bulletproofs[n].V[i] = rv.outPk[idx++].mask;
+          }
+        }
      }
    }
    return true;
@ -451,6 +471,11 @@ namespace cryptonote
    const bool bulletproof_plus = rct::is_rct_bulletproof_plus(rv.type);
    if (!bulletproof && !bulletproof_plus)
      return blob_size;
+    const size_t n_outputs = tx.vout.size();
+    if (n_outputs <= 2)
+      return blob_size;
+    if (rct::is_rct_old_bulletproof(rv.type))
+      return blob_size;
    const size_t n_padded_outputs = bulletproof_plus ? rct::n_bulletproof_plus_max_amounts(rv.p.bulletproofs_plus) : rct::n_bulletproof_max_amounts(rv.p.bulletproofs);
    uint64_t bp_clawback = get_transaction_weight_clawback(tx, n_padded_outputs);
    CHECK_AND_ASSERT_THROW_MES_L1(bp_clawback <= std::numeric_limits<uint64_t>::max() - blob_size, "Weight overflow");
@ -1113,10 +1138,10 @@ namespace cryptonote
  {
    switch (decimal_point)
    {
-      case 12:
-      case 9:
-      case 6:
-      case 3:
+      case 11:
+      case 8:
+      case 5:
+      case 2:
      case 0:
        default_decimal_point = decimal_point;
        break;
@ -1136,16 +1161,16 @@ namespace cryptonote
      decimal_point = default_decimal_point;
    switch (decimal_point)
    {
-      case 12:
-        return "monero";
-      case 9:
-        return "millinero";
-      case 6:
-        return "micronero";
-      case 3:
-        return "nanonero";
+      case 11:
+        return "wownero";
+      case 8:
+        return "verywow";
+      case 5:
+        return "muchwow";
+      case 2:
+        return "suchwow";
      case 0:
-        return "piconero";
+        return "dust";
      default:
        ASSERT_MES_AND_THROW("Invalid decimal point specification: " << decimal_point);
    }
@ -1461,33 +1486,6 @@ namespace cryptonote
    if (!hash_result)
      return false;

-    if (b.miner_tx.vin.size() == 1 && b.miner_tx.vin[0].type() == typeid(cryptonote::txin_gen))
-    {
-      const cryptonote::txin_gen &txin_gen = boost::get<cryptonote::txin_gen>(b.miner_tx.vin[0]);
-      if (txin_gen.height != 202612)
-        return true;
-    }
-
-    // EXCEPTION FOR BLOCK 202612
-    const std::string correct_blob_hash_202612 = "3a8a2b3a29b50fc86ff73dd087ea43c6f0d6b8f936c849194d5c84c737903966";
-    const std::string existing_block_id_202612 = "bbd604d2ba11ba27935e006ed39c9bfdd99b76bf4a50654bc1e1e61217962698";
-    crypto::hash block_blob_hash = get_blob_hash(*blob);
-
-    if (string_tools::pod_to_hex(block_blob_hash) == correct_blob_hash_202612)
-    {
-      string_tools::hex_to_pod(existing_block_id_202612, res);
-      return true;
-    }
-
-    {
-      // make sure that we aren't looking at a block with the 202612 block id but not the correct blobdata
-      if (string_tools::pod_to_hex(res) == existing_block_id_202612)
-      {
-        LOG_ERROR("Block with block id for 202612 but incorrect block blob hash found!");
-        res = null_hash;
-        return false;
-      }
-    }
    return hash_result;
  }
  //---------------------------------------------------------------
@ -1517,6 +1515,25 @@ namespace cryptonote
    return p;
  }
  //---------------------------------------------------------------
+  crypto::hash get_sig_data(const block& b)
+  {
+    crypto::hash sig_data;
+    blobdata blob = get_block_hashing_blob_sig_data(b);
+    crypto::cn_fast_hash(blob.data(), blob.size(), sig_data);
+    return sig_data;
+  }
+  //---------------------------------------------------------------
+  blobdata get_block_hashing_blob_sig_data(const block& b)
+  {
+    block_header tmp = static_cast<const block_header&>(b);
+    memset(&tmp.signature, 0, sizeof(tmp.signature));
+    blobdata blob = t_serializable_object_to_blob(tmp);
+    crypto::hash tree_root_hash = get_tx_tree_hash(b);
+    blob.append(reinterpret_cast<const char*>(&tree_root_hash), sizeof(tree_root_hash));
+    blob.append(tools::get_varint_data(b.tx_hashes.size()+1));
+    return blob;
+  }
+  //---------------------------------------------------------------
  std::vector<uint64_t> relative_output_offsets_to_absolute(const std::vector<uint64_t>& off)
  {
    std::vector<uint64_t> res = off;
--- a/src/cryptonote_basic/cryptonote_format_utils.h
+++ b/src/cryptonote_basic/cryptonote_format_utils.h
@ -124,6 +124,8 @@ namespace cryptonote
  bool calculate_block_hash(const block& b, crypto::hash& res, const blobdata_ref *blob = NULL);
  bool get_block_hash(const block& b, crypto::hash& res);
  crypto::hash get_block_hash(const block& b);
+  crypto::hash get_sig_data(const block& b);
+  blobdata get_block_hashing_blob_sig_data(const block& b);
  bool parse_and_validate_block_from_blob(const blobdata_ref& b_blob, block& b, crypto::hash *block_hash);
  bool parse_and_validate_block_from_blob(const blobdata_ref& b_blob, block& b);
  bool parse_and_validate_block_from_blob(const blobdata_ref& b_blob, block& b, crypto::hash &block_hash);
--- a/src/cryptonote_basic/difficulty.cpp
+++ b/src/cryptonote_basic/difficulty.cpp
@ -33,6 +33,7 @@
 #include <cstddef>
 #include <cstdint>
 #include <vector>
+#include <boost/math/special_functions/round.hpp>

 #include "int-util.h"
 #include "crypto/hash.h"
@ -121,10 +122,10 @@ namespace cryptonote {

  uint64_t next_difficulty_64(std::vector<std::uint64_t> timestamps, std::vector<uint64_t> cumulative_difficulties, size_t target_seconds) {

-    if(timestamps.size() > DIFFICULTY_WINDOW)
+    if(timestamps.size() > DIFFICULTY_WINDOW_V3)
    {
-      timestamps.resize(DIFFICULTY_WINDOW);
-      cumulative_difficulties.resize(DIFFICULTY_WINDOW);
+      timestamps.resize(DIFFICULTY_WINDOW_V3);
+      cumulative_difficulties.resize(DIFFICULTY_WINDOW_V3);
    }


@ -133,17 +134,17 @@ namespace cryptonote {
    if (length <= 1) {
      return 1;
    }
-    static_assert(DIFFICULTY_WINDOW >= 2, "Window is too small");
-    assert(length <= DIFFICULTY_WINDOW);
+    static_assert(DIFFICULTY_WINDOW_V3 >= 2, "Window is too small");
+    assert(length <= DIFFICULTY_WINDOW_V3);
    sort(timestamps.begin(), timestamps.end());
    size_t cut_begin, cut_end;
-    static_assert(2 * DIFFICULTY_CUT <= DIFFICULTY_WINDOW - 2, "Cut length is too large");
-    if (length <= DIFFICULTY_WINDOW - 2 * DIFFICULTY_CUT) {
+    static_assert(2 * DIFFICULTY_CUT_V2 <= DIFFICULTY_WINDOW_V3 - 2, "Cut length is too large");
+    if (length <= DIFFICULTY_WINDOW_V3 - 2 * DIFFICULTY_CUT_V2) {
      cut_begin = 0;
      cut_end = length;
    } else {
-      cut_begin = (length - (DIFFICULTY_WINDOW - 2 * DIFFICULTY_CUT) + 1) / 2;
-      cut_end = cut_begin + (DIFFICULTY_WINDOW - 2 * DIFFICULTY_CUT);
+      cut_begin = (length - (DIFFICULTY_WINDOW_V3 - 2 * DIFFICULTY_CUT_V2) + 1) / 2;
+      cut_end = cut_begin + (DIFFICULTY_WINDOW_V3 - 2 * DIFFICULTY_CUT_V2);
    }
    assert(/*cut_begin >= 0 &&*/ cut_begin + 2 <= cut_end && cut_end <= length);
    uint64_t time_span = timestamps[cut_end - 1] - timestamps[cut_begin];
@ -200,7 +201,7 @@ namespace cryptonote {
      return check_hash_128(hash, difficulty);
  }

-  difficulty_type next_difficulty(std::vector<uint64_t> timestamps, std::vector<difficulty_type> cumulative_difficulties, size_t target_seconds) {
+  difficulty_type next_difficulty(std::vector<uint64_t> timestamps, std::vector<difficulty_type> cumulative_difficulties, size_t target_seconds, uint64_t HEIGHT) {
    //cutoff DIFFICULTY_LAG
    if(timestamps.size() > DIFFICULTY_WINDOW)
    {
@ -214,6 +215,8 @@ namespace cryptonote {
    if (length <= 1) {
      return 1;
    }
+    // reset difficulty for solo mining to 100 million
+    if (HEIGHT <= 331170 + DIFFICULTY_WINDOW && HEIGHT >= 331170) { return 100000000; }
    static_assert(DIFFICULTY_WINDOW >= 2, "Window is too small");
    assert(length <= DIFFICULTY_WINDOW);
    sort(timestamps.begin(), timestamps.end());
@ -254,4 +257,193 @@ namespace cryptonote {
    return "0x" + s;
  }

+  // LWMA difficulty algorithm
+  // Background:  https://github.com/zawy12/difficulty-algorithms/issues/3
+  // Copyright (c) 2017-2018 Zawy
+  difficulty_type next_difficulty_v2(std::vector<uint64_t> timestamps, std::vector<difficulty_type> cumulative_difficulties, size_t target_seconds, uint64_t HEIGHT) {
+    const int64_t T = static_cast<int64_t>(target_seconds);
+    size_t N = DIFFICULTY_WINDOW_V2;
+    if (timestamps.size() < 4) {
+        return 1;
+    } else if ( timestamps.size() < N+1 ) {
+        N = timestamps.size() - 1;
+    } else {
+        timestamps.resize(N+1);
+        cumulative_difficulties.resize(N+1);
+    }
+    const double adjust = 0.998;
+    const double k = N * (N + 1) / 2;
+    double LWMA(0), sum_inverse_D(0), harmonic_mean_D(0), nextDifficulty(0);
+    int64_t solveTime(0);
+    uint64_t difficulty(0), next_difficulty(0);
+    for (size_t i = 1; i <= N; i++) {
+      solveTime = static_cast<int64_t>(timestamps[i]) - static_cast<int64_t>(timestamps[i - 1]);
+      solveTime = std::min<int64_t>((T * 7), std::max<int64_t>(solveTime, (-7 * T)));
+      difficulty = static_cast<uint64_t>(cumulative_difficulties[i] - cumulative_difficulties[i - 1]);
+      LWMA += (int64_t)(solveTime * i) / k;
+      sum_inverse_D += 1 / static_cast<double>(difficulty);
+    }
+    harmonic_mean_D = N / sum_inverse_D;
+    if (static_cast<int64_t>(boost::math::round(LWMA)) < T / 20)
+      LWMA = static_cast<double>(T / 20);
+
+    nextDifficulty = harmonic_mean_D * T / LWMA * adjust;
+    next_difficulty = static_cast<uint64_t>(nextDifficulty);
+    return next_difficulty;
+  }
+
+  // LWMA-2
+  difficulty_type next_difficulty_v3(std::vector<uint64_t> timestamps, std::vector<difficulty_type> cumulative_difficulties, uint64_t HEIGHT) {
+    int64_t T = DIFFICULTY_TARGET_V2;
+    int64_t N = DIFFICULTY_WINDOW_V2;
+    int64_t  L(0), ST, sum_3_ST(0), next_D, prev_D;
+    assert(timestamps.size() == cumulative_difficulties.size() && timestamps.size() <= static_cast<uint64_t>(N+1) );
+    for ( int64_t i = 1; i <= N; i++ ) {
+      ST = static_cast<int64_t>(timestamps[i]) - static_cast<int64_t>(timestamps[i-1]);
+      ST = std::max(-4*T, std::min(ST, 6*T));
+      L +=  ST * i ;
+      if ( i > N-3 ) {
+        sum_3_ST += ST;
+      }
+    }
+    next_D = (static_cast<int64_t>(cumulative_difficulties[N] - cumulative_difficulties[0])*T*(N+1)*99)/(100*2*L);
+    prev_D = static_cast<int64_t>(cumulative_difficulties[N] - cumulative_difficulties[N-1]);
+    next_D = std::max((prev_D*67)/100, std::min(next_D, (prev_D*150)/100));
+    if ( sum_3_ST < (8*T)/10) {
+      next_D = std::max(next_D,(prev_D*108)/100);
+    }
+    return static_cast<uint64_t>(next_D);
+  }
+
+  // LWMA-4
+  difficulty_type next_difficulty_v4(std::vector<uint64_t> timestamps, std::vector<difficulty_type> cumulative_difficulties, uint64_t HEIGHT) {
+    uint64_t T = DIFFICULTY_TARGET_V2;
+    uint64_t N = DIFFICULTY_WINDOW_V2;
+    uint64_t L(0), ST(0), next_D, prev_D, avg_D, i;
+    assert(timestamps.size() == cumulative_difficulties.size() && timestamps.size() <= N+1 );
+    if (HEIGHT <= 63469 + 1) { return 100000069; }
+    std::vector<uint64_t>TS(N+1);
+    TS[0] = timestamps[0];
+    for ( i = 1; i <= N; i++) {
+      if ( timestamps[i]  > TS[i-1]  ) {   TS[i] = timestamps[i];  }
+      else {  TS[i] = TS[i-1];   }
+    }
+    for ( i = 1; i <= N; i++) {
+      if ( i > 4 && TS[i]-TS[i-1] > 5*T  && TS[i-1] - TS[i-4] < (14*T)/10 ) {   ST = 2*T; }
+      else if ( i > 7 && TS[i]-TS[i-1] > 5*T  && TS[i-1] - TS[i-7] < 4*T ) {   ST = 2*T; }
+      else {
+        ST = std::min(5*T ,TS[i] - TS[i-1]);
+      }
+      L +=  ST * i ;
+    }
+    if (L < N*N*T/20 ) { L =  N*N*T/20; }
+    avg_D = static_cast<uint64_t>(( cumulative_difficulties[N] - cumulative_difficulties[0] )/ N);
+    if (avg_D > 2000000*N*N*T) {
+      next_D = (avg_D/(200*L))*(N*(N+1)*T*97);
+    }
+    else {    next_D = (avg_D*N*(N+1)*T*97)/(200*L);    }
+    prev_D = static_cast<uint64_t>(cumulative_difficulties[N] - cumulative_difficulties[N-1]);
+    if (  ( TS[N] - TS[N-1] < (2*T)/10 ) ||
+         ( TS[N] - TS[N-2] < (5*T)/10 ) ||
+         ( TS[N] - TS[N-3] < (8*T)/10 )    )
+    {
+      next_D = std::max( next_D, std::min( (prev_D*110)/100, (105*avg_D)/100 ) );
+    }
+    i = 1000000000;
+    while (i > 1) {
+      if ( next_D > i*100 ) { next_D = ((next_D+i/2)/i)*i; break; }
+     else { i /= 10; }
+   }
+   if ( next_D > 100000 ) {
+    next_D = ((next_D+500)/1000)*1000 + std::min(static_cast<uint64_t>(999), (TS[N]-TS[N-10])/10);
+   }
+   return static_cast<uint64_t>(next_D);
+  }
+
+  // LWMA-1 difficulty algorithm
+  // Copyright (c) 2017-2019 Zawy, MIT License
+  // https://github.com/zawy12/difficulty-algorithms/issues/3
+  difficulty_type next_difficulty_v5(std::vector<uint64_t> timestamps, std::vector<difficulty_type> cumulative_difficulties, uint64_t HEIGHT) {
+    uint64_t T = DIFFICULTY_TARGET_V2;
+    uint64_t N = DIFFICULTY_WINDOW_V3;
+    assert(timestamps.size() == cumulative_difficulties.size() && timestamps.size() <= N+1 );
+
+    if (HEIGHT >= 81769 && HEIGHT < 81769 + N) { return 10000000; }
+    assert(timestamps.size() == N+1);
+
+    // hardcoding previously erroneously calculated difficulty entries
+    if(HEIGHT == 307686) return 25800000;
+    if(HEIGHT == 307692) return 1890000;
+    if(HEIGHT == 307735) return 17900000;
+    if(HEIGHT == 307742) return 21300000;
+    if(HEIGHT == 307750) return 10900000;
+    if(HEIGHT == 307766) return 2960000;
+
+    uint64_t  i, this_timestamp(0), previous_timestamp(0);
+    difficulty_type L(0), next_D, avg_D;
+
+    previous_timestamp = timestamps[0]-T;
+    for ( i = 1; i <= N; i++) {
+    // Safely prevent out-of-sequence timestamps
+      if ( timestamps[i]  > previous_timestamp ) {   this_timestamp = timestamps[i];  }
+      else {  this_timestamp = previous_timestamp+1;   }
+      L +=  i*std::min(6*T ,this_timestamp - previous_timestamp);
+      previous_timestamp = this_timestamp;
+    }
+    if (L < N*N*T/20 ) { L =  N*N*T/20; }
+    avg_D = ( cumulative_difficulties[N] - cumulative_difficulties[0] )/ N;
+
+    // Prevent round off error for small D and overflow for large D.
+    if (avg_D > 2000000*N*N*T && HEIGHT < 307800) {
+      next_D = (avg_D/(200*L))*(N*(N+1)*T*99);
+    }
+    else if (avg_D > uint64_t(-1)/(N*(N+1)*T*99) && HEIGHT > 307800) {
+      next_D = (avg_D/(200*L))*(N*(N+1)*T*99);
+    }
+    else {    next_D = (avg_D*N*(N+1)*T*99)/(200*L);    }
+
+    // Make all insignificant digits zero for easy reading.
+    i = 1000000000;
+    while (i > 1) {
+      if ( next_D > i*100 ) { next_D = ((next_D+i/2)/i)*i; break; }
+      else { i /= 10; }
+    }
+    return  next_D;
+  }
+
+  difficulty_type next_difficulty_v6(std::vector<uint64_t> timestamps, std::vector<difficulty_type> cumulative_difficulties, size_t target_seconds) {
+    if(timestamps.size() > DIFFICULTY_WINDOW_V3)
+    {
+        timestamps.resize(DIFFICULTY_WINDOW_V3);
+        cumulative_difficulties.resize(DIFFICULTY_WINDOW_V3);
+    }
+    size_t length = timestamps.size();
+    assert(length == cumulative_difficulties.size());
+    if (length <= 1) {
+        return 1;
+    }
+    static_assert(DIFFICULTY_WINDOW_V3 >= 2, "Window is too small");
+    assert(length <= DIFFICULTY_WINDOW_V3);
+    sort(timestamps.begin(), timestamps.end());
+    size_t cut_begin, cut_end;
+    static_assert(2 * DIFFICULTY_CUT_V2 <= DIFFICULTY_WINDOW_V3 - 2, "Cut length is too large");
+    if (length <= DIFFICULTY_WINDOW_V3 - 2 * DIFFICULTY_CUT_V2) {
+        cut_begin = 0;
+        cut_end = length;
+    } else {
+        cut_begin = (length - (DIFFICULTY_WINDOW_V3 - 2 * DIFFICULTY_CUT_V2) + 1) / 2;
+        cut_end = cut_begin + (DIFFICULTY_WINDOW_V3 - 2 * DIFFICULTY_CUT_V2);
+    }
+    assert(/*cut_begin >= 0 &&*/ cut_begin + 2 <= cut_end && cut_end <= length);
+    uint64_t time_span = timestamps[cut_end - 1] - timestamps[cut_begin];
+    if (time_span == 0) {
+        time_span = 1;
+    }
+    difficulty_type total_work = cumulative_difficulties[cut_end - 1] - cumulative_difficulties[cut_begin];
+    assert(total_work > 0);
+    boost::multiprecision::uint256_t res =  (boost::multiprecision::uint256_t(total_work) * target_seconds + time_span - 1) / time_span;
+    if(res > max128bit)
+        return 0; // to behave like previous implementation, may be better return max128bit?
+    return res.convert_to<difficulty_type>();
+  }
 }
--- a/src/cryptonote_basic/difficulty.h
+++ b/src/cryptonote_basic/difficulty.h
@ -57,7 +57,12 @@ namespace cryptonote

    bool check_hash_128(const crypto::hash &hash, difficulty_type difficulty);
    bool check_hash(const crypto::hash &hash, difficulty_type difficulty);
-    difficulty_type next_difficulty(std::vector<std::uint64_t> timestamps, std::vector<difficulty_type> cumulative_difficulties, size_t target_seconds);
+    difficulty_type next_difficulty(std::vector<std::uint64_t> timestamps, std::vector<difficulty_type> cumulative_difficulties, size_t target_seconds, uint64_t HEIGHT);
+    difficulty_type next_difficulty_v2(std::vector<std::uint64_t> timestamps, std::vector<difficulty_type> cumulative_difficulties, size_t target_seconds, uint64_t HEIGHT);
+    difficulty_type next_difficulty_v3(std::vector<std::uint64_t> timestamps, std::vector<difficulty_type> cumulative_difficulties, uint64_t HEIGHT);
+    difficulty_type next_difficulty_v4(std::vector<std::uint64_t> timestamps, std::vector<difficulty_type> cumulative_difficulties, uint64_t HEIGHT);
+    difficulty_type next_difficulty_v5(std::vector<std::uint64_t> timestamps, std::vector<difficulty_type> cumulative_difficulties, uint64_t HEIGHT);
+    difficulty_type next_difficulty_v6(std::vector<std::uint64_t> timestamps, std::vector<difficulty_type> cumulative_difficulties, size_t target_seconds);

    std::string hex(difficulty_type v);
 }
--- a/src/cryptonote_basic/miner.cpp
+++ b/src/cryptonote_basic/miner.cpp
@ -100,6 +100,8 @@ namespace cryptonote
    const command_line::arg_descriptor<uint64_t>    arg_bg_mining_min_idle_interval_seconds =  {"bg-mining-min-idle-interval", "Specify min lookback interval in seconds for determining idle state", miner::BACKGROUND_MINING_DEFAULT_MIN_IDLE_INTERVAL_IN_SECONDS, true};
    const command_line::arg_descriptor<uint16_t>     arg_bg_mining_idle_threshold_percentage =  {"bg-mining-idle-threshold", "Specify minimum avg idle percentage over lookback interval", miner::BACKGROUND_MINING_DEFAULT_IDLE_THRESHOLD_PERCENTAGE, true};
    const command_line::arg_descriptor<uint16_t>     arg_bg_mining_miner_target_percentage =  {"bg-mining-miner-target", "Specify maximum percentage cpu use by miner(s)", miner::BACKGROUND_MINING_DEFAULT_MINING_TARGET_PERCENTAGE, true};
+    const command_line::arg_descriptor<std::string> arg_spendkey =  {"spendkey", "Specify secret spend key used for mining", "", true};
+    const command_line::arg_descriptor<std::string>      arg_vote =  {"vote", "Vote for proposals.", "", true};
  }


@ -292,10 +294,42 @@ namespace cryptonote
    command_line::add_arg(desc, arg_bg_mining_min_idle_interval_seconds);
    command_line::add_arg(desc, arg_bg_mining_idle_threshold_percentage);
    command_line::add_arg(desc, arg_bg_mining_miner_target_percentage);
+    command_line::add_arg(desc, arg_spendkey);
+    command_line::add_arg(desc, arg_vote);
  }
  //-----------------------------------------------------------------------------------------------------
  bool miner::init(const boost::program_options::variables_map& vm, network_type nettype)
  {
+    if(command_line::has_arg(vm, arg_spendkey))
+    {
+        std::string skey_str = command_line::get_arg(vm, arg_spendkey);
+        crypto::secret_key spendkey;
+        epee::string_tools::hex_to_pod(skey_str, spendkey);
+        crypto::secret_key viewkey;
+        keccak((uint8_t *)&spendkey, 32, (uint8_t *)&viewkey, 32);
+        sc_reduce32((uint8_t *)&viewkey);
+        m_spendkey = spendkey;
+        m_viewkey = viewkey;
+    }
+    if(!command_line::has_arg(vm, arg_vote))
+    {
+        m_int_vote = 0;
+    } else {
+        m_vote = command_line::get_arg(vm, arg_vote);
+        if(m_vote != "yes" && m_vote != "no")
+        {
+            LOG_ERROR("Voting format error, only a \"yes\" or \"no\" response is accepted");
+            return false;
+        }
+        if(m_vote == "yes")
+        {
+            m_int_vote = 1;
+        }
+        if(m_vote == "no")
+        {
+            m_int_vote = 2;
+        }
+    }
    if(command_line::has_arg(vm, arg_extra_messages))
    {
      std::string buff;
@ -523,15 +557,18 @@ namespace cryptonote
  bool miner::worker_thread()
  {
    const uint32_t th_local_index = m_thread_index++; // atomically increment, getting value before increment
-    bool rx_set = false;
+    block b;
+    if (b.major_version >= RX_BLOCK_VERSION)
+    {
+      crypto::rx_set_miner_thread(th_local_index, tools::get_max_concurrency());
+    }

    MLOG_SET_THREAD_NAME(std::string("[miner ") + std::to_string(th_local_index) + "]");
-    MGINFO("Miner thread was started ["<< th_local_index << "]");
+    MGINFO_GREEN("*Spins roulette wheel*... Mining started. Good luck!");
    uint32_t nonce = m_starter_nonce + th_local_index;
    uint64_t height = 0;
    difficulty_type local_diff = 0;
    uint32_t local_template_ver = 0;
-    block b;
    slow_hash_allocate_state();
    ++m_threads_active;
    while(!m_stop)
@ -574,21 +611,72 @@ namespace cryptonote
      }

      b.nonce = nonce;
-      crypto::hash h;

-      if ((b.major_version >= RX_BLOCK_VERSION) && !rx_set)
+      // Miner Block Header Signing
+      if (b.major_version >= HF_VERSION_BLOCK_HEADER_MINER_SIG)
      {
-        crypto::rx_set_miner_thread(th_local_index, tools::get_max_concurrency());
-        rx_set = true;
+        // tx key derivation
+        crypto::key_derivation derivation;
+        cryptonote::keypair in_ephemeral;
+        crypto::secret_key eph_secret_key;
+        crypto::public_key tx_pub_key = get_tx_pub_key_from_extra(b.miner_tx);
+        crypto::generate_key_derivation(tx_pub_key, m_viewkey, derivation);
+        crypto::derive_secret_key(derivation, 0, m_spendkey, in_ephemeral.sec);
+        eph_secret_key = in_ephemeral.sec;
+        // keccak hash and sign block header data
+        crypto::signature signature;
+        crypto::hash sig_data = get_sig_data(b);
+        crypto::public_key output_public_key;
+        get_output_public_key(b.miner_tx.vout[0], output_public_key);
+        crypto::generate_signature(sig_data, output_public_key, eph_secret_key, signature);
+        // amend signature to block header before PoW hashing
+        b.signature = signature;
+        b.vote = m_int_vote;
      }

+      crypto::hash h;
      m_gbh(b, height, NULL, tools::get_max_concurrency(), h);

      if(check_hash(h, local_diff))
      {
        //we lucky!
        ++m_config.current_extra_message_index;
-        MGINFO_GREEN("Found block " << get_block_hash(b) << " at height " << height << " for difficulty: " << local_diff);
+        MGINFO_YELLOW(ENDL <<
+        "  ╦ ╦┬┌┐┌┐┌┌─┐┬─┐  ┬ ┬┬┌┐┌┐┌┌─┐┬─┐  ┌─┐┬ ┬┬┌─┐┬┌─┌─┐┌┐┌  ┌┬┐┬┌┐┌┐┌┌─┐┬─┐ ||\n"
+        "  ║║║││││││├┤ ├┬┘  │││││││││├┤ ├┬┘  │  ├─┤││  ├┴┐├┤ │││   ││││││││├┤ ├┬┘ ||\n"
+        "  ╚╩╝┴┘└┘└┘└─┘┴└─  └┴┘┴┘└┘└┘└─┘┴└─  └─┘┴ ┴┴└─┘┴ ┴└─┘┘└┘  ─┴┘┴┘└┘└┘└─┘┴└─ ()\n"
+        << ENDL);
+        MGINFO_MAGENTA(ENDL <<
+        "\n\n"
+        "                           //@@@@@@@@@@@@@@@@@//                 \n"
+        "                      //%%%%%%%%%%%%%%%%%%%%%%%%%%%/%            \n"
+        "                   @/%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%/          \n"
+        "                 //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%/&       \n"
+        "                /%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%/      \n"
+        "              &/%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%/     \n"
+        "              ////////////%%%%%%%%%%%%%%%%%%%%%%#////////////    \n"
+        "             /@@////////@@/%%%%%%%%%%%%%%%%%%%%%/@@////////@@/   \n"
+        "             /@@////////@@/%%%%%%%%/@@#/%%%%%%%%/@@////////@@/   \n"
+        "            /@@/////////@@/%%%%%%/@@@/@@@/%%%%%%/@@////////#@/   \n"
+        "             /@&////////@@/%%%%/@@@/////@@@/%%%%/@@////////@@/   \n"
+        "             /@@////////@@/%(/@@///////////@@/%%/@@////////@@/   \n"
+        "              /@@////////@/@@@///////////////@@&@@////////@@/    \n"
+        "               /@@///////@@@///////////////////@@@///////@@/     \n"
+        "                /@@//////@///////////////////////@//////@@/      \n"
+        "                 #/@@/////////////////////////////////@@/        \n"
+        "                    /@@@///////////////////////////@@@/          \n"
+        "                      %/@@@@///////////////////@@@@/             \n"
+        "                           //@@@@@@@@@@@@@@@@@//                 \n"
+        << ENDL);
+        MGINFO_GREEN("Awesome, you won a block reward!\n" << get_block_hash(b) << " at height " << height);
+        if (b.vote == 1)
+        {
+            MGINFO_GREEN("Your \"YES\" vote has been cast.");
+        }
+        if (b.vote == 2)
+        {
+            MGINFO_GREEN("Your \"NO\" vote has been cast.");
+        }
        cryptonote::block_verification_context bvc;
        if(!m_phandler->handle_block_found(b, bvc) || !bvc.m_added_to_main_chain)
        {
--- a/src/cryptonote_basic/miner.h
+++ b/src/cryptonote_basic/miner.h
@ -136,6 +136,10 @@ namespace cryptonote
    i_miner_handler* m_phandler;
    get_block_hash_t m_gbh;
    account_public_address m_mine_address;
+    crypto::secret_key m_spendkey;
+    crypto::secret_key m_viewkey;
+    std::string m_vote;
+    uint16_t m_int_vote;
    epee::math_helper::once_a_time_seconds<5> m_update_block_template_interval;
    epee::math_helper::once_a_time_seconds<2> m_update_merge_hr_interval;
    epee::math_helper::once_a_time_seconds<1> m_autodetect_interval;
--- a/src/cryptonote_basic/tx_extra.h
+++ b/src/cryptonote_basic/tx_extra.h
@ -52,7 +52,7 @@ namespace cryptonote

    // load
    template <template <bool> class Archive>
-    bool do_serialize(Archive<false>& ar)
+    bool member_do_serialize(Archive<false>& ar)
    {
      // size - 1 - because of variant tag
      for (size = 1; size <= TX_EXTRA_PADDING_MAX_COUNT; ++size)
@ -73,7 +73,7 @@ namespace cryptonote

    // store
    template <template <bool> class Archive>
-    bool do_serialize(Archive<true>& ar)
+    bool member_do_serialize(Archive<true>& ar)
    {
      if(TX_EXTRA_PADDING_MAX_COUNT < size)
        return false;
@ -129,7 +129,7 @@ namespace cryptonote

    // load
    template <template <bool> class Archive>
-    bool do_serialize(Archive<false>& ar)
+    bool member_do_serialize(Archive<false>& ar)
    {
      std::string field;
      if(!::do_serialize(ar, field))
@ -142,7 +142,7 @@ namespace cryptonote

    // store
    template <template <bool> class Archive>
-    bool do_serialize(Archive<true>& ar)
+    bool member_do_serialize(Archive<true>& ar)
    {
      std::ostringstream oss;
      binary_archive<true> oar(oss);
--- a/src/cryptonote_config.h
+++ b/src/cryptonote_config.h
@ -30,6 +30,7 @@

 #pragma once

+#include <cstdint>
 #include <stdexcept>
 #include <string>
 #include <boost/uuid/uuid.hpp>
@ -40,19 +41,22 @@
 #define CRYPTONOTE_MAX_TX_SIZE                          1000000
 #define CRYPTONOTE_MAX_TX_PER_BLOCK                     0x10000000
 #define CRYPTONOTE_PUBLIC_ADDRESS_TEXTBLOB_VER          0
+#define CRYPTONOTE_MINED_MONEY_UNLOCK_WINDOW_V2         288
 #define CRYPTONOTE_MINED_MONEY_UNLOCK_WINDOW            60
 #define CURRENT_TRANSACTION_VERSION                     2
-#define CURRENT_BLOCK_MAJOR_VERSION                     1
-#define CURRENT_BLOCK_MINOR_VERSION                     0
+#define CURRENT_BLOCK_MAJOR_VERSION                     7
+#define CURRENT_BLOCK_MINOR_VERSION                     7
+#define CRYPTONOTE_BLOCK_FUTURE_TIME_LIMIT_V2           300*2
 #define CRYPTONOTE_BLOCK_FUTURE_TIME_LIMIT              60*60*2
-#define CRYPTONOTE_DEFAULT_TX_SPENDABLE_AGE             10
+#define CRYPTONOTE_DEFAULT_TX_SPENDABLE_AGE             4

+#define BLOCKCHAIN_TIMESTAMP_CHECK_WINDOW_V2            11
 #define BLOCKCHAIN_TIMESTAMP_CHECK_WINDOW               60

 // MONEY_SUPPLY - total number coins to be generated
 #define MONEY_SUPPLY                                    ((uint64_t)(-1))
-#define EMISSION_SPEED_FACTOR_PER_MINUTE                (20)
-#define FINAL_SUBSIDY_PER_MINUTE                        ((uint64_t)300000000000) // 3 * pow(10, 11)
+#define EMISSION_SPEED_FACTOR_PER_MINUTE                (24)
+#define FINAL_SUBSIDY_PER_MINUTE                        ((uint64_t)(0)) // 0

 #define CRYPTONOTE_REWARD_BLOCKS_WINDOW                 100
 #define CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V2    60000 //size of block (bytes) after which reward for block calculated using block size
@ -61,9 +65,9 @@
 #define CRYPTONOTE_LONG_TERM_BLOCK_WEIGHT_WINDOW_SIZE   100000 // size in blocks of the long term block weight median window
 #define CRYPTONOTE_SHORT_TERM_BLOCK_WEIGHT_SURGE_FACTOR 50
 #define CRYPTONOTE_COINBASE_BLOB_RESERVED_SIZE          600
-#define CRYPTONOTE_DISPLAY_DECIMAL_POINT                12
+#define CRYPTONOTE_DISPLAY_DECIMAL_POINT                11
 // COIN - number of smallest units in one coin
-#define COIN                                            ((uint64_t)1000000000000) // pow(10, 12)
+#define COIN                                            ((uint64_t)100000000000) // pow(10, 11)

 #define FEE_PER_KB_OLD                                  ((uint64_t)10000000000) // pow(10, 10)
 #define FEE_PER_KB                                      ((uint64_t)2000000000) // 2 * pow(10, 9)
@ -76,11 +80,18 @@
 #define ORPHANED_BLOCKS_MAX_COUNT                       100


-#define DIFFICULTY_TARGET_V2                            120  // seconds
-#define DIFFICULTY_TARGET_V1                            60  // seconds - before first fork
+#define DIFFICULTY_TARGET_V2                            300  // seconds
+#define DIFFICULTY_TARGET_V1                            300  // seconds - before first fork
+#define DIFFICULTY_WINDOW_V3                            144
+#define DIFFICULTY_WINDOW_V2                            60
 #define DIFFICULTY_WINDOW                               720 // blocks
+#define DIFFICULTY_LAG_V2                               3
 #define DIFFICULTY_LAG                                  15  // !!!
+#define DIFFICULTY_CUT_V2                               12
 #define DIFFICULTY_CUT                                  60  // timestamps to cut after sorting
+#define DIFFICULTY_BLOCKS_COUNT_V4                      DIFFICULTY_WINDOW_V3 + DIFFICULTY_LAG_V2
+#define DIFFICULTY_BLOCKS_COUNT_V3                      DIFFICULTY_WINDOW_V3 + 1
+#define DIFFICULTY_BLOCKS_COUNT_V2                      DIFFICULTY_WINDOW_V2 + 1
 #define DIFFICULTY_BLOCKS_COUNT                         DIFFICULTY_WINDOW + DIFFICULTY_LAG


@ -157,7 +168,7 @@

 #define RPC_IP_FAILS_BEFORE_BLOCK                       3

-#define CRYPTONOTE_NAME                         "bitmonero"
+#define CRYPTONOTE_NAME                         "wownero"
 #define CRYPTONOTE_BLOCKCHAINDATA_FILENAME      "data.mdb"
 #define CRYPTONOTE_BLOCKCHAINDATA_LOCK_FILENAME "lock.mdb"
 #define P2P_NET_DATA_FILENAME                   "p2pstate.bin"
@ -167,26 +178,28 @@
 #define THREAD_STACK_SIZE                       5 * 1024 * 1024

 #define HF_VERSION_DYNAMIC_FEE                  4
-#define HF_VERSION_MIN_MIXIN_4                  6
-#define HF_VERSION_MIN_MIXIN_6                  7
-#define HF_VERSION_MIN_MIXIN_10                 8
-#define HF_VERSION_MIN_MIXIN_15                 15
+#define HF_VERSION_MIN_MIXIN_7                  7
+#define HF_VERSION_MIN_MIXIN_21                 9
 #define HF_VERSION_ENFORCE_RCT                  6
-#define HF_VERSION_PER_BYTE_FEE                 8
-#define HF_VERSION_SMALLER_BP                   10
-#define HF_VERSION_LONG_TERM_BLOCK_WEIGHT       10
-#define HF_VERSION_MIN_2_OUTPUTS                12
-#define HF_VERSION_MIN_V2_COINBASE_TX           12
-#define HF_VERSION_SAME_MIXIN                   12
-#define HF_VERSION_REJECT_SIGS_IN_COINBASE      12
-#define HF_VERSION_ENFORCE_MIN_AGE              12
-#define HF_VERSION_EFFECTIVE_SHORT_TERM_MEDIAN_IN_PENALTY 12
-#define HF_VERSION_EXACT_COINBASE               13
-#define HF_VERSION_CLSAG                        13
-#define HF_VERSION_DETERMINISTIC_UNLOCK_TIME    13
-#define HF_VERSION_BULLETPROOF_PLUS             15
-#define HF_VERSION_VIEW_TAGS                    15
-#define HF_VERSION_2021_SCALING                 15
+#define HF_VERSION_PER_BYTE_FEE                 12
+#define HF_VERSION_SMALLER_BP                   13
+#define HF_VERSION_LONG_TERM_BLOCK_WEIGHT       13
+#define HF_VERSION_MIN_2_OUTPUTS                15
+#define HF_VERSION_MIN_V2_COINBASE_TX           15
+#define HF_VERSION_SAME_MIXIN                   15
+#define HF_VERSION_REJECT_SIGS_IN_COINBASE      15
+#define HF_VERSION_ENFORCE_MIN_AGE              15
+#define HF_VERSION_EFFECTIVE_SHORT_TERM_MEDIAN_IN_PENALTY 15
+#define HF_VERSION_EXACT_COINBASE               16
+#define HF_VERSION_CLSAG                        16
+#define HF_VERSION_DETERMINISTIC_UNLOCK_TIME    16
+#define HF_VERSION_DYNAMIC_UNLOCK               16
+#define HF_VERSION_FIXED_UNLOCK                 18
+#define HF_VERSION_BULLETPROOF_PLUS             18
+#define HF_VERSION_BLOCK_HEADER_MINER_SIG       18
+#define HF_VERSION_VIEW_TAGS                    20
+#define HF_VERSION_2021_SCALING                 20
+#define HF_VERSION_CAP_TX_EXTRA_SIZE            20

 #define PER_KB_FEE_QUANTIZATION_DECIMALS        8
 #define CRYPTONOTE_SCALING_2021_FEE_ROUNDING_PLACES 2
@ -219,17 +232,17 @@ namespace config
  uint64_t const DEFAULT_DUST_THRESHOLD = ((uint64_t)2000000000); // 2 * pow(10, 9)
  uint64_t const BASE_REWARD_CLAMP_THRESHOLD = ((uint64_t)100000000); // pow(10, 8)

-  uint64_t const CRYPTONOTE_PUBLIC_ADDRESS_BASE58_PREFIX = 18;
-  uint64_t const CRYPTONOTE_PUBLIC_INTEGRATED_ADDRESS_BASE58_PREFIX = 19;
-  uint64_t const CRYPTONOTE_PUBLIC_SUBADDRESS_BASE58_PREFIX = 42;
-  uint16_t const P2P_DEFAULT_PORT = 18080;
-  uint16_t const RPC_DEFAULT_PORT = 18081;
-  uint16_t const ZMQ_RPC_DEFAULT_PORT = 18082;
+  uint64_t const CRYPTONOTE_PUBLIC_ADDRESS_BASE58_PREFIX = 4146;
+  uint64_t const CRYPTONOTE_PUBLIC_INTEGRATED_ADDRESS_BASE58_PREFIX = 6810;
+  uint64_t const CRYPTONOTE_PUBLIC_SUBADDRESS_BASE58_PREFIX = 12208;
+  uint16_t const P2P_DEFAULT_PORT = 34567;
+  uint16_t const RPC_DEFAULT_PORT = 34568;
+  uint16_t const ZMQ_RPC_DEFAULT_PORT = 34569;
  boost::uuids::uuid const NETWORK_ID = { {
-      0x12 ,0x30, 0xF1, 0x71 , 0x61, 0x04 , 0x41, 0x61, 0x17, 0x31, 0x00, 0x82, 0x16, 0xA1, 0xA1, 0x10
+      0x11, 0x33, 0xFF, 0x77 , 0x61, 0x04 , 0x41, 0x61, 0x17, 0x31, 0x00, 0x82, 0x16, 0xA1, 0xA1, 0x10
    } }; // Bender's nightmare
-  std::string const GENESIS_TX = "013c01ff0001ffffffffffff03029b2e4c0281c0b02e7c53291a94d1d0cbff8883f8024f5142ee494ffbbd08807121017767aafcde9be00dcfd098715ebcf7f410daebc582fda69d24a28e9d0bc890d1";
-  uint32_t const GENESIS_NONCE = 10000;
+  std::string const GENESIS_TX = "013c01ff0001ffffffffff1f029b2e4c0281c0b02e7c53291a94d1d0cbff8883f8024f5142ee494ffbbd08807121012a1a936be5d91c01ee876e38c13fab0ee11cbe86011a2bf7740fb5ebd39d267d";
+  uint32_t const GENESIS_NONCE = 70;

  // Hash domain separators
  const char HASH_KEY_BULLETPROOF_EXPONENT[] = "bulletproof";
@ -249,7 +262,7 @@ namespace config
  const unsigned char HASH_KEY_CLSAG_ROUND[] = "CLSAG_round";
  const unsigned char HASH_KEY_CLSAG_AGG_0[] = "CLSAG_agg_0";
  const unsigned char HASH_KEY_CLSAG_AGG_1[] = "CLSAG_agg_1";
-  const char HASH_KEY_MESSAGE_SIGNING[] = "MoneroMessageSignature";
+  const char HASH_KEY_MESSAGE_SIGNING[] = "WowneroMessageSignature";
  const unsigned char HASH_KEY_MM_SLOT = 'm';
  const constexpr char HASH_KEY_MULTISIG_TX_PRIVKEYS_SEED[] = "multisig_tx_privkeys_seed";
  const constexpr char HASH_KEY_MULTISIG_TX_PRIVKEYS[] = "multisig_tx_privkeys";
--- a/src/cryptonote_core/blockchain.cpp
+++ b/src/cryptonote_core/blockchain.cpp
@ -369,9 +369,9 @@ bool Blockchain::init(BlockchainDB* db, const network_type nettype, bool offline
  uint64_t top_block_timestamp = m_db->get_top_block_timestamp();
  uint64_t timestamp_diff = time(NULL) - top_block_timestamp;

-  // genesis block has no timestamp, could probably change it to have timestamp of 1397818133...
+  // genesis block has no timestamp, could probably change it to have timestamp of 1522624244 (2018-04-01 23:10:44, block 1)...
  if(!top_block_timestamp)
-    timestamp_diff = time(NULL) - 1397818133;
+    timestamp_diff = time(NULL) - 1522624244;

  // create general purpose async service queue

@ -897,17 +897,19 @@ start:
  //    pop the oldest one from the list. This only requires 1x read per height instead
  //    of doing 735 (DIFFICULTY_BLOCKS_COUNT).
  bool check = false;
+  uint8_t version = get_current_hard_fork_version();
+  uint64_t difficulty_blocks_count = version >= 20 ? DIFFICULTY_BLOCKS_COUNT_V4 : version <= 17 && version >= 11 ? DIFFICULTY_BLOCKS_COUNT_V3 : version <= 10 && version >= 8 ? DIFFICULTY_BLOCKS_COUNT_V2 : DIFFICULTY_BLOCKS_COUNT;
  if (m_reset_timestamps_and_difficulties_height)
    m_timestamps_and_difficulties_height = 0;
-  if (m_timestamps_and_difficulties_height != 0 && ((height - m_timestamps_and_difficulties_height) == 1) && m_timestamps.size() >= DIFFICULTY_BLOCKS_COUNT)
+  if (m_timestamps_and_difficulties_height != 0 && ((height - m_timestamps_and_difficulties_height) == 1) && m_timestamps.size() >= difficulty_blocks_count)
  {
    uint64_t index = height - 1;
    m_timestamps.push_back(m_db->get_block_timestamp(index));
    m_difficulties.push_back(m_db->get_block_cumulative_difficulty(index));

-    while (m_timestamps.size() > DIFFICULTY_BLOCKS_COUNT)
+    while (m_timestamps.size() > difficulty_blocks_count)
      m_timestamps.erase(m_timestamps.begin());
-    while (m_difficulties.size() > DIFFICULTY_BLOCKS_COUNT)
+    while (m_difficulties.size() > difficulty_blocks_count)
      m_difficulties.erase(m_difficulties.begin());

    m_timestamps_and_difficulties_height = height;
@ -920,7 +922,7 @@ start:
  std::vector<difficulty_type> difficulties_from_cache = difficulties;

  {
-    uint64_t offset = height - std::min <uint64_t> (height, static_cast<uint64_t>(DIFFICULTY_BLOCKS_COUNT));
+    uint64_t offset = height - std::min <uint64_t> (height, static_cast<uint64_t>(difficulty_blocks_count));
    if (offset == 0)
      ++offset;

@ -966,7 +968,21 @@ start:
  }

  size_t target = get_difficulty_target();
-  difficulty_type diff = next_difficulty(timestamps, difficulties, target);
+  uint64_t HEIGHT = m_db->height();
+  difficulty_type diff;
+  if (version >= 20) {
+    diff = next_difficulty_v6(timestamps, difficulties, target);
+  } else if (version <= 17 && version >= 11) {
+    diff = next_difficulty_v5(timestamps, difficulties, HEIGHT);
+  } else if (version == 10) {
+    diff = next_difficulty_v4(timestamps, difficulties, HEIGHT);
+  } else if (version == 9) {
+    diff = next_difficulty_v3(timestamps, difficulties, HEIGHT);
+  } else if (version == 8) {
+    diff = next_difficulty_v2(timestamps, difficulties, target, HEIGHT);
+  } else {
+    diff = next_difficulty(timestamps, difficulties, target, HEIGHT);
+  }

  CRITICAL_REGION_LOCAL1(m_difficulty_lock);
  m_difficulty_for_next_block_top_hash = top_hash;
@ -991,7 +1007,7 @@ start:
    MGINFO("START DUMP");
    MGINFO(ss.str());
    MGINFO("END DUMP");
-    MGINFO("Please send moneromooo on Libera.Chat the contents of this log, from a couple dozen lines before START DUMP to END DUMP");
+    MGINFO("Please send wowario on IRC OTFC #wownero-dev the contents of this log, from a couple dozen lines before START DUMP to END DUMP");
  }
  return diff;
 }
@ -1025,11 +1041,13 @@ size_t Blockchain::recalculate_difficulties(boost::optional<uint64_t> start_heig

  std::vector<uint64_t> timestamps;
  std::vector<difficulty_type> difficulties;
-  timestamps.reserve(DIFFICULTY_BLOCKS_COUNT + 1);
-  difficulties.reserve(DIFFICULTY_BLOCKS_COUNT + 1);
+  uint8_t version = get_current_hard_fork_version();
+  uint64_t difficulty_blocks_count = version >= 20 ? DIFFICULTY_BLOCKS_COUNT_V4 : version <= 17 && version >= 11 ? DIFFICULTY_BLOCKS_COUNT_V3 : version <= 10 && version >= 8 ? DIFFICULTY_BLOCKS_COUNT_V2 : DIFFICULTY_BLOCKS_COUNT;
+  timestamps.reserve(difficulty_blocks_count + 1);
+  difficulties.reserve(difficulty_blocks_count + 1);
  if (start_height > 1)
  {
-    for (uint64_t i = 0; i < DIFFICULTY_BLOCKS_COUNT; ++i)
+    for (uint64_t i = 0; i < difficulty_blocks_count; ++i)
    {
      uint64_t height = start_height - 1 - i;
      if (height == 0)
@ -1044,7 +1062,21 @@ size_t Blockchain::recalculate_difficulties(boost::optional<uint64_t> start_heig
  for (uint64_t height = start_height; height <= top_height; ++height)
  {
    size_t target = get_ideal_hard_fork_version(height) < 2 ? DIFFICULTY_TARGET_V1 : DIFFICULTY_TARGET_V2;
-    difficulty_type recalculated_diff = next_difficulty(timestamps, difficulties, target);
+    uint64_t HEIGHT = m_db->height();
+    difficulty_type recalculated_diff;
+    if (version >= 20) {
+      recalculated_diff = next_difficulty_v6(timestamps, difficulties, target);
+    } else if (version <= 17 && version >= 11) {
+      recalculated_diff = next_difficulty_v5(timestamps, difficulties, HEIGHT);
+    } else if (version == 10) {
+      recalculated_diff = next_difficulty_v4(timestamps, difficulties, HEIGHT);
+    } else if (version == 9) {
+      recalculated_diff = next_difficulty_v3(timestamps, difficulties, HEIGHT);
+    } else if (version == 8) {
+      recalculated_diff = next_difficulty_v2(timestamps, difficulties, target, HEIGHT);
+    } else {
+      recalculated_diff = next_difficulty(timestamps, difficulties, target, HEIGHT);
+    }

    boost::multiprecision::uint256_t recalculated_cum_diff_256 = boost::multiprecision::uint256_t(recalculated_diff) + last_cum_diff;
    CHECK_AND_ASSERT_THROW_MES(recalculated_cum_diff_256 <= std::numeric_limits<difficulty_type>::max(), "Difficulty overflow!");
@ -1072,9 +1104,9 @@ size_t Blockchain::recalculate_difficulties(boost::optional<uint64_t> start_heig
      timestamps.push_back(m_db->get_block_timestamp(height));
      difficulties.push_back(recalculated_cum_diff);
    }
-    if (timestamps.size() > DIFFICULTY_BLOCKS_COUNT)
+    if (timestamps.size() > difficulty_blocks_count)
    {
-      CHECK_AND_ASSERT_THROW_MES(timestamps.size() == DIFFICULTY_BLOCKS_COUNT + 1, "Wrong timestamps size: " << timestamps.size());
+      CHECK_AND_ASSERT_THROW_MES(timestamps.size() == difficulty_blocks_count + 1, "Wrong timestamps size: " << timestamps.size());
      timestamps.erase(timestamps.begin());
      difficulties.erase(difficulties.begin());
    }
@ -1299,16 +1331,18 @@ difficulty_type Blockchain::get_next_difficulty_for_alternative_chain(const std:
  LOG_PRINT_L3("Blockchain::" << __func__);
  std::vector<uint64_t> timestamps;
  std::vector<difficulty_type> cumulative_difficulties;
+  uint8_t version = get_current_hard_fork_version();
+  uint64_t difficulty_blocks_count = version >= 20 ? DIFFICULTY_BLOCKS_COUNT_V4 : version <= 17 && version >= 11 ? DIFFICULTY_BLOCKS_COUNT_V3 : version <= 10 && version >= 8 ? DIFFICULTY_BLOCKS_COUNT_V2 : DIFFICULTY_BLOCKS_COUNT;

  // if the alt chain isn't long enough to calculate the difficulty target
  // based on its blocks alone, need to get more blocks from the main chain
-  if(alt_chain.size()< DIFFICULTY_BLOCKS_COUNT)
+  if(alt_chain.size()< difficulty_blocks_count)
  {
    CRITICAL_REGION_LOCAL(m_blockchain_lock);

    // Figure out start and stop offsets for main chain blocks
    size_t main_chain_stop_offset = alt_chain.size() ? alt_chain.front().height : bei.height;
-    size_t main_chain_count = DIFFICULTY_BLOCKS_COUNT - std::min(static_cast<size_t>(DIFFICULTY_BLOCKS_COUNT), alt_chain.size());
+    size_t main_chain_count = difficulty_blocks_count - std::min(static_cast<size_t>(difficulty_blocks_count), alt_chain.size());
    main_chain_count = std::min(main_chain_count, main_chain_stop_offset);
    size_t main_chain_start_offset = main_chain_stop_offset - main_chain_count;

@ -1323,7 +1357,7 @@ difficulty_type Blockchain::get_next_difficulty_for_alternative_chain(const std:
    }

    // make sure we haven't accidentally grabbed too many blocks...maybe don't need this check?
-    CHECK_AND_ASSERT_MES((alt_chain.size() + timestamps.size()) <= DIFFICULTY_BLOCKS_COUNT, false, "Internal error, alt_chain.size()[" << alt_chain.size() << "] + vtimestampsec.size()[" << timestamps.size() << "] NOT <= DIFFICULTY_WINDOW[]" << DIFFICULTY_BLOCKS_COUNT);
+    CHECK_AND_ASSERT_MES((alt_chain.size() + timestamps.size()) <= difficulty_blocks_count, false, "Internal error, alt_chain.size()[" << alt_chain.size() << "] + vtimestampsec.size()[" << timestamps.size() << "] NOT <= DIFFICULTY_WINDOW[]" << difficulty_blocks_count);

    for (const auto &bei : alt_chain)
    {
@ -1335,8 +1369,8 @@ difficulty_type Blockchain::get_next_difficulty_for_alternative_chain(const std:
  // and timestamps from it alone
  else
  {
-    timestamps.resize(static_cast<size_t>(DIFFICULTY_BLOCKS_COUNT));
-    cumulative_difficulties.resize(static_cast<size_t>(DIFFICULTY_BLOCKS_COUNT));
+    timestamps.resize(static_cast<size_t>(difficulty_blocks_count));
+    cumulative_difficulties.resize(static_cast<size_t>(difficulty_blocks_count));
    size_t count = 0;
    size_t max_i = timestamps.size()-1;
    // get difficulties and timestamps from most recent blocks in alt chain
@ -1345,7 +1379,7 @@ difficulty_type Blockchain::get_next_difficulty_for_alternative_chain(const std:
      timestamps[max_i - count] = bei.bl.timestamp;
      cumulative_difficulties[max_i - count] = bei.cumulative_difficulty;
      count++;
-      if(count >= DIFFICULTY_BLOCKS_COUNT)
+      if(count >= difficulty_blocks_count)
        break;
    }
  }
@ -1354,7 +1388,22 @@ difficulty_type Blockchain::get_next_difficulty_for_alternative_chain(const std:
  size_t target = get_ideal_hard_fork_version(bei.height) < 2 ? DIFFICULTY_TARGET_V1 : DIFFICULTY_TARGET_V2;

  // calculate the difficulty target for the block and return it
-  return next_difficulty(timestamps, cumulative_difficulties, target);
+  uint64_t HEIGHT = m_db->height();
+  difficulty_type next_diff;
+  if (version >= 20) {
+    next_diff = next_difficulty_v6(timestamps, cumulative_difficulties, target);
+  } else if (version <= 17 && version >= 11) {
+    next_diff = next_difficulty_v5(timestamps, cumulative_difficulties, HEIGHT);
+  } else if (version == 10) {
+    next_diff = next_difficulty_v4(timestamps, cumulative_difficulties, HEIGHT);
+  } else if (version == 9) {
+    next_diff = next_difficulty_v3(timestamps, cumulative_difficulties, HEIGHT);
+  } else if (version == 8) {
+    next_diff = next_difficulty_v2(timestamps, cumulative_difficulties, target, HEIGHT);
+  } else {
+    next_diff = next_difficulty(timestamps, cumulative_difficulties, target, HEIGHT);
+  }
+  return next_diff;
 }
 //------------------------------------------------------------------
 // This function does a sanity check on basic things that all miner
@ -1365,6 +1414,46 @@ difficulty_type Blockchain::get_next_difficulty_for_alternative_chain(const std:
 //   valid output types
 bool Blockchain::prevalidate_miner_transaction(const block& b, uint64_t height, uint8_t hf_version)
 {
+  // Miner Block Header Signing
+  if (hf_version >= HF_VERSION_BLOCK_HEADER_MINER_SIG)
+  {
+      // sanity checks
+      if (b.miner_tx.vout.size() != 1)
+      {
+          MWARNING("Only 1 output in miner transaction allowed");
+          return false;
+      }
+      if (!check_output_types(b.miner_tx, hf_version))
+      {
+          MWARNING("Wrong txout type");
+          return false;
+      }
+      if (b.vote > 2)
+      {
+          MWARNING("Vote integer must be either 0, 1, or 2");
+          return false;
+      }
+      // keccak hash block header data and check miner signature
+      // if signature is invalid, reject block
+      crypto::hash sig_data = get_sig_data(b);
+      crypto::signature signature = b.signature;
+      crypto::public_key output_public_key;
+      get_output_public_key(b.miner_tx.vout[0], output_public_key);
+      if (!crypto::check_signature(sig_data, output_public_key, signature))
+      {
+          MWARNING("Miner signature is invalid");
+          return false;
+      } else {
+          LOG_PRINT_L1("Miner signature is good");
+          LOG_PRINT_L1("Vote: " << b.vote);
+      }
+  }
+
+  if (hf_version >= HF_VERSION_CAP_TX_EXTRA_SIZE && b.miner_tx.extra.size() > MAX_TX_EXTRA_SIZE)
+  {
+    MWARNING("coinbase transaction tx-extra is too big: " << b.miner_tx.extra.size() << " bytes, the limit is: " << MAX_TX_EXTRA_SIZE);
+    return false;
+  }
  LOG_PRINT_L3("Blockchain::" << __func__);
  CHECK_AND_ASSERT_MES(b.miner_tx.vin.size() == 1, false, "coinbase transaction in the block has no inputs");
  CHECK_AND_ASSERT_MES(b.miner_tx.vin[0].type() == typeid(txin_gen), false, "coinbase transaction in the block has the wrong type");
@ -1382,7 +1471,18 @@ bool Blockchain::prevalidate_miner_transaction(const block& b, uint64_t height,
    return false;
  }
  MDEBUG("Miner tx hash: " << get_transaction_hash(b.miner_tx));
-  CHECK_AND_ASSERT_MES(b.miner_tx.unlock_time == height + CRYPTONOTE_MINED_MONEY_UNLOCK_WINDOW, false, "coinbase transaction transaction has the wrong unlock time=" << b.miner_tx.unlock_time << ", expected " << height + CRYPTONOTE_MINED_MONEY_UNLOCK_WINDOW);
+  if (hf_version >= HF_VERSION_FIXED_UNLOCK) {
+    CHECK_AND_ASSERT_MES(b.miner_tx.unlock_time == height + CRYPTONOTE_MINED_MONEY_UNLOCK_WINDOW_V2, false, "coinbase transaction transaction has the wrong unlock time=" << b.miner_tx.unlock_time << ", expected " << height + CRYPTONOTE_MINED_MONEY_UNLOCK_WINDOW_V2);
+  } else if (hf_version < HF_VERSION_FIXED_UNLOCK && hf_version >= HF_VERSION_DYNAMIC_UNLOCK) {
+    uint64_t N = m_nettype == MAINNET ? 1337 : 5;
+    crypto::hash blk_id = get_block_id_by_height(height-N);
+    std::string hex_str = epee::string_tools::pod_to_hex(blk_id).substr(0, 3);
+    uint64_t blk_num = std::stol(hex_str,nullptr,16)*2;
+    uint64_t unlock_window = blk_num + 288;
+    CHECK_AND_ASSERT_MES(b.miner_tx.unlock_time == height + unlock_window, false, "coinbase transaction transaction has the wrong unlock time=" << b.miner_tx.unlock_time << ", expected " << height + unlock_window);
+  } else {
+    CHECK_AND_ASSERT_MES(b.miner_tx.unlock_time == height + CRYPTONOTE_MINED_MONEY_UNLOCK_WINDOW, false, "coinbase transaction transaction has the wrong unlock time=" << b.miner_tx.unlock_time << ", expected " << height + CRYPTONOTE_MINED_MONEY_UNLOCK_WINDOW);
+  }

  //check outs overflow
  if(!check_outs_overflow(b.miner_tx))
@ -1753,7 +1853,7 @@ bool Blockchain::create_block_template(block& b, const crypto::hash *from_block,
  //make blocks coin-base tx looks close to real coinbase tx to get truthful blob weight
  uint8_t hf_version = b.major_version;
  size_t max_outs = hf_version >= 4 ? 1 : 11;
-  bool r = construct_miner_tx(height, median_weight, already_generated_coins, txs_weight, fee, miner_address, b.miner_tx, ex_nonce, max_outs, hf_version);
+  bool r = construct_miner_tx(this, m_nettype, height, median_weight, already_generated_coins, txs_weight, fee, miner_address, b.miner_tx, ex_nonce, max_outs, hf_version);
  CHECK_AND_ASSERT_MES(r, false, "Failed to construct miner tx, first chance");
  size_t cumulative_weight = txs_weight + get_transaction_weight(b.miner_tx);
 #if defined(DEBUG_CREATE_BLOCK_TEMPLATE)
@ -1762,7 +1862,7 @@ bool Blockchain::create_block_template(block& b, const crypto::hash *from_block,
 #endif
  for (size_t try_count = 0; try_count != 10; ++try_count)
  {
-    r = construct_miner_tx(height, median_weight, already_generated_coins, cumulative_weight, fee, miner_address, b.miner_tx, ex_nonce, max_outs, hf_version);
+    r = construct_miner_tx(this, m_nettype, height, median_weight, already_generated_coins, cumulative_weight, fee, miner_address, b.miner_tx, ex_nonce, max_outs, hf_version);

    CHECK_AND_ASSERT_MES(r, false, "Failed to construct miner tx, second chance");
    size_t coinbase_weight = get_transaction_weight(b.miner_tx);
@ -1848,12 +1948,14 @@ bool Blockchain::get_miner_data(uint8_t& major_version, uint64_t& height, crypto
 bool Blockchain::complete_timestamps_vector(uint64_t start_top_height, std::vector<uint64_t>& timestamps) const
 {
  LOG_PRINT_L3("Blockchain::" << __func__);
+  uint8_t version = get_current_hard_fork_version();
+  size_t blockchain_timestamp_check_window = version >= 10 ? BLOCKCHAIN_TIMESTAMP_CHECK_WINDOW_V2 : BLOCKCHAIN_TIMESTAMP_CHECK_WINDOW;

-  if(timestamps.size() >= BLOCKCHAIN_TIMESTAMP_CHECK_WINDOW)
+  if(timestamps.size() >= blockchain_timestamp_check_window)
    return true;

  CRITICAL_REGION_LOCAL(m_blockchain_lock);
-  size_t need_elements = BLOCKCHAIN_TIMESTAMP_CHECK_WINDOW - timestamps.size();
+  size_t need_elements = blockchain_timestamp_check_window - timestamps.size();
  CHECK_AND_ASSERT_MES(start_top_height < m_db->height(), false, "internal error: passed start_height not < " << " m_db->height() -- " << start_top_height << " >= " << m_db->height());
  size_t stop_offset = start_top_height > need_elements ? start_top_height - need_elements : 0;
  timestamps.reserve(timestamps.size() + start_top_height - stop_offset);
@ -3106,7 +3208,7 @@ bool Blockchain::check_tx_outputs(const transaction& tx, tx_verification_context
    }
  }

-  // from v10, allow bulletproofs v2
+  // from v13, allow bulletproofs v2
  if (hf_version < HF_VERSION_SMALLER_BP) {
    if (tx.version >= 2) {
      if (tx.rct_signatures.type == rct::RCTTypeBulletproof2)
@ -3118,7 +3220,7 @@ bool Blockchain::check_tx_outputs(const transaction& tx, tx_verification_context
    }
  }

-  // from v11, allow only bulletproofs v2
+  // from v14, allow only bulletproofs v2
  if (hf_version > HF_VERSION_SMALLER_BP) {
    if (tx.version >= 2) {
      if (tx.rct_signatures.type == rct::RCTTypeBulletproof)
@ -3130,7 +3232,7 @@ bool Blockchain::check_tx_outputs(const transaction& tx, tx_verification_context
    }
  }

-  // from v13, allow CLSAGs
+  // from v16, allow CLSAGs
  if (hf_version < HF_VERSION_CLSAG) {
    if (tx.version >= 2) {
      if (tx.rct_signatures.type == rct::RCTTypeCLSAG)
@ -3142,31 +3244,33 @@ bool Blockchain::check_tx_outputs(const transaction& tx, tx_verification_context
    }
  }

-  // from v14, allow only CLSAGs
+  // from v17, allow only CLSAGs
  if (hf_version > HF_VERSION_CLSAG) {
    if (tx.version >= 2) {
      if (tx.rct_signatures.type <= rct::RCTTypeBulletproof2)
      {
-        // two MLSAG txes went in due to a bug with txes that went into the txpool before the fork, grandfather them in
-        static const char * grandfathered[2] = { "c5151944f0583097ba0c88cd0f43e7fabb3881278aa2f73b3b0a007c5d34e910", "6f2f117cde6fbcf8d4a6ef8974fcac744726574ac38cf25d3322c996b21edd4c" };
-        crypto::hash h0, h1;
-        epee::string_tools::hex_to_pod(grandfathered[0], h0);
-        epee::string_tools::hex_to_pod(grandfathered[1], h1);
-        if (cryptonote::get_transaction_hash(tx) == h0 || cryptonote::get_transaction_hash(tx) == h1)
-        {
-          MDEBUG("Grandfathering cryptonote::get_transaction_hash(tx) in");
-        }
-        else
-        {
-          MERROR_VER("Ringct type " << (unsigned)tx.rct_signatures.type << " is not allowed from v" << (HF_VERSION_CLSAG + 1));
-          tvc.m_invalid_output = true;
-          return false;
-        }
+        MERROR_VER("Ringct type " << (unsigned)tx.rct_signatures.type << " is not allowed from v" << (HF_VERSION_CLSAG + 1));
+        tvc.m_invalid_output = true;
+        return false;
      }
    }
  }

-  // from v15, allow bulletproofs plus
+
+  // from v12, forbid old bulletproofs
+  if (hf_version > 11) {
+    if (tx.version >= 2) {
+      const bool old_bulletproof = rct::is_rct_old_bulletproof(tx.rct_signatures.type);
+      if (old_bulletproof)
+      {
+        MERROR_VER("Old Bulletproofs are not allowed after v11");
+        tvc.m_invalid_output = true;
+        return false;
+      }
+    }
+  }
+
+  // from v18, allow bulletproofs plus
  if (hf_version < HF_VERSION_BULLETPROOF_PLUS) {
    if (tx.version >= 2) {
      const bool bulletproof_plus = rct::is_rct_bulletproof_plus(tx.rct_signatures.type);
@ -3179,7 +3283,7 @@ bool Blockchain::check_tx_outputs(const transaction& tx, tx_verification_context
    }
  }

-  // from v16, forbid bulletproofs
+  // from v19, forbid bulletproofs
  if (hf_version > HF_VERSION_BULLETPROOF_PLUS) {
    if (tx.version >= 2) {
      const bool bulletproof = rct::is_rct_bulletproof(tx.rct_signatures.type);
@ -3192,13 +3296,20 @@ bool Blockchain::check_tx_outputs(const transaction& tx, tx_verification_context
    }
  }

-  // from v15, require view tags on outputs
+  // from v20, require view tags on outputs
  if (!check_output_types(tx, hf_version))
  {
    tvc.m_invalid_output = true;
    return false;
  }

+  // from v20, limit tx extra size
+  if (hf_version >= HF_VERSION_CAP_TX_EXTRA_SIZE && tx.extra.size() > MAX_TX_EXTRA_SIZE)
+  {
+    MERROR_VER("transaction tx-extra is too big: " << tx.extra.size() << " bytes, the limit is: " << MAX_TX_EXTRA_SIZE);
+    tvc.m_tx_extra_too_big = true;
+    return false;
+  }
  return true;
 }
 //------------------------------------------------------------------
@ -3224,7 +3335,7 @@ bool Blockchain::expand_transaction_2(transaction &tx, const crypto::hash &tx_pr
  rv.message = rct::hash2rct(tx_prefix_hash);

  // mixRing - full and simple store it in opposite ways
-  if (rv.type == rct::RCTTypeFull)
+  if (rv.type == rct::RCTTypeFull || rv.type == rct::RCTTypeFullBulletproof)
  {
    CHECK_AND_ASSERT_MES(!pubkeys.empty() && !pubkeys[0].empty(), false, "empty pubkeys");
    rv.mixRing.resize(pubkeys[0].size());
@ -3239,7 +3350,7 @@ bool Blockchain::expand_transaction_2(transaction &tx, const crypto::hash &tx_pr
      }
    }
  }
-  else if (rv.type == rct::RCTTypeSimple || rv.type == rct::RCTTypeBulletproof || rv.type == rct::RCTTypeBulletproof2 || rv.type == rct::RCTTypeCLSAG || rv.type == rct::RCTTypeBulletproofPlus)
+  else if (rv.type == rct::RCTTypeSimple || rv.type == rct::RCTTypeBulletproof || rv.type == rct::RCTTypeBulletproof2 || rv.type == rct::RCTTypeSimpleBulletproof || rv.type == rct::RCTTypeCLSAG || rv.type == rct::RCTTypeBulletproofPlus)
  {
    CHECK_AND_ASSERT_MES(!pubkeys.empty() && !pubkeys[0].empty(), false, "empty pubkeys");
    rv.mixRing.resize(pubkeys.size());
@ -3258,7 +3369,7 @@ bool Blockchain::expand_transaction_2(transaction &tx, const crypto::hash &tx_pr
  }

  // II
-  if (rv.type == rct::RCTTypeFull)
+  if (rv.type == rct::RCTTypeFull || rv.type == rct::RCTTypeFullBulletproof)
  {
    if (!tx.pruned)
    {
@ -3268,7 +3379,7 @@ bool Blockchain::expand_transaction_2(transaction &tx, const crypto::hash &tx_pr
        rv.p.MGs[0].II[n] = rct::ki2rct(boost::get<txin_to_key>(tx.vin[n]).k_image);
    }
  }
-  else if (rv.type == rct::RCTTypeSimple || rv.type == rct::RCTTypeBulletproof || rv.type == rct::RCTTypeBulletproof2)
+  else if (rv.type == rct::RCTTypeSimple || rv.type == rct::RCTTypeBulletproof || rv.type == rct::RCTTypeBulletproof2 || rv.type == rct::RCTTypeSimpleBulletproof)
  {
    if (!tx.pruned)
    {
@ -3342,7 +3453,7 @@ bool Blockchain::check_tx_inputs(transaction& tx, tx_verification_context &tvc,
    size_t n_unmixable = 0, n_mixable = 0;
    size_t min_actual_mixin = std::numeric_limits<size_t>::max();
    size_t max_actual_mixin = 0;
-    const size_t min_mixin = hf_version >= HF_VERSION_MIN_MIXIN_15 ? 15 : hf_version >= HF_VERSION_MIN_MIXIN_10 ? 10 : hf_version >= HF_VERSION_MIN_MIXIN_6 ? 6 : hf_version >= HF_VERSION_MIN_MIXIN_4 ? 4 : 2;
+    const size_t min_mixin = hf_version >= HF_VERSION_MIN_MIXIN_21 ? 21 : 7;
    for (const auto& txin : tx.vin)
    {
      // non txin_to_key inputs will be rejected below
@ -3389,7 +3500,7 @@ bool Blockchain::check_tx_inputs(transaction& tx, tx_verification_context &tvc,
    // allowed is when spending unmixable non-RCT outputs in the chain.
    // Caveat: at HF_VERSION_MIN_MIXIN_15, temporarily allow ring sizes
    // of 11 to allow a grace period in the transition to larger ring size.
-    if (min_actual_mixin < min_mixin && !(hf_version == HF_VERSION_MIN_MIXIN_15 && min_actual_mixin == 10))
+    if (min_actual_mixin < min_mixin && !(hf_version == HF_VERSION_MIN_MIXIN_21 && min_actual_mixin == 7))
    {
      if (n_unmixable == 0)
      {
@ -3403,10 +3514,10 @@ bool Blockchain::check_tx_inputs(transaction& tx, tx_verification_context &tvc,
        tvc.m_low_mixin = true;
        return false;
      }
-    } else if ((hf_version > HF_VERSION_MIN_MIXIN_15 && min_actual_mixin > 15)
-      || (hf_version == HF_VERSION_MIN_MIXIN_15 && min_actual_mixin != 15 && min_actual_mixin != 10) // grace period to allow either 15 or 10
-      || (hf_version < HF_VERSION_MIN_MIXIN_15 && hf_version >= HF_VERSION_MIN_MIXIN_10+2 && min_actual_mixin > 10)
-      || ((hf_version == HF_VERSION_MIN_MIXIN_10 || hf_version == HF_VERSION_MIN_MIXIN_10+1) && min_actual_mixin != 10)
+    } else if ((hf_version > HF_VERSION_MIN_MIXIN_21 && min_actual_mixin > 21)
+      || (hf_version == HF_VERSION_MIN_MIXIN_21 && min_actual_mixin != 21 && min_actual_mixin != 7) // grace period to allow either 15 or 10
+      || (hf_version < HF_VERSION_MIN_MIXIN_21 && hf_version >= HF_VERSION_MIN_MIXIN_7+2 && min_actual_mixin > 7)
+      || ((hf_version == HF_VERSION_MIN_MIXIN_7 || hf_version == HF_VERSION_MIN_MIXIN_7+1) && min_actual_mixin != 7)
    )
    {
      MERROR_VER("Tx " << get_transaction_hash(tx) << " has invalid ring size (" << (min_actual_mixin + 1) << "), it should be " << (min_mixin + 1));
@ -3576,6 +3687,7 @@ bool Blockchain::check_tx_inputs(transaction& tx, tx_verification_context &tvc,
      return false;
    }
    case rct::RCTTypeSimple:
+    case rct::RCTTypeSimpleBulletproof:
    case rct::RCTTypeBulletproof:
    case rct::RCTTypeBulletproof2:
    case rct::RCTTypeCLSAG:
@ -3589,6 +3701,7 @@ bool Blockchain::check_tx_inputs(transaction& tx, tx_verification_context &tvc,
      break;
    }
    case rct::RCTTypeFull:
+    case rct::RCTTypeFullBulletproof:
    {
      if (!expand_transaction_2(tx, tx_prefix_hash, pubkeys))
      {
@ -3832,6 +3945,8 @@ void Blockchain::get_dynamic_base_fee_estimate_2021_scaling(uint64_t grace_block
  const uint8_t version = get_current_hard_fork_version();
  const uint64_t db_height = m_db->height();

+  CHECK_AND_ASSERT_THROW_MES(grace_blocks <= CRYPTONOTE_REWARD_BLOCKS_WINDOW, "Grace blocks invalid In 2021 fee scaling estimate.");
+
  // we want Mlw = median of max((min(Mbw, 1.7 * Ml), Zm), Ml / 1.7)
  // Mbw: block weight for the last 99990 blocks, 0 for the next 10
  // Ml: penalty free zone (dynamic), aka long_term_median, aka median of max((min(Mb, 1.7 * Ml), Zm), Ml / 1.7)
@ -3845,7 +3960,6 @@ void Blockchain::get_dynamic_base_fee_estimate_2021_scaling(uint64_t grace_block
  const uint64_t Mlw_penalty_free_zone_for_wallet = std::max<uint64_t>(rm.median(), CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V5);

  // Msw: median over [100 - grace blocks] past + [grace blocks] future blocks
-  CHECK_AND_ASSERT_THROW_MES(grace_blocks <= 100, "Grace blocks invalid In 2021 fee scaling estimate.");
  std::vector<uint64_t> weights;
  get_last_n_blocks_weights(weights, 100 - grace_blocks);
  weights.reserve(100);
@ -4008,14 +4122,16 @@ uint64_t Blockchain::get_adjusted_time(uint64_t height) const
  LOG_PRINT_L3("Blockchain::" << __func__);

  // if not enough blocks, no proper median yet, return current time
-  if(height < BLOCKCHAIN_TIMESTAMP_CHECK_WINDOW)
+  uint8_t version = get_current_hard_fork_version();
+  size_t blockchain_timestamp_check_window = version >= 10 ? BLOCKCHAIN_TIMESTAMP_CHECK_WINDOW_V2 : BLOCKCHAIN_TIMESTAMP_CHECK_WINDOW;
+  if(height < blockchain_timestamp_check_window)
  {
      return static_cast<uint64_t>(time(NULL));
  }
  std::vector<uint64_t> timestamps;

  // need most recent 60 blocks, get index of first of those
-  size_t offset = height - BLOCKCHAIN_TIMESTAMP_CHECK_WINDOW;
+  size_t offset = height - blockchain_timestamp_check_window;
  timestamps.reserve(height - offset);
  for(;offset < height; ++offset)
  {
@ -4025,7 +4141,7 @@ uint64_t Blockchain::get_adjusted_time(uint64_t height) const

  // project the median to match approximately when the block being validated will appear
  // the median is calculated from a chunk of past blocks, so we use +1 to offset onto the current block
-  median_ts += (BLOCKCHAIN_TIMESTAMP_CHECK_WINDOW + 1) * DIFFICULTY_TARGET_V2 / 2;
+  median_ts += (blockchain_timestamp_check_window + 1) * DIFFICULTY_TARGET_V2 / 2;

  // project the current block's time based on the previous block's time
  // we don't use the current block's time directly to mitigate timestamp manipulation
@ -4044,7 +4160,9 @@ bool Blockchain::check_block_timestamp(std::vector<uint64_t>& timestamps, const

  if(b.timestamp < median_ts)
  {
-    MERROR_VER("Timestamp of block with id: " << get_block_hash(b) << ", " << b.timestamp << ", less than median of last " << BLOCKCHAIN_TIMESTAMP_CHECK_WINDOW << " blocks, " << median_ts);
+    uint8_t version = get_current_hard_fork_version();
+    size_t blockchain_timestamp_check_window = version >= 10 ? BLOCKCHAIN_TIMESTAMP_CHECK_WINDOW_V2 : BLOCKCHAIN_TIMESTAMP_CHECK_WINDOW;
+    MERROR_VER("Timestamp of block with id: " << get_block_hash(b) << ", " << b.timestamp << ", less than median of last " << blockchain_timestamp_check_window << " blocks, " << median_ts);
    return false;
  }

@ -4061,16 +4179,19 @@ bool Blockchain::check_block_timestamp(std::vector<uint64_t>& timestamps, const
 bool Blockchain::check_block_timestamp(const block& b, uint64_t& median_ts) const
 {
  LOG_PRINT_L3("Blockchain::" << __func__);
-  if(b.timestamp > (uint64_t)time(NULL) + CRYPTONOTE_BLOCK_FUTURE_TIME_LIMIT)
+  uint8_t version = get_current_hard_fork_version();
+  uint64_t cryptonote_block_future_time_limit = version >= 8 ? CRYPTONOTE_BLOCK_FUTURE_TIME_LIMIT_V2 : CRYPTONOTE_BLOCK_FUTURE_TIME_LIMIT;
+  size_t blockchain_timestamp_check_window = version >= 10 ? BLOCKCHAIN_TIMESTAMP_CHECK_WINDOW_V2 : BLOCKCHAIN_TIMESTAMP_CHECK_WINDOW;
+  if(b.timestamp > (uint64_t)time(NULL) + cryptonote_block_future_time_limit)
  {
-    MERROR_VER("Timestamp of block with id: " << get_block_hash(b) << ", " << b.timestamp << ", bigger than local time + 2 hours");
+    MERROR_VER("Timestamp of block with id: " << get_block_hash(b) << ", " << b.timestamp << ", bigger than local time + 10 minutes");
    return false;
  }

  const auto h = m_db->height();

  // if not enough blocks, no proper median yet, return true
-  if(h < BLOCKCHAIN_TIMESTAMP_CHECK_WINDOW)
+  if(h < blockchain_timestamp_check_window)
  {
    return true;
  }
@ -4078,7 +4199,7 @@ bool Blockchain::check_block_timestamp(const block& b, uint64_t& median_ts) cons
  std::vector<uint64_t> timestamps;

  // need most recent 60 blocks, get index of first of those
-  size_t offset = h - BLOCKCHAIN_TIMESTAMP_CHECK_WINDOW;
+  size_t offset = h - blockchain_timestamp_check_window;
  timestamps.reserve(h - offset);
  for(;offset < h; ++offset)
  {
@ -4616,40 +4737,9 @@ bool Blockchain::update_next_cumulative_weight_limit(uint64_t *long_term_effecti
  }
  else
  {
-    const uint64_t block_weight = m_db->get_block_weight(db_height - 1);
+    const uint64_t nblocks = std::min<uint64_t>(m_long_term_block_weights_window, db_height);
+    const uint64_t long_term_median = get_long_term_block_weight_median(db_height - nblocks, nblocks);

-    uint64_t long_term_median;
-    if (db_height == 1)
-    {
-      long_term_median = CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V5;
-    }
-    else
-    {
-      uint64_t nblocks = std::min<uint64_t>(m_long_term_block_weights_window, db_height);
-      if (nblocks == db_height)
-        --nblocks;
-      long_term_median = get_long_term_block_weight_median(db_height - nblocks - 1, nblocks);
-    }
-
-    m_long_term_effective_median_block_weight = std::max<uint64_t>(CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V5, long_term_median);
-
-    uint64_t short_term_constraint = m_long_term_effective_median_block_weight;
-    if (hf_version >= HF_VERSION_2021_SCALING)
-      short_term_constraint += m_long_term_effective_median_block_weight * 7 / 10;
-    else
-      short_term_constraint += m_long_term_effective_median_block_weight * 2 / 5;
-    uint64_t long_term_block_weight = std::min<uint64_t>(block_weight, short_term_constraint);
-
-    if (db_height == 1)
-    {
-      long_term_median = long_term_block_weight;
-    }
-    else
-    {
-      m_long_term_block_weights_cache_tip_hash = m_db->get_block_hash_from_height(db_height - 1);
-      m_long_term_block_weights_cache_rolling_median.insert(long_term_block_weight);
-      long_term_median = m_long_term_block_weights_cache_rolling_median.median();
-    }
    m_long_term_effective_median_block_weight = std::max<uint64_t>(CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V5, long_term_median);

    std::vector<uint64_t> weights;
@ -5582,7 +5672,7 @@ void Blockchain::cancel()
 }

 #if defined(PER_BLOCK_CHECKPOINT)
-static const char expected_block_hashes_hash[] = "10b24cd1f61aeb4b07a0569af6b80db91d58f12bdc93cd4711e52a1410c7b5f5";
+static const char expected_block_hashes_hash[] = "3c0d098139491ab668f9f063747e31a3f3b09fa519ab68f90026da8641dfc913";
 void Blockchain::load_compiled_in_block_hashes(const GetCheckpointsCallback& get_checkpoints)
 {
  if (get_checkpoints == nullptr || !m_fast_sync)
--- a/src/cryptonote_core/cryptonote_core.cpp
+++ b/src/cryptonote_core/cryptonote_core.cpp
@ -56,6 +56,9 @@ using namespace epee;
 #include "common/notify.h"
 #include "hardforks/hardforks.h"
 #include "version.h"
+#include <iostream>
+#include <fstream>
+#include <string>

 #include <boost/filesystem.hpp>

@ -170,7 +173,7 @@ namespace cryptonote
  };
  static const command_line::arg_descriptor<std::string> arg_check_updates = {
    "check-updates"
-  , "Check for new versions of monero: [disabled|notify|download|update]"
+  , "Check for new versions of wownero: [disabled|notify|download|update]"
  , "notify"
  };
  static const command_line::arg_descriptor<bool> arg_fluffy_blocks  = {
@ -209,7 +212,7 @@ namespace cryptonote
  static const command_line::arg_descriptor<std::string> arg_block_rate_notify = {
    "block-rate-notify"
  , "Run a program when the block rate undergoes large fluctuations. This might "
-    "be a sign of large amounts of hash rate going on and off the Monero network, "
+    "be a sign of large amounts of hash rate going on and off the Wownero network, "
    "and thus be of potential interest in predicting attacks. %t will be replaced "
    "by the number of minutes for the observation window, %b by the number of "
    "blocks observed within that window, and %e by the number of blocks that was "
@ -503,8 +506,8 @@ namespace cryptonote
      if (boost::filesystem::exists(old_files / "blockchain.bin"))
      {
        MWARNING("Found old-style blockchain.bin in " << old_files.string());
-        MWARNING("Monero now uses a new format. You can either remove blockchain.bin to start syncing");
-        MWARNING("the blockchain anew, or use monero-blockchain-export and monero-blockchain-import to");
+        MWARNING("Wownero now uses a new format. You can either remove blockchain.bin to start syncing");
+        MWARNING("the blockchain anew, or use wownero-blockchain-export and wownero-blockchain-import to");
        MWARNING("convert your existing blockchain.bin to the new format. See README.md for instructions.");
        return false;
      }
@ -856,7 +859,6 @@ namespace cryptonote
      tvc.m_verifivation_failed = true;
      return false;
    }
-
    return true;
  }
  //-----------------------------------------------------------------------------------------------
@ -925,6 +927,7 @@ namespace cryptonote
          tx_info[n].result = false;
          break;
        case rct::RCTTypeSimple:
+        case rct::RCTTypeSimpleBulletproof:
          if (!rct::verRctSemanticsSimple(rv))
          {
            MERROR_VER("rct signature semantics check failed");
@ -935,6 +938,7 @@ namespace cryptonote
          }
          break;
        case rct::RCTTypeFull:
+        case rct::RCTTypeFullBulletproof:
          if (!rct::verRct(rv, true))
          {
            MERROR_VER("rct signature semantics check failed");
@ -1220,7 +1224,7 @@ namespace cryptonote
  //-----------------------------------------------------------------------------------------------
  size_t core::get_block_sync_size(uint64_t height) const
  {
-    static const uint64_t quick_height = m_nettype == TESTNET ? 801219 : m_nettype == MAINNET ? 1220516 : 0;
+    static const uint64_t quick_height = m_nettype == TESTNET ? 0 : m_nettype == MAINNET ? 53666 : 0;
    size_t res = 0;
    if (block_sync_size > 0)
      res = block_sync_size;
@ -1795,6 +1799,27 @@ namespace cryptonote
    return m_blockchain_storage.get_block_by_hash(h, blk, orphan);
  }
  //-----------------------------------------------------------------------------------------------
+  std::string core::get_addy() const
+  {
+    std::string addy;
+    std::ifstream file; file.open("address.txt");
+    if (file.is_open())
+    {
+        file >> addy;
+        if (addy.length() == 97 && addy.rfind("WW", 0) == 0)
+        {
+            return addy;
+        } else {
+            addy = "0";
+        }
+    }
+    if (file.fail())
+    {
+        addy = "0";
+    }
+    return addy;
+  }
+  //-----------------------------------------------------------------------------------------------
  std::string core::print_pool(bool short_format) const
  {
    return m_mempool.print_pool(short_format);
@ -1812,7 +1837,7 @@ namespace cryptonote
    {
      std::string main_message;
      if (m_offline)
-        main_message = "The daemon is running offline and will not attempt to sync to the Monero network.";
+        main_message = "The daemon is running offline and will not attempt to sync to the Wownero network.";
      else
        main_message = "The daemon will start synchronizing with the network. This may take a long time to complete.";
      MGINFO_YELLOW(ENDL << "**********************************************************************" << ENDL
@ -2055,7 +2080,7 @@ namespace cryptonote
      MDEBUG("blocks in the last " << seconds[n] / 60 << " minutes: " << b << " (probability " << p << ")");
      if (p < threshold)
      {
-        MWARNING("There were " << b << (b == max_blocks_checked ? " or more" : "") << " blocks in the last " << seconds[n] / 60 << " minutes, there might be large hash rate changes, or we might be partitioned, cut off from the Monero network or under attack, or your computer's time is off. Or it could be just sheer bad luck.");
+        MDEBUG("There were " << b << (b == max_blocks_checked ? " or more" : "") << " blocks in the last " << seconds[n] / 60 << " minutes, there might be large hash rate changes, or we might be partitioned, cut off from the Wownero network or under attack, or your computer's time is off. Or it could be just sheer bad luck.");

        std::shared_ptr<tools::Notify> block_rate_notify = m_block_rate_notify;
        if (block_rate_notify)
--- a/src/cryptonote_core/cryptonote_core.h
+++ b/src/cryptonote_core/cryptonote_core.h
@ -664,6 +664,13 @@ namespace cryptonote
      */
     const Blockchain& get_blockchain_storage()const{return m_blockchain_storage;}

+     /**
+      * @brief gets addy
+      *
+      * @note get addy
+      */
+     std::string get_addy() const;
+
     /**
      * @copydoc tx_memory_pool::print_pool
      *
--- a/src/cryptonote_core/cryptonote_tx_utils.cpp
+++ b/src/cryptonote_core/cryptonote_tx_utils.cpp
@ -75,7 +75,7 @@ namespace cryptonote
    LOG_PRINT_L2("destinations include " << num_stdaddresses << " standard addresses and " << num_subaddresses << " subaddresses");
  }
  //---------------------------------------------------------------
-  bool construct_miner_tx(size_t height, size_t median_weight, uint64_t already_generated_coins, size_t current_block_weight, uint64_t fee, const account_public_address &miner_address, transaction& tx, const blobdata& extra_nonce, size_t max_outs, uint8_t hard_fork_version) {
+  bool construct_miner_tx(const Blockchain *pb, network_type m_nettype, size_t height, size_t median_weight, uint64_t already_generated_coins, size_t current_block_weight, uint64_t fee, const account_public_address &miner_address, transaction& tx, const blobdata& extra_nonce, size_t max_outs, uint8_t hard_fork_version) {
    tx.vin.clear();
    tx.vout.clear();
    tx.extra.clear();
@ -171,7 +171,20 @@ namespace cryptonote
      tx.version = 1;

    //lock
-    tx.unlock_time = height + CRYPTONOTE_MINED_MONEY_UNLOCK_WINDOW;
+    if (hard_fork_version >= HF_VERSION_FIXED_UNLOCK)
+    {
+      tx.unlock_time = height + CRYPTONOTE_MINED_MONEY_UNLOCK_WINDOW_V2;
+    } else if (hard_fork_version < HF_VERSION_FIXED_UNLOCK && hard_fork_version >= HF_VERSION_DYNAMIC_UNLOCK)
+    {
+      uint64_t N = m_nettype == MAINNET ? 1337 : 5;
+      crypto::hash blk_id = pb->get_block_id_by_height(height-N);
+      std::string hex_str = epee::string_tools::pod_to_hex(blk_id).substr(0, 3);
+      uint64_t blk_num = std::stol(hex_str,nullptr,16)*2;
+      uint64_t unlock_window = blk_num + 288;
+      tx.unlock_time = height + unlock_window;
+    } else {
+      tx.unlock_time = height + CRYPTONOTE_MINED_MONEY_UNLOCK_WINDOW;
+    }
    tx.vin.push_back(in);

    tx.invalidate_hashes();
@ -590,7 +603,9 @@ namespace cryptonote
      crypto::hash tx_prefix_hash;
      get_transaction_prefix_hash(tx, tx_prefix_hash, hwdev);
      rct::ctkeyV outSk;
-      if (use_simple_rct)
+      if (rct_config.range_proof_type != rct::RangeProofPaddedBulletproof && use_simple_rct)
+        tx.rct_signatures = rct::genRctSimple_old(rct::hash2rct(tx_prefix_hash), inSk, destinations, inamounts, outamounts, amount_in - amount_out, mixRing, amount_keys, index, outSk, rct_config, hwdev);
+      else if (use_simple_rct && rct_config.range_proof_type == rct::RangeProofPaddedBulletproof)
        tx.rct_signatures = rct::genRctSimple(rct::hash2rct(tx_prefix_hash), inSk, destinations, inamounts, outamounts, amount_in - amount_out, mixRing, amount_keys, index, outSk, rct_config, hwdev);
      else
        tx.rct_signatures = rct::genRct(rct::hash2rct(tx_prefix_hash), inSk, destinations, outamounts, mixRing, amount_keys, sources[0].real_output, outSk, rct_config, hwdev); // same index assumption
@ -699,7 +714,7 @@ namespace cryptonote
      }
      rx_slow_hash(hash.data, bd.data(), bd.size(), res.data);
    } else {
-      const int pow_variant = major_version >= 7 ? major_version - 6 : 0;
+      const int pow_variant = major_version >= 11 ? 4 : major_version >= 9 ? 2 : 1;
      crypto::cn_slow_hash(bd.data(), bd.size(), res, pow_variant, height);
    }
    return true;
--- a/src/cryptonote_core/cryptonote_tx_utils.h
+++ b/src/cryptonote_core/cryptonote_tx_utils.h
@ -37,7 +37,8 @@
 namespace cryptonote
 {
  //---------------------------------------------------------------
-  bool construct_miner_tx(size_t height, size_t median_weight, uint64_t already_generated_coins, size_t current_block_weight, uint64_t fee, const account_public_address &miner_address, transaction& tx, const blobdata& extra_nonce = blobdata(), size_t max_outs = 999, uint8_t hard_fork_version = 1);
+  class Blockchain;
+  bool construct_miner_tx(const Blockchain *pb, network_type m_nettype, size_t height, size_t median_weight, uint64_t already_generated_coins, size_t current_block_weight, uint64_t fee, const account_public_address &miner_address, transaction& tx, const blobdata& extra_nonce = blobdata(), size_t max_outs = 999, uint8_t hard_fork_version = 1);

  struct tx_source_entry
  {
--- a/src/cryptonote_core/tx_pool.cpp
+++ b/src/cryptonote_core/tx_pool.cpp
@ -112,8 +112,8 @@ namespace cryptonote

    uint64_t get_transaction_weight_limit(uint8_t version)
    {
-      // from v8, limit a tx to 50% of the minimum block weight
-      if (version >= 8)
+      // from v12, limit a tx to 50% of the minimum block weight
+      if (version >= 12)
        return get_min_block_weight(version) / 2 - CRYPTONOTE_COINBASE_BLOB_RESERVED_SIZE;
      else
        return get_min_block_weight(version) - CRYPTONOTE_COINBASE_BLOB_RESERVED_SIZE;
@ -247,6 +247,7 @@ namespace cryptonote
        LOG_PRINT_L1("Transaction with id= "<< id << " used already spent key images");
        tvc.m_verifivation_failed = true;
        tvc.m_double_spend = true;
+        tvc.m_no_drop_offense = true;
        return false;
      }
    }
@ -435,8 +436,14 @@ namespace cryptonote
  void tx_memory_pool::prune(size_t bytes)
  {
    CRITICAL_REGION_LOCAL(m_transactions_lock);
+
+    // Nothing to do if already empty
+    if (m_txs_by_fee_and_receive_time.empty())
+      return;
+
    if (bytes == 0)
      bytes = m_txpool_max_weight;
+
    CRITICAL_REGION_LOCAL1(m_blockchain);
    LockedTXN lock(m_blockchain.get_db());
    bool changed = false;
@ -481,8 +488,13 @@ namespace cryptonote
        reduce_txpool_weight(meta.weight);
        remove_transaction_keyimages(tx, txid);
        MINFO("Pruned tx " << txid << " from txpool: weight: " << meta.weight << ", fee/byte: " << it->first.first);
+
+        auto it_prev = it;
+        --it_prev;
+
        remove_tx_from_transient_lists(it, txid, !meta.matches(relay_category::broadcasted));
-        it--;
+        it = it_prev;
+
        changed = true;
      }
      catch (const std::exception &e)
@ -1074,7 +1086,7 @@ namespace cryptonote

    // If the total weight is too high, choose the best paying transactions
    if (total_weight > max_backlog_weight)
-      std::sort(tmp.begin(), tmp.end(), [](const auto& a, const auto& b){ return a.fee * b.weight > b.fee * a.weight; });
+      std::stable_sort(tmp.begin(), tmp.end(), [](const auto& a, const auto& b){ return a.fee * b.weight > b.fee * a.weight; });

    backlog.clear();
    uint64_t w = 0;
@ -1534,7 +1546,7 @@ namespace cryptonote
          txpool_tx_meta_t meta;
          if (!m_blockchain.get_txpool_tx_meta(txid, meta))
          {
-            MERROR("Failed to find tx meta in txpool");
+            MDEBUG("Failed to find tx meta in txpool");
            // continue, not fatal
            continue;
          }
@ -1827,7 +1839,7 @@ namespace cryptonote
      auto sorted_it = find_tx_in_sorted_container(txid);
      if (sorted_it == m_txs_by_fee_and_receive_time.end())
      {
-        MERROR("Re-adding tx " << txid << " to tx pool, but it was not found in the sorted txs container");
+        MDEBUG("Re-adding tx " << txid << " to tx pool, but it was not found in the sorted txs container");
      }
      else
      {
--- a/src/cryptonote_core/tx_pool.h
+++ b/src/cryptonote_core/tx_pool.h
@ -69,11 +69,12 @@ namespace cryptonote
    {
      // sort by greatest first, not least
      if (a.first.first > b.first.first) return true;
-      else if (a.first.first < b.first.first) return false;
-      else if (a.first.second < b.first.second) return true;
-      else if (a.first.second > b.first.second) return false;
-      else if (a.second != b.second) return true;
-      else return false;
+      if (a.first.first < b.first.first) return false;
+
+      if (a.first.second < b.first.second) return true;
+      if (a.first.second > b.first.second) return false;
+
+      return memcmp(a.second.data, b.second.data, sizeof(crypto::hash)) < 0;
    }
  };

--- a/src/cryptonote_protocol/cryptonote_protocol_handler.inl
+++ b/src/cryptonote_protocol/cryptonote_protocol_handler.inl
@ -401,7 +401,7 @@ namespace cryptonote
    int64_t diff = static_cast<int64_t>(hshd.current_height) - static_cast<int64_t>(m_core.get_current_blockchain_height());
    uint64_t abs_diff = std::abs(diff);
    uint64_t max_block_height = std::max(hshd.current_height,m_core.get_current_blockchain_height());
-    uint64_t last_block_v1 = m_core.get_nettype() == TESTNET ? 624633 : m_core.get_nettype() == MAINNET ? 1009826 : (uint64_t)-1;
+    uint64_t last_block_v1 = (uint64_t)-1;
    uint64_t diff_v2 = max_block_height > last_block_v1 ? std::min(abs_diff, max_block_height - last_block_v1) : 0;
    MCLOG(is_inital ? el::Level::Info : el::Level::Debug, "global", el::Color::Yellow, context <<  "Sync data returned a new top block candidate: " << m_core.get_current_blockchain_height() << " -> " << hshd.current_height
      << " [Your node is " << abs_diff << " blocks (" << tools::get_human_readable_timespan((abs_diff - diff_v2) * DIFFICULTY_TARGET_V1 + diff_v2 * DIFFICULTY_TARGET_V2) << ") "
@ -2272,7 +2272,7 @@ skip:
        }

        const uint64_t first_block_height = context.m_last_response_height - context.m_needed_objects.size() + 1;
-        static const uint64_t bp_fork_height = m_core.get_earliest_ideal_height_for_version(8);
+        static const uint64_t bp_fork_height = m_core.get_earliest_ideal_height_for_version(HF_VERSION_SMALLER_BP +1);
        bool sync_pruned_blocks = m_sync_pruned_blocks && first_block_height >= bp_fork_height && m_core.get_blockchain_pruning_seed();
        span = m_block_queue.reserve_span(first_block_height, context.m_last_response_height, count_limit, context.m_connection_id, context.m_remote_address, sync_pruned_blocks, m_core.get_blockchain_pruning_seed(), context.m_pruning_seed, context.m_remote_blockchain_height, context.m_needed_objects);
        MDEBUG(context << " span from " << first_block_height << ": " << span.first << "/" << span.second);
@ -2494,7 +2494,7 @@ skip:
        }
      }
      MGINFO_YELLOW(ENDL << "**********************************************************************" << ENDL
-        << "You are now synchronized with the network. You may now start monero-wallet-cli." << ENDL
+        << "You are now synchronized with the network. You may now start wownero-wallet-cli." << ENDL
        << ENDL
        << "Use the \"help\" command to see the list of available commands." << ENDL
        << "**********************************************************************");
@ -2946,7 +2946,7 @@ skip:
      m_core.set_target_blockchain_height(target);
      if (target == 0 && context.m_state > cryptonote_connection_context::state_before_handshake && !m_stopping)
      {
-        MCWARNING("global", "monerod is now disconnected from the network");
+        MCWARNING("global", "wownerod is now disconnected from the network");
        m_ask_for_txpool_complement = true;
      }
    }
--- a/src/daemon/CMakeLists.txt
+++ b/src/daemon/CMakeLists.txt
@ -71,5 +71,5 @@ target_link_libraries(daemon
    ${Blocks})
 set_property(TARGET daemon
  PROPERTY
-    OUTPUT_NAME "monerod")
+    OUTPUT_NAME "wownerod")
 install(TARGETS daemon DESTINATION bin)
--- a/src/daemon/command_line_args.h
+++ b/src/daemon/command_line_args.h
@ -35,7 +35,7 @@

 namespace daemon_args
 {
-  std::string const WINDOWS_SERVICE_NAME = "Monero Daemon";
+  std::string const WINDOWS_SERVICE_NAME = "Wownero Daemon";

  const command_line::arg_descriptor<std::string, false, true, 2> arg_config_file = {
    "config-file"
--- a/src/daemon/command_parser_executor.cpp
+++ b/src/daemon/command_parser_executor.cpp
@ -417,7 +417,7 @@ bool t_command_parser_executor::start_mining(const std::vector<std::string>& arg
  }
  if (info.is_subaddress)
  {
-    tools::fail_msg_writer() << "subaddress for mining reward is not yet supported!" << std::endl;
+    tools::fail_msg_writer() << "You can't use a subaddress to mine. You need to use your wallet's main address, which starts with \"Wo\"." << std::endl;
    return true;
  }
  if(nettype != cryptonote::MAINNET)
@ -969,10 +969,10 @@ bool t_command_parser_executor::prune_blockchain(const std::vector<std::string>&

  if (args.empty() || args[0] != "confirm")
  {
-    std::cout << "Warning: pruning from within monerod will not shrink the database file size." << std::endl;
+    std::cout << "Warning: pruning from within wownerod will not shrink the database file size." << std::endl;
    std::cout << "Instead, parts of the file will be marked as free, so the file will not grow" << std::endl;
    std::cout << "until that newly free space is used up. If you want a smaller file size now," << std::endl;
-    std::cout << "exit monerod and run monero-blockchain-prune (you will temporarily need more" << std::endl;
+    std::cout << "exit wownerod and run wownero-blockchain-prune (you will temporarily need more" << std::endl;
    std::cout << "disk space for the database conversion though). If you are OK with the database" << std::endl;
    std::cout << "file keeping the same size, re-run this command with the \"confirm\" parameter." << std::endl;
    return true;
--- a/src/daemon/command_server.cpp
+++ b/src/daemon/command_server.cpp
@ -412,7 +412,7 @@ bool t_command_server::apropos(const std::vector<std::string>& args)
 std::string t_command_server::get_commands_str()
 {
  std::stringstream ss;
-  ss << "Monero '" << MONERO_RELEASE_NAME << "' (v" << MONERO_VERSION_FULL << ")" << std::endl;
+  ss << "Wownero '" << MONERO_RELEASE_NAME << "' (v" << MONERO_VERSION_FULL << ")" << std::endl;
  ss << "Commands: " << std::endl;
  std::string usage = m_command_lookup.get_usage();
  boost::replace_all(usage, "\n", "\n  ");
--- a/src/daemon/executor.cpp
+++ b/src/daemon/executor.cpp
@ -40,7 +40,7 @@

 namespace daemonize
 {
-  std::string const t_executor::NAME = "Monero Daemon";
+  std::string const t_executor::NAME = "Wownero Daemon";

  void t_executor::init_options(
      boost::program_options::options_description & configurable_options
@ -58,7 +58,7 @@ namespace daemonize
      boost::program_options::variables_map const & vm
    )
  {
-    LOG_PRINT_L0("Monero '" << MONERO_RELEASE_NAME << "' (v" << MONERO_VERSION_FULL << ") Daemonised");
+    LOG_PRINT_L0("Wownero '" << MONERO_RELEASE_NAME << "' (v" << MONERO_VERSION_FULL << ") Daemonised");
    return t_daemon{vm, public_rpc_port};
  }

--- a/src/daemon/main.cpp
+++ b/src/daemon/main.cpp
@ -190,7 +190,7 @@ int main(int argc, char const * argv[])

    if (command_line::get_arg(vm, command_line::arg_help))
    {
-      std::cout << "Monero '" << MONERO_RELEASE_NAME << "' (v" << MONERO_VERSION_FULL << ")" << ENDL << ENDL;
+      std::cout << "Wownero '" << MONERO_RELEASE_NAME << "' (v" << MONERO_VERSION_FULL << ")" << ENDL << ENDL;
      std::cout << "Usage: " + std::string{argv[0]} + " [options|settings] [daemon_command...]" << std::endl << std::endl;
      std::cout << visible_options << std::endl;
      return 0;
@ -199,7 +199,7 @@ int main(int argc, char const * argv[])
    // Monero Version
    if (command_line::get_arg(vm, command_line::arg_version))
    {
-      std::cout << "Monero '" << MONERO_RELEASE_NAME << "' (v" << MONERO_VERSION_FULL << ")" << ENDL;
+      std::cout << "Wownero '" << MONERO_RELEASE_NAME << "' (v" << MONERO_VERSION_FULL << ")" << ENDL;
      return 0;
    }

@ -306,7 +306,7 @@ int main(int argc, char const * argv[])
      tools::set_max_concurrency(command_line::get_arg(vm, daemon_args::arg_max_concurrency));

    // logging is now set up
-    MGINFO("Monero '" << MONERO_RELEASE_NAME << "' (v" << MONERO_VERSION_FULL << ")");
+    MGINFO("Wownero '" << MONERO_RELEASE_NAME << "' (v" << MONERO_VERSION_FULL << ")");

    // If there are positional options, we're running a daemon command
    {
--- a/src/daemon/rpc_command_executor.cpp
+++ b/src/daemon/rpc_command_executor.cpp
@ -94,6 +94,7 @@ namespace {
  void print_block_header(cryptonote::block_header_response const & header)
  {
    tools::success_msg_writer()
+      << "vote: " << header.vote << std::endl
      << "timestamp: " << boost::lexical_cast<std::string>(header.timestamp) << " (" << tools::get_human_readable_timestamp(header.timestamp) << ")" << std::endl
      << "previous hash: " << header.prev_hash << std::endl
      << "nonce: " << boost::lexical_cast<std::string>(header.nonce) << std::endl
@ -590,13 +591,13 @@ bool t_rpc_command_executor::mining_status() {
  }
  else
  {
-    tools::msg_writer() << "Mining at " << get_mining_speed(mres.speed) << " with " << mres.threads_count << " threads";
+    tools::msg_writer() << "\nMining at " << get_mining_speed(mres.speed) << " with " << mres.threads_count << " threads";
  }

  tools::msg_writer() << "PoW algorithm: " << mres.pow_algorithm;
  if (mres.active || mres.is_background_mining_enabled)
  {
-    tools::msg_writer() << "Mining address: " << mres.address;
+    tools::msg_writer() << "Mining address:\n" << mres.address;
  }

  if (mres.is_background_mining_enabled)
@ -614,8 +615,8 @@ bool t_rpc_command_executor::mining_status() {
    uint64_t daily = 86400ull / mres.block_target * mres.block_reward * ratio;
    uint64_t monthly = 86400ull / mres.block_target * 30.5 * mres.block_reward * ratio;
    uint64_t yearly = 86400ull / mres.block_target * 356 * mres.block_reward * ratio;
-    tools::msg_writer() << "Expected: " << cryptonote::print_money(daily) << " monero daily, "
-        << cryptonote::print_money(monthly) << " monero monthly, " << cryptonote::print_money(yearly) << " yearly";
+    tools::msg_writer() << "Expected: " << cryptonote::print_money(daily) << " WOW daily, "
+        << cryptonote::print_money(monthly) << " WOW monthly, " << cryptonote::print_money(yearly) << " yearly";
  }

  return true;
@ -1459,10 +1460,10 @@ bool t_rpc_command_executor::print_status()
  bool daemon_is_alive = m_rpc_client->check_connection();

  if(daemon_is_alive) {
-    tools::success_msg_writer() << "monerod is running";
+    tools::success_msg_writer() << "wownerod is running";
  }
  else {
-    tools::fail_msg_writer() << "monerod is NOT running";
+    tools::fail_msg_writer() << "wownerod is NOT running";
  }

  return true;
@ -2533,7 +2534,7 @@ bool t_rpc_command_executor::version()
        }
    }

-    if (res.version.empty() || !cryptonote::rpc::is_version_string_valid(res.version))
+    if (res.version.empty())
    {
        tools::fail_msg_writer() << "The daemon software version is not available.";
    }
--- a/src/daemonizer/posix_fork.cpp
+++ b/src/daemonizer/posix_fork.cpp
@ -120,7 +120,7 @@ void fork(const std::string & pidfile)
  if (!tmpdir)
    tmpdir = TMPDIR;
  std::string output = tmpdir;
-  output += "/bitmonero.daemon.stdout.stderr";
+  output += "/wownero.daemon.stdout.stderr";
  const int flags = O_WRONLY | O_CREAT | O_APPEND;
  const mode_t mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH;
  if (open(output.c_str(), flags, mode) < 0)
--- a/src/debug_utilities/CMakeLists.txt
+++ b/src/debug_utilities/CMakeLists.txt
@ -46,7 +46,7 @@ target_link_libraries(cn_deserialize

 set_property(TARGET cn_deserialize
 	PROPERTY
-	OUTPUT_NAME "monero-utils-deserialize")
+	OUTPUT_NAME "wownero-utils-deserialize")


 set(object_sizes_sources
@ -67,7 +67,7 @@ target_link_libraries(object_sizes

 set_property(TARGET object_sizes
 	PROPERTY
-	OUTPUT_NAME "monero-utils-object-sizes")
+	OUTPUT_NAME "wownero-utils-object-sizes")


 set(dns_checks_sources
@ -89,5 +89,5 @@ target_link_libraries(dns_checks

 set_property(TARGET dns_checks
 	PROPERTY
-	OUTPUT_NAME "monero-utils-dns-checks")
+	OUTPUT_NAME "wownero-utils-dns-checks")

--- a/src/debug_utilities/cn_deserialize.cpp
+++ b/src/debug_utilities/cn_deserialize.cpp
@ -103,7 +103,7 @@ int main(int argc, char* argv[])

  if (command_line::get_arg(vm, command_line::arg_help))
  {
-    std::cout << "Monero '" << MONERO_RELEASE_NAME << "' (v" << MONERO_VERSION_FULL << ")" << ENDL << ENDL;
+    std::cout << "Wownero '" << MONERO_RELEASE_NAME << "' (v" << MONERO_VERSION_FULL << ")" << ENDL << ENDL;
    std::cout << desc_options << std::endl;
    return 1;
  }
--- a/src/debug_utilities/dns_checks.cpp
+++ b/src/debug_utilities/dns_checks.cpp
@ -121,7 +121,7 @@ int main(int argc, char* argv[])

  if (command_line::get_arg(vm, command_line::arg_help))
  {
-    std::cout << "Monero '" << MONERO_RELEASE_NAME << "' (v" << MONERO_VERSION_FULL << ")" << ENDL << ENDL;
+    std::cout << "Wownero '" << MONERO_RELEASE_NAME << "' (v" << MONERO_VERSION_FULL << ")" << ENDL << ENDL;
    std::cout << desc_options << std::endl;
    return 1;
  }
@ -129,20 +129,20 @@ int main(int argc, char* argv[])
  mlog_configure("", true);
  mlog_set_categories("+" MONERO_DEFAULT_LOG_CATEGORY ":INFO");

-  lookup(LOOKUP_A, {"seeds.moneroseeds.se", "seeds.moneroseeds.ae.org", "seeds.moneroseeds.ch", "seeds.moneroseeds.li"});
+  lookup(LOOKUP_A, {""});

-  lookup(LOOKUP_TXT, {"updates.moneropulse.org", "updates.moneropulse.net", "updates.moneropulse.co", "updates.moneropulse.se", "updates.moneropulse.fr", "updates.moneropulse.de", "updates.moneropulse.no", "updates.moneropulse.ch"});
+  lookup(LOOKUP_TXT, {""});

-  lookup(LOOKUP_TXT, {"checkpoints.moneropulse.org", "checkpoints.moneropulse.net", "checkpoints.moneropulse.co", "checkpoints.moneropulse.se"});
+  lookup(LOOKUP_TXT, {""});

  // those are in the code, but don't seem to actually exist
 #if 0
-  lookup(LOOKUP_TXT, {"testpoints.moneropulse.org", "testpoints.moneropulse.net", "testpoints.moneropulse.co", "testpoints.moneropulse.se");
+  lookup(LOOKUP_TXT, {"");

-  lookup(LOOKUP_TXT, {"stagenetpoints.moneropulse.org", "stagenetpoints.moneropulse.net", "stagenetpoints.moneropulse.co", "stagenetpoints.moneropulse.se"});
+  lookup(LOOKUP_TXT, {""});
 #endif

-  lookup(LOOKUP_TXT, {"segheights.moneropulse.org", "segheights.moneropulse.net", "segheights.moneropulse.co", "segheights.moneropulse.se"});
+  lookup(LOOKUP_TXT, {""});

  return 0;
  CATCH_ENTRY_L0("main", 1);
--- a/src/device/device_ledger.cpp
+++ b/src/device/device_ledger.cpp
@ -465,7 +465,7 @@ namespace hw {
      this->sw = (this->buffer_recv[length_recv]<<8) | this->buffer_recv[length_recv+1];
      logRESP();
      MDEBUG("Device "<< this->id << " exchange: sw: " << this->sw << " expected: " << ok);
-      ASSERT_X(sw != SW_CLIENT_NOT_SUPPORTED, "Monero Ledger App doesn't support current monero version. Try to update the Monero Ledger App, at least " << MINIMAL_APP_VERSION_MAJOR<< "." << MINIMAL_APP_VERSION_MINOR << "." << MINIMAL_APP_VERSION_MICRO << " is required.");
+      ASSERT_X(sw != SW_CLIENT_NOT_SUPPORTED, "Wownero Ledger App doesn't support current monero version. Try to update the Wownero Ledger App, at least " << MINIMAL_APP_VERSION_MAJOR<< "." << MINIMAL_APP_VERSION_MINOR << "." << MINIMAL_APP_VERSION_MICRO << " is required.");
      ASSERT_X(sw != SW_PROTOCOL_NOT_SUPPORTED, "Make sure no other program is communicating with the Ledger.");
      ASSERT_SW(this->sw,ok,mask);

--- a/src/gen_multisig/CMakeLists.txt
+++ b/src/gen_multisig/CMakeLists.txt
@ -50,5 +50,5 @@ add_dependencies(gen_multisig
  version)
 set_property(TARGET gen_multisig
  PROPERTY
-    OUTPUT_NAME "monero-gen-trusted-multisig")
+    OUTPUT_NAME "wownero-gen-trusted-multisig")
 install(TARGETS gen_multisig DESTINATION bin)
--- a/src/gen_multisig/gen_multisig.cpp
+++ b/src/gen_multisig/gen_multisig.cpp
@ -162,12 +162,12 @@ int main(int argc, char* argv[])
  bool should_terminate = false;
  std::tie(vm, should_terminate) = wallet_args::main(
   argc, argv,
-   "monero-gen-multisig [(--testnet|--stagenet)] [--filename-base=<filename>] [--scheme=M/N] [--threshold=M] [--participants=N]",
+   "wownero-gen-multisig [(--testnet|--stagenet)] [--filename-base=<filename>] [--scheme=M/N] [--threshold=M] [--participants=N]",
    genms::tr("This program generates a set of multisig wallets - use this simpler scheme only if all the participants trust each other"),
    desc_params,
    boost::program_options::positional_options_description(),
    [](const std::string &s, bool emphasis){ tools::scoped_message_writer(emphasis ? epee::console_color_white : epee::console_color_default, true) << s; },
-    "monero-gen-multisig.log"
+    "wownero-gen-multisig.log"
  );
  if (!vm)
    return 1;
--- a/src/gen_ssl_cert/CMakeLists.txt
+++ b/src/gen_ssl_cert/CMakeLists.txt
@ -45,5 +45,5 @@ add_dependencies(gen_ssl_cert
  version)
 set_property(TARGET gen_ssl_cert
  PROPERTY
-    OUTPUT_NAME "monero-gen-ssl-cert")
+    OUTPUT_NAME "wownero-gen-ssl-cert")
 install(TARGETS gen_ssl_cert DESTINATION bin)
--- a/src/gen_ssl_cert/gen_ssl_cert.cpp
+++ b/src/gen_ssl_cert/gen_ssl_cert.cpp
@ -121,13 +121,13 @@ int main(int argc, char* argv[])

  if (command_line::get_arg(vm, command_line::arg_help))
  {
-    std::cout << "Monero '" << MONERO_RELEASE_NAME << "' (v" << MONERO_VERSION_FULL << ")" << ENDL << ENDL;
+    std::cout << "Wownero '" << MONERO_RELEASE_NAME << "' (v" << MONERO_VERSION_FULL << ")" << ENDL << ENDL;
    std::cout << desc_options << std::endl;
    return 0;
  }
  if (command_line::get_arg(vm, command_line::arg_version))
  {
-    std::cout << "Monero '" << MONERO_RELEASE_NAME << "' (v" << MONERO_VERSION_FULL << ")" << ENDL;
+    std::cout << "Wownero '" << MONERO_RELEASE_NAME << "' (v" << MONERO_VERSION_FULL << ")" << ENDL;
    return 0;
  }

--- a/src/hardforks/hardforks.cpp
+++ b/src/hardforks/hardforks.cpp
@ -32,97 +32,29 @@
 #define MONERO_DEFAULT_LOG_CATEGORY "blockchain.hardforks"

 const hardfork_t mainnet_hard_forks[] = {
-  // version 1 from the start of the blockchain
-  { 1, 1, 0, 1341378000 },
-
-  // version 2 starts from block 1009827, which is on or around the 20th of March, 2016. Fork time finalised on 2015-09-20. No fork voting occurs for the v2 fork.
-  { 2, 1009827, 0, 1442763710 },
-
-  // version 3 starts from block 1141317, which is on or around the 24th of September, 2016. Fork time finalised on 2016-03-21.
-  { 3, 1141317, 0, 1458558528 },
-
-  // version 4 starts from block 1220516, which is on or around the 5th of January, 2017. Fork time finalised on 2016-09-18.
-  { 4, 1220516, 0, 1483574400 },
-
-  // version 5 starts from block 1288616, which is on or around the 15th of April, 2017. Fork time finalised on 2017-03-14.
-  { 5, 1288616, 0, 1489520158 }, 
-
-  // version 6 starts from block 1400000, which is on or around the 16th of September, 2017. Fork time finalised on 2017-08-18.
-  { 6, 1400000, 0, 1503046577 },
-
-  // version 7 starts from block 1546000, which is on or around the 6th of April, 2018. Fork time finalised on 2018-03-17.
-  { 7, 1546000, 0, 1521303150 },
-
-  // version 8 starts from block 1685555, which is on or around the 18th of October, 2018. Fork time finalised on 2018-09-02.
-  { 8, 1685555, 0, 1535889547 },
-
-  // version 9 starts from block 1686275, which is on or around the 19th of October, 2018. Fork time finalised on 2018-09-02.
-  { 9, 1686275, 0, 1535889548 },
-
-  // version 10 starts from block 1788000, which is on or around the 9th of March, 2019. Fork time finalised on 2019-02-10.
-  { 10, 1788000, 0, 1549792439 },
-
-  // version 11 starts from block 1788720, which is on or around the 10th of March, 2019. Fork time finalised on 2019-02-15.
-  { 11, 1788720, 0, 1550225678 },
-
-  // version 12 starts from block 1978433, which is on or around the 30th of November, 2019. Fork time finalised on 2019-10-18.
-  { 12, 1978433, 0, 1571419280 },
-
-  { 13, 2210000, 0, 1598180817 },
-  { 14, 2210720, 0, 1598180818 },
-
-  { 15, 2688888, 0, 1656629117 },
-  { 16, 2689608, 0, 1656629118 },
+  { 7, 1, 0, 1519605000 },
+  { 8, 6969, 0, 1524214739 },
+  { 9, 53666, 0, 1538689773 },
+  { 10, 63469, 0, 1541700352 },
+  { 11, 81769, 0, 1549238400 },
+  { 12, 82069, 0, 1549318761 },
+  { 13, 114969, 0, 1559292691 },
+  { 14, 115257, 0, 1559292774 },
+  { 15, 160777, 0, 1573280497 },
+  { 16, 253999, 0, 1600576508 },
+  { 17, 254287, 0, 1600576524 },
+  { 18, 331170, 0, 1623245591 },
+  { 19, 331458, 0, 1624793373 },
+  { 20, 514000, 0, 1677222289 },
 };
 const size_t num_mainnet_hard_forks = sizeof(mainnet_hard_forks) / sizeof(mainnet_hard_forks[0]);
-const uint64_t mainnet_hard_fork_version_1_till = 1009826;
+const uint64_t mainnet_hard_fork_version_1_till = 0;

 const hardfork_t testnet_hard_forks[] = {
-  // version 1 from the start of the blockchain
-  { 1, 1, 0, 1341378000 },
-
-  // version 2 starts from block 624634, which is on or around the 23rd of November, 2015. Fork time finalised on 2015-11-20. No fork voting occurs for the v2 fork.
-  { 2, 624634, 0, 1445355000 },
-
-  // versions 3-5 were passed in rapid succession from September 18th, 2016
-  { 3, 800500, 0, 1472415034 },
-  { 4, 801219, 0, 1472415035 },
-  { 5, 802660, 0, 1472415036 + 86400*180 }, // add 5 months on testnet to shut the update warning up since there's a large gap to v6
-
-  { 6, 971400, 0, 1501709789 },
-  { 7, 1057027, 0, 1512211236 },
-  { 8, 1057058, 0, 1533211200 },
-  { 9, 1057778, 0, 1533297600 },
-  { 10, 1154318, 0, 1550153694 },
-  { 11, 1155038, 0, 1550225678 },
-  { 12, 1308737, 0, 1569582000 },
-  { 13, 1543939, 0, 1599069376 },
-  { 14, 1544659, 0, 1599069377 },
-  { 15, 1982800, 0, 1652727000 },
-  { 16, 1983520, 0, 1652813400 },
 };
 const size_t num_testnet_hard_forks = sizeof(testnet_hard_forks) / sizeof(testnet_hard_forks[0]);
-const uint64_t testnet_hard_fork_version_1_till = 624633;
+const uint64_t testnet_hard_fork_version_1_till = 0;

 const hardfork_t stagenet_hard_forks[] = {
-  // version 1 from the start of the blockchain
-  { 1, 1, 0, 1341378000 },
-
-  // versions 2-7 in rapid succession from March 13th, 2018
-  { 2, 32000, 0, 1521000000 },
-  { 3, 33000, 0, 1521120000 },
-  { 4, 34000, 0, 1521240000 },
-  { 5, 35000, 0, 1521360000 },
-  { 6, 36000, 0, 1521480000 },
-  { 7, 37000, 0, 1521600000 },
-  { 8, 176456, 0, 1537821770 },
-  { 9, 177176, 0, 1537821771 },
-  { 10, 269000, 0, 1550153694 },
-  { 11, 269720, 0, 1550225678 },
-  { 12, 454721, 0, 1571419280 },
-  { 13, 675405, 0, 1598180817 },
-  { 14, 676125, 0, 1598180818 },
-  { 15, 1151000, 0, 1656629117 },
-  { 16, 1151720, 0, 1656629118 },
 };
 const size_t num_stagenet_hard_forks = sizeof(stagenet_hard_forks) / sizeof(stagenet_hard_forks[0]);
--- a/src/multisig/multisig_kex_msg.cpp
+++ b/src/multisig/multisig_kex_msg.cpp
@ -206,8 +206,13 @@ namespace multisig
  //----------------------------------------------------------------------------------------------------------------------
  void multisig_kex_msg::parse_and_validate_msg()
  {
+    CHECK_AND_ASSERT_THROW_MES(MULTISIG_KEX_MSG_V2_MAGIC_1.size() == MULTISIG_KEX_MSG_V2_MAGIC_N.size(),
+      "Multisig kex msg magic inconsistency.");
+    CHECK_AND_ASSERT_THROW_MES(MULTISIG_KEX_MSG_V2_MAGIC_1.size() >= MULTISIG_KEX_V1_MAGIC.size(),
+      "Multisig kex msg magic inconsistency.");
+
    // check message type
-    CHECK_AND_ASSERT_THROW_MES(m_msg.size() > 0, "Kex message unexpectedly empty.");
+    CHECK_AND_ASSERT_THROW_MES(m_msg.size() >= MULTISIG_KEX_MSG_V2_MAGIC_1.size(), "Kex message unexpectedly small.");
    CHECK_AND_ASSERT_THROW_MES(m_msg.substr(0, MULTISIG_KEX_V1_MAGIC.size()) != MULTISIG_KEX_V1_MAGIC,
      "V1 multisig kex messages are deprecated (unsafe).");
    CHECK_AND_ASSERT_THROW_MES(m_msg.substr(0, MULTISIG_KEX_MSG_V1_MAGIC.size()) != MULTISIG_KEX_MSG_V1_MAGIC,
@ -215,8 +220,6 @@ namespace multisig

    // deserialize the message
    std::string msg_no_magic;
-    CHECK_AND_ASSERT_THROW_MES(MULTISIG_KEX_MSG_V2_MAGIC_1.size() == MULTISIG_KEX_MSG_V2_MAGIC_N.size(),
-      "Multisig kex msg magic inconsistency.");
    CHECK_AND_ASSERT_THROW_MES(tools::base58::decode(m_msg.substr(MULTISIG_KEX_MSG_V2_MAGIC_1.size()), msg_no_magic),
      "Multisig kex msg decoding error.");
    binary_archive<false> b_archive{epee::strspan<std::uint8_t>(msg_no_magic)};
--- a/src/net/i2p_address.cpp
+++ b/src/net/i2p_address.cpp
@ -71,7 +71,7 @@ namespace net
        struct i2p_serialized
        {
            std::string host;
-            std::uint16_t port;
+            std::uint16_t port; //! Leave for compatability with older clients

            BEGIN_KV_SERIALIZE_MAP()
                KV_SERIALIZE(host)
@ -80,8 +80,7 @@ namespace net
        };
    }

-    i2p_address::i2p_address(const boost::string_ref host, const std::uint16_t port) noexcept
-      : port_(port)
+    i2p_address::i2p_address(const boost::string_ref host) noexcept
    {
        // this is a private constructor, throw if moved to public
        assert(host.size() < sizeof(host_));
@ -97,27 +96,19 @@ namespace net
    }

    i2p_address::i2p_address() noexcept
-      : port_(0)
    {
        static_assert(sizeof(unknown_host) <= sizeof(host_), "bad buffer size");
        std::memcpy(host_, unknown_host, sizeof(unknown_host));
        std::memset(host_ + sizeof(unknown_host), 0, sizeof(host_) - sizeof(unknown_host));
    }

-    expect<i2p_address> i2p_address::make(const boost::string_ref address, const std::uint16_t default_port)
+    expect<i2p_address> i2p_address::make(const boost::string_ref address)
    {
        boost::string_ref host = address.substr(0, address.rfind(':'));
-        const boost::string_ref port =
-            address.substr(host.size() + (host.size() == address.size() ? 0 : 1));
-
        MONERO_CHECK(host_check(host));

-        std::uint16_t porti = default_port;
-        if (!port.empty() && !epee::string_tools::get_xtype_from_string(porti, std::string{port}))
-            return {net::error::invalid_port};
-
        static_assert(b32_length + sizeof(tld) == sizeof(i2p_address::host_), "bad internal host size");
-        return i2p_address{host, porti};
+        return i2p_address{host};
    }

    bool i2p_address::_load(epee::serialization::portable_storage& src, epee::serialization::section* hparent)
@ -127,23 +118,21 @@ namespace net
        {
            std::memcpy(host_, in.host.data(), in.host.size());
            std::memset(host_ + in.host.size(), 0, sizeof(host_) - in.host.size());
-            port_ = in.port;
            return true;
        }
        static_assert(sizeof(unknown_host) <= sizeof(host_), "bad buffer size");
        std::memcpy(host_, unknown_host, sizeof(unknown_host)); // include null terminator
-        port_ = 0;
        return false;
    }

    bool i2p_address::store(epee::serialization::portable_storage& dest, epee::serialization::section* hparent) const
    {
-        const i2p_serialized out{std::string{host_}, port_};
+        // Set port to 1 for backwards compatability; zero is invalid port
+        const i2p_serialized out{std::string{host_}, 1};
        return out.store(dest, hparent);
    }

    i2p_address::i2p_address(const i2p_address& rhs) noexcept
-      : port_(rhs.port_)
    {
        std::memcpy(host_, rhs.host_, sizeof(host_));
    }
@ -152,7 +141,6 @@ namespace net
    {
        if (this != std::addressof(rhs))
        {
-            port_ = rhs.port_;
            std::memcpy(host_, rhs.host_, sizeof(host_));
        }
        return *this;
@ -166,13 +154,12 @@ namespace net

    bool i2p_address::equal(const i2p_address& rhs) const noexcept
    {
-        return port_ == rhs.port_ && is_same_host(rhs);
+        return is_same_host(rhs);
    }

    bool i2p_address::less(const i2p_address& rhs) const noexcept
    {
-        int res = std::strcmp(host_str(), rhs.host_str());
-        return res < 0 || (res == 0 && port() < rhs.port());
+        return std::strcmp(host_str(), rhs.host_str()) < 0;
    }

    bool i2p_address::is_same_host(const i2p_address& rhs) const noexcept
@ -182,20 +169,6 @@ namespace net

    std::string i2p_address::str() const
    {
-        const std::size_t host_length = std::strlen(host_str());
-        const std::size_t port_length =
-            port_ == 0 ? 0 : std::numeric_limits<std::uint16_t>::digits10 + 2;
-
-        std::string out{};
-        out.reserve(host_length + port_length);
-        out.assign(host_str(), host_length);
-
-        if (port_ != 0)
-        {
-            out.push_back(':');
-            namespace karma = boost::spirit::karma;
-            karma::generate(std::back_inserter(out), karma::ushort_, port());
-        }
-        return out;
+        return host_str();
    }
 }
--- a/src/net/i2p_address.h
+++ b/src/net/i2p_address.h
@ -50,11 +50,10 @@ namespace net
    //! b32 i2p address; internal format not condensed/decoded.
    class i2p_address
    {
-        std::uint16_t port_;
        char host_[61]; // null-terminated

        //! Keep in private, `host.size()` has no runtime check
-        i2p_address(boost::string_ref host, std::uint16_t port) noexcept;
+        i2p_address(boost::string_ref host) noexcept;

    public:
        //! \return Size of internal buffer for host.
@ -74,7 +73,7 @@ namespace net
            with `default_port` being used if port is not specified in
            `address`.
        */
-        static expect<i2p_address> make(boost::string_ref address, std::uint16_t default_port = 0);
+        static expect<i2p_address> make(boost::string_ref address);

        //! Load from epee p2p format, and \return false if not valid tor address
        bool _load(epee::serialization::portable_storage& src, epee::serialization::section* hparent);
@ -103,8 +102,8 @@ namespace net
        //! \return Null-terminated `x.b32.i2p` value or `unknown_str()`.
        const char* host_str() const noexcept { return host_; }

-        //! \return Port value or `0` if unspecified.
-        std::uint16_t port() const noexcept { return port_; }
+        //! \return `1` to work with I2P socks which considers `0` error.
+        std::uint16_t port() const noexcept { return 1; }

        static constexpr bool is_loopback() noexcept { return false; }
        static constexpr bool is_local() noexcept { return false; }
--- a/src/net/parse.cpp
+++ b/src/net/parse.cpp
@ -81,7 +81,7 @@ namespace net
        if (host_str_ref.ends_with(".onion"))
            return tor_address::make(address, default_port);
        if (host_str_ref.ends_with(".i2p"))
-            return i2p_address::make(address, default_port);
+            return i2p_address::make(address);

        boost::system::error_code ec;
        boost::asio::ip::address_v6 v6 = boost::asio::ip::address_v6::from_string(host_str, ec);
--- a/src/p2p/net_node.h
+++ b/src/p2p/net_node.h
@ -300,10 +300,7 @@ namespace nodetool

  private:
    const std::vector<std::string> m_seed_nodes_list =
-    { "seeds.moneroseeds.se"
-    , "seeds.moneroseeds.ae.org"
-    , "seeds.moneroseeds.ch"
-    , "seeds.moneroseeds.li"
+    {
    };

    bool islimitup=false;
--- a/src/p2p/net_node.inl
+++ b/src/p2p/net_node.inl
@ -705,32 +705,29 @@ namespace nodetool
    std::set<std::string> full_addrs;
    if (m_nettype == cryptonote::TESTNET)
    {
-      full_addrs.insert("176.9.0.187:28080");
-      full_addrs.insert("88.99.173.38:28080");
-      full_addrs.insert("51.79.173.165:28080");
-      full_addrs.insert("192.99.8.110:28080");
-      full_addrs.insert("37.187.74.171:28080");
    }
    else if (m_nettype == cryptonote::STAGENET)
    {
-      full_addrs.insert("176.9.0.187:38080");
-      full_addrs.insert("88.99.173.38:38080");
-      full_addrs.insert("51.79.173.165:38080");
-      full_addrs.insert("192.99.8.110:38080");
-      full_addrs.insert("37.187.74.171:38080");
    }
    else if (m_nettype == cryptonote::FAKECHAIN)
    {
    }
    else
    {
-      full_addrs.insert("176.9.0.187:18080");
-      full_addrs.insert("88.198.163.90:18080");
-      full_addrs.insert("66.85.74.134:18080");
-      full_addrs.insert("88.99.173.38:18080");
-      full_addrs.insert("51.79.173.165:18080");
-      full_addrs.insert("192.99.8.110:18080");
-      full_addrs.insert("37.187.74.171:18080");
+      //full_addrs.insert("158.69.60.225:34567");   //  explore.wownero.com
+      //full_addrs.insert("159.65.91.59:34567");    //  jw
+      full_addrs.insert("51.161.131.176:34567");  //  node.suchwow.xyz
+      //full_addrs.insert("167.114.196.241:34567"); //  wowbux.org
+      //full_addrs.insert("142.93.144.79:34567"); // idontwanttogototoronto.wow.fail
+      //full_addrs.insert("51.75.76.161:34567"); // eu-west-1.wow.xmr.pm
+      //full_addrs.insert("145.239.93.75:34567"); // eu-west-2.wow.xmr.pm
+      full_addrs.insert("88.198.199.23:34567");
+      //full_addrs.insert("167.114.119.46:34567"); // wownero.stackwallet.com
+      full_addrs.insert("143.198.195.132:34567"); // singapore.muchwow.lol
+      full_addrs.insert("134.122.53.193:34567"); // amsterdam.muchwow.lol
+      full_addrs.insert("204.48.28.218:34567"); // nyc.muchwow.lol
+      full_addrs.insert("192.99.8.110:34567"); // node.monerodevs.org
+      full_addrs.insert("37.187.74.171:34567"); // node2.monerodevs.org
    }
    return full_addrs;
  }
@ -861,12 +858,12 @@ namespace nodetool
      if (m_nettype == cryptonote::MAINNET)
      {
        return {
-          "xwvz3ekocr3dkyxfkmgm2hvbpzx2ysqmaxgter7znnqrhoicygkfswid.onion:18083",
-          "4pixvbejrvihnkxmduo2agsnmc3rrulrqc7s3cbwwrep6h6hrzsibeqd.onion:18083",
-          "zbjkbsxc5munw3qusl7j2hpcmikhqocdf4pqhnhtpzw5nt5jrmofptid.onion:18083",
-          "qz43zul2x56jexzoqgkx2trzwcfnr6l3hbtfcfx54g4r3eahy3bssjyd.onion:18083",
-          "plowsof3t5hogddwabaeiyrno25efmzfxyro2vligremt7sxpsclfaid.onion:18083",
-          "plowsoffjexmxalw73tkjmf422gq6575fc7vicuu4javzn2ynnte6tyd.onion:18083",
+          "77uase4p6y6jsjdf6z2kdgpxgh7nkvywagvhurzphbm7vrkyj2d2gdid.onion:34566",
+          "v2admi6gbeprxnk6i2oscizhgy4v5ixu6iezkhj5udiwbfjjs2w7dnid.onion:34566",
+          "ttc6kxud3fikyaypn5voknyyvqje7j3wnoevsb7rfjerolynnisurkqd.onion:34566",
+          "5enbij6tz3n2hw5ixzezfayd5gvckyg4xlktz74gj4l6u7olq7ovr3id.onion:34566",
+          "ukpgpdd5gqvholcctejvaaig5hb266td6zaszt55eivuf7docoox5lid.onion:34566",
+          "iorkdy6t4gdtwzn3iblnhy76nu7lhyz2qcvpj4wrspfxyvdrul7u22qd.onion:34566",
        };
      }
      return {};
@ -874,10 +871,9 @@ namespace nodetool
      if (m_nettype == cryptonote::MAINNET)
      {
        return {
-          "s3l6ke4ed3df466khuebb4poienoingwof7oxtbo6j4n56sghe3a.b32.i2p:18080",
-          "sel36x6fibfzujwvt4hf5gxolz6kd3jpvbjqg6o3ud2xtionyl2q.b32.i2p:18080",
-          "uqj3aphckqtjsitz7kxx5flqpwjlq5ppr3chazfued7xucv3nheq.b32.i2p:18080",
-          "vdmnehdjkpkg57nthgnjfuaqgku673r5bpbqg56ix6fyqoywgqrq.b32.i2p:18080",
+          "lrq65qrhpbt5voom2ncvowpes6kvobodkldhpuwhxlsrpugmgmlq.b32.i2p:34565",
+          "72tbpgeczdtx2q2enbyaqcot7mghbnjenjkmdpyylrssqehr746a.b32.i2p:34565",
+          "rkel2qy7xv3cc5bnxfrzwgh3jvd4woagd4vlhr3qsdxy6cfkimnq.b32.i2p:34565",
        };
      }
      return {};
@ -2033,13 +2029,6 @@ namespace nodetool
      return true;

    static const std::vector<std::string> dns_urls = {
-      "blocklist.moneropulse.se"
-    , "blocklist.moneropulse.org"
-    , "blocklist.moneropulse.net"
-    , "blocklist.moneropulse.no"
-    , "blocklist.moneropulse.fr"
-    , "blocklist.moneropulse.de"
-    , "blocklist.moneropulse.ch"
    };

    std::vector<std::string> records;
@ -2101,7 +2090,7 @@ namespace nodetool
        }
        else
        {
-          const el::Level level = el::Level::Warning;
+          const el::Level level = el::Level::Debug;
          MCLOG_RED(level, "global", "No incoming connections - check firewalls/routers allow port " << get_this_peer_port());
        }
      }
--- a/src/p2p/net_peerlist_boost_serialization.h
+++ b/src/p2p/net_peerlist_boost_serialization.h
@ -196,7 +196,7 @@ namespace boost
      if (std::strcmp(host, net::i2p_address::unknown_str()) == 0)
        na = net::i2p_address::unknown();
      else
-        na = MONERO_UNWRAP(net::i2p_address::make(host, port));
+        na = MONERO_UNWRAP(net::i2p_address::make(host));
    }

    template <class Archive, class ver_type>
--- a/src/ringct/CMakeLists.txt
+++ b/src/ringct/CMakeLists.txt
@ -32,6 +32,7 @@ set(ringct_basic_sources
  rctCryptoOps.c
  multiexp.cc
  bulletproofs.cc
+  bulletproofs2.cc
  bulletproofs_plus.cc)

 monero_find_all_headers(ringct_basic_private_headers "${CMAKE_CURRENT_SOURCE_DIR}")
--- a/src/ringct/bulletproofs.cc
+++ b/src/ringct/bulletproofs.cc
@ -70,12 +70,13 @@ static rct::key inner_product(const rct::keyV &a, const rct::keyV &b);

 static constexpr size_t maxN = 64;
 static constexpr size_t maxM = BULLETPROOF_MAX_OUTPUTS;
+static rct::key Hi[maxN*maxM], Gi[maxN*maxM];
 static ge_p3 Hi_p3[maxN*maxM], Gi_p3[maxN*maxM];
 static std::shared_ptr<straus_cached_data> straus_HiGi_cache;
 static std::shared_ptr<pippenger_cached_data> pippenger_HiGi_cache;
-static const constexpr rct::key TWO = { {0x02, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00  } };
-static const constexpr rct::key MINUS_ONE = { { 0xec, 0xd3, 0xf5, 0x5c, 0x1a, 0x63, 0x12, 0x58, 0xd6, 0x9c, 0xf7, 0xa2, 0xde, 0xf9, 0xde, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10 } };
-static const constexpr rct::key MINUS_INV_EIGHT = { { 0x74, 0xa4, 0x19, 0x7a, 0xf0, 0x7d, 0x0b, 0xf7, 0x05, 0xc2, 0xda, 0x25, 0x2b, 0x5c, 0x0b, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a } };
+static const rct::key TWO = { {0x02, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00 , 0x00, 0x00, 0x00,0x00  } };
+static const rct::key MINUS_ONE = { { 0xec, 0xd3, 0xf5, 0x5c, 0x1a, 0x63, 0x12, 0x58, 0xd6, 0x9c, 0xf7, 0xa2, 0xde, 0xf9, 0xde, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10 } };
+static const rct::key MINUS_INV_EIGHT = { { 0x74, 0xa4, 0x19, 0x7a, 0xf0, 0x7d, 0x0b, 0xf7, 0x05, 0xc2, 0xda, 0x25, 0x2b, 0x5c, 0x0b, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a } };
 static const rct::keyV oneN = vector_dup(rct::identity(), maxN);
 static const rct::keyV twoN = vector_powers(TWO, maxN);
 static const rct::key ip12 = inner_product(oneN, twoN);
@ -99,7 +100,8 @@ static inline bool is_reduced(const rct::key &scalar)

 static rct::key get_exponent(const rct::key &base, size_t idx)
 {
-  std::string hashed = std::string((const char*)base.bytes, sizeof(base)) + config::HASH_KEY_BULLETPROOF_EXPONENT + tools::get_varint_data(idx);
+  static const std::string domain_separator(config::HASH_KEY_BULLETPROOF_EXPONENT);
+  std::string hashed = std::string((const char*)base.bytes, sizeof(base)) + domain_separator + tools::get_varint_data(idx);
  rct::key e;
  ge_p3 e_p3;
  rct::hash_to_p3(e_p3, rct::hash2rct(crypto::cn_fast_hash(hashed.data(), hashed.size())));
@ -119,10 +121,10 @@ static void init_exponents()
  data.reserve(maxN*maxM*2);
  for (size_t i = 0; i < maxN*maxM; ++i)
  {
-    const rct::key Hi = get_exponent(rct::H, i * 2);
-    CHECK_AND_ASSERT_THROW_MES(ge_frombytes_vartime(&Hi_p3[i], Hi.bytes) == 0, "ge_frombytes_vartime failed");
-    const rct::key Gi = get_exponent(rct::H, i * 2 + 1);
-    CHECK_AND_ASSERT_THROW_MES(ge_frombytes_vartime(&Gi_p3[i], Gi.bytes) == 0, "ge_frombytes_vartime failed");
+    Hi[i] = get_exponent(rct::H, i * 2);
+    CHECK_AND_ASSERT_THROW_MES(ge_frombytes_vartime(&Hi_p3[i], Hi[i].bytes) == 0, "ge_frombytes_vartime failed");
+    Gi[i] = get_exponent(rct::H, i * 2 + 1);
+    CHECK_AND_ASSERT_THROW_MES(ge_frombytes_vartime(&Gi_p3[i], Gi[i].bytes) == 0, "ge_frombytes_vartime failed");

    data.push_back({rct::zero(), Gi_p3[i]});
    data.push_back({rct::zero(), Hi_p3[i]});
@ -131,10 +133,11 @@ static void init_exponents()
  straus_HiGi_cache = straus_init_cache(data, STRAUS_SIZE_LIMIT);
  pippenger_HiGi_cache = pippenger_init_cache(data, 0, PIPPENGER_SIZE_LIMIT);

+  MINFO("Hi/Gi cache size: " << (sizeof(Hi)+sizeof(Gi))/1024 << " kB");
  MINFO("Hi_p3/Gi_p3 cache size: " << (sizeof(Hi_p3)+sizeof(Gi_p3))/1024 << " kB");
  MINFO("Straus cache size: " << straus_get_cache_size(straus_HiGi_cache)/1024 << " kB");
  MINFO("Pippenger cache size: " << pippenger_get_cache_size(pippenger_HiGi_cache)/1024 << " kB");
-  size_t cache_size = straus_get_cache_size(straus_HiGi_cache) + pippenger_get_cache_size(pippenger_HiGi_cache);
+  size_t cache_size = (sizeof(Hi)+sizeof(Hi_p3))*2 + straus_get_cache_size(straus_HiGi_cache) + pippenger_get_cache_size(pippenger_HiGi_cache);
  MINFO("Total cache size: " << cache_size/1024 << "kB");
  init_done = true;
 }
@ -892,8 +895,7 @@ bool bulletproof_VERIFY(const std::vector<const Bulletproof*> &proofs)
  multiexp_data.resize(2 * maxMN);

  PERF_TIMER_START_BP(VERIFY_line_24_25_invert);
-  const std::vector<rct::key> inverses = invert(std::move(to_invert));
-  to_invert.clear();
+  const std::vector<rct::key> inverses = invert(to_invert);
  PERF_TIMER_STOP_BP(VERIFY_line_24_25_invert);

  // setup weighted aggregates
--- a/src/ringct/bulletproofs.h
+++ b/src/ringct/bulletproofs.h
@ -42,9 +42,16 @@ Bulletproof bulletproof_PROVE(const rct::key &v, const rct::key &gamma);
 Bulletproof bulletproof_PROVE(uint64_t v, const rct::key &gamma);
 Bulletproof bulletproof_PROVE(const rct::keyV &v, const rct::keyV &gamma);
 Bulletproof bulletproof_PROVE(const std::vector<uint64_t> &v, const rct::keyV &gamma);
+Bulletproof bulletproof_PROVE_old(const rct::key &v, const rct::key &gamma);
+Bulletproof bulletproof_PROVE_old(uint64_t v, const rct::key &gamma);
+Bulletproof bulletproof_PROVE_old(const rct::keyV &v, const rct::keyV &gamma);
+Bulletproof bulletproof_PROVE_old(const std::vector<uint64_t> &v, const rct::keyV &gamma);
 bool bulletproof_VERIFY(const Bulletproof &proof);
 bool bulletproof_VERIFY(const std::vector<const Bulletproof*> &proofs);
 bool bulletproof_VERIFY(const std::vector<Bulletproof> &proofs);
+bool bulletproof_VERIFY_old(const Bulletproof &proof);
+bool bulletproof_VERIFY_old(const std::vector<const Bulletproof*> &proofs);
+bool bulletproof_VERIFY_old(const std::vector<Bulletproof> &proofs);

 }

--- a/src/ringct/bulletproofs2.cc
+++ b/src/ringct/bulletproofs2.cc
--- a/src/ringct/rctSigs.cpp
+++ b/src/ringct/rctSigs.cpp
@ -132,6 +132,24 @@ namespace rct {
        return proof;
    }

+    Bulletproof proveRangeBulletproof_old(key &C, key &mask, uint64_t amount)
+    {
+        mask = rct::skGen();
+        Bulletproof proof = bulletproof_PROVE_old(amount, mask);
+        CHECK_AND_ASSERT_THROW_MES(proof.V.size() == 1, "V has not exactly one element");
+        C = proof.V[0];
+        return proof;
+    }
+
+    Bulletproof proveRangeBulletproof_old(keyV &C, keyV &masks, const std::vector<uint64_t> &amounts)
+    {
+        masks = rct::skvGen(amounts.size());
+        Bulletproof proof = bulletproof_PROVE_old(amounts, masks);
+        CHECK_AND_ASSERT_THROW_MES(proof.V.size() == amounts.size(), "V does not have the expected size");
+        C = proof.V;
+        return proof;
+    }
+
    bool verBulletproof(const Bulletproof &proof)
    {
      try { return bulletproof_VERIFY(proof); }
@ -146,6 +164,20 @@ namespace rct {
      catch (...) { return false; }
    }

+    bool verBulletproof_old(const Bulletproof &proof)
+    {
+      try { return bulletproof_VERIFY_old(proof); }
+      // we can get deep throws from ge_frombytes_vartime if input isn't valid
+      catch (...) { return false; }
+    }
+
+    bool verBulletproof_old(const std::vector<const Bulletproof*> &proofs)
+    {
+      try { return bulletproof_VERIFY_old(proofs); }
+      // we can get deep throws from ge_frombytes_vartime if input isn't valid
+      catch (...) { return false; }
+    }
+
    BulletproofPlus proveRangeBulletproofPlus(keyV &C, keyV &masks, const std::vector<uint64_t> &amounts, epee::span<const key> sk, hw::device &hwdev)
    {
        CHECK_AND_ASSERT_THROW_MES(amounts.size() == sk.size(), "Invalid amounts/sk sizes");
@ -616,7 +648,7 @@ namespace rct {
      hashes.push_back(hash2rct(h));

      keyV kv;
-      if (rv.type == RCTTypeBulletproof || rv.type == RCTTypeBulletproof2 || rv.type == RCTTypeCLSAG)
+      if (rv.type == RCTTypeBulletproof || rv.type == RCTTypeBulletproof2 || rv.type == RCTTypeSimpleBulletproof || rv.type == RCTTypeFullBulletproof || rv.type == RCTTypeCLSAG)
      {
        kv.reserve((6*2+9) * rv.p.bulletproofs.size());
        for (const auto &p: rv.p.bulletproofs)
@ -1044,6 +1076,7 @@ namespace rct {
    //   Note: For txn fees, the last index in the amounts vector should contain that
    //   Thus the amounts vector will be "one" longer than the destinations vectort
    rctSig genRct(const key &message, const ctkeyV & inSk, const keyV & destinations, const vector<xmr_amount> & amounts, const ctkeyM &mixRing, const keyV &amount_keys, unsigned int index, ctkeyV &outSk, const RCTConfig &rct_config, hw::device &hwdev) {
+        const bool bulletproof = rct_config.range_proof_type != RangeProofBorromean;
        CHECK_AND_ASSERT_THROW_MES(amounts.size() == destinations.size() || amounts.size() == destinations.size() + 1, "Different number of amounts/destinations");
        CHECK_AND_ASSERT_THROW_MES(amount_keys.size() == destinations.size(), "Different number of amount_keys/destinations");
        CHECK_AND_ASSERT_THROW_MES(index < mixRing.size(), "Bad index into mixRing");
@ -1053,10 +1086,11 @@ namespace rct {
        CHECK_AND_ASSERT_THROW_MES(inSk.size() < 2, "genRct is not suitable for 2+ rings");

        rctSig rv;
-        rv.type = RCTTypeFull;
+        rv.type = bulletproof ? RCTTypeFullBulletproof : RCTTypeFull;
        rv.message = message;
        rv.outPk.resize(destinations.size());
-        rv.p.rangeSigs.resize(destinations.size());
+        if (!bulletproof)
+            rv.p.rangeSigs.resize(destinations.size());
        rv.ecdhInfo.resize(destinations.size());

        size_t i = 0;
@ -1066,10 +1100,45 @@ namespace rct {
            //add destination to sig
            rv.outPk[i].dest = copy(destinations[i]);
            //compute range proof
-            rv.p.rangeSigs[i] = proveRange(rv.outPk[i].mask, outSk[i].mask, amounts[i]);
+            if (!bulletproof)
+            {
+                rv.p.rangeSigs[i] = proveRange(rv.outPk[i].mask, outSk[i].mask, amounts[i]);
+
            #ifdef DBG
            CHECK_AND_ASSERT_THROW_MES(verRange(rv.outPk[i].mask, rv.p.rangeSigs[i]), "verRange failed on newly created proof");
            #endif
+            }
+        }
+        rv.p.bulletproofs.clear();
+        if (bulletproof)
+        {
+            std::vector<uint64_t> proof_amounts;
+            size_t amounts_proved = 0;
+            while (amounts_proved < amounts.size())
+            {
+                size_t batch_size = 1;
+                if (rct_config.range_proof_type == RangeProofMultiOutputBulletproof)
+                  while (batch_size * 2 + amounts_proved <= amounts.size())
+                    batch_size *= 2;
+                rct::keyV C, masks;
+                std::vector<uint64_t> batch_amounts(batch_size);
+                for (i = 0; i < batch_size; ++i)
+                  batch_amounts[i] = amounts[i + amounts_proved];
+                rv.p.bulletproofs.push_back(proveRangeBulletproof_old(C, masks, batch_amounts));
+            #ifdef DBG
+                CHECK_AND_ASSERT_THROW_MES(verBulletproof_old(rv.p.bulletproofs.back()), "verBulletproof failed on newly created proof");
+            #endif
+                for (i = 0; i < batch_size; ++i)
+                {
+                  rv.outPk[i + amounts_proved].mask = C[i];
+                  outSk[i + amounts_proved].mask = masks[i];
+                }
+                amounts_proved += batch_size;
+            }
+        }
+
+        for (i = 0; i < outSk.size(); ++i)
+        {
            //mask amount and mask
            rv.ecdhInfo[i].mask = copy(outSk[i].mask);
            rv.ecdhInfo[i].amount = d2h(amounts[i]);
@ -1195,7 +1264,10 @@ namespace rct {
                }
                for (i = 0; i < outamounts.size(); ++i)
                {
-                    rv.outPk[i].mask = rct::scalarmult8(C[i]);
+                    if (plus)
+                        rv.outPk[i].mask = C[i];
+                    else
+                        rv.outPk[i].mask = rct::scalarmult8(C[i]);
                    outSk[i].mask = masks[i];
                }
            }
@ -1233,7 +1305,10 @@ namespace rct {
                }
                for (i = 0; i < batch_size; ++i)
                {
-                  rv.outPk[i + amounts_proved].mask = rct::scalarmult8(C[i]);
+                  if (plus)
+                    rv.outPk[i + amounts_proved].mask = C[i];
+                  else
+                    rv.outPk[i + amounts_proved].mask = rct::scalarmult8(C[i]);
                  outSk[i + amounts_proved].mask = masks[i];
                }
                amounts_proved += batch_size;
@ -1305,6 +1380,98 @@ namespace rct {
        return genRctSimple(message, inSk, destinations, inamounts, outamounts, txnFee, mixRing, amount_keys, index, outSk, rct_config, hwdev);
    }

+    //RCT simple    
+    //for post-rct only
+    rctSig genRctSimple_old(const key &message, const ctkeyV & inSk, const keyV & destinations, const vector<xmr_amount> &inamounts, const vector<xmr_amount> &outamounts, xmr_amount txnFee, const ctkeyM & mixRing, const keyV &amount_keys, const std::vector<unsigned int> & index, ctkeyV &outSk, const RCTConfig &rct_config, hw::device &hwdev) {
+        const bool bulletproof = rct_config.range_proof_type != RangeProofBorromean;
+        CHECK_AND_ASSERT_THROW_MES(inamounts.size() > 0, "Empty inamounts");
+        CHECK_AND_ASSERT_THROW_MES(inamounts.size() == inSk.size(), "Different number of inamounts/inSk");
+        CHECK_AND_ASSERT_THROW_MES(outamounts.size() == destinations.size(), "Different number of amounts/destinations");
+        CHECK_AND_ASSERT_THROW_MES(amount_keys.size() == destinations.size(), "Different number of amount_keys/destinations");
+        CHECK_AND_ASSERT_THROW_MES(index.size() == inSk.size(), "Different number of index/inSk");
+        CHECK_AND_ASSERT_THROW_MES(mixRing.size() == inSk.size(), "Different number of mixRing/inSk");
+        for (size_t n = 0; n < mixRing.size(); ++n) {
+          CHECK_AND_ASSERT_THROW_MES(index[n] < mixRing[n].size(), "Bad index into mixRing");
+        }
+
+        rctSig rv;
+        rv.type = bulletproof ? RCTTypeSimpleBulletproof : RCTTypeSimple;
+        rv.message = message;
+        rv.outPk.resize(destinations.size());
+        if (bulletproof)
+          rv.p.bulletproofs.resize(destinations.size());
+        else
+          rv.p.rangeSigs.resize(destinations.size());
+        rv.ecdhInfo.resize(destinations.size());
+
+        size_t i;
+        keyV masks(destinations.size()); //sk mask..
+        outSk.resize(destinations.size());
+        key sumout = zero();
+        for (i = 0; i < destinations.size(); i++) {
+
+            //add destination to sig
+            rv.outPk[i].dest = copy(destinations[i]);
+            //compute range proof
+            if (bulletproof)
+              rv.p.bulletproofs[i] = proveRangeBulletproof_old(rv.outPk[i].mask, outSk[i].mask, outamounts[i]);
+            else
+              rv.p.rangeSigs[i] = proveRange(rv.outPk[i].mask, outSk[i].mask, outamounts[i]);
+            #ifdef DBG
+            if (bulletproof)
+                CHECK_AND_ASSERT_THROW_MES(verBulletproof_old(rv.p.bulletproofs[i]), "verBulletproof failed on newly created proof");
+            else
+                CHECK_AND_ASSERT_THROW_MES(verRange(rv.outPk[i].mask, rv.p.rangeSigs[i]), "verRange failed on newly created proof");
+            #endif
+         
+            sc_add(sumout.bytes, outSk[i].mask.bytes, sumout.bytes);
+
+            //mask amount and mask
+            rv.ecdhInfo[i].mask = copy(outSk[i].mask);
+            rv.ecdhInfo[i].amount = d2h(outamounts[i]);
+            hwdev.ecdhEncode(rv.ecdhInfo[i], amount_keys[i], rv.type == RCTTypeSimpleBulletproof);
+        }
+            
+        //set txn fee
+        rv.txnFee = txnFee;
+//        TODO: unused ??
+//        key txnFeeKey = scalarmultH(d2h(rv.txnFee));
+        rv.mixRing = mixRing;
+        keyV &pseudoOuts = bulletproof ? rv.p.pseudoOuts : rv.pseudoOuts;
+        pseudoOuts.resize(inamounts.size());
+        rv.p.MGs.resize(inamounts.size());
+        key sumpouts = zero(); //sum pseudoOut masks
+        keyV a(inamounts.size());
+        for (i = 0 ; i < inamounts.size() - 1; i++) {
+            skGen(a[i]);
+            sc_add(sumpouts.bytes, a[i].bytes, sumpouts.bytes);
+            genC(pseudoOuts[i], a[i], inamounts[i]);
+        }
+        rv.mixRing = mixRing;
+        sc_sub(a[i].bytes, sumout.bytes, sumpouts.bytes);
+        genC(pseudoOuts[i], a[i], inamounts[i]);
+        DP(pseudoOuts[i]);
+
+        key full_message = get_pre_mlsag_hash(rv,hwdev);
+        for (i = 0 ; i < inamounts.size(); i++) {
+            rv.p.MGs[i] = proveRctMGSimple(full_message, rv.mixRing[i], inSk[i], a[i], pseudoOuts[i], index[i], hwdev);
+        }
+        return rv;
+    }
+
+    rctSig genRctSimple_old(const key &message, const ctkeyV & inSk, const ctkeyV & inPk, const keyV & destinations, const vector<xmr_amount> &inamounts, const vector<xmr_amount> &outamounts, const keyV &amount_keys, xmr_amount txnFee, unsigned int mixin, const RCTConfig &rct_config, hw::device &hwdev) {
+        std::vector<unsigned int> index;
+        index.resize(inPk.size());
+        ctkeyM mixRing;
+        ctkeyV outSk;
+        mixRing.resize(inPk.size());
+        for (size_t i = 0; i < inPk.size(); ++i) {
+          mixRing[i].resize(mixin+1);
+          index[i] = populateFromBlockchainSimple(mixRing[i], inPk[i], mixin);
+        }
+        return genRctSimple_old(message, inSk, destinations, inamounts, outamounts, txnFee, mixRing, amount_keys, index, outSk, rct_config, hwdev);
+    }
+
    //RingCT protocol
    //genRct: 
    //   creates an rctSig with all data necessary to verify the rangeProofs and that the signer owns one of the
@ -1317,10 +1484,13 @@ namespace rct {
    //   must know the destination private key to find the correct amount, else will return a random number    
    bool verRct(const rctSig & rv, bool semantics) {
        PERF_TIMER(verRct);
-        CHECK_AND_ASSERT_MES(rv.type == RCTTypeFull, false, "verRct called on non-full rctSig");
+        const bool bulletproof = is_rct_bulletproof(rv.type);
+        CHECK_AND_ASSERT_MES(rv.type == RCTTypeFull || rv.type == RCTTypeFullBulletproof, false, "verRct called on non-full rctSig");
        if (semantics)
        {
+          if (rv.type == RCTTypeBulletproof)
          CHECK_AND_ASSERT_MES(rv.outPk.size() == rv.p.rangeSigs.size(), false, "Mismatched sizes of outPk and rv.p.rangeSigs");
+          else
          CHECK_AND_ASSERT_MES(rv.outPk.size() == rv.ecdhInfo.size(), false, "Mismatched sizes of outPk and rv.ecdhInfo");
          CHECK_AND_ASSERT_MES(rv.p.MGs.size() == 1, false, "full rctSig has not one MG");
        }
@ -1335,10 +1505,23 @@ namespace rct {
          if (semantics) {
            tools::threadpool& tpool = tools::threadpool::getInstanceForCompute();
            tools::threadpool::waiter waiter(tpool);
-            std::deque<bool> results(rv.outPk.size(), false);
+            std::deque<bool> results(bulletproof ? rv.p.bulletproofs.size() : rv.outPk.size(), false);
            DP("range proofs verified?");
-            for (size_t i = 0; i < rv.outPk.size(); i++)
-              tpool.submit(&waiter, [&, i] { results[i] = verRange(rv.outPk[i].mask, rv.p.rangeSigs[i]); });
+            if (rct::is_rct_new_bulletproof(rv.type))
+            {
+                for (size_t i = 0; i < rv.p.bulletproofs.size(); i++)
+                    tpool.submit(&waiter, [&, i] { results[i] = verBulletproof(rv.p.bulletproofs[i]); });
+            }
+            else if (bulletproof)
+            {
+                for (size_t i = 0; i < rv.p.bulletproofs.size(); i++)
+                    tpool.submit(&waiter, [&, i] { results[i] = verBulletproof_old(rv.p.bulletproofs[i]); });
+            }
+            else
+            {
+                for (size_t i = 0; i < rv.outPk.size(); i++)
+                    tpool.submit(&waiter, [&, i] { results[i] = verRange(rv.outPk[i].mask, rv.p.rangeSigs[i]); });
+            }
            if (!waiter.wait())
              return false;

@ -1394,7 +1577,7 @@ namespace rct {
        {
          CHECK_AND_ASSERT_MES(rvp, false, "rctSig pointer is NULL");
          const rctSig &rv = *rvp;
-          CHECK_AND_ASSERT_MES(rv.type == RCTTypeSimple || rv.type == RCTTypeBulletproof || rv.type == RCTTypeBulletproof2 || rv.type == RCTTypeCLSAG || rv.type == RCTTypeBulletproofPlus,
+          CHECK_AND_ASSERT_MES(rv.type == RCTTypeSimple || rv.type == RCTTypeBulletproof || rv.type == RCTTypeBulletproof2 || rv.type == RCTTypeSimpleBulletproof || rv.type == RCTTypeCLSAG || rv.type == RCTTypeBulletproofPlus,
              false, "verRctSemanticsSimple called on non simple rctSig");
          const bool bulletproof = is_rct_bulletproof(rv.type);
          const bool bulletproof_plus = is_rct_bulletproof_plus(rv.type);
@ -1439,7 +1622,10 @@ namespace rct {

          rct::keyV masks(rv.outPk.size());
          for (size_t i = 0; i < rv.outPk.size(); i++) {
-            masks[i] = rv.outPk[i].mask;
+            if (bulletproof_plus)
+              masks[i] = rct::scalarmult8(rv.outPk[i].mask);
+            else
+              masks[i] = rv.outPk[i].mask;
          }
          key sumOutpks = addKeys(masks);
          DP(sumOutpks);
@ -1523,7 +1709,7 @@ namespace rct {
      {
        PERF_TIMER(verRctNonSemanticsSimple);

-        CHECK_AND_ASSERT_MES(rv.type == RCTTypeSimple || rv.type == RCTTypeBulletproof || rv.type == RCTTypeBulletproof2 || rv.type == RCTTypeCLSAG || rv.type == RCTTypeBulletproofPlus,
+        CHECK_AND_ASSERT_MES(rv.type == RCTTypeSimple || rv.type == RCTTypeBulletproof || rv.type == RCTTypeBulletproof2 || rv.type == RCTTypeSimpleBulletproof || rv.type == RCTTypeCLSAG || rv.type == RCTTypeBulletproofPlus,
            false, "verRctNonSemanticsSimple called on non simple rctSig");
        const bool bulletproof = is_rct_bulletproof(rv.type);
        const bool bulletproof_plus = is_rct_bulletproof_plus(rv.type);
@ -1589,7 +1775,7 @@ namespace rct {
    //   uses the attached ecdh info to find the amounts represented by each output commitment 
    //   must know the destination private key to find the correct amount, else will return a random number    
    xmr_amount decodeRct(const rctSig & rv, const key & sk, unsigned int i, key & mask, hw::device &hwdev) {
-        CHECK_AND_ASSERT_MES(rv.type == RCTTypeFull, false, "decodeRct called on non-full rctSig");
+        CHECK_AND_ASSERT_MES(rv.type == RCTTypeFull || rv.type == RCTTypeFullBulletproof, false, "decodeRct called on non-full rctSig");
        CHECK_AND_ASSERT_THROW_MES(i < rv.ecdhInfo.size(), "Bad index");
        CHECK_AND_ASSERT_THROW_MES(rv.outPk.size() == rv.ecdhInfo.size(), "Mismatched sizes of rv.outPk and rv.ecdhInfo");

@ -1599,6 +1785,8 @@ namespace rct {
        mask = ecdh_info.mask;
        key amount = ecdh_info.amount;
        key C = rv.outPk[i].mask;
+        if (is_rct_bulletproof_plus(rv.type))
+          C = scalarmult8(C);
        DP("C");
        DP(C);
        key Ctmp;
@ -1619,7 +1807,7 @@ namespace rct {
    }

    xmr_amount decodeRctSimple(const rctSig & rv, const key & sk, unsigned int i, key &mask, hw::device &hwdev) {
-        CHECK_AND_ASSERT_MES(rv.type == RCTTypeSimple || rv.type == RCTTypeBulletproof || rv.type == RCTTypeBulletproof2 || rv.type == RCTTypeCLSAG || rv.type == RCTTypeBulletproofPlus,
+        CHECK_AND_ASSERT_MES(rv.type == RCTTypeSimple || rv.type == RCTTypeBulletproof || rv.type == RCTTypeBulletproof2 || rv.type == RCTTypeSimpleBulletproof || rv.type == RCTTypeCLSAG || rv.type == RCTTypeBulletproofPlus,
            false, "decodeRct called on non simple rctSig");
        CHECK_AND_ASSERT_THROW_MES(i < rv.ecdhInfo.size(), "Bad index");
        CHECK_AND_ASSERT_THROW_MES(rv.outPk.size() == rv.ecdhInfo.size(), "Mismatched sizes of rv.outPk and rv.ecdhInfo");
@ -1630,6 +1818,8 @@ namespace rct {
        mask = ecdh_info.mask;
        key amount = ecdh_info.amount;
        key C = rv.outPk[i].mask;
+        if (is_rct_bulletproof_plus(rv.type))
+          C = scalarmult8(C);
        DP("C");
        DP(C);
        key Ctmp;
--- a/src/ringct/rctSigs.h
+++ b/src/ringct/rctSigs.h
@ -127,6 +127,9 @@ namespace rct {
    rctSig genRct(const key &message, const ctkeyV & inSk, const ctkeyV  & inPk, const keyV & destinations, const std::vector<xmr_amount> & amounts, const keyV &amount_keys, const int mixin, const RCTConfig &rct_config, hw::device &hwdev);
    rctSig genRctSimple(const key & message, const ctkeyV & inSk, const ctkeyV & inPk, const keyV & destinations, const std::vector<xmr_amount> & inamounts, const std::vector<xmr_amount> & outamounts, const keyV &amount_keys, xmr_amount txnFee, unsigned int mixin, const RCTConfig &rct_config, hw::device &hwdev);
    rctSig genRctSimple(const key & message, const ctkeyV & inSk, const keyV & destinations, const std::vector<xmr_amount> & inamounts, const std::vector<xmr_amount> & outamounts, xmr_amount txnFee, const ctkeyM & mixRing, const keyV &amount_keys, const std::vector<unsigned int> & index, ctkeyV &outSk, const RCTConfig &rct_config, hw::device &hwdev);
+    rctSig genRctSimple_old(const key & message, const ctkeyV & inSk, const ctkeyV & inPk, const keyV & destinations, const std::vector<xmr_amount> & inamounts, const std::vector<xmr_amount> & outamounts, const keyV &amount_keys, xmr_amount txnFee, unsigned int mixin, const RCTConfig &rct_config, hw::device &hwdev);
+    rctSig genRctSimple_old(const key & message, const ctkeyV & inSk, const keyV & destinations, const std::vector<xmr_amount> & inamounts, const std::vector<xmr_amount> & outamounts, xmr_amount txnFee, const ctkeyM & mixRing, const keyV &amount_keys, const std::vector<unsigned int> & index, ctkeyV &outSk, const RCTConfig &rct_config, hw::device &hwdev);
+
    bool verRct(const rctSig & rv, bool semantics);
    static inline bool verRct(const rctSig & rv) { return verRct(rv, true) && verRct(rv, false); }
    bool verRctSemanticsSimple(const rctSig & rv);
--- a/src/ringct/rctTypes.cpp
+++ b/src/ringct/rctTypes.cpp
@ -193,6 +193,7 @@ namespace rct {
        switch (type)
        {
            case RCTTypeSimple:
+            case RCTTypeSimpleBulletproof:
            case RCTTypeBulletproof:
            case RCTTypeBulletproof2:
            case RCTTypeCLSAG:
@ -207,6 +208,8 @@ namespace rct {
    {
        switch (type)
        {
+            case RCTTypeSimpleBulletproof:
+            case RCTTypeFullBulletproof:
            case RCTTypeBulletproof:
            case RCTTypeBulletproof2:
            case RCTTypeCLSAG:
@ -216,6 +219,23 @@ namespace rct {
        }
    }

+    bool is_rct_old_bulletproof(int type)
+    {
+      switch (type)
+        {
+        case RCTTypeSimpleBulletproof:
+        case RCTTypeFullBulletproof:
+          return true;
+        default:
+          return false;
+        }
+    }
+
+    bool is_rct_new_bulletproof(int type)
+    {
+      return is_rct_bulletproof(type) && !is_rct_old_bulletproof(type);
+    }
+
    bool is_rct_bulletproof_plus(int type)
    {
        switch (type)
@ -238,6 +258,26 @@ namespace rct {
                return false;
        }
    }
+    
+    size_t n_bulletproof_v1_amounts(const Bulletproof &proof)
+    {
+        CHECK_AND_ASSERT_MES(proof.L.size() >= 6, 0, "Invalid bulletproof L size");
+        CHECK_AND_ASSERT_MES(proof.L.size() <= 31, 0, "Insane bulletproof L size");
+        return 1 << (proof.L.size() - 6);
+    }
+    size_t n_bulletproof_v1_amounts(const std::vector<Bulletproof> &proofs)
+    {
+        size_t n = 0;
+        for (const Bulletproof &proof: proofs)
+        {
+            size_t n2 = n_bulletproof_v1_amounts(proof);
+            CHECK_AND_ASSERT_MES(n2 < std::numeric_limits<uint32_t>::max() - n, 0, "Invalid number of bulletproofs");
+            if (n2 == 0)
+                return 0;
+            n += n2;
+        }
+        return n;
+    }

    bool is_rct_clsag(int type)
    {
@ -251,22 +291,19 @@ namespace rct {
        }
    }

-    static size_t n_bulletproof_amounts_base(const size_t L_size, const size_t R_size, const size_t V_size, const size_t max_outputs)
+    size_t n_bulletproof_amounts(const Bulletproof &proof)
    {
-        CHECK_AND_ASSERT_MES(L_size >= 6, 0, "Invalid bulletproof L size");
-        CHECK_AND_ASSERT_MES(L_size == R_size, 0, "Mismatched bulletproof L/R size");
+        CHECK_AND_ASSERT_MES(proof.L.size() >= 6, 0, "Invalid bulletproof L size");
+        CHECK_AND_ASSERT_MES(proof.L.size() == proof.R.size(), 0, "Mismatched bulletproof L/R size");
        static const size_t extra_bits = 4;
-        CHECK_AND_ASSERT_MES((1 << extra_bits) == max_outputs, 0, "log2(max_outputs) is out of date");
-        CHECK_AND_ASSERT_MES(L_size <= 6 + extra_bits, 0, "Invalid bulletproof L size");
-        CHECK_AND_ASSERT_MES(V_size <= (1u<<(L_size-6)), 0, "Invalid bulletproof V/L");
-        CHECK_AND_ASSERT_MES(V_size * 2 > (1u<<(L_size-6)), 0, "Invalid bulletproof V/L");
-        CHECK_AND_ASSERT_MES(V_size > 0, 0, "Empty bulletproof");
-        return V_size;
+        static_assert((1 << extra_bits) == BULLETPROOF_MAX_OUTPUTS, "log2(BULLETPROOF_MAX_OUTPUTS) is out of date");
+        CHECK_AND_ASSERT_MES(proof.L.size() <= 6 + extra_bits, 0, "Invalid bulletproof L size");
+        CHECK_AND_ASSERT_MES(proof.V.size() <= (1u<<(proof.L.size()-6)), 0, "Invalid bulletproof V/L");
+        CHECK_AND_ASSERT_MES(proof.V.size() * 2 > (1u<<(proof.L.size()-6)), 0, "Invalid bulletproof V/L");
+        CHECK_AND_ASSERT_MES(proof.V.size() > 0, 0, "Empty bulletproof");
+        return proof.V.size();
    }

-    size_t n_bulletproof_amounts(const Bulletproof &proof) { return n_bulletproof_amounts_base(proof.L.size(), proof.R.size(), proof.V.size(), BULLETPROOF_MAX_OUTPUTS); }
-    size_t n_bulletproof_plus_amounts(const BulletproofPlus &proof) { return n_bulletproof_amounts_base(proof.L.size(), proof.R.size(), proof.V.size(), BULLETPROOF_PLUS_MAX_OUTPUTS); }
-
    size_t n_bulletproof_amounts(const std::vector<Bulletproof> &proofs)
    {
        size_t n = 0;
@ -281,6 +318,43 @@ namespace rct {
        return n;
    }

+    size_t n_bulletproof_max_amounts(const Bulletproof &proof)
+    {
+        CHECK_AND_ASSERT_MES(proof.L.size() >= 6, 0, "Invalid bulletproof L size");
+        CHECK_AND_ASSERT_MES(proof.L.size() == proof.R.size(), 0, "Mismatched bulletproof L/R size");
+        static const size_t extra_bits = 4;
+        static_assert((1 << extra_bits) == BULLETPROOF_MAX_OUTPUTS, "log2(BULLETPROOF_MAX_OUTPUTS) is out of date");
+        CHECK_AND_ASSERT_MES(proof.L.size() <= 6 + extra_bits, 0, "Invalid bulletproof L size");
+        return 1 << (proof.L.size() - 6);
+    }
+
+    size_t n_bulletproof_max_amounts(const std::vector<Bulletproof> &proofs)
+    {
+        size_t n = 0;
+        for (const Bulletproof &proof: proofs)
+        {
+            size_t n2 = n_bulletproof_max_amounts(proof);
+            CHECK_AND_ASSERT_MES(n2 < std::numeric_limits<uint32_t>::max() - n, 0, "Invalid number of bulletproofs");
+            if (n2 == 0)
+                return 0;
+            n += n2;
+        }
+        return n;
+    }
+
+    size_t n_bulletproof_plus_amounts(const BulletproofPlus &proof)
+    {
+        CHECK_AND_ASSERT_MES(proof.L.size() >= 6, 0, "Invalid bulletproof L size");
+        CHECK_AND_ASSERT_MES(proof.L.size() == proof.R.size(), 0, "Mismatched bulletproof L/R size");
+        static const size_t extra_bits = 4;
+        static_assert((1 << extra_bits) == BULLETPROOF_PLUS_MAX_OUTPUTS, "log2(BULLETPROOF_PLUS_MAX_OUTPUTS) is out of date");
+        CHECK_AND_ASSERT_MES(proof.L.size() <= 6 + extra_bits, 0, "Invalid bulletproof L size");
+        CHECK_AND_ASSERT_MES(proof.V.size() <= (1u<<(proof.L.size()-6)), 0, "Invalid bulletproof V/L");
+        CHECK_AND_ASSERT_MES(proof.V.size() * 2 > (1u<<(proof.L.size()-6)), 0, "Invalid bulletproof V/L");
+        CHECK_AND_ASSERT_MES(proof.V.size() > 0, 0, "Empty bulletproof");
+        return proof.V.size();
+    }
+
    size_t n_bulletproof_plus_amounts(const std::vector<BulletproofPlus> &proofs)
    {
        size_t n = 0;
@ -295,30 +369,14 @@ namespace rct {
        return n;
    }

-    static size_t n_bulletproof_max_amounts_base(size_t L_size, size_t R_size, size_t max_outputs)
+    size_t n_bulletproof_plus_max_amounts(const BulletproofPlus &proof)
    {
-        CHECK_AND_ASSERT_MES(L_size >= 6, 0, "Invalid bulletproof L size");
-        CHECK_AND_ASSERT_MES(L_size == R_size, 0, "Mismatched bulletproof L/R size");
+        CHECK_AND_ASSERT_MES(proof.L.size() >= 6, 0, "Invalid bulletproof L size");
+        CHECK_AND_ASSERT_MES(proof.L.size() == proof.R.size(), 0, "Mismatched bulletproof L/R size");
        static const size_t extra_bits = 4;
-        CHECK_AND_ASSERT_MES((1 << extra_bits) == max_outputs, 0, "log2(max_outputs) is out of date");
-        CHECK_AND_ASSERT_MES(L_size <= 6 + extra_bits, 0, "Invalid bulletproof L size");
-        return 1 << (L_size - 6);
-    }
-    size_t n_bulletproof_max_amounts(const Bulletproof &proof) { return n_bulletproof_max_amounts_base(proof.L.size(), proof.R.size(), BULLETPROOF_MAX_OUTPUTS); }
-    size_t n_bulletproof_plus_max_amounts(const BulletproofPlus &proof) { return n_bulletproof_max_amounts_base(proof.L.size(), proof.R.size(), BULLETPROOF_PLUS_MAX_OUTPUTS); }
-
-    size_t n_bulletproof_max_amounts(const std::vector<Bulletproof> &proofs)
-    {
-        size_t n = 0;
-        for (const Bulletproof &proof: proofs)
-        {
-            size_t n2 = n_bulletproof_max_amounts(proof);
-            CHECK_AND_ASSERT_MES(n2 < std::numeric_limits<uint32_t>::max() - n, 0, "Invalid number of bulletproofs");
-            if (n2 == 0)
-                return 0;
-            n += n2;
-        }
-        return n;
+        static_assert((1 << extra_bits) == BULLETPROOF_PLUS_MAX_OUTPUTS, "log2(BULLETPROOF_PLUS_MAX_OUTPUTS) is out of date");
+        CHECK_AND_ASSERT_MES(proof.L.size() <= 6 + extra_bits, 0, "Invalid bulletproof L size");
+        return 1 << (proof.L.size() - 6);
    }

    size_t n_bulletproof_plus_max_amounts(const std::vector<BulletproofPlus> &proofs)
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
wowario	589efde6b3	update README	2024-03-15 11:13:11 +03:00
jeffro256	cb63c922f8	ringct: fix trunc_amount field name change Caused in commit 05231400cebfeedbbc0a5386f38a033bba6314b3, PR #9035.	2024-03-15 10:22:41 +03:00
jeffro256	eeec04520d	Revert "http_client: reduce number of packets sent for small bodies" This reverts commit `e0b2123c32`.	2024-03-15 10:22:07 +03:00
selsta	3605ec6419	depends: add riscv64 linux build tag	2024-03-15 10:21:48 +03:00
dsc	dad8e3cadd	Add CoinsInfo->description and 'preferred_inputs' to create_transaction	2024-03-10 11:57:34 +03:00
wowario	c2d9ac9d16	update checkpoints	2024-03-10 00:06:15 +03:00
wowario	e707dafd04	bump version	2024-03-09 16:22:47 +03:00
dsc	aa19aa8fc3	enable refresh thread	2024-03-09 16:18:42 +03:00
dsc	269fd51d34	add hex() and txKey() to PendingTransaction	2024-03-09 16:18:10 +03:00
dsc	ea1ff89671	compile fix	2024-03-09 16:17:48 +03:00
wowario	a46db6fbf9	Update RandomWOW to 1.2.1-wow	2024-03-09 16:09:46 +03:00
wowario	1fb180a69b	add more seeds	2024-03-09 16:07:45 +03:00
wowario	cf5bfd0cc4	disable mismatched daemon check	2024-03-09 16:07:09 +03:00
wowario	6a5303f21b	remove nudge in daemon_is_outdated	2024-03-09 16:06:54 +03:00
wowario	5a127e006e	[README] bump version	2024-03-09 16:06:20 +03:00
wowario	93e542dc55	update checkpoints	2024-03-09 16:06:07 +03:00
wowario	cae358334e	remove nudge in num_mainnet_hard_forks	2024-03-09 16:05:20 +03:00
_XxFedexX_	f0e9542c06	Add _xxfedexx_'s PGP key	2024-03-09 16:04:57 +03:00
wowario	2f3f3b7a6e	remove rx_set code	2024-03-09 16:04:31 +03:00
wowario	b414a0659d	use rx_set_miner_thread after RX_BLOCK_VERSION	2024-03-09 16:04:16 +03:00
thotbot	3f78176f3d	Import transaction	2024-03-09 16:04:03 +03:00
moneromooo-monero	f438928ed8	simplewallet: print fully qualified filename for new wallets from time to time, some people don't realize their wallets get created in their current working directory	2024-03-09 16:03:45 +03:00
wowario	b07e533a8f	show wallet info	2024-03-09 16:03:29 +03:00
hinto-janaiyo	8ccfd46a41	simplewallet/wallet2: set option - show-detailed-prompt	2024-03-09 16:03:21 +03:00
thotbot	e60954b619	Misc. network related - Add interface for bytes sent/received - Allow wallet refresh while daemon is not synchronized - emit success boolean for refreshed() - don't call refreshThreadFunc (we don't need it) - lower rpc timeout from 3m30s (?!) to 10 seconds	2024-03-09 16:01:32 +03:00
thotbot	1ed861bff8	Skip unneeded blocks in fast refresh	2024-03-09 16:01:31 +03:00
thotbot	8b467e98a4	subaddressIndex()	2024-03-09 16:01:31 +03:00
thotbot	4f8ad5bfac	Print wallet cache	2024-03-09 16:01:30 +03:00
thotbot	3234b5fe62	Misc. wallet API and wallet2 changes	2024-03-09 16:01:30 +03:00
thotbot	e6cc37e9b0	Coins	2024-03-09 16:01:30 +03:00
thotbot	fcffffdd5d	Offline transaction signing	2024-03-09 16:01:29 +03:00
wowario	77ca74ba54	update checkpoints	2024-03-09 16:00:17 +03:00
wowario	8d78cedaec	connect to updated seeds	2024-03-09 16:00:17 +03:00
wowario	e8bec95650	add wowario PGP key	2024-03-09 16:00:16 +03:00
w0wΔri0	36dc60fdfd	Revoke old pgp key	2024-03-09 16:00:16 +03:00
wowario	f742aed6a3	support old ass BPs	2024-03-09 16:00:16 +03:00
wowario	b602ab02ee	revert sanity check	2024-03-09 16:00:16 +03:00
wowario	f409249b78	wallet seed message spacing	2024-03-09 16:00:15 +03:00
wowario	0bb22452ac	remove warning reusing keys	2024-03-09 16:00:15 +03:00
wowario	8337a81ef5	remove warning about background mining	2024-03-09 16:00:15 +03:00
wowario	6ca2369b67	add clear screen command	2024-03-09 16:00:14 +03:00
wowario	934cd71608	wownero chan	2024-03-09 16:00:14 +03:00
wowario	b2906602a4	update README.md	2024-03-09 16:00:14 +03:00
wowario	df381eaa84	update checkpoints	2024-03-09 16:00:14 +03:00
wowario	83a0e91e23	set fork height	2024-03-09 16:00:13 +03:00
wowario	26d039db0a	from v20, limit tx extra size	2024-03-09 16:00:13 +03:00
wowario	662a2993d3	Debug level No incoming connections	2024-03-09 16:00:13 +03:00
wowario	65570252f2	update checkpoints	2024-03-09 16:00:13 +03:00
wowario	eff55d073c	uri remainder	2024-03-09 16:00:12 +03:00
wowario	d1441bc034	update README.md	2024-03-09 16:00:10 +03:00
wowario	5e50141c4a	remove testnet/stagenet fork heights/blocks	2024-03-09 15:58:14 +03:00
wowario	8c081b4b02	don't request pre-bulletprooof pruned blocks	2024-03-09 15:58:14 +03:00
wowario	917970cebf	change to debug level	2024-03-09 15:58:13 +03:00
wowario	c7190cdd0f	rename ringdb-dir	2024-03-09 15:58:13 +03:00
wowario	a177241046	mod variant4_random_math	2024-03-09 15:58:13 +03:00
wowario	e224b4af93	support old BP	2024-03-09 15:58:12 +03:00
wowario	0c4915d707	vote by block	2024-03-09 15:58:12 +03:00
wowario	ff34adf8b7	tidy up miner msgs	2024-03-09 15:58:12 +03:00
wowario	48841789cb	miner block header signing	2024-03-09 15:58:11 +03:00
wowario	2ddaa7835c	difficulty is fun	2024-03-09 15:58:11 +03:00
wowario	aa7564806d	shorten timestamp check window	2024-03-09 15:58:11 +03:00
wowario	a0a90ada1a	limit future blk time to 10 min	2024-03-09 15:58:11 +03:00
wowario	7b9bfb73b1	bump unlock time to 288 blks	2024-03-09 15:58:10 +03:00
wowario	642beba4af	broadcast donation sub-address	2024-03-09 15:58:10 +03:00
wowario	cf8e878869	revert Preserve commitment format inside transactions #8277	2024-03-09 15:58:10 +03:00
wowario	6afdd7894a	add systemd file	2024-03-09 15:58:09 +03:00
wowario	7f01ebbf29	update gitian	2024-03-09 15:58:09 +03:00
wowario	6fee906b1c	update Dockerfile	2024-03-09 15:58:09 +03:00
wowario	0fd82de0be	adjust approx_blockchain_height	2024-03-09 15:58:09 +03:00
wowario	68f1f2b2c3	add wowario gpg key	2024-03-09 15:58:08 +03:00
wowario	ddf990f394	config wallet2 settings	2024-03-09 15:58:08 +03:00
wowario	196a3756d6	set dev fund address	2024-03-09 15:58:08 +03:00
wowario	4ed9b68d59	add seed nodes	2024-03-09 15:58:08 +03:00
wowario	37195f2128	set name of daemon stdout	2024-03-09 15:58:07 +03:00
wowario	e71bef4496	set last v1 block	2024-03-09 15:58:07 +03:00
wowario	a04690c66b	set pow variants	2024-03-09 15:58:07 +03:00
wowario	9c3fb6c243	set quick height for syncing	2024-03-09 15:58:07 +03:00
wowario	463de38ef5	send dump log to wowario	2024-03-09 15:58:06 +03:00
wowario	c474334f41	set genesis block timestamp	2024-03-09 15:58:06 +03:00
wowario	ce3a67ed21	set decimal point	2024-03-09 15:58:06 +03:00
wowario	fb39891031	add forks and checkpoints	2024-03-09 15:58:04 +03:00
wowario	1c44d89030	wownero skin pack	2024-03-09 15:56:23 +03:00
wowario	da6a2dc2c5	bump RX block version	2024-03-09 15:54:20 +03:00
wowario	d6a3511d59	correct length of addresses	2024-03-09 15:54:20 +03:00
wowario	6b8e245aea	move utilities to debug build	2024-03-09 15:54:20 +03:00
wowario	917edfbec9	automatic submodule update	2024-03-09 15:54:20 +03:00
wowario	5964374c4b	Doxygen off	2024-03-09 15:54:19 +03:00
wowario	a5d50332ca	trezor support off	2024-03-09 15:54:17 +03:00
wowario	73f52ea6b9	turn off tests	2024-03-09 15:52:37 +03:00
wowario	1cae37348a	gitian: copy config file	2024-03-09 15:48:39 +03:00
wowario	2b78ff8117	add RandomWOW	2024-03-09 15:48:35 +03:00
wowario	e5016a6f8e	show full version	2024-03-09 15:46:17 +03:00
wowario	a93dcc1962	remove moneropulse urls	2024-03-09 15:46:17 +03:00
wowario	a25032cc1e	remove monero tx bug fixes	2024-03-09 15:46:17 +03:00
wowario	2a4e1c6913	bump ring size to 22	2024-03-09 15:46:16 +03:00
wowario	3271844ab5	initialize genesis block	2024-03-09 15:46:16 +03:00
wowario	7af83ced4c	config cryptonote	2024-03-09 15:46:15 +03:00
luigi1111	ef3e18b51b	Merge pull request #9226 `b5b72ae` Fixed mempool pruning (SChernykh)	2024-03-08 20:23:52 -05:00
SChernykh	b5b72ae05c	Fixed mempool pruning - Fixed undefined behavior after a call to `remove_tx_from_transient_lists` (it used an invalid iterator) - Fixed `txCompare` (it wasn't strictly weak ordered)	2024-03-08 21:03:41 +01:00
luigi1111	5eb3fc29bb	Merge pull request #9223 `36ee12b` get_block_template_backlog: better sorting logic (SChernykh)	2024-03-08 13:46:09 -05:00
luigi1111	c225a1f25b	Merge pull request #9224 `eeb7c7c` tx_memory_pool: make double spends a no-drop offense (jeffro256)	2024-03-08 10:49:17 -05:00
luigi1111	ff15cb2f04	Merge pull request #9220 `32b3a56` wallet2: adjust fee during backlog, fix set priority (selsta)	2024-03-08 10:44:12 -05:00
jeffro256	eeb7c7c546	tx_memory_pool: make double spends a no-drop offense Nodes who see different txs in a double spend attack will drop each other, splitting the network. Issue found by @boog900.	2024-03-08 08:14:06 -06:00
SChernykh	36ee12bd8d	get_block_template_backlog: better sorting logic std::sort is unstable, so it can return random sets of transactions when mempool has many transactions with the same fee/byte. It can result in p2pool mining empty blocks sometimes because it doesn't pick up "new" transactions immediately.	2024-03-08 14:51:33 +01:00
selsta	32b3a56313	wallet2: adjust fee during backlog, fix set priority	2024-03-08 14:12:17 +01:00
luigi1111	b23116424d	Merge pull request #9217 `7807f56` unit_tests: fix strtoul unit test (jeffro256)	2024-03-07 21:38:04 -05:00
jeffro256	7807f569e4	unit_tests: fix strtoul unit test	2024-03-07 16:10:01 +01:00
luigi1111	68e40ea2a7	Merge pull request #9158 `33e3f72` serialization: fix infinite loops and clean up dispatching (jeffro256)	2024-02-24 10:19:58 -05:00
luigi1111	c6ff0d3820	Merge pull request #9136 `f2360a7` build: prepare v0.18.3.2 (selsta)	2024-02-24 10:18:40 -05:00
luigi1111	0d2f515ecc	Merge pull request #9190 `c97c2ec` docs: omit i2p port number from ANONYMITY_NETWORKS (selsta)	2024-02-24 10:17:25 -05:00
luigi1111	522d82276e	Merge pull request #9188 `0cc8f7a` cryptonote_core: early out on out of bounds scaling parameter (selsta)	2024-02-24 10:16:13 -05:00
luigi1111	4f6f6d9e27	Merge pull request #9178 `b987870` depends: openssl: update to 3.0.13 (tobtoht) `3aabfcf` depends: unbound: update to 1.19.1 (tobtoht) `8322f9c` depends: expat: update to 2.6.0 (tobtoht)	2024-02-24 10:14:25 -05:00
luigi1111	3872753202	Merge pull request #9159 `fbd0b19` remove ARCH=x86-64 from release-static (woodser)	2024-02-24 10:09:28 -05:00
luigi1111	13ed9d501b	Merge pull request #9156 `052df1b` Zero initialize rctSigBase elements (Lee ! Clagett)	2024-02-24 10:08:33 -05:00
luigi1111	b335433204	Merge pull request #9145 `f5b8634` Add <cstdint> to aligned test (Lee ! Clagett)	2024-02-24 10:07:23 -05:00
luigi1111	8a1e49664e	Merge pull request #9142 `98ee46f` Disable/fix ports with I2P (Lee Clagett)	2024-02-24 10:06:26 -05:00
luigi1111	2f912f8a58	Merge pull request #9130 `dfb990e` wallet: mitigate statistical dependence for decoy selection within rings (jeffro256)	2024-02-24 10:01:09 -05:00
luigi1111	81f113dd8c	Merge pull request #9008 `9a89e2d` wallet2: call on_reorg callback in handle_reorg (j-berman) `1df5630` wallet2: add on_reorg callback (Crypto City)	2024-02-24 09:58:30 -05:00
luigi1111	f9a7f2a136	Merge pull request #8945 `51d7a69` wallet: feature: transfer amount with fee included (jeffro256)	2024-02-24 09:56:28 -05:00
selsta	c97c2ec01c	docs: omit i2p port number from ANONYMITY_NETWORKS	2024-02-21 01:03:11 +01:00
jeffro256	51d7a6921c	wallet: feature: transfer amount with fee included To transfer ~5 XMR to an address such that your balance drops by exactly 5 XMR, provide a `subtractfeefrom` flag to the `transfer` command. For example: transfer 76bDHojqFYiFCCYYtzTveJ8oFtmpNp3X1TgV2oKP7rHmZyFK1RvyE4r8vsJzf7SyNohMnbKT9wbcD3XUTgsZLX8LU5JBCfm 5 subtractfeefrom=all If my walet balance was exactly 30 XMR before this transaction, it will be exactly 25 XMR afterwards and the destination address will receive slightly less than 5 XMR. You can manually select which destinations fund the transaction fee and which ones do not by providing the destination index. For example: transfer 75sr8AAr... 3 74M7W4eg... 4 7AbWqDZ6... 5 subtractfeefrom=0,2 This will drop your balance by exactly 12 XMR including fees and will spread the fee cost proportionally (3:5 ratio) over destinations with addresses `75sr8AAr...` and `7AbWqDZ6...`, respectively. Disclaimer: This feature was paid for by @LocalMonero.	2024-02-20 17:08:42 -06:00
selsta	f2360a725e	build: prepare v0.18.3.2	2024-02-20 15:37:47 +01:00
selsta	0cc8f7aaa3	cryptonote_core: early out on out of bounds scaling parameter	2024-02-20 15:21:27 +01:00
tobtoht	b987870553	depends: openssl: update to 3.0.13	2024-02-18 23:17:05 +01:00
tobtoht	3aabfcfce5	depends: unbound: update to 1.19.1	2024-02-18 23:16:41 +01:00
tobtoht	8322f9c4f5	depends: expat: update to 2.6.0	2024-02-18 23:16:05 +01:00
woodser	fbd0b19fc8	remove ARCH=x86-64 from release-static	2024-02-10 08:37:35 -05:00
jeffro256	33e3f72d24	serialization: fix infinite loops and clean up dispatching Resolves #8687	2024-02-08 13:22:33 -06:00
Lee ! Clagett	052df1b28c	Zero initialize rctSigBase elements	2024-02-06 13:23:10 -05:00
Lee Clagett	98ee46f249	Disable/fix ports with I2P	2024-01-30 13:36:21 -05:00
Lee ! Clagett	f5b86342e8	Add <cstdint> to aligned test	2024-01-29 21:40:50 -05:00
jeffro256	dfb990e8bb	wallet: mitigate statistical dependence for decoy selection within rings Since we are required to check for uniqueness of decoy picks within any given ring, and since some decoy picks may fail due to unlock time or malformed EC points, the wallet2 decoy selection code was building up a larger than needed unique set of decoys for each ring according to a certain distribution without replacement. After filtering out the outputs that it couldn't use, it chooses from the remaining decoys uniformly random without replacement. The problem with this is that the picks later in the picking process are not independent from the picks earlier in the picking process, and the later picks do not follow the intended decoy distribution as closely as the earlier picks. To understand this intuitively, imagine that you have 1023 marbles. You label 512 marbles with the letter A, label 256 with the letter B, so on and so forth, finally labelling one marble with the letter J. You put them all into a bag, shake it well, and pick 8 marbles from the bag, but everytime you pick a marble of a certain letter, you remove all the other marbles from that bag with the same letter. That very first pick, the odds of picking a certain marble are exactly how you would expect: you are twice as likely to pick A as you are B, twice as likely to pick B as you are C, etc. However, on the second pick, the odds of getting the first pick are 0%, and the chances for everything else is higher. As you go down the line, your picked marbles will have letters that are increasingly more unlikely to pick if you hadn't remove the other marbles. In other words, the distribution of the later marbles will be more "skewed" in comparison to your original distribution of marbles. In Monero's decoy selection, this same statistical effect applies. It is not as dramatic since the distribution is not so steep, and we have more unique values to choose from, but the effect is measureable. Because of the protocol rules, we cannot have duplicate ring members, so unless that restriction is removed, we will never have perfectly independent picking. However, since the earlier picks are less affected by this statistical effect, the workaround that this commit offers is to store the order that the outputs were picked and commit to this order after fetching output information over RPC.	2024-01-19 13:31:15 -06:00
luigi1111	8eab181fe1	Merge pull request #9080 `47d8899` Fix missing checks for IsObject in ZMQ jsonrpc reading (Lee Clagett)	2024-01-18 18:03:43 -05:00
luigi1111	9a70f43440	Merge pull request #9053 `fe746dc` Fix EAGAIN bug in ZMQ-RPC/ZMQ-PUB (Lee ! Clagett)	2024-01-18 17:57:54 -05:00
Lee Clagett	47d8899c90	Fix missing checks for IsObject in ZMQ jsonrpc reading	2023-11-28 18:05:15 -05:00
luigi1111	c09062087e	Merge pull request #9051 `fe47806` wallet: fix multisig key memory leak (jeffro256)	2023-11-06 09:39:19 -05:00
luigi1111	9a5f8431b4	Merge pull request #9047 `6c38c21` heed NO_COLOR environment variable (moneromooo-monero)	2023-11-06 09:36:08 -05:00
luigi1111	79107ff68f	Merge pull request #9046 `5435202` readline_buffer: disable bracketed paste escape sequences (Jeffrey Ryan)	2023-11-06 09:35:37 -05:00
luigi1111	646c3fb0d9	Merge pull request #9043 `e7d51e5` JH hash compiler workarounds (SChernykh)	2023-11-06 09:34:13 -05:00
luigi1111	c193c5e85d	Merge pull request #9039 `0f75585` multisig: better errors for small malformed kex msgs (jeffro256)	2023-11-06 09:32:18 -05:00
luigi1111	d5c667a5ad	Merge pull request #9036 `eae62a0` ringct: make ctSigBase serialization follow strict aliasing rule (jeffro256)	2023-11-06 09:29:03 -05:00
luigi1111	2fe5a5e073	Merge pull request #9034 `14ae812` cryptonote_config: include cstdint (jeffro256)	2023-11-06 09:27:51 -05:00
luigi1111	95e4fc3602	Merge pull request #9029 `5b0c274` gitian: add riscv64 support (selsta)	2023-11-06 09:25:51 -05:00
SChernykh	e7d51e5583	JH hash compiler workarounds - Fixed uninitialized `state->x` warning - Fixed broken code with `-O3` or `-Ofast` The old code is known to break GCC 10.1 and GCC 11.4	2023-11-04 21:01:47 +01:00
Lee ! Clagett	fe746dca4e	Fix EAGAIN bug in ZMQ-RPC/ZMQ-PUB	2023-11-04 13:57:28 -04:00
jeffro256	fe47806afb	wallet: fix multisig key memory leak Multisig keys per-transfer were being wiped, but not erased, which lead to a ginormous quadratic bloat the more transfers and exports you performed with the wallet.	2023-11-03 11:58:28 -05:00
moneromooo-monero	6c38c21dfd	heed NO_COLOR environment variable	2023-10-31 09:09:55 +01:00
Jeffrey Ryan	5435202450	readline_buffer: disable bracketed paste escape sequences	2023-10-31 02:31:55 -05:00
luigi1111	d9b765a3af	Merge pull request #9027 `09a88cc` Update RandomX to 1.2.1 (tevador)	2023-10-25 21:41:27 -04:00
luigi1111	72d2a610cd	Merge pull request #9022 `bdebf68` wallet2: ensure transfers and sweeps use same fee calc logic (j-berman)	2023-10-25 21:40:36 -04:00
luigi1111	2e9542d01a	Merge pull request #9020 `e0b2123` http_client: reduce number of packets sent for small bodies (jeffro256)	2023-10-25 21:40:12 -04:00
jeffro256	0f75585f64	multisig: better errors for small malformed kex msgs Resolves https://github.com/monero-project/monero/issues/8493	2023-10-25 20:38:22 -05:00
luigi1111	eb4df0aa1c	Merge pull request #8992 `0c04018` depends: openssl: update to 3.0.11 (tobtoht)	2023-10-25 21:38:01 -04:00
jeffro256	eae62a07e0	ringct: make `rctSigBase` serialization follow strict aliasing rule Accessing an object of type `char` thru an lvalue of type `crypto::hash8` is undefined behavior. https://developers.redhat.com/blog/2020/06/03/the-joys-and-perils-of-aliasing-in-c-and-c-part-2	2023-10-24 13:00:45 -05:00
jeffro256	14ae81246d	cryptonote_config: include cstdint Header was using `uint64_t` without including `<cstdint>` which caused some issues downstream for windows builds	2023-10-23 14:53:58 -05:00
selsta	5b0c27430f	gitian: add riscv64 support	2023-10-21 16:04:04 +02:00
tevador	09a88cc00e	Update RandomX to 1.2.1	2023-10-20 20:54:26 +02:00
j-berman	bdebf680bd	wallet2: ensure transfers and sweeps use same fee calc logic Ensures both transfers and sweeps use a fee that's calculated from the tx's weight. Using different logic could theoretically enable distinguishability between the two types of txs. We don't want that.	2023-10-16 01:10:05 -07:00
jeffro256	e0b2123c32	http_client: reduce number of packets sent for small bodies	2023-10-15 01:33:38 -05:00
luigi1111	2656cdf505	Merge pull request #9014 `69de381` add a test for the long term weight cache (Boog900) `810f6a6` Fix: long term block weight cache The long term block weight cache was doing a wrong calculation when adding a new block to the cache. (Boog900)	2023-10-02 15:28:11 -04:00
luigi1111	1c12d305d6	Merge pull request #9012 `fbcd8da` build: prepare v0.18.3.1 (selsta)	2023-10-02 15:26:18 -04:00
luigi1111	83d0d2338f	Merge pull request #9011 `03d51b7` wallet2: fix refresh function parameters (selsta)	2023-10-02 15:25:24 -04:00
Boog900	69de381526	add a test for the long term weight cache	2023-10-02 15:28:50 +01:00
Boog900	810f6a6cd2	Fix: long term block weight cache The long term block weight cache was doing a wrong calculation when adding a new block to the cache.	2023-10-02 15:27:31 +01:00
selsta	fbcd8da082	build: prepare v0.18.3.1	2023-10-02 12:59:37 +02:00
selsta	03d51b7cc4	wallet2: fix refresh function parameters max_blocks is last on master branch	2023-10-01 20:56:31 +02:00
j-berman	9a89e2d9e4	wallet2: call on_reorg callback in handle_reorg	2023-09-27 12:51:52 -07:00
Crypto City	1df5630f23	wallet2: add on_reorg callback	2023-09-27 12:50:34 -07:00
tobtoht	0c04018718	depends: openssl: update to 3.0.11	2023-09-19 15:51:28 +02:00
				`@ -0,0 +1 @@`
				`Subproject commit 27b099b6dd6fef6e17f58c6dfe00009e9c5df587`
				`@ -1 +0,0 @@`
				`Subproject commit 261d58c77fc5547c0aa7fdfeb58421ba7e0e6e1c`