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
178 changed files with 5229 additions and 3217 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,8 +36,8 @@
 #include "warnings.h"
 #include "misc_log_ex.h"

-#include <boost/lexical_cast.hpp>
 #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)
@@ -254,7 +254,7 @@ void BlockchainDB::add_transaction(const crypto::hash& blk_hash, const std::pair
  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::YIELD) {
+  if (tx.type == cryptonote::transaction_type::STAKE) {

    // We now need to insert a record into the "yield_tx_data" table to record the TX
    
@@ -357,7 +357,7 @@ uint64_t BlockchainDB::add_block( const std::pair<block, blobdata>& blck
      }

      // Is this a YIELD TX?
-      if (tx.first.type == cryptonote::transaction_type::YIELD) {
+      if (tx.first.type == cryptonote::transaction_type::STAKE) {
        yield_total += tx.first.amount_burnt;
      }
    }
@@ -462,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);
@@ -847,7 +847,7 @@ int BlockchainLMDB::get_yield_tx_info(const uint64_t height, std::vector<yield_t
  while (1)
  {
    int ret = mdb_cursor_get(m_cur_yield_txs, &k, &v, op);
-    op = MDB_NEXT;
+    op = MDB_NEXT_DUP;
    if (ret == MDB_NOTFOUND)
      break;
    if (ret)
@@ -894,7 +894,7 @@ void BlockchainLMDB::add_block(const block& blk, size_t block_weight, uint64_t l

  CURSOR(yield_blocks)
  yield_block_info ybi_matured, ybi_prev;
-  uint64_t yield_lock_period = cryptonote::get_config(nettype).YIELD_LOCK_PERIOD;
+  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);
@@ -1179,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::BURN || tx.type == cryptonote::transaction_type::CONVERT || tx.type == cryptonote::transaction_type::YIELD) {
+  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));
@@ -1232,7 +1232,7 @@ 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_info yield_data;
@@ -1249,9 +1249,28 @@ uint64_t BlockchainLMDB::add_transaction_data(const crypto::hash& blk_hash, cons
      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()  ));
  }
@@ -1381,7 +1400,7 @@ 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
    MDB_val_set(val_height, m_height);
    MDB_val v;
@@ -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; };
 };

 }
@@ -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` 
@@ -391,7 +391,7 @@ int main(int argc, char* argv[])
    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]." 
@@ -1224,7 +1224,7 @@ int main(int argc, char* argv[])
    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
@@ -93,7 +93,7 @@ int main(int argc, char* argv[])
    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
@@ -95,7 +95,7 @@ int main(int argc, char* argv[])
    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
@@ -675,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
@@ -488,7 +488,7 @@ int main(int argc, char* argv[])
    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
@@ -142,7 +142,7 @@ int main(int argc, char* argv[])
    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
@@ -180,7 +180,7 @@ int main(int argc, char* argv[])
    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
@@ -125,7 +125,7 @@ int main(int argc, char* argv[])
    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;
  }

@@ -122,7 +122,7 @@ public:
   * @brief Gets a DNS address from OpenAlias format
   *
   * If the address looks good, but contains one @ symbol, replace that with a .
-   * e.g. donate@salvium.network becomes donate.salvium.network
+   * e.g. donate@getmonero.org becomes donate.getmonero.org
   *
   * @param oa_addr  OpenAlias address
   *
@@ -62,7 +62,7 @@ namespace tools
    while (1)
    {
      t1 = epee::misc_utils::get_ns_count();
-      if (t1 - t0 > 1*1000000000) break; // work one second
+      if (t1 - t0 > 1*100000000) break; // work 0.1 seconds
    }

    uint64_t r1 = get_tick_count();
@@ -106,7 +106,7 @@ namespace tools
 #ifdef _WIN32
    static const char *extension = strncmp(buildtag.c_str(), "source", 6) ? (strncmp(buildtag.c_str(), "install-", 8) ? ".zip" : ".exe") : ".tar.bz2";
 #elif defined(__APPLE__)
-    static const char *extension = strncmp(software.c_str(), "monero-gui", 10) ? ".tar.bz2" : ".dmg";
+    static const char *extension = strncmp(software.c_str(), "salvium-gui", 10) ? ".tar.bz2" : ".dmg";
 #else
    static const char extension[] = ".tar.bz2";
 #endif
--- 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