added more secure verification of protocol_tx outputs; bumped version number

fixed logging message for adding block to separate out the burnt reward from the block reward
Merge branch 'rebase-v0.18.3.3' of https://github.com/somerandomcryptoguy/salvium into rebase-v0.18.3.3
2024-06-07 17:02:13 +01:00 · 2024-06-07 13:07:11 +01:00 · 2024-06-06 14:14:52 +01:00 · 2024-06-06 14:13:14 +01:00 · 2024-06-05 15:54:06 +01:00 · 2024-06-05 15:52:35 +01:00
203 changed files with 6835 additions and 3545 deletions
@@ -1,4 +1,4 @@
-# Copyright (c) 2014-2023, The Monero Project
+# Copyright (c) 2014-2022, The Monero Project
 #
 # All rights reserved.
 #
@@ -46,7 +46,7 @@ endif()
 cmake_minimum_required(VERSION 3.5)
 message(STATUS "CMake version ${CMAKE_VERSION}")

-project(monero)
+project(salvium)

 option (USE_CCACHE "Use ccache if a usable instance is found" ON)
 if (USE_CCACHE)
@@ -412,7 +412,7 @@ if (CMAKE_BUILD_TYPE STREQUAL "Debug")
 else()
  set(DEFAULT_BUILD_DEBUG_UTILITIES OFF)
 endif()
-option(BUILD_DEBUG_UTILITIES "Build debug utilities." ${DEFAULT_BUILD_DEBUG_UTILITIES})
+option(BUILD_DEBUG_UTILITIES "Build debug utilities." DEFAULT_BUILD_DEBUG_UTILITIES)

 if(OSSFUZZ)
  message(STATUS "Using OSS-Fuzz fuzzing system")
@@ -449,12 +449,15 @@ endif()
 # Check if we're on OpenBSD. See the README.md for build instructions.
 if(CMAKE_SYSTEM_NAME MATCHES "kOpenBSD.*|OpenBSD.*")
  set(OPENBSD TRUE)
-elseif(CMAKE_SYSTEM_NAME MATCHES "kNetBSD.*|NetBSD.*")
-  set(NETBSD TRUE)
-elseif(CMAKE_SYSTEM_NAME MATCHES ".*BSDI.*")
-  set(BSDI TRUE)
 endif()

+# TODO: check bsdi, NetBSD, to see if they need the same FreeBSD changes
+#
+# elseif(CMAKE_SYSTEM_NAME MATCHES "kNetBSD.*|NetBSD.*")
+#   set(NETBSD TRUE)
+# elseif(CMAKE_SYSTEM_NAME MATCHES ".*BSDI.*")
+#   set(BSDI TRUE)
+
 include_directories(external/rapidjson/include external/easylogging++ src contrib/epee/include external external/supercop/include)

 if(APPLE)
@@ -528,7 +531,7 @@ add_definitions("-DBLOCKCHAIN_DB=${BLOCKCHAIN_DB}")
 # Can't install hook in static build on OSX, because OSX linker does not support --wrap
 # On ARM, having libunwind package (with .so's only) installed breaks static link.
 # When possible, avoid stack tracing using libunwind in favor of using easylogging++.
-if (APPLE OR NETBSD)
+if (APPLE)
  set(DEFAULT_STACK_TRACE OFF)
  set(LIBUNWIND_LIBRARIES "")
 elseif (DEPENDS AND NOT LINUX)
@@ -701,7 +704,7 @@ endif()
 include(CheckTrezor)

 if(MSVC)
-  add_definitions("/bigobj /MP /W3 /GS- /D_CRT_SECURE_NO_WARNINGS /wd4996 /wd4345 /D_WIN32_WINNT=0x0600 /DWIN32_LEAN_AND_MEAN /DGTEST_HAS_TR1_TUPLE=0 /D__SSE4_1__")
+  add_definitions("/bigobj /MP /W3 /GS- /D_CRT_SECURE_NO_WARNINGS /wd4996 /wd4345 /D_WIN32_WINNT=0x0600 /DWIN32_LEAN_AND_MEAN /DGTEST_HAS_TR1_TUPLE=0 /FIinline_c.h /D__SSE4_1__")
  # set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /Dinline=__inline")
  set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /STACK:10485760")
  if(STATIC)
@@ -709,6 +712,7 @@ if(MSVC)
      string(REPLACE "/MD" "/MT" ${VAR} "${${VAR}}")
    endforeach()
  endif()
+  include_directories(SYSTEM src/platform/msc)
 else()
  include(TestCXXAcceptsFlag)
  message(STATUS "Building on ${CMAKE_SYSTEM_PROCESSOR} for ${ARCH}")
@@ -785,6 +789,7 @@ else()
    set(WARNINGS "${WARNINGS} -Wno-error=unused-value -Wno-error=unused-but-set-variable")
    set(MINGW_FLAG "${MINGW_FLAG} -DWIN32_LEAN_AND_MEAN")
    set(Boost_THREADAPI win32)
+    include_directories(SYSTEM src/platform/mingw)
    # mingw doesn't support LTO (multiple definition errors at link time)
    set(USE_LTO_DEFAULT false)
    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--stack,10485760")
@@ -1003,7 +1008,7 @@ else()

  set(DEBUG_FLAGS "-g3")

-  # At least some CLANGs default to not enough for monero
+  # At least some CLANGs default to not enough for Salvium
  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ftemplate-depth=900")

  if(NOT DEFINED USE_LTO_DEFAULT)
@@ -1096,7 +1101,7 @@ if(MINGW)
  set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -Wa,-mbig-obj")
  set(EXTRA_LIBRARIES mswsock;ws2_32;iphlpapi;crypt32;bcrypt)
  if(DEPENDS)
-    set(ICU_LIBRARIES iconv)
+    set(ICU_LIBRARIES icuio icui18n icuuc icudata icutu iconv)
  else()
    set(ICU_LIBRARIES icuio icuin icuuc icudt icutu iconv)
  endif()
@@ -1111,8 +1116,7 @@ elseif(CMAKE_SYSTEM_NAME MATCHES "(SunOS|Solaris)")
  set(EXTRA_LIBRARIES socket nsl resolv)
 elseif(NOT MSVC AND NOT DEPENDS)
  find_library(RT rt)
-  find_library(Z z)
-  set(EXTRA_LIBRARIES ${RT} ${Z})
+  set(EXTRA_LIBRARIES ${RT})
 endif()

 list(APPEND EXTRA_LIBRARIES ${CMAKE_DL_LIBS})
@@ -1135,9 +1139,7 @@ if (HIDAPI_FOUND OR LibUSB_COMPILE_TEST_PASSED)
  endif()
 endif()

-if(NOT OPENBSD)
-  option(USE_READLINE "Build with GNU readline support." ON)
-endif()
+option(USE_READLINE "Build with GNU readline support." ON)
 if(USE_READLINE AND NOT DEPENDS)
  find_package(Readline)
  if(READLINE_FOUND AND GNU_READLINE_FOUND)
@@ -1 +1 @@
-# Welcome to Fulmo
+# Welcome to Salvium
@@ -1,4 +1,4 @@
-# Copyright (c) 2014-2023, The Monero Project
+# Copyright (c) 2014-2022, The Monero Project
 # 
 # All rights reserved.
 # 
@@ -121,7 +121,17 @@ $(host_arch)_$(host_os)_native_toolchain?=$($(host_os)_native_toolchain)

 include funcs.mk

+CONF_PKGS := cmake-conf mxe-conf
+
+build-only-$(1)_$(3): CMAKE_RUNRESULT_FILE = $(PREFIX)/share/cmake/modules/TryRunResults.cmake
+build-only-$(1)_$(3): CMAKE_TOOLCHAIN_FILE = $(PREFIX)/$(3)/share/cmake/mxe-conf.cmake
+build-only-$(1)_$(3): CMAKE_TOOLCHAIN_DIR  = $(PREFIX)/$(3)/share/cmake/mxe-conf.d
+build-only-$(1)_$(3): CMAKE_STATIC_BOOL = $(if $(findstring shared,$(3)),OFF,ON)
+build-only-$(1)_$(3): CMAKE_SHARED_BOOL = $(if $(findstring shared,$(3)),ON,OFF)
+
+
 toolchain_path=$($($(host_arch)_$(host_os)_native_toolchain)_prefixbin)
+final_build_id_long+=$(shell $(build_SHA256SUM) config.site.in)
 final_build_id_long+=$(shell $(build_SHA256SUM) toolchain.cmake.in)
 final_build_id+=$(shell echo -n "$(final_build_id_long)" | $(build_SHA256SUM) | cut -c-$(HASH_LENGTH))
 $(host_prefix)/.stamp_$(final_build_id): $(native_packages) $(packages)
@@ -132,6 +142,26 @@ $(host_prefix)/.stamp_$(final_build_id): $(native_packages) $(packages)
 	$(AT)cd $(@D); $(foreach package,$^, tar xf $($(package)_cached); )
 	$(AT)touch $@

+$(host_prefix)/share/config.site : config.site.in $(host_prefix)/.stamp_$(final_build_id)
+	$(AT)@mkdir -p $(@D)
+	$(AT)sed -e 's|@HOST@|$(host)|' \
+            -e 's|@CC@|$(toolchain_path)$(host_CC)|' \
+            -e 's|@CXX@|$(toolchain_path)$(host_CXX)|' \
+            -e 's|@AR@|$(toolchain_path)$(host_AR)|' \
+            -e 's|@RANLIB@|$(toolchain_path)$(host_RANLIB)|' \
+            -e 's|@NM@|$(toolchain_path)$(host_NM)|' \
+            -e 's|@STRIP@|$(toolchain_path)$(host_STRIP)|' \
+            -e 's|@build_os@|$(build_os)|' \
+            -e 's|@host_os@|$(host_os)|' \
+            -e 's|@CFLAGS@|$(strip $(host_CFLAGS) $(host_$(release_type)_CFLAGS))|' \
+            -e 's|@CXXFLAGS@|$(strip $(host_CXXFLAGS) $(host_$(release_type)_CXXFLAGS))|' \
+            -e 's|@CPPFLAGS@|$(strip $(host_CPPFLAGS) $(host_$(release_type)_CPPFLAGS))|' \
+            -e 's|@LDFLAGS@|$(strip $(host_LDFLAGS) $(host_$(release_type)_LDFLAGS))|' \
+            -e 's|@allow_host_packages@|$(ALLOW_HOST_PACKAGES)|' \
+            -e 's|@debug@|$(DEBUG)|' \
+            $< > $@
+	$(AT)touch $@
+
 $(host_prefix)/share/toolchain.cmake : toolchain.cmake.in $(host_prefix)/.stamp_$(final_build_id)
 	$(AT)@mkdir -p $(@D)
 	$(AT)sed -e 's|@HOST@|$(host)|' \
@@ -176,10 +206,12 @@ check-packages:
 check-sources:
 	@$(foreach package,$(all_packages),$(call check_or_remove_sources,$(package));)

+$(host_prefix)/share/config.site: check-packages
 $(host_prefix)/share/toolchain.cmake: check-packages

 check-packages: check-sources

+install: check-packages $(host_prefix)/share/config.site
 install: check-packages $(host_prefix)/share/toolchain.cmake

 download-one: check-sources $(all_sources)
@@ -1,6 +1,6 @@
 ### Usage

-To build dependencies for the current arch+OS, from this working directory:
+To build dependencies for the current arch+OS:

 ```bash
 make
@@ -20,12 +20,10 @@ make HOST=x86_64-w64-mingw32 -j4

 A toolchain will be generated that's suitable for plugging into Monero's
 cmake. In the above example, a dir named x86_64-w64-mingw32 will be
-created. To use it for Monero, from the top of the Monero source tree:
+created. To use it for Monero:

 ```bash
-mkdir build
-cd build
-cmake -DCMAKE_TOOLCHAIN_FILE=$PWD/../contrib/depends/x86_64-w64-mingw32/share/toolchain.cmake ..
+cmake -DCMAKE_TOOLCHAIN=`pwd`/contrib/depends/x86_64-w64-mingw32
 ```

 Common `host-platform-triplets` for cross compilation are:
@@ -0,0 +1,66 @@
+depends_prefix="`dirname ${ac_site_file}`/.."
+
+cross_compiling=maybe
+host_alias=@HOST@
+ac_tool_prefix=${host_alias}-
+
+if test -z $with_boost; then
+  with_boost=$depends_prefix
+fi
+
+if test x@host_os@ = xdarwin; then
+  BREW=no
+  PORT=no
+fi
+
+PATH=$depends_prefix/native/bin:$PATH
+PKG_CONFIG="`which pkg-config` --static"
+
+# These two need to remain exported because pkg-config does not see them
+# otherwise. That means they must be unexported at the end of configure.ac to
+# avoid ruining the cache. Sigh.
+export PKG_CONFIG_PATH=$depends_prefix/share/pkgconfig:$depends_prefix/lib/pkgconfig
+if test -z "@allow_host_packages@"; then
+  export PKGCONFIG_LIBDIR=
+fi
+
+CPPFLAGS="-I$depends_prefix/include/ $CPPFLAGS"
+LDFLAGS="-L$depends_prefix/lib $LDFLAGS"
+
+CC="@CC@"
+CXX="@CXX@"
+OBJC="${CC}"
+CCACHE=$depends_prefix/native/bin/ccache
+PYTHONPATH=$depends_prefix/native/lib/python/dist-packages:$PYTHONPATH
+
+if test -n "@AR@"; then
+  AR=@AR@
+  ac_cv_path_ac_pt_AR=${AR}
+fi
+
+if test -n "@RANLIB@"; then
+  RANLIB=@RANLIB@
+  ac_cv_path_ac_pt_RANLIB=${RANLIB}
+fi
+
+if test -n "@NM@"; then
+  NM=@NM@
+  ac_cv_path_ac_pt_NM=${NM}
+fi
+
+if test -n "@debug@"; then
+  enable_reduce_exports=no
+fi
+
+if test -n "@CFLAGS@"; then
+  CFLAGS="@CFLAGS@ $CFLAGS"
+fi
+if test -n "@CXXFLAGS@"; then
+  CXXFLAGS="@CXXFLAGS@ $CXXFLAGS"
+fi
+if test -n "@CPPFLAGS@"; then
+  CPPFLAGS="@CPPFLAGS@ $CPPFLAGS"
+fi
+if test -n "@LDFLAGS@"; then
+  LDFLAGS="@LDFLAGS@ $LDFLAGS"
+fi
@@ -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),)
@@ -1,12 +1,12 @@
 package=expat
-$(package)_version=2.5.0
-$(package)_download_path=https://github.com/libexpat/libexpat/releases/download/R_2_5_0
+$(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=6f0e6e01f7b30025fa05c85fdad1e5d0ec7fd35d9f61b22f34998de11969ff67
+$(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

@@ -0,0 +1,30 @@
+package=graphviz
+$(package)_version=2.40.1
+$(package)_download_path=www.graphviz.org/pub/graphviz/stable/SOURCES/
+$(package)_file_name=$(package)-$($(package)_version).tar.gz
+$(package)_sha256_hash=ca5218fade0204d59947126c38439f432853543b0818d9d728c589dfe7f3a421
+
+define $(package)_preprocess_cmds
+  ./autogen.sh
+endef
+
+define $(package)_set_vars
+  $(package)_config_opts=--disable-shared --enable-multibye --without-purify --without-curses
+  $(package)_config_opts_release=--disable-debug-mode
+  $(package)_config_opts_linux=--with-pic
+endef
+
+define $(package)_config_cmds
+  $($(package)_autoconf)
+endef
+
+define $(package)_build_cmds
+  $(MAKE)
+endef
+
+define $(package)_stage_cmds
+  $(MAKE) DESTDIR=$($(package)_staging_dir) install
+endef
+
+define $(package)_postprocess_cmds
+endef
@@ -0,0 +1,27 @@
+package=icu4c
+$(package)_version=55.2
+$(package)_download_path=https://github.com/unicode-org/icu/releases/download/release-55-2/
+$(package)_file_name=$(package)-55_2-src.tgz
+$(package)_sha256_hash=eda2aa9f9c787748a2e2d310590720ca8bcc6252adf6b4cfb03b65bef9d66759
+$(package)_patches=icu-001-dont-build-static-dynamic-twice.patch
+
+define $(package)_set_vars
+  $(package)_build_opts=CFLAGS="$($(package)_cflags) $($(package)_cppflags) -DU_USING_ICU_NAMESPACE=0 -DU_STATIC_IMPLEMENTATION -DU_COMBINED_IMPLEMENTATION -fPIC -DENABLE_STATIC=YES -DPGKDATA_MODE=static"
+endef
+
+define $(package)_config_cmds
+  patch -p1 < $($(package)_patch_dir)/icu-001-dont-build-static-dynamic-twice.patch &&\
+  mkdir builda &&\
+  mkdir buildb &&\
+  cd builda &&\
+  sh ../source/runConfigureICU Linux &&\
+  make &&\
+  cd ../buildb &&\
+  sh ../source/runConfigureICU MinGW --enable-static=yes --disable-shared --disable-layout --disable-layoutex --disable-tests --disable-samples --prefix=$(host_prefix) --with-cross-build=`pwd`/../builda &&\
+  $(MAKE) $($(package)_build_opts)
+endef
+
+define $(package)_stage_cmds
+  cd buildb &&\
+  $(MAKE) $($(package)_build_opts) DESTDIR=$($(package)_staging_dir) install lib/*
+endef
@@ -0,0 +1,23 @@
+package=libICE
+$(package)_version=1.0.9
+$(package)_download_path=https://xorg.freedesktop.org/releases/individual/lib/
+$(package)_file_name=$(package)-$($(package)_version).tar.bz2
+$(package)_sha256_hash=8f7032f2c1c64352b5423f6b48a8ebdc339cc63064af34d66a6c9aa79759e202
+$(package)_dependencies=xtrans xproto
+
+define $(package)_set_vars
+  $(package)_config_opts=--disable-static --disable-docs --disable-specs --without-xsltproc
+  $(package)_config_opts_linux=--with-pic
+endef
+
+define $(package)_config_cmds
+  $($(package)_autoconf)
+endef
+
+define $(package)_build_cmds
+  $(MAKE)
+endef
+
+define $(package)_stage_cmds
+  $(MAKE) DESTDIR=$($(package)_staging_dir) install
+endef
@@ -0,0 +1,23 @@
+package=libSM
+$(package)_version=1.2.2
+$(package)_download_path=https://xorg.freedesktop.org/releases/individual/lib/
+$(package)_file_name=$(package)-$($(package)_version).tar.bz2
+$(package)_sha256_hash=0baca8c9f5d934450a70896c4ad38d06475521255ca63b717a6510fdb6e287bd
+$(package)_dependencies=xtrans xproto libICE
+
+define $(package)_set_vars
+  $(package)_config_opts=--without-libuuid  --without-xsltproc  --disable-docs --disable-static
+  $(package)_config_opts_linux=--with-pic
+endef
+
+define $(package)_config_cmds
+  $($(package)_autoconf)
+endef
+
+define $(package)_build_cmds
+  $(MAKE)
+endef
+
+define $(package)_stage_cmds
+  $(MAKE) DESTDIR=$($(package)_staging_dir) install
+endef
@@ -0,0 +1,20 @@
+package=native_biplist
+$(package)_version=0.9
+$(package)_download_path=https://pypi.python.org/packages/source/b/biplist
+$(package)_file_name=biplist-$($(package)_version).tar.gz
+$(package)_sha256_hash=b57cadfd26e4754efdf89e9e37de87885f9b5c847b2615688ca04adfaf6ca604
+$(package)_install_libdir=$(build_prefix)/lib/python/dist-packages
+$(package)_patches=sorted_list.patch
+
+define $(package)_preprocess_cmds
+  patch -p1 < $($(package)_patch_dir)/sorted_list.patch
+endef
+
+define $(package)_build_cmds
+    python setup.py build
+endef
+
+define $(package)_stage_cmds
+    mkdir -p $($(package)_install_libdir) && \
+    python setup.py install --root=$($(package)_staging_dir) --prefix=$(build_prefix) --install-lib=$($(package)_install_libdir)
+endef
@@ -0,0 +1,26 @@
+package=native_cdrkit
+$(package)_version=1.1.11
+$(package)_download_path=https://distro.ibiblio.org/fatdog/source/600/c
+$(package)_file_name=cdrkit-$($(package)_version).tar.bz2
+$(package)_sha256_hash=b50d64c214a65b1a79afe3a964c691931a4233e2ba605d793eb85d0ac3652564
+$(package)_patches=cdrkit-deterministic.patch
+
+define $(package)_preprocess_cmds
+  patch -p1 < $($(package)_patch_dir)/cdrkit-deterministic.patch
+endef
+
+define $(package)_config_cmds
+  cmake -DCMAKE_INSTALL_PREFIX=$(build_prefix)
+endef
+
+define $(package)_build_cmds
+  $(MAKE) genisoimage
+endef
+
+define $(package)_stage_cmds
+  $(MAKE) DESTDIR=$($(package)_staging_dir) -C genisoimage install
+endef
+
+define $(package)_postprocess_cmds
+  rm bin/isovfy bin/isoinfo bin/isodump bin/isodebug bin/devdump
+endef
@@ -0,0 +1,23 @@
+package=native_cmake
+$(package)_version=3.14.0
+$(package)_version_dot=v3.14
+$(package)_download_path=https://cmake.org/files/$($(package)_version_dot)/
+$(package)_file_name=cmake-$($(package)_version).tar.gz
+$(package)_sha256_hash=aa76ba67b3c2af1946701f847073f4652af5cbd9f141f221c97af99127e75502
+
+define $(package)_set_vars
+$(package)_config_opts=
+endef
+
+define $(package)_config_cmds
+  ./bootstrap &&\
+  ./configure $($(package)_config_opts)
+endef
+
+define $(package)_build_cmd
+  $(MAKE)
+endef
+
+define $(package)_stage_cmds
+  $(MAKE) DESTDIR=$($(package)_staging_dir) install
+endef
@@ -0,0 +1,17 @@
+package=native_ds_store
+$(package)_version=1.1.0
+$(package)_download_path=https://github.com/al45tair/ds_store/archive/
+$(package)_download_file=v$($(package)_version).tar.gz
+$(package)_file_name=$(package)-$($(package)_version).tar.gz
+$(package)_sha256_hash=a9f4c0755c6be7224ff7029e188dd262e830bb81e801424841db9eb0780ec8ed
+$(package)_install_libdir=$(build_prefix)/lib/python/dist-packages
+$(package)_dependencies=native_biplist
+
+define $(package)_build_cmds
+    python setup.py build
+endef
+
+define $(package)_stage_cmds
+    mkdir -p $($(package)_install_libdir) && \
+    python setup.py install --root=$($(package)_staging_dir) --prefix=$(build_prefix) --install-lib=$($(package)_install_libdir)
+endef
@@ -0,0 +1,22 @@
+package=native_libdmg-hfsplus
+$(package)_version=0.1
+$(package)_download_path=https://github.com/theuni/libdmg-hfsplus/archive
+$(package)_file_name=libdmg-hfsplus-v$($(package)_version).tar.gz
+$(package)_sha256_hash=6569a02eb31c2827080d7d59001869ea14484c281efab0ae7f2b86af5c3120b3
+$(package)_build_subdir=build
+
+define $(package)_preprocess_cmds
+  mkdir build
+endef
+
+define $(package)_config_cmds
+  cmake -DCMAKE_INSTALL_PREFIX:PATH=$(build_prefix)/bin ..
+endef
+
+define $(package)_build_cmds
+  $(MAKE) -C dmg
+endef
+
+define $(package)_stage_cmds
+  $(MAKE) DESTDIR=$($(package)_staging_dir) -C dmg install
+endef
@@ -0,0 +1,21 @@
+package=native_mac_alias
+$(package)_version=1.1.0
+$(package)_download_path=https://github.com/al45tair/mac_alias/archive/
+$(package)_download_file=v$($(package)_version).tar.gz
+$(package)_file_name=$(package)-$($(package)_version).tar.gz
+$(package)_sha256_hash=b10cb44ecb64fc25283fae7a9cf365d2829377d84e37b9c21100aca8757509be
+$(package)_install_libdir=$(build_prefix)/lib/python/dist-packages
+$(package)_patches=python3.patch
+
+define $(package)_preprocess_cmds
+  patch -p1 < $($(package)_patch_dir)/python3.patch
+endef
+
+define $(package)_build_cmds
+    python setup.py build
+endef
+
+define $(package)_stage_cmds
+    mkdir -p $($(package)_install_libdir) && \
+    python setup.py install --root=$($(package)_staging_dir) --prefix=$(build_prefix) --install-lib=$($(package)_install_libdir)
+endef
@@ -1,8 +1,8 @@
 package=openssl
-$(package)_version=3.0.9
+$(package)_version=3.0.13
 $(package)_download_path=https://www.openssl.org/source
 $(package)_file_name=$(package)-$($(package)_version).tar.gz
-$(package)_sha256_hash=eb1ab04781474360f77c318ab89d8c5a03abc38e63d65a603cabbf1b00a1dc90
+$(package)_sha256_hash=88525753f79d3bec27d2fa7c66aa0b92b3aa9498dafd93d7cfa4b3780cdae313

 define $(package)_set_vars
 $(package)_config_env=AR="$($(package)_ar)" ARFLAGS=$($(package)_arflags) RANLIB="$($(package)_ranlib)" CC="$($(package)_cc)"
@@ -29,7 +29,7 @@ ifneq ($(host_arch),riscv64)
 linux_packages += unwind
 endif

-mingw32_packages = sodium $(hardware_packages)
+mingw32_packages = icu4c sodium $(hardware_packages)
 mingw32_native_packages = $(hardware_native_packages)

 ifneq ($(build_os),darwin)
@@ -1,18 +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
@@ -31,6 +34,3 @@ endef
 define $(package)_stage_cmds
  $(MAKE) DESTDIR=$($(package)_staging_dir) install
 endef
-
-define $(package)_postprocess_cmds
-endef
@@ -0,0 +1,21 @@
+package=xproto
+$(package)_version=7.0.26
+$(package)_download_path=https://xorg.freedesktop.org/releases/individual/proto
+$(package)_file_name=$(package)-$($(package)_version).tar.bz2
+$(package)_sha256_hash=636162c1759805a5a0114a369dffdeccb8af8c859ef6e1445f26a4e6e046514f
+
+define $(package)_set_vars
+$(package)_config_opts=--disable-shared
+endef
+
+define $(package)_config_cmds
+  $($(package)_autoconf)
+endef
+
+define $(package)_build_cmds
+  $(MAKE)
+endef
+
+define $(package)_stage_cmds
+  $(MAKE) DESTDIR=$($(package)_staging_dir) install
+endef
@@ -0,0 +1,67 @@
+This file is part of MXE. See LICENSE.md for licensing information.
+
+Contains ad hoc patches for cross building.
+
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Tony Theodore <tonyt@logyst.com>
+Date: Fri, 12 Aug 2016 02:01:20 +1000
+Subject: [PATCH 1/3] fix windres invocation options
+
+windres doesn't recognise various gcc flags like -mms-bitfields,
+-fopenmp, -mthreads etc. (basically not `-D` or `-I`)
+
+diff --git a/Modules/Platform/Windows-windres.cmake b/Modules/Platform/Windows-windres.cmake
+index 1111111..2222222 100644
+--- a/Modules/Platform/Windows-windres.cmake
+++ b/Modules/Platform/Windows-windres.cmake
+@@ -1 +1 @@
+-set(CMAKE_RC_COMPILE_OBJECT "<CMAKE_RC_COMPILER> -O coff <DEFINES> <INCLUDES> <FLAGS> <SOURCE> <OBJECT>")
+set(CMAKE_RC_COMPILE_OBJECT "<CMAKE_RC_COMPILER> -O coff <DEFINES> <INCLUDES> <SOURCE> <OBJECT>")
+
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Tony Theodore <tonyt@logyst.com>
+Date: Tue, 25 Jul 2017 20:34:56 +1000
+Subject: [PATCH 2/3] add option to disable -isystem
+
+taken from (not accepted):
+https://gitlab.kitware.com/cmake/cmake/merge_requests/895
+
+see also:
+https://gitlab.kitware.com/cmake/cmake/issues/16291
+https://gitlab.kitware.com/cmake/cmake/issues/16919
+
+diff --git a/Modules/Compiler/GNU.cmake b/Modules/Compiler/GNU.cmake
+index 1111111..2222222 100644
+--- a/Modules/Compiler/GNU.cmake
+++ b/Modules/Compiler/GNU.cmake
+@@ -42,7 +42,7 @@ macro(__compiler_gnu lang)
+   string(APPEND CMAKE_${lang}_FLAGS_RELWITHDEBINFO_INIT " -O2 -g -DNDEBUG")
+   set(CMAKE_${lang}_CREATE_PREPROCESSED_SOURCE "<CMAKE_${lang}_COMPILER> <DEFINES> <INCLUDES> <FLAGS> -E <SOURCE> > <PREPROCESSED_SOURCE>")
+   set(CMAKE_${lang}_CREATE_ASSEMBLY_SOURCE "<CMAKE_${lang}_COMPILER> <DEFINES> <INCLUDES> <FLAGS> -S <SOURCE> -o <ASSEMBLY_SOURCE>")
+-  if(NOT APPLE OR NOT CMAKE_${lang}_COMPILER_VERSION VERSION_LESS 4) # work around #4462
+  if(NOT APPLE OR NOT CMAKE_${lang}_COMPILER_VERSION VERSION_LESS 4 AND (NOT MXE_DISABLE_INCLUDE_SYSTEM_FLAG)) # work around #4462
+     set(CMAKE_INCLUDE_SYSTEM_FLAG_${lang} "-isystem ")
+   endif()
+ endmacro()
+
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Tony Theodore <tonyt@logyst.com>
+Date: Tue, 15 Aug 2017 15:25:06 +1000
+Subject: [PATCH 3/3] add CPACK_NSIS_EXECUTABLE variable
+
+
+diff --git a/Source/CPack/cmCPackNSISGenerator.cxx b/Source/CPack/cmCPackNSISGenerator.cxx
+index 1111111..2222222 100644
+--- a/Source/CPack/cmCPackNSISGenerator.cxx
+++ b/Source/CPack/cmCPackNSISGenerator.cxx
+@@ -384,7 +384,9 @@ int cmCPackNSISGenerator::InitializeInternal()
+   }
+ #endif
+ 
+-  nsisPath = cmSystemTools::FindProgram("makensis", path, false);
+  this->SetOptionIfNotSet("CPACK_NSIS_EXECUTABLE", "makensis");
+  nsisPath = cmSystemTools::FindProgram(
+    this->GetOption("CPACK_NSIS_EXECUTABLE"), path, false);
+ 
+   if (nsisPath.empty()) {
+     cmCPackLogger(
@@ -0,0 +1,37 @@
+Don't build object files twice
+
+When passed --enable-static and --enable-shared, icu will generate
+both a shared and a static version of its libraries.
+
+However, in order to do so, it builds each and every object file
+twice: once with -fPIC (for the shared library), and once without
+-fPIC (for the static library). While admittedly building -fPIC for a
+static library generates a slightly suboptimal code, this is what all
+the autotools-based project are doing. They build each object file
+once, and they use it for both the static and shared libraries.
+
+icu builds the object files for the shared library as .o files, and
+the object files for static library as .ao files. By simply changing
+the suffix of object files used for static libraries to ".o", we tell
+icu to use the ones built for the shared library (i.e, with -fPIC),
+and avoid the double build of icu.
+
+On a fast build server, this brings the target icu build from
+3m41.302s down to 1m43.926s (approximate numbers: some other builds
+are running on the system at the same time).
+
+Signed-off-by: Thomas Petazzoni <thomas.petazzoni@free-electrons.com>
+
+Index: b/source/config/mh-linux
+===================================================================
+--- a/source/config/mh-linux
+++ b/source/config/mh-linux
+@@ -38,7 +38,7 @@
+ ## Shared object suffix
+ SO = so
+ ## Non-shared intermediate object suffix
+-STATIC_O = ao
+STATIC_O = o
+ 
+ ## Compilation rules
+ %.$(STATIC_O): $(srcdir)/%.c
@@ -0,0 +1,29 @@
+--- a/biplist/__init__.py	2014-10-26 19:03:11.000000000 +0000
+++ b/biplist/__init__.py	2016-07-19 19:30:17.663521999 +0000
+@@ -541,7 +541,7 @@
+             return HashableWrapper(n)
+         elif isinstance(root, dict):
+             n = {}
+-            for key, value in iteritems(root):
+            for key, value in sorted(iteritems(root)):
+                 n[self.wrapRoot(key)] = self.wrapRoot(value)
+             return HashableWrapper(n)
+         elif isinstance(root, list):
+@@ -616,7 +616,7 @@
+             elif isinstance(obj, dict):
+                 size = proc_size(len(obj))
+                 self.incrementByteCount('dictBytes', incr=1+size)
+-                for key, value in iteritems(obj):
+                for key, value in sorted(iteritems(obj)):
+                     check_key(key)
+                     self.computeOffsets(key, asReference=True)
+                     self.computeOffsets(value, asReference=True)
+@@ -714,7 +714,7 @@
+                 keys = []
+                 values = []
+                 objectsToWrite = []
+-                for key, value in iteritems(obj):
+                for key, value in sorted(iteritems(obj)):
+                     keys.append(key)
+                     values.append(value)
+                 for key in keys:
@@ -0,0 +1,86 @@
+--- cdrkit-1.1.11.old/genisoimage/tree.c	2008-10-21 19:57:47.000000000 -0400
+++ cdrkit-1.1.11/genisoimage/tree.c	2013-12-06 00:23:18.489622668 -0500
+@@ -1139,8 +1139,9 @@
+ scan_directory_tree(struct directory *this_dir, char *path, 
+ 						  struct directory_entry *de)
+ {
+-	DIR		*current_dir;
+        int             current_file;
+ 	char		whole_path[PATH_MAX];
+        struct dirent  **d_list;
+ 	struct dirent	*d_entry;
+ 	struct directory *parent;
+ 	int		dflag;
+@@ -1164,7 +1165,8 @@
+ 	this_dir->dir_flags |= DIR_WAS_SCANNED;
+ 
+ 	errno = 0;	/* Paranoia */
+-	current_dir = opendir(path);
+	//current_dir = opendir(path);
+        current_file = scandir(path, &d_list, NULL, alphasort);
+ 	d_entry = NULL;
+ 
+ 	/*
+@@ -1173,12 +1175,12 @@
+ 	 */
+ 	old_path = path;
+ 
+-	if (current_dir) {
+	if (current_file >= 0) {
+ 		errno = 0;
+-		d_entry = readdir(current_dir);
+		d_entry = d_list[0];
+ 	}
+ 
+-	if (!current_dir || !d_entry) {
+	if (current_file < 0 || !d_entry) {
+ 		int	ret = 1;
+ 
+ #ifdef	USE_LIBSCHILY
+@@ -1191,8 +1193,8 @@
+ 			de->isorec.flags[0] &= ~ISO_DIRECTORY;
+ 			ret = 0;
+ 		}
+-		if (current_dir)
+-			closedir(current_dir);
+		if(d_list)
+			free(d_list);
+ 		return (ret);
+ 	}
+ #ifdef	ABORT_DEEP_ISO_ONLY
+@@ -1208,7 +1210,7 @@
+ 			errmsgno(EX_BAD, "use Rock Ridge extensions via -R or -r,\n");
+ 			errmsgno(EX_BAD, "or allow deep ISO9660 directory nesting via -D.\n");
+ 		}
+-		closedir(current_dir);
+		free(d_list);
+ 		return (1);
+ 	}
+ #endif
+@@ -1250,13 +1252,13 @@
+ 		 * The first time through, skip this, since we already asked
+ 		 * for the first entry when we opened the directory.
+ 		 */
+-		if (dflag)
+-			d_entry = readdir(current_dir);
+		if (dflag && current_file >= 0)
+			d_entry = d_list[current_file];
+ 		dflag++;
+ 
+-		if (!d_entry)
+		if (current_file < 0)
+ 			break;
+-
+                current_file--;
+ 		/* OK, got a valid entry */
+ 
+ 		/* If we do not want all files, then pitch the backups. */
+@@ -1348,7 +1350,7 @@
+ 		insert_file_entry(this_dir, whole_path, d_entry->d_name);
+ #endif	/* APPLE_HYB */
+ 	}
+-	closedir(current_dir);
+	free(d_list);
+ 
+ #ifdef APPLE_HYB
+ 	/*
@@ -0,0 +1,72 @@
+diff -dur a/mac_alias/alias.py b/mac_alias/alias.py
+--- a/mac_alias/alias.py	2015-10-19 12:12:48.000000000 +0200
+++ b/mac_alias/alias.py	2016-04-03 12:13:12.037159417 +0200
+@@ -243,10 +243,10 @@
+         alias = Alias()
+         alias.appinfo = appinfo
+             
+-        alias.volume = VolumeInfo (volname.replace('/',':'),
+        alias.volume = VolumeInfo (volname.decode().replace('/',':'),
+                                    voldate, fstype, disktype,
+                                    volattrs, volfsid)
+-        alias.target = TargetInfo (kind, filename.replace('/',':'),
+        alias.target = TargetInfo (kind, filename.decode().replace('/',':'),
+                                    folder_cnid, cnid,
+                                    crdate, creator_code, type_code)
+         alias.target.levels_from = levels_from
+@@ -261,9 +261,9 @@
+                 b.read(1)
+ 
+             if tag == TAG_CARBON_FOLDER_NAME:
+-                alias.target.folder_name = value.replace('/',':')
+                alias.target.folder_name = value.decode().replace('/',':')
+             elif tag == TAG_CNID_PATH:
+-                alias.target.cnid_path = struct.unpack(b'>%uI' % (length // 4),
+                alias.target.cnid_path = struct.unpack('>%uI' % (length // 4),
+                                                            value)
+             elif tag == TAG_CARBON_PATH:
+                 alias.target.carbon_path = value
+@@ -298,9 +298,9 @@
+                 alias.target.creation_date \
+                     = mac_epoch + datetime.timedelta(seconds=seconds)
+             elif tag == TAG_POSIX_PATH:
+-                alias.target.posix_path = value
+                alias.target.posix_path = value.decode()
+             elif tag == TAG_POSIX_PATH_TO_MOUNTPOINT:
+-                alias.volume.posix_path = value
+                alias.volume.posix_path = value.decode()
+             elif tag == TAG_RECURSIVE_ALIAS_OF_DISK_IMAGE:
+                 alias.volume.disk_image_alias = Alias.from_bytes(value)
+             elif tag == TAG_USER_HOME_LENGTH_PREFIX:
+@@ -422,13 +422,13 @@
+         #       (so doing so is ridiculous, and nothing could rely on it).
+         b.write(struct.pack(b'>h28pI2shI64pII4s4shhI2s10s',
+                             self.target.kind,
+-                            carbon_volname, voldate,
+                            carbon_volname, int(voldate),
+                             self.volume.fs_type,
+                             self.volume.disk_type,
+                             self.target.folder_cnid,
+                             carbon_filename,
+                             self.target.cnid,
+-                            crdate,
+                            int(crdate),
+                             self.target.creator_code,
+                             self.target.type_code,
+                             self.target.levels_from,
+@@ -449,12 +449,12 @@
+ 
+         b.write(struct.pack(b'>hhQhhQ',
+                 TAG_HIGH_RES_VOLUME_CREATION_DATE,
+-                8, long(voldate * 65536),
+                8, int(voldate * 65536),
+                 TAG_HIGH_RES_CREATION_DATE,
+-                8, long(crdate * 65536)))
+                8, int(crdate * 65536)))
+ 
+         if self.target.cnid_path:
+-            cnid_path = struct.pack(b'>%uI' % len(self.target.cnid_path),
+            cnid_path = struct.pack('>%uI' % len(self.target.cnid_path),
+                                     *self.target.cnid_path)
+             b.write(struct.pack(b'>hh', TAG_CNID_PATH,
+                                  len(cnid_path)))
@@ -0,0 +1,29 @@
+package=protobuf
+$(package)_version=$(native_$(package)_version)
+$(package)_download_path=$(native_$(package)_download_path)
+$(package)_file_name=$(native_$(package)_file_name)
+$(package)_sha256_hash=$(native_$(package)_sha256_hash)
+$(package)_dependencies=native_$(package)
+$(package)_cxxflags=-std=c++11
+
+define $(package)_set_vars
+  $(package)_config_opts=--disable-shared --with-protoc=$(build_prefix)/bin/protoc
+  $(package)_config_opts_linux=--with-pic
+endef
+
+define $(package)_config_cmds
+  $($(package)_autoconf)
+endef
+
+define $(package)_build_cmds
+  $(MAKE) -C src libprotobuf.la
+endef
+
+define $(package)_stage_cmds
+  $(MAKE) DESTDIR=$($(package)_staging_dir) -C src install-libLTLIBRARIES install-nobase_includeHEADERS &&\
+  $(MAKE) DESTDIR=$($(package)_staging_dir) install-pkgconfigDATA
+endef
+
+define $(package)_postprocess_cmds
+  rm lib/libprotoc.a
+endef
@@ -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")
@@ -1,4 +1,4 @@
-# Copyright (c) 2014-2023, The Monero Project
+# Copyright (c) 2014-2022, The Monero Project
 # 
 # All rights reserved.
 # 
@@ -1,4 +1,4 @@
-// Copyright (c) 2019-2023, The Monero Project
+// Copyright (c) 2019-2022, The Monero Project
 //
 // All rights reserved.
 //
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2023, The Monero Project
+// Copyright (c) 2020-2022, The Monero Project

 //
 // All rights reserved.
@@ -74,7 +74,6 @@ namespace epee
  public:
    using char_type = std::uint8_t;
    using Ch = char_type;
-    using value_type = char_type;

    //! Increase internal buffer by at least `byte_stream_increase` bytes.
    byte_stream() noexcept
@@ -87,7 +86,6 @@ namespace epee
    ~byte_stream() noexcept = default;
    byte_stream& operator=(byte_stream&& rhs) noexcept;

-    std::uint8_t* data() noexcept { return buffer_.get(); }
    const std::uint8_t* data() const noexcept { return buffer_.get(); }
    std::uint8_t* tellp() const noexcept { return next_write_; }
    std::size_t available() const noexcept { return end_ - next_write_; }
@@ -1,4 +1,4 @@
-// Copyright (c) 2018-2023, The Monero Project
+// Copyright (c) 2018-2022, The Monero Project

 // 
 // All rights reserved.
@@ -1,4 +1,4 @@
-// Copyright (c) 2017-2023, The Monero Project
+// Copyright (c) 2017-2022, The Monero Project
 //
 // All rights reserved.
 //
@@ -67,9 +67,6 @@ namespace epee
      return out;
    }

-    //! Write `src` as hex to `out`. `out` must be exactly 2x in size.
-    static bool buffer(span<char> out, const span<const std::uint8_t> src) noexcept;
-
    //! Append `src` as hex to `out`.
    static void buffer(std::ostream& out, const span<const std::uint8_t> src);

@@ -1,4 +1,4 @@
-// Copyright (c) 2014-2023, The Monero Project
+// Copyright (c) 2014-2022, The Monero Project
 // 
 // All rights reserved.
 // 
@@ -1,4 +1,4 @@
-// Copyright (c) 2017-2023, The Monero Project
+// Copyright (c) 2017-2022, The Monero Project
 // 
 // All rights reserved.
 // 
@@ -1,4 +1,4 @@
-// Copyright (c) 2018-2023, The Monero Project
+// Copyright (c) 2018-2022, The Monero Project

 // 
 // All rights reserved.
@@ -54,6 +54,7 @@ namespace net_utils
  std::string convert(char val);
  std::string conver_to_url_format(const std::string& uri);
  std::string convert_from_url_format(const std::string& uri);
+  std::string convert_to_url_format_force_all(const std::string& uri);

 namespace http
 {
@@ -71,6 +72,7 @@ namespace http
    virtual bool is_connected(bool *ssl = NULL) = 0;
    virtual bool invoke(const boost::string_ref uri, const boost::string_ref method, const boost::string_ref body, std::chrono::milliseconds timeout, const http_response_info** ppresponse_info = NULL, const fields_list& additional_params = fields_list()) = 0;
    virtual bool invoke_get(const boost::string_ref uri, std::chrono::milliseconds timeout, const std::string& body = std::string(), const http_response_info** ppresponse_info = NULL, const fields_list& additional_params = fields_list()) = 0;
+    virtual bool invoke_post(const boost::string_ref uri, const std::string& body, std::chrono::milliseconds timeout, const http_response_info** ppresponse_info = NULL, const fields_list& additional_params = fields_list()) = 0;
    virtual uint64_t get_bytes_sent() const = 0;
    virtual uint64_t get_bytes_received() const = 0;
  };
@@ -1,4 +1,4 @@
-// Copyright (c) 2018-2023, The Monero Project
+// Copyright (c) 2018-2022, The Monero Project

 // 
 // All rights reserved.
@@ -8,7 +8,7 @@
 // ! (how ever if in some wonderful juristdictions that is not the case, then why not make another sub-class withat that members and licence it as epee part)
 // ! Working on above premise, IF this is valid in your juristdictions, then consider this code as released as:

-// Copyright (c) 2014-2023, The Monero Project
+// Copyright (c) 2014-2022, The Monero Project
 // 
 // All rights reserved.
 // 
@@ -1,4 +1,4 @@
-// Copyright (c) 2018-2023, The Monero Project
+// Copyright (c) 2018-2022, The Monero Project

 //
 // All rights reserved.
@@ -1,4 +1,4 @@
-// Copyright (c) 2014-2023, The Monero Project
+// Copyright (c) 2014-2022, The Monero Project
 //
 // All rights reserved.
 //
@@ -55,8 +55,20 @@ namespace net_utils
 			http_method_unknown
 		};

+		enum http_content_type
+		{
+			http_content_type_text_html,
+			http_content_type_image_gif, 
+			http_content_type_other,
+			http_content_type_not_set
+		};
+
 		typedef std::list<std::pair<std::string, std::string> > fields_list;

+		std::string get_value_from_fields_list(const std::string& param_name, const net_utils::http::fields_list& fields);
+
+		std::string get_value_from_uri_line(const std::string& param_name, const std::string& uri);
+
 		static inline void add_field(std::string& out, const boost::string_ref name, const boost::string_ref value)
 		{
 			out.append(name.data(), name.size()).append(": ");
@@ -32,6 +32,7 @@
 #include <boost/regex.hpp>
 #include <boost/optional/optional.hpp>
 #include <boost/utility/string_ref.hpp>
+//#include <mbstring.h>
 #include <algorithm>
 #include <cctype>
 #include <functional>
@@ -47,13 +48,57 @@
 #include "net_parse_helpers.h"
 #include "syncobj.h"

+//#include "shlwapi.h"
+
+//#pragma comment(lib, "shlwapi.lib")
+
 #undef MONERO_DEFAULT_LOG_CATEGORY
 #define MONERO_DEFAULT_LOG_CATEGORY "net.http"

+extern epee::critical_section gregexp_lock;
+
+
 namespace epee
 {
 namespace net_utils
 {
+
+	/*struct url 
+	{
+	public:
+		void parse(const std::string& url_s)
+		{
+			const string prot_end("://");
+			string::const_iterator prot_i = search(url_s.begin(), url_s.end(),
+				prot_end.begin(), prot_end.end());
+			protocol_.reserve(distance(url_s.begin(), prot_i));
+			transform(url_s.begin(), prot_i,
+				back_inserter(protocol_),
+				ptr_fun<int,int>(tolower)); // protocol is icase
+			if( prot_i == url_s.end() )
+				return;
+			advance(prot_i, prot_end.length());
+			string::const_iterator path_i = find(prot_i, url_s.end(), '/');
+			host_.reserve(distance(prot_i, path_i));
+			transform(prot_i, path_i,
+				back_inserter(host_),
+				ptr_fun<int,int>(tolower)); // host is icase
+			string::const_iterator query_i = find(path_i, url_s.end(), '?');
+			path_.assign(path_i, query_i);
+			if( query_i != url_s.end() )
+				++query_i;
+			query_.assign(query_i, url_s.end());
+		}
+
+		std::string protocol_;
+		std::string host_;
+		std::string path_;
+		std::string query_;
+	};*/
+
+
+
+
 	//---------------------------------------------------------------------------
 	namespace http
 	{
@@ -90,6 +135,7 @@ namespace net_utils
 			http_response_info m_response_info;
 			size_t m_len_in_summary;
 			size_t m_len_in_remain;
+			//std::string* m_ptarget_buffer;
 			boost::shared_ptr<i_sub_handler> m_pcontent_encoding_handler;
 			reciev_machine_state m_state;
 			chunked_state m_chunked_state;
@@ -254,6 +300,12 @@ namespace net_utils
 				return false;
 			}
 			//---------------------------------------------------------------------------
+			inline bool invoke_post(const boost::string_ref uri, const std::string& body, std::chrono::milliseconds timeout, const http_response_info** ppresponse_info = NULL, const fields_list& additional_params = fields_list()) override
+			{
+				CRITICAL_REGION_LOCAL(m_lock);
+				return invoke(uri, "POST", body, timeout, ppresponse_info, additional_params);
+			}
+			//---------------------------------------------------------------------------
 			bool test(const std::string &s, std::chrono::milliseconds timeout) // TEST FUNC ONLY
 			{
 				CRITICAL_REGION_LOCAL(m_lock);
@@ -63,11 +63,15 @@
  bool handled = false; \
  if(false) return true; //just a stub to have "else if"

+#define MAP_URI2(pattern, callback)  else if(std::string::npos != query_info.m_URI.find(pattern)) return callback(query_info, response_info, &m_conn_context);
+
+#define MAP_URI_AUTO_XML2(s_pattern, callback_f, command_type) //TODO: don't think i ever again will use xml - ambiguous and "overtagged" format
+
 #define MAP_URI_AUTO_JON2_IF(s_pattern, callback_f, command_type, cond) \
    else if((query_info.m_URI == s_pattern) && (cond)) \
    { \
      handled = true; \
-      uint64_t ticks = epee::misc_utils::get_tick_count(); \
+      uint64_t ticks = misc_utils::get_tick_count(); \
      boost::value_initialized<command_type::request> req; \
      bool parse_res = epee::serialization::load_t_from_json(static_cast<command_type::request&>(req), query_info.m_body); \
      if (!parse_res) \
@@ -103,7 +107,7 @@
    else if(query_info.m_URI == s_pattern) \
    { \
      handled = true; \
-      uint64_t ticks = epee::misc_utils::get_tick_count(); \
+      uint64_t ticks = misc_utils::get_tick_count(); \
      boost::value_initialized<command_type::request> req; \
      bool parse_res = epee::serialization::load_t_from_binary(static_cast<command_type::request&>(req), epee::strspan<uint8_t>(query_info.m_body)); \
      if (!parse_res) \
@@ -113,7 +117,7 @@
         response_info.m_response_comment = "Bad request"; \
         return true; \
      } \
-      uint64_t ticks1 = epee::misc_utils::get_tick_count(); \
+      uint64_t ticks1 = misc_utils::get_tick_count(); \
      boost::value_initialized<command_type::response> resp;\
      MINFO(m_conn_context << "calling " << s_pattern); \
      bool res = false; \
@@ -125,7 +129,7 @@
        response_info.m_response_comment = "Internal Server Error"; \
        return true; \
      } \
-      uint64_t ticks2 = epee::misc_utils::get_tick_count(); \
+      uint64_t ticks2 = misc_utils::get_tick_count(); \
      epee::byte_slice buffer; \
      epee::serialization::store_t_to_binary(static_cast<command_type::response&>(resp), buffer, 64 * 1024); \
      uint64_t ticks3 = epee::misc_utils::get_tick_count(); \
@@ -135,6 +139,8 @@
      MDEBUG( s_pattern << "() processed with " << ticks1-ticks << "/"<< ticks2-ticks1 << "/" << ticks3-ticks2 << "ms"); \
    }

+#define CHAIN_URI_MAP2(callback) else {callback(query_info, response_info, m_conn_context);handled = true;}
+
 #define END_URI_MAP2() return handled;}


@@ -219,6 +225,26 @@

 #define MAP_JON_RPC_WE(method_name, callback_f, command_type) MAP_JON_RPC_WE_IF(method_name, callback_f, command_type, true)

+#define MAP_JON_RPC_WERI(method_name, callback_f, command_type) \
+    else if(callback_name == method_name) \
+{ \
+  PREPARE_OBJECTS_FROM_JSON(command_type) \
+  epee::json_rpc::error_response fail_resp = AUTO_VAL_INIT(fail_resp); \
+  fail_resp.jsonrpc = "2.0"; \
+  fail_resp.id = req.id; \
+  MINFO(m_conn_context << "calling RPC method " << method_name); \
+  bool res = false; \
+  try { res = callback_f(req.params, resp.result, fail_resp.error, response_info, &m_conn_context); } \
+  catch (const std::exception &e) { MERROR(m_conn_context << "Failed to " << #callback_f << "(): " << e.what()); } \
+  if (!res) \
+  { \
+    epee::serialization::store_t_to_json(static_cast<epee::json_rpc::error_response&>(fail_resp), response_info.m_body); \
+    return true; \
+  } \
+  FINALIZE_OBJECTS_TO_JSON(method_name) \
+  return true;\
+}
+
 #define MAP_JON_RPC(method_name, callback_f, command_type) \
    else if(callback_name == method_name) \
 { \
@@ -102,6 +102,7 @@ public:
  uint64_t m_max_packet_size;
  uint64_t m_invoke_timeout;

+  int invoke(int command, message_writer in_msg, std::string& buff_out, boost::uuids::uuid connection_id);
  template<class callback_t>
  int invoke_async(int command, message_writer in_msg, boost::uuids::uuid connection_id, const callback_t &cb, size_t timeout = LEVIN_DEFAULT_TIMEOUT_PRECONFIGURED);

@@ -164,6 +165,14 @@ public:
  };

  std::atomic<bool> m_protocol_released;
+  std::atomic<bool> m_invoke_buf_ready;
+
+  volatile int m_invoke_result_code;
+
+  critical_section m_local_inv_buff_lock;
+  std::string m_local_inv_buff;
+
+  critical_section m_call_lock;

  std::atomic<uint32_t> m_wait_count;
  std::atomic<uint32_t> m_close_called;
@@ -309,6 +318,8 @@ public:
    m_wait_count = 0;
    m_oponent_protocol_ver = 0;
    m_connection_initialized = false;
+    m_invoke_buf_ready = false;
+    m_invoke_result_code = LEVIN_ERROR_CONNECTION;
  }
  virtual ~async_protocol_handler()
  {
@@ -510,8 +521,21 @@ public:
            }
            else
            {
-              MERROR("Received levin response but have no invoke handlers");
-              return false;
+              invoke_response_handlers_guard.unlock();
+              //use sync call scenario
+              if(!m_wait_count && !m_close_called)
+              {
+                MERROR(m_connection_context << "no active invoke when response came, wtf?");
+                return false;
+              }else
+              {
+                CRITICAL_REGION_BEGIN(m_local_inv_buff_lock);
+                m_local_inv_buff = std::string((const char*)buff_to_invoke.data(), buff_to_invoke.size());
+                buff_to_invoke = epee::span<const uint8_t>((const uint8_t*)NULL, 0);
+                m_invoke_result_code = m_current_head.m_return_code;
+                CRITICAL_REGION_END();
+                m_invoke_buf_ready = true;
+              }
            }
          }else
          {
@@ -615,6 +639,9 @@ public:
    int err_code = LEVIN_OK;
    do
    {
+      CRITICAL_REGION_LOCAL(m_call_lock);
+
+      m_invoke_buf_ready = false;
      CRITICAL_REGION_BEGIN(m_invoke_response_handlers_lock);

      if (command == m_connection_context.handshake_command())
@@ -646,6 +673,55 @@ public:
    return true;
  }

+  int invoke(int command, message_writer in_msg, std::string& buff_out)
+  {
+    misc_utils::auto_scope_leave_caller scope_exit_handler = misc_utils::create_scope_leave_handler(
+                                      boost::bind(&async_protocol_handler::finish_outer_call, this));
+
+    CRITICAL_REGION_LOCAL(m_call_lock);
+
+    m_invoke_buf_ready = false;
+
+    if (command == m_connection_context.handshake_command())
+      m_max_packet_size = m_config.m_max_packet_size;
+
+    if (!send_message(in_msg.finalize_invoke(command)))
+    {
+      LOG_ERROR_CC(m_connection_context, "Failed to send request");
+      return LEVIN_ERROR_CONNECTION;
+    }
+
+    uint64_t ticks_start = misc_utils::get_tick_count();
+    size_t prev_size = 0;
+
+    while(!m_invoke_buf_ready && !m_protocol_released)
+    {
+      if(m_cache_in_buffer.size() - prev_size >= MIN_BYTES_WANTED)
+      {
+        prev_size = m_cache_in_buffer.size();
+        ticks_start = misc_utils::get_tick_count();
+      }
+      if(misc_utils::get_tick_count() - ticks_start > m_config.m_invoke_timeout)
+      {
+        MWARNING(m_connection_context << "invoke timeout (" << m_config.m_invoke_timeout << "), closing connection ");
+        close();
+        return LEVIN_ERROR_CONNECTION_TIMEDOUT;
+      }
+      if(!m_pservice_endpoint->call_run_once_service_io())
+        return LEVIN_ERROR_CONNECTION_DESTROYED;
+    }
+
+    if(m_protocol_released)
+      return LEVIN_ERROR_CONNECTION_DESTROYED;
+
+    CRITICAL_REGION_BEGIN(m_local_inv_buff_lock);
+    buff_out.swap(m_local_inv_buff);
+    m_local_inv_buff.clear();
+    CRITICAL_REGION_END();
+
+    return m_invoke_result_code;
+  }
+
  /*! Sends `message` without adding a levin header. The message must have been
      created with `make_noise_notify`, `make_fragmented_notify`, or
      `message_writer::finalize_notify`. See additional instructions for
@@ -751,6 +827,14 @@ int async_protocol_handler_config<t_connection_context>::find_and_lock_connectio
  return LEVIN_OK;
 }
 //------------------------------------------------------------------------------------------
+template<class t_connection_context>
+int async_protocol_handler_config<t_connection_context>::invoke(int command, message_writer in_msg, std::string& buff_out, boost::uuids::uuid connection_id)
+{
+  async_protocol_handler<t_connection_context>* aph;
+  int r = find_and_lock_connection(connection_id, aph);
+  return LEVIN_OK == r ? aph->invoke(command, std::move(in_msg), buff_out) : r;
+}
+//------------------------------------------------------------------------------------------
 template<class t_connection_context> template<class callback_t>
 int async_protocol_handler_config<t_connection_context>::invoke_async(int command, message_writer in_msg, boost::uuids::uuid connection_id, const callback_t &cb, size_t timeout)
 {
@@ -29,6 +29,8 @@

 #pragma once

+//#include <Winsock2.h>
+//#include <Ws2tcpip.h>
 #include <atomic>
 #include <string>
 #include <boost/version.hpp>
@@ -50,6 +52,11 @@
 #undef MONERO_DEFAULT_LOG_CATEGORY
 #define MONERO_DEFAULT_LOG_CATEGORY "net"

+#ifndef MAKE_IP
+#define MAKE_IP( a1, a2, a3, a4 )	(a1|(a2<<8)|(a3<<16)|(a4<<24))
+#endif
+
+
 namespace epee
 {
 namespace net_utils
@@ -99,6 +106,7 @@ namespace net_utils
 				m_ssl_socket(new boost::asio::ssl::stream<boost::asio::ip::tcp::socket>(m_io_service, m_ctx)),
 				m_connector(direct_connect{}),
 				m_ssl_options(epee::net_utils::ssl_support_t::e_ssl_support_autodetect),
+				m_initialized(true),
 				m_connected(false),
 				m_deadline(m_io_service, std::chrono::steady_clock::time_point::max()),
 				m_shutdowned(false),
@@ -141,6 +149,12 @@ namespace net_utils
 			m_ssl_options = std::move(ssl_options);
 		}

+    inline
+      bool connect(const std::string& addr, int port, std::chrono::milliseconds timeout)
+    {
+      return connect(addr, std::to_string(port), timeout);
+    }
+
    inline
 			try_connect_result_t try_connect(const std::string& addr, const std::string& port, std::chrono::milliseconds timeout)
 		{
@@ -319,6 +333,64 @@ namespace net_utils
 			return true;
 		}

+		inline 
+			bool send(const void* data, size_t sz)
+		{
+			try
+			{
+				/*
+				m_deadline.expires_from_now(boost::posix_time::milliseconds(m_reciev_timeout));
+
+				// Set up the variable that receives the result of the asynchronous
+				// operation. The error code is set to would_block to signal that the
+				// operation is incomplete. Asio guarantees that its asynchronous
+				// operations will never fail with would_block, so any other value in
+				// ec indicates completion.
+				boost::system::error_code ec = boost::asio::error::would_block;
+
+				// Start the asynchronous operation itself. The boost::lambda function
+				// object is used as a callback and will update the ec variable when the
+				// operation completes. The blocking_udp_client.cpp example shows how you
+				// can use boost::bind rather than boost::lambda.
+				boost::asio::async_write(m_socket, boost::asio::buffer(data, sz), boost::lambda::var(ec) = boost::lambda::_1);
+
+				// Block until the asynchronous operation has completed.
+				while (ec == boost::asio::error::would_block)
+				{
+					m_io_service.run_one();
+				}
+				*/
+				boost::system::error_code ec;
+
+				size_t writen = write(data, sz, ec);
+
+				if (!writen || ec)
+				{
+					LOG_PRINT_L3("Problems at write: " << ec.message());
+          m_connected = false;
+					return false;
+				}else
+				{
+					m_deadline.expires_at(std::chrono::steady_clock::time_point::max());
+					m_bytes_sent += sz;
+				}
+			}
+
+			catch(const boost::system::system_error& er)
+			{
+				LOG_ERROR("Some problems at send, message: " << er.what());
+        m_connected = false;
+				return false;
+			}
+			catch(...)
+			{
+				LOG_ERROR("Some fatal problems.");
+				return false;
+			}
+
+			return true;
+		}
+
 		bool is_connected(bool *ssl = NULL)
 		{
 			if (!m_connected || !m_ssl_socket->next_layer().is_open())
@@ -415,6 +487,79 @@ namespace net_utils

 		}

+		inline bool recv_n(std::string& buff, int64_t sz, std::chrono::milliseconds timeout)
+		{
+
+			try
+			{
+				// Set a deadline for the asynchronous operation. Since this function uses
+				// a composed operation (async_read_until), the deadline applies to the
+				// entire operation, rather than individual reads from the socket.
+				m_deadline.expires_from_now(timeout);
+
+				// Set up the variable that receives the result of the asynchronous
+				// operation. The error code is set to would_block to signal that the
+				// operation is incomplete. Asio guarantees that its asynchronous
+				// operations will never fail with would_block, so any other value in
+				// ec indicates completion.
+				//boost::system::error_code ec = boost::asio::error::would_block;
+
+				// Start the asynchronous operation itself. The boost::lambda function
+				// object is used as a callback and will update the ec variable when the
+				// operation completes. The blocking_udp_client.cpp example shows how you
+				// can use boost::bind rather than boost::lambda.
+
+				buff.resize(static_cast<size_t>(sz));
+				boost::system::error_code ec = boost::asio::error::would_block;
+				size_t bytes_transfered = 0;
+
+				
+				handler_obj hndlr(ec, bytes_transfered);
+				async_read((char*)buff.data(), buff.size(), boost::asio::transfer_at_least(buff.size()), hndlr);
+				
+				// Block until the asynchronous operation has completed.
+				while (ec == boost::asio::error::would_block && !m_shutdowned)
+				{
+					m_io_service.run_one(); 
+				}
+
+				if (ec)
+				{
+					LOG_PRINT_L3("Problems at read: " << ec.message());
+          m_connected = false;
+					return false;
+				}else
+				{
+					m_deadline.expires_at(std::chrono::steady_clock::time_point::max());
+				}
+
+				m_bytes_received += bytes_transfered;
+				if(bytes_transfered != buff.size())
+				{
+					LOG_ERROR("Transferred mismatch with transfer_at_least value: m_bytes_transferred=" << bytes_transfered << " at_least value=" << buff.size());
+					return false;
+				}
+
+				return true;
+			}
+
+			catch(const boost::system::system_error& er)
+			{
+				LOG_ERROR("Some problems at read, message: " << er.what());
+        m_connected = false;
+				return false;
+			}
+			catch(...)
+			{
+				LOG_ERROR("Some fatal problems at read.");
+				return false;
+			}
+
+
+
+			return false;
+		}
+		
 		bool shutdown()
 		{
 			m_deadline.cancel();
@@ -434,6 +579,16 @@ namespace net_utils
      m_connected = false;
 			return true;
 		}
+		
+		boost::asio::io_service& get_io_service()
+		{
+			return m_io_service;
+		}
+
+		boost::asio::ip::tcp::socket& get_socket()
+		{
+			return m_ssl_socket->next_layer();
+		}

 		uint64_t get_bytes_sent() const
 		{
@@ -493,6 +648,16 @@ namespace net_utils
 		}
 		
 	protected:
+		bool write(const void* data, size_t sz, boost::system::error_code& ec)
+		{
+			bool success;
+			if(m_ssl_options.support != ssl_support_t::e_ssl_support_disabled)
+				success = boost::asio::write(*m_ssl_socket, boost::asio::buffer(data, sz), ec);
+			else
+				success = boost::asio::write(m_ssl_socket->next_layer(), boost::asio::buffer(data, sz), ec);
+			return success;
+		}
+		
 		void async_write(const void* data, size_t sz, boost::system::error_code& ec) 
 		{
 			if(m_ssl_options.support != ssl_support_t::e_ssl_support_disabled)
@@ -516,12 +681,126 @@ namespace net_utils
 		std::shared_ptr<boost::asio::ssl::stream<boost::asio::ip::tcp::socket>> m_ssl_socket;
 		std::function<connect_func> m_connector;
 		ssl_options_t m_ssl_options;
+		bool m_initialized;
 		bool m_connected;
 		boost::asio::steady_timer m_deadline;
 		std::atomic<bool> m_shutdowned;
 		std::atomic<uint64_t> m_bytes_sent;
 		std::atomic<uint64_t> m_bytes_received;
 	};
+
+
+	/************************************************************************/
+	/*                                                                      */
+	/************************************************************************/
+	class async_blocked_mode_client: public blocked_mode_client
+	{
+	public:
+		async_blocked_mode_client():m_send_deadline(blocked_mode_client::m_io_service)
+		{
+
+			// No deadline is required until the first socket operation is started. We
+			// set the deadline to positive infinity so that the actor takes no action
+			// until a specific deadline is set.
+			m_send_deadline.expires_at(boost::posix_time::pos_infin);
+
+			// Start the persistent actor that checks for deadline expiry.
+			check_send_deadline();
+		}
+		~async_blocked_mode_client()
+		{
+			m_send_deadline.cancel();
+		}
+		
+		bool shutdown()
+		{
+			blocked_mode_client::shutdown();
+			m_send_deadline.cancel();
+			return true;
+		}
+
+		inline 
+			bool send(const void* data, size_t sz)
+		{
+			try
+			{
+				/*
+				m_send_deadline.expires_from_now(boost::posix_time::milliseconds(m_reciev_timeout));
+
+				// Set up the variable that receives the result of the asynchronous
+				// operation. The error code is set to would_block to signal that the
+				// operation is incomplete. Asio guarantees that its asynchronous
+				// operations will never fail with would_block, so any other value in
+				// ec indicates completion.
+				boost::system::error_code ec = boost::asio::error::would_block;
+
+				// Start the asynchronous operation itself. The boost::lambda function
+				// object is used as a callback and will update the ec variable when the
+				// operation completes. The blocking_udp_client.cpp example shows how you
+				// can use boost::bind rather than boost::lambda.
+				boost::asio::async_write(m_socket, boost::asio::buffer(data, sz), boost::lambda::var(ec) = boost::lambda::_1);
+
+				// Block until the asynchronous operation has completed.
+				while(ec == boost::asio::error::would_block)
+				{
+					m_io_service.run_one();
+				}*/
+				
+				boost::system::error_code ec;
+
+				size_t writen = write(data, sz, ec);
+				
+				if (!writen || ec)
+				{
+					LOG_PRINT_L3("Problems at write: " << ec.message());
+					return false;
+				}else
+				{
+					m_send_deadline.expires_at(boost::posix_time::pos_infin);
+				}
+			}
+
+			catch(const boost::system::system_error& er)
+			{
+				LOG_ERROR("Some problems at connect, message: " << er.what());
+				return false;
+			}
+			catch(...)
+			{
+				LOG_ERROR("Some fatal problems.");
+				return false;
+			}
+
+			return true;
+		}
+
+
+	private:
+
+		boost::asio::deadline_timer m_send_deadline;
+
+		void check_send_deadline()
+		{
+			// Check whether the deadline has passed. We compare the deadline against
+			// the current time since a new asynchronous operation may have moved the
+			// deadline before this actor had a chance to run.
+			if (m_send_deadline.expires_at() <= boost::asio::deadline_timer::traits_type::now())
+			{
+				// The deadline has passed. The socket is closed so that any outstanding
+				// asynchronous operations are cancelled. This allows the blocked
+				// connect(), read_line() or write_line() functions to return.
+				LOG_PRINT_L3("Timed out socket");
+				m_ssl_socket->next_layer().close();
+
+				// There is no longer an active deadline. The expiry is set to positive
+				// infinity so that the actor takes no action until a new deadline is set.
+				m_send_deadline.expires_at(boost::posix_time::pos_infin);
+			}
+
+			// Put the actor back to sleep.
+			m_send_deadline.async_wait(boost::bind(&async_blocked_mode_client::check_send_deadline, this));
+		}
+	};
 }
 }

@@ -151,33 +151,6 @@ namespace net_utils
 	bool create_ec_ssl_certificate(EVP_PKEY *&pkey, X509 *&cert);
 	bool create_rsa_ssl_certificate(EVP_PKEY *&pkey, X509 *&cert);

-  /**
-   * @brief Create a human-readable X509 certificate fingerprint
-   *
-   * Example output: "12:A3:92:19:87:D2:A2:A5:77:94:82:29:B9:5A:91:01:AB:5F:75:16:9A:BA:CD:3D:D3:69:3D:6A:87:DC:E8:0E"
-   *
-   * @param[in] cert The certificate which will be used to create the fingerprint
-   * @param[in] fdig The digest algorithm to use, defaults to SHA-256 b/c that is what ssl_options_t uses
-   * @return The human-readable fingerprint string
-   *
-   * @throw boost::system_error if there is an OpenSSL error
-   */
-  std::string get_hr_ssl_fingerprint(const X509 *cert, const EVP_MD *fdig = EVP_sha256());
-
-  /**
-   * @brief Create a human-readable fingerprint from the contents of an X509 certificate
-   *
-   * Should be equivalent to the command `openssl x509 -in <cert file> -fingerprint -sha256 -noout`
-   * Example output: "12:A3:92:19:87:D2:A2:A5:77:94:82:29:B9:5A:91:01:AB:5F:75:16:9A:BA:CD:3D:D3:69:3D:6A:87:DC:E8:0E"
-   *
-   * @param[in] cert_path The path to an X509 certificate which will be used to create the fingerprint
-   * @param[in] fdig The digest algorithm to use, defaults to SHA-256 b/c that is what ssl_options_t uses
-   * @return The human-readable fingerprint string
-   *
-   * @throw boost::system_error if there is an OpenSSL error or file I/O error
-   */
-  std::string get_hr_ssl_fingerprint_from_file(const std::string& cert_path, const EVP_MD *fdig = EVP_sha256());
-
  //! Store private key for `ssl` at `base + ".key"` unencrypted and certificate for `ssl` at `base + ".crt"`.
  boost::system::error_code store_ssl_keys(boost::asio::ssl::context& ssl, const boost::filesystem::path& base);
 }
@@ -2,7 +2,7 @@
 /// @author rfree (current maintainer in monero.cc project)
 /// @brief implementaion for throttling of connection (count and rate-limit speed etc)

-// Copyright (c) 2014-2023, The Monero Project
+// Copyright (c) 2014-2022, The Monero Project
 // 
 // All rights reserved.
 // 
@@ -2,7 +2,7 @@
 /// @author rfree (current maintainer in monero.cc project)
 /// @brief interface for throttling of connection (count and rate-limit speed etc)

-// Copyright (c) 2014-2023, The Monero Project
+// Copyright (c) 2014-2022, The Monero Project
 // 
 // All rights reserved.
 // 
@@ -1,4 +1,4 @@
-// Copyright (c) 2019-2023, The Monero Project
+// Copyright (c) 2019-2022, The Monero Project
 // 
 // All rights reserved.
 // 
@@ -1,4 +1,4 @@
-// Copyright (c) 2017-2023, The Monero Project
+// Copyright (c) 2017-2022, The Monero Project
 //
 // All rights reserved.
 //
@@ -147,6 +147,16 @@ namespace epee
    return {reinterpret_cast<const std::uint8_t*>(src.data()), src.size_bytes()}; 
  }

+  //! \return `span<std::uint8_t>` from a STL compatible `src`.
+  template<typename T>
+  constexpr span<std::uint8_t> to_mut_byte_span(T& src)
+  {
+    using value_type = typename T::value_type;
+    static_assert(!std::is_empty<value_type>(), "empty value types will not work -> sizeof == 1");
+    static_assert(!has_padding<value_type>(), "source value type may have padding");
+    return {reinterpret_cast<std::uint8_t*>(src.data()), src.size() * sizeof(value_type)};
+  }
+
  //! \return `span<const std::uint8_t>` which represents the bytes at `&src`.
  template<typename T>
  span<const std::uint8_t> as_byte_span(const T& src) noexcept
@@ -26,10 +26,13 @@
 // 

 #pragma once
-
-#include "net/http_base.h"
-#include "net/jsonrpc_structs.h"
+#include <boost/utility/string_ref.hpp>
+#include <chrono>
+#include <string>
+#include "byte_slice.h"
 #include "portable_storage_template_helper.h"
+#include "net/http_base.h"
+#include "net/http_server_handlers_map2.h"

 namespace epee
 {
@@ -133,5 +136,12 @@ namespace epee
      epee::json_rpc::error error_struct;
      return invoke_http_json_rpc(uri, method_name, out_struct, result_struct, error_struct, transport, timeout, http_method, req_id);
    }
-  } // namespace net_utils
-} // namespace epee
+
+    template<class t_command, class t_transport>
+    bool invoke_http_json_rpc(const boost::string_ref uri, typename t_command::request& out_struct, typename t_command::response& result_struct, t_transport& transport, std::chrono::milliseconds timeout = std::chrono::seconds(15), const boost::string_ref http_method = "POST", const std::string& req_id = "0")
+    {
+      return invoke_http_json_rpc(uri, t_command::methodname(), out_struct, result_struct, transport, timeout, http_method, req_id);
+    }
+
+  }
+}
@@ -56,6 +56,33 @@ namespace epee
 {
  namespace net_utils
  {
+    template<class t_arg, class t_result, class t_transport>
+    bool invoke_remote_command2(const epee::net_utils::connection_context_base context, int command, const t_arg& out_struct, t_result& result_struct, t_transport& transport)
+    {
+      const boost::uuids::uuid &conn_id = context.m_connection_id;
+      typename serialization::portable_storage stg;
+      out_struct.store(stg);
+      levin::message_writer to_send{16 * 1024};
+      std::string buff_to_recv;
+      stg.store_to_binary(to_send.buffer);
+
+      int res = transport.invoke(command, std::move(to_send), buff_to_recv, conn_id);
+      if( res <=0 )
+      {
+        LOG_PRINT_L1("Failed to invoke command " << command << " return code " << res);
+        return false;
+      }
+      typename serialization::portable_storage stg_ret;
+      if(!stg_ret.load_from_binary(buff_to_recv, &default_levin_limits))
+      {
+        on_levin_traffic(context, true, false, true, buff_to_recv.size(), command);
+        LOG_ERROR("Failed to load_from_binary on command " << command);
+        return false;
+      }
+      on_levin_traffic(context, true, false, false, buff_to_recv.size(), command);
+      return result_struct.load(stg_ret);
+    }
+
    template<class t_result, class t_arg, class callback_t, class t_transport>
    bool async_invoke_remote_command2(const epee::net_utils::connection_context_base &context, int command, const t_arg& out_struct, t_transport& transport, const callback_t &cb, size_t inv_timeout = LEVIN_DEFAULT_TIMEOUT_PRECONFIGURED)
    {
@@ -189,20 +216,65 @@ namespace epee
    return handle_invoke_map(true, command, in_buff, fake_str, context, handled); \
  } 

+
+#define CHAIN_LEVIN_INVOKE_MAP() \
+  int invoke(int command, const epee::span<const uint8_t> in_buff, epee::byte_stream& buff_out, epee::net_utils::connection_context_base& context) \
+  { \
+  bool handled = false; \
+  return handle_invoke_map(false, command, in_buff, buff_out, context, handled); \
+  } 
+
+#define CHAIN_LEVIN_NOTIFY_MAP() \
+  int notify(int command, const epee::span<const uint8_t> in_buff, epee::net_utils::connection_context_base& context) \
+  { \
+  bool handled = false; std::string fake_str;\
+  return handle_invoke_map(true, command, in_buff, fake_str, context, handled); \
+  } 
+
+#define CHAIN_LEVIN_NOTIFY_STUB() \
+  int notify(int command, const epee::span<const uint8_t> in_buff, epee::net_utils::connection_context_base& context) \
+  { \
+  return -1; \
+  } 
+
 #define BEGIN_INVOKE_MAP2(owner_type) \
  template <class t_context> int handle_invoke_map(bool is_notify, int command, const epee::span<const uint8_t> in_buff, epee::byte_stream& buff_out, t_context& context, bool& handled) \
  { \
  try { \
  typedef owner_type internal_owner_type_name;

+#define HANDLE_INVOKE2(command_id, func, type_name_in, typename_out) \
+  if(!is_notify && command_id == command) \
+  {handled=true;return epee::net_utils::buff_to_t_adapter<internal_owner_type_name, type_name_in, typename_out>(this, command, in_buff, buff_out, std::bind(func, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4), context);}
+
 #define HANDLE_INVOKE_T2(COMMAND, func) \
  if(!is_notify && COMMAND::ID == command) \
  {handled=true;return epee::net_utils::buff_to_t_adapter<internal_owner_type_name, typename COMMAND::request, typename COMMAND::response>(command, in_buff, buff_out, std::bind(func, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4), context);}

+
+#define HANDLE_NOTIFY2(command_id, func, type_name_in) \
+  if(is_notify && command_id == command) \
+  {handled=true;return epee::net_utils::buff_to_t_adapter<internal_owner_type_name, type_name_in>(this, command, in_buff, std::bind(func, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3), context);}
+
 #define HANDLE_NOTIFY_T2(NOTIFY, func) \
  if(is_notify && NOTIFY::ID == command) \
  {handled=true;return epee::net_utils::buff_to_t_adapter<internal_owner_type_name, typename NOTIFY::request>(this, command, in_buff, std::bind(func, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3), context);}

+
+#define CHAIN_INVOKE_MAP2(func) \
+  { \
+  int res = func(is_notify, command, in_buff, buff_out, context, handled); \
+  if(handled) \
+  return res; \
+  }
+
+#define CHAIN_INVOKE_MAP_TO_OBJ2(obj) \
+  { \
+  int res = obj.handle_invoke_map(is_notify, command, in_buff, buff_out, context, handled); \
+  if(handled) \
+  return res; \
+  }
+
 #define CHAIN_INVOKE_MAP_TO_OBJ_FORCE_CONTEXT(obj, context_type) \
  { \
  int res = obj.handle_invoke_map(is_notify, command, in_buff, buff_out, static_cast<context_type>(context), handled); \
@@ -1,4 +1,4 @@
-// Copyright (c) 2019-2023, The Monero Project
+// Copyright (c) 2019-2022, The Monero Project
 // 
 // All rights reserved.
 // 
@@ -33,6 +33,9 @@
 #include "portable_storage_base.h"
 #include "portable_storage_bin_utils.h"

+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "serialization"
+
 #ifdef EPEE_PORTABLE_STORAGE_RECURSION_LIMIT
 #define EPEE_PORTABLE_STORAGE_RECURSION_LIMIT_INTERNAL EPEE_PORTABLE_STORAGE_RECURSION_LIMIT
 #else 
@@ -31,6 +31,9 @@
 #include "parserse_base_utils.h"
 #include "file_io_utils.h"

+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "serialization"
+
 #define EPEE_JSON_RECURSION_LIMIT_INTERNAL 100

 namespace epee
@@ -36,6 +36,7 @@
 #include "warnings.h"
 #include "misc_log_ex.h"

+#include <boost/numeric/conversion/bounds.hpp>
 #include <boost/lexical_cast.hpp>
 #include <typeinfo>
 #include <iomanip>
@@ -34,8 +34,102 @@ namespace epee
 {
 namespace string_encoding
 {
+	inline std::string convert_to_ansii(const std::wstring& str_from)
+	{
+		
+		std::string res(str_from.begin(), str_from.end());
+		return res;
+		/*
+		std::string result;
+		std::locale loc;
+		for(unsigned int i= 0; i < str_from.size(); ++i)
+		{
+			result += std::use_facet<std::ctype<wchar_t> >(loc).narrow(str_from[i]);
+		}
+		return result;
+		*/
+		
+		//return boost::lexical_cast<std::string>(str_from);
+		/*
+		std::string str_trgt;
+		if(!str_from.size())
+			return str_trgt;
+		int cb = ::WideCharToMultiByte( code_page, 0, str_from.data(), (__int32)str_from.size(), 0, 0, 0, 0  );
+		if(!cb)
+			return str_trgt;
+		str_trgt.resize(cb);
+		::WideCharToMultiByte(  code_page, 0, str_from.data(), (int)str_from.size(), 
+			                        (char*)str_trgt.data(), (int)str_trgt.size(), 0, 0);
+		return str_trgt;*/
+	}
+
+	inline std::string convert_to_ansii(const std::string& str_from)
+	{
+		return str_from;
+	}
+
+	inline std::wstring convert_to_unicode(const std::string& str_from)
+	{
+		std::wstring result;
+		std::locale loc;
+		for(unsigned int i= 0; i < str_from.size(); ++i)
+		{
+			result += std::use_facet<std::ctype<wchar_t> >(loc).widen(str_from[i]);
+		}
+		return result;
+		
+		//return boost::lexical_cast<std::wstring>(str_from);
+		/*
+		std::wstring str_trgt;
+		if(!str_from.size())
+			return str_trgt;
+
+		int cb = ::MultiByteToWideChar( code_page, 0, str_from.data(), (int)str_from.size(), 0, 0 );
+		if(!cb)
+			return str_trgt;
+
+		str_trgt.resize(cb);
+		::MultiByteToWideChar( code_page, 0, str_from.data(),(int)str_from.size(), 
+								(wchar_t*)str_trgt.data(),(int)str_trgt.size());
+		return str_trgt;*/
+	}
+	inline std::wstring convert_to_unicode(const std::wstring& str_from)
+	{
+		return str_from;
+	}
+
+	template<class target_string>
+	inline target_string convert_to_t(const std::wstring& str_from);
+	
+	template<>
+	inline std::string convert_to_t<std::string>(const std::wstring& str_from)
+	{
+		return convert_to_ansii(str_from);
+	}
+
+	template<>
+	inline std::wstring convert_to_t<std::wstring>(const std::wstring& str_from)
+	{
+		return str_from;
+	}
+
+	template<class target_string>
+	inline target_string convert_to_t(const std::string& str_from);
+
+	template<>
+	inline std::string convert_to_t<std::string>(const std::string& str_from)
+	{
+		return str_from;
+	}
+
+	template<>
+	inline std::wstring convert_to_t<std::wstring>(const std::string& str_from)
+	{
+		return convert_to_unicode(str_from);
+	}
+
 	inline 
-	const std::string& base64_chars()
+	std::string& base64_chars()
 	{

 		static std::string chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
@@ -1,4 +1,4 @@
-// Copyright (c) 2017-2023, The Monero Project
+// Copyright (c) 2017-2022, The Monero Project
 // 
 // All rights reserved.
 // 
@@ -1,4 +1,4 @@
-# Copyright (c) 2014-2023, The Monero Project
+# Copyright (c) 2014-2022, The Monero Project
 # 
 # All rights reserved.
 # 
@@ -37,6 +37,7 @@ monero_add_library(epee byte_slice.cpp byte_stream.cpp hex.cpp abstract_http_cli
    misc_language.cpp
    file_io_utils.cpp
    net_parse_helpers.cpp
+    http_base.cpp
    ${EPEE_HEADERS_PUBLIC}
    )

@@ -116,6 +116,16 @@ namespace net_utils
    return result;
  }
  //----------------------------------------------------------------------------------------------------
+  std::string convert_to_url_format_force_all(const std::string& uri)
+  {
+    std::string result;
+
+    for(size_t i = 0; i!= uri.size(); i++)
+    {
+        result += convert(uri[i]);
+    }
+    return result;
+  }

 namespace http
 {
@@ -1,4 +1,4 @@
-// Copyright (c) 2018-2023, The Monero Project
+// Copyright (c) 2018-2022, The Monero Project

 // 
 // All rights reserved.
@@ -1,4 +1,4 @@
-// Copyright (c) 2019-2023, The Monero Project
+// Copyright (c) 2019-2022, The Monero Project
 //
 // All rights reserved.
 //
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2023, The Monero Project
+// Copyright (c) 2020-2022, The Monero Project

 //
 // All rights reserved.
@@ -2,7 +2,7 @@
 /// @author rfree (current maintainer in monero.cc project)
 /// @brief base for connection, contains e.g. the ratelimit hooks

-// Copyright (c) 2014-2023, The Monero Project
+// Copyright (c) 2014-2022, The Monero Project
 // 
 // All rights reserved.
 // 
@@ -1,4 +1,4 @@
-// Copyright (c) 2017-2023, The Monero Project
+// Copyright (c) 2017-2022, The Monero Project
 //
 // All rights reserved.
 //
@@ -69,14 +69,6 @@ namespace epee
  std::string to_hex::string(const span<const std::uint8_t> src) { return convert<std::string>(src); }
  epee::wipeable_string to_hex::wipeable_string(const span<const std::uint8_t> src) { return convert<epee::wipeable_string>(src); }

-  bool to_hex::buffer(span<char> out, const span<const std::uint8_t> src) noexcept
-  {
-    if (out.size() % 2 != 0 || out.size() / 2 != src.size())
-      return false;
-    to_hex::buffer_unchecked(out.data(), src);
-    return true;
-  }
-
  void to_hex::buffer(std::ostream& out, const span<const std::uint8_t> src)
  {
    write_hex(std::ostreambuf_iterator<char>{out}, src);
@@ -1,4 +1,4 @@
-// Copyright (c) 2014-2023, The Monero Project
+// Copyright (c) 2014-2022, The Monero Project
 //
 // All rights reserved.
 //
@@ -0,0 +1,71 @@
+// Copyright (c) 2006-2013, Andrey N. Sabelnikov, www.sabelnikov.net
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+// * Neither the name of the Andrey N. Sabelnikov nor the
+// names of its contributors may be used to endorse or promote products
+// derived from this software without specific prior written permission.
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER  BE LIABLE FOR ANY
+// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// 
+
+#include "net/http_base.h"
+#include "memwipe.h"
+#include "string_tools.h"
+
+#include <boost/regex.hpp>
+#include <string>
+#include <utility>
+
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "net.http"
+
+namespace epee
+{
+namespace net_utils
+{
+namespace http
+{
+    std::string get_value_from_fields_list(const std::string& param_name, const net_utils::http::fields_list& fields)
+    {
+        fields_list::const_iterator it = fields.begin();
+        for(; it != fields.end(); ++it)
+            if(!string_tools::compare_no_case(param_name, it->first))
+                break;
+
+        if(it==fields.end())
+            return std::string();
+
+        return it->second;
+    }
+
+    std::string get_value_from_uri_line(const std::string& param_name, const std::string& uri)
+    {
+        std::string buff = "([\\?|&])";
+        buff += param_name + "=([^&]*)";
+        boost::regex match_param(buff.c_str(), boost::regex::icase | boost::regex::normal);
+        boost::smatch	result;
+        if(boost::regex_search(uri, result, match_param, boost::match_default) && result[0].matched) 
+        {
+            return result[2];
+        }
+        return std::string();
+    }
+}
+}
+}
@@ -1,4 +1,4 @@
-// Copyright (c) 2019-2023, The Monero Project
+// Copyright (c) 2019-2022, The Monero Project
 // 
 // All rights reserved.
 // 
@@ -1,4 +1,4 @@
-// Copyright (c) 2019-2023, The Monero Project
+// Copyright (c) 2019-2022, The Monero Project
 //
 // All rights reserved.
 //
@@ -1,4 +1,4 @@
-// Copyright (c) 2017-2023, The Monero Project
+// Copyright (c) 2017-2022, The Monero Project
 // 
 // All rights reserved.
 // 
@@ -1,4 +1,4 @@
-// Copyright (c) 2018-2023, The Monero Project
+// Copyright (c) 2018-2022, The Monero Project

 // 
 // All rights reserved.
@@ -1,4 +1,4 @@
-// Copyright (c) 2018-2023, The Monero Project
+// Copyright (c) 2018-2022, The Monero Project

 // 
 // All rights reserved.
@@ -30,7 +30,6 @@
 #include <string.h>
 #include <thread>
 #include <boost/asio/ssl.hpp>
-#include <boost/asio/steady_timer.hpp>
 #include <boost/cerrno.hpp>
 #include <boost/filesystem/operations.hpp>
 #include <boost/asio/strand.hpp>
@@ -39,8 +38,8 @@
 #include <openssl/ssl.h>
 #include <openssl/pem.h>
 #include "misc_log_ex.h"
+#include "net/net_helper.h"
 #include "net/net_ssl.h"
-#include "net/net_utils_base.h"
 #include "file_io_utils.h" // to validate .crt and .key paths

 #undef MONERO_DEFAULT_LOG_CATEGORY
@@ -644,56 +643,6 @@ bool ssl_options_t::handshake(
  return true;
 }

-std::string get_hr_ssl_fingerprint(const X509 *cert, const EVP_MD *fdig)
-{
-  unsigned int j;
-  unsigned int n;
-  unsigned char md[EVP_MAX_MD_SIZE];
-  std::string fingerprint;
-
-  CHECK_AND_ASSERT_THROW_MES(cert && fdig, "Pointer args to get_hr_ssl_fingerprint cannot be null");
-
-  if (!X509_digest(cert, fdig, md, &n))
-  {
-    const unsigned long ssl_err_val = static_cast<int>(ERR_get_error());
-    const boost::system::error_code ssl_err_code = boost::asio::error::ssl_errors(static_cast<int>(ssl_err_val));
-    MERROR("Failed to create SSL fingerprint: " << ERR_reason_error_string(ssl_err_val));
-    throw boost::system::system_error(ssl_err_code, ERR_reason_error_string(ssl_err_val));
-  }
-  fingerprint.resize(n * 3 - 1);
-  char *out = &fingerprint[0];
-  for (j = 0; j < n; ++j)
-  {
-    snprintf(out, 3 + (j + 1 < n), "%02X%s", md[j], (j + 1 == n) ? "" : ":");
-    out += 3;
-  }
-  return fingerprint;
-}
-
-std::string get_hr_ssl_fingerprint_from_file(const std::string& cert_path, const EVP_MD *fdig) {
-  // Open file for reading
-  FILE* fp = fopen(cert_path.c_str(), "r");
-  if (!fp)
-  {
-    const boost::system::error_code err_code(errno, boost::system::system_category());
-    throw boost::system::system_error(err_code, "Failed to open certificate file '" + cert_path + "'");
-  }
-  std::unique_ptr<FILE, decltype(&fclose)> file(fp, &fclose);
-
-  // Extract certificate structure from file
-  X509* ssl_cert_handle = PEM_read_X509(file.get(), NULL, NULL, NULL);
-  if (!ssl_cert_handle) {
-    const unsigned long ssl_err_val = static_cast<int>(ERR_get_error());
-    const boost::system::error_code ssl_err_code = boost::asio::error::ssl_errors(static_cast<int>(ssl_err_val));
-    MERROR("OpenSSL error occurred while loading certificate at '" + cert_path + "'");
-    throw boost::system::system_error(ssl_err_code, ERR_reason_error_string(ssl_err_val));
-  }
-  std::unique_ptr<X509, decltype(&X509_free)> ssl_cert(ssl_cert_handle, &X509_free);
-
-  // Get the fingerprint from X509 structure
-  return get_hr_ssl_fingerprint(ssl_cert.get(), fdig);
-}
-
 bool ssl_support_from_string(ssl_support_t &ssl, boost::string_ref s)
 {
  if (s == "enabled")
@@ -758,29 +707,6 @@ boost::system::error_code store_ssl_keys(boost::asio::ssl::context& ssl, const b
    return boost::asio::error::ssl_errors(ERR_get_error());
  if (std::fclose(file.release()) != 0)
    return {errno, boost::system::system_category()};
-
-  // write SHA-256 fingerprint file
-  const boost::filesystem::path fp_file{base.string() + ".fingerprint"};
-  file.reset(std::fopen(fp_file.string().c_str(), "w"));
-  if (!file)
-    return {errno, boost::system::system_category()};
-  const auto fp_perms = (boost::filesystem::owner_read | boost::filesystem::group_read | boost::filesystem::others_read);
-  boost::filesystem::permissions(fp_file, fp_perms, error);
-  if (error)
-    return error;
-  try
-  {
-    const std::string fingerprint = get_hr_ssl_fingerprint(ssl_cert);
-    if (fingerprint.length() != fwrite(fingerprint.c_str(), sizeof(char), fingerprint.length(), file.get()))
-      return {errno, boost::system::system_category()};
-  }
-  catch (const boost::system::system_error& fperr)
-  {
-    return fperr.code();
-  }
-  if (std::fclose(file.release()) != 0)
-    return {errno, boost::system::system_category()};
-
  return error;
 }

@@ -2,7 +2,7 @@
 /// @author rfree (current maintainer in monero.cc project)
 /// @brief implementaion for throttling of connection (count and rate-limit speed etc)

-// Copyright (c) 2014-2023, The Monero Project
+// Copyright (c) 2014-2022, The Monero Project
 // 
 // All rights reserved.
 // 
@@ -26,7 +26,7 @@ Throttling work by:

 */

-// Copyright (c) 2014-2023, The Monero Project
+// Copyright (c) 2014-2022, The Monero Project
 // 
 // All rights reserved.
 // 
@@ -1,4 +1,4 @@
-// Copyright (c) 2017-2023, The Monero Project
+// Copyright (c) 2017-2022, The Monero Project
 // 
 // All rights reserved.
 // 
@@ -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.1.0
+VERSION=v0.18.3.3
 ./dockrun.sh $VERSION
 ```

@@ -133,7 +133,7 @@ Common setup part:
 su - gitianuser

 GH_USER=YOUR_GITHUB_USER_NAME
-VERSION=v0.18.0.0
+VERSION=v0.18.3.3
 ```

 Where `GH_USER` is your GitHub user name and `VERSION` is the version tag you want to build. 
@@ -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"
@@ -43,7 +44,7 @@ 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"
@@ -159,7 +160,13 @@ 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
@@ -86,9 +86,9 @@ monero_add_library(version SOURCES ${CMAKE_BINARY_DIR}/version.cpp DEPENDS genve
 add_subdirectory(common)
 add_subdirectory(crypto)
 add_subdirectory(ringct)
+add_subdirectory(oracle)
 add_subdirectory(checkpoints)
 add_subdirectory(cryptonote_basic)
-add_subdirectory(oracle)
 add_subdirectory(cryptonote_core)
 add_subdirectory(lmdb)
 add_subdirectory(multisig)
@@ -1,5 +1,5 @@
 // Copyright (c) 2014-2022, The Monero Project
-// Portions Copyright (c) 2023, Fulmo (author: SRCG)
+// Portions Copyright (c) 2023, Salvium (author: SRCG)
 // 
 // All rights reserved.
 // 
@@ -232,21 +232,33 @@ void BlockchainDB::add_transaction(const crypto::hash& blk_hash, const std::pair
  {
    // miner v2 txes have their coinbase output in one single out to save space,
    // and we store them as rct outputs with an identity mask
+    uint64_t unlock_time = 0;
+    if (!cryptonote::get_output_unlock_time(tx.vout[i], unlock_time)) {
+      LOG_PRINT_L1("Failed to get output unlock time, aborting transaction addition");
+      throw std::runtime_error("Unexpected error getting output unlock_time, aborting");
+    }
    if (miner_tx && tx.version == 2)
    {
      cryptonote::tx_out vout = tx.vout[i];
      rct::key commitment = rct::zeroCommit(vout.amount);
      vout.amount = 0;
-      amount_output_indices[i] = add_output(tx_hash, vout, i, tx.unlock_time,
+      amount_output_indices[i] = add_output(tx_hash, vout, i, unlock_time,
        &commitment);
    }
    else
    {
-      amount_output_indices[i] = add_output(tx_hash, tx.vout[i], i, tx.unlock_time,
+      amount_output_indices[i] = add_output(tx_hash, tx.vout[i], i, unlock_time,
        tx.version > 1 ? &tx.rct_signatures.outPk[i].mask : NULL);
    }
  }
  add_tx_amount_output_indices(tx_id, amount_output_indices);
+
+  // Check to see if this is a YIELD TX
+  if (tx.type == cryptonote::transaction_type::STAKE) {
+
+    // We now need to insert a record into the "yield_tx_data" table to record the TX
+    
+  }
 }

 uint64_t BlockchainDB::add_block( const std::pair<block, blobdata>& blck
@@ -255,6 +267,8 @@ uint64_t BlockchainDB::add_block( const std::pair<block, blobdata>& blck
                                , const difficulty_type& cumulative_difficulty
                                , const uint64_t& coins_generated
                                , const std::vector<std::pair<transaction, blobdata>>& txs
+                                , const cryptonote::network_type& nettype
+                                , cryptonote::yield_block_info& ybi
                                )
 {
  const block &blk = blck.first;
@@ -295,6 +309,7 @@ uint64_t BlockchainDB::add_block( const std::pair<block, blobdata>& blck
  }

  std::map<std::string, int64_t> slippage_counts;
+  uint64_t yield_total = 0;
  if (blk.protocol_tx.version == 2)
  {
    num_rct_outs += blk.protocol_tx.vout.size();
@@ -333,44 +348,69 @@ uint64_t BlockchainDB::add_block( const std::pair<block, blobdata>& blck
        num_rct_outs_by_asset_type.add(asset_type, 1);
      }

-      // Update the amount tallies by ADDING the burnt amount
+      // Is this a CONVERT TX?
      if (tx.first.type == cryptonote::transaction_type::CONVERT) {
+        // Update the amount tallies by ADDING the burnt amount
        if (slippage_counts.count(asset_type) == 0)
          slippage_counts[asset_type] = 0;
        slippage_counts[asset_type] += tx.first.amount_burnt;
      }
+
+      // Is this a YIELD TX?
+      if (tx.first.type == cryptonote::transaction_type::STAKE) {
+        yield_total += tx.first.amount_burnt;
+      }
    }
    ++tx_i;
  }

  // SRCG: This is the code that calculates the total slippage for the block
-  // Now convert all of the residual balances into FULM
-  /*
+  // Now convert all of the residual balances into SAL
+  boost::multiprecision::int128_t slippage_total_128 = 0;
  uint64_t slippage_total = 0;
-  for (const auto& tally: slippage_counts) {
-    if (tally.second < 0)
-      throw std::runtime_error("Found a negative tally when summing the burnt/minted amounts");
-    uint64_t slippage_amount = 0;
-    if (tally.first == "FULM") {
-      slippage_amount = tally.second;
-    } else {
-      // Sanity check - do we have a price for this asset type in the PR?
-      if (blk.pricing_record.count(tally.first) == 0) {
-        // No price available - bail out, because block is invalid
-        throw std::runtime_error("Asset type is not present in available pricing record:" + tally.first);
+  if (blk.major_version >= HF_VERSION_ENABLE_CONVERT) {
+    for (const auto& tally: slippage_counts) {
+      boost::multiprecision::int128_t slippage_amount_128 = 0;
+      if (tally.first == "SAL") {
+        slippage_amount_128 = tally.second;
+      } else {
+        // Sanity check - do we have a price for both source asset type and SAL in the PR?
+        boost::multiprecision::int128_t sal_price = blk.pricing_record["SAL"];
+        boost::multiprecision::int128_t asset_price = blk.pricing_record[tally.first];
+        if (sal_price == 0) {
+          // No price available - bail out, because block is invalid
+          throw std::runtime_error("Asset type 'SAL' is not present in available pricing record");
+        }
+        if (asset_price == 0) {
+          // No price available - bail out, because block is invalid
+          throw std::runtime_error("Asset type '" + tally.first + "' is not present in available pricing record");
+        }
+        // Convert the VSD amount into SAL
+        boost::multiprecision::int128_t tally_128 = tally.second;
+        tally_128 *= asset_price;
+        tally_128 /= sal_price;
+        slippage_amount_128 = tally_128.convert_to<int64_t>();
      }
-      // Convert the amount
-      //boost::multiprecision::uint128_t tally_128 = tally.second;
+      slippage_total_128 += slippage_amount_128;
    }
+    if (slippage_total_128 < 0)
+      throw std::runtime_error("Found a negative slippage total when summing the burnt/minted amounts");
+    slippage_total = slippage_total_128.convert_to<uint64_t>();
+
+  } else {
+
+    // Prior to activation of conversions, the staking reward is purely a percentage of the block reward
+    if (blk.miner_tx.amount_burnt == 0 and prev_height != 0)
+      throw std::runtime_error("Staking reward is zero, but block reward is present");
+    slippage_total = blk.miner_tx.amount_burnt;
  }
-  */
  
  TIME_MEASURE_FINISH(time1);
  time_add_transaction += time1;

  // call out to subclass implementation to add the block & metadata
  time1 = epee::misc_utils::get_tick_count();
-  add_block(blk, block_weight, long_term_block_weight, cumulative_difficulty, coins_generated, num_rct_outs, num_rct_outs_by_asset_type, blk_hash);
+  add_block(blk, block_weight, long_term_block_weight, cumulative_difficulty, coins_generated, num_rct_outs, num_rct_outs_by_asset_type, blk_hash, slippage_total, yield_total, nettype, ybi);
  TIME_MEASURE_FINISH(time1);
  time_add_block1 += time1;

@@ -422,7 +462,7 @@ void BlockchainDB::remove_transaction(const crypto::hash& tx_hash)
  }

  // Check for yield_tx entries
-  if (tx.type == cryptonote::transaction_type::YIELD) {
+  if (tx.type == cryptonote::transaction_type::STAKE) {
  }
  
  const bool miner_tx = tx.vin.size() == 1 && tx.vin[0].type() == typeid(txin_gen);
@@ -157,7 +157,7 @@ struct txpool_tx_meta_t
 {
  crypto::hash max_used_block_id;
  crypto::hash last_failed_id;
-  crypto::key_image input_k_image;
+  crypto::public_key return_pubkey;
  crypto::public_key return_address;
  crypto::public_key one_time_public_key;
  uint64_t weight;
@@ -197,6 +197,14 @@ struct txpool_tx_meta_t
  }
 };

+typedef struct yield_tx_info {
+  uint64_t block_height;
+  crypto::hash tx_hash;
+  uint64_t locked_coins;
+  crypto::public_key return_address;
+  crypto::public_key P_change;
+  crypto::public_key return_pubkey;
+} yield_tx_info;

 #define DBF_SAFE       1
 #define DBF_FAST       2
@@ -408,16 +416,22 @@ private:
   * @param cumulative_difficulty the accumulated difficulty after this block
   * @param coins_generated the number of coins generated total after this block
   * @param blk_hash the hash of the block
+   * @param slippage_total the total value (expressed in SAL coins) of all slippage for this block
+   * @param yield_total the total of SAL coins that have been locked for yield in this block
   */
-  virtual void add_block( const block& blk
-                , size_t block_weight
-                , uint64_t long_term_block_weight
-                , const difficulty_type& cumulative_difficulty
-                , const uint64_t& coins_generated
-                , uint64_t num_rct_outs
-                , oracle::asset_type_counts& cum_rct_by_asset_type
-                , const crypto::hash& blk_hash
-                ) = 0;
+  virtual void add_block( const block& blk,
+                          size_t block_weight,
+                          uint64_t long_term_block_weight,
+                          const difficulty_type& cumulative_difficulty,
+                          const uint64_t& coins_generated,
+                          uint64_t num_rct_outs,
+                          oracle::asset_type_counts& cum_rct_by_asset_type,
+                          const crypto::hash& blk_hash,
+                          uint64_t slippage_total,
+                          uint64_t yield_total,
+                          const cryptonote::network_type& nettype,
+                          cryptonote::yield_block_info& ybi
+                          ) = 0;

  /**
   * @brief remove data about the top block
@@ -869,6 +883,8 @@ public:
                            , const difficulty_type& cumulative_difficulty
                            , const uint64_t& coins_generated
                            , const std::vector<std::pair<transaction, blobdata>>& txs
+                            , const cryptonote::network_type& nettype
+                            , cryptonote::yield_block_info& ybi
                            );

  /**
@@ -1898,6 +1914,10 @@ public:
   */
  virtual uint64_t get_database_size() const = 0;

+  virtual int get_yield_block_info(const uint64_t height, yield_block_info& ybi) = 0;
+  virtual int get_yield_tx_info(const uint64_t height, std::vector<yield_tx_info>& yti_container) = 0;
+
+  
  /**
   * @brief set whether or not to automatically remove logs
   *
@@ -1,5 +1,5 @@
 // Copyright (c) 2014-2023, The Monero Project
-// Portions Copyright (c) 2023, Fulmo (author: SRCG)
+// Portions Copyright (c) 2023, Salvium (author: SRCG)
 // All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without modification, are
@@ -212,8 +212,8 @@ namespace
 *
 * alt_blocks       block hash   {block data, block blob}
 *
- * yield_block_data block height {}
- * yield_tx_data    block height {txn hash, dest address, amount}
+ * yield_block_data block height {slippage_coins, locked_coins, lc_total, network_health}
+ * yield_tx_data    block height {txn hash, locked_coins, return_address}
 *
 * Note: where the data items are of uniform size, DUPFIXED tables have
 * been used to save space. In most of these cases, a dummy "zerokval"
@@ -223,6 +223,7 @@ namespace
 *
 * The output_amounts table doesn't use a dummy key, but uses DUPSORT.
 */
+
 const char* const LMDB_BLOCKS = "blocks";
 const char* const LMDB_BLOCK_HEIGHTS = "block_heights";
 const char* const LMDB_BLOCK_INFO = "block_info";
@@ -256,19 +257,20 @@ const char* const LMDB_CIRC_SUPPLY_TALLY = "circ_supply_tally";
  /**
   * We have the following information that will go into a "yield_txs" table in the blockchain:
   *
-   * block_height    (uint64_t)     (this is the key field)
-   * ---------------------------------------------------------
-   * txn_hash         (crypto:hash)  (so we can verify)
-   * dest_address     (crypto::key)  (where to send the yield)
-   * amount_locked    (uint64_t)     (how much was locked)
+   * block_height        (uint64_t)     (this is the key field)
+   * ------------------------------------------------------------
+   * txn_hash            (crypto:hash)  (so we can verify)
+   * dest_address        (crypto::key)  (where to send the yield)
+   * amount_locked       (uint64_t)     (how much was locked)
   *
   * We also have the following information that will go into a "yield_blocks" table:
   *
-   * block_height     (uint64_t)     (this is the key field)
-   * --------------------------------------------------------
-   * slippage_amount  (uint64_t)     (amount needed to determine yield payout for the block)
-   * coins_locked     (uint64_t)     (total number of coins locked at this height)
-   * network_health   (uint8_t)      (a fudge factor used to adjust the slippage:yield ratio dynamically)
+   * block_height        (uint64_t)     (this is the key field)
+   * ------------------------------------------------------------
+   * slippage_amount     (uint64_t)     (amount needed to determine yield payout for the block)
+   * locked_coins        (uint64_t)     (total number of coins locked at this height)
+   * locked_coins_total  (uint64_t)     (total number of coins locked at this height)
+   * network_health      (uint8_t)      (a fudge factor used to adjust the slippage:yield ratio dynamically)
   *
   * So, let's say that we have a block height h for which we want to assess the yield payments. First off,
   * we are ONLY interested in making ANY payment if we have YIELD.block_height == h + 21600 (i.e. the yield
@@ -375,31 +377,12 @@ typedef struct outassettype {
  uint64_t output_id;
 } outassettype;

-typedef struct circ_supply {
-  crypto::hash tx_hash;
-  uint32_t asset_type;
-  uint64_t amount_burnt;
-  uint64_t amount_minted;
-} circ_supply;
-
 typedef struct circ_supply_tally {
  bool is_negative;
  uint64_t amount_hi;
  uint64_t amount_lo;
 } circ_supply_tally;
  
-typedef struct yield_tx_data {
-  crypto::hash tx_hash;
-  crypto::public_key return_address;
-  uint64_t amount;
-} yield_tx_data;    
-
-typedef struct yield_block_data {
-  uint64_t slippage_total;
-  uint64_t locked_coins_total;
-  uint8_t network_health_percentage;
-} yield_block_data;
-  
 std::atomic<uint64_t> mdb_txn_safe::num_active_txns{0};
 std::atomic_flag mdb_txn_safe::creation_gate = ATOMIC_FLAG_INIT;

@@ -817,7 +800,69 @@ estim:
  return threshold_size;
 }

-void BlockchainLMDB::add_block(const block& blk, size_t block_weight, uint64_t long_term_block_weight, const difficulty_type& cumulative_difficulty, const uint64_t& coins_generated, uint64_t num_rct_outs, oracle::asset_type_counts& cum_rct_by_asset_type, const crypto::hash& blk_hash)
+int BlockchainLMDB::get_yield_block_info(const uint64_t height, yield_block_info& ybi)
+{
+  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
+  check_open();
+  
+  // Clear the YBI, just in case
+  std::memset(&ybi, 0, sizeof(struct yield_block_info));
+
+  // Query for the matured YIELD_BLOCK_INFO information
+  TXN_PREFIX_RDONLY();
+  RCURSOR(yield_blocks);
+  
+  MDB_val v;
+  MDB_val_set(k, height);
+  int ret = mdb_cursor_get(m_cur_yield_blocks, &k, &v, MDB_SET);
+  if (ret == MDB_NOTFOUND) {
+    LOG_ERROR("Failed to locate YBI for block height " << height);
+    return ret;
+  }
+  if (ret)
+    throw0(DB_ERROR(lmdb_error("Failed to enumerate yield block info: ", ret).c_str()));
+
+  yield_block_info *p = (yield_block_info*)v.mv_data;
+  ybi = *p;
+
+  // Return success to caller
+  return ret;
+}
+
+int BlockchainLMDB::get_yield_tx_info(const uint64_t height, std::vector<yield_tx_info>& yti_container)
+{
+  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
+  check_open();
+
+  // Clear the container
+  yti_container.clear();
+
+  // Query for the (presumably matured) YIELD_TX_INFO information
+  TXN_PREFIX_RDONLY();
+  RCURSOR(yield_txs);
+  
+  MDB_val v;
+  MDB_val_set(k, height);
+  MDB_cursor_op op = MDB_SET;
+  while (1)
+  {
+    int ret = mdb_cursor_get(m_cur_yield_txs, &k, &v, op);
+    op = MDB_NEXT_DUP;
+    if (ret == MDB_NOTFOUND)
+      break;
+    if (ret)
+      throw0(DB_ERROR(lmdb_error("Failed to enumerate yield TX info: ", ret).c_str()));
+
+    // Push result back into the container
+    yield_tx_info *p = (yield_tx_info*)v.mv_data;
+    yti_container.emplace_back(*p);
+  }
+
+  // Return success to caller
+  return 0;
+}
+
+void BlockchainLMDB::add_block(const block& blk, size_t block_weight, uint64_t long_term_block_weight, const difficulty_type& cumulative_difficulty, const uint64_t& coins_generated, uint64_t num_rct_outs, oracle::asset_type_counts& cum_rct_by_asset_type, const crypto::hash& blk_hash, uint64_t slippage_total, uint64_t yield_total, const cryptonote::network_type& nettype, cryptonote::yield_block_info& ybi)
 {
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  check_open();
@@ -847,11 +892,50 @@ void BlockchainLMDB::add_block(const block& blk, size_t block_weight, uint64_t l

  int result = 0;

+  CURSOR(yield_blocks)
+  yield_block_info ybi_matured, ybi_prev;
+  uint64_t yield_lock_period = cryptonote::get_config(nettype).STAKE_LOCK_PERIOD;
+  if (m_height > yield_lock_period) {
+    uint64_t height_matured = m_height - yield_lock_period - 1;
+    result = get_yield_block_info(height_matured, ybi_matured);
+    if (result)
+    {
+      throw0(DB_ERROR(lmdb_error("Failed to get YBI for matured height: ", result).c_str()));
+    }
+  } else {
+    // Chain is too new - just clear the memory of the "matured" YBI struct
+    std::memset(&ybi_matured, 0, sizeof(struct yield_block_info));
+    ybi_prev.network_health_percentage = 100;
+  }
+  if (m_height >= 1) {
+    // Query for the latest YIELD_BLOCK_INFO information
+    result = get_yield_block_info(m_height - 1, ybi_prev);
+    if (result)
+    {
+      throw0(DB_ERROR(lmdb_error("Failed to get YBI for last block: ", result).c_str()));
+    }
+  } else {
+    // Chain is too new - just clear the memory of the "prev" YBI struct
+    std::memset(&ybi_prev, 0, sizeof(struct yield_block_info));
+    ybi_prev.network_health_percentage = 100;
+  }
+  
+  // Create the YIELD_BLOCK_INFO instance for this block
+  ybi.block_height = m_height;
+  ybi.slippage_total_this_block = slippage_total;
+  ybi.locked_coins_this_block = yield_total;
+  ybi.locked_coins_tally = ybi_prev.locked_coins_tally - ybi_matured.locked_coins_this_block + yield_total;
+  ybi.network_health_percentage = 100;
+
+  // Put the YBI into the table
  MDB_val_set(key, m_height);
+  MDB_val_set(ybi_val, ybi);
+  result = mdb_cursor_put(m_cur_yield_blocks, &key, &ybi_val, MDB_APPEND);
+  if (result)
+    throw0(DB_ERROR(lmdb_error("Failed to add YBI to db: ", result).c_str()));

  CURSOR(blocks)
  CURSOR(block_info)
-  CURSOR(circ_supply_tally)

  // this call to mdb_cursor_put will change height()
  cryptonote::blobdata block_blob(block_to_blob(blk));
@@ -915,6 +999,7 @@ void BlockchainLMDB::remove_block()
  CURSOR(block_heights)
  CURSOR(blocks)
  CURSOR(circ_supply_tally)
+  CURSOR(yield_blocks)
  MDB_val_copy<uint64_t> k(m_height - 1);
  MDB_val h = k;
  if ((result = mdb_cursor_get(m_cur_block_info, (MDB_val *)&zerokval, &h, MDB_GET_BOTH)))
@@ -935,6 +1020,13 @@ void BlockchainLMDB::remove_block()

  if ((result = mdb_cursor_del(m_cur_block_info, 0)))
      throw1(DB_ERROR(lmdb_error("Failed to add removal of block info to db transaction: ", result).c_str()));
+
+  MDB_val_copy<uint64_t> k2(m_height - 1);
+  MDB_val v = k2;
+  if ((result = mdb_cursor_get(m_cur_yield_blocks, &k2,  NULL, MDB_SET)))
+      throw1(BLOCK_DNE(lmdb_error("Attempting to remove yield block info that's not in the db: ", result).c_str()));
+  if ((result = mdb_cursor_del(m_cur_yield_blocks, 0)))
+      throw1(DB_ERROR(lmdb_error("Failed to add removal of yield block info to db transaction: ", result).c_str()));
 }

 boost::multiprecision::int128_t
@@ -1087,7 +1179,7 @@ uint64_t BlockchainLMDB::add_transaction_data(const crypto::hash& blk_hash, cons
      throw0(DB_ERROR(lmdb_error("Failed to add prunable tx prunable hash to db transaction: ", result).c_str()));
  }

-  if (tx.type == cryptonote::transaction_type::CONVERT || tx.type == cryptonote::transaction_type::BURN) {
+  if (tx.type == cryptonote::transaction_type::BURN || tx.type == cryptonote::transaction_type::CONVERT || tx.type == cryptonote::transaction_type::STAKE) {

    // Get the current tally value for the source currency type
    MDB_val_copy<uint64_t> source_idx(cryptonote::asset_id_from_type(tx.source_asset_type));
@@ -1096,10 +1188,10 @@ uint64_t BlockchainLMDB::add_transaction_data(const crypto::hash& blk_hash, cons
    boost::multiprecision::int128_t final_source_tally = source_tally - tx.amount_burnt;
    boost::multiprecision::int128_t coinbase = get_block_already_generated_coins(m_height-1);
    if (source_tally == 0 && result == MDB_NOTFOUND) {
-      if (tx.source_asset_type == "FULM") {
+      if (tx.source_asset_type == "SAL") {
        final_source_tally += coinbase;
      } else {
-        throw0(DB_ERROR("burn underflow - asset balance is zero for non-FULM asset"));
+        throw0(DB_ERROR("burn underflow - asset balance is zero for non-SAL asset"));
      }
    }
    write_circulating_supply_data(m_cur_circ_supply_tally, source_idx, final_source_tally);
@@ -1130,7 +1222,7 @@ uint64_t BlockchainLMDB::add_transaction_data(const crypto::hash& blk_hash, cons
      boost::multiprecision::int128_t final_source_tally = source_tally + asset.second;
      boost::multiprecision::int128_t coinbase = get_block_already_generated_coins(m_height-1);
      if (source_tally == 0 && result == MDB_NOTFOUND) {
-        if (tx.source_asset_type == "FULM") {
+        if (tx.source_asset_type == "SAL") {
          final_source_tally += coinbase;
        }
      }
@@ -1140,15 +1232,45 @@ uint64_t BlockchainLMDB::add_transaction_data(const crypto::hash& blk_hash, cons
  }
  
  // Is there yield_tx data to add?
-  if (tx.type == cryptonote::transaction_type::YIELD) {
+  if (tx.type == cryptonote::transaction_type::STAKE) {
+
    // Create the object we are going to write to the database
-    yield_tx_data yield_data;
+    yield_tx_info yield_data;
+    yield_data.block_height = m_height;
    yield_data.tx_hash = tx_hash;
    yield_data.return_address = tx.return_address;
-    yield_data.amount = tx.amount_burnt; // SRCG - this feels as though we are bastardising the variable for an invalid purpose
+    yield_data.locked_coins = tx.amount_burnt;
+    if (tx.vin.empty())
+      throw0(DB_ERROR("tx.vin is empty (needed to create yield data for the PROTOCOL_TX)"));
+    if (tx.vin[0].type() != typeid(cryptonote::txin_to_key))
+      throw0(DB_ERROR("tx.vin[0] is wrong type (needed to create yield data for the PROTOCOL_TX)"));
+    yield_data.return_pubkey = tx.return_pubkey;
+    if (tx.vout.size() != 1)
+      throw0(DB_ERROR("tx.vout is wrong size (needed to create yield data for the PROTOCOL_TX)"));
+    if (!cryptonote::get_output_public_key(tx.vout[0], yield_data.P_change))
+      throw0(DB_ERROR("failed to get P_change from tx.vout[0] (needed to create yield data for the PROTOCOL_TX)"));
+
+    // Because LMDB is shockingly bad at handling duplicates, we have resorted to using a counter of elements
+    // in the first element of the struct.
+    MDB_val data;
    MDB_val_set(val_height, m_height);
+    result = mdb_cursor_get(m_cur_yield_txs, &val_height, &data, MDB_SET);
+    if (!result)
+    {
+      mdb_size_t num_elems = 0;
+      result = mdb_cursor_count(m_cur_yield_txs, &num_elems);
+      if (result)
+        throw0(DB_ERROR(std::string("Failed to get number of yield TXs for height: ").append(mdb_strerror(result)).c_str()));
+      yield_data.block_height = num_elems;
+    }
+    else if (result != MDB_NOTFOUND)
+      throw0(DB_ERROR(lmdb_error("Failed to get output amount in db transaction: ", result).c_str()));
+    else
+     yield_data.block_height = 0;
+
+    // Now we know how many there are, write out the data to the DB
    MDB_val_set(val_yield_tx_data, yield_data);
-    result = mdb_cursor_put(m_cur_yield_txs, &val_height, &val_yield_tx_data, MDB_APPEND);
+    result = mdb_cursor_put(m_cur_yield_txs, &val_height, &val_yield_tx_data, MDB_APPENDDUP);
    if (result)
      throw0(DB_ERROR(  lmdb_error("Failed to add tx yield data to db transaction: ", result).c_str()  ));
  }
@@ -1173,7 +1295,6 @@ void BlockchainLMDB::remove_transaction_data(const crypto::hash& tx_hash, const
  CURSOR(txs_prunable_hash)
  CURSOR(txs_prunable_tip)
  CURSOR(tx_outputs)
-  CURSOR(circ_supply)
  CURSOR(circ_supply_tally)
  CURSOR(yield_txs)

@@ -1264,20 +1385,6 @@ void BlockchainLMDB::remove_transaction_data(const crypto::hash& tx_hash, const
      LOG_PRINT_L1("tx ID " << tip->data.tx_id << "\n\tAsset Type = " << cryptonote::asset_type_from_id(asset.first) << "\n\tTally before undoing mint =" << source_tally.str() << "\n\tTally after undoing mint =" << final_source_tally.str());
    }
  }
-  /*
-  // Update the circ_supply table by deleting all entries for this TX
-  if ((result = mdb_cursor_get(m_cur_circ_supply, &val_tx_id, NULL, MDB_SET))) {
-    if (result == MDB_NOTFOUND) {
-      LOG_PRINT_L1("failed to obtain circulating supply data - no burns / conversions made yet?");
-    } else {
-      throw1(DB_ERROR(lmdb_error("Failed to locate circulating supply for removal: ", result).c_str()));
-    }
-  } else {
-    result = mdb_cursor_del(m_cur_circ_supply, 0);
-    if (result)
-      throw1(DB_ERROR(lmdb_error("Failed to add removal of circulating supply to db transaction: ", result).c_str()));
-  }
-  */
  remove_tx_outputs(tip->data.tx_id, tx);

  result = mdb_cursor_get(m_cur_tx_outputs, &val_tx_id, NULL, MDB_SET);
@@ -1293,18 +1400,23 @@ void BlockchainLMDB::remove_transaction_data(const crypto::hash& tx_hash, const
  }

  // Is there yield_tx data to remove?
-  if (tx.type == cryptonote::transaction_type::YIELD) {
+  if (tx.type == cryptonote::transaction_type::STAKE) {
    // Remove any yield_tx data for this transaction
-    result = mdb_cursor_get(m_cur_yield_txs, &val_tx_id, NULL, MDB_SET);
-    if (result == MDB_NOTFOUND)
-      LOG_PRINT_L1("tx has no yield_tx data to remove: " << tx_hash);
-    else if (result)
-      throw1(DB_ERROR(lmdb_error("Failed to locate yield_tx data for removal: ", result).c_str()));
-    if (!result)
-    {
-      result = mdb_cursor_del(m_cur_yield_txs, 0);
-      if (result)
-        throw1(DB_ERROR(lmdb_error("Failed to add removal of yield_tx data to db transaction: ", result).c_str()));
+    MDB_val_set(val_height, m_height);
+    MDB_val v;
+    while (1) {
+      result = mdb_cursor_get(m_cur_yield_txs, &val_height, &v, MDB_SET);
+      if (result == MDB_NOTFOUND)
+        break;
+      else if (result)
+        throw1(DB_ERROR(lmdb_error("Failed to locate yield_tx data for removal: ", result).c_str()));
+      const yield_tx_info yti = *(const yield_tx_info*)v.mv_data;
+      if (yti.tx_hash == tx_hash) {
+        result = mdb_cursor_del(m_cur_yield_txs, 0);
+        if (result)
+          throw1(DB_ERROR(lmdb_error("Failed to add removal of yield_tx data to db transaction: ", result).c_str()));
+        break;
+      }
    }
  }
  
@@ -1788,6 +1900,7 @@ void BlockchainLMDB::open(const std::string& filename, const int db_flags)
  lmdb_db_open(txn, LMDB_CIRC_SUPPLY_TALLY, MDB_CREATE, m_circ_supply_tally, "Failed to open db handle for m_circ_supply_tally");

  lmdb_db_open(txn, LMDB_YIELD_TXS, MDB_INTEGERKEY | MDB_DUPSORT | MDB_DUPFIXED | MDB_CREATE, m_yield_txs, "Failed to open db handle for m_yield_txs");
+  lmdb_db_open(txn, LMDB_YIELD_BLOCKS, MDB_INTEGERKEY | MDB_CREATE, m_yield_blocks, "Failed to open db handle for m_yield_blocks");

  mdb_set_dupsort(txn, m_spent_keys, compare_hash32);
  mdb_set_dupsort(txn, m_block_heights, compare_hash32);
@@ -1849,7 +1962,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 fulmod once to convert the database.");
+        MFATAL("Please run salviumd once to convert the database.");
        return;
      }
      // Note that there was a schema change within version 0 as well.
@@ -1991,6 +2104,8 @@ void BlockchainLMDB::reset()
    throw0(DB_ERROR(lmdb_error("Failed to drop m_properties: ", result).c_str()));
  if (auto result = mdb_drop(txn, m_yield_txs, 0))
    throw0(DB_ERROR(lmdb_error("Failed to drop m_yield_txs: ", result).c_str()));
+  if (auto result = mdb_drop(txn, m_yield_blocks, 0))
+    throw0(DB_ERROR(lmdb_error("Failed to drop m_yield_blocks: ", result).c_str()));

  // init with current version
  MDB_val_str(k, "version");
@@ -3298,7 +3413,13 @@ std::map<std::string,uint64_t> BlockchainLMDB::get_circulating_supply() const
  }

  uint64_t m_coinbase = get_block_already_generated_coins(m_height-1);
-  LOG_PRINT_L3("BlockchainLMDB::" << __func__ << " - mined supply for FULM = " << m_coinbase);
+  LOG_PRINT_L3("BlockchainLMDB::" << __func__ << " - mined supply for SAL = " << m_coinbase);
+
+  // SRCG: For V1, we can simply return this number, because there is no other source of coins
+  circulating_supply["SAL"] = m_coinbase;
+  return circulating_supply;
+  
+  /*
  check_open();
  
  TXN_PREFIX_RDONLY();
@@ -3324,9 +3445,9 @@ std::map<std::string,uint64_t> BlockchainLMDB::get_circulating_supply() const
    const std::string currency_label = cryptonote::asset_type_from_id(currency_type);
    boost::multiprecision::int128_t amount = import_tally_from_cst(cst);

-    // Check for FULM - we need to adjust the total for them
+    // Check for SAL - we need to adjust the total for them
    if (currency_type == 0) {
-      // Get the current circulating supply for FULM
+      // Get the current circulating supply for SAL
      amount += m_coinbase;
    }

@@ -3337,9 +3458,10 @@ std::map<std::string,uint64_t> BlockchainLMDB::get_circulating_supply() const

  // NEAC: check for empty supply tally - only happens prior to first conversion on chain
  if (circulating_supply.empty()) {
-    circulating_supply["FULM"] = m_coinbase;
+    circulating_supply["SAL"] = m_coinbase;
  }
  return circulating_supply;
+  */
 }

 uint64_t BlockchainLMDB::num_outputs() const
@@ -4530,7 +4652,7 @@ void BlockchainLMDB::block_rtxn_abort() const
 }

 uint64_t BlockchainLMDB::add_block(const std::pair<block, blobdata>& blk, size_t block_weight, uint64_t long_term_block_weight, const difficulty_type& cumulative_difficulty, const uint64_t& coins_generated,
-    const std::vector<std::pair<transaction, blobdata>>& txs)
+                                   const std::vector<std::pair<transaction, blobdata>>& txs, const cryptonote::network_type& nettype, cryptonote::yield_block_info& ybi)
 {
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  check_open();
@@ -4548,7 +4670,7 @@ uint64_t BlockchainLMDB::add_block(const std::pair<block, blobdata>& blk, size_t

  try
  {
-    BlockchainDB::add_block(blk, block_weight, long_term_block_weight, cumulative_difficulty, coins_generated, txs);
+    BlockchainDB::add_block(blk, block_weight, long_term_block_weight, cumulative_difficulty, coins_generated, txs, nettype, ybi);
  }
  catch (const DB_ERROR_TXN_START& e)
  {
@@ -341,6 +341,8 @@ public:
                            , const difficulty_type& cumulative_difficulty
                            , const uint64_t& coins_generated
                            , const std::vector<std::pair<transaction, blobdata>>& txs
+                            , const cryptonote::network_type& nettype
+                            , cryptonote::yield_block_info& ybi
                            );

  virtual void set_batch_transactions(bool batch_transactions);
@@ -388,15 +390,19 @@ private:
  void check_and_resize_for_batch(uint64_t batch_num_blocks, uint64_t batch_bytes);
  uint64_t get_estimated_batch_size(uint64_t batch_num_blocks, uint64_t batch_bytes) const;

-  virtual void add_block( const block& blk
-                , size_t block_weight
-                , uint64_t long_term_block_weight
-                , const difficulty_type& cumulative_difficulty
-                , const uint64_t& coins_generated
-                , uint64_t num_rct_outs
-                , oracle::asset_type_counts& cum_rct_by_asset_type
-                , const crypto::hash& block_hash
-                );
+  virtual void add_block( const block& blk,
+                          size_t block_weight,
+                          uint64_t long_term_block_weight,
+                          const difficulty_type& cumulative_difficulty,
+                          const uint64_t& coins_generated,
+                          uint64_t num_rct_outs,
+                          oracle::asset_type_counts& cum_rct_by_asset_type,
+                          const crypto::hash& blk_hash,
+                          uint64_t slippage_total,
+                          uint64_t yield_total,
+                          const cryptonote::network_type& nettype,
+                          cryptonote::yield_block_info& ybi
+                          );

  virtual void remove_block();

@@ -453,6 +459,9 @@ private:
  //void migrate_0_1();
  void cleanup_batch();

+  virtual int get_yield_block_info(const uint64_t height, yield_block_info& ybi);
+  virtual int get_yield_tx_info(const uint64_t height, std::vector<yield_tx_info>& yti_container);
+
 private:
  MDB_env* m_env;

@@ -486,7 +495,9 @@ private:

  MDB_dbi m_circ_supply;
  MDB_dbi m_circ_supply_tally;
+
  MDB_dbi m_yield_txs;
+  MDB_dbi m_yield_blocks;

  mutable uint64_t m_cum_size;	// used in batch size estimation
  mutable unsigned int m_cum_count;
@@ -76,7 +76,7 @@ public:
  virtual uint64_t get_block_height(const crypto::hash& h) const override { return 0; }
  virtual cryptonote::block_header get_block_header(const crypto::hash& h) const override { return cryptonote::block_header(); }
  virtual uint64_t get_block_timestamp(const uint64_t& height) const override { return 0; }
-  virtual std::pair<std::vector<uint64_t>, uint64_t> get_block_cumulative_rct_outputs(const std::vector<uint64_t> &heights, const std::string asset_type) const override { return std::pair<std::vector<uint64_t>, uint64_t>(); }
+  virtual std::vector<uint64_t> get_block_cumulative_rct_outputs(const std::vector<uint64_t> &heights) const override { return {}; }
  virtual uint64_t get_top_block_timestamp() const override { return 0; }
  virtual size_t get_block_weight(const uint64_t& height) const override { return 128; }
  virtual std::vector<uint64_t> get_block_weights(uint64_t start_height, size_t count) const override { return {}; }
@@ -101,8 +101,6 @@ public:
  virtual std::vector<cryptonote::transaction> get_tx_list(const std::vector<crypto::hash>& hlist) const override { return std::vector<cryptonote::transaction>(); }
  virtual uint64_t get_tx_block_height(const crypto::hash& h) const override { return 0; }
  virtual uint64_t get_num_outputs(const uint64_t& amount) const override { return 1; }
-  virtual uint64_t get_num_outputs_of_asset_type(const std::string asset_type) const override { return 1; }
-
  virtual uint64_t get_indexing_base() const override { return 0; }
  virtual cryptonote::output_data_t get_output_key(const uint64_t& amount, const uint64_t& index, bool include_commitmemt) const override { return cryptonote::output_data_t(); }
  virtual cryptonote::tx_out_index get_output_tx_and_index_from_global(const uint64_t& index) const override { return cryptonote::tx_out_index(); }
@@ -110,13 +108,13 @@ public:
  virtual void get_output_tx_and_index(const uint64_t& amount, const std::vector<uint64_t> &offsets, std::vector<cryptonote::tx_out_index> &indices) const override {}
  virtual void get_output_key(const epee::span<const uint64_t> &amounts, const std::vector<uint64_t> &offsets, std::vector<cryptonote::output_data_t> &outputs, bool allow_partial = false) const override {}
  virtual bool can_thread_bulk_indices() const override { return false; }
-  virtual std::vector<std::vector<std::pair<uint64_t, uint64_t>>> get_tx_amount_output_indices(const uint64_t tx_index, size_t n_txes) const override { return std::vector<std::vector<std::pair<uint64_t, uint64_t>>>(); }
+  virtual std::vector<std::vector<uint64_t>> get_tx_amount_output_indices(const uint64_t tx_index, size_t n_txes) const override { return std::vector<std::vector<uint64_t>>(); }
  virtual bool has_key_image(const crypto::key_image& img) const override { return false; }
  virtual void remove_block() override { }
-  virtual uint64_t add_transaction_data(const crypto::hash& blk_hash, const std::pair<cryptonote::transaction, cryptonote::blobdata_ref>& tx, const crypto::hash& tx_hash, const crypto::hash& tx_prunable_hash, const bool miner_tx) override {return 0;}
-  virtual void remove_transaction_data(const crypto::hash& tx_hash, const cryptonote::transaction& tx, const bool miner_tx) override {}
-  virtual std::pair<uint64_t, uint64_t> add_output(const crypto::hash& tx_hash, const cryptonote::tx_out& tx_output, const uint64_t& local_index, const uint64_t unlock_time, const rct::key *commitment) override {return std::make_pair(0, 0);}
-  virtual void add_tx_amount_output_indices(const uint64_t tx_index, const std::vector<std::pair<uint64_t, uint64_t>>& amount_output_indices) override {}
+  virtual uint64_t add_transaction_data(const crypto::hash& blk_hash, const std::pair<cryptonote::transaction, cryptonote::blobdata_ref>& tx, const crypto::hash& tx_hash, const crypto::hash& tx_prunable_hash) override {return 0;}
+  virtual void remove_transaction_data(const crypto::hash& tx_hash, const cryptonote::transaction& tx) override {}
+  virtual uint64_t add_output(const crypto::hash& tx_hash, const cryptonote::tx_out& tx_output, const uint64_t& local_index, const uint64_t unlock_time, const rct::key *commitment) override {return 0;}
+  virtual void add_tx_amount_output_indices(const uint64_t tx_index, const std::vector<uint64_t>& amount_output_indices) override {}
  virtual void add_spent_key(const crypto::key_image& k_image) override {}
  virtual void remove_spent_key(const crypto::key_image& k_image) override {}

@@ -146,7 +144,6 @@ public:
                        , const cryptonote::difficulty_type& cumulative_difficulty
                        , const uint64_t& coins_generated
                        , uint64_t num_rct_outs
-                        , oracle::asset_type_counts& cum_rct_by_asset_type
                        , const crypto::hash& blk_hash
                        ) override { }
  virtual cryptonote::block get_block_from_height(const uint64_t& height) const override { return cryptonote::block(); }
@@ -169,10 +166,6 @@ public:
  virtual uint64_t get_alt_block_count() override { return 0; }
  virtual void drop_alt_blocks() override {}
  virtual bool for_all_alt_blocks(std::function<bool(const crypto::hash &blkid, const alt_block_data_t &data, const cryptonote::blobdata_ref *blob)> f, bool include_blob = false) const override { return true; }
-
-  virtual std::map<std::string, uint64_t> get_circulating_supply() const override { return std::map<std::string, uint64_t>(); }
-  virtual void get_output_id_from_asset_type_output_index(const std::string asset_type, const std::vector<uint64_t> &asset_type_output_indices, std::vector<uint64_t> &output_indices) const override { }
-  virtual uint64_t get_output_id_from_asset_type_output_index(const std::string asset_type, const uint64_t &asset_type_output_index) const override { return 0; };
 };

 }
@@ -157,7 +157,7 @@ endif()

 set_property(TARGET blockchain_import
 	PROPERTY
-	OUTPUT_NAME "fulmo-blockchain-import")
+	OUTPUT_NAME "salvium-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 "fulmo-blockchain-export")
+	OUTPUT_NAME "salvium-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 "fulmo-blockchain-mark-spent-outputs")
+	OUTPUT_NAME "salvium-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 "fulmo-blockchain-usage")
+	OUTPUT_NAME "salvium-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 "fulmo-blockchain-ancestry")
+	OUTPUT_NAME "salvium-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 "fulmo-blockchain-depth")
+	OUTPUT_NAME "salvium-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 "fulmo-blockchain-stats")
+	OUTPUT_NAME "salvium-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 "fulmo-blockchain-prune-known-spent-data")
+	OUTPUT_NAME "salvium-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 "fulmo-blockchain-prune")
+	OUTPUT_NAME "salvium-blockchain-prune")
 install(TARGETS blockchain_prune DESTINATION bin)

 target_link_libraries(blockchain_prune
@@ -12,16 +12,16 @@ See also each utility's "--help" option.

 ### Export an existing blockchain database

-`$ monero-blockchain-export`
+`$ salvium-blockchain-export`

 This loads the existing blockchain and exports it to `$MONERO_DATA_DIR/export/blockchain.raw`

 ### Import the exported file

-`$ monero-blockchain-import`
+`$ salvium-blockchain-import`

 This imports blocks from `$MONERO_DATA_DIR/export/blockchain.raw` (exported using the
-`monero-blockchain-export` tool as described above) into the current database.
+`salvium-blockchain-export` tool as described above) into the current database.

 Defaults: `--batch on`, `--batch size 20000`, `--verify on`

@@ -30,14 +30,14 @@ Batch size refers to number of blocks and can be adjusted for performance based
 Verification should only be turned off if importing from a trusted blockchain.

 If you encounter an error like "resizing not supported in batch mode", you can just re-run
-the `monero-blockchain-import` command again, and it will restart from where it left off.
+the `salvium-blockchain-import` command again, and it will restart from where it left off.

 ```bash
 ## use default settings to import blockchain.raw into database
-$ monero-blockchain-import
+$ salvium-blockchain-import

 ## fast import with large batch size, database mode "fastest", verification off
-$ monero-blockchain-import --batch-size 20000 --database lmdb#fastest --verify off
+$ salvium-blockchain-import --batch-size 20000 --database lmdb#fastest --verify off

 ```

@@ -80,9 +80,9 @@ LMDB flags (more than one may be specified):
 ## Examples:

 ```bash
-$ monero-blockchain-import --database lmdb#fastest
+$ salvium-blockchain-import --database lmdb#fastest

-$ monero-blockchain-import --database lmdb#nosync
+$ salvium-blockchain-import --database lmdb#nosync

-$ monero-blockchain-import --database lmdb#nosync,nometasync
+$ salvium-blockchain-import --database lmdb#nosync,nometasync
 ```
@@ -4,16 +4,16 @@ Monero Blockchain Stats utlity exports daily statistics for the monero blockchai

 ## Usage:

-See also the utility's help option. `monero-blockchain-stats --help`
+See also the utility's help option. `salvium-blockchain-stats --help`

 From the command line run:

-`$ monero-blockchain-stats`
+`$ salvium-blockchain-stats`

 This loads the existing blockchain and prints the results to the terminal. Default printed data includes Blocks per Day, Total Blocks, Transactions per Day, Total Transactions, Bytes per Day and Total Bytes. The format of the output is in tab delimited csv which is printed to the console. Redirecting or piping the output of the command allows for saving the output to a csv file or feeding your own script accordingly, i.e.:

- `monero-blockchain-stats > stats-$(date +'%Y-%m-%d').csv`
- `monero-blockchain-stats | save-to-database.sh`
+- `salvium-blockchain-stats > stats-$(date +'%Y-%m-%d').csv`
+- `salvium-blockchain-stats | save-to-database.sh`

 ### Options
 `--data-dir arg` 
@@ -386,12 +386,12 @@ int main(int argc, char* argv[])

  if (command_line::get_arg(vm, command_line::arg_help))
  {
-    std::cout << "Fulmo '" << MONERO_RELEASE_NAME << "' (v" << MONERO_VERSION_FULL << ")" << ENDL << ENDL;
+    std::cout << "Salvium '" << 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("salvium-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
@@ -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 Salvium 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 << "Fulmo '" << MONERO_RELEASE_NAME << "' (v" << MONERO_VERSION_FULL << ")" << ENDL << ENDL;
+    std::cout << "Salvium '" << 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("salvium-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
@@ -88,12 +88,12 @@ int main(int argc, char* argv[])

  if (command_line::get_arg(vm, command_line::arg_help))
  {
-    std::cout << "Fulmo '" << MONERO_RELEASE_NAME << "' (v" << MONERO_VERSION_FULL << ")" << ENDL << ENDL;
+    std::cout << "Salvium '" << 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("salvium-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
@@ -90,12 +90,12 @@ int main(int argc, char* argv[])

  if (command_line::get_arg(vm, command_line::arg_help))
  {
-    std::cout << "Fulmo '" << MONERO_RELEASE_NAME << "' (v" << MONERO_VERSION_FULL << ")" << ENDL << ENDL;
+    std::cout << "Salvium '" << 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("salvium-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
@@ -487,8 +487,9 @@ int import_from_file(cryptonote::core& core, const std::string& import_file_path

          try
          {
+            cryptonote::yield_block_info ybi; // This just gets discarded because we aren't looking to maintain a cache of YBI data in the import utility
            uint64_t long_term_block_weight = core.get_blockchain_storage().get_next_long_term_block_weight(block_weight);
-            core.get_blockchain_storage().get_db().add_block(std::make_pair(b, block_to_blob(b)), block_weight, long_term_block_weight, cumulative_difficulty, coins_generated, txs);
+            core.get_blockchain_storage().get_db().add_block(std::make_pair(b, block_to_blob(b)), block_weight, long_term_block_weight, cumulative_difficulty, coins_generated, txs, opt_testnet ? cryptonote::TESTNET : opt_stagenet ? cryptonote::STAGENET : cryptonote::MAINNET, ybi);
          }
          catch (const std::exception& e)
          {
@@ -637,7 +638,7 @@ int main(int argc, char* argv[])

  if (command_line::get_arg(vm, command_line::arg_help))
  {
-    std::cout << "Fulmo '" << MONERO_RELEASE_NAME << "' (v" << MONERO_VERSION_FULL << ")" << ENDL << ENDL;
+    std::cout << "Salvium '" << MONERO_RELEASE_NAME << "' (v" << MONERO_VERSION_FULL << ")" << ENDL << ENDL;
    std::cout << desc_options << std::endl;
    return 1;
  }
@@ -674,7 +675,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("salvium-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
@@ -483,12 +483,12 @@ int main(int argc, char* argv[])

  if (command_line::get_arg(vm, command_line::arg_help))
  {
-    std::cout << "Fulmo '" << MONERO_RELEASE_NAME << "' (v" << MONERO_VERSION_FULL << ")" << ENDL << ENDL;
+    std::cout << "Salvium '" << 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("salvium-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
@@ -137,12 +137,12 @@ int main(int argc, char* argv[])

  if (command_line::get_arg(vm, command_line::arg_help))
  {
-    std::cout << "Fulmo '" << MONERO_RELEASE_NAME << "' (v" << MONERO_VERSION_FULL << ")" << ENDL << ENDL;
+    std::cout << "Salvium '" << 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("salvium-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
@@ -175,12 +175,12 @@ int main(int argc, char* argv[])

  if (command_line::get_arg(vm, command_line::arg_help))
  {
-    std::cout << "Fulmo '" << MONERO_RELEASE_NAME << "' (v" << MONERO_VERSION_FULL << ")" << ENDL << ENDL;
+    std::cout << "Salvium '" << 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("salvium-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
@@ -242,7 +242,7 @@ int main(int argc, char* argv[])
 /*
 * The default output can be plotted with GnuPlot using these commands:
 set key autotitle columnhead
-set title "Fulmo Blockchain Growth"
+set title "Salvium Blockchain Growth"
 set timefmt "%Y-%m-%d"
 set xdata time
 set xrange ["2014-04-17":*]
@@ -120,12 +120,12 @@ int main(int argc, char* argv[])

  if (command_line::get_arg(vm, command_line::arg_help))
  {
-    std::cout << "Fulmo '" << MONERO_RELEASE_NAME << "' (v" << MONERO_VERSION_FULL << ")" << ENDL << ENDL;
+    std::cout << "Salvium '" << 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("salvium-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
@@ -184,24 +184,72 @@ namespace cryptonote
  {
    if (nettype == TESTNET)
    {
-      /*
      ADD_CHECKPOINT2(0,     "48ca7cd3c8de5b6a4d53d2861fbdaedca141553559f9be9520068053cda8430b", "0x1");
      ADD_CHECKPOINT2(1000000, "46b690b710a07ea051bc4a6b6842ac37be691089c0f7758cfeec4d5fc0b4a258", "0x7aaad7153");
      ADD_CHECKPOINT2(1058600, "12904f6b4d9e60fd875674e07147d2c83d6716253f046af7b894c3e81da7e1bd", "0x971efd119");
      ADD_CHECKPOINT2(1450000, "87562ca6786f41556b8d5b48067303a57dc5ca77155b35199aedaeca1550f5a0", "0xa639e2930e");
-      */
      return true;
    }
    if (nettype == STAGENET)
    {
-      /*
      ADD_CHECKPOINT2(0,       "76ee3cc98646292206cd3e86f74d88b4dcc1d937088645e9b0cbca84b7ce74eb", "0x1");
      ADD_CHECKPOINT2(10000,   "1f8b0ce313f8b9ba9a46108bfd285c45ad7c2176871fd41c3a690d4830ce2fd5", "0x1d73ba");
      ADD_CHECKPOINT2(550000,  "409f68cddd8e74b37469b41c1e61250d81c5776b42264f416d5d27c4626383ed", "0x5f3d4d03e");
-      */
      return true;
    }
-    //ADD_CHECKPOINT2(0,        "f17c77c1d17cd0de699f4c86638e2878f3c70934659b92825bcabc6f792d5575", "0x1");
+    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(2985000, "08f5e6b7301c1b6ed88268a28f8677a06e8ff943b3f9e48d3080f71f9c134bfb", "0x444b7b42a633c96");
+    ADD_CHECKPOINT2(3088000, "bddf8ca09110d33d6d497f13a113630c2b6af1c84d4f3a6f35cb1446f2604ade", "0x4aed3615c2f8c3e");
+    ADD_CHECKPOINT2(3102800, "083f4a34f9490403b564286e7f13fd1ed45c52c86fa47195f151594e5bc87504", "0x4bbed52d4da5dfb");
    return true;
  }

--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Some Random Crypto Guy	e69437ca6a	added more secure verification of protocol_tx outputs; bumped version number	2024-06-07 17:02:13 +01:00
Neil Coggins	50075e04c3	fixed logging message for adding block to separate out the burnt reward from the block reward	2024-06-07 13:07:11 +01:00
Neil Coggins	7f3dba49a7	Merge branch 'rebase-v0.18.3.3' of https://github.com/somerandomcryptoguy/salvium into rebase-v0.18.3.3	2024-06-06 14:14:52 +01:00
Neil Coggins	9c098ae1fb	added support for auto-frozen incoming payments	2024-06-06 14:13:14 +01:00
Some Random Crypto Guy	078fa00bc5	bumped version number	2024-06-05 15:54:06 +01:00
Some Random Crypto Guy	9dc1c429f7	replaced the windows fixes back into the rebased code	2024-06-05 15:52:35 +01:00
Some Random Crypto Guy	8c5a1248b6	added missing files from v0.18.3.3 contrib area	2024-06-05 14:17:15 +01:00
Some Random Crypto Guy	d39c20bb2d	rebase to 0.18.3.3 completed	2024-06-05 14:03:44 +01:00
Some Random Crypto Guy	e23423c16d	partial fix to the detection of return payments - ECDH is an issue again, but reversion to using F point should resolve this and complete the implementation	2024-05-27 10:38:44 +01:00
ncoggins	42d8dc5ece	fixed output of show_transfers, including filtering by TX type; bumped version number	2024-05-20 20:57:10 +01:00
Some Random Crypto Guy	89d426a739	Merge branch 'updated_return_address' into develop	2024-05-20 10:33:48 +01:00
ncoggins	199e47e076	small fix to prevent wallets from abandoning scanning when encountering protocol_tx not intended for them - duh!	2024-05-20 09:28:44 +01:00
Some Random Crypto Guy	d24ed9e0cc	fixes to the CLI wallet output of staking and protocol_tx outputs	2024-05-18 13:51:10 +01:00
ncoggins	872303f6ad	fixed removal of m_locked_coins entries when PROTOCOL_TX pays out	2024-05-18 08:41:54 +01:00
Some Random Crypto Guy	c56cfc6754	added versioning to avoid inadvertent use of old nodes	2024-05-17 13:09:57 +01:00
Neil Coggins	de4e974e4c	resolved MacOS wallet build issues	2024-05-17 11:30:58 +01:00
Some Random Crypto Guy	4607939ab6	fixed unlock time info displayed for mined blocks; added tx_type to get_return_address() call - needed for F point on transfers; bumped version	2024-05-16 22:29:32 +01:00
Some Random Crypto Guy	9a37188885	fixed issue with Hardfork 2; removed PRs from HardFork 1 as unnecessary / slowing the chain down	2024-05-16 10:58:02 +01:00
Some Random Crypto Guy	aee0f479c1	changed NETWORK_ID and GENESIS_TX for new Salvium networks; fixed genesis_tx calculation for non-mainnet	2024-05-15 12:58:39 +01:00
Some Random Crypto Guy	9f5e18495b	fixed windows build issues	2024-05-14 20:58:18 +01:00
Some Random Crypto Guy	ae28c7a900	implementation of yield_info function	2024-05-14 14:23:31 +01:00
Some Random Crypto Guy	b0ce6d2969	resolved the yield calculation issue	2024-05-12 22:59:43 +01:00
Some Random Crypto Guy	34b2f9b315	commenced removal of pricing_record touchpoints for MVP release	2024-05-07 14:34:19 +01:00
Some Random Crypto Guy	7bafd2866c	a number of fixes; disabled return_payment as the functionality is changing to NOT require returning the same output	2024-03-27 14:50:31 +00:00
Some Random Crypto Guy	606580a173	Interim checkin This code contains working "return address" semantics for CONVERT and YIELD.	2024-02-16 11:02:11 +00:00
Some Random Crypto Guy	a3a7f686f3	Added functions to cache and manage yield calculations Removed "tx.amount_locked" field - "tx.amount_burnt" is technically correct for all cases. Removed invalid checkpoint data.	2024-01-30 14:22:46 +00:00
Some Random Crypto Guy	a0d2044b5d	fixed a bug with serialization of the pricing record when communicating between daemon and wallet for conversions	2024-01-17 14:54:41 +00:00
Some Random Crypto Guy	3a032c58a4	Fixed a number of issues with serialization of pricing_record entries.	2024-01-17 12:43:10 +00:00