fixed full reward zone buffer on fork transition to match between daemon and wallet

increased max TX size from HF2; bumped version number
added hard fork 2 for v0.6.0
2024-10-30 15:48:45 +00:00 · 2024-10-30 14:31:27 +00:00 · 2024-10-22 12:04:03 +01:00 · 2024-10-22 12:03:29 +01:00 · 2024-10-21 14:18:51 +01:00 · 2024-10-18 14:37:36 +01:00
238 changed files with 71760 additions and 280299 deletions
@@ -0,0 +1,127 @@
+name: ci/gh-actions/depends
+
+on:
+  push:
+    paths-ignore:
+      - 'docs/**'
+      - '**/README.md'
+  pull_request:
+    paths-ignore:
+      - 'docs/**'
+      - '**/README.md'
+
+env:
+  APT_SET_CONF: |
+        echo "Acquire::Retries \"3\";"         | sudo tee -a /etc/apt/apt.conf.d/80-custom
+        echo "Acquire::http::Timeout \"120\";" | sudo tee -a /etc/apt/apt.conf.d/80-custom
+        echo "Acquire::ftp::Timeout \"120\";"  | sudo tee -a /etc/apt/apt.conf.d/80-custom
+  CCACHE_SETTINGS: |
+        ccache --max-size=150M
+        ccache --set-config=compression=true
+  USE_DEVICE_TREZOR_MANDATORY: ON
+
+jobs:
+  build-cross:
+    runs-on: ubuntu-20.04
+    env:
+      CCACHE_TEMPDIR: /tmp/.ccache-temp
+    strategy:
+      fail-fast: false
+      matrix:
+        toolchain:
+          - name: "RISCV 64bit"
+            host: "riscv64-linux-gnu"
+            packages: "python3 gperf g++-riscv64-linux-gnu"
+          - name: "ARM v7"
+            host: "arm-linux-gnueabihf"
+            packages: "python3 gperf g++-arm-linux-gnueabihf"
+          - name: "ARM v8"
+            host: "aarch64-linux-gnu"
+            packages: "python3 gperf g++-aarch64-linux-gnu"
+          - name: "i686 Win"
+            host: "i686-w64-mingw32"
+            packages: "python3 g++-mingw-w64-i686"
+          - name: "i686 Linux"
+            host: "i686-pc-linux-gnu"
+            packages: "gperf cmake g++-multilib python3-zmq"
+          - name: "Win64"
+            host: "x86_64-w64-mingw32"
+            packages: "cmake python3 g++-mingw-w64-x86-64"
+          - name: "x86_64 Linux"
+            host: "x86_64-unknown-linux-gnu"
+            packages: "gperf cmake python3-zmq libdbus-1-dev libharfbuzz-dev"
+          - name: "Cross-Mac x86_64"
+            host: "x86_64-apple-darwin"
+            packages: "cmake imagemagick libcap-dev librsvg2-bin libz-dev libbz2-dev libtiff-tools python-dev python3-setuptools-git"
+          - name: "Cross-Mac aarch64"
+            host: "aarch64-apple-darwin"
+            packages: "cmake imagemagick libcap-dev librsvg2-bin libz-dev libbz2-dev libtiff-tools python-dev python3-setuptools-git"
+          - name: "x86_64 Freebsd"
+            host: "x86_64-unknown-freebsd"
+            packages: "clang-8 gperf cmake python3-zmq libdbus-1-dev libharfbuzz-dev"
+              #          - name: "ARMv8 Android"
+              #            host: "aarch64-linux-android"
+              #            packages: "gperf cmake python3"
+    name: ${{ matrix.toolchain.name }}
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        fetch-depth: 0
+        submodules: recursive
+# Most volatile cache
+    - name: ccache
+      uses: actions/cache@v4
+      with:
+        path: ~/.ccache
+        key: ccache-${{ matrix.toolchain.host }}-${{ github.sha }}
+        restore-keys: ccache-${{ matrix.toolchain.host }}-
+# Less volatile cache
+    - name: depends cache
+      uses: actions/cache@v4
+      with:
+        path: contrib/depends/built
+        key: depends-${{ matrix.toolchain.host }}-${{ hashFiles('contrib/depends/packages/*') }}
+        restore-keys: |
+          depends-${{ matrix.toolchain.host }}-${{ hashFiles('contrib/depends/packages/*') }}
+          depends-${{ matrix.toolchain.host }}-
+# Static cache
+    - name: OSX SDK cache
+      uses: actions/cache@v4
+      with:
+        path: contrib/depends/sdk-sources
+        key: sdk-${{ matrix.toolchain.host }}-${{ matrix.toolchain.osx_sdk }}
+        restore-keys: sdk-${{ matrix.toolchain.host }}-${{ matrix.toolchain.osx_sdk }}
+    - name: set apt conf
+      run: ${{env.APT_SET_CONF}}
+    - name: install dependencies
+      run: sudo apt update; sudo apt -y install build-essential libtool libssl-dev cmake autotools-dev automake pkg-config bsdmainutils curl git ca-certificates ccache ${{ matrix.toolchain.packages }}
+    - name: prepare w64-mingw32
+      if: ${{ matrix.toolchain.host == 'x86_64-w64-mingw32' || matrix.toolchain.host == 'i686-w64-mingw32' }}
+      run: |
+        sudo update-alternatives --set ${{ matrix.toolchain.host }}-g++ $(which ${{ matrix.toolchain.host }}-g++-posix)
+        sudo update-alternatives --set ${{ matrix.toolchain.host }}-gcc $(which ${{ matrix.toolchain.host }}-gcc-posix)
+    - name: build
+      run: |
+        ${{env.CCACHE_SETTINGS}}
+        make depends target=${{ matrix.toolchain.host }} -j2
+    - uses: actions/upload-artifact@v4
+      if: ${{ matrix.toolchain.host == 'x86_64-w64-mingw32' || matrix.toolchain.host == 'x86_64-apple-darwin' || matrix.toolchain.host == 'aarch64-apple-darwin' || matrix.toolchain.host == 'x86_64-unknown-linux-gnu' }}
+      with:
+        name: ${{ matrix.toolchain.name }}
+        path: |
+          /home/runner/work/${{ github.event.repository.name }}/${{ github.event.repository.name }}/build/${{ matrix.toolchain.host }}/release/bin/salvium-wallet-cli*
+          /home/runner/work/${{ github.event.repository.name }}/${{ github.event.repository.name }}/build/${{ matrix.toolchain.host }}/release/bin/salviumd*
+    - name: zip daemon & cli
+      run: |
+        zip salvium-${GITHUB_REF_NAME}-${{ matrix.toolchain.host }}.zip /home/runner/work/${{ github.event.repository.name }}/${{ github.event.repository.name }}/build/${{ matrix.toolchain.host }}/release/bin/salvium-wallet-rpc* /home/runner/work/${{ github.event.repository.name }}/${{ github.event.repository.name }}/build/${{ matrix.toolchain.host }}/release/bin/salvium-wallet-cli* /home/runner/work/${{ github.event.repository.name }}/${{ github.event.repository.name }}/build/${{ matrix.toolchain.host }}/release/bin/salviumd*
+        ls -l
+    - name: "Deploy"
+      uses: keithweaver/aws-s3-github-action@v1.0.0
+      with:
+        command: cp
+        source: ./salvium-${{ github.ref_name }}-${{ matrix.toolchain.host }}.zip
+        destination: s3://${{ vars.S3_BUCKET }}/salvium-${{ github.ref_name }}-${{ matrix.toolchain.host }}.zip
+        aws_access_key_id: ${{ secrets.AWS_ACCESS_KEY_ID }}
+        aws_secret_access_key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
+        aws_region: eu-west-1
+        flags: --acl public-read
@@ -1,4 +1,4 @@
-# Copyright (c) 2014-2022, The Monero Project
+# Copyright (c) 2014-2023, The Monero Project
 #
 # All rights reserved.
 #
@@ -28,6 +28,9 @@
 #
 # Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers

+cmake_minimum_required(VERSION 3.5)
+message(STATUS "CMake version ${CMAKE_VERSION}")
+
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)

 list(INSERT CMAKE_MODULE_PATH 0
@@ -37,15 +40,15 @@ include(CheckCXXCompilerFlag)
 include(CheckLinkerFlag)
 include(CheckLibraryExists)
 include(CheckFunctionExists)
+if (POLICY CMP0148)
+    cmake_policy(SET CMP0148 OLD) # https://cmake.org/cmake/help/latest/policy/CMP0148.html
+endif()
 include(FindPythonInterp)

 if (IOS)
    INCLUDE(CmakeLists_IOS.txt)
 endif()

-cmake_minimum_required(VERSION 3.5)
-message(STATUS "CMake version ${CMAKE_VERSION}")
-
 project(salvium)

 option (USE_CCACHE "Use ccache if a usable instance is found" ON)
@@ -96,7 +99,7 @@ enable_language(C ASM)
 set(CMAKE_C_STANDARD 11)
 set(CMAKE_C_STANDARD_REQUIRED ON)
 set(CMAKE_C_EXTENSIONS OFF)
-set(CMAKE_CXX_STANDARD 14)
+set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)

@@ -219,7 +222,7 @@ function(forbid_undefined_symbols)
    file(MAKE_DIRECTORY "${TEST_PROJECT}")
    file(WRITE "${TEST_PROJECT}/CMakeLists.txt"
      [=[
-cmake_minimum_required(VERSION 3.1)
+cmake_minimum_required(VERSION 3.5)
 project(test)
 option(EXPECT_SUCCESS "" ON)
 file(WRITE "${CMAKE_SOURCE_DIR}/incorrect_source.cpp" "void undefined_symbol(); void symbol() { undefined_symbol(); }")
@@ -412,7 +415,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,15 +452,12 @@ 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)
@@ -531,14 +531,14 @@ 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)
+if (APPLE OR NETBSD)
  set(DEFAULT_STACK_TRACE OFF)
  set(LIBUNWIND_LIBRARIES "")
 elseif (DEPENDS AND NOT LINUX)
  set(DEFAULT_STACK_TRACE OFF)
  set(LIBUNWIND_LIBRARIES "")
 elseif(CMAKE_C_COMPILER_ID STREQUAL "GNU" AND NOT MINGW)
-  set(DEFAULT_STACK_TRACE ON)
+  set(DEFAULT_STACK_TRACE OFF)
  set(STACK_TRACE_LIB "easylogging++") # for diag output only
  set(LIBUNWIND_LIBRARIES "")
 elseif (ARM)
@@ -547,7 +547,7 @@ elseif (ARM)
 else()
  find_package(Libunwind)
  if(LIBUNWIND_FOUND)
-    set(DEFAULT_STACK_TRACE ON)
+    set(DEFAULT_STACK_TRACE OFF)
    set(STACK_TRACE_LIB "libunwind") # for diag output only
  else()
    set(DEFAULT_STACK_TRACE OFF)
@@ -704,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 /FIinline_c.h /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 /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)
@@ -712,7 +712,6 @@ 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}")
@@ -789,7 +788,6 @@ 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")
@@ -1004,11 +1002,14 @@ else()

  if(APPLE)
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fvisibility=default -DGTEST_HAS_TR1_TUPLE=0")
+    if(ARM)
+      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-aligned-allocation")
+    endif()
  endif()

  set(DEBUG_FLAGS "-g3")

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

  if(NOT DEFINED USE_LTO_DEFAULT)
@@ -1075,8 +1076,14 @@ if(STATIC)
  set(Boost_USE_STATIC_LIBS ON)
  set(Boost_USE_STATIC_RUNTIME ON)
 endif()
-find_package(Boost 1.58 QUIET REQUIRED COMPONENTS system filesystem thread date_time chrono regex serialization program_options locale)
+
+set(BOOST_COMPONENTS system filesystem thread date_time chrono regex serialization program_options)
+if (WIN32)
+  list(APPEND BOOST_COMPONENTS locale)
+endif()
+find_package(Boost 1.58 QUIET REQUIRED COMPONENTS ${BOOST_COMPONENTS})
 add_definitions(-DBOOST_ASIO_ENABLE_SEQUENTIAL_STRAND_ALLOCATION)
+add_definitions(-DBOOST_NO_AUTO_PTR)

 set(CMAKE_FIND_LIBRARY_SUFFIXES ${OLD_LIB_SUFFIXES})
 if(NOT Boost_FOUND)
@@ -1100,9 +1107,7 @@ include_directories(SYSTEM ${Boost_INCLUDE_DIRS})
 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 icuio icui18n icuuc icudata icutu iconv)
-  else()
+  if(NOT DEPENDS)
    set(ICU_LIBRARIES icuio icuin icuuc icudt icutu iconv)
  endif()
 elseif(APPLE OR OPENBSD OR ANDROID)
@@ -1116,7 +1121,8 @@ elseif(CMAKE_SYSTEM_NAME MATCHES "(SunOS|Solaris)")
  set(EXTRA_LIBRARIES socket nsl resolv)
 elseif(NOT MSVC AND NOT DEPENDS)
  find_library(RT rt)
-  set(EXTRA_LIBRARIES ${RT})
+  find_library(Z z)
+  set(EXTRA_LIBRARIES ${RT} ${Z})
 endif()

 list(APPEND EXTRA_LIBRARIES ${CMAKE_DL_LIBS})
@@ -1124,7 +1130,7 @@ list(APPEND EXTRA_LIBRARIES ${CMAKE_DL_LIBS})
 if (HIDAPI_FOUND OR LibUSB_COMPILE_TEST_PASSED)
  if (APPLE)
    if(DEPENDS)
-      list(APPEND EXTRA_LIBRARIES "-framework Foundation -framework AppKit -framework IOKit")
+      list(APPEND EXTRA_LIBRARIES "-framework Foundation -framework AppKit -framework IOKit -framework Security")
    else()
      find_library(COREFOUNDATION CoreFoundation)
      find_library(APPKIT AppKit)
@@ -1139,7 +1145,9 @@ if (HIDAPI_FOUND OR LibUSB_COMPILE_TEST_PASSED)
  endif()
 endif()

-option(USE_READLINE "Build with GNU readline support." ON)
+if(NOT OPENBSD)
+  option(USE_READLINE "Build with GNU readline support." ON)
+endif()
 if(USE_READLINE AND NOT DEPENDS)
  find_package(Readline)
  if(READLINE_FOUND AND GNU_READLINE_FOUND)
@@ -1171,13 +1179,17 @@ if(CMAKE_C_COMPILER_ID MATCHES "Clang" AND ARCH_WIDTH EQUAL "32" AND NOT IOS AND
  endif()
 endif()

+if(STATIC)
+  set(sodium_USE_STATIC_LIBS ON)
+endif()
+find_package(Sodium REQUIRED)
+
 find_path(ZMQ_INCLUDE_PATH zmq.h)
 find_library(ZMQ_LIB zmq)
 find_library(PGM_LIBRARY pgm)
 find_library(NORM_LIBRARY norm)
 find_library(GSSAPI_LIBRARY gssapi_krb5)
 find_library(PROTOLIB_LIBRARY protolib)
-find_library(SODIUM_LIBRARY sodium)
 find_library(BSD_LIBRARY bsd)
 find_library(MD_LIBRARY md)
 find_library(PROTOKIT_LIBRARY protokit)
@@ -1200,8 +1212,8 @@ endif()
 if(PROTOLIB_LIBRARY)
  set(ZMQ_LIB "${ZMQ_LIB};${PROTOLIB_LIBRARY}")
 endif()
-if(SODIUM_LIBRARY)
-  set(ZMQ_LIB "${ZMQ_LIB};${SODIUM_LIBRARY}")
+if(Sodium_FOUND)
+  set(ZMQ_LIB "${ZMQ_LIB};${sodium_LIBRARIES}")
 endif()
 if(BSD_LIBRARY)
  set(ZMQ_LIB "${ZMQ_LIB};${BSD_LIBRARY}")
@@ -41,26 +41,26 @@ RUN set -ex && \
    rm -rf /var/lib/apt
 COPY --from=builder /src/build/x86_64-linux-gnu/release/bin /usr/local/bin/

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

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

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

-EXPOSE 18080
-EXPOSE 18081
+EXPOSE 19080
+EXPOSE 19081

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

-ENTRYPOINT ["monerod"]
-CMD ["--p2p-bind-ip=0.0.0.0", "--p2p-bind-port=18080", "--rpc-bind-ip=0.0.0.0", "--rpc-bind-port=18081", "--non-interactive", "--confirm-external-bind"]
+ENTRYPOINT ["salviumd"]
+CMD ["--p2p-bind-ip=0.0.0.0", "--p2p-bind-port=19080", "--rpc-bind-ip=0.0.0.0", "--rpc-bind-port=19081", "--non-interactive", "--confirm-external-bind"]

@@ -48,7 +48,7 @@ all: release-all

 depends:
 	cd contrib/depends && $(MAKE) HOST=$(target) && cd ../.. && mkdir -p build/$(target)/release
-	cd build/$(target)/release && cmake -DCMAKE_TOOLCHAIN_FILE=$(CURDIR)/contrib/depends/$(target)/share/toolchain.cmake ../../.. && $(MAKE)
+	cd build/$(target)/release && USE_DEVICE_TREZOR_MANDATORY=1 cmake -DCMAKE_TOOLCHAIN_FILE=$(CURDIR)/contrib/depends/$(target)/share/toolchain.cmake ../../.. && $(MAKE)

 cmake-debug:
 	mkdir -p $(builddir)/debug
@@ -104,7 +104,7 @@ release-all:

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

 coverage:
 	mkdir -p $(builddir)/debug
@@ -1 +1,647 @@
-# Welcome to Salvium
+# Salvium Zero v0.6.1
+
+Copyright (c) 2023-2024, Salvium
+Portions Copyright (c) 2014-2023, The Monero Project
+Portions Copyright (c) 2012-2013 The Cryptonote developers.
+
+## Table of Contents
+
+  - [Development resources](#development-resources)
+  - [Introduction](#introduction)
+  - [About this project](#about-this-project)
+  - [Supporting the project](#supporting-the-project)
+  - [License](#license)
+  - [Contributing](#contributing)
+  - [Compiling Salvium from source](#compiling-salvium-from-source)
+    - [Dependencies](#dependencies)
+    - [Gitian builds](#gitian-builds)
+  - [Internationalization](#Internationalization)
+  - [Debugging](#Debugging)
+  - [Known issues](#known-issues)
+
+## Development resources
+
+- Web: [salvium.io](https://salvium.io)
+- Mail: [dev@salvium.io](mailto:dev@salvium.io)
+- GitHub: [https://github.com/salvium/salvium](https://github.com/salvium/salvium)
+
+## Introduction
+
+Salvium is a private, secure, untraceable, decentralised digital currency. You are your bank, you control your funds, and nobody can trace your transfers unless you allow them to do so.
+
+**Privacy:** Salvium uses a cryptographically sound system to allow you to send and receive funds without your transactions being easily revealed on the blockchain (the ledger of transactions that everyone has). This ensures that your purchases, receipts, and all transfers remain private by default.
+
+**Security:** Using the power of a distributed peer-to-peer consensus network, every transaction on the network is cryptographically secured. Individual wallets have a 25-word mnemonic seed that is only displayed once and can be written down to backup the wallet. Wallet files should be encrypted with a strong passphrase to ensure they are useless if ever stolen.
+
+**Untraceability:** By taking advantage of ring signatures, a special property of a certain type of cryptography, Salvium is able to ensure that transactions are not only untraceable but have an optional measure of ambiguity that ensures that transactions cannot easily be tied back to an individual user or computer.
+
+**Decentralization:** The utility of Salvium depends on its decentralised peer-to-peer consensus network - anyone should be able to run the salvium software, validate the integrity of the blockchain, and participate in all aspects of the salvium network using consumer-grade commodity hardware. Decentralization of the salvium network is maintained by software development that minimizes the costs of running the salvium software and inhibits the proliferation of specialized, non-commodity hardware.
+
+## About this project
+
+This is the core implementation of Salvium. It is open source and completely free to use without restrictions, except for those specified in the license agreement below. There are no restrictions on anyone creating an alternative implementation of Salvium that uses the protocol and network in a compatible manner.
+
+As with many development projects, the repository on GitHub is considered to be the "staging" area for the latest changes. Before changes are merged into that branch on the main repository, they are tested by individual developers in their own branches, submitted as a pull request, and then subsequently tested by contributors who focus on testing and code reviews. That having been said, the repository should be carefully considered before using it in a production environment, unless there is a patch in the repository for a particular show-stopping issue you are experiencing. It is generally a better idea to use a tagged release for stability.
+
+**Anyone is welcome to contribute to Salvium's codebase!** If you have a fix or code change, feel free to submit it as a pull request directly to the "master" branch. In cases where the change is relatively small or does not affect other parts of the codebase, it may be merged in immediately by any one of the collaborators. On the other hand, if the change is particularly large or complex, it is expected that it will be discussed at length either well in advance of the pull request being submitted, or even directly on the pull request.
+
+## Supporting the project
+
+Salvium is a 100% community-sponsored endeavor. If you want to join our efforts, the easiest thing you can do is support the project financially. Go to [https://salvium.io/donate/](https://salvium.io/donate/) for more information.
+
+## License
+
+See [LICENSE](LICENSE).
+
+## Contributing
+
+If you want to help out, see [CONTRIBUTING](docs/CONTRIBUTING.md) for a set of guidelines.
+
+## Compiling Salvium from source
+
+### Dependencies
+
+The following table summarizes the tools and libraries required to build. A
+few of the libraries are also included in this repository (marked as
+"Vendored"). By default, the build uses the library installed on the system
+and ignores the vendored sources. However, if no library is found installed on
+the system, then the vendored source will be built and used. The vendored
+sources are also used for statically-linked builds because distribution
+packages often include only shared library binaries (`.so`) but not static
+library archives (`.a`).
+
+| Dep          | Min. version  | Vendored | Debian/Ubuntu pkg    | Arch pkg     | Void pkg           | Fedora pkg          | Optional | Purpose         |
+| ------------ | ------------- | -------- | -------------------- | ------------ | ------------------ | ------------------- | -------- | --------------- |
+| GCC          | 7             | NO       | `build-essential`    | `base-devel` | `base-devel`       | `gcc`               | NO       |                 |
+| CMake        | 3.5           | NO       | `cmake`              | `cmake`      | `cmake`            | `cmake`             | NO       |                 |
+| pkg-config   | any           | NO       | `pkg-config`         | `base-devel` | `base-devel`       | `pkgconf`           | NO       |                 |
+| Boost        | 1.58          | NO       | `libboost-all-dev`   | `boost`      | `boost-devel`      | `boost-devel`       | NO       | C++ libraries   |
+| OpenSSL      | basically any | NO       | `libssl-dev`         | `openssl`    | `openssl-devel`    | `openssl-devel`     | NO       | sha256 sum      |
+| libzmq       | 4.2.0         | NO       | `libzmq3-dev`        | `zeromq`     | `zeromq-devel`     | `zeromq-devel`      | NO       | ZeroMQ library  |
+| OpenPGM      | ?             | NO       | `libpgm-dev`         | `libpgm`     |                    | `openpgm-devel`     | NO       | For ZeroMQ      |
+| libnorm[2]   | ?             | NO       | `libnorm-dev`        |              |                    |                     | YES      | For ZeroMQ      |
+| libunbound   | 1.4.16        | NO       | `libunbound-dev`     | `unbound`    | `unbound-devel`    | `unbound-devel`     | NO       | DNS resolver    |
+| libsodium    | ?             | NO       | `libsodium-dev`      | `libsodium`  | `libsodium-devel`  | `libsodium-devel`   | NO       | cryptography    |
+| libunwind    | any           | NO       | `libunwind8-dev`     | `libunwind`  | `libunwind-devel`  | `libunwind-devel`   | YES      | Stack traces    |
+| liblzma      | any           | NO       | `liblzma-dev`        | `xz`         | `liblzma-devel`    | `xz-devel`          | YES      | For libunwind   |
+| libreadline  | 6.3.0         | NO       | `libreadline6-dev`   | `readline`   | `readline-devel`   | `readline-devel`    | YES      | Input editing   |
+| expat        | 1.1           | NO       | `libexpat1-dev`      | `expat`      | `expat-devel`      | `expat-devel`       | YES      | XML parsing     |
+| GTest        | 1.5           | YES      | `libgtest-dev`[1]    | `gtest`      | `gtest-devel`      | `gtest-devel`       | YES      | Test suite      |
+| ccache       | any           | NO       | `ccache`             | `ccache`     | `ccache`           | `ccache`            | YES      | Compil. cache   |
+| Doxygen      | any           | NO       | `doxygen`            | `doxygen`    | `doxygen`          | `doxygen`           | YES      | Documentation   |
+| Graphviz     | any           | NO       | `graphviz`           | `graphviz`   | `graphviz`         | `graphviz`          | YES      | Documentation   |
+| lrelease     | ?             | NO       | `qttools5-dev-tools` | `qt5-tools`  | `qt5-tools`        | `qt5-linguist`      | YES      | Translations    |
+| libhidapi    | ?             | NO       | `libhidapi-dev`      | `hidapi`     | `hidapi-devel`     | `hidapi-devel`      | YES      | Hardware wallet |
+| libusb       | ?             | NO       | `libusb-1.0-0-dev`   | `libusb`     | `libusb-devel`     | `libusbx-devel`     | YES      | Hardware wallet |
+| libprotobuf  | ?             | NO       | `libprotobuf-dev`    | `protobuf`   | `protobuf-devel`   | `protobuf-devel`    | YES      | Hardware wallet |
+| protoc       | ?             | NO       | `protobuf-compiler`  | `protobuf`   | `protobuf`         | `protobuf-compiler` | YES      | Hardware wallet |
+| libudev      | ?             | NO       | `libudev-dev`        | `systemd`    | `eudev-libudev-devel` | `systemd-devel`  | YES      | Hardware wallet |
+
+[1] On Debian/Ubuntu `libgtest-dev` only includes sources and headers. You must
+build the library binary manually. This can be done with the following command `sudo apt-get install libgtest-dev && cd /usr/src/gtest && sudo cmake . && sudo make`
+then:
+
+* on Debian:
+  `sudo mv libg* /usr/lib/`
+* on Ubuntu:
+  `sudo mv lib/libg* /usr/lib/`
+
+[2] libnorm-dev is needed if your zmq library was built with libnorm, and not needed otherwise
+
+Install all dependencies at once on Debian/Ubuntu:
+
+```
+sudo apt update && sudo apt install build-essential cmake pkg-config libssl-dev libzmq3-dev libunbound-dev libsodium-dev libunwind8-dev liblzma-dev libreadline6-dev libexpat1-dev libpgm-dev qttools5-dev-tools libhidapi-dev libusb-1.0-0-dev libprotobuf-dev protobuf-compiler libudev-dev libboost-chrono-dev libboost-date-time-dev libboost-filesystem-dev libboost-locale-dev libboost-program-options-dev libboost-regex-dev libboost-serialization-dev libboost-system-dev libboost-thread-dev python3 ccache doxygen graphviz
+```
+
+Install all dependencies at once on Arch:
+```
+sudo pacman -Syu --needed base-devel cmake boost openssl zeromq libpgm unbound libsodium libunwind xz readline expat gtest python3 ccache doxygen graphviz qt5-tools hidapi libusb protobuf systemd
+```
+
+Install all dependencies at once on Fedora:
+```
+sudo dnf install gcc gcc-c++ cmake pkgconf boost-devel openssl-devel zeromq-devel openpgm-devel unbound-devel libsodium-devel libunwind-devel xz-devel readline-devel expat-devel gtest-devel ccache doxygen graphviz qt5-linguist hidapi-devel libusbx-devel protobuf-devel protobuf-compiler systemd-devel
+```
+
+Install all dependencies at once on openSUSE:
+
+```
+sudo zypper ref && sudo zypper in cppzmq-devel libboost_chrono-devel libboost_date_time-devel libboost_filesystem-devel libboost_locale-devel libboost_program_options-devel libboost_regex-devel libboost_serialization-devel libboost_system-devel libboost_thread-devel libexpat-devel libminiupnpc-devel libsodium-devel libunwind-devel unbound-devel cmake doxygen ccache fdupes gcc-c++ libevent-devel libopenssl-devel pkgconf-pkg-config readline-devel xz-devel libqt5-qttools-devel patterns-devel-C-C++-devel_C_C++
+```
+
+Install all dependencies at once on macOS with the provided Brewfile:
+
+```
+brew update && brew bundle --file=contrib/brew/Brewfile
+```
+
+FreeBSD 12.1 one-liner required to build dependencies:
+
+```
+pkg install git gmake cmake pkgconf boost-libs libzmq4 libsodium unbound
+```
+
+### Cloning the repository
+
+Clone recursively to pull-in needed submodule(s):
+
+```
+git clone --recursive https://github.com/salvium/salvium
+```
+
+If you already have a repo cloned, initialize and update:
+
+```
+cd salvium && git submodule init && git submodule update
+```
+
+*Note*: If there are submodule differences between branches, you may need 
+to use `git submodule sync && git submodule update` after changing branches
+to build successfully.
+
+### Build instructions
+
+Salvium uses the CMake build system and a top-level [Makefile](Makefile) that
+invokes cmake commands as needed.
+
+#### On Linux and macOS
+
+* Install the dependencies
+* Change to the root of the source code directory, change to the most recent release branch, and build:
+
+    ```bash
+    cd salvium
+    git checkout release-v0.18
+    make
+    ```
+
+    *Optional*: If your machine has several cores and enough memory, enable
+    parallel build by running `make -j<number of threads>` instead of `make`. For
+    this to be worthwhile, the machine should have one core and about 2GB of RAM
+    available per thread.
+
+    *Note*: The instructions above will compile the most stable release of the
+    Salvium software. If you would like to use and test the most recent software,
+    use `git checkout master`. The master branch may contain updates that are
+    both unstable and incompatible with release software, though testing is always
+    encouraged.
+
+* The resulting executables can be found in `build/release/bin`
+
+* Add `PATH="$PATH:$HOME/salvium/build/release/bin"` to `.profile`
+
+* Run Salvium with `salviumd --detach`
+
+* **Optional**: build and run the test suite to verify the binaries:
+
+    ```bash
+    make release-test
+    ```
+
+    *NOTE*: `core_tests` test may take a few hours to complete.
+
+* **Optional**: to build binaries suitable for debugging:
+
+    ```bash
+    make debug
+    ```
+
+* **Optional**: to build statically-linked binaries:
+
+    ```bash
+    make release-static
+    ```
+
+Dependencies need to be built with -fPIC. Static libraries usually aren't, so you may have to build them yourself with -fPIC. Refer to their documentation for how to build them.
+
+* **Optional**: build documentation in `doc/html` (omit `HAVE_DOT=YES` if `graphviz` is not installed):
+
+    ```bash
+    HAVE_DOT=YES doxygen Doxyfile
+    ```
+
+* **Optional**: use ccache not to rebuild translation units, that haven't really changed. Salvium's CMakeLists.txt file automatically handles it
+
+    ```bash
+    sudo apt install ccache
+    ```
+
+#### On the Raspberry Pi
+
+Tested on a Raspberry Pi Zero with a clean install of minimal Raspbian Stretch (2017-09-07 or later) from https://www.raspberrypi.org/downloads/raspbian/. If you are using Raspian Jessie, [please see note in the following section](#note-for-raspbian-jessie-users).
+
+* `apt-get update && apt-get upgrade` to install all of the latest software
+
+* Install the dependencies for Salvium from the 'Debian' column in the table above.
+
+* Increase the system swap size:
+
+    ```bash
+    sudo /etc/init.d/dphys-swapfile stop  
+    sudo nano /etc/dphys-swapfile  
+    CONF_SWAPSIZE=2048
+    sudo /etc/init.d/dphys-swapfile start
+    ```
+
+* If using an external hard disk without an external power supply, ensure it gets enough power to avoid hardware issues when syncing, by adding the line "max_usb_current=1" to /boot/config.txt
+
+* Clone Salvium and checkout the most recent release version:
+
+    ```bash
+    git clone https://github.com/salvium/salvium
+    cd salvium
+    git checkout v0.6.1
+    ```
+
+* Build:
+
+    ```bash
+    USE_SINGLE_BUILDDIR=1 make release
+    ```
+
+* Wait 4-6 hours
+
+* The resulting executables can be found in `build/release/bin`
+
+* Add `export PATH="$PATH:$HOME/salvium/build/release/bin"` to `$HOME/.profile`
+
+* Run `source $HOME/.profile`
+
+* Run Salvium with `salviumd --detach`
+
+* You may wish to reduce the size of the swap file after the build has finished, and delete the boost directory from your home directory
+
+#### *Note for Raspbian Jessie users:*
+
+If you are using the older Raspbian Jessie image, compiling Salvium is a bit more complicated. The version of Boost available in the Debian Jessie repositories is too old to use with Salvium, and thus you must compile a newer version yourself. The following explains the extra steps and has been tested on a Raspberry Pi 2 with a clean install of minimal Raspbian Jessie.
+
+* As before, `apt-get update && apt-get upgrade` to install all of the latest software, and increase the system swap size
+
+    ```bash
+    sudo /etc/init.d/dphys-swapfile stop
+    sudo nano /etc/dphys-swapfile
+    CONF_SWAPSIZE=2048
+    sudo /etc/init.d/dphys-swapfile start
+    ```
+
+
+* Then, install the dependencies for Salvium except for `libunwind` and `libboost-all-dev`
+
+* Install the latest version of boost (this may first require invoking `apt-get remove --purge libboost*-dev` to remove a previous version if you're not using a clean install):
+
+    ```bash
+    cd
+    wget https://sourceforge.net/projects/boost/files/boost/1.72.0/boost_1_72_0.tar.bz2
+    tar xvfo boost_1_72_0.tar.bz2
+    cd boost_1_72_0
+    ./bootstrap.sh
+    sudo ./b2
+    ```
+
+* Wait ~8 hours
+
+    ```bash    
+    sudo ./bjam cxxflags=-fPIC cflags=-fPIC -a install
+    ```
+
+* Wait ~4 hours
+
+* From here, follow the [general Raspberry Pi instructions](#on-the-raspberry-pi) from the "Clone Salvium and checkout most recent release version" step.
+
+#### On Windows:
+
+Binaries for Windows are built on Windows using the MinGW toolchain within
+[MSYS2 environment](https://www.msys2.org). The MSYS2 environment emulates a
+POSIX system. The toolchain runs within the environment and *cross-compiles*
+binaries that can run outside of the environment as a regular Windows
+application.
+
+**Preparing the build environment**
+
+* Download and install the [MSYS2 installer](https://www.msys2.org), either the 64-bit or the 32-bit package, depending on your system.
+* Open the MSYS shell via the `MSYS2 Shell` shortcut
+* Update packages using pacman:
+
+    ```bash
+    pacman -Syu
+    ```
+
+* Exit the MSYS shell using Alt+F4
+* Edit the properties for the `MSYS2 Shell` shortcut changing "msys2_shell.bat" to "msys2_shell.cmd -mingw64" for 64-bit builds or "msys2_shell.cmd -mingw32" for 32-bit builds
+* Restart MSYS shell via modified shortcut and update packages again using pacman:
+
+    ```bash
+    pacman -Syu
+    ```
+
+
+* Install dependencies:
+
+    To build for 64-bit Windows:
+
+    ```bash
+    pacman -S mingw-w64-x86_64-toolchain make mingw-w64-x86_64-cmake mingw-w64-x86_64-boost mingw-w64-x86_64-openssl mingw-w64-x86_64-zeromq mingw-w64-x86_64-libsodium mingw-w64-x86_64-hidapi mingw-w64-x86_64-unbound
+    ```
+
+    To build for 32-bit Windows:
+
+    ```bash
+    pacman -S mingw-w64-i686-toolchain make mingw-w64-i686-cmake mingw-w64-i686-boost mingw-w64-i686-openssl mingw-w64-i686-zeromq mingw-w64-i686-libsodium mingw-w64-i686-hidapi mingw-w64-i686-unbound
+    ```
+
+* Open the MingW shell via `MinGW-w64-Win64 Shell` shortcut on 64-bit Windows
+  or `MinGW-w64-Win64 Shell` shortcut on 32-bit Windows. Note that if you are
+  running 64-bit Windows, you will have both 64-bit and 32-bit MinGW shells.
+
+**Cloning**
+
+* To git clone, run:
+
+    ```bash
+    git clone --recursive https://github.com/salvium/salvium
+    ```
+
+**Building**
+
+* Change to the cloned directory, run:
+
+    ```bash
+    cd salvium
+    ```
+
+* If you would like a specific [version/tag](https://github.com/salvium/salvium/tags), do a git checkout for that version. eg. 'v0.6.1'. If you don't care about the version and just want binaries from master, skip this step:
+
+    ```bash
+    git checkout v0.6.1
+    ```
+
+* If you are on a 64-bit system, run:
+
+    ```bash
+    make release-static-win64
+    ```
+
+* If you are on a 32-bit system, run:
+
+    ```bash
+    make release-static-win32
+    ```
+
+* The resulting executables can be found in `build/release/bin`
+
+* **Optional**: to build Windows binaries suitable for debugging on a 64-bit system, run:
+
+    ```bash
+    make debug-static-win64
+    ```
+
+* **Optional**: to build Windows binaries suitable for debugging on a 32-bit system, run:
+
+    ```bash
+    make debug-static-win32
+    ```
+
+* The resulting executables can be found in `build/debug/bin`
+
+### On FreeBSD:
+
+The project can be built from scratch by following instructions for Linux above(but use `gmake` instead of `make`). 
+If you are running Salvium in a jail, you need to add `sysvsem="new"` to your jail configuration, otherwise lmdb will throw the error message: `Failed to open lmdb environment: Function not implemented`.
+
+### On OpenBSD:
+
+You will need to add a few packages to your system. `pkg_add cmake gmake zeromq libiconv boost libunbound`.
+
+The `doxygen` and `graphviz` packages are optional and require the xbase set.
+Running the test suite also requires `py3-requests` package.
+
+Build salvium: `gmake`
+
+Note: you may encounter the following error when compiling the latest version of Salvium as a normal user:
+
+```
+LLVM ERROR: out of memory
+c++: error: unable to execute command: Abort trap (core dumped)
+```
+
+Then you need to increase the data ulimit size to 2GB and try again: `ulimit -d 2000000`
+
+### On NetBSD:
+
+Check that the dependencies are present: `pkg_info -c libexecinfo boost-headers boost-libs protobuf readline libusb1 zeromq git-base pkgconf gmake cmake | more`, and install any that are reported missing, using `pkg_add` or from your pkgsrc tree.  Readline is optional but worth having.
+
+Third-party dependencies are usually under `/usr/pkg/`, but if you have a custom setup, adjust the "/usr/pkg" (below) accordingly.
+
+Clone the salvium repository recursively and checkout the most recent release as described above. Then build salvium: `gmake BOOST_ROOT=/usr/pkg LDFLAGS="-Wl,-R/usr/pkg/lib" release`.  The resulting executables can be found in `build/NetBSD/[Release version]/Release/bin/`.
+
+### On Solaris:
+
+The default Solaris linker can't be used, you have to install GNU ld, then run cmake manually with the path to your copy of GNU ld:
+
+```bash
+mkdir -p build/release
+cd build/release
+cmake -DCMAKE_LINKER=/path/to/ld -D CMAKE_BUILD_TYPE=Release ../..
+cd ../..
+```
+
+Then you can run make as usual.
+
+### Building portable statically linked binaries
+
+By default, in either dynamically or statically linked builds, binaries target the specific host processor on which the build happens and are not portable to other processors. Portable binaries can be built using the following targets:
+
+* ```make release-static-linux-x86_64``` builds binaries on Linux on x86_64 portable across POSIX systems on x86_64 processors
+* ```make release-static-linux-i686``` builds binaries on Linux on x86_64 or i686 portable across POSIX systems on i686 processors
+* ```make release-static-linux-armv8``` builds binaries on Linux portable across POSIX systems on armv8 processors
+* ```make release-static-linux-armv7``` builds binaries on Linux portable across POSIX systems on armv7 processors
+* ```make release-static-linux-armv6``` builds binaries on Linux portable across POSIX systems on armv6 processors
+* ```make release-static-win64``` builds binaries on 64-bit Windows portable across 64-bit Windows systems
+* ```make release-static-win32``` builds binaries on 64-bit or 32-bit Windows portable across 32-bit Windows systems
+
+### Cross Compiling
+
+You can also cross-compile static binaries on Linux for Windows and macOS with the `depends` system.
+
+* ```make depends target=x86_64-linux-gnu``` for 64-bit linux binaries.
+* ```make depends target=x86_64-w64-mingw32``` for 64-bit windows binaries.
+  * Requires: `python3 g++-mingw-w64-x86-64 wine1.6 bc`
+  * You also need to run:  
+```update-alternatives --set x86_64-w64-mingw32-g++ x86_64-w64-mingw32-g++-posix && update-alternatives --set x86_64-w64-mingw32-gcc x86_64-w64-mingw32-gcc-posix```
+* ```make depends target=x86_64-apple-darwin``` for macOS binaries.
+  * Requires: `cmake imagemagick libcap-dev librsvg2-bin libz-dev libbz2-dev libtiff-tools python-dev`
+* ```make depends target=i686-linux-gnu``` for 32-bit linux binaries.
+  * Requires: `g++-multilib bc`
+* ```make depends target=i686-w64-mingw32``` for 32-bit windows binaries.
+  * Requires: `python3 g++-mingw-w64-i686`
+* ```make depends target=arm-linux-gnueabihf``` for armv7 binaries.
+  * Requires: `g++-arm-linux-gnueabihf`
+* ```make depends target=aarch64-linux-gnu``` for armv8 binaries.
+  * Requires: `g++-aarch64-linux-gnu`
+* ```make depends target=riscv64-linux-gnu``` for RISC V 64 bit binaries.
+  * Requires: `g++-riscv64-linux-gnu`
+* ```make depends target=x86_64-unknown-freebsd``` for freebsd binaries.
+  * Requires: `clang-8`
+* ```make depends target=arm-linux-android``` for 32bit android binaries
+* ```make depends target=aarch64-linux-android``` for 64bit android binaries
+
+
+The required packages are the names for each toolchain on apt. Depending on your distro, they may have different names. The `depends` system has been tested on Ubuntu 18.04 and 20.04.
+
+Using `depends` might also be easier to compile Salvium on Windows than using MSYS. Activate Windows Subsystem for Linux (WSL) with a distro (for example Ubuntu), install the apt build-essentials and follow the `depends` steps as depicted above.
+
+The produced binaries still link libc dynamically. If the binary is compiled on a current distribution, it might not run on an older distribution with an older installation of libc. Passing `-DBACKCOMPAT=ON` to cmake will make sure that the binary will run on systems having at least libc version 2.17.
+
+### Trezor hardware wallet support
+
+If you have an issue with building Salvium with Trezor support, you can disable it by setting `USE_DEVICE_TREZOR=OFF`, e.g., 
+
+```bash
+USE_DEVICE_TREZOR=OFF make release
+```
+
+For more information, please check out Trezor [src/device_trezor/README.md](src/device_trezor/README.md).
+
+### Gitian builds
+
+See [contrib/gitian/README.md](contrib/gitian/README.md).
+
+## Running salviumd
+
+The build places the binary in `bin/` sub-directory within the build directory
+from which cmake was invoked (repository root by default). To run in the
+foreground:
+
+```bash
+./bin/salviumd
+```
+
+To list all available options, run `./bin/salviumd --help`.  Options can be
+specified either on the command line or in a configuration file passed by the
+`--config-file` argument.  To specify an option in the configuration file, add
+a line with the syntax `argumentname=value`, where `argumentname` is the name
+of the argument without the leading dashes, for example, `log-level=1`.
+
+To run in background:
+
+```bash
+./bin/salviumd --log-file salviumd.log --detach
+```
+
+To run as a systemd service, copy
+[salviumd.service](utils/systemd/salviumd.service) to `/etc/systemd/system/` and
+[salviumd.conf](utils/conf/salviumd.conf) to `/etc/`. The [example
+service](utils/systemd/salviumd.service) assumes that the user `salvium` exists
+and its home is the data directory specified in the [example
+config](utils/conf/salviumd.conf).
+
+If you're on Mac, you may need to add the `--max-concurrency 1` option to
+salvium-wallet-cli, and possibly salviumd, if you get crashes refreshing.
+
+## Internationalization
+
+See [README.i18n.md](docs/README.i18n.md).
+
+## Debugging
+
+This section contains general instructions for debugging failed installs or problems encountered with Salvium. First, ensure you are running the latest version built from the GitHub repo.
+
+### Obtaining stack traces and core dumps on Unix systems
+
+We generally use the tool `gdb` (GNU debugger) to provide stack trace functionality, and `ulimit` to provide core dumps in builds which crash or segfault.
+
+* To use `gdb` in order to obtain a stack trace for a build that has stalled:
+
+Run the build.
+
+Once it stalls, enter the following command:
+
+```bash
+gdb /path/to/salviumd `pidof salviumd`
+```
+
+Type `thread apply all bt` within gdb in order to obtain the stack trace
+
+* If however the core dumps or segfaults:
+
+Enter `ulimit -c unlimited` on the command line to enable unlimited filesizes for core dumps
+
+Enter `echo core | sudo tee /proc/sys/kernel/core_pattern` to stop cores from being hijacked by other tools
+
+Run the build.
+
+When it terminates with an output along the lines of "Segmentation fault (core dumped)", there should be a core dump file in the same directory as salviumd. It may be named just `core`, or `core.xxxx` with numbers appended.
+
+You can now analyse this core dump with `gdb` as follows:
+
+```bash
+gdb /path/to/salviumd /path/to/dumpfile`
+```
+
+Print the stack trace with `bt`
+
+ * If a program crashed and cores are managed by systemd, the following can also get a stack trace for that crash:
+
+```bash
+coredumpctl -1 gdb
+```
+
+#### To run Salvium within gdb:
+
+Type `gdb /path/to/salviumd`
+
+Pass command-line options with `--args` followed by the relevant arguments
+
+Type `run` to run salviumd
+
+### Analysing memory corruption
+
+There are two tools available:
+
+#### ASAN
+
+Configure Salvium with the -D SANITIZE=ON cmake flag, eg:
+
+```bash
+cd build/debug && cmake -D SANITIZE=ON -D CMAKE_BUILD_TYPE=Debug ../..
+```
+
+You can then run the salvium tools normally. Performance will typically halve.
+
+#### valgrind
+
+Install valgrind and run as `valgrind /path/to/salviumd`. It will be very slow.
+
+### LMDB
+
+Instructions for debugging suspected blockchain corruption as per @HYC
+
+There is an `mdb_stat` command in the LMDB source that can print statistics about the database but it's not routinely built. This can be built with the following command:
+
+```bash
+cd ~/salvium/external/db_drivers/liblmdb && make
+```
+
+The output of `mdb_stat -ea <path to blockchain dir>` will indicate inconsistencies in the blocks, block_heights and block_info table.
+
+The output of `mdb_dump -s blocks <path to blockchain dir>` and `mdb_dump -s block_info <path to blockchain dir>` is useful for indicating whether blocks and block_info contain the same keys.
+
+These records are dumped as hex data, where the first line is the key and the second line is the data.
+
+# Known Issues
+
+## Protocols
+
+### Socket-based
+
+Because of the nature of the socket-based protocols that drive salvium, certain protocol weaknesses are somewhat unavoidable at this time. While these weaknesses can theoretically be fully mitigated, the effort required (the means) may not justify the ends. As such, please consider taking the following precautions if you are a salvium node operator:
+
+- Run `salviumd` on a "secured" machine. If operational security is not your forte, at a very minimum, have a dedicated a computer running `salviumd` and **do not** browse the web, use email clients, or use any other potentially harmful apps on your `salviumd` machine. **Do not click links or load URL/MUA content on the same machine**. Doing so may potentially exploit weaknesses in commands which accept "localhost" and "127.0.0.1".
+- If you plan on hosting a public "remote" node, start `salviumd` with `--restricted-rpc`. This is a must.
+
+### Blockchain-based
+
+Certain blockchain "features" can be considered "bugs" if misused correctly. Consequently, please consider the following:
+
+- When receiving salvium, be aware that it may be locked for an arbitrary time if the sender elected to, preventing you from spending that salvium until the lock time expires. You may want to hold off acting upon such a transaction until the unlock time lapses. To get a sense of that time, you can consider the remaining blocktime until unlock as seen in the `show_transfers` command.
@@ -1,8 +1,27 @@
-OPTION(USE_DEVICE_TREZOR "Trezor support compilation" ON)
-OPTION(USE_DEVICE_TREZOR_LIBUSB "Trezor LibUSB compilation" ON)
-OPTION(USE_DEVICE_TREZOR_UDP_RELEASE "Trezor UdpTransport in release mode" OFF)
-OPTION(USE_DEVICE_TREZOR_DEBUG "Trezor Debugging enabled" OFF)
-OPTION(TREZOR_DEBUG "Main trezor debugging switch" OFF)
+# Function for setting default options default values via env vars
+function(_trezor_default_val val_name val_default)
+    if(NOT DEFINED ENV{${val_name}})
+        set(ENV{${val_name}} ${val_default})
+    endif()
+endfunction()
+
+# Define default options via env vars
+_trezor_default_val(USE_DEVICE_TREZOR OFF)
+_trezor_default_val(USE_DEVICE_TREZOR_MANDATORY OFF)
+_trezor_default_val(USE_DEVICE_TREZOR_PROTOBUF_TEST OFF)
+_trezor_default_val(USE_DEVICE_TREZOR_LIBUSB OFF)
+_trezor_default_val(USE_DEVICE_TREZOR_UDP_RELEASE OFF)
+_trezor_default_val(USE_DEVICE_TREZOR_DEBUG OFF)
+_trezor_default_val(TREZOR_DEBUG OFF)
+
+# Main options
+OPTION(USE_DEVICE_TREZOR "Trezor support compilation" $ENV{USE_DEVICE_TREZOR})
+OPTION(USE_DEVICE_TREZOR_MANDATORY "Trezor compilation is mandatory, fail build if Trezor support cannot be compiled" $ENV{USE_DEVICE_TREZOR_MANDATORY})
+OPTION(USE_DEVICE_TREZOR_PROTOBUF_TEST "Trezor Protobuf test" $ENV{USE_DEVICE_TREZOR_PROTOBUF_TEST})
+OPTION(USE_DEVICE_TREZOR_LIBUSB "Trezor LibUSB compilation" $ENV{USE_DEVICE_TREZOR_LIBUSB})
+OPTION(USE_DEVICE_TREZOR_UDP_RELEASE "Trezor UdpTransport in release mode" $ENV{USE_DEVICE_TREZOR_UDP_RELEASE})
+OPTION(USE_DEVICE_TREZOR_DEBUG "Trezor Debugging enabled" $ENV{USE_DEVICE_TREZOR_DEBUG})
+OPTION(TREZOR_DEBUG "Main Trezor debugging switch" $ENV{TREZOR_DEBUG})

 # Helper function to fix cmake < 3.6.0 FindProtobuf variables
 function(_trezor_protobuf_fix_vars)
@@ -30,33 +49,68 @@ function(_trezor_protobuf_fix_vars)
    endif()
 endfunction()

+macro(trezor_fatal_msg msg)
+    if ($ENV{USE_DEVICE_TREZOR_MANDATORY})
+        message(FATAL_ERROR
+                "${msg}\n"
+                "==========================================================================\n"
+                "[ERROR] To compile without Trezor support, set USE_DEVICE_TREZOR=OFF. "
+                "It is possible both via cmake variable and environment variable, e.g., "
+                "`USE_DEVICE_TREZOR=OFF make release`\n"
+                "For more information, please check src/device_trezor/README.md\n"
+        )
+    else()
+        message(WARNING
+                "${msg}\n"
+                "==========================================================================\n"
+                "[WARNING] Trezor support cannot be compiled! Skipping Trezor compilation. \n"
+                "For more information, please check src/device_trezor/README.md\n")
+        set(USE_DEVICE_TREZOR OFF)
+        return()  # finish this cmake file processing (as this is macro).
+    endif()
+endmacro()
+
 # Use Trezor master switch
 if (USE_DEVICE_TREZOR)
    # Protobuf is required to build protobuf messages for Trezor
    include(FindProtobuf OPTIONAL)
-    find_package(Protobuf)
+
+    # PkgConfig works better with new Protobuf
+    find_package(PkgConfig QUIET)
+    pkg_check_modules(PROTOBUF protobuf)
+
+    if (NOT Protobuf_FOUND)
+        FIND_PACKAGE(Protobuf CONFIG)
+    endif()
+    if (NOT Protobuf_FOUND)
+        FIND_PACKAGE(Protobuf)
+    endif()
+
    _trezor_protobuf_fix_vars()

-    # Protobuf handling the cache variables set in docker.
+    # Early fail for optional Trezor support
    if(NOT Protobuf_FOUND AND NOT Protobuf_LIBRARY AND NOT Protobuf_PROTOC_EXECUTABLE AND NOT Protobuf_INCLUDE_DIR)
-        message(STATUS "Could not find Protobuf")
-    elseif(NOT Protobuf_LIBRARY OR NOT EXISTS "${Protobuf_LIBRARY}")
-        message(STATUS "Protobuf library not found: ${Protobuf_LIBRARY}")
+        trezor_fatal_msg("Trezor: Could not find Protobuf")
+    elseif(${CMAKE_CXX_STANDARD} LESS 17 AND ${Protobuf_VERSION} GREATER 21)
+        trezor_fatal_msg("Trezor: Unsupported Protobuf version ${Protobuf_VERSION} with C++ ${CMAKE_CXX_STANDARD}. Please, use Protobuf v21.")
+    elseif(NOT Protobuf_LIBRARY)
+        trezor_fatal_msg("Trezor: Protobuf library not found: ${Protobuf_LIBRARY}")
        unset(Protobuf_FOUND)
    elseif(NOT Protobuf_PROTOC_EXECUTABLE OR NOT EXISTS "${Protobuf_PROTOC_EXECUTABLE}")
-        message(STATUS "Protobuf executable not found: ${Protobuf_PROTOC_EXECUTABLE}")
+        trezor_fatal_msg("Trezor: Protobuf executable not found: ${Protobuf_PROTOC_EXECUTABLE}")
        unset(Protobuf_FOUND)
    elseif(NOT Protobuf_INCLUDE_DIR OR NOT EXISTS "${Protobuf_INCLUDE_DIR}")
-        message(STATUS "Protobuf include dir not found: ${Protobuf_INCLUDE_DIR}")
+        trezor_fatal_msg("Trezor: Protobuf include dir not found: ${Protobuf_INCLUDE_DIR}")
        unset(Protobuf_FOUND)
    else()
-        message(STATUS "Protobuf lib: ${Protobuf_LIBRARY}, inc: ${Protobuf_INCLUDE_DIR}, protoc: ${Protobuf_PROTOC_EXECUTABLE}")
+        message(STATUS "Trezor: Protobuf lib: ${Protobuf_LIBRARY}, inc: ${Protobuf_INCLUDE_DIR}, protoc: ${Protobuf_PROTOC_EXECUTABLE}")
        set(Protobuf_INCLUDE_DIRS ${Protobuf_INCLUDE_DIR})
-        set(Protobuf_FOUND 1)  # override found if all rquired info was provided by variables
+        set(Protobuf_FOUND 1)  # override found if all required info was provided by variables
    endif()

    if(TREZOR_DEBUG)
        set(USE_DEVICE_TREZOR_DEBUG 1)
+        message(STATUS "Trezor: debug build enabled")
    endif()

    # Compile debugging support (for tests)
@@ -64,7 +118,7 @@ if (USE_DEVICE_TREZOR)
        add_definitions(-DWITH_TREZOR_DEBUGGING=1)
    endif()
 else()
-    message(STATUS "Trezor support disabled by USE_DEVICE_TREZOR")
+    message(STATUS "Trezor: support disabled by USE_DEVICE_TREZOR")
 endif()

 if(Protobuf_FOUND AND USE_DEVICE_TREZOR)
@@ -85,7 +139,7 @@ if(Protobuf_FOUND AND USE_DEVICE_TREZOR)
    endif()

    if(NOT TREZOR_PYTHON)
-        message(STATUS "Trezor: Python not found")
+        trezor_fatal_msg("Trezor: Python not found")
    endif()
 endif()

@@ -93,27 +147,43 @@ endif()
 if(Protobuf_FOUND AND USE_DEVICE_TREZOR AND TREZOR_PYTHON)
    execute_process(COMMAND ${Protobuf_PROTOC_EXECUTABLE} -I "${CMAKE_CURRENT_LIST_DIR}" -I "${Protobuf_INCLUDE_DIR}" "${CMAKE_CURRENT_LIST_DIR}/test-protobuf.proto" --cpp_out ${CMAKE_BINARY_DIR} RESULT_VARIABLE RET OUTPUT_VARIABLE OUT ERROR_VARIABLE ERR)
    if(RET)
-        message(STATUS "Protobuf test generation failed: ${OUT} ${ERR}")
+        trezor_fatal_msg("Trezor: Protobuf test generation failed: ${OUT} ${ERR}")
    endif()

-    try_compile(Protobuf_COMPILE_TEST_PASSED
-        "${CMAKE_BINARY_DIR}"
-        SOURCES
-        "${CMAKE_BINARY_DIR}/test-protobuf.pb.cc"
-        "${CMAKE_CURRENT_LIST_DIR}/test-protobuf.cpp"
-        CMAKE_FLAGS
-        "-DINCLUDE_DIRECTORIES=${Protobuf_INCLUDE_DIR};${CMAKE_BINARY_DIR}"
-        "-DCMAKE_CXX_STANDARD=11"
-        LINK_LIBRARIES ${Protobuf_LIBRARY}
-        OUTPUT_VARIABLE OUTPUT
-    )
-    if(NOT Protobuf_COMPILE_TEST_PASSED)
-        message(STATUS "Protobuf Compilation test failed: ${OUTPUT}.")
+    if(ANDROID)
+        set(CMAKE_TRY_COMPILE_LINKER_FLAGS "${CMAKE_TRY_COMPILE_LINKER_FLAGS} -llog")
+        set(CMAKE_TRY_COMPILE_LINK_LIBRARIES "${CMAKE_TRY_COMPILE_LINK_LIBRARIES} log")
+    endif()
+
+    if(USE_DEVICE_TREZOR_PROTOBUF_TEST)
+        if(PROTOBUF_LDFLAGS)
+            set(PROTOBUF_TRYCOMPILE_LINKER "${PROTOBUF_LDFLAGS}")
+        else()
+            set(PROTOBUF_TRYCOMPILE_LINKER "${Protobuf_LIBRARY}")
+        endif()
+        
+        try_compile(Protobuf_COMPILE_TEST_PASSED
+            "${CMAKE_BINARY_DIR}"
+            SOURCES
+            "${CMAKE_BINARY_DIR}/test-protobuf.pb.cc"
+            "${CMAKE_CURRENT_LIST_DIR}/test-protobuf.cpp"
+            CMAKE_FLAGS
+            CMAKE_EXE_LINKER_FLAGS ${CMAKE_TRY_COMPILE_LINKER_FLAGS}
+            "-DINCLUDE_DIRECTORIES=${Protobuf_INCLUDE_DIR};${CMAKE_BINARY_DIR}"
+            "-DCMAKE_CXX_STANDARD=${CMAKE_CXX_STANDARD}"
+            LINK_LIBRARIES "${PROTOBUF_TRYCOMPILE_LINKER}" ${CMAKE_TRY_COMPILE_LINK_LIBRARIES}
+            OUTPUT_VARIABLE OUTPUT
+        )
+        if(NOT Protobuf_COMPILE_TEST_PASSED)
+            trezor_fatal_msg("Trezor: Protobuf Compilation test failed: ${OUTPUT}.")
+        endif()
+    else ()
+        message(STATUS "Trezor: Protobuf Compilation test skipped, build may fail later")
    endif()
 endif()

 # Try to build protobuf messages
-if(Protobuf_FOUND AND USE_DEVICE_TREZOR AND TREZOR_PYTHON AND Protobuf_COMPILE_TEST_PASSED)
+if(Protobuf_FOUND AND USE_DEVICE_TREZOR AND TREZOR_PYTHON)
    set(ENV{PROTOBUF_INCLUDE_DIRS} "${Protobuf_INCLUDE_DIR}")
    set(ENV{PROTOBUF_PROTOC_EXECUTABLE} "${Protobuf_PROTOC_EXECUTABLE}")
    set(TREZOR_PROTOBUF_PARAMS "")
@@ -123,59 +193,62 @@ if(Protobuf_FOUND AND USE_DEVICE_TREZOR AND TREZOR_PYTHON AND Protobuf_COMPILE_T
    
    execute_process(COMMAND ${TREZOR_PYTHON} tools/build_protob.py ${TREZOR_PROTOBUF_PARAMS} WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR}/../src/device_trezor/trezor RESULT_VARIABLE RET OUTPUT_VARIABLE OUT ERROR_VARIABLE ERR)
    if(RET)
-        message(WARNING "Trezor protobuf messages could not be regenerated (err=${RET}, python ${PYTHON})."
+        trezor_fatal_msg("Trezor: protobuf messages could not be regenerated (err=${RET}, python ${PYTHON})."
                "OUT: ${OUT}, ERR: ${ERR}."
                "Please read src/device_trezor/trezor/tools/README.md")
-    else()
-        message(STATUS "Trezor protobuf messages regenerated out: \"${OUT}.\"")
-        set(DEVICE_TREZOR_READY 1)
-        add_definitions(-DDEVICE_TREZOR_READY=1)
-        add_definitions(-DPROTOBUF_INLINE_NOT_IN_HEADERS=0)
+    endif()

-        if(CMAKE_BUILD_TYPE STREQUAL "Debug")
-            add_definitions(-DTREZOR_DEBUG=1)
+    message(STATUS "Trezor: protobuf messages regenerated out: \"${OUT}.\"")
+    set(DEVICE_TREZOR_READY 1)
+    add_definitions(-DDEVICE_TREZOR_READY=1)
+    add_definitions(-DPROTOBUF_INLINE_NOT_IN_HEADERS=0)
+
+    if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+        add_definitions(-DTREZOR_DEBUG=1)
+    endif()
+
+    if(USE_DEVICE_TREZOR_UDP_RELEASE)
+        message(STATUS "Trezor: UDP transport enabled (emulator)")
+        add_definitions(-DUSE_DEVICE_TREZOR_UDP_RELEASE=1)
+    endif()
+
+    if (Protobuf_INCLUDE_DIR)
+        include_directories(${Protobuf_INCLUDE_DIR})
+    endif()
+
+    # LibUSB support, check for particular version
+    # Include support only if compilation test passes
+    if (USE_DEVICE_TREZOR_LIBUSB)
+        find_package(LibUSB)
+    endif()
+
+    if (LibUSB_COMPILE_TEST_PASSED)
+        add_definitions(-DHAVE_TREZOR_LIBUSB=1)
+        if(LibUSB_INCLUDE_DIRS)
+            include_directories(${LibUSB_INCLUDE_DIRS})
+        endif()
+    endif()
+
+    set(TREZOR_LIBUSB_LIBRARIES "")
+    if(LibUSB_COMPILE_TEST_PASSED)
+        list(APPEND TREZOR_LIBUSB_LIBRARIES ${LibUSB_LIBRARIES} ${LIBUSB_DEP_LINKER})
+        message(STATUS "Trezor: compatible LibUSB found at: ${LibUSB_INCLUDE_DIRS}")
+    elseif(USE_DEVICE_TREZOR_LIBUSB AND NOT ANDROID)
+        trezor_fatal_msg("Trezor: LibUSB not found or test failed, please install libusb-1.0.26")
+    endif()
+
+    if (BUILD_GUI_DEPS)
+        set(TREZOR_DEP_LIBS "")
+        set(TREZOR_DEP_LINKER "")
+
+        if (Protobuf_LIBRARY)
+            list(APPEND TREZOR_DEP_LIBS ${Protobuf_LIBRARY})
+            string(APPEND TREZOR_DEP_LINKER " -lprotobuf")
        endif()

-        if(USE_DEVICE_TREZOR_UDP_RELEASE)
-            add_definitions(-DUSE_DEVICE_TREZOR_UDP_RELEASE=1)
-        endif()
-
-        if (Protobuf_INCLUDE_DIR)
-            include_directories(${Protobuf_INCLUDE_DIR})
-        endif()
-
-        # LibUSB support, check for particular version
-        # Include support only if compilation test passes
-        if (USE_DEVICE_TREZOR_LIBUSB)
-            find_package(LibUSB)
-        endif()
-
-        if (LibUSB_COMPILE_TEST_PASSED)
-            add_definitions(-DHAVE_TREZOR_LIBUSB=1)
-            if(LibUSB_INCLUDE_DIRS)
-                include_directories(${LibUSB_INCLUDE_DIRS})
-            endif()
-        endif()
-
-        set(TREZOR_LIBUSB_LIBRARIES "")
-        if(LibUSB_COMPILE_TEST_PASSED)
-            list(APPEND TREZOR_LIBUSB_LIBRARIES ${LibUSB_LIBRARIES} ${LIBUSB_DEP_LINKER})
-            message(STATUS "Trezor compatible LibUSB found at: ${LibUSB_INCLUDE_DIRS}")
-        endif()
-
-        if (BUILD_GUI_DEPS)
-            set(TREZOR_DEP_LIBS "")
-            set(TREZOR_DEP_LINKER "")
-
-            if (Protobuf_LIBRARY)
-                list(APPEND TREZOR_DEP_LIBS ${Protobuf_LIBRARY})
-                string(APPEND TREZOR_DEP_LINKER " -lprotobuf")
-            endif()
-
-            if (TREZOR_LIBUSB_LIBRARIES)
-                list(APPEND TREZOR_DEP_LIBS ${TREZOR_LIBUSB_LIBRARIES})
-                string(APPEND TREZOR_DEP_LINKER " -lusb-1.0 ${LIBUSB_DEP_LINKER}")
-            endif()
+        if (TREZOR_LIBUSB_LIBRARIES)
+            list(APPEND TREZOR_DEP_LIBS ${TREZOR_LIBUSB_LIBRARIES})
+            string(APPEND TREZOR_DEP_LINKER " -lusb-1.0 ${LIBUSB_DEP_LINKER}")
        endif()
    endif()
 endif()
@@ -95,11 +95,31 @@ if ( LibUSB_FOUND )
 endif ( LibUSB_FOUND )

 if ( LibUSB_FOUND )
-    check_library_exists ( "${LibUSB_LIBRARIES}" usb_open "" LibUSB_FOUND )
-    check_library_exists ( "${LibUSB_LIBRARIES}" libusb_get_device_list "" LibUSB_VERSION_1.0 )
-    check_library_exists ( "${LibUSB_LIBRARIES}" libusb_get_port_numbers "" LibUSB_VERSION_1.0.16 )
+    if (APPLE)
+        if(DEPENDS)
+            list(APPEND TEST_COMPILE_EXTRA_LIBRARIES "-framework Foundation -framework IOKit -framework Security")
+        else()
+            find_library(COREFOUNDATION CoreFoundation)
+            find_library(IOKIT IOKit)
+            find_library(SECURITY_FRAMEWORK Security)
+            list(APPEND TEST_COMPILE_EXTRA_LIBRARIES ${IOKIT})
+            list(APPEND TEST_COMPILE_EXTRA_LIBRARIES ${COREFOUNDATION})
+            list(APPEND TEST_COMPILE_EXTRA_LIBRARIES ${SECURITY_FRAMEWORK})

-    if((STATIC AND UNIX AND NOT APPLE) OR (DEPENDS AND CMAKE_SYSTEM_NAME STREQUAL "Linux") OR ANDROID)
+            if(STATIC)
+                find_library(OBJC objc.a)
+                set(LIBUSB_DEP_LINKER ${OBJC})
+                list(APPEND TEST_COMPILE_EXTRA_LIBRARIES ${LIBUSB_DEP_LINKER})
+            endif()
+        endif()
+    endif()
+    if (WIN32)
+        list(APPEND TEST_COMPILE_EXTRA_LIBRARIES setupapi)
+    endif()
+    list(APPEND TEST_COMPILE_EXTRA_LIBRARIES ${LibUSB_LIBRARIES})
+    set(CMAKE_REQUIRED_LIBRARIES ${TEST_COMPILE_EXTRA_LIBRARIES})
+
+    if((STATIC AND UNIX AND NOT APPLE AND NOT FREEBSD) OR (DEPENDS AND CMAKE_SYSTEM_NAME STREQUAL "Linux") OR ANDROID)
        find_library(LIBUDEV_LIBRARY udev)
        if(LIBUDEV_LIBRARY)
            set(LibUSB_LIBRARIES "${LibUSB_LIBRARIES};${LIBUDEV_LIBRARY}")
@@ -108,37 +128,20 @@ if ( LibUSB_FOUND )
        endif()
    endif()

+    check_library_exists ( "${LibUSB_LIBRARIES}" usb_open "" LibUSB_FOUND )
+    check_library_exists ( "${LibUSB_LIBRARIES}" libusb_get_device_list "" LibUSB_VERSION_1.0 )
+    check_library_exists ( "${LibUSB_LIBRARIES}" libusb_get_port_numbers "" LibUSB_VERSION_1.0.16 )
+
    # Library 1.0.16+ compilation test.
    # The check_library_exists does not work well on Apple with shared libs.
    if (APPLE OR LibUSB_VERSION_1.0.16 OR STATIC)
-        if (APPLE)
-            if(DEPENDS)
-                list(APPEND TEST_COMPILE_EXTRA_LIBRARIES "-framework Foundation -framework IOKit -framework Security")
-            else()
-                find_library(COREFOUNDATION CoreFoundation)
-                find_library(IOKIT IOKit)
-                list(APPEND TEST_COMPILE_EXTRA_LIBRARIES ${IOKIT})
-                list(APPEND TEST_COMPILE_EXTRA_LIBRARIES ${COREFOUNDATION})
-
-                if(STATIC)
-                    find_library(OBJC objc.a)
-                    set(LIBUSB_DEP_LINKER ${OBJC})
-                    list(APPEND TEST_COMPILE_EXTRA_LIBRARIES ${LIBUSB_DEP_LINKER})
-                endif()
-            endif()
-        endif()
-        if (WIN32)
-            list(APPEND TEST_COMPILE_EXTRA_LIBRARIES setupapi)
-        endif()
-        list(APPEND TEST_COMPILE_EXTRA_LIBRARIES ${LibUSB_LIBRARIES})
-
        try_compile(LibUSB_COMPILE_TEST_PASSED
                ${CMAKE_BINARY_DIR}
                "${CMAKE_CURRENT_LIST_DIR}/test-libusb-version.c"
                CMAKE_FLAGS
                    "-DINCLUDE_DIRECTORIES=${LibUSB_INCLUDE_DIRS}"
                    "-DLINK_DIRECTORIES=${LibUSB_LIBRARIES}"
-                LINK_LIBRARIES ${TEST_COMPILE_EXTRA_LIBRARIES}
+                LINK_LIBRARIES ${LibUSB_LIBRARIES} ${TEST_COMPILE_EXTRA_LIBRARIES}
                OUTPUT_VARIABLE OUTPUT)
        unset(TEST_COMPILE_EXTRA_LIBRARIES)
        message(STATUS "LibUSB Compilation test: ${LibUSB_COMPILE_TEST_PASSED}")
@@ -0,0 +1,297 @@
+# Written in 2016 by Henrik Steffen Gaßmann <henrik@gassmann.onl>
+#
+# To the extent possible under law, the author(s) have dedicated all
+# copyright and related and neighboring rights to this software to the
+# public domain worldwide. This software is distributed without any warranty.
+#
+# You should have received a copy of the CC0 Public Domain Dedication
+# along with this software. If not, see
+#
+#     http://creativecommons.org/publicdomain/zero/1.0/
+#
+########################################################################
+# Tries to find the local libsodium installation.
+#
+# On Windows the sodium_DIR environment variable is used as a default
+# hint which can be overridden by setting the corresponding cmake variable.
+#
+# Once done the following variables will be defined:
+#
+#   sodium_FOUND
+#   sodium_INCLUDE_DIR
+#   sodium_LIBRARY_DEBUG
+#   sodium_LIBRARY_RELEASE
+#
+#
+# Furthermore an imported "sodium" target is created.
+#
+
+if (CMAKE_C_COMPILER_ID STREQUAL "GNU"
+    OR CMAKE_C_COMPILER_ID STREQUAL "Clang")
+    set(_GCC_COMPATIBLE 1)
+endif()
+
+# static library option
+if (NOT DEFINED sodium_USE_STATIC_LIBS)
+    option(sodium_USE_STATIC_LIBS "enable to statically link against sodium" OFF)
+endif()
+if(NOT (sodium_USE_STATIC_LIBS EQUAL sodium_USE_STATIC_LIBS_LAST))
+    unset(sodium_LIBRARY CACHE)
+    unset(sodium_LIBRARY_DEBUG CACHE)
+    unset(sodium_LIBRARY_RELEASE CACHE)
+    unset(sodium_DLL_DEBUG CACHE)
+    unset(sodium_DLL_RELEASE CACHE)
+    set(sodium_USE_STATIC_LIBS_LAST ${sodium_USE_STATIC_LIBS} CACHE INTERNAL "internal change tracking variable")
+endif()
+
+
+########################################################################
+# UNIX
+if (UNIX)
+    # import pkg-config
+    find_package(PkgConfig QUIET)
+    if (PKG_CONFIG_FOUND)
+        pkg_check_modules(sodium_PKG QUIET libsodium)
+    endif()
+
+    if(sodium_USE_STATIC_LIBS)
+        foreach(_libname ${sodium_PKG_STATIC_LIBRARIES})
+            if (NOT _libname MATCHES "^lib.*\\.a$") # ignore strings already ending with .a
+                list(INSERT sodium_PKG_STATIC_LIBRARIES 0 "lib${_libname}.a")
+            endif()
+        endforeach()
+        list(REMOVE_DUPLICATES sodium_PKG_STATIC_LIBRARIES)
+
+        # if pkgconfig for libsodium doesn't provide
+        # static lib info, then override PKG_STATIC here..
+        if (NOT sodium_PKG_STATIC_FOUND)
+            set(sodium_PKG_STATIC_LIBRARIES libsodium.a)
+        endif()
+
+        set(XPREFIX sodium_PKG_STATIC)
+    else()
+        if (NOT sodium_PKG_FOUND)
+            set(sodium_PKG_LIBRARIES sodium)
+        endif()
+
+        set(XPREFIX sodium_PKG)
+    endif()
+
+    find_path(sodium_INCLUDE_DIR sodium.h
+        HINTS ${${XPREFIX}_INCLUDE_DIRS}
+    )
+    find_library(sodium_LIBRARY_DEBUG NAMES ${${XPREFIX}_LIBRARIES}
+        HINTS ${${XPREFIX}_LIBRARY_DIRS}
+    )
+    find_library(sodium_LIBRARY_RELEASE NAMES ${${XPREFIX}_LIBRARIES}
+        HINTS ${${XPREFIX}_LIBRARY_DIRS}
+    )
+
+
+########################################################################
+# Windows
+elseif (WIN32)
+    set(sodium_DIR "$ENV{sodium_DIR}" CACHE FILEPATH "sodium install directory")
+    mark_as_advanced(sodium_DIR)
+
+    find_path(sodium_INCLUDE_DIR sodium.h
+        HINTS ${sodium_DIR}
+        PATH_SUFFIXES include
+    )
+
+    if (MSVC)
+        # detect target architecture
+        file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/arch.cpp" [=[
+            #if defined _M_IX86
+            #error ARCH_VALUE x86_32
+            #elif defined _M_X64
+            #error ARCH_VALUE x86_64
+            #endif
+            #error ARCH_VALUE unknown
+        ]=])
+        try_compile(_UNUSED_VAR "${CMAKE_CURRENT_BINARY_DIR}" "${CMAKE_CURRENT_BINARY_DIR}/arch.cpp"
+            OUTPUT_VARIABLE _COMPILATION_LOG
+        )
+        string(REGEX REPLACE ".*ARCH_VALUE ([a-zA-Z0-9_]+).*" "\\1" _TARGET_ARCH "${_COMPILATION_LOG}")
+
+        # construct library path
+        if (_TARGET_ARCH STREQUAL "x86_32")
+            string(APPEND _PLATFORM_PATH "Win32")
+        elseif(_TARGET_ARCH STREQUAL "x86_64")
+            string(APPEND _PLATFORM_PATH "x64")
+        else()
+            message(FATAL_ERROR "the ${_TARGET_ARCH} architecture is not supported by Findsodium.cmake.")
+        endif()
+        string(APPEND _PLATFORM_PATH "/$$CONFIG$$")
+
+        if (MSVC_VERSION LESS 1900)
+            math(EXPR _VS_VERSION "${MSVC_VERSION} / 10 - 60")
+        else()
+            math(EXPR _VS_VERSION "${MSVC_VERSION} / 10 - 50")
+        endif()
+        string(APPEND _PLATFORM_PATH "/v${_VS_VERSION}")
+
+        if (sodium_USE_STATIC_LIBS)
+            string(APPEND _PLATFORM_PATH "/static")
+        else()
+            string(APPEND _PLATFORM_PATH "/dynamic")
+        endif()
+
+        string(REPLACE "$$CONFIG$$" "Debug" _DEBUG_PATH_SUFFIX "${_PLATFORM_PATH}")
+        string(REPLACE "$$CONFIG$$" "Release" _RELEASE_PATH_SUFFIX "${_PLATFORM_PATH}")
+
+        find_library(sodium_LIBRARY_DEBUG libsodium.lib
+            HINTS ${sodium_DIR}
+            PATH_SUFFIXES ${_DEBUG_PATH_SUFFIX}
+        )
+        find_library(sodium_LIBRARY_RELEASE libsodium.lib
+            HINTS ${sodium_DIR}
+            PATH_SUFFIXES ${_RELEASE_PATH_SUFFIX}
+        )
+        if (NOT sodium_USE_STATIC_LIBS)
+            set(CMAKE_FIND_LIBRARY_SUFFIXES_BCK ${CMAKE_FIND_LIBRARY_SUFFIXES})
+            set(CMAKE_FIND_LIBRARY_SUFFIXES ".dll")
+            find_library(sodium_DLL_DEBUG libsodium
+                HINTS ${sodium_DIR}
+                PATH_SUFFIXES ${_DEBUG_PATH_SUFFIX}
+            )
+            find_library(sodium_DLL_RELEASE libsodium
+                HINTS ${sodium_DIR}
+                PATH_SUFFIXES ${_RELEASE_PATH_SUFFIX}
+            )
+            set(CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES_BCK})
+        endif()
+
+    elseif(_GCC_COMPATIBLE)
+        if (sodium_USE_STATIC_LIBS)
+            find_library(sodium_LIBRARY_DEBUG libsodium.a
+                HINTS ${sodium_DIR}
+                PATH_SUFFIXES lib
+            )
+            find_library(sodium_LIBRARY_RELEASE libsodium.a
+                HINTS ${sodium_DIR}
+                PATH_SUFFIXES lib
+            )
+        else()
+            find_library(sodium_LIBRARY_DEBUG libsodium.dll.a
+                HINTS ${sodium_DIR}
+                PATH_SUFFIXES lib
+            )
+            find_library(sodium_LIBRARY_RELEASE libsodium.dll.a
+                HINTS ${sodium_DIR}
+                PATH_SUFFIXES lib
+            )
+
+            file(GLOB _DLL
+                LIST_DIRECTORIES false
+                RELATIVE "${sodium_DIR}/bin"
+                "${sodium_DIR}/bin/libsodium*.dll"
+            )
+            find_library(sodium_DLL_DEBUG ${_DLL} libsodium
+                HINTS ${sodium_DIR}
+                PATH_SUFFIXES bin
+            )
+            find_library(sodium_DLL_RELEASE ${_DLL} libsodium
+                HINTS ${sodium_DIR}
+                PATH_SUFFIXES bin
+            )
+        endif()
+    else()
+        message(FATAL_ERROR "this platform is not supported by FindSodium.cmake")
+    endif()
+
+
+########################################################################
+# unsupported
+else()
+    message(FATAL_ERROR "this platform is not supported by FindSodium.cmake")
+endif()
+
+
+########################################################################
+# common stuff
+
+# extract sodium version
+if (sodium_INCLUDE_DIR)
+    set(_VERSION_HEADER "${_INCLUDE_DIR}/sodium/version.h")
+    if (EXISTS _VERSION_HEADER)
+        file(READ "${_VERSION_HEADER}" _VERSION_HEADER_CONTENT)
+        string(REGEX REPLACE ".*#[ \t]*define[ \t]*SODIUM_VERSION_STRING[ \t]*\"([^\n]*)\".*" "\\1"
+            sodium_VERSION "${_VERSION_HEADER_CONTENT}")
+        set(sodium_VERSION "${sodium_VERSION}" PARENT_SCOPE)
+    endif()
+endif()
+
+# communicate results
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(
+    Sodium # The name must be either uppercase or match the filename case.
+    REQUIRED_VARS
+        sodium_LIBRARY_RELEASE
+        sodium_LIBRARY_DEBUG
+        sodium_INCLUDE_DIR
+    VERSION_VAR
+        sodium_VERSION
+)
+
+if(Sodium_FOUND)
+    set(sodium_LIBRARIES
+        optimized ${sodium_LIBRARY_RELEASE} debug ${sodium_LIBRARY_DEBUG})
+endif()
+
+# mark file paths as advanced
+mark_as_advanced(sodium_INCLUDE_DIR)
+mark_as_advanced(sodium_LIBRARY_DEBUG)
+mark_as_advanced(sodium_LIBRARY_RELEASE)
+if (WIN32)
+    mark_as_advanced(sodium_DLL_DEBUG)
+    mark_as_advanced(sodium_DLL_RELEASE)
+endif()
+
+# create imported target
+if(sodium_USE_STATIC_LIBS)
+    set(_LIB_TYPE STATIC)
+else()
+    set(_LIB_TYPE SHARED)
+endif()
+
+if(NOT TARGET sodium)
+    add_library(sodium ${_LIB_TYPE} IMPORTED)
+endif()
+
+set_target_properties(sodium PROPERTIES
+    INTERFACE_INCLUDE_DIRECTORIES "${sodium_INCLUDE_DIR}"
+    IMPORTED_LINK_INTERFACE_LANGUAGES "C"
+)
+
+if (sodium_USE_STATIC_LIBS)
+    set_target_properties(sodium PROPERTIES
+        INTERFACE_COMPILE_DEFINITIONS "SODIUM_STATIC"
+        IMPORTED_LOCATION "${sodium_LIBRARY_RELEASE}"
+        IMPORTED_LOCATION_DEBUG "${sodium_LIBRARY_DEBUG}"
+    )
+else()
+    if (UNIX)
+        set_target_properties(sodium PROPERTIES
+            IMPORTED_LOCATION "${sodium_LIBRARY_RELEASE}"
+            IMPORTED_LOCATION_DEBUG "${sodium_LIBRARY_DEBUG}"
+        )
+    elseif (WIN32)
+        set_target_properties(sodium PROPERTIES
+            IMPORTED_IMPLIB "${sodium_LIBRARY_RELEASE}"
+            IMPORTED_IMPLIB_DEBUG "${sodium_LIBRARY_DEBUG}"
+        )
+        if (NOT (sodium_DLL_DEBUG MATCHES ".*-NOTFOUND"))
+            set_target_properties(sodium PROPERTIES
+                IMPORTED_LOCATION_DEBUG "${sodium_DLL_DEBUG}"
+            )
+        endif()
+        if (NOT (sodium_DLL_RELEASE MATCHES ".*-NOTFOUND"))
+            set_target_properties(sodium PROPERTIES
+                IMPORTED_LOCATION_RELWITHDEBINFO "${sodium_DLL_RELEASE}"
+                IMPORTED_LOCATION_MINSIZEREL "${sodium_DLL_RELEASE}"
+                IMPORTED_LOCATION_RELEASE "${sodium_DLL_RELEASE}"
+            )
+        endif()
+    endif()
+endif()
@@ -31,4 +31,5 @@ brew "doxygen"
 brew "graphviz"
 brew "libunwind-headers"
 brew "xz"
-brew "protobuf"
+brew "protobuf@21", link: true
+brew "libusb"
@@ -8,3 +8,4 @@ i686*
 mips*
 arm*
 aarch64*
+riscv64*
@@ -1,5 +1,9 @@
 .NOTPARALLEL :

+# Pattern rule to print variables, e.g. make print-all_packages
+print-%: FORCE
+	@echo '$($*)'
+
 SOURCES_PATH ?= $(BASEDIR)/sources
 BASE_CACHE ?= $(BASEDIR)/built
 FALLBACK_DOWNLOAD_PATH ?= https://downloads.getmonero.org/depends-sources
@@ -68,21 +72,6 @@ $(host_arch)_$(host_os)_prefix=$(BASEDIR)/$(host)
 $(host_arch)_$(host_os)_host=$(host)
 host_prefix=$($(host_arch)_$(host_os)_prefix)
 build_prefix=$(host_prefix)/native
-ifeq ($(host_os),mingw32)
-host_cmake=Windows
-endif
-ifeq ($(host_os),linux)
-host_cmake=Linux
-endif
-ifeq ($(host_os),freebsd)
-host_cmake=FreeBSD
-endif
-ifeq ($(host_os),darwin)
-host_cmake=Darwin
-endif
-ifeq ($(host_os),android)
-host_cmake=Android
-endif

 AT_$(V):=
 AT_:=@
@@ -121,17 +110,7 @@ $(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)
@@ -142,26 +121,6 @@ $(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)|' \
@@ -181,7 +140,7 @@ $(host_prefix)/share/toolchain.cmake : toolchain.cmake.in $(host_prefix)/.stamp_
            -e 's|@debug@|$(DEBUG)|' \
            -e 's|@release_type@|$(release_type)|' \
            -e 's|@build_tests@|$(build_tests)|' \
-            -e 's|@depends@|$(host_cmake)|' \
+            -e 's|@cmake_system_name@|$($(host_os)_cmake_system)|' \
            -e 's|@prefix@|$($(host_arch)_$(host_os)_prefix)|'\
            -e 's|@arch@|$(host_arch)|'\
            $< > $@
@@ -206,24 +165,27 @@ 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)

 download-osx:
-	@$(MAKE) -s HOST=x86_64-apple-darwin11 download-one
+	@$(MAKE) -s HOST=x86_64-apple-darwin download-one
 download-linux:
 	@$(MAKE) -s HOST=x86_64-unknown-linux-gnu download-one
 download-win:
 	@$(MAKE) -s HOST=x86_64-w64-mingw32 download-one
-download: download-osx download-linux download-win
+download-freebsd:
+	@$(MAKE) -s HOST=x86_64-unknown-freebsd download-one
+download-android:
+	@$(MAKE) -s HOST=aarch64-linux-android download-one
+download: download-osx download-linux download-win download-freebsd download-android

 $(foreach package,$(all_packages),$(eval $(call ext_add_stages,$(package))))

-.PHONY: install cached download-one download-osx download-linux download-win download check-packages check-sources
+.PHONY: install cached download-one download-osx download-linux download-win download-freebsd download-android download check-packages check-sources
+.PHONY: FORCE
@@ -1,6 +1,6 @@
 ### Usage

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

 ```bash
 make
@@ -20,17 +20,19 @@ 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:
+created. To use it for Monero, from the top of the Monero source tree:

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

 Common `host-platform-triplets` for cross compilation are:

 - `i686-w64-mingw32` for Win32
 - `x86_64-w64-mingw32` for Win64
- `x86_64-apple-darwin11` for MacOSX x86_64
+- `x86_64-apple-darwin` for MacOSX x86_64
 - `arm-linux-gnueabihf` for Linux ARM 32 bit
 - `aarch64-linux-gnu` for Linux ARM 64 bit
 - `riscv64-linux-gnu` for Linux RISCV 64 bit
@@ -1,66 +0,0 @@
-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
@@ -20,3 +20,4 @@ android_debug_CXXFLAGS=$(android_debug_CFLAGS)

 android_native_toolchain=android_ndk

+android_cmake_system=Android
@@ -1,12 +1,12 @@
-OSX_MIN_VERSION=10.8
+OSX_MIN_VERSION=10.13
 LD64_VERSION=609
 ifeq (aarch64, $(host_arch))
 CC_target=arm64-apple-$(host_os)
 else
 CC_target=$(host)
 endif
-darwin_CC=clang -target $(CC_target) -mmacosx-version-min=$(OSX_MIN_VERSION) --sysroot $(host_prefix)/native/SDK/ -mlinker-version=$(LD64_VERSION) -B$(host_prefix)/native/bin/$(host)-
-darwin_CXX=clang++ -target $(CC_target) -mmacosx-version-min=$(OSX_MIN_VERSION) --sysroot $(host_prefix)/native/SDK/ -mlinker-version=$(LD64_VERSION) -stdlib=libc++ -B$(host_prefix)/native/bin/$(host)-
+darwin_CC=clang -target $(CC_target) -mmacosx-version-min=$(OSX_MIN_VERSION) --sysroot $(host_prefix)/native/SDK/ -iwithsysroot/usr/include -iframeworkwithsysroot/System/Library/Frameworks -mlinker-version=$(LD64_VERSION) -B$(host_prefix)/native/bin/$(host)-
+darwin_CXX=clang++ -target $(CC_target) -mmacosx-version-min=$(OSX_MIN_VERSION) --sysroot $(host_prefix)/native/SDK/ -iwithsysroot/usr/include/c++/v1 -iwithsysroot/usr/include -iframeworkwithsysroot/System/Library/Frameworks -mlinker-version=$(LD64_VERSION) -stdlib=libc++ -B$(host_prefix)/native/bin/$(host)-

 darwin_CFLAGS=-pipe
 darwin_CXXFLAGS=$(darwin_CFLAGS)
@@ -19,3 +19,5 @@ darwin_debug_CFLAGS=-O1
 darwin_debug_CXXFLAGS=$(darwin_debug_CFLAGS)

 darwin_native_toolchain=native_cctools darwin_sdk
+
+darwin_cmake_system=Darwin
@@ -16,3 +16,4 @@ freebsd_debug_CXXFLAGS=$(freebsd_debug_CFLAGS)

 freebsd_native_toolchain=freebsd_base

+freebsd_cmake_system=FreeBSD
@@ -30,3 +30,5 @@ i686_linux_CXX=$(default_host_CXX) -m32
 x86_64_linux_CC=$(default_host_CC) -m64
 x86_64_linux_CXX=$(default_host_CXX) -m64
 endif
+
+linux_cmake_system=Linux
@@ -1,4 +1,4 @@
-mingw32_CFLAGS=-pipe
+mingw32_CFLAGS=-pipe -pthread
 mingw32_CXXFLAGS=$(mingw32_CFLAGS)
 mingw32_ARFLAGS=cr

@@ -9,3 +9,5 @@ mingw32_debug_CFLAGS=-O1
 mingw32_debug_CXXFLAGS=$(mingw32_debug_CFLAGS)

 mingw32_debug_CPPFLAGS=-D_GLIBCXX_DEBUG -D_GLIBCXX_DEBUG_PEDANTIC
+
+mingw32_cmake_system=Windows
@@ -1,8 +1,9 @@
 package=android_ndk
-$(package)_version=17b
+$(package)_version=18b
 $(package)_download_path=https://dl.google.com/android/repository/
 $(package)_file_name=android-ndk-r$($(package)_version)-linux-x86_64.zip
-$(package)_sha256_hash=5dfbbdc2d3ba859fed90d0e978af87c71a91a5be1f6e1c40ba697503d48ccecd
+$(package)_sha256_hash=4f61cbe4bbf6406aa5ef2ae871def78010eed6271af72de83f8bd0b07a9fd3fd
+$(package)_patches=api_definition.patch

 define $(package)_set_vars
 $(package)_config_opts_arm=--arch arm
@@ -14,6 +15,11 @@ define $(package)_extract_cmds
  unzip -q $($(1)_source_dir)/$($(package)_file_name)
 endef

+define $(package)_preprocess_cmds
+  cd android-ndk-r$($(package)_version) && \
+  patch -p1 < $($(package)_patch_dir)/api_definition.patch
+endef
+
 define $(package)_stage_cmds
  android-ndk-r$($(package)_version)/build/tools/make_standalone_toolchain.py --api 21 \
    --install-dir $(build_prefix) --stl=libc++ $($(package)_config_opts) &&\
@@ -3,7 +3,6 @@ $(package)_version=1_64_0
 $(package)_download_path=https://downloads.sourceforge.net/project/boost/boost/1.64.0/
 $(package)_file_name=$(package)_$($(package)_version).tar.bz2
 $(package)_sha256_hash=7bcc5caace97baa948931d712ea5f37038dbb1c5d89b43ad4def4ed7cb683332
-$(package)_dependencies=libiconv
 $(package)_patches=fix_aroptions.patch fix_arm_arch.patch

 define $(package)_set_vars
@@ -22,7 +21,8 @@ $(package)_toolset_$(host_os)=gcc
 $(package)_archiver_$(host_os)=$($(package)_ar)
 $(package)_toolset_darwin=darwin
 $(package)_archiver_darwin=$($(package)_libtool)
-$(package)_config_libraries=chrono,filesystem,program_options,system,thread,test,date_time,regex,serialization,locale
+$(package)_config_libraries_$(host_os)="chrono,filesystem,program_options,system,thread,test,date_time,regex,serialization"
+$(package)_config_libraries_mingw32="chrono,filesystem,program_options,system,thread,test,date_time,regex,serialization,locale"
 $(package)_cxxflags=-std=c++11
 $(package)_cxxflags_linux=-fPIC
 $(package)_cxxflags_freebsd=-fPIC
@@ -35,7 +35,7 @@ define $(package)_preprocess_cmds
 endef

 define $(package)_config_cmds
-  ./bootstrap.sh --without-icu --with-libraries=$(boost_config_libraries)
+  ./bootstrap.sh --without-icu --with-libraries=$(boost_config_libraries_$(host_os))
 endef

 define $(package)_build_cmds
@@ -1,8 +1,8 @@
 package=darwin_sdk
-$(package)_version=11.1
-$(package)_download_path=https://github.com/phracker/MacOSX-SDKs/releases/download/11.3/
-$(package)_file_name=MacOSX$($(package)_version).sdk.tar.xz
-$(package)_sha256_hash=68797baaacb52f56f713400de306a58a7ca00b05c3dc6d58f0a8283bcac721f8
+$(package)_version=12.2
+$(package)_download_path=https://bitcoincore.org/depends-sources/sdks
+$(package)_file_name=Xcode-12.2-12B45b-extracted-SDK-with-libcxx-headers.tar.gz
+$(package)_sha256_hash=df75d30ecafc429e905134333aeae56ac65fac67cb4182622398fd717df77619

 define $(package)_stage_cmds
  mkdir -p $($(package)_staging_dir)/$(host_prefix)/native/SDK &&\
@@ -1,9 +1,8 @@
 package=eudev
-$(package)_version=v3.2.6
-$(package)_download_path=https://github.com/gentoo/eudev/archive/
-$(package)_download_file=$($(package)_version).tar.gz
+$(package)_version=3.2.14
+$(package)_download_path=https://github.com/eudev-project/eudev/releases/download/v$($(package)_version)/
 $(package)_file_name=$(package)-$($(package)_version).tar.gz
-$(package)_sha256_hash=a96ecb8637667897b8bd4dee4c22c7c5f08b327be45186e912ce6bc768385852
+$(package)_sha256_hash=8da4319102f24abbf7fff5ce9c416af848df163b29590e666d334cc1927f006f

 define $(package)_set_vars
  $(package)_config_opts=--disable-gudev --disable-introspection --disable-hwdb --disable-manpages --disable-shared
@@ -1,30 +0,0 @@
-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
@@ -1,27 +0,0 @@
-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
@@ -1,23 +0,0 @@
-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
@@ -1,23 +0,0 @@
-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
@@ -1,35 +0,0 @@
-package=libiconv
-$(package)_version=1.15
-$(package)_download_path=https://ftp.gnu.org/gnu/libiconv
-$(package)_file_name=libiconv-$($(package)_version).tar.gz
-$(package)_sha256_hash=ccf536620a45458d26ba83887a983b96827001e92a13847b45e4925cc8913178
-$(package)_patches=fix-whitespace.patch
-
-define $(package)_set_vars
-  $(package)_config_opts=--disable-nls
-  $(package)_config_opts=--enable-static
-  $(package)_config_opts=--disable-shared
-  $(package)_config_opts_linux=--with-pic
-  $(package)_config_opts_freebsd=--with-pic
-endef
-
-define $(package)_preprocess_cmds
-  cp -f $(BASEDIR)/config.guess $(BASEDIR)/config.sub build-aux/ &&\
-  patch -p1 < $($(package)_patch_dir)/fix-whitespace.patch
-endef
-
-define $(package)_config_cmds
-  $($(package)_autoconf) AR_FLAGS=$($(package)_arflags)
-endef
-
-define $(package)_build_cmds
-  $(MAKE)
-endef
-
-define $(package)_stage_cmds
-  $(MAKE) DESTDIR=$($(package)_staging_dir) install
-endef
-
-define $(package)_postprocess_cmds
-  rm lib/*.la
-endef
@@ -1,10 +1,11 @@
 package=libusb
-$(package)_version=1.0.26
+$(package)_version=1.0.27
 $(package)_download_path=https://github.com/libusb/libusb/releases/download/v$($(package)_version)
 $(package)_file_name=$(package)-$($(package)_version).tar.bz2
-$(package)_sha256_hash=12ce7a61fc9854d1d2a1ffe095f7b5fac19ddba095c259e6067a46500381b5a5
+$(package)_sha256_hash=ffaa41d741a8a3bee244ac8e54a72ea05bf2879663c098c82fc5757853441575

 define $(package)_preprocess_cmds
+  cp -f $(BASEDIR)/config.guess $(BASEDIR)/config.sub . && \
  autoreconf -i
 endef

@@ -13,19 +14,12 @@ define $(package)_set_vars
  $(package)_config_opts_linux=--with-pic --disable-udev
  $(package)_config_opts_mingw32=--disable-udev
  $(package)_config_opts_darwin=--disable-udev
+  $(package)_config_opts_freebsd=--with-pic --disable-udev
 endef

-ifneq ($(host_os),darwin)
-  define $(package)_config_cmds
-    cp -f $(BASEDIR)/config.guess config.guess &&\
-    cp -f $(BASEDIR)/config.sub config.sub &&\
-    $($(package)_autoconf) AR_FLAGS=$($(package)_arflags)
-  endef
-else
-  define $(package)_config_cmds
-    $($(package)_autoconf) AR_FLAGS=$($(package)_arflags)
-  endef
-endif
+define $(package)_config_cmds
+  $($(package)_autoconf) AR_FLAGS=$($(package)_arflags)
+endef

 define $(package)_build_cmd
  $(MAKE)
@@ -35,5 +29,6 @@ define $(package)_stage_cmds
  $(MAKE) DESTDIR=$($(package)_staging_dir) install
 endef

-define $(package)_postprocess_cmds  cp -f lib/libusb-1.0.a lib/libusb.a
+define $(package)_postprocess_cmds
+  cp -f lib/libusb-1.0.a lib/libusb.a
 endef
@@ -1,20 +0,0 @@
-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
@@ -1,25 +0,0 @@
-package=native_ccache
-$(package)_version=3.3.4
-$(package)_download_path=https://samba.org/ftp/ccache
-$(package)_file_name=ccache-$($(package)_version).tar.bz2
-$(package)_sha256_hash=fa9d7f38367431bc86b19ad107d709ca7ecf1574fdacca01698bdf0a47cd8567
-
-define $(package)_set_vars
-$(package)_config_opts=
-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
-  rm -rf lib include
-endef
@@ -6,6 +6,7 @@ $(package)_file_name=$(package)-$($(package)_version).tar.gz
 $(package)_sha256_hash=70a7189418c2086d20c299c5d59250cf5940782c778892ccc899c66516ed240e
 $(package)_build_subdir=cctools
 $(package)_dependencies=native_clang native_libtapi
+$(package)_patches=no-build-date.patch

 define $(package)_set_vars
 $(package)_config_opts=--target=$(host) --disable-lto-support --with-libtapi=$(host_prefix)
@@ -14,6 +15,10 @@ $(package)_cc=$(host_prefix)/native/bin/clang
 $(package)_cxx=$(host_prefix)/native/bin/clang++
 endef

+define $(package)_preprocess_cmds
+  patch -p1 < $($(package)_patch_dir)/no-build-date.patch
+endef
+
 define $(package)_config_cmds
  $($(package)_autoconf)
 endef
@@ -1,26 +0,0 @@
-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
@@ -24,6 +24,5 @@ define $(package)_stage_cmds
  cp lib/libLTO.so $($(package)_staging_prefix_dir)/lib/ && \
  cp -rf lib/clang/$($(package)_version)/include/* $($(package)_staging_prefix_dir)/lib/clang/$($(package)_version)/include/ && \
  cp bin/dsymutil $($(package)_staging_prefix_dir)/bin/$(host)-dsymutil && \
-  if `test -d include/c++/`; then cp -rf include/c++/ $($(package)_staging_prefix_dir)/include/; fi && \
  if `test -d lib/c++/`; then cp -rf lib/c++/ $($(package)_staging_prefix_dir)/lib/; fi
 endef
@@ -1,23 +0,0 @@
-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
@@ -1,17 +0,0 @@
-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
@@ -1,22 +0,0 @@
-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
@@ -6,6 +6,11 @@ $(package)_file_name=$(package)-$($(package)_version).tar.gz
 $(package)_sha256_hash=62e419c12d1c9fad67cc1cd523132bc00db050998337c734c15bc8d73cc02b61
 $(package)_build_subdir=build
 $(package)_dependencies=native_clang
+$(package)_patches=no_embed_git_rev.patch
+
+define $(package)_preprocess_cmds
+  patch -p1 -i $($(package)_patch_dir)/no_embed_git_rev.patch
+endef

 define $(package)_config_cmds
  echo -n $(build_prefix) > INSTALLPREFIX; \
@@ -1,21 +0,0 @@
-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,9 @@
-package=protobuf3
-$(package)_version=3.6.1
+package=native_protobuf
+$(package)_version=21.12
+$(package)_version_protobuf_cpp=3.21.12
 $(package)_download_path=https://github.com/protocolbuffers/protobuf/releases/download/v$($(package)_version)/
-$(package)_file_name=protobuf-cpp-$($(package)_version).tar.gz
-$(package)_sha256_hash=b3732e471a9bb7950f090fd0457ebd2536a9ba0891b7f3785919c654fe2a2529
+$(package)_file_name=protobuf-cpp-$($(package)_version_protobuf_cpp).tar.gz
+$(package)_sha256_hash=4eab9b524aa5913c6fffb20b2a8abf5ef7f95a80bc0701f3a6dbb4c607f73460
 $(package)_cxxflags=-std=c++11

 define $(package)_set_vars
@@ -15,13 +16,13 @@ define $(package)_config_cmds
 endef

 define $(package)_build_cmds
-  $(MAKE) -C src
+  $(MAKE) -C src protoc
 endef

 define $(package)_stage_cmds
-  $(MAKE) DESTDIR=$($(package)_staging_dir) -C src install
+  $(MAKE) DESTDIR=$($(package)_staging_dir) -C src install-binPROGRAMS install-nobase_dist_protoDATA
 endef

 define $(package)_postprocess_cmds
-  rm lib/libprotoc.a
+  rm -rf lib/
 endef
@@ -4,9 +4,12 @@ $(package)_download_path=https://www.openssl.org/source
 $(package)_file_name=$(package)-$($(package)_version).tar.gz
 $(package)_sha256_hash=88525753f79d3bec27d2fa7c66aa0b92b3aa9498dafd93d7cfa4b3780cdae313

+# The bundled ranlib in Android NDK 18b inserts timestamps by default.
+# To prevent reproducibility issues, we must enable [D]eterministic mode.
+
 define $(package)_set_vars
-$(package)_config_env=AR="$($(package)_ar)" ARFLAGS=$($(package)_arflags) RANLIB="$($(package)_ranlib)" CC="$($(package)_cc)"
-$(package)_config_env_android=ANDROID_NDK_ROOT="$(host_prefix)/native" PATH="$(host_prefix)/native/bin" CC=clang AR=ar RANLIB=ranlib
+$(package)_config_env=AR="$($(package)_ar)" RANLIB="$($(package)_ranlib)" CC="$($(package)_cc)"
+$(package)_config_env_android=ANDROID_NDK_ROOT="$(host_prefix)/native" PATH="$(host_prefix)/native/bin" CC=clang AR=ar RANLIB="ranlib -D"
 $(package)_build_env_android=ANDROID_NDK_ROOT="$(host_prefix)/native"
 $(package)_config_opts=--prefix=$(host_prefix) --openssldir=$(host_prefix)/etc/openssl --libdir=$(host_prefix)/lib
 $(package)_config_opts+=no-capieng
@@ -52,7 +55,7 @@ define $(package)_preprocess_cmds
 endef

 define $(package)_config_cmds
-  ./Configure $($(package)_config_opts)
+  ./Configure $($(package)_config_opts) ARFLAGS=$($(package)_arflags)
 endef

 define $(package)_build_cmds
@@ -1,38 +1,28 @@
-packages:=boost openssl zeromq libiconv expat unbound
-
-# ccache is useless in gitian builds
-ifneq ($(GITIAN),1)
-native_packages := native_ccache
-endif
+packages:=boost openssl zeromq expat unbound sodium

 hardware_packages := hidapi protobuf libusb
 hardware_native_packages := native_protobuf

-android_native_packages = android_ndk
-android_packages = ncurses readline sodium
+android_native_packages = android_ndk $(hardware_native_packages)
+android_packages = ncurses readline protobuf

 darwin_native_packages = $(hardware_native_packages)
-darwin_packages = ncurses readline sodium $(hardware_packages)
+darwin_packages = ncurses readline $(hardware_packages)

 # not really native...
-freebsd_native_packages = freebsd_base
-freebsd_packages = ncurses readline sodium
+freebsd_native_packages = freebsd_base $(hardware_native_packages)
+freebsd_packages = ncurses readline protobuf libusb

-linux_packages = eudev ncurses readline sodium $(hardware_packages)
+linux_packages = eudev ncurses readline $(hardware_packages)
 linux_native_packages = $(hardware_native_packages)

 ifeq ($(build_tests),ON)
 packages += gtest
 endif

-ifneq ($(host_arch),riscv64)
-linux_packages += unwind
-endif
-
-mingw32_packages = icu4c sodium $(hardware_packages)
+mingw32_packages = $(hardware_packages)
 mingw32_native_packages = $(hardware_native_packages)

 ifneq ($(build_os),darwin)
 darwin_native_packages += darwin_sdk native_clang native_cctools native_libtapi
 endif
-
@@ -1,21 +1,17 @@
 package=protobuf
 $(package)_version=$(native_$(package)_version)
+$(package)_version_protobuf_cpp=$(native_$(package)_version_protobuf_cpp)
 $(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
-$(package)_patches=visibility.patch

 define $(package)_set_vars
  $(package)_config_opts=--disable-shared --with-protoc=$(build_prefix)/bin/protoc
  $(package)_config_opts_linux=--with-pic
 endef

-define $(package)_preprocess_cmds
-  patch -p0 < $($(package)_patch_dir)/visibility.patch
-endef
-
 define $(package)_config_cmds
  $($(package)_autoconf) AR_FLAGS=$($(package)_arflags)
 endef
@@ -25,12 +21,7 @@ define $(package)_build_cmds
 endef

 define $(package)_stage_cmds
-  $(MAKE) DESTDIR=$($(package)_staging_dir) -C src install-libLTLIBRARIES install-nobase_includeHEADERS &&\
-  $(MAKE) DESTDIR=$($(package)_staging_dir) install-pkgconfigDATA
+  $(MAKE) DESTDIR=$($(package)_staging_dir) -C src install-nobase_includeHEADERS &&\
+  $(MAKE) DESTDIR=$($(package)_staging_dir) install-pkgconfigDATA &&\
+  cp src/.libs/libprotobuf.a $($(package)_staging_prefix_dir)/lib/
 endef
-
-define $(package)_postprocess_cmds
-  rm lib/libprotoc.a &&\
-  rm lib/*.la
-endef
-
@@ -24,7 +24,7 @@ define $(package)_preprocess_cmds
 endef

 define $(package)_config_cmds
-  $($(package)_autoconf) ac_cv_func_getentropy=no
+  $($(package)_autoconf) ac_cv_func_getentropy=no AR_FLAGS=$($(package)_arflags)
 endef

 define $(package)_build_cmds
@@ -1,29 +0,0 @@
-package=unwind
-$(package)_version=1.5.0
-$(package)_download_path=https://download.savannah.nongnu.org/releases/libunwind
-$(package)_file_name=lib$(package)-$($(package)_version).tar.gz
-$(package)_sha256_hash=90337653d92d4a13de590781371c604f9031cdb50520366aa1e3a91e1efb1017
-$(package)_patches=fix_obj_order.patch
-
-define $(package)_preprocess_cmds
-  patch -p0 < $($(package)_patch_dir)/fix_obj_order.patch
-endef
-
-define $(package)_config_cmds
-  cp -f $(BASEDIR)/config.guess config/config.guess &&\
-  cp -f $(BASEDIR)/config.sub config/config.sub &&\
-  $($(package)_autoconf) --disable-shared --enable-static --disable-tests --disable-documentation AR_FLAGS=$($(package)_arflags)
-endef
-
-define $(package)_build_cmds
-  $(MAKE)
-endef
-
-define $(package)_stage_cmds
-  $(MAKE) DESTDIR=$($(package)_staging_dir) install
-endef
-
-define $(package)_postprocess_cmds
-  rm lib/*.la
-endef
-
@@ -1,21 +0,0 @@
-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
@@ -1,21 +1,16 @@
 package=zeromq
-$(package)_version=4.3.4
+$(package)_version=4.3.5
 $(package)_download_path=https://github.com/zeromq/libzmq/releases/download/v$($(package)_version)/
 $(package)_file_name=$(package)-$($(package)_version).tar.gz
-$(package)_sha256_hash=c593001a89f5a85dd2ddf564805deb860e02471171b3f204944857336295c3e5
-$(package)_patches=06aba27b04c5822cb88a69677382a0f053367143.patch
+$(package)_sha256_hash=6653ef5910f17954861fe72332e68b03ca6e4d9c7160eb3a8de5a5a913bfab43

 define $(package)_set_vars
-  $(package)_config_opts=--without-documentation --disable-shared --without-libsodium --disable-curve
+  $(package)_config_opts=--without-documentation --disable-shared --without-libsodium --disable-curve --with-cv-impl=pthread
  $(package)_config_opts_linux=--with-pic
  $(package)_config_opts_freebsd=--with-pic
  $(package)_cxxflags=-std=c++11
 endef

-define $(package)_preprocess_cmds
-  patch -p1 < $($(package)_patch_dir)/06aba27b04c5822cb88a69677382a0f053367143.patch
-endef
-
 define $(package)_config_cmds
  $($(package)_autoconf) AR_FLAGS=$($(package)_arflags)
 endef
@@ -0,0 +1,15 @@
+CMake 3.10.2 compatibility, see:
+https://github.com/Kitware/CMake/blob/c1e087a9d3af74299d7681c9f9de59e5977a1539/Modules/Platform/Android-Determine.cmake#L105
+
+diff --git a/build/tools/make_standalone_toolchain.py b/build/tools/make_standalone_toolchain.py
+index b8172b2..1984595 100755
+--- a/build/tools/make_standalone_toolchain.py
+++ b/build/tools/make_standalone_toolchain.py
+@@ -208,6 +208,7 @@ def make_clang_scripts(install_dir, triple, api, windows):
+ 
+     target = '-'.join([arch, 'none', os_name, env])
+     common_flags = '-target {}{}'.format(target, api)
+    common_flags += ' -D__ANDROID_API__={}'.format(api)
+ 
+     # We only need mstackrealign to fix issues on 32-bit x86 pre-24. After 24,
+     # this consumes an extra register unnecessarily, which can cause issues for
@@ -1,67 +0,0 @@
-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(
@@ -1,37 +0,0 @@
-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
@@ -1,13 +0,0 @@
-diff --git a/preload/configure b/preload/configure
-index aab5c77..e20b8f0 100755
--- a/preload/configure
-+++ b/preload/configure
-@@ -588,7 +588,7 @@ MAKEFLAGS=
- PACKAGE_NAME='libiconv'
- PACKAGE_TARNAME='libiconv'
- PACKAGE_VERSION='0'
-PACKAGE_STRING='libiconv 0'
-+PACKAGE_STRING='libiconv0'
- PACKAGE_BUGREPORT=''
- PACKAGE_URL=''
-
@@ -1,29 +0,0 @@
--- 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,12 @@
+diff --git a/cctools/ld64/src/ld/Options.cpp b/cctools/ld64/src/ld/Options.cpp
+index 3bb8324..033760d 100644
+--- a/cctools/ld64/src/ld/Options.cpp
+++ b/cctools/ld64/src/ld/Options.cpp
+@@ -4279,7 +4279,6 @@ void Options::buildSearchPaths(int argc, const char* argv[])
+ 			fVerbose = true;
+ 			extern const char ldVersionString[];
+ 			fprintf(stderr, "%s", ldVersionString);
+-			fprintf(stderr, "BUILD "  __TIME__ " "  __DATE__"\n");
+ 			fprintf(stderr, "configured to support archs: %s\n", ALL_SUPPORTED_ARCHS);
+ 			 // if only -v specified, exit cleanly
+ 			 if ( argc == 2 ) {
@@ -1,86 +0,0 @@
--- 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,31 @@
+diff --git a/src/llvm/CMakeLists.txt b/src/llvm/CMakeLists.txt
+index ab92717c8..4ad621ea3 100644
+--- a/src/llvm/CMakeLists.txt
+++ b/src/llvm/CMakeLists.txt
+@@ -752,9 +752,10 @@ set(LLVM_SRPM_USER_BINARY_SPECFILE ${CMAKE_CURRENT_SOURCE_DIR}/llvm.spec.in
+ set(LLVM_SRPM_BINARY_SPECFILE ${CMAKE_CURRENT_BINARY_DIR}/llvm.spec)
+ set(LLVM_SRPM_DIR "${CMAKE_CURRENT_BINARY_DIR}/srpm")
+ 
+-# SVN_REVISION and GIT_COMMIT get set by the call to add_version_info_from_vcs.
+-# DUMMY_VAR contains a version string which we don't care about.
+-add_version_info_from_vcs(DUMMY_VAR)
+# A call to add_version_info_from_vcs() was removed, leaving SVN_REVISION
+# and GIT_COMMIT unset. Accordingly, LLVM_RPM_SPEC_REVISION is left empty.
+# This variable appears to be unused. Since it may be used in a future
+# update of native_libtapi this change serves as a precautionairy measure.
+ if ( SVN_REVISION )
+   set(LLVM_RPM_SPEC_REVISION "r${SVN_REVISION}")
+ elseif ( GIT_COMMIT )
+diff --git a/src/llvm/cmake/modules/GenerateVersionFromCVS.cmake b/src/llvm/cmake/modules/GenerateVersionFromCVS.cmake
+index 6b1c71983..e16326ed6 100644
+--- a/src/llvm/cmake/modules/GenerateVersionFromCVS.cmake
+++ b/src/llvm/cmake/modules/GenerateVersionFromCVS.cmake
+@@ -24,7 +24,7 @@ include(VersionFromVCS)
+ set(ENV{TERM} "dumb")
+ 
+ function(append_info name path)
+-  add_version_info_from_vcs(REVISION ${path})
+  set(REVISION "git-0000000")
+   string(STRIP "${REVISION}" REVISION)
+   file(APPEND "${HEADER_FILE}.txt"
+     "#define ${name} \"${REVISION}\"\n")
@@ -1,72 +0,0 @@
-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)))
@@ -1,159 +0,0 @@
--- src/google/protobuf/descriptor.cc.O	2018-07-30 22:16:10.000000000 +0000
-+++ src/google/protobuf/descriptor.cc	2022-05-06 13:38:14.827309092 +0000
-@@ -32,6 +32,9 @@
- //  Based on original Protocol Buffers design by
- //  Sanjay Ghemawat, Jeff Dean, and others.
- 
-+#if defined(__APPLE__) && defined(__arm64__)
-+#pragma GCC visibility push(hidden)
-+#endif
- #include <algorithm>
- #include <functional>
- #include <google/protobuf/stubs/hash.h>
-@@ -7274,3 +7277,6 @@
- 
- }  // namespace protobuf
- }  // namespace google
-+#if defined(__APPLE__) && defined(__arm64__)
-+#pragma GCC visibility pop
-+#endif
--- src/google/protobuf/extension_set.cc.O	2018-07-23 20:56:42.000000000 +0000
-+++ src/google/protobuf/extension_set.cc	2022-05-06 14:48:55.369877050 +0000
-@@ -32,6 +32,9 @@
- //  Based on original Protocol Buffers design by
- //  Sanjay Ghemawat, Jeff Dean, and others.
- 
-+#if defined(__APPLE__) && defined(__arm64__)
-+#pragma GCC visibility push(hidden)
-+#endif
- #include <google/protobuf/stubs/hash.h>
- #include <tuple>
- #include <utility>
-@@ -1914,3 +1917,6 @@
- }  // namespace internal
- }  // namespace protobuf
- }  // namespace google
-+#if defined(__APPLE__) && defined(__arm64__)
-+#pragma GCC visibility pop
-+#endif
--- src/google/protobuf/extension_set_heavy.cc.O	2018-07-30 22:16:10.000000000 +0000
-+++ src/google/protobuf/extension_set_heavy.cc	2022-05-06 14:14:27.847320946 +0000
-@@ -35,6 +35,10 @@
- // Contains methods defined in extension_set.h which cannot be part of the
- // lite library because they use descriptors or reflection.
- 
-+#if defined(__APPLE__) && defined(__arm64__)
-+#pragma GCC visibility push(hidden)
-+#endif
-+
- #include <google/protobuf/stubs/casts.h>
- #include <google/protobuf/descriptor.pb.h>
- #include <google/protobuf/io/coded_stream.h>
-@@ -814,3 +818,6 @@
- }  // namespace internal
- }  // namespace protobuf
- }  // namespace google
-+#if defined(__APPLE__) && defined(__arm64__)
-+#pragma GCC visibility pop
-+#endif
--- src/google/protobuf/generated_message_reflection.cc.O	2018-07-23 20:56:42.000000000 +0000
-+++ src/google/protobuf/generated_message_reflection.cc	2022-05-06 13:38:49.655540772 +0000
-@@ -32,6 +32,9 @@
- //  Based on original Protocol Buffers design by
- //  Sanjay Ghemawat, Jeff Dean, and others.
- 
-+#if defined(__APPLE__) && defined(__arm64__)
-+#pragma GCC visibility push(hidden)
-+#endif
- #include <algorithm>
- #include <set>
- 
-@@ -2420,3 +2423,6 @@
- }  // namespace internal
- }  // namespace protobuf
- }  // namespace google
-+#if defined(__APPLE__) && defined(__arm64__)
-+#pragma GCC visibility pop
-+#endif
--- src/google/protobuf/map_field.cc.O	2018-07-23 20:56:42.000000000 +0000
-+++ src/google/protobuf/map_field.cc	2022-05-06 13:34:44.913905697 +0000
-@@ -28,6 +28,10 @@
- // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- 
-+#if defined(__APPLE__) && defined(__arm64__)
-+#pragma GCC visibility push(hidden)
-+#endif
-+
- #include <google/protobuf/map_field.h>
- #include <google/protobuf/map_field_inl.h>
- 
-@@ -462,3 +466,6 @@
- }  // namespace internal
- }  // namespace protobuf
- }  // namespace google
-+#if defined(__APPLE__) && defined(__arm64__)
-+#pragma GCC visibility pop
-+#endif
--- src/google/protobuf/text_format.cc.O	2018-07-30 22:16:11.000000000 +0000
-+++ src/google/protobuf/text_format.cc	2022-05-06 13:34:58.881999517 +0000
-@@ -32,6 +32,10 @@
- //  Based on original Protocol Buffers design by
- //  Sanjay Ghemawat, Jeff Dean, and others.
- 
-+#if defined(__APPLE__) && defined(__arm64__)
-+#pragma GCC visibility push(hidden)
-+#endif
-+
- #include <algorithm>
- #include <float.h>
- #include <math.h>
-@@ -2258,3 +2262,6 @@
- 
- }  // namespace protobuf
- }  // namespace google
-+#if defined(__APPLE__) && defined(__arm64__)
-+#pragma GCC visibility pop
-+#endif
--- src/google/protobuf/wire_format.cc.O	2018-07-23 20:56:42.000000000 +0000
-+++ src/google/protobuf/wire_format.cc	2022-05-06 13:06:23.294219228 +0000
-@@ -32,6 +32,10 @@
- //  Based on original Protocol Buffers design by
- //  Sanjay Ghemawat, Jeff Dean, and others.
- 
-+#if defined(__APPLE__) && defined(__arm64__)
-+#pragma GCC visibility push(hidden)
-+#endif
-+
- #include <stack>
- #include <string>
- #include <vector>
-@@ -1445,3 +1449,7 @@
- }  // namespace internal
- }  // namespace protobuf
- }  // namespace google
-+
-+#if defined(__APPLE__) && defined(__arm64__)
-+#pragma GCC visibility pop
-+#endif
--- src/google/protobuf/stubs/status.cc.O	2018-07-23 20:56:42.000000000 +0000
-+++ src/google/protobuf/stubs/status.cc	2022-05-06 15:18:53.393208814 +0000
-@@ -27,6 +27,11 @@
- // 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.
-+
-+#if defined(__APPLE__) && defined(__arm64__)
-+#pragma GCC visibility push(hidden)
-+#endif
-+
- #include <google/protobuf/stubs/status.h>
- 
- #include <ostream>
-@@ -132,3 +137,6 @@
- }  // namespace util
- }  // namespace protobuf
- }  // namespace google
-+#if defined(__APPLE__) && defined(__arm64__)
-+#pragma GCC visibility pop
-+#endif
@@ -1,11 +0,0 @@
--- config/ltmain.sh.0	2020-11-10 17:25:26.000000000 +0100
-+++ config/ltmain.sh	2021-09-11 19:39:36.000000000 +0200
-@@ -10768,6 +10768,8 @@
- 	fi
- 	func_to_tool_file "$oldlib" func_convert_file_msys_to_w32
- 	tool_oldlib=$func_to_tool_file_result
-+	oldobjs=`for obj in $oldobjs; do echo $obj; done | sort`
-+	oldobjs=" `echo $oldobjs`"
- 	eval cmds=\"$old_archive_cmds\"
- 
- 	func_len " $cmds"
@@ -1,22 +0,0 @@
-From 06aba27b04c5822cb88a69677382a0f053367143 Mon Sep 17 00:00:00 2001
-From: sabotagebeats <27985126+sabotagebeats@users.noreply.github.com>
-Date: Thu, 22 Jul 2021 21:53:19 -0700
-Subject: [PATCH] fix: building libzmq fails with error src/clock.cpp:131:16:
- error: unused variable 'nsecs_per_usec'
-
---
- src/clock.cpp | 1 +
- 1 file changed, 1 insertion(+)
-
-diff --git a/src/clock.cpp b/src/clock.cpp
-index 93da90a8e..63c0100a5 100644
--- a/src/clock.cpp
-+++ b/src/clock.cpp
-@@ -195,6 +195,7 @@ uint64_t zmq::clock_t::now_us ()
- 
- #else
- 
-+    LIBZMQ_UNUSED (nsecs_per_usec);
-     //  Use POSIX gettimeofday function to get precise time.
-     struct timeval tv;
-     int rc = gettimeofday (&tv, NULL);
@@ -1,29 +0,0 @@
-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
@@ -1,5 +1,5 @@
 # Set the system name to one of Android, Darwin, FreeBSD, Linux, or Windows
-SET(CMAKE_SYSTEM_NAME @depends@)
+SET(CMAKE_SYSTEM_NAME @cmake_system_name@)
 SET(CMAKE_SYSTEM_PROCESSOR @arch@)
 SET(CMAKE_BUILD_TYPE @release_type@)

@@ -27,12 +27,6 @@ SET(Terminfo_LIBRARY @prefix@/lib/libtinfo.a)
 SET(UNBOUND_INCLUDE_DIR @prefix@/include)
 SET(UNBOUND_LIBRARIES @prefix@/lib/libunbound.a)

-if(NOT CMAKE_SYSTEM_NAME STREQUAL "Android")
-SET(LIBUNWIND_INCLUDE_DIR @prefix@/include)
-SET(LIBUNWIND_LIBRARIES @prefix@/lib/libunwind.a)
-SET(LIBUNWIND_LIBRARY_DIRS @prefix@/lib)
-
-if(NOT CMAKE_SYSTEM_NAME STREQUAL "FreeBSD")
 SET(LIBUSB-1.0_LIBRARY @prefix@/lib/libusb-1.0.a)
 SET(LIBUDEV_LIBRARY @prefix@/lib/libudev.a)

@@ -41,8 +35,11 @@ SET(Protobuf_PROTOC_EXECUTABLE @prefix@/native/bin/protoc CACHE FILEPATH "Path t
 SET(Protobuf_INCLUDE_DIR @prefix@/include CACHE PATH "Protobuf include dir")
 SET(Protobuf_INCLUDE_DIRS @prefix@/include CACHE PATH "Protobuf include dir")
 SET(Protobuf_LIBRARY @prefix@/lib/libprotobuf.a CACHE FILEPATH "Protobuf library")
-endif()

+if(NOT CMAKE_SYSTEM_NAME STREQUAL "Android")
+SET(LIBUNWIND_INCLUDE_DIR @prefix@/include)
+SET(LIBUNWIND_LIBRARIES @prefix@/lib/libunwind.a)
+SET(LIBUNWIND_LIBRARY_DIRS @prefix@/lib)
 endif()

 SET(ZMQ_INCLUDE_PATH @prefix@/include)
@@ -68,15 +65,15 @@ set (CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY) # Find includes in target
 # specify the cross compiler to be used. Darwin uses clang provided by the SDK.
 if(CMAKE_SYSTEM_NAME STREQUAL "Darwin")
  if(ARCHITECTURE STREQUAL "aarch64")
-    SET(CLANG_TARGET "arm64-apple-darwin11")
-    SET(CONF_TRIPLE "aarch64-apple-darwin11")
+    SET(CLANG_TARGET "arm64-apple-darwin")
+    SET(CONF_TRIPLE "aarch64-apple-darwin")
    SET(BUILD_TAG "mac-armv8")
    SET(CMAKE_OSX_ARCHITECTURES "arm64")
    set(ARM ON)
    set(ARM_ID "armv8-a")
  else()
-    SET(CLANG_TARGET "x86_64-apple-darwin11")
-    SET(CONF_TRIPLE "x86_64-apple-darwin11")
+    SET(CLANG_TARGET "x86_64-apple-darwin")
+    SET(CONF_TRIPLE "x86_64-apple-darwin")
    SET(BUILD_TAG "mac-x64")
    SET(CMAKE_OSX_ARCHITECTURES "x86_64")
  endif()
@@ -94,8 +91,8 @@ if(CMAKE_SYSTEM_NAME STREQUAL "Darwin")
  SET(BREW OFF)
  SET(PORT OFF)
  SET(CMAKE_OSX_SYSROOT "@prefix@/native/SDK/")
-  SET(CMAKE_OSX_DEPLOYMENT_TARGET "10.08")
-  SET(CMAKE_CXX_STANDARD 14)
+  SET(CMAKE_OSX_DEPLOYMENT_TARGET "10.13")
+  SET(CMAKE_CXX_STANDARD 17)
  SET(LLVM_ENABLE_PIC OFF)
  SET(LLVM_ENABLE_PIE OFF)
 elseif(CMAKE_SYSTEM_NAME STREQUAL "Android")
@@ -0,0 +1,31 @@
+#!/bin/bash
+
+# Get the git information
+TAG=`git tag -l --points-at HEAD`
+COMMIT=`git rev-parse --short=9 HEAD`
+
+# Build the 64-bit Windows release
+USE_DEVICE_TREZOR=OFF make depends target=x86_64-w64-mingw32 -j12
+pushd ./build/x86_64-w64-mingw32/release/bin > /dev/null
+zip -ur ~/releases/salvium-${TAG}-win64.zip salviumd.exe salvium-wallet-cli.exe salvium-wallet-rpc.exe
+popd > /dev/null
+
+# Build the 64-bit Apple Silicon release
+USE_DEVICE_TREZOR=OFF make depends target=aarch64-apple-darwin -j12
+pushd ./build/aarch64-apple-darwin/release/bin > /dev/null
+zip -ur ~/releases/salvium-${TAG}-macos-arm64.zip salviumd salvium-wallet-cli salvium-wallet-rpc
+popd > /dev/null
+
+# Build the 64-bit MacOS Intel Silicon release
+USE_DEVICE_TREZOR=OFF make depends target=x86_64-apple-darwin -j12
+pushd ./build/x86_64-apple-darwin/release/bin > /dev/null
+zip -ur ~/releases/salvium-${TAG}-macos-x86_64.zip salviumd salvium-wallet-cli salvium-wallet-rpc
+popd > /dev/null
+
+# Build the 64-bit Linux release
+USE_DEVICE_TREZOR=OFF make depends target=x86_64-linux-gnu -j12
+pushd ./build/x86_64-linux-gnu/release/bin > /dev/null
+zip -ur ~/releases/salvium-${TAG}-linux-x86_64.zip salviumd salvium-wallet-cli salvium-wallet-rpc
+popd > /dev/null
+
+# Finish
@@ -1,4 +1,5 @@
 // Copyright (c) 2014-2023, The Monero Project
+// Portions Copyright (c) 2023-2024, Salvium (author: SRCG)
 //
 // All rights reserved.
 //
@@ -1914,8 +1915,8 @@ public:
   */
  virtual uint64_t get_database_size() const = 0;

-  virtual int get_yield_block_info(const uint64_t height, yield_block_info& ybi) = 0;
-  virtual int get_yield_tx_info(const uint64_t height, std::vector<yield_tx_info>& yti_container) = 0;
+  virtual int get_yield_block_info(const uint64_t height, yield_block_info& ybi) const = 0;
+  virtual int get_yield_tx_info(const uint64_t height, std::vector<yield_tx_info>& yti_container) const = 0;

  
  /**
@@ -1,5 +1,5 @@
 // Copyright (c) 2014-2023, The Monero Project
-// Portions Copyright (c) 2023, Salvium (author: SRCG)
+// Portions Copyright (c) 2023-2024, Salvium (author: SRCG)
 // All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without modification, are
@@ -800,7 +800,7 @@ estim:
  return threshold_size;
 }

-int BlockchainLMDB::get_yield_block_info(const uint64_t height, yield_block_info& ybi)
+int BlockchainLMDB::get_yield_block_info(const uint64_t height, yield_block_info& ybi) const
 {
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  check_open();
@@ -825,11 +825,13 @@ int BlockchainLMDB::get_yield_block_info(const uint64_t height, yield_block_info
  yield_block_info *p = (yield_block_info*)v.mv_data;
  ybi = *p;

+  TXN_POSTFIX_RDONLY();
+
  // Return success to caller
  return ret;
 }

-int BlockchainLMDB::get_yield_tx_info(const uint64_t height, std::vector<yield_tx_info>& yti_container)
+int BlockchainLMDB::get_yield_tx_info(const uint64_t height, std::vector<yield_tx_info>& yti_container) const
 {
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  check_open();
@@ -858,6 +860,8 @@ int BlockchainLMDB::get_yield_tx_info(const uint64_t height, std::vector<yield_t
    yti_container.emplace_back(*p);
  }

+  TXN_POSTFIX_RDONLY();
+
  // Return success to caller
  return 0;
 }
@@ -1179,21 +1183,38 @@ 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::MINER) {
+
+    // Update the circulating supply tally because of potentially burnt block_reward proportion
+    MDB_val_copy<uint64_t> source_idx(cryptonote::asset_id_from_type("SAL"));
+    boost::multiprecision::int128_t source_tally = 0;
+    result = read_circulating_supply_data(m_cur_circ_supply_tally, source_idx, source_tally);
+    if (result && (m_height>0 || result != MDB_NOTFOUND))
+      throw0(DB_ERROR(lmdb_error("Failed to get circulating supply tally when adding db transaction: ", result).c_str()));
+    boost::multiprecision::int128_t final_source_tally = source_tally;
+    for (const auto& out: tx.vout) {
+
+      // Sanity check - prevent overflow
+      if (final_source_tally > final_source_tally + out.amount)
+        throw0(DB_ERROR("numeric overflow detected when adding miner_tx for db transaction")); 
+
+      // Fetch the amount for this output
+      final_source_tally += out.amount;
+    }
+    write_circulating_supply_data(m_cur_circ_supply_tally, source_idx, final_source_tally);
+    LOG_PRINT_L1("tx ID " << tx_id << "\n\tTally before burn = " << source_tally.str() << "\n\tTally after burn = " << final_source_tally.str());
+  }
+  
  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));
    boost::multiprecision::int128_t source_tally = 0;
    result = read_circulating_supply_data(m_cur_circ_supply_tally, source_idx, source_tally);
-    boost::multiprecision::int128_t final_source_tally = source_tally - tx.amount_burnt;
+    boost::multiprecision::int128_t final_source_tally = source_tally - tx.amount_burnt - tx.rct_signatures.txnFee;
    boost::multiprecision::int128_t coinbase = get_block_already_generated_coins(m_height-1);
-    if (source_tally == 0 && result == MDB_NOTFOUND) {
-      if (tx.source_asset_type == "SAL") {
-        final_source_tally += coinbase;
-      } else {
-        throw0(DB_ERROR("burn underflow - asset balance is zero for non-SAL asset"));
-      }
-    }
+    if (result)
+      throw0(DB_ERROR(lmdb_error("Failed to get circulating supply tally when adding db transaction: ", result).c_str()));
    write_circulating_supply_data(m_cur_circ_supply_tally, source_idx, final_source_tally);
    LOG_PRINT_L1("tx ID " << tx_id << "\n\tTally before burn = " << source_tally.str() << "\n\tTally after burn = " << final_source_tally.str());
  }
@@ -1219,6 +1240,8 @@ uint64_t BlockchainLMDB::add_transaction_data(const crypto::hash& blk_hash, cons
      MDB_val_copy<uint64_t> source_idx(asset.first);
      boost::multiprecision::int128_t source_tally = 0;
      result = read_circulating_supply_data(m_cur_circ_supply_tally, source_idx, source_tally);
+      if (result)
+        throw0(DB_ERROR(lmdb_error("Failed to get circulating supply tally when adding db transaction: ", result).c_str()));
      boost::multiprecision::int128_t final_source_tally = source_tally + asset.second;
      boost::multiprecision::int128_t coinbase = get_block_already_generated_coins(m_height-1);
      if (source_tally == 0 && result == MDB_NOTFOUND) {
@@ -1238,7 +1261,17 @@ uint64_t BlockchainLMDB::add_transaction_data(const crypto::hash& blk_hash, cons
    yield_tx_info yield_data;
    yield_data.block_height = m_height;
    yield_data.tx_hash = tx_hash;
-    yield_data.return_address = tx.return_address;
+    if (tx.version == TRANSACTION_VERSION_2_OUTS) {
+      if (tx.return_address == crypto::null_pkey)
+        throw0(DB_ERROR("missing return_address entry (needed to create yield data for PROTOCOL_TX)  - v2 STAKE"));
+      yield_data.return_address = tx.return_address;
+    } else if (tx.version >= TRANSACTION_VERSION_N_OUTS) {
+      if (tx.return_address_list.empty())
+        throw0(DB_ERROR("no return_address_list entry (needed to create yield data for the PROTOCOL_TX)"));
+      else if (tx.return_address_list.size() > 1)
+        throw0(DB_ERROR("too many return_address_list entries provided (only one needed to create yield data for the PROTOCOL_TX)"));
+      yield_data.return_address = tx.return_address_list[0];
+    }
    yield_data.locked_coins = tx.amount_burnt;
    if (tx.vin.empty())
      throw0(DB_ERROR("tx.vin is empty (needed to create yield data for the PROTOCOL_TX)"));
@@ -1340,7 +1373,29 @@ void BlockchainLMDB::remove_transaction_data(const crypto::hash& tx_hash, const
        throw1(DB_ERROR(lmdb_error("Failed to add removal of prunable hash tx to db transaction: ", result).c_str()));
  }

-  if (tx.type == cryptonote::transaction_type::CONVERT || tx.type == cryptonote::transaction_type::BURN) {
+  if (tx.type == cryptonote::transaction_type::MINER) {
+
+    // Update the circulating supply tally because of potentially burnt block_reward proportion
+    MDB_val_copy<uint64_t> source_idx(cryptonote::asset_id_from_type("SAL"));
+    boost::multiprecision::int128_t source_tally = 0;
+    result = read_circulating_supply_data(m_cur_circ_supply_tally, source_idx, source_tally);
+    if (result && (m_height>0 || result != MDB_NOTFOUND))
+      throw0(DB_ERROR(lmdb_error("remove_transaction_data() - Failed to get circulating supply tally when removing db transaction: ", result).c_str()));
+    boost::multiprecision::int128_t final_source_tally = source_tally;
+    for (const auto& out: tx.vout) {
+
+      // Sanity check - prevent underflow
+      if (final_source_tally < final_source_tally - out.amount)
+        throw0(DB_ERROR("remove_transaction_data() - numeric underflow detected when removing miner_tx for db transaction")); 
+
+      // Fetch the amount for this output
+      final_source_tally -= out.amount;
+    }
+    write_circulating_supply_data(m_cur_circ_supply_tally, source_idx, final_source_tally);
+    LOG_PRINT_L1("tx ID " << tip->data.tx_id << "\n\tTally before burn = " << source_tally.str() << "\n\tTally after burn = " << final_source_tally.str());
+  }
+  
+  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));
@@ -1348,8 +1403,10 @@ void BlockchainLMDB::remove_transaction_data(const crypto::hash& tx_hash, const
    result = read_circulating_supply_data(m_cur_circ_supply_tally, source_idx, source_tally);
    if (result == MDB_NOTFOUND)
      throw0(DB_ERROR("remove_transaction_data() - minted asset not found"));
-    boost::multiprecision::int128_t final_source_tally = source_tally + tx.amount_burnt;
-    boost::multiprecision::int128_t coinbase = get_block_already_generated_coins(m_height-1);
+    // Sanity check - prevent overflow
+    if (source_tally > source_tally + tx.amount_burnt + tx.rct_signatures.txnFee)
+      throw0(DB_ERROR("remove_transaction_data() - numeric overflow detected when processing C/B/S for db transaction")); 
+    boost::multiprecision::int128_t final_source_tally = source_tally + tx.amount_burnt + tx.rct_signatures.txnFee;
    write_circulating_supply_data(m_cur_circ_supply_tally, source_idx, final_source_tally);
    LOG_PRINT_L1("tx ID " << tip->data.tx_id << "\n\tTally before remint =" << source_tally.str() << "\n\tTally after remint =" << final_source_tally.str());
  }
@@ -1399,17 +1456,28 @@ void BlockchainLMDB::remove_transaction_data(const crypto::hash& tx_hash, const
      throw1(DB_ERROR(lmdb_error("Failed to add removal of tx outputs to db transaction: ", result).c_str()));
  }

+  // SRCG: The following code is designed to clean up the STAKE transactions, but it is very poorly written
+  // Since transactions are ALWAYS supposed to be created in order, it stands that they should ALWAYS be
+  // removed in REVERSE ORDER. Yet the following loop starts from the beginning - this is the worst possible
+  // implementation in performance terms, since it will ALWAYS take the longest possible time to remove the
+  // correct TX.
+
+  // RECODE TO START FROM THE END OF THE DATABASE TABLE, AND THROW AN EXCEPTION IF YOU DO NOT MATCH FIRST TIME!
+  
  // Is there yield_tx data to remove?
  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;
+    MDB_cursor_op op = MDB_SET;
    while (1) {
-      result = mdb_cursor_get(m_cur_yield_txs, &val_height, &v, MDB_SET);
-      if (result == MDB_NOTFOUND)
-        break;
-      else if (result)
+      result = mdb_cursor_get(m_cur_yield_txs, &val_height, &v, op);
+      if (result == MDB_NOTFOUND) {
+        throw1(DB_ERROR("Failed to locate yield tx for removal from db transaction"));
+      } else if (result) {
        throw1(DB_ERROR(lmdb_error("Failed to locate yield_tx data for removal: ", result).c_str()));
+      }
+      op = MDB_NEXT_DUP;
      const yield_tx_info yti = *(const yield_tx_info*)v.mv_data;
      if (yti.tx_hash == tx_hash) {
        result = mdb_cursor_del(m_cur_yield_txs, 0);
@@ -3415,11 +3483,13 @@ std::map<std::string,uint64_t> BlockchainLMDB::get_circulating_supply() const
  uint64_t m_coinbase = get_block_already_generated_coins(m_height-1);
  LOG_PRINT_L3("BlockchainLMDB::" << __func__ << " - mined supply for SAL = " << m_coinbase);

-  // SRCG: For V1, we can simply return this number, because there is no other source of coins
-  circulating_supply["SAL"] = m_coinbase;
-  return circulating_supply;
+  uint64_t staked_coins = 0;
+  yield_block_info ybi;
+  int result = get_yield_block_info(m_height-1, ybi);
+  if (result)
+    throw0(DB_ERROR(lmdb_error("Failed to get YBI when querying supply: ", result).c_str()));
+  staked_coins = ybi.locked_coins_tally;
  
-  /*
  check_open();
  
  TXN_PREFIX_RDONLY();
@@ -3427,8 +3497,6 @@ std::map<std::string,uint64_t> BlockchainLMDB::get_circulating_supply() const

  MDB_val k;
  MDB_val v;
-  int result = 0;
-
  MDB_cursor_op op = MDB_FIRST;
  while (1)
  {
@@ -3460,8 +3528,12 @@ std::map<std::string,uint64_t> BlockchainLMDB::get_circulating_supply() const
  if (circulating_supply.empty()) {
    circulating_supply["SAL"] = m_coinbase;
  }
+
+  // Adjust the supply to account for the staked coins
+  circulating_supply["STAKE"] = staked_coins;
+  
+  circulating_supply["BURN"] = m_coinbase - circulating_supply["SAL"] - circulating_supply["STAKE"];
  return circulating_supply;
-  */
 }

 uint64_t BlockchainLMDB::num_outputs() const
@@ -459,8 +459,8 @@ private:
  //void migrate_0_1();
  void cleanup_batch();

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

 private:
  MDB_env* m_env;
@@ -133,14 +133,27 @@ monero_private_headers(blockchain_stats
 	  ${blockchain_stats_private_headers})


+set(blockchain_scanner_sources
+  blockchain_scanner.cpp
+  )
+
+set(blockchain_scanner_private_headers)
+
+monero_private_headers(blockchain_scanner
+	  ${blockchain_scanner_private_headers})
+
+
 monero_add_executable(blockchain_import
  ${blockchain_import_sources}
  ${blockchain_import_private_headers})

 target_link_libraries(blockchain_import
  PRIVATE
+    crypto
+    cncrypto
    cryptonote_core
    blockchain_db
+    oracle
    version
    epee
    ${Boost_FILESYSTEM_LIBRARY}
@@ -166,8 +179,11 @@ monero_add_executable(blockchain_export

 target_link_libraries(blockchain_export
  PRIVATE
+    crypto
+    cncrypto
    cryptonote_core
    blockchain_db
+    oracle
    version
    epee
    ${Boost_FILESYSTEM_LIBRARY}
@@ -188,8 +204,11 @@ monero_add_executable(blockchain_blackball
 target_link_libraries(blockchain_blackball
  PRIVATE
    wallet
+    crypto
+    cncrypto
    cryptonote_core
    blockchain_db
+    oracle
    version
    epee
    ${Boost_FILESYSTEM_LIBRARY}
@@ -210,8 +229,11 @@ monero_add_executable(blockchain_usage

 target_link_libraries(blockchain_usage
  PRIVATE
+    crypto
+    cncrypto
    cryptonote_core
    blockchain_db
+    oracle
    version
    epee
    ${Boost_FILESYSTEM_LIBRARY}
@@ -233,6 +255,7 @@ target_link_libraries(blockchain_ancestry
  PRIVATE
    cryptonote_core
    blockchain_db
+    oracle
    version
    epee
    ${Boost_FILESYSTEM_LIBRARY}
@@ -254,6 +277,7 @@ target_link_libraries(blockchain_depth
  PRIVATE
    cryptonote_core
    blockchain_db
+    oracle
    version
    epee
    ${Boost_FILESYSTEM_LIBRARY}
@@ -267,6 +291,27 @@ set_property(TARGET blockchain_depth
 	OUTPUT_NAME "salvium-blockchain-depth")
 install(TARGETS blockchain_depth DESTINATION bin)

+monero_add_executable(blockchain_scanner
+  ${blockchain_scanner_sources}
+  ${blockchain_scanner_private_headers})
+
+target_link_libraries(blockchain_scanner
+  PRIVATE
+    cryptonote_core
+    blockchain_db
+    version
+    epee
+    ${Boost_FILESYSTEM_LIBRARY}
+    ${Boost_SYSTEM_LIBRARY}
+    ${Boost_THREAD_LIBRARY}
+    ${CMAKE_THREAD_LIBS_INIT}
+    ${EXTRA_LIBRARIES})
+
+set_property(TARGET blockchain_scanner
+	PROPERTY
+	OUTPUT_NAME "salvium-blockchain-scanner")
+install(TARGETS blockchain_scanner DESTINATION bin)
+
 monero_add_executable(blockchain_stats
  ${blockchain_stats_sources}
  ${blockchain_stats_private_headers})
@@ -275,6 +320,7 @@ target_link_libraries(blockchain_stats
  PRIVATE
    cryptonote_core
    blockchain_db
+    oracle
    version
    epee
    ${Boost_FILESYSTEM_LIBRARY}
@@ -294,8 +340,11 @@ monero_add_executable(blockchain_prune_known_spent_data

 target_link_libraries(blockchain_prune_known_spent_data
  PRIVATE
+    crypto
+    cncrypto
    cryptonote_core
    blockchain_db
+    oracle
    p2p
    version
    epee
@@ -321,8 +370,11 @@ install(TARGETS blockchain_prune DESTINATION bin)

 target_link_libraries(blockchain_prune
  PRIVATE
+    crypto
+    cncrypto
    cryptonote_core
    blockchain_db
+    oracle
    p2p
    version
    epee
@@ -449,9 +449,7 @@ int main(int argc, char* argv[])
  // because unlike blockchain_storage constructor, which takes a pointer to
  // tx_memory_pool, Blockchain's constructor takes tx_memory_pool object.
  LOG_PRINT_L0("Initializing source blockchain (BlockchainDB)");
-  std::unique_ptr<Blockchain> core_storage;
-  tx_memory_pool m_mempool(*core_storage);
-  core_storage.reset(new Blockchain(m_mempool));
+  std::unique_ptr<BlockchainAndPool> core_storage = std::make_unique<BlockchainAndPool>();
  BlockchainDB *db = new_db();
  if (db == NULL)
  {
@@ -472,7 +470,7 @@ int main(int argc, char* argv[])
    LOG_PRINT_L0("Error opening database: " << e.what());
    return 1;
  }
-  r = core_storage->init(db, net_type);
+  r = core_storage->blockchain.init(db, net_type);

  CHECK_AND_ASSERT_MES(r, 1, "Failed to initialize source blockchain storage");
  LOG_PRINT_L0("Source blockchain storage initialized OK");
@@ -716,7 +714,7 @@ int main(int argc, char* argv[])
  }

 done:
-  core_storage->deinit();
+  core_storage->blockchain.deinit();

  if (opt_show_cache_stats)
  MINFO("cache: txes " << std::to_string(cached_txes*100./total_txes)
@@ -959,7 +959,7 @@ static void open_db(const std::string &filename, MDB_env **env, MDB_txn **txn, M
  dbr = mdb_env_set_maxdbs(*env, 1);
  CHECK_AND_ASSERT_THROW_MES(!dbr, "Failed to set max env dbs: " + std::string(mdb_strerror(dbr)));
  const std::string actual_filename = filename;
-  MINFO("Opening monero blockchain at " << actual_filename);
+  MINFO("Opening Salvium blockchain at " << actual_filename);
  dbr = mdb_env_open(*env, actual_filename.c_str(), flags, 0664);
  CHECK_AND_ASSERT_THROW_MES(!dbr, "Failed to open rings database file '"
      + actual_filename + "': " + std::string(mdb_strerror(dbr)));
@@ -136,9 +136,7 @@ int main(int argc, char* argv[])
  // because unlike blockchain_storage constructor, which takes a pointer to
  // tx_memory_pool, Blockchain's constructor takes tx_memory_pool object.
  LOG_PRINT_L0("Initializing source blockchain (BlockchainDB)");
-  std::unique_ptr<Blockchain> core_storage;
-  tx_memory_pool m_mempool(*core_storage);
-  core_storage.reset(new Blockchain(m_mempool));
+  std::unique_ptr<BlockchainAndPool> core_storage = std::make_unique<BlockchainAndPool>();
  BlockchainDB *db = new_db();
  if (db == NULL)
  {
@@ -159,7 +157,7 @@ int main(int argc, char* argv[])
    LOG_PRINT_L0("Error opening database: " << e.what());
    return 1;
  }
-  r = core_storage->init(db, net_type);
+  r = core_storage->blockchain.init(db, net_type);

  CHECK_AND_ASSERT_MES(r, 1, "Failed to initialize source blockchain storage");
  LOG_PRINT_L0("Source blockchain storage initialized OK");
@@ -327,7 +325,7 @@ done:
  LOG_PRINT_L0("Average min depth for " << start_txids.size() << " transaction(s): " << cumulative_depth/(float)depths.size());
  LOG_PRINT_L0("Median min depth for " << start_txids.size() << " transaction(s): " << epee::misc_utils::median(depths));

-  core_storage->deinit();
+  core_storage->blockchain.deinit();
  return 0;

  CATCH_ENTRY("Depth query error", 1);
@@ -136,9 +136,7 @@ int main(int argc, char* argv[])
  // because unlike blockchain_storage constructor, which takes a pointer to
  // tx_memory_pool, Blockchain's constructor takes tx_memory_pool object.
  LOG_PRINT_L0("Initializing source blockchain (BlockchainDB)");
-  Blockchain* core_storage = NULL;
-  tx_memory_pool m_mempool(*core_storage);
-  core_storage = new Blockchain(m_mempool);
+  std::unique_ptr<BlockchainAndPool> core_storage = std::make_unique<BlockchainAndPool>();

  BlockchainDB* db = new_db();
  if (db == NULL)
@@ -162,9 +160,9 @@ int main(int argc, char* argv[])
    LOG_PRINT_L0("Error opening database: " << e.what());
    return 1;
  }
-  r = core_storage->init(db, opt_testnet ? cryptonote::TESTNET : opt_stagenet ? cryptonote::STAGENET : cryptonote::MAINNET);
+  r = core_storage->blockchain.init(db, opt_testnet ? cryptonote::TESTNET : opt_stagenet ? cryptonote::STAGENET : cryptonote::MAINNET);

-  if (core_storage->get_blockchain_pruning_seed() && !opt_blocks_dat)
+  if (core_storage->blockchain.get_blockchain_pruning_seed() && !opt_blocks_dat)
  {
    LOG_PRINT_L0("Blockchain is pruned, cannot export");
    return 1;
@@ -177,12 +175,12 @@ int main(int argc, char* argv[])
  if (opt_blocks_dat)
  {
    BlocksdatFile blocksdat;
-    r = blocksdat.store_blockchain_raw(core_storage, NULL, output_file_path, block_stop);
+    r = blocksdat.store_blockchain_raw(&core_storage->blockchain, NULL, output_file_path, block_stop);
  }
  else
  {
    BootstrapFile bootstrap;
-    r = bootstrap.store_blockchain_raw(core_storage, NULL, output_file_path, block_start, block_stop);
+    r = bootstrap.store_blockchain_raw(&core_storage->blockchain, NULL, output_file_path, block_start, block_stop);
  }
  CHECK_AND_ASSERT_MES(r, 1, "Failed to export blockchain raw data");
  LOG_PRINT_L0("Blockchain raw data exported OK");
@@ -524,15 +524,14 @@ int main(int argc, char* argv[])
  // because unlike blockchain_storage constructor, which takes a pointer to
  // tx_memory_pool, Blockchain's constructor takes tx_memory_pool object.
  MINFO("Initializing source blockchain (BlockchainDB)");
-  std::array<std::unique_ptr<Blockchain>, 2> core_storage;
-  Blockchain *blockchain = NULL;
-  tx_memory_pool m_mempool(*blockchain);
+  std::array<std::unique_ptr<BlockchainAndPool>, 2> core_storage{
+      std::make_unique<BlockchainAndPool>(),
+      std::make_unique<BlockchainAndPool>()};
+
  boost::filesystem::path paths[2];
  bool already_pruned = false;
  for (size_t n = 0; n < core_storage.size(); ++n)
  {
-    core_storage[n].reset(new Blockchain(m_mempool));
-
    BlockchainDB* db = new_db();
    if (db == NULL)
    {
@@ -577,12 +576,12 @@ int main(int argc, char* argv[])
      MERROR("Error opening database: " << e.what());
      return 1;
    }
-    r = core_storage[n]->init(db, net_type);
+    r = core_storage[n]->blockchain.init(db, net_type);

    std::string source_dest = n == 0 ? "source" : "pruned";
    CHECK_AND_ASSERT_MES(r, 1, "Failed to initialize " << source_dest << " blockchain storage");
    MINFO(source_dest << " blockchain storage initialized OK");
-    if (n == 0 && core_storage[0]->get_blockchain_pruning_seed())
+    if (n == 0 && core_storage[0]->blockchain.get_blockchain_pruning_seed())
    {
      if (!opt_copy_pruned_database)
      {
@@ -592,9 +591,9 @@ int main(int argc, char* argv[])
      already_pruned = true;
    }
  }
-  core_storage[0]->deinit();
+  core_storage[0]->blockchain.deinit();
  core_storage[0].reset(NULL);
-  core_storage[1]->deinit();
+  core_storage[1]->blockchain.deinit();
  core_storage[1].reset(NULL);

  MINFO("Pruning...");
@@ -160,9 +160,7 @@ int main(int argc, char* argv[])
  const std::string input = command_line::get_arg(vm, arg_input);

  LOG_PRINT_L0("Initializing source blockchain (BlockchainDB)");
-  std::unique_ptr<Blockchain> core_storage;
-  tx_memory_pool m_mempool(*core_storage);
-  core_storage.reset(new Blockchain(m_mempool));
+  std::unique_ptr<BlockchainAndPool> core_storage = std::make_unique<BlockchainAndPool>();
  BlockchainDB *db = new_db();
  if (db == NULL)
  {
@@ -182,7 +180,7 @@ int main(int argc, char* argv[])
    LOG_PRINT_L0("Error opening database: " << e.what());
    return 1;
  }
-  r = core_storage->init(db, net_type);
+  r = core_storage->blockchain.init(db, net_type);

  CHECK_AND_ASSERT_MES(r, 1, "Failed to initialize source blockchain storage");
  LOG_PRINT_L0("Source blockchain storage initialized OK");
@@ -280,7 +278,7 @@ int main(int argc, char* argv[])
  MINFO("Prunable outputs: " << num_prunable_outputs);

  LOG_PRINT_L0("Blockchain known spent data pruned OK");
-  core_storage->deinit();
+  core_storage->blockchain.deinit();
  return 0;

  CATCH_ENTRY("Error", 1);
@@ -0,0 +1,499 @@
+// Copyright (c) 2014-2019, The Monero Project
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without modification, are
+// permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this list of
+//    conditions and the following disclaimer.
+//
+// 2. 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.
+//
+// 3. Neither the name of the copyright holder 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 HOLDER OR CONTRIBUTORS 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 <boost/algorithm/string.hpp>
+#include <boost/filesystem.hpp>
+#include "common/command_line.h"
+#include "common/varint.h"
+#include "cryptonote_basic/cryptonote_boost_serialization.h"
+#include "cryptonote_core/tx_pool.h"
+#include "cryptonote_core/cryptonote_core.h"
+#include "cryptonote_core/cryptonote_tx_utils.h"
+#include "cryptonote_core/blockchain.h"
+#include "blockchain_db/blockchain_db.h"
+#include "oracle/pricing_record.h"
+#include "version.h"
+
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "bcutil"
+
+#define DELIM "|"
+
+namespace po = boost::program_options;
+using namespace epee;
+using namespace cryptonote;
+
+static bool stop_requested = false;
+
+int main(int argc, char* argv[])
+{
+  TRY_ENTRY();
+
+  epee::string_tools::set_module_name_and_folder(argv[0]);
+
+  uint32_t log_level = 0;
+  uint64_t block_start = 0;
+  uint64_t block_stop = 0;
+
+  tools::on_startup();
+
+  boost::filesystem::path output_file_path;
+
+  po::options_description desc_cmd_only("Command line options");
+  po::options_description desc_cmd_sett("Command line options and settings options");
+  const command_line::arg_descriptor<std::string> arg_log_level  = {"log-level",  "0-4 or categories", ""};
+  const command_line::arg_descriptor<uint64_t> arg_block_start  = {"block-start", "start at block number", block_start};
+  const command_line::arg_descriptor<uint64_t> arg_block_stop = {"block-stop", "Stop at block number", block_stop};
+  const command_line::arg_descriptor<std::string> arg_delimiter  = {"delimiter", "\"<string>\"", DELIM};
+
+  command_line::add_arg(desc_cmd_sett, cryptonote::arg_data_dir);
+  command_line::add_arg(desc_cmd_sett, cryptonote::arg_testnet_on);
+  command_line::add_arg(desc_cmd_sett, cryptonote::arg_stagenet_on);
+  command_line::add_arg(desc_cmd_sett, arg_log_level);
+  command_line::add_arg(desc_cmd_sett, arg_block_start);
+  command_line::add_arg(desc_cmd_sett, arg_block_stop);
+  command_line::add_arg(desc_cmd_sett, arg_delimiter);
+  command_line::add_arg(desc_cmd_only, command_line::arg_help);
+
+  po::options_description desc_options("Allowed options");
+  desc_options.add(desc_cmd_only).add(desc_cmd_sett);
+
+  po::variables_map vm;
+  bool r = command_line::handle_error_helper(desc_options, [&]()
+  {
+    auto parser = po::command_line_parser(argc, argv).options(desc_options);
+    po::store(parser.run(), vm);
+    po::notify(vm);
+    return true;
+  });
+  if (! r)
+    return 1;
+
+  if (command_line::get_arg(vm, command_line::arg_help))
+  {
+    std::cout << "Salvium '" << MONERO_RELEASE_NAME << "' (v" << MONERO_VERSION_FULL << ")" << ENDL << ENDL;
+    std::cout << desc_options << std::endl;
+    return 1;
+  }
+
+  mlog_configure(mlog_get_default_log_path("monero-blockchain-stats.log"), true);
+  if (!command_line::is_arg_defaulted(vm, arg_log_level))
+    mlog_set_log(command_line::get_arg(vm, arg_log_level).c_str());
+  else
+    mlog_set_log(std::string(std::to_string(log_level) + ",bcutil:INFO").c_str());
+
+  LOG_PRINT_L0("Starting...");
+
+  std::string opt_data_dir = command_line::get_arg(vm, cryptonote::arg_data_dir);
+  bool opt_testnet = command_line::get_arg(vm, cryptonote::arg_testnet_on);
+  bool opt_stagenet = command_line::get_arg(vm, cryptonote::arg_stagenet_on);
+  network_type net_type = opt_testnet ? TESTNET : opt_stagenet ? STAGENET : MAINNET;
+  block_start = command_line::get_arg(vm, arg_block_start);
+  block_stop = command_line::get_arg(vm, arg_block_stop);
+  std::string delimiter = command_line::get_arg(vm, arg_delimiter);
+
+  // If we wanted to use the memory pool, we would set up a fake_core.
+
+  // Use Blockchain instead of lower-level BlockchainDB for two reasons:
+  // 1. Blockchain has the init() method for easy setup
+  // 2. exporter needs to use get_current_blockchain_height(), get_block_id_by_height(), get_block_by_hash()
+  //
+  // cannot match blockchain_storage setup above with just one line,
+  // e.g.
+  //   Blockchain* core_storage = new Blockchain(NULL);
+  // because unlike blockchain_storage constructor, which takes a pointer to
+  // tx_memory_pool, Blockchain's constructor takes tx_memory_pool object.
+  LOG_PRINT_L0("Initializing source blockchain (BlockchainDB)");
+  std::unique_ptr<BlockchainAndPool> core_storage = std::make_unique<BlockchainAndPool>();
+
+  BlockchainDB* db = new_db();
+  if (db == NULL)
+  {
+    LOG_ERROR("Failed to initialize a database");
+    throw std::runtime_error("Failed to initialize a database");
+  }
+  LOG_PRINT_L0("database: LMDB");
+
+  boost::filesystem::path folder(opt_data_dir);
+  if (opt_stagenet) {
+    folder /= std::to_string(STAGENET_VERSION);
+  } else if (opt_testnet) {
+    folder /= std::to_string(TESTNET_VERSION);
+  }
+  folder /= db->get_db_name();
+  LOG_PRINT_L0("Loading blockchain from folder " << folder << " ...");
+  const std::string filename = folder.string();
+
+  try
+  {
+    db->open(filename, DBF_RDONLY);
+  }
+  catch (const std::exception& e)
+  {
+    LOG_PRINT_L0("Error opening database: " << e.what());
+    return 1;
+  }
+  r = core_storage->blockchain.init(db, opt_testnet ? cryptonote::TESTNET : opt_stagenet ? cryptonote::STAGENET : cryptonote::MAINNET);
+
+  CHECK_AND_ASSERT_MES(r, 1, "Failed to initialize source blockchain storage");
+  LOG_PRINT_L0("Source blockchain storage initialized OK");
+
+  tools::signal_handler::install([](int type) {
+    stop_requested = true;
+  });
+
+  const uint64_t db_height = db->height();
+  if (!block_stop)
+      block_stop = db_height;
+  MINFO("Starting from height " << block_start << ", stopping at height " << block_stop);
+
+/*
+ * The default output can be plotted with GnuPlot using these commands:
+set key autotitle columnhead
+set title "Salvium Blockchain Growth"
+set timefmt "%Y-%m-%d"
+set xdata time
+set xrange ["2014-04-17":*]
+set format x "%Y-%m-%d"
+set yrange [0:*]
+set y2range [0:*]
+set ylabel "Txs/Day"
+set y2label "Bytes"
+set y2tics nomirror
+plot 'stats.csv' index "DATA" using (timecolumn(1,"%Y-%m-%d")):4 with lines, '' using (timecolumn(1,"%Y-%m-%d")):7 axes x1y2 with lines
+ */
+
+  // spit out a comment that GnuPlot can use as an index
+  std::cout << ENDL << "# DATA" << ENDL;
+  std::cout << "Date" << delimiter << "Height" << delimiter << "Transaction ID" << delimiter << "Reason" << delimiter << "Extra Information";
+  std::cout << ENDL;
+
+#define MAX_INOUT	0xffffffff
+#define MAX_RINGS	0xffffffff
+
+  struct tm prevtm = {0}, currtm;
+  uint64_t prevsz = 0, currsz = 0;
+  uint64_t prevtxs = 0, currtxs = 0;
+  uint64_t currblks = 0;
+  uint32_t txhr[24] = {0};
+  unsigned int i;
+
+  for (uint64_t h = block_start; h < block_stop; ++h)
+  {
+    cryptonote::blobdata bd = db->get_block_blob_from_height(h);
+    cryptonote::block blk;
+    if (!cryptonote::parse_and_validate_block_from_blob(bd, blk))
+    {
+      LOG_PRINT_L0("Bad block from db");
+      return 1;
+    }
+    time_t tt = blk.timestamp;
+    char timebuf[64];
+    epee::misc_utils::get_gmt_time(tt, currtm);
+    if (!prevtm.tm_year)
+      prevtm = currtm;
+    // catch change of day
+    if (currtm.tm_mday > prevtm.tm_mday || (currtm.tm_mday == 1 && prevtm.tm_mday > 27))
+    {
+      // check for timestamp fudging around month ends
+      if (prevtm.tm_mday == 1 && currtm.tm_mday > 27)
+        goto skip;
+      strftime(timebuf, sizeof(timebuf), "%Y-%m-%d", &currtm);
+      prevtm = currtm;
+    }
+skip:
+    currsz += bd.size();
+    uint64_t coinbase_amount;
+    uint64_t tx_fee_amount = 0;
+    std::set<std::string> used_assets, miner_tx_assets, protocol_tx_assets;
+    std::map<size_t, std::vector<std::string>> used_tx_versions;
+    used_assets.insert("SAL");
+
+    // Check TX versions
+    if (blk.miner_tx.version != 2) {
+      std::cout << timebuf << "" << delimiter << "" << h << "" << delimiter << "" << blk.miner_tx.hash << "" << delimiter << "invalid miner TX version detected" << delimiter << "version:" << blk.miner_tx.version << std::endl;
+    }
+    if (blk.protocol_tx.version != 2) {
+      std::cout << timebuf << "" << delimiter << "" << h << "" << delimiter << "" << blk.protocol_tx.hash << "" << delimiter << "invalid protocol TX version detected" << delimiter << "version:" << blk.protocol_tx.version << std::endl;
+    }
+    
+    // Get the miner_tx assets
+    for (const auto& miner_tx_vout : blk.miner_tx.vout) {
+      std::string asset_type;
+      if (!cryptonote::get_output_asset_type(miner_tx_vout, asset_type)) {
+        throw std::runtime_error("Aborting: failed to get output asset type from miner_tx");
+      } else if (asset_type != "SAL") {
+        throw std::runtime_error("Aborting: invalid output asset type from miner_tx");
+      }
+      miner_tx_assets.insert(asset_type);
+    }
+
+    // Get the protocol_tx assets
+    for (const auto& protocol_tx_vout : blk.protocol_tx.vout) {
+      std::string asset_type;
+      if (!cryptonote::get_output_asset_type(protocol_tx_vout, asset_type)) {
+        throw std::runtime_error("Aborting: failed to get output asset type from protocol_tx");
+      } else if (asset_type != "SAL") {
+        throw std::runtime_error("Aborting: invalid output asset type from protocol_tx");
+      }
+      protocol_tx_assets.insert(asset_type);
+    }
+
+    for (const auto& tx_id : blk.tx_hashes)
+    {
+      if (tx_id == crypto::null_hash)
+      {
+        throw std::runtime_error("Aborting: tx == null_hash");
+      }
+      if (!db->get_pruned_tx_blob(tx_id, bd))
+      {
+        throw std::runtime_error("Aborting: tx not found");
+      }
+      transaction tx;
+      if (!parse_and_validate_tx_base_from_blob(bd, tx))
+      {
+        std::cout << timebuf << "" << delimiter << "" << h << "" << delimiter << "" << tx_id << "" << delimiter << "invalid TX detected" << delimiter << std::endl;
+        continue;
+      }
+      currsz += bd.size();
+      if (db->get_prunable_tx_blob(tx_id, bd))
+        currsz += bd.size();
+      currtxs++;
+
+      if (tx.version != 2) {
+        std::cout << timebuf << "" << delimiter << "" << h << "" << delimiter << "" << tx_id << "" << delimiter << "invalid TX version detected" << delimiter << "version:" << tx.version << std::endl;
+      }
+      
+      /*
+      std::string source;
+      std::string dest;
+      offshore::pricing_record pr;
+      if (!cryptonote::get_tx_asset_types(tx, source, dest, false)) {
+        std::cout << timebuf << "" << delimiter << "" << h << "" << delimiter << "" << tx_id << "" << delimiter << "At least 1 input or 1 output of the tx was invalid" << delimiter << "get_tx_asset_types() failed : ";
+        if (source.empty()) {
+          std::cout << "source is empty" << std::endl;
+        }
+        if (dest.empty()) {
+          std::cout << "dest is empty" << std::endl;
+        }
+      }
+      if (!cryptonote::get_tx_type(source, dest, offshore, onshore, offshore_transfer, xusd_to_xasset, xasset_to_xusd, xasset_transfer)) {
+        std::cout << timebuf << "" << delimiter << "" << h << "" << delimiter << "" << tx_id << "" << delimiter << "At least 1 input or 1 output of the tx was invalid" << delimiter << "get_tx_type() failed" << std::endl;
+      }
+      */
+      
+      // Add the source currency to the list of expected ones
+      used_assets.insert(tx.source_asset_type);
+      /*        
+      if ((offshore && !tx.rct_signatures.txnOffshoreFee) ||
+          (onshore && !tx.rct_signatures.txnOffshoreFee_usd) ||
+          (xusd_to_xasset && !tx.rct_signatures.txnOffshoreFee_usd) ||
+          (xasset_to_xusd && !tx.rct_signatures.txnOffshoreFee_xasset)) {
+        std::cout << timebuf << "" << delimiter << "" << h << "" << delimiter << "" << tx_id << "" << delimiter << "Missing conversion fee." << delimiter << "" <<
+          "Source:" << source << ", dest:" << dest <<
+          ", XHV fees:" << tx.rct_signatures.txnFee << "," << tx.rct_signatures.txnOffshoreFee <<
+          ", XUSD fees:" << tx.rct_signatures.txnFee_usd << "," << tx.rct_signatures.txnOffshoreFee_usd <<
+          ", burnt:" << tx.amount_burnt << ", minted:" << tx.amount_minted << std::endl;
+      } else if ((offshore || onshore || xusd_to_xasset || xasset_to_xusd) && (!tx.amount_burnt || !tx.amount_minted)) {
+        std::cout << timebuf << "" << delimiter << "" << h << "" << delimiter << "" << tx_id << "" << delimiter << "Missing burnt/minted value." << std::endl;
+      }
+      */
+      /*
+      // Only run these checks for conversions
+      if (source != dest) {
+
+        // Check PR record is not too old
+        if (h > (tx.pricing_record_height + 10)) {
+          std::cout << timebuf << "" << delimiter << "" << h << "" << delimiter << "" << tx_id << "" << delimiter << "pricing record used by tx was too old" <<
+            delimiter << "tx.pricing_record_height = " << tx.pricing_record_height << std::endl;
+        }
+
+        // Get the PR used by the TX
+        cryptonote::blobdata bd_pr = db->get_block_blob_from_height(tx.pricing_record_height);
+        cryptonote::block blk_pr;
+        if (!cryptonote::parse_and_validate_block_from_blob(bd_pr, blk_pr)) {
+          LOG_PRINT_L0("Bad block from db");
+          return 1;
+        }
+
+        // Get a more convenient handle on the conversion PR
+        pr = blk_pr.pricing_record;
+        
+        // Verify the fees in 128-bit space
+        boost::multiprecision::uint128_t burnt_128 = tx.amount_burnt;
+        boost::multiprecision::uint128_t minted_128 = tx.amount_minted;
+
+        // calculate conversion fees
+        uint32_t fees_version = (h >= 831700) ? 2 : (h >= 653565) ? 2 : 1;
+        uint64_t blocks_to_unlock = tx.unlock_time - h + 1;
+
+        boost::multiprecision::uint128_t fee;
+        if (offshore) {
+          if (fees_version >= 3) {
+            std::cout << timebuf << "" << delimiter << "" << h << "" << delimiter << "" << tx_id << "" << delimiter
+                      << "invalid fee version " << fees_version << "" << delimiter << "..." << std::endl;
+          } else if (fees_version == 2) {
+
+            fee = 
+              (blocks_to_unlock >= 5030) ? (tx.amount_burnt / 500) :
+              (blocks_to_unlock >= 1430) ? (tx.amount_burnt / 20) :
+              (blocks_to_unlock >= 710) ? (tx.amount_burnt / 10) :
+              tx.amount_burnt / 5;
+
+          } else {
+
+            // Calculate the priority based on the unlock time
+            uint64_t priority =
+              (blocks_to_unlock >= 5030) ? 1 :
+              (blocks_to_unlock >= 1430) ? 2 :
+              (blocks_to_unlock >= 710) ? 3 :
+              4;
+            uint64_t unlock_time = 60 * pow(3, 4-priority);
+
+            // abs() implementation for uint64_t's
+            uint64_t delta = (pr.unused1 > pr.xUSD) ? pr.unused1 - pr.xUSD : pr.xUSD - pr.unused1;
+
+            // Estimate the fee
+            double scale = exp((M_PI / -1000.0) * (unlock_time - 60) * 1.2);
+            scale *= delta;
+            scale *= tx.amount_burnt;
+            scale /= 1000000000000;
+            fee = (boost::multiprecision::uint128_t)(scale);
+          }
+
+          if ((h >= 658500) && (fee != tx.rct_signatures.txnOffshoreFee)) {
+            std::cout << timebuf << "" << delimiter << "" << h << "" << delimiter << "" << tx_id << "" << delimiter
+                      << "invalid fee " << tx.rct_signatures.txnOffshoreFee << "" << delimiter << "check:" << fee << std::endl;
+          }
+        
+        } else if (onshore) {
+          
+          if (fees_version >= 3) {
+            std::cout << timebuf << "" << delimiter << "" << h << "" << delimiter << "" << tx_id << "" << delimiter
+                      << "invalid fee version " << fees_version << "" << delimiter << "..." << std::endl;
+          } else if (fees_version == 2) {
+
+            fee = 
+              (blocks_to_unlock >= 5030) ? (tx.amount_burnt / 500) :
+              (blocks_to_unlock >= 1430) ? (tx.amount_burnt / 20) :
+              (blocks_to_unlock >= 710) ? (tx.amount_burnt / 10) :
+              tx.amount_burnt / 5;
+            
+          } else {
+            
+            // Calculate the priority based on the unlock time
+            uint64_t priority =
+              (blocks_to_unlock >= 5030) ? 1 :
+              (blocks_to_unlock >= 1430) ? 2 :
+              (blocks_to_unlock >= 710) ? 3 :
+              4;
+            uint64_t unlock_time = 60 * pow(3, 4-priority);
+
+            // abs() implementation for uint64_t's
+            uint64_t delta = (pr.unused1 > pr.xUSD) ? pr.unused1 - pr.xUSD : pr.xUSD - pr.unused1;
+
+            // Estimate the fee
+            double scale = exp((M_PI / -1000.0) * (unlock_time - 60) * 1.2);
+            scale *= delta;
+            scale *= tx.amount_burnt;
+            scale /= 1000000000000;
+            fee = (boost::multiprecision::uint128_t)(scale);
+          }
+
+          if ((h >= 658500) && (fee != tx.rct_signatures.txnOffshoreFee_usd)) {
+            std::cout << timebuf << "" << delimiter << "" << h << "" << delimiter << "" << tx_id << "" << delimiter
+                      << "invalid offshore fee " << tx.rct_signatures.txnOffshoreFee_usd << "" << delimiter << "check:" << fee << std::endl;
+          }
+
+        } else if (xusd_to_xasset) {
+
+          fee = tx.amount_burnt;
+          fee *= 3;
+          fee /= 1000;
+          
+          if (fee != tx.rct_signatures.txnOffshoreFee_usd) {
+            std::cout << timebuf << "" << delimiter << "" << h << "" << delimiter << "" << tx_id << "" << delimiter
+                      << "invalid xusd_to_xasset fee " << tx.rct_signatures.txnOffshoreFee_usd << "" << delimiter << "check:" << fee << std::endl;
+          }
+
+        } else if (xasset_to_xusd) {
+
+          fee = tx.amount_burnt;
+          fee *= 3;
+          fee /= 1000;
+          
+          if (fee != tx.rct_signatures.txnOffshoreFee_xasset) {
+            std::cout << timebuf << "" << delimiter << "" << h << "" << delimiter << "" << tx_id << "" << delimiter
+                      << "invalid xasset_to_xusd fee " << tx.rct_signatures.txnOffshoreFee_xasset << "" << delimiter << "check:" << fee << std::endl;
+          }
+
+        }
+        
+        // Check for 0 price in the source or destination currency
+        if (offshore|| xusd_to_xasset) {
+          if (!pr[dest]) {
+            std::cout << timebuf << "" << delimiter << "" << h << "" << delimiter << "" << tx_id << "" << delimiter << "0 exchange rate used for dest " << dest << "" << delimiter << "..." << std::endl;
+          } else if (pr[dest] == 1000000000000) {
+            std::cout << timebuf << "" << delimiter << "" << h << "" << delimiter << "" << tx_id << "" << delimiter << "1.0000 exchange rate used for dest " << dest << "" << delimiter << "..." << std::endl;
+          }
+        } else if (onshore || xasset_to_xusd) {
+          if (!pr[source]) {
+            std::cout << timebuf << "" << delimiter << "" << h << "" << delimiter << "" << tx_id << "" << delimiter << "0 exchange rate used for source " << source << "" << delimiter << "..." << std::endl;
+          } else if (pr[source] == 1000000000000) {
+            std::cout << timebuf << "" << delimiter << "" << h << "" << delimiter << "" << tx_id << "" << delimiter << "1.0000 exchange rate used for source " << source << "" << delimiter << "..." << std::endl;
+          }
+        }
+      }
+      */
+    }
+
+    /*
+    // compare the asset sets
+    if (used_assets == miner_tx_assets) {
+    } else if (used_assets.empty() && (miner_tx_assets.size() == 1) && (miner_tx_assets.count("XHV") == 1)) {
+    } else {
+      std::cout << timebuf << "" << delimiter << "" << h << "" << delimiter << "" << blk.miner_tx.hash << "" << delimiter << "Mismatch in miner reward assets detected" << delimiter << "Used assets = { ";
+      for (auto const &i: used_assets)
+        std::cout << i << " ";
+      std::cout << "}, miner_tx claimed { ";
+      for (auto const &i: miner_tx_assets)
+        std::cout << i << " ";
+      std::cout << "}" << std::endl;
+    }
+    */
+    
+    currblks++;
+
+    if (stop_requested)
+      break;
+  }
+
+  return 0;
+
+  CATCH_ENTRY("Stats reporting error", 1);
+}
@@ -1,4 +1,4 @@
-// Copyright (c) 2014-2022, The Monero Project
+// Copyright (c) 2014-2023, The Monero Project
 //
 // All rights reserved.
 //
@@ -31,10 +31,9 @@
 #include "common/command_line.h"
 #include "common/varint.h"
 #include "cryptonote_basic/cryptonote_boost_serialization.h"
-#include "cryptonote_core/tx_pool.h"
 #include "cryptonote_core/cryptonote_core.h"
-#include "cryptonote_core/blockchain.h"
 #include "blockchain_db/blockchain_db.h"
+#include "time_helper.h"
 #include "version.h"

 #undef MONERO_DEFAULT_LOG_CATEGORY
@@ -180,7 +179,7 @@ int main(int argc, char* argv[])
    return 1;
  }

-  mlog_configure(mlog_get_default_log_path("salvium-blockchain-stats.log"), true);
+  mlog_configure(mlog_get_default_log_path("monero-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
@@ -203,9 +202,8 @@ int main(int argc, char* argv[])
  do_diff = command_line::get_arg(vm, arg_diff);

  LOG_PRINT_L0("Initializing source blockchain (BlockchainDB)");
-  std::unique_ptr<Blockchain> core_storage;
-  tx_memory_pool m_mempool(*core_storage);
-  core_storage.reset(new Blockchain(m_mempool));
+  std::unique_ptr<BlockchainAndPool> core_storage = std::make_unique<BlockchainAndPool>();
+
  BlockchainDB *db = new_db();
  if (db == NULL)
  {
@@ -225,7 +223,7 @@ int main(int argc, char* argv[])
    LOG_PRINT_L0("Error opening database: " << e.what());
    return 1;
  }
-  r = core_storage->init(db, net_type);
+  r = core_storage->blockchain.init(db, net_type);

  CHECK_AND_ASSERT_MES(r, 1, "Failed to initialize source blockchain storage");
  LOG_PRINT_L0("Source blockchain storage initialized OK");
@@ -381,7 +379,7 @@ plot 'stats.csv' index "DATA" using (timecolumn(1,"%Y-%m-%d")):4 with lines, ''
  if (currblks)
    doprint();

-  core_storage->deinit();
+  core_storage->blockchain.deinit();
  return 0;

  CATCH_ENTRY("Stats reporting error", 1);
@@ -151,9 +151,8 @@ int main(int argc, char* argv[])
  // tx_memory_pool, Blockchain's constructor takes tx_memory_pool object.
  LOG_PRINT_L0("Initializing source blockchain (BlockchainDB)");
  const std::string input = command_line::get_arg(vm, arg_input);
-  std::unique_ptr<Blockchain> core_storage;
-  tx_memory_pool m_mempool(*core_storage);
-  core_storage.reset(new Blockchain(m_mempool));
+  std::unique_ptr<BlockchainAndPool> core_storage = std::make_unique<BlockchainAndPool>();
+
  BlockchainDB* db = new_db();
  if (db == NULL)
  {
@@ -174,7 +173,7 @@ int main(int argc, char* argv[])
    LOG_PRINT_L0("Error opening database: " << e.what());
    return 1;
  }
-  r = core_storage->init(db, net_type);
+  r = core_storage->blockchain.init(db, net_type);

  CHECK_AND_ASSERT_MES(r, 1, "Failed to initialize source blockchain storage");
  LOG_PRINT_L0("Source blockchain storage initialized OK");
@@ -185,10 +184,10 @@ int main(int argc, char* argv[])
  std::unordered_map<uint64_t,uint64_t> indices;

  LOG_PRINT_L0("Reading blockchain from " << input);
-  core_storage->for_all_transactions([&](const crypto::hash &hash, const cryptonote::transaction &tx)->bool
+  core_storage->blockchain.for_all_transactions([&](const crypto::hash &hash, const cryptonote::transaction &tx)->bool
  {
    const bool coinbase = tx.vin.size() == 1 && tx.vin[0].type() == typeid(txin_gen);
-    const uint64_t height = core_storage->get_db().get_tx_block_height(hash);
+    const uint64_t height = core_storage->blockchain.get_db().get_tx_block_height(hash);

    // create new outputs
    for (const auto &out: tx.vout)
@@ -182,74 +182,29 @@ namespace cryptonote

  bool checkpoints::init_default_checkpoints(network_type nettype)
  {
-    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 == MAINNET) {
+      ADD_CHECKPOINT2(1,     "b6b45052e7e182ebaeb14ab713db29ad979115e664d766aa0910e325564a27a6", "0x2");
+      ADD_CHECKPOINT2(10,    "82724681cf6bd934eb3253d041de50206a77627ce40ffe418ce6e0fe392ec684", "0x7812a");
+      ADD_CHECKPOINT2(20,    "4dac7b512d876df05bfa4f39b8dbacd75cb1483fbced8bfc5446ebe21b25a04f", "0xba98f");
+      ADD_CHECKPOINT2(30,    "668246360c93ef791a59157cec9cd09722b32a966051feea399082433138f07b", "0xcc235");
+      ADD_CHECKPOINT2(40,    "9a4183bc1d6e9828eac46505c5ef37ae5447ba6c9325dca02be9e1201f939a7d", "0xdf077");
+      ADD_CHECKPOINT2(50,    "5cd8b089d2e77aed9b803b398c6bff07ca652100cb8fa114c91b72509aeeb7e9", "0xf37eb");
+      ADD_CHECKPOINT2(60,    "0e1acf00dd38e0757996dcdc4b69ad54baf7ebe10ae1e8168b192acb1a0ed7f2", "0x10993b");
+      ADD_CHECKPOINT2(70,    "988977507f388221a927e279307b548a0ae0de10ded8c4f22c315e1b483f921a", "0x121537");
+      ADD_CHECKPOINT2(80,    "88ea1c49b20e7596e21ca8137b2a9fa98558df269a15816fe7d7495f1c63ea43", "0x13a290");
+      ADD_CHECKPOINT2(90,    "254800bb6f9794aad95b2226ffc1a1eef0a817472e1877ae08fac6becb55b147", "0x153a55");
+      ADD_CHECKPOINT2(100,   "ba8d75fad878af26ac2504b4868893a7f86c59f013d0f096925cf53271dd04e8", "0x16e91e");
+      ADD_CHECKPOINT2(110,   "dca0779bfe403730b923fa0918645daeec6096b953be2c554f133460c6fcce35", "0x18acb9");
+      ADD_CHECKPOINT2(120,   "5a57287f6b5c105ae264b88050731c5b9ad1313b916143d7585af1d345e70247", "0x1a88f5");
+      ADD_CHECKPOINT2(130,   "4fd292ac0774461e968924f8097e78ec03eee43a2997deaddbc7993e470a61d6", "0x1c6edd");
+      ADD_CHECKPOINT2(140,   "5a3b6ceeef5fd498ea3330acb8a0e87f2c1566c9b0100ad67237e5664d1f053b", "0x1e4991");
+      ADD_CHECKPOINT2(150,   "78f26d08d39f7d5e1a3548277321471e16c95096fa9bcecbe8a420d406ee249b", "0x202406");
+      ADD_CHECKPOINT2(160,   "7acaab1037ccfbadd3126d2612d5dc154020297f980df0b8df462f9c761d3326", "0x22154b");
+      ADD_CHECKPOINT2(170,   "9541ae934e40fa6749ca3453e47cf5fdf38efbac9efcaa2714121e8a21dd2d24", "0x241ce7");
+      ADD_CHECKPOINT2(180,   "e20bc8ac6aabb6b0792f23a29ce42a577c6a57d177a8ac1a51b68fb6de508045", "0x262b40");
+      ADD_CHECKPOINT2(190,   "f69fdad7a15471b63a82668b618ee5b2a384291269d944b11974a723c1604124", "0x2856a3");
+      ADD_CHECKPOINT2(200,   "eba53fa7006dfcdc837a56c0bc8f0e1883cf34861c26934d680252a6878a3f5d", "0x2aa022");
    }
-    if (nettype == STAGENET)
-    {
-      ADD_CHECKPOINT2(0,       "76ee3cc98646292206cd3e86f74d88b4dcc1d937088645e9b0cbca84b7ce74eb", "0x1");
-      ADD_CHECKPOINT2(10000,   "1f8b0ce313f8b9ba9a46108bfd285c45ad7c2176871fd41c3a690d4830ce2fd5", "0x1d73ba");
-      ADD_CHECKPOINT2(550000,  "409f68cddd8e74b37469b41c1e61250d81c5776b42264f416d5d27c4626383ed", "0x5f3d4d03e");
-      return true;
-    }
-    ADD_CHECKPOINT2(1,     "771fbcd656ec1464d3a02ead5e18644030007a0fc664c0a964d30922821a8148", "0x2");
-    ADD_CHECKPOINT2(10,    "c0e3b387e47042f72d8ccdca88071ff96bff1ac7cde09ae113dbb7ad3fe92381", "0x2a974");
-    ADD_CHECKPOINT2(100,   "ac3e11ca545e57c49fca2b4e8c48c03c23be047c43e471e1394528b1f9f80b2d", "0x35d14b");
-    ADD_CHECKPOINT2(1000,  "5acfc45acffd2b2e7345caf42fa02308c5793f15ec33946e969e829f40b03876", "0x36a0373");
-    ADD_CHECKPOINT2(10000, "c758b7c81f928be3295d45e230646de8b852ec96a821eac3fea4daf3fcac0ca2", "0x60a91390");
-    ADD_CHECKPOINT2(22231, "7cb10e29d67e1c069e6e11b17d30b809724255fee2f6868dc14cfc6ed44dfb25", "0x1e288793d");
-    ADD_CHECKPOINT2(29556, "53c484a8ed91e4da621bb2fa88106dbde426fe90d7ef07b9c1e5127fb6f3a7f6", "0x71f64cce8");
-    ADD_CHECKPOINT2(50000, "0fe8758ab06a8b9cb35b7328fd4f757af530a5d37759f9d3e421023231f7b31c", "0x893044b400");
-    ADD_CHECKPOINT2(80000, "a62dcd7b536f22e003ebae8726e9e7276f63d594e264b6f0cd7aab27b66e75e3", "0x5cc113f1076");
-    ADD_CHECKPOINT2(202612, "bbd604d2ba11ba27935e006ed39c9bfdd99b76bf4a50654bc1e1e61217962698", "0x73310a259eb2");
-    ADD_CHECKPOINT2(202613, "e2aa337e78df1f98f462b3b1e560c6b914dec47b610698b7b7d1e3e86b6197c2", "0x733154039b97");
-    ADD_CHECKPOINT2(202614, "c29e3dc37d8da3e72e506e31a213a58771b24450144305bcba9e70fa4d6ea6fb", "0x73319dc90cb6");
-    ADD_CHECKPOINT2(205000, "5d3d7a26e6dc7535e34f03def711daa8c263785f73ec1fadef8a45880fde8063", "0x75fcc3d85123");
-    ADD_CHECKPOINT2(220000, "9613f455933c00e3e33ac315cc6b455ee8aa0c567163836858c2d9caff111553", "0x89cfed0cae3c");
-    ADD_CHECKPOINT2(230300, "bae7a80c46859db355556e3a9204a337ae8f24309926a1312323fdecf1920e61", "0x967d13e5baa9");
-    ADD_CHECKPOINT2(230700, "93e631240ceac831da1aebfc5dac8f722c430463024763ebafa888796ceaeedf", "0x96fb9663ebe7");
-    ADD_CHECKPOINT2(231350, "b5add137199b820e1ea26640e5c3e121fd85faa86a1e39cf7e6cc097bdeb1131", "0x97b9919177bf");
-    ADD_CHECKPOINT2(232150, "955de8e6b6508af2c24f7334f97beeea651d78e9ade3ab18fec3763be3201aa8", "0x98a038b612e8");
-    ADD_CHECKPOINT2(249380, "654fb0a81ce3e5caf7e3264a70f447d4bd07586c08fa50f6638cc54da0a52b2d", "0xac9739634e6d");
-    ADD_CHECKPOINT2(460000, "75037a7aed3e765db96c75bcf908f59d690a5f3390baebb9edeafd336a1c4831", "0x167799549bdda");
-    ADD_CHECKPOINT2(500000, "2428f0dbe49796be05ed81b347f53e1f7f44aed0abf641446ec2b94cae066b02", "0x188ce145e4ba9");
-    ADD_CHECKPOINT2(600000, "f5828ebf7d7d1cb61762c4dfe3ccf4ecab2e1aad23e8113668d981713b7a54c5", "0x1d9f3759e1554");
-    ADD_CHECKPOINT2(700000, "12be9b3d210b93f574d2526abb9c1ab2a881b479131fd0d4f7dac93875f503cd", "0x2201e4ee39c2c");
-    ADD_CHECKPOINT2(825000, "56503f9ad766774b575be3aff73245e9d159be88132c93d1754764f28da2ff60", "0x27565a442d5df");
-    ADD_CHECKPOINT2(900000, "d9958d0e7dcf91a5a7b11de225927bf7efc6eb26240315ce12372be902cc1337", "0x2a6334031546e");
-    ADD_CHECKPOINT2(913193, "5292d5d56f6ba4de33a58d9a34d263e2cb3c6fee0aed2286fd4ac7f36d53c85f", "0x2aefe7f40f5ea");
-    ADD_CHECKPOINT2(1000000, "a886ef5149902d8342475fee9bb296341b891ac67c4842f47a833f23c00ed721", "0x2edd71370f0e5");
-    ADD_CHECKPOINT2(1100000, "3fd720c5c8b3072fc1ccda922dec1ef25f9ed88a1e6ad4103d0fe00b180a5903", "0x390eb0035c53a");
-    ADD_CHECKPOINT2(1150000, "1dd16f626d18e1e988490dfd06de5920e22629c972c58b4d8daddea0038627b2", "0x422d5662e9e37");
-    ADD_CHECKPOINT2(1200000, "fa7d13a90850882060479d100141ff84286599ae39c3277c8ea784393f882d1f", "0x4c73503fc4aa3");
-    ADD_CHECKPOINT2(1300000, "31b34272343a44a9f4ac7de7a8fcf3b7d8a3124d7d6870affd510d2f37e74cd0", "0x723f49bc249d5");
-    ADD_CHECKPOINT2(1390000, "a8f5649dd4ded60eedab475f2bec8c934681c07e3cf640e9be0617554f13ff6c", "0xb4bba65e2841b");
-    ADD_CHECKPOINT2(1450000, "ac94e8860093bc7c83e4e91215cba1d663421ecf4067a0ae609c3a8b52bcfac2", "0x11a4aabdca9511");
-    ADD_CHECKPOINT2(1530000, "01759bce497ec38e63c78b1038892169203bb78f87e488172f6b854fcd63ba7e", "0x2819ce9f9e91e5");
-    ADD_CHECKPOINT2(1579000, "7d0d7a2346373afd41ed1e744a939fc5d474a7dbaa257be5c6fff4009e789241", "0x357a590e7dda83");
-    ADD_CHECKPOINT2(1668900, "ac2dcaf3d2f58ffcf8391639f0f1ebafcb8eac43c49479c7c37f611868d07568", "0x474226e475cc3b");
-    ADD_CHECKPOINT2(1775600, "1c6e01c661dc22cab939e79ec6a5272190624ce8356d2f7b958e4f9a57fdb05e", "0x5e3b9d206a27c6");
-    ADD_CHECKPOINT2(1856000, "9b57f17f29c71a3acd8a7904b93c41fa6eb8d2b7c73936ce4f1702d14880ba29", "0x6bde5e1caccee1");
-    ADD_CHECKPOINT2(1958000, "98a5d6e51afdf3146e0eefb10a66e8648d8d4d5c2742be8835e976ba217c9bb2", "0x79dd46d2a0971a");
-    ADD_CHECKPOINT2(2046000, "5e867f0b8baefed9244a681df97fc885d8ab36c3dfcd24c7a3abf3b8ac8b8314", "0x9cb8b6ff2978c6");
-    ADD_CHECKPOINT2(2092500, "c4e00820c9c7989b49153d5e90ae095a18a11d990e82fcc3be54e6ed785472b5", "0xb4e585a31369cb");
-    ADD_CHECKPOINT2(2182500, "0d22b5f81982eff21d094af9e821dc2007e6342069e3b1a37b15d97646353124", "0xead4a874083492");
-    ADD_CHECKPOINT2(2661600, "41c9060e8426012238e8a26da26fcb90797436896cc70886a894c2c560bcccf2", "0x2e0d87526ff161f");
-    ADD_CHECKPOINT2(2677000, "1b9fee6246eeb176bd17d637bf252e9af54a4218675f01b4449cc0901867f9eb", "0x2f165bc1a5163ba");
-    ADD_CHECKPOINT2(2706000, "d8eb144c5e1fe6b329ecc900ec95e7792fccff84175fb23a25ed59d7299a511c", "0x310f7d89372f705");
-    ADD_CHECKPOINT2(2720000, "b19fb41dff15bd1016afbee9f8469f05aab715c9e5d1b974466a11fd58ecbb86", "0x3216b5851ddbb61");
-    ADD_CHECKPOINT2(2817000, "39726d19ccaac01d150bec827b877ffae710b516bd633503662036ef4422e577", "0x3900669561954c1");
-    ADD_CHECKPOINT2(2844000, "28fc7b446dfef5b469f5778eb72ddf32a307a5f5a9823d1c394e772349e05d40", "0x3af384ec0e97d12");
-    ADD_CHECKPOINT2(2851000, "5bf0e47fc782263191a33f63a67db6c711781dc2a3c442e17ed901ec401be5c9", "0x3b6cd8a8ed610e8");
-    ADD_CHECKPOINT2(2971000, "3d4cac5ac515eeabd18769ab943af85f36db51d28720def0d0e6effc2c8f5ce3", "0x436e532738b8b5b");
-    ADD_CHECKPOINT2(2985000, "08f5e6b7301c1b6ed88268a28f8677a06e8ff943b3f9e48d3080f71f9c134bfb", "0x444b7b42a633c96");
-    ADD_CHECKPOINT2(3088000, "bddf8ca09110d33d6d497f13a113630c2b6af1c84d4f3a6f35cb1446f2604ade", "0x4aed3615c2f8c3e");
-    ADD_CHECKPOINT2(3102800, "083f4a34f9490403b564286e7f13fd1ed45c52c86fa47195f151594e5bc87504", "0x4bbed52d4da5dfb");
    return true;
  }

@@ -294,22 +249,22 @@ namespace cryptonote
    std::vector<std::string> records;

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

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

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

    if (!tools::dns_utils::load_txt_records_from_dns(records, nettype == TESTNET ? testnet_dns_urls : nettype == STAGENET ? stagenet_dns_urls : dns_urls))
@@ -102,7 +102,7 @@ namespace tools

  std::string get_update_url(const std::string &software, const std::string &subdir, const std::string &buildtag, const std::string &version, bool user)
  {
-    const char *base = user ? "https://downloads.salvium.network/" : "https://updates.salvium.network/";
+    const char *base = user ? "https://downloads.salvium.io/" : "https://updates.salvium.io/";
 #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__)
@@ -1,4 +1,4 @@
-// Copyright (c) 2014-2022, The Monero Project
+// Copyright (c) 2014-2023, The Monero Project
 // 
 // All rights reserved.
 // 
@@ -78,7 +78,6 @@ using namespace epee;
  #include <strsafe.h>
 #else 
  #include <sys/file.h>
-  #include <sys/utsname.h>
  #include <sys/stat.h>
 #endif
 #include <boost/filesystem.hpp>
@@ -140,7 +139,7 @@ namespace tools
  private_file::private_file(std::FILE* handle, std::string&& filename) noexcept
    : m_handle(handle), m_filename(std::move(filename)) {}

-  private_file private_file::create(std::string name)
+  private_file private_file::create(std::string name, uint32_t extra_flags)
  {
 #ifdef WIN32
    struct close_handle
@@ -193,7 +192,7 @@ namespace tools
        name.c_str(),
        GENERIC_WRITE, FILE_SHARE_READ,
        std::addressof(attributes),
-        CREATE_NEW, (FILE_ATTRIBUTE_TEMPORARY | FILE_FLAG_DELETE_ON_CLOSE),
+        CREATE_NEW, (FILE_ATTRIBUTE_TEMPORARY | FILE_FLAG_DELETE_ON_CLOSE | extra_flags),
        nullptr
      )
    };
@@ -212,7 +211,7 @@ namespace tools
      }
    }
 #else
-    const int fdr = open(name.c_str(), (O_RDONLY | O_CREAT), S_IRUSR);
+    const int fdr = open(name.c_str(), (O_RDONLY | O_CREAT | extra_flags), S_IRUSR);
    if (0 <= fdr)
    {
      struct stat rstats = {};
@@ -243,6 +242,23 @@ namespace tools
    return {};
  }

+  private_file private_file::drop_and_recreate(std::string filename)
+  {
+    if (epee::file_io_utils::is_file_exist(filename)) {
+      boost::system::error_code ec{};
+      boost::filesystem::remove(filename, ec);
+      if (ec) {
+        MERROR("Failed to remove " << filename << ": " << ec.message());
+        return {};
+      }
+    }
+#ifdef WIN32
+    return create(filename);
+#else
+    return create(filename, O_EXCL);
+#endif
+  }
+
  private_file::~private_file() noexcept
  {
    try
@@ -320,277 +336,6 @@ namespace tools
 #endif
  }

-#ifdef WIN32
-  std::string get_windows_version_display_string()
-  {
-    typedef void (WINAPI *PGNSI)(LPSYSTEM_INFO);
-    typedef BOOL (WINAPI *PGPI)(DWORD, DWORD, DWORD, DWORD, PDWORD);
-#define BUFSIZE 10000
-
-    char pszOS[BUFSIZE] = {0};
-    OSVERSIONINFOEX osvi;
-    SYSTEM_INFO si;
-    PGNSI pGNSI;
-    PGPI pGPI;
-    BOOL bOsVersionInfoEx;
-    DWORD dwType;
-
-    ZeroMemory(&si, sizeof(SYSTEM_INFO));
-    ZeroMemory(&osvi, sizeof(OSVERSIONINFOEX));
-
-    osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
-    bOsVersionInfoEx = GetVersionEx((OSVERSIONINFO*) &osvi);
-
-    if(!bOsVersionInfoEx) return pszOS;
-
-    // Call GetNativeSystemInfo if supported or GetSystemInfo otherwise.
-
-    pGNSI = (PGNSI) GetProcAddress(
-      GetModuleHandle(TEXT("kernel32.dll")), 
-      "GetNativeSystemInfo");
-    if(NULL != pGNSI)
-      pGNSI(&si);
-    else GetSystemInfo(&si);
-
-    if ( VER_PLATFORM_WIN32_NT==osvi.dwPlatformId && 
-      osvi.dwMajorVersion > 4 )
-    {
-      StringCchCopy(pszOS, BUFSIZE, TEXT("Microsoft "));
-
-      // Test for the specific product.
-      if ( osvi.dwMajorVersion == 10 )
-      {
-        if ( osvi.dwMinorVersion == 0 )
-        {
-          if( osvi.wProductType == VER_NT_WORKSTATION )
-            StringCchCat(pszOS, BUFSIZE, TEXT("Windows 10 "));
-          else StringCchCat(pszOS, BUFSIZE, TEXT("Windows Server 2016 " ));
-        }
-      }
-
-      if ( osvi.dwMajorVersion == 6 )
-      {
-        if ( osvi.dwMinorVersion == 0 )
-        {
-          if( osvi.wProductType == VER_NT_WORKSTATION )
-            StringCchCat(pszOS, BUFSIZE, TEXT("Windows Vista "));
-          else StringCchCat(pszOS, BUFSIZE, TEXT("Windows Server 2008 " ));
-        }
-
-        if ( osvi.dwMinorVersion == 1 )
-        {
-          if( osvi.wProductType == VER_NT_WORKSTATION )
-            StringCchCat(pszOS, BUFSIZE, TEXT("Windows 7 "));
-          else StringCchCat(pszOS, BUFSIZE, TEXT("Windows Server 2008 R2 " ));
-        }
-
-        if ( osvi.dwMinorVersion == 2 )
-        {
-          if( osvi.wProductType == VER_NT_WORKSTATION )
-            StringCchCat(pszOS, BUFSIZE, TEXT("Windows 8 "));
-          else StringCchCat(pszOS, BUFSIZE, TEXT("Windows Server 2012 " ));
-        }
-
-        if ( osvi.dwMinorVersion == 3 )
-        {
-          if( osvi.wProductType == VER_NT_WORKSTATION )
-            StringCchCat(pszOS, BUFSIZE, TEXT("Windows 8.1 "));
-          else StringCchCat(pszOS, BUFSIZE, TEXT("Windows Server 2012 R2 " ));
-        }
-
-        pGPI = (PGPI) GetProcAddress(
-          GetModuleHandle(TEXT("kernel32.dll")), 
-          "GetProductInfo");
-
-        pGPI( osvi.dwMajorVersion, osvi.dwMinorVersion, 0, 0, &dwType);
-
-        switch( dwType )
-        {
-        case PRODUCT_ULTIMATE:
-          StringCchCat(pszOS, BUFSIZE, TEXT("Ultimate Edition" ));
-          break;
-        case PRODUCT_PROFESSIONAL:
-          StringCchCat(pszOS, BUFSIZE, TEXT("Professional" ));
-          break;
-        case PRODUCT_HOME_PREMIUM:
-          StringCchCat(pszOS, BUFSIZE, TEXT("Home Premium Edition" ));
-          break;
-        case PRODUCT_HOME_BASIC:
-          StringCchCat(pszOS, BUFSIZE, TEXT("Home Basic Edition" ));
-          break;
-        case PRODUCT_ENTERPRISE:
-          StringCchCat(pszOS, BUFSIZE, TEXT("Enterprise Edition" ));
-          break;
-        case PRODUCT_BUSINESS:
-          StringCchCat(pszOS, BUFSIZE, TEXT("Business Edition" ));
-          break;
-        case PRODUCT_STARTER:
-          StringCchCat(pszOS, BUFSIZE, TEXT("Starter Edition" ));
-          break;
-        case PRODUCT_CLUSTER_SERVER:
-          StringCchCat(pszOS, BUFSIZE, TEXT("Cluster Server Edition" ));
-          break;
-        case PRODUCT_DATACENTER_SERVER:
-          StringCchCat(pszOS, BUFSIZE, TEXT("Datacenter Edition" ));
-          break;
-        case PRODUCT_DATACENTER_SERVER_CORE:
-          StringCchCat(pszOS, BUFSIZE, TEXT("Datacenter Edition (core installation)" ));
-          break;
-        case PRODUCT_ENTERPRISE_SERVER:
-          StringCchCat(pszOS, BUFSIZE, TEXT("Enterprise Edition" ));
-          break;
-        case PRODUCT_ENTERPRISE_SERVER_CORE:
-          StringCchCat(pszOS, BUFSIZE, TEXT("Enterprise Edition (core installation)" ));
-          break;
-        case PRODUCT_ENTERPRISE_SERVER_IA64:
-          StringCchCat(pszOS, BUFSIZE, TEXT("Enterprise Edition for Itanium-based Systems" ));
-          break;
-        case PRODUCT_SMALLBUSINESS_SERVER:
-          StringCchCat(pszOS, BUFSIZE, TEXT("Small Business Server" ));
-          break;
-        case PRODUCT_SMALLBUSINESS_SERVER_PREMIUM:
-          StringCchCat(pszOS, BUFSIZE, TEXT("Small Business Server Premium Edition" ));
-          break;
-        case PRODUCT_STANDARD_SERVER:
-          StringCchCat(pszOS, BUFSIZE, TEXT("Standard Edition" ));
-          break;
-        case PRODUCT_STANDARD_SERVER_CORE:
-          StringCchCat(pszOS, BUFSIZE, TEXT("Standard Edition (core installation)" ));
-          break;
-        case PRODUCT_WEB_SERVER:
-          StringCchCat(pszOS, BUFSIZE, TEXT("Web Server Edition" ));
-          break;
-        }
-      }
-
-      if ( osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 2 )
-      {
-        if( GetSystemMetrics(SM_SERVERR2) )
-          StringCchCat(pszOS, BUFSIZE, TEXT( "Windows Server 2003 R2, "));
-        else if ( osvi.wSuiteMask & VER_SUITE_STORAGE_SERVER )
-          StringCchCat(pszOS, BUFSIZE, TEXT( "Windows Storage Server 2003"));
-        else if ( osvi.wSuiteMask & VER_SUITE_WH_SERVER )
-          StringCchCat(pszOS, BUFSIZE, TEXT( "Windows Home Server"));
-        else if( osvi.wProductType == VER_NT_WORKSTATION &&
-          si.wProcessorArchitecture==PROCESSOR_ARCHITECTURE_AMD64)
-        {
-          StringCchCat(pszOS, BUFSIZE, TEXT( "Windows XP Professional x64 Edition"));
-        }
-        else StringCchCat(pszOS, BUFSIZE, TEXT("Windows Server 2003, "));
-
-        // Test for the server type.
-        if ( osvi.wProductType != VER_NT_WORKSTATION )
-        {
-          if ( si.wProcessorArchitecture==PROCESSOR_ARCHITECTURE_IA64 )
-          {
-            if( osvi.wSuiteMask & VER_SUITE_DATACENTER )
-              StringCchCat(pszOS, BUFSIZE, TEXT( "Datacenter Edition for Itanium-based Systems" ));
-            else if( osvi.wSuiteMask & VER_SUITE_ENTERPRISE )
-              StringCchCat(pszOS, BUFSIZE, TEXT( "Enterprise Edition for Itanium-based Systems" ));
-          }
-
-          else if ( si.wProcessorArchitecture==PROCESSOR_ARCHITECTURE_AMD64 )
-          {
-            if( osvi.wSuiteMask & VER_SUITE_DATACENTER )
-              StringCchCat(pszOS, BUFSIZE, TEXT( "Datacenter x64 Edition" ));
-            else if( osvi.wSuiteMask & VER_SUITE_ENTERPRISE )
-              StringCchCat(pszOS, BUFSIZE, TEXT( "Enterprise x64 Edition" ));
-            else StringCchCat(pszOS, BUFSIZE, TEXT( "Standard x64 Edition" ));
-          }
-
-          else
-          {
-            if ( osvi.wSuiteMask & VER_SUITE_COMPUTE_SERVER )
-              StringCchCat(pszOS, BUFSIZE, TEXT( "Compute Cluster Edition" ));
-            else if( osvi.wSuiteMask & VER_SUITE_DATACENTER )
-              StringCchCat(pszOS, BUFSIZE, TEXT( "Datacenter Edition" ));
-            else if( osvi.wSuiteMask & VER_SUITE_ENTERPRISE )
-              StringCchCat(pszOS, BUFSIZE, TEXT( "Enterprise Edition" ));
-            else if ( osvi.wSuiteMask & VER_SUITE_BLADE )
-              StringCchCat(pszOS, BUFSIZE, TEXT( "Web Edition" ));
-            else StringCchCat(pszOS, BUFSIZE, TEXT( "Standard Edition" ));
-          }
-        }
-      }
-
-      if ( osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 1 )
-      {
-        StringCchCat(pszOS, BUFSIZE, TEXT("Windows XP "));
-        if( osvi.wSuiteMask & VER_SUITE_PERSONAL )
-          StringCchCat(pszOS, BUFSIZE, TEXT( "Home Edition" ));
-        else StringCchCat(pszOS, BUFSIZE, TEXT( "Professional" ));
-      }
-
-      if ( osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 0 )
-      {
-        StringCchCat(pszOS, BUFSIZE, TEXT("Windows 2000 "));
-
-        if ( osvi.wProductType == VER_NT_WORKSTATION )
-        {
-          StringCchCat(pszOS, BUFSIZE, TEXT( "Professional" ));
-        }
-        else 
-        {
-          if( osvi.wSuiteMask & VER_SUITE_DATACENTER )
-            StringCchCat(pszOS, BUFSIZE, TEXT( "Datacenter Server" ));
-          else if( osvi.wSuiteMask & VER_SUITE_ENTERPRISE )
-            StringCchCat(pszOS, BUFSIZE, TEXT( "Advanced Server" ));
-          else StringCchCat(pszOS, BUFSIZE, TEXT( "Server" ));
-        }
-      }
-
-      // Include service pack (if any) and build number.
-
-      if( strlen(osvi.szCSDVersion) > 0 )
-      {
-        StringCchCat(pszOS, BUFSIZE, TEXT(" ") );
-        StringCchCat(pszOS, BUFSIZE, osvi.szCSDVersion);
-      }
-
-      TCHAR buf[80];
-
-      StringCchPrintf( buf, 80, TEXT(" (build %d)"), osvi.dwBuildNumber);
-      StringCchCat(pszOS, BUFSIZE, buf);
-
-      if ( osvi.dwMajorVersion >= 6 )
-      {
-        if ( si.wProcessorArchitecture==PROCESSOR_ARCHITECTURE_AMD64 )
-          StringCchCat(pszOS, BUFSIZE, TEXT( ", 64-bit" ));
-        else if (si.wProcessorArchitecture==PROCESSOR_ARCHITECTURE_INTEL )
-          StringCchCat(pszOS, BUFSIZE, TEXT(", 32-bit"));
-      }
-
-      return pszOS; 
-    }
-    else
-    {  
-      printf( "This sample does not support this version of Windows.\n");
-      return pszOS;
-    }
-  }
-#else
-std::string get_nix_version_display_string()
-{
-  struct utsname un;
-
-  if(uname(&un) < 0)
-    return std::string("*nix: failed to get os version");
-  return std::string() + un.sysname + " " + un.version + " " + un.release;
-}
-#endif
-
-
-
-  std::string get_os_version_string()
-  {
-#ifdef WIN32
-    return get_windows_version_display_string();
-#else
-    return get_nix_version_display_string();
-#endif
-  }
-
-

 #ifdef WIN32
  std::string get_special_folder_path(int nfolder, bool iscreate)
@@ -1080,7 +825,7 @@ std::string get_nix_version_display_string()
    time_t tt = ts;
    struct tm tm;
    misc_utils::get_gmt_time(tt, tm);
-    strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S", &tm);
+    strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%SZ", &tm);
    return std::string(buffer);
  }

@@ -1,4 +1,4 @@
-// Copyright (c) 2014-2022, The Monero Project
+// Copyright (c) 2014-2023, The Monero Project
 // 
 // All rights reserved.
 // 
@@ -68,7 +68,7 @@ namespace tools
  };

  void copy_file(const std::string& from, const std::string& to);
-  
+
  //! A file restricted to process owner AND process. Deletes file on destruction.
  class private_file {
    std::unique_ptr<std::FILE, close_file> m_handle;
@@ -82,7 +82,11 @@ namespace tools

    /*! \return File only readable by owner and only used by this process
      OR `private_file{}` on error. */
-    static private_file create(std::string filename);
+    static private_file create(std::string filename, uint32_t extra_flags = 0);
+
+    /*! \return Drop and create file only readable by owner and only used
+      by this process OR `private_file{}` on error. */
+    static private_file drop_and_recreate(std::string filename);    

    private_file(private_file&&) = default;
    private_file& operator=(private_file&&) = default;
@@ -71,7 +71,7 @@ target_link_libraries(cncrypto
    epee
    randomx
    ${Boost_SYSTEM_LIBRARY}
-    ${SODIUM_LIBRARY}
+    ${sodium_LIBRARIES}
  PRIVATE
    ${EXTRA_LIBRARIES})

@@ -1,4 +1,5 @@
 // Copyright (c) 2014-2022, The Monero Project
+// Portions Copyright (c) 2023-2024, Salvium (author: SRCG)
 // 
 // All rights reserved.
 // 
@@ -90,7 +91,7 @@ namespace cryptonote
    BEGIN_SERIALIZE_OBJECT()
      FIELD(key)
      FIELD(asset_type)
-      FIELD(unlock_time)
+      VARINT_FIELD(unlock_time)
    END_SERIALIZE()
  };

@@ -199,8 +200,11 @@ namespace cryptonote
    std::vector<uint8_t> extra;
    // TX type
    cryptonote::transaction_type type;
-    // Return address
    crypto::public_key return_address;
+    // Return address list (must be at least 1 and at most BULLETPROOF_MAX_OUTPUTS-1 - the "-1" is for the change output)
+    std::vector<crypto::public_key> return_address_list;
+    //return_address_change_mask
+    std::vector<uint8_t> return_address_change_mask;
    // Return TX public key
    crypto::public_key return_pubkey;
    // Source asset type
@@ -223,8 +227,13 @@ namespace cryptonote
      if (type != cryptonote::transaction_type::PROTOCOL) {
        VARINT_FIELD(amount_burnt)
        if (type != cryptonote::transaction_type::MINER) {
-          FIELD(return_address)
-          FIELD(return_pubkey)
+          if (type == cryptonote::transaction_type::TRANSFER && version >= TRANSACTION_VERSION_N_OUTS) {
+            FIELD(return_address_list)
+            FIELD(return_address_change_mask)
+          } else {
+            FIELD(return_address)
+            FIELD(return_pubkey)
+          }
          FIELD(source_asset_type)
          FIELD(destination_asset_type)
          VARINT_FIELD(amount_slippage_limit)
@@ -243,6 +252,8 @@ namespace cryptonote
      extra.clear();
      type = cryptonote::transaction_type::UNSET;
      return_address = crypto::null_pkey;
+      return_address_list.clear();
+      return_address_change_mask.clear();
      return_pubkey = crypto::null_pkey;
      source_asset_type.clear();
      destination_asset_type.clear();
@@ -70,8 +70,6 @@ namespace cryptonote {
  {
    if (version < 2)
      return CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V1;
-    if (version < 5)
-      return CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V2;
    return CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V5;
  }
  //-----------------------------------------------------------------------------------------------
@@ -82,7 +80,7 @@ namespace cryptonote {
  //-----------------------------------------------------------------------------------------------
  bool get_block_reward(size_t median_weight, size_t current_block_weight, uint64_t already_generated_coins, uint64_t &reward, uint8_t version) {
    static_assert(DIFFICULTY_TARGET_V2%60==0&&DIFFICULTY_TARGET_V1%60==0,"difficulty targets must be a multiple of 60");
-    const int target = version < 2 ? DIFFICULTY_TARGET_V1 : DIFFICULTY_TARGET_V2;
+    const int target = DIFFICULTY_TARGET_V2;
    const int target_minutes = target / 60;
    const int emission_speed_factor = EMISSION_SPEED_FACTOR_PER_MINUTE - (target_minutes-1);

@@ -316,6 +314,53 @@ namespace cryptonote {
  bool operator ==(const cryptonote::block& a, const cryptonote::block& b) {
    return cryptonote::get_block_hash(a) == cryptonote::get_block_hash(b);
  }
+  //--------------------------------------------------------------------------------
+  int compare_hash32_reversed_nbits(const crypto::hash& ha, const crypto::hash& hb, unsigned int nbits)
+  {
+    static_assert(sizeof(uint64_t) * 4 == sizeof(crypto::hash), "hash is wrong size");
+
+    // We have to copy these buffers b/c of the strict aliasing rule
+    uint64_t va[4];
+    memcpy(va, &ha, sizeof(crypto::hash));
+    uint64_t vb[4];
+    memcpy(vb, &hb, sizeof(crypto::hash));
+
+    for (int n = 3; n >= 0 && nbits; --n)
+    {
+      const unsigned int msb_nbits = std::min<unsigned int>(64, nbits);
+      const uint64_t lsb_nbits_dropped = static_cast<uint64_t>(64 - msb_nbits);
+      const uint64_t van = SWAP64LE(va[n]) >> lsb_nbits_dropped;
+      const uint64_t vbn = SWAP64LE(vb[n]) >> lsb_nbits_dropped;
+      nbits -= msb_nbits;
+
+      if (van < vbn) return -1; else if (van > vbn) return 1;
+    }
+
+    return 0;
+  }
+
+  crypto::hash make_hash32_loose_template(unsigned int nbits, const crypto::hash& h)
+  {
+    static_assert(sizeof(uint64_t) * 4 == sizeof(crypto::hash), "hash is wrong size");
+
+    // We have to copy this buffer b/c of the strict aliasing rule
+    uint64_t vh[4];
+    memcpy(vh, &h, sizeof(crypto::hash));
+
+    for (int n = 3; n >= 0; --n)
+    {
+      const unsigned int msb_nbits = std::min<unsigned int>(64, nbits);
+      const uint64_t mask = msb_nbits ? (~((std::uint64_t(1) << (64 - msb_nbits)) - 1)) : 0;
+      nbits -= msb_nbits;
+
+      vh[n] &= SWAP64LE(mask);
+    }
+
+    crypto::hash res;
+    memcpy(&res, vh, sizeof(crypto::hash));
+    return res;
+  }
+  //--------------------------------------------------------------------------------
 }

 //--------------------------------------------------------------------------------
@@ -39,15 +39,6 @@ namespace cryptonote {
  /************************************************************************/
  /*                                                                      */
  /************************************************************************/
-  template<class t_array>
-  struct array_hasher: std::unary_function<t_array&, std::size_t>
-  {
-    std::size_t operator()(const t_array& val) const
-    {
-      return boost::hash_range(&val.data[0], &val.data[sizeof(val.data)]);
-    }
-  };
-

 #pragma pack(push, 1)
  struct public_address_outer_blob
@@ -121,6 +112,41 @@ namespace cryptonote {

  bool operator ==(const cryptonote::transaction& a, const cryptonote::transaction& b);
  bool operator ==(const cryptonote::block& a, const cryptonote::block& b);
+
+  /************************************************************************/
+  /* K-anonymity helper functions                                         */
+  /************************************************************************/
+
+  /**
+   * @brief Compares two hashes up to `nbits` bits in reverse byte order ("LMDB key order")
+   *
+   * The comparison essentially goes from the 31th, 30th, 29th, ..., 0th byte and compares the MSBs
+   * to the LSBs in each byte, up to `nbits` bits. If we use up `nbits` bits before finding a
+   * difference in the bits between the two hashes, we return 0. If we encounter a zero bit in `ha`
+   * where `hb` has a one in that bit place, then we reutrn -1. If the converse scenario happens,
+   * we return a 1. When `nbits` == 256 (there are 256 bits in `crypto::hash`), calling this is
+   * functionally identical to `BlockchainLMDB::compare_hash32`.
+   *
+   * @param ha left hash
+   * @param hb right hash
+   * @param nbits the number of bits to consider, a higher value means a finer comparison
+   * @return int 0 if ha == hb, -1 if ha < hb, 1 if ha > hb
+   */
+  int compare_hash32_reversed_nbits(const crypto::hash& ha, const crypto::hash& hb, unsigned int nbits);
+
+  /**
+   * @brief Make a template which matches `h` in LMDB order up to `nbits` bits, safe for k-anonymous fetching
+   *
+   * To be more technical, this function creates a hash which satifies the following property:
+   *     For all `H_prime` s.t. `0 == compare_hash32_reversed_nbits(real_hash, H_prime, nbits)`,
+   *     `1 > compare_hash32_reversed_nbits(real_hash, H_prime, 256)`.
+   * In other words, we return the "least" hash nbit-equal to `real_hash`.
+   *
+   * @param nbits The number of "MSB" bits to include in the template
+   * @param real_hash The original hash which contains more information than we want to disclose
+   * @return crypto::hash hash template that contains `nbits` bits matching real_hash and no more
+   */
+  crypto::hash make_hash32_loose_template(unsigned int nbits, const crypto::hash& real_hash);
 }

 bool parse_hash256(const std::string &str_hash, crypto::hash& hash);
@@ -166,24 +166,7 @@ namespace boost
  inline void serialize(Archive &a, cryptonote::transaction_prefix &x, const boost::serialization::version_type ver)
  {
    a & x.version;
-    a & x.vin;
-    a & x.vout;
-    a & x.extra;
-    a & x.type;
-    if (x.type != cryptonote::transaction_type::MINER && x.type != cryptonote::transaction_type::PROTOCOL) {
-      a & x.return_address;
-      a & x.return_pubkey;
-      a & x.source_asset_type;
-      a & x.destination_asset_type;
-      a & x.amount_burnt;
-      a & x.amount_slippage_limit;
-    }
-  }
-
-  template <class Archive>
-  inline void serialize(Archive &a, cryptonote::transaction &x, const boost::serialization::version_type ver)
-  {
-    a & x.version;
+    a & x.unlock_time;
    a & x.vin;
    a & x.vout;
    a & x.extra;
@@ -191,8 +174,39 @@ namespace boost
    if (x.type != cryptonote::transaction_type::PROTOCOL) {
      a & x.amount_burnt;
      if (x.type != cryptonote::transaction_type::MINER) {
-        a & x.return_address;
-        a & x.return_pubkey;
+        if (x.type == cryptonote::transaction_type::TRANSFER && x.version >= TRANSACTION_VERSION_N_OUTS) {
+          a & x.return_address_list;
+          a & x.return_address_change_mask;
+        } else {
+          a & x.return_address;
+          a & x.return_pubkey;
+        }
+        a & x.source_asset_type;
+        a & x.destination_asset_type;
+        a & x.amount_slippage_limit;
+      }
+    }
+  }
+
+  template <class Archive>
+  inline void serialize(Archive &a, cryptonote::transaction &x, const boost::serialization::version_type ver)
+  {
+    a & x.version;
+    a & x.unlock_time;
+    a & x.vin;
+    a & x.vout;
+    a & x.extra;
+    a & x.type;
+    if (x.type != cryptonote::transaction_type::PROTOCOL) {
+      a & x.amount_burnt;
+      if (x.type != cryptonote::transaction_type::MINER) {
+        if (x.type == cryptonote::transaction_type::TRANSFER && x.version >= TRANSACTION_VERSION_N_OUTS) {
+          a & x.return_address_list;
+          a & x.return_address_change_mask;
+        } else {
+          a & x.return_address;
+          a & x.return_pubkey;
+        }
        a & x.source_asset_type;
        a & x.destination_asset_type;
        a & x.amount_slippage_limit;
@@ -1,4 +1,5 @@
 // Copyright (c) 2014-2022, The Monero Project
+// Portions Copyright (c) 2023-2024, Salvium (author: SRCG)
 // 
 // All rights reserved.
 // 
@@ -1231,7 +1232,7 @@ namespace cryptonote
  {
    for (const auto &o: tx.vout)
    {
-      if (hf_version > HF_VERSION_VIEW_TAGS)
+      if (hf_version > HF_VERSION_REQUIRE_VIEW_TAGS)
      {
        // from v15, require outputs have view tags
        CHECK_AND_ASSERT_MES(o.target.type() == typeid(txout_to_tagged_key), false, "wrong variant type: "
@@ -1243,7 +1244,7 @@ namespace cryptonote
        CHECK_AND_ASSERT_MES(o.target.type() == typeid(txout_to_key), false, "wrong variant type: "
          << o.target.type().name() << ", expected txout_to_key in transaction id=" << get_transaction_hash(tx));
      }
-      else  //(hf_version == HF_VERSION_VIEW_TAGS)
+      else  //(hf_version == HF_VERSION_VIEW_TAGS || hf_version == HF_VERSION_VIEW_TAGS+1)
      {
        // require outputs be of type txout_to_key OR txout_to_tagged_key
        // to allow grace period before requiring all to be txout_to_tagged_key
@@ -1255,6 +1256,11 @@ namespace cryptonote
          << o.target.type().name() << " and " << tx.vout[0].target.type().name() << ", "
          << "expected matching variant types in transaction id=" << get_transaction_hash(tx));
      }
+
+      // Verify the asset type
+      std::string asset_type;
+      CHECK_AND_ASSERT_MES(cryptonote::get_output_asset_type(o, asset_type), false, "failed to get asset type");
+      CHECK_AND_ASSERT_MES(asset_type == "SAL", false, "wrong output asset type:" << asset_type);
    }
    return true;
  }
@@ -1718,7 +1724,7 @@ namespace cryptonote
    blobdata blob = t_serializable_object_to_blob(static_cast<block_header>(b));
    crypto::hash tree_root_hash = get_tx_tree_hash(b);
    blob.append(reinterpret_cast<const char*>(&tree_root_hash), sizeof(tree_root_hash));
-    blob.append(tools::get_varint_data(b.tx_hashes.size()+1));
+    blob.append(tools::get_varint_data(b.tx_hashes.size() + (b.major_version >= HF_VERSION_ENABLE_N_OUTS ? 2 : 1)));
    return blob;
  }
  //---------------------------------------------------------------
@@ -1789,6 +1795,7 @@ namespace cryptonote
    CHECK_AND_ASSERT_MES(r, false, "Failed to parse block from blob");
    b.invalidate_hashes();
    b.miner_tx.invalidate_hashes();
+    b.protocol_tx.invalidate_hashes();
    if (block_hash)
    {
      calculate_block_hash(b, *block_hash, &b_blob);
@@ -1,4 +1,5 @@
 // Copyright (c) 2014-2022, The Monero Project
+// Portions Copyright (c) 2023-2024, Salvium (author: SRCG)
 // 
 // All rights reserved.
 // 
@@ -33,6 +33,7 @@
 #include <cstddef>
 #include <cstdint>
 #include <vector>
+#include <boost/math/special_functions/round.hpp>

 #include "int-util.h"
 #include "crypto/hash.h"
@@ -239,6 +240,63 @@ namespace cryptonote {
    return res.convert_to<difficulty_type>();
  }

+  difficulty_type next_difficulty_v2(std::vector<std::uint64_t> timestamps, std::vector<difficulty_type> cumulative_difficulties, size_t target_seconds) {
+
+    // LWMA difficulty algorithm
+    // Copyright (c) 2017-2018 Zawy
+    // MIT license http://www.opensource.org/licenses/mit-license.php.
+    // This is an improved version of Tom Harding's (Deger8) "WT-144"
+    // Karbowanec, Masari, Bitcoin Gold, and Bitcoin Cash have contributed.
+    // See https://github.com/zawy12/difficulty-algorithms/issues/3 for other algos.
+    // Do not use "if solvetime < 0 then solvetime = 1" which allows a catastrophic exploit.
+    // T= target_solvetime;
+    // N=45, 55, 70, 90, 120 for T=600, 240, 120, 90, and 60
+
+    const int64_t T = static_cast<int64_t>(target_seconds);
+    size_t N = DIFFICULTY_WINDOW_V2;
+
+    if (timestamps.size() > N) {
+      timestamps.resize(N + 1);
+      cumulative_difficulties.resize(N + 1);
+    }
+    size_t n = timestamps.size();
+    assert(n == cumulative_difficulties.size());
+    assert(n <= DIFFICULTY_WINDOW_V2);
+    // If new coin, just "give away" first 5 blocks at low difficulty
+    if ( n < 6 ) { return  1; }
+    // If height "n" is from 6 to N, then reset N to n-1.
+    else if (n < N+1) { N=n-1; }
+
+    // To get an average solvetime to within +/- ~0.1%, use an adjustment factor.
+    // adjust=0.99 for 90 < N < 130
+    const long double adjust = 0.998;
+    // The divisor k normalizes LWMA.
+    const long double k = N * (N + 1) / 2;
+
+    long double LWMA(0), sum_inverse_D(0), harmonic_mean_D(0), nextDifficulty(0);
+    int64_t solveTime(0);
+    uint64_t difficulty(0), next_difficulty(0);
+
+    // Loop through N most recent blocks.
+    for (size_t i = 1; i <= N; i++) {
+      solveTime = static_cast<int64_t>(timestamps[i]) - static_cast<int64_t>(timestamps[i - 1]);
+      solveTime = std::min<int64_t>((T * 7), std::max<int64_t>(solveTime, (-7 * T)));
+      difficulty = (cumulative_difficulties[i] - cumulative_difficulties[i - 1]).convert_to<uint64_t>();
+      LWMA += (int64_t)(solveTime * i) / k;
+      sum_inverse_D += 1 / static_cast<double>(difficulty);
+    }
+
+    // Keep LWMA sane in case something unforeseen occurs.
+    if (static_cast<int64_t>(boost::math::round(LWMA)) < T / 20)
+      LWMA = static_cast<double>(T / 20);
+
+    harmonic_mean_D = N / sum_inverse_D * adjust;
+    nextDifficulty = harmonic_mean_D * T / LWMA;
+    next_difficulty = static_cast<uint64_t>(nextDifficulty);
+
+    return next_difficulty;
+  }
+  
  std::string hex(difficulty_type v)
  {
    static const char chars[] = "0123456789abcdef";
@@ -58,6 +58,7 @@ namespace cryptonote
    bool check_hash_128(const crypto::hash &hash, difficulty_type difficulty);
    bool check_hash(const crypto::hash &hash, difficulty_type difficulty);
    difficulty_type next_difficulty(std::vector<std::uint64_t> timestamps, std::vector<difficulty_type> cumulative_difficulties, size_t target_seconds);
-
+    difficulty_type next_difficulty_v2(std::vector<std::uint64_t> timestamps, std::vector<difficulty_type> cumulative_difficulties, size_t target_seconds);
+  
    std::string hex(difficulty_type v);
 }
@@ -1,4 +1,4 @@
-// Copyright (c) 2014-2022, The Monero Project
+// Copyright (c) 2014-2023, The Monero Project
 //
 // All rights reserved.
 //
@@ -42,6 +42,7 @@
 #include "string_coding.h"
 #include "string_tools.h"
 #include "storages/portable_storage_template_helper.h"
+#include "time_helper.h"
 #include "boost/logic/tribool.hpp"
 #include <boost/filesystem.hpp>

@@ -576,7 +577,7 @@ namespace cryptonote
      b.nonce = nonce;
      crypto::hash h;

-      if ((b.major_version >= RX_BLOCK_VERSION) && !rx_set)
+      if (!rx_set)
      {
        crypto::rx_set_miner_thread(th_local_index, tools::get_max_concurrency());
        rx_set = true;
@@ -59,6 +59,7 @@ namespace cryptonote
    bool m_fee_too_low;
    bool m_too_few_outputs;
    bool m_tx_extra_too_big;
+    bool m_version_mismatch; // TX version wrong for the currently-active HF version
  };

  struct block_verification_context
@@ -42,7 +42,9 @@
 #define CRYPTONOTE_MAX_TX_PER_BLOCK                     0x10000000
 #define CRYPTONOTE_PUBLIC_ADDRESS_TEXTBLOB_VER          0
 #define CRYPTONOTE_MINED_MONEY_UNLOCK_WINDOW            60
-#define CURRENT_TRANSACTION_VERSION                     2
+#define CURRENT_TRANSACTION_VERSION                     3
+#define TRANSACTION_VERSION_2_OUTS                      2
+#define TRANSACTION_VERSION_N_OUTS                      3
 #define CURRENT_BLOCK_MAJOR_VERSION                     1
 #define CURRENT_BLOCK_MINOR_VERSION                     1
 #define CRYPTONOTE_BLOCK_FUTURE_TIME_LIMIT              60*60*2
@@ -52,7 +54,7 @@

 // MONEY_SUPPLY - total number coins to be generated
 #define MONEY_SUPPLY                                    ((uint64_t)(18440000000000000ull)) // 184.4M coins * pow(10, 8)
-#define EMISSION_SPEED_FACTOR_PER_MINUTE                (20)
+#define EMISSION_SPEED_FACTOR_PER_MINUTE                (21)
 #define FINAL_SUBSIDY_PER_MINUTE                        ((uint64_t)30000000) // 3 * pow(10, 7)

 #define BURN_LOCK_PERIOD                                0
@@ -85,9 +87,11 @@

 #define DIFFICULTY_TARGET_V2                            120  // seconds
 #define DIFFICULTY_TARGET_V1                            60  // seconds - before first fork
+#define DIFFICULTY_WINDOW_V2                            70 // blocks
 #define DIFFICULTY_WINDOW                               720 // blocks
 #define DIFFICULTY_LAG                                  15  // !!!
 #define DIFFICULTY_CUT                                  60  // timestamps to cut after sorting
+#define DIFFICULTY_BLOCKS_COUNT_V2                      DIFFICULTY_WINDOW_V2
 #define DIFFICULTY_BLOCKS_COUNT                         DIFFICULTY_WINDOW + DIFFICULTY_LAG


@@ -208,15 +212,19 @@
 #define HF_VERSION_REJECT_SIGS_IN_COINBASE      1
 #define HF_VERSION_BULLETPROOF_PLUS             1
 #define HF_VERSION_ENABLE_RETURN                1
+#define HF_VERSION_VIEW_TAGS                    1

 #define HF_VERSION_LONG_TERM_BLOCK_WEIGHT       2
-#define HF_VERSION_VIEW_TAGS                    2
 #define HF_VERSION_2021_SCALING                 2
-#define HF_VERSION_ENABLE_CONVERT               2
-#define HF_VERSION_ENABLE_ORACLE                2
-#define HF_VERSION_SLIPPAGE_YIELD               2
+#define HF_VERSION_ENABLE_N_OUTS                2

-#define TESTNET_VERSION                         5
+#define HF_VERSION_REQUIRE_VIEW_TAGS            3
+
+#define HF_VERSION_ENABLE_CONVERT               255
+#define HF_VERSION_ENABLE_ORACLE                255
+#define HF_VERSION_SLIPPAGE_YIELD               255
+
+#define TESTNET_VERSION                         12
 #define STAGENET_VERSION                        1

 #define PER_KB_FEE_QUANTIZATION_DECIMALS        8
@@ -263,13 +271,13 @@ namespace config
      0x12 ,0x30, 0xF1, 0x71 , 0x61, 0x04 , 0x41, 0x61, 0x17, 0x31, 0x82, 0x53, 0x41, 0x4C, 0xFF, 0x10
    } };

-  std::string const GENESIS_TX = "0201ff000180c0d0c7bbbff60302c33815291bac1b6d5c685129c1de6383e550688d005a3ce2b66a96b7050579060353414c3c00000000000000210149117096744b390170a118fc14d8f13edb40a7d2764fde3043d9fbae7d2efdef010000";
+  std::string const GENESIS_TX = "020001ff000180c0d0c7bbbff603031c7d3e2240c8ddbc2966c9dcbf703c3aa99624d34b82fbfebd71dcfa001c59800353414c3cb42101d7be8f8312cdd54e1ae390e86d6733c3d8f1ef7be27f75f5acbf0dc57aa8e60d010000";
  
  uint32_t const GENESIS_NONCE = 10000;

  const uint64_t STAKE_LOCK_PERIOD = 30*24*30;

-  std::string const TREASURY_ADDRESS = "SaLvdVTaMJp5hrGv2rDWzaCrM6Wrq2T4tNBPX8kvuAJv7iUiYNy4vceFskGRAawnBDiqZ9jWYXZmWemRnEKtWmNMeuSXZg6jwtx";
+  std::string const TREASURY_ADDRESS = "SaLvdZR6w1A21sf2Wh6jYEh1wzY4GSbT7RX6FjyPsnLsffWLrzFQeXUXJcmBLRWDzZC2YXeYe5t7qKsnrg9FpmxmEcxPHsEYfqA";
  
  // Hash domain separators
  const char HASH_KEY_BULLETPROOF_EXPONENT[] = "bulletproof";
@@ -298,7 +306,7 @@ namespace config
  // Multisig
  const uint32_t MULTISIG_MAX_SIGNERS{16};

-  std::array<std::string, 3> const ORACLE_URLS = {{"oracle.salvium.network:8443", "oracle.salvium.network:8443", "oracle.salvium.network:8443"}};
+  std::array<std::string, 3> const ORACLE_URLS = {{"oracle.salvium.io:8443", "oracle.salvium.io:8443", "oracle.salvium.io:8443"}};
  
  std::string const ORACLE_PUBLIC_KEY = "-----BEGIN PUBLIC KEY-----\n"
    "MIIDRDCCAjYGByqGSM44BAEwggIpAoIBAQCZP7IJ5PcNvGbWiEqAioKF9wViVxEN\n"
@@ -337,12 +345,12 @@ namespace config
    boost::uuids::uuid const NETWORK_ID = { {
        0x12 ,0x30, 0xF1, 0x71 , 0x61, 0x04 , 0x41, 0x61, 0x17, 0x31, 0x82, 0x53, 0x41, 0x4C, 0x00, TESTNET_VERSION
      } };
-    std::string const GENESIS_TX = "020001ff000180c0d0c7bbbff6030279e90d3da9f9568396c5795833e6aed334d10b6bc08219de189e3ac6fade73c50353414c3c00000000000000210118c0fd33040975cb28c52cca0005a909661afeec61944e42b8646e069fd04209010000";
+    std::string const GENESIS_TX = "020001ff000180c0d0c7bbbff60302838f76f69b70bb0d0f1961a12f6082a033d22285c07d4f12ec93c28197ae2a600353414c3c2101009e8b0abce686c417a1b1344eb7337176bdca90cc928b0facec8a9516190645010000";
    uint32_t const GENESIS_NONCE = 10001;

    const uint64_t STAKE_LOCK_PERIOD = 20;
  
-    std::array<std::string, 3> const ORACLE_URLS = {{"oracle.salvium.network:8443", "oracle.salvium.network:8443", "oracle.salvium.network:8443"}};
+    std::array<std::string, 3> const ORACLE_URLS = {{"oracle.salvium.io:8443", "oracle.salvium.io:8443", "oracle.salvium.io:8443"}};

    std::string const ORACLE_PUBLIC_KEY = "-----BEGIN PUBLIC KEY-----\n"
      "MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE5YBxWx1AZCA9jTUk8Pr2uZ9jpfRt\n"
@@ -368,7 +376,7 @@ namespace config

    const uint64_t STAKE_LOCK_PERIOD = 20;
  
-    std::array<std::string, 3> const ORACLE_URLS = {{"oracle.salvium.network:8443", "oracle.salvium.network:8443", "oracle.salvium.network:8443"}};
+    std::array<std::string, 3> const ORACLE_URLS = {{"oracle.salvium.io:8443", "oracle.salvium.io:8443", "oracle.salvium.io:8443"}};

    std::string const ORACLE_PUBLIC_KEY = "-----BEGIN PUBLIC KEY-----\n"
      "MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE5YBxWx1AZCA9jTUk8Pr2uZ9jpfRt\n"
@@ -53,6 +53,7 @@ target_link_libraries(cryptonote_core
    blockchain_db
    ringct
    device
+    oracle
    hardforks
    ${Boost_DATE_TIME_LIBRARY}
    ${Boost_PROGRAM_OPTIONS_LIBRARY}
@@ -1,4 +1,5 @@
 // Copyright (c) 2014-2022, The Monero Project
+// Portions Copyright (c) 2023-2024, Salvium (author: SRCG)
 //
 // All rights reserved.
 //
@@ -887,6 +888,15 @@ start:
  uint64_t height;
  auto new_top_hash = get_tail_id(height); // get it again now that we have the lock
  ++height;
+
+  uint8_t version = get_current_hard_fork_version();
+  size_t difficulty_blocks_count;
+  if (version == 1) {
+    difficulty_blocks_count = DIFFICULTY_BLOCKS_COUNT;
+  } else {
+    difficulty_blocks_count = DIFFICULTY_BLOCKS_COUNT_V2;
+  }
+
  if (!(new_top_hash == top_hash)) D=0;
  ss << "Re-locked, height " << height << ", tail id " << new_top_hash << (new_top_hash == top_hash ? "" : " (different)") << std::endl;
  top_hash = new_top_hash;
@@ -899,15 +909,15 @@ start:
  bool check = false;
  if (m_reset_timestamps_and_difficulties_height)
    m_timestamps_and_difficulties_height = 0;
-  if (m_timestamps_and_difficulties_height != 0 && ((height - m_timestamps_and_difficulties_height) == 1) && m_timestamps.size() >= DIFFICULTY_BLOCKS_COUNT)
+  if (m_timestamps_and_difficulties_height != 0 && ((height - m_timestamps_and_difficulties_height) == 1) && m_timestamps.size() >= difficulty_blocks_count)
  {
    uint64_t index = height - 1;
    m_timestamps.push_back(m_db->get_block_timestamp(index));
    m_difficulties.push_back(m_db->get_block_cumulative_difficulty(index));

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

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

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

@@ -966,7 +976,12 @@ start:
  }

  size_t target = get_difficulty_target();
-  difficulty_type diff = next_difficulty(timestamps, difficulties, target);
+  difficulty_type diff;
+  if (version == 1) {
+    diff = next_difficulty(timestamps, difficulties, target);
+  } else {
+    diff = next_difficulty_v2(timestamps, difficulties, target);
+  }

  CRITICAL_REGION_LOCAL1(m_difficulty_lock);
  m_difficulty_for_next_block_top_hash = top_hash;
@@ -1025,11 +1040,18 @@ size_t Blockchain::recalculate_difficulties(boost::optional<uint64_t> start_heig

  std::vector<uint64_t> timestamps;
  std::vector<difficulty_type> difficulties;
-  timestamps.reserve(DIFFICULTY_BLOCKS_COUNT + 1);
-  difficulties.reserve(DIFFICULTY_BLOCKS_COUNT + 1);
+  uint8_t version = get_current_hard_fork_version();
+  size_t difficulty_blocks_count;
+  if (version == 1) {
+    difficulty_blocks_count = DIFFICULTY_BLOCKS_COUNT;
+  } else {
+    difficulty_blocks_count = DIFFICULTY_BLOCKS_COUNT_V2;
+  }
+  timestamps.reserve(difficulty_blocks_count + 1);
+  difficulties.reserve(difficulty_blocks_count + 1);
  if (start_height > 1)
  {
-    for (uint64_t i = 0; i < DIFFICULTY_BLOCKS_COUNT; ++i)
+    for (uint64_t i = 0; i < difficulty_blocks_count; ++i)
    {
      uint64_t height = start_height - 1 - i;
      if (height == 0)
@@ -1043,8 +1065,10 @@ size_t Blockchain::recalculate_difficulties(boost::optional<uint64_t> start_heig
  std::vector<difficulty_type> new_cumulative_difficulties;
  for (uint64_t height = start_height; height <= top_height; ++height)
  {
-    size_t target = get_ideal_hard_fork_version(height) < 2 ? DIFFICULTY_TARGET_V1 : DIFFICULTY_TARGET_V2;
-    difficulty_type recalculated_diff = next_difficulty(timestamps, difficulties, target);
+    size_t target = DIFFICULTY_TARGET_V2;
+    difficulty_type recalculated_diff = (version == 1)
+      ? next_difficulty(timestamps, difficulties, target)
+      : next_difficulty_v2(timestamps, difficulties, target);

    boost::multiprecision::uint256_t recalculated_cum_diff_256 = boost::multiprecision::uint256_t(recalculated_diff) + last_cum_diff;
    CHECK_AND_ASSERT_THROW_MES(recalculated_cum_diff_256 <= std::numeric_limits<difficulty_type>::max(), "Difficulty overflow!");
@@ -1072,9 +1096,9 @@ size_t Blockchain::recalculate_difficulties(boost::optional<uint64_t> start_heig
      timestamps.push_back(m_db->get_block_timestamp(height));
      difficulties.push_back(recalculated_cum_diff);
    }
-    if (timestamps.size() > DIFFICULTY_BLOCKS_COUNT)
+    if (timestamps.size() > difficulty_blocks_count)
    {
-      CHECK_AND_ASSERT_THROW_MES(timestamps.size() == DIFFICULTY_BLOCKS_COUNT + 1, "Wrong timestamps size: " << timestamps.size());
+      CHECK_AND_ASSERT_THROW_MES(timestamps.size() == difficulty_blocks_count + 1, "Wrong timestamps size: " << timestamps.size());
      timestamps.erase(timestamps.begin());
      difficulties.erase(difficulties.begin());
    }
@@ -1298,16 +1322,23 @@ difficulty_type Blockchain::get_next_difficulty_for_alternative_chain(const std:
  LOG_PRINT_L3("Blockchain::" << __func__);
  std::vector<uint64_t> timestamps;
  std::vector<difficulty_type> cumulative_difficulties;
-
+  uint8_t version = get_current_hard_fork_version();
+  size_t difficulty_blocks_count;
+  if (version == 1) {
+    difficulty_blocks_count = DIFFICULTY_BLOCKS_COUNT;
+  } else {
+    difficulty_blocks_count = DIFFICULTY_BLOCKS_COUNT_V2;
+  }
+  
  // if the alt chain isn't long enough to calculate the difficulty target
  // based on its blocks alone, need to get more blocks from the main chain
-  if(alt_chain.size()< DIFFICULTY_BLOCKS_COUNT)
+  if(alt_chain.size()< difficulty_blocks_count)
  {
    CRITICAL_REGION_LOCAL(m_blockchain_lock);

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

@@ -1322,7 +1353,7 @@ difficulty_type Blockchain::get_next_difficulty_for_alternative_chain(const std:
    }

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

    for (const auto &bei : alt_chain)
    {
@@ -1334,8 +1365,8 @@ difficulty_type Blockchain::get_next_difficulty_for_alternative_chain(const std:
  // and timestamps from it alone
  else
  {
-    timestamps.resize(static_cast<size_t>(DIFFICULTY_BLOCKS_COUNT));
-    cumulative_difficulties.resize(static_cast<size_t>(DIFFICULTY_BLOCKS_COUNT));
+    timestamps.resize(static_cast<size_t>(difficulty_blocks_count));
+    cumulative_difficulties.resize(static_cast<size_t>(difficulty_blocks_count));
    size_t count = 0;
    size_t max_i = timestamps.size()-1;
    // get difficulties and timestamps from most recent blocks in alt chain
@@ -1344,16 +1375,20 @@ difficulty_type Blockchain::get_next_difficulty_for_alternative_chain(const std:
      timestamps[max_i - count] = bei.bl.timestamp;
      cumulative_difficulties[max_i - count] = bei.cumulative_difficulty;
      count++;
-      if(count >= DIFFICULTY_BLOCKS_COUNT)
+      if(count >= difficulty_blocks_count)
        break;
    }
  }

  // FIXME: This will fail if fork activation heights are subject to voting
-  size_t target = get_ideal_hard_fork_version(bei.height) < 2 ? DIFFICULTY_TARGET_V1 : DIFFICULTY_TARGET_V2;
+  size_t target = DIFFICULTY_TARGET_V2;

  // calculate the difficulty target for the block and return it
-  return next_difficulty(timestamps, cumulative_difficulties, target);
+  if (version == 1) {
+    return next_difficulty(timestamps, cumulative_difficulties, target);
+  } else {
+    return next_difficulty_v2(timestamps, cumulative_difficulties, target);
+  }
 }
 //------------------------------------------------------------------
 // This function does a sanity check on basic things that all miner
@@ -1422,10 +1457,7 @@ bool Blockchain::prevalidate_protocol_transaction(const block& b, uint64_t heigh
    return false;
  }
  MDEBUG("Protocol tx hash: " << get_transaction_hash(b.protocol_tx));
-  //CHECK_AND_ASSERT_MES(b.protocol_tx.unlock_time == height, false, "coinbase protocol transaction transaction has the wrong unlock time=" << b.protocol_tx.unlock_time << ", expected " << height + CRYPTONOTE_MINED_MONEY_UNLOCK_WINDOW);

-  // SRCG - we still need to make output checks
-  /*
  //check outs overflow
  if(!check_outs_overflow(b.protocol_tx))
  {
@@ -1433,8 +1465,8 @@ bool Blockchain::prevalidate_protocol_transaction(const block& b, uint64_t heigh
    return false;
  }

-  CHECK_AND_ASSERT_MES(check_output_types(b.miner_tx, hf_version), false, "miner transaction has invalid output type(s) in block " << get_block_hash(b));
-  */
+  CHECK_AND_ASSERT_MES(check_output_types(b.protocol_tx, hf_version), false, "protocol transaction has invalid output type(s) in block " << get_block_hash(b));
+
  return true;
 }
 //------------------------------------------------------------------
@@ -1450,6 +1482,7 @@ bool Blockchain::validate_miner_transaction(const block& b, size_t cumulative_bl

  switch (version) {
  case HF_VERSION_BULLETPROOF_PLUS:
+  case HF_VERSION_ENABLE_N_OUTS:
    if (b.miner_tx.amount_burnt > 0) {
      CHECK_AND_ASSERT_MES(money_in_use + b.miner_tx.amount_burnt > money_in_use, false, "miner transaction is overflowed by amount_burnt");
      money_in_use += b.miner_tx.amount_burnt;
@@ -1480,7 +1513,7 @@ bool Blockchain::validate_miner_transaction(const block& b, size_t cumulative_bl
 }
 //------------------------------------------------------------------
 // SRCG
-bool Blockchain::validate_protocol_transaction(const block& b, uint64_t height, std::vector<std::pair<transaction, blobdata>>& txs, const std::map<std::string, uint64_t>& circ_supply, uint8_t hf_version)
+bool Blockchain::validate_protocol_transaction(const block& b, uint64_t height, std::vector<std::pair<transaction, blobdata>>& txs, uint8_t hf_version)
 {
  LOG_PRINT_L3("Blockchain::" << __func__);
  CHECK_AND_ASSERT_MES(b.tx_hashes.size() == txs.size(), false, "Invalid number of TXs / hashes supplied");
@@ -1490,16 +1523,29 @@ bool Blockchain::validate_protocol_transaction(const block& b, uint64_t height,
    CHECK_AND_ASSERT_MES(b.protocol_tx.vout.size() == 0, false, "void protocol transaction in the block has outputs");
    return true;
  }
+
+  if (!b.protocol_tx.vout.size()) {
+    // No money is minted, nothing to verify - bail out
+    return true;
+  }
+
+  // Get the circulating supply so we can verify 
+  std::map<std::string, uint64_t> circ_supply;
+  if (hf_version >= HF_VERSION_ENABLE_CONVERT) {
+    circ_supply = get_db().get_circulating_supply();
+  }
  
  // Build a map of outputs from the protocol_tx
  std::map<crypto::public_key, std::tuple<std::string, uint64_t, uint64_t>> outputs;
  for (auto& o : b.protocol_tx.vout) {
    if (o.target.type() == typeid(txout_to_key)) {
      txout_to_key out = boost::get<txout_to_key>(o.target);
-      outputs[out.key] = {out.asset_type, o.amount, out.unlock_time};
+      CHECK_AND_ASSERT_MES(out.unlock_time == CRYPTONOTE_MINED_MONEY_UNLOCK_WINDOW, false, "Invalid unlock time on protocol_tx output");
+      outputs[out.key] = std::make_tuple(out.asset_type, o.amount, out.unlock_time);
    } else if (o.target.type() == typeid(txout_to_tagged_key)) {
      txout_to_tagged_key out = boost::get<txout_to_tagged_key>(o.target);
-      outputs[out.key] = {out.asset_type, o.amount, out.unlock_time};
+      CHECK_AND_ASSERT_MES(out.unlock_time == CRYPTONOTE_MINED_MONEY_UNLOCK_WINDOW, false, "Invalid unlock time on protocol_tx output");
+      outputs[out.key] = std::make_tuple(out.asset_type, o.amount, out.unlock_time);
    } else {
      MERROR("Block at height: " << height << " attempting to add protocol transaction with invalid type " << o.target.type().name());
      return false;
@@ -1566,7 +1612,7 @@ bool Blockchain::validate_protocol_transaction(const block& b, uint64_t height,
          return false;
        }
        if (amount_minted_check != output_amount) {
-          LOG_ERROR("Block at height: " << height << " - Output amount does not match amount_burnt for refunded TX id " << tx->hash << " - rejecting block");
+          LOG_ERROR("Block at height: " << height << " - Output amount does not match amount minted for converted TX id " << tx->hash << " - rejecting block");
          return false;
        }

@@ -1581,12 +1627,12 @@ bool Blockchain::validate_protocol_transaction(const block& b, uint64_t height,
  }

  // Can we have matured STAKE transactions yet?
-  uint64_t lock_period = get_config(m_nettype).STAKE_LOCK_PERIOD;
-  if (height > lock_period) {
+  uint64_t stake_lock_period = get_config(m_nettype).STAKE_LOCK_PERIOD;
+  if (height > stake_lock_period) {

    // Yes - Get the staking data for the block that matured this time
    cryptonote::yield_block_info ybi_matured;
-    uint64_t matured_height = height - lock_period - 1;
+    uint64_t matured_height = height - stake_lock_period - 1;
    bool ok = get_ybi_entry(matured_height, ybi_matured);
    if (ok && ybi_matured.locked_coins_this_block > 0) {
      
@@ -3555,7 +3601,7 @@ bool Blockchain::check_tx_outputs(const transaction& tx, tx_verification_context
    }
  }

-  // from v15, require view tags on outputs
+  // from v15, require view tags and asset types on outputs
  if (!check_output_types(tx, hf_version))
  {
    tvc.m_invalid_output = true;
@@ -3565,6 +3611,43 @@ bool Blockchain::check_tx_outputs(const transaction& tx, tx_verification_context
  return true;
 }
 //------------------------------------------------------------------
+bool Blockchain::check_tx_type_and_version(const transaction& tx, tx_verification_context &tvc) const
+{
+  LOG_PRINT_L3("Blockchain::" << __func__);
+  CRITICAL_REGION_LOCAL(m_blockchain_lock);
+
+  const uint8_t hf_version = m_hardfork->get_current_version();
+
+  // Prior to v2, only allow TX v2
+  if (hf_version < HF_VERSION_ENABLE_N_OUTS) {
+
+    // Check for N-out TXs
+    if (tx.version >= TRANSACTION_VERSION_N_OUTS) {
+      MERROR_VER("N-out TXs are not permitted prior to v" + std::to_string(HF_VERSION_ENABLE_N_OUTS));
+      tvc.m_version_mismatch = true;
+      return false;
+    }
+
+    // Check for v1 TXs - genesis block protocol_tx exception required!
+    if (tx.version == 1 && epee::string_tools::pod_to_hex(cryptonote::get_transaction_hash(tx)) == "4f78ff511e860acd03138737a71505eb62eb78b620e180e58c8e13ed0e1e3e19") {
+      MERROR("v1 TXs are not permitted");
+      tvc.m_version_mismatch = true;
+      return false;
+    }
+  }
+
+  // After v2 allow N-out TXs for TRANSFER ONLY
+  if (hf_version >= HF_VERSION_ENABLE_N_OUTS) {
+    if (tx.version >= TRANSACTION_VERSION_N_OUTS && tx.type != cryptonote::transaction_type::TRANSFER) {
+      MERROR("N-out TXs are only permitted for TRANSFER TX type");
+      tvc.m_version_mismatch = true;
+      return false;
+    }
+  }
+  
+  return true;
+}
+//------------------------------------------------------------------
 bool Blockchain::have_tx_keyimges_as_spent(const transaction &tx) const
 {
  LOG_PRINT_L3("Blockchain::" << __func__);
@@ -3579,7 +3662,7 @@ bool Blockchain::have_tx_keyimges_as_spent(const transaction &tx) const
 bool Blockchain::expand_transaction_2(transaction &tx, const crypto::hash &tx_prefix_hash, const std::vector<std::vector<rct::ctkey>> &pubkeys, const uint8_t &hf_version)
 {
  PERF_TIMER(expand_transaction_2);
-  CHECK_AND_ASSERT_MES(tx.version == 2, false, "Transaction version is not 2");
+  CHECK_AND_ASSERT_MES(tx.version == 2 || tx.version == 3, false, "Transaction version is not 2/3");

  rct::rctSig &rv = tx.rct_signatures;

@@ -3768,7 +3851,7 @@ bool Blockchain::check_tx_inputs(transaction& tx, tx_verification_context &tvc,
    }

    // min/max tx version based on HF, and we accept v1 txes if having a non mixable
-    const size_t max_tx_version = (hf_version < HF_VERSION_SLIPPAGE_YIELD) ? 2 : CURRENT_TRANSACTION_VERSION;
+    const size_t max_tx_version = (hf_version >= HF_VERSION_ENABLE_N_OUTS) ? TRANSACTION_VERSION_N_OUTS : TRANSACTION_VERSION_2_OUTS;
    if (tx.version > max_tx_version)
    {
      MERROR_VER("transaction version " << (unsigned)tx.version << " is higher than max accepted version " << max_tx_version);
@@ -4336,7 +4419,7 @@ bool Blockchain::calculate_yield_payouts(const uint64_t start_height, std::vecto
  LOG_PRINT_L3("Blockchain::" << __func__);

  // Clear the yield payout amounts
-  yield_container.empty();
+  yield_container.clear();

  // Get the YIELD TX information for matured staked coins
  std::vector<cryptonote::yield_tx_info> yield_entries;
@@ -4900,12 +4983,8 @@ leave:
  }
  TIME_MEASURE_FINISH(vmt);

-  TIME_MEASURE_START(gcs);
-  std::map<std::string, uint64_t> circ_supply = get_db().get_circulating_supply();
-  TIME_MEASURE_FINISH(gcs);
-
  TIME_MEASURE_START(vpt);
-  if(!validate_protocol_transaction(bl, blockchain_height, txs, circ_supply, m_hardfork->get_current_version()))
+  if(!validate_protocol_transaction(bl, blockchain_height, txs, m_hardfork->get_current_version()))
  {
    MERROR_VER("Block with id: " << id << " has incorrect protocol transaction");
    bvc.m_verifivation_failed = true;
@@ -5978,7 +6057,7 @@ bool Blockchain::get_hard_fork_voting_info(uint8_t version, uint32_t &window, ui

 uint64_t Blockchain::get_difficulty_target() const
 {
-  return get_current_hard_fork_version() < 2 ? DIFFICULTY_TARGET_V1 : DIFFICULTY_TARGET_V2;
+  return DIFFICULTY_TARGET_V2;
 }

 std::map<uint64_t, std::tuple<uint64_t, uint64_t, uint64_t>> Blockchain:: get_output_histogram(const std::vector<uint64_t> &amounts, bool unlocked, uint64_t recent_cutoff, uint64_t min_count) const
@@ -6049,7 +6128,7 @@ void Blockchain::cancel()
 }

 #if defined(PER_BLOCK_CHECKPOINT)
-static const char expected_block_hashes_hash[] = "2c95b5af1f3ee41893ae0c585fd59207a40f28ed4addbaad64a46a39b82955e7";
+static const char expected_block_hashes_hash[] = "3cb6d33c311e54f2b8439a3e4cc047f6b9b74db9fd92955f1db131a5dfce1edf";
 void Blockchain::load_compiled_in_block_hashes(const GetCheckpointsCallback& get_checkpoints)
 {
  if (get_checkpoints == nullptr || !m_fast_sync)
@@ -725,6 +725,19 @@ namespace cryptonote
     */
    bool check_tx_outputs(const transaction& tx, tx_verification_context &tvc) const;

+    /**
+     * @brief check that a transaction's version & type conforms to current standards
+     *
+     * This function checks, for example at the time of this writing, that
+     * the TX version and type is supported by the current HF version on-chain.
+     *
+     * @param tx the transaction to check the version and type of
+     * @param tvc returned info about tx verification
+     *
+     * @return false if the TX version and/or type is unsupported, otherwise true
+     */
+    bool check_tx_type_and_version(const transaction& tx, tx_verification_context &tvc) const;
+    
    /**
     * @brief gets the block weight limit based on recent blocks
     *
@@ -1521,7 +1534,7 @@ namespace cryptonote
     *
     * @return false if anything is found wrong with the protocol transaction, otherwise true
     */
-    bool validate_protocol_transaction(const block& b, uint64_t height, std::vector<std::pair<transaction, blobdata>>& txs, const std::map<std::string, uint64_t>& circ_supply, uint8_t hf_version);
+    bool validate_protocol_transaction(const block& b, uint64_t height, std::vector<std::pair<transaction, blobdata>>& txs, uint8_t hf_version);

    /**
     * @brief reverts the blockchain to its previous state following a failed switch
@@ -1708,5 +1721,7 @@ namespace cryptonote
     * @param already_generated_coins total coins mined by the network so far
     */
    void send_miner_notifications(uint64_t height, const crypto::hash &seed_hash, const crypto::hash &prev_id, uint64_t already_generated_coins);
+
+    friend struct BlockchainAndPool;
  };
 }  // namespace cryptonote
@@ -0,0 +1,62 @@
+// Copyright (c) 2023, The Monero Project
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice,
+// this list of
+//    conditions and the following disclaimer.
+//
+// 2. 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.
+//
+// 3. Neither the name of the copyright holder 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 HOLDER OR CONTRIBUTORS 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.
+
+#pragma once
+
+#include <memory>
+
+#include "blockchain.h"
+#include "tx_pool.h"
+#include "warnings.h"
+
+namespace cryptonote
+{
+/**
+ * @brief Container for safely constructing Blockchain and tx_memory_pool classes
+ * 
+ * The reason for this class existing is that the constructors for both Blockchain and
+ * tx_memory_pool take a reference for tx_memory_pool and Blockchain, respectively. Because of this
+ * circular reference, it is annoying/unsafe to construct these normally. This class guarantees that
+ * we don't make any silly mistakes with pointers / dangling references.
+ */
+struct BlockchainAndPool
+{
+    Blockchain blockchain;
+    tx_memory_pool tx_pool;
+
+PUSH_WARNINGS
+DISABLE_GCC_WARNING(uninitialized)
+    BlockchainAndPool(): blockchain(tx_pool), tx_pool(blockchain) {}
+POP_WARNINGS
+};
+}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Some Random Crypto Guy	a9406b158d	fixed full reward zone buffer on fork transition to match between daemon and wallet	2024-10-30 15:48:45 +00:00
Some Random Crypto Guy	e45643e157	increased max TX size from HF2; bumped version number	2024-10-30 14:31:27 +00:00
Some Random Crypto Guy	1df18ca6a4	added hard fork 2 for v0.6.0	2024-10-22 12:04:03 +01:00
Some Random Crypto Guy	91b2ec275a	Updated + fixed translations mechanism; updated fast-sync checkpoints; bumped version	2024-10-22 12:03:29 +01:00
Some Random Crypto Guy	e45fdb863c	Merge branch 'develop'	2024-10-21 14:18:51 +01:00
Some Random Crypto Guy	cb2f9d3f75	updated seed IPs, updated mainnet checksums, bumped version	2024-10-18 14:37:36 +01:00
Some Random Crypto Guy	59025bb27b	updated fast-sync checkpoints; updated testnet seed IPs	2024-10-18 13:55:50 +01:00
Some Random Crypto Guy	204c6fc778	fixed issue with migration to new difficulty algorithm; bumped version	2024-10-18 12:37:59 +01:00
Some Random Crypto Guy	78c2b4b1fb	import of blockchain scanner - unfinished	2024-10-16 17:55:46 +01:00
Some Random Crypto Guy	fcac456902	import of blockchain scanner - unfinished	2024-10-16 17:54:45 +01:00
Some Random Crypto Guy	1824a34a68	bumped version, ready for testnet	2024-10-15 12:08:58 +01:00
Some Random Crypto Guy	1786c628bf	disabled yield reporting until daemon is synced	2024-10-15 11:26:14 +01:00
Some Random Crypto Guy	6b8df3cee5	disabled STAKE for multisig - deferred solution until Salvium One	2024-10-15 11:25:42 +01:00
Some Random Crypto Guy	884db2b499	solved issue of STAKE TXs paying out without view_tags; bumped version	2024-10-14 10:55:57 +01:00
Some Random Crypto Guy	ce7a1bdd96	working multisig N-out-TX support	2024-10-11 13:38:07 +01:00
Some Random Crypto Guy	57cbb146db	working multisig N-out-TX support	2024-10-11 13:29:55 +01:00
Some Random Crypto Guy	85c856411e	resolved indexing error with m_transfers_indices changing from vector to set	2024-10-09 13:41:01 +01:00
Some Random Crypto Guy	6fefb49da0	fixed merge regression in wallet; updated build order for binary releases	2024-10-09 13:37:14 +01:00
Some Random Crypto Guy	c5c828516b	merged N-out-TX and multisig support; implemented new difficulty algorithm; bumped version	2024-10-09 13:20:51 +01:00
Some Random Crypto Guy	218911d9fc	bumped RC version	2024-10-09 12:24:29 +01:00
Some Random Crypto Guy	da3ef2511d	fixed return_payment issues for N-out-TXs; fixed change_index being incorrect datatype; partial fix to asset_type RPC propagation issue	2024-10-09 12:21:50 +01:00
Some Random Crypto Guy	8b2b039036	N-out-TX support working for simple cases - needs edge case testing still	2024-10-08 12:03:20 +01:00
Some Random Crypto Guy	4d1c84fcaf	Merge branch 'develop'	2024-10-04 10:06:24 +01:00
Some Random Crypto Guy	bb91b01cf7	Merge branch 'multisig' into develop	2024-10-03 13:48:42 +01:00
Some Random Crypto Guy	7f0eda828a	disabled staking on multisig wallets	2024-10-03 13:20:25 +01:00
Some Random Crypto Guy	d3f15211d7	updated to support multisig wallets; fixed a couple of minor bugs; removed some extraneous code; bumped version	2024-10-03 10:01:29 +01:00
Some Random Crypto Guy	b828703bbd	added maturation block to output of yield_info in CLI wallet	2024-09-30 14:38:41 +01:00
Some Random Crypto Guy	2fa8ef97ef	started work on support for STAKE and BURN commands in multisig	2024-09-30 13:08:07 +01:00
Some Random Crypto Guy	acb3af43f0	initial implementation of multisig wallet / TX support	2024-09-27 16:15:42 +01:00
Some Random Crypto Guy	d1eed6e9ff	interim commit - NOT TESTED	2024-09-14 11:06:23 +01:00
Some Random Crypto Guy	30a2931067	fixed copy/paste glitch on previous	2024-09-09 12:01:15 +01:00
Some Random Crypto Guy	1c73dd0c9f	switch to LWMA difficulty algorithm for HF2+	2024-09-08 19:54:12 +01:00
Some Random Crypto Guy	1c84c00fe6	Merge branch 'main' into develop, ahead of new Salvium One development	2024-09-02 15:26:40 +01:00
SomeRandomDevopsGuy	7abf28d87c	feat: Cross-Platform Binary Build and S3 Upload GitHub Action (#5 ) * add CI * add deploy * add deploy * add deploy * add deploy * add deploy * add deploy * add deploy * add deploy * add deploy * add deploy * add deploy * add deploy * add deploy * add deploy * add deploy * add deploy * add deploy * add deploy * add deploy --------- Co-authored-by: SomeRandomDevopsGuy <srdg@srdg.io>	2024-09-02 12:08:32 +01:00
Some Random Crypto Guy	ea919eb6ea	various translations updated; bumped version number	2024-08-31 21:46:57 +01:00
Some Random Crypto Guy	42aee311cd	Merge branch 'develop'	2024-08-30 21:22:41 +01:00
Some Random Crypto Guy	d51ca28d7b	fixed crash on calling yield_info from new wallet	2024-08-30 21:21:58 +01:00
Some Random Crypto Guy	77683cafa1	Merge branch 'develop'	2024-08-29 12:44:29 +01:00
Some Random Crypto Guy	e193d141bf	new translations; tweaked API to allow GUI to obtain staking TX data; bumped version	2024-08-29 12:28:20 +01:00
Some Random Crypto Guy	c248b78831	switched simple_wallet over to new routines for yield calculations; updated yield_info display to include yield earned on active STAKE TXs	2024-08-19 13:28:30 +01:00
Some Random Crypto Guy	6b75cb1fb5	fixed erroneous display of staked coins in all wallet balances	2024-08-19 11:07:45 +01:00
Some Random Crypto Guy	a926092d9a	Merge branch 'main' into develop	2024-08-19 11:06:52 +01:00
Some Random Crypto Guy	6d8e925fdb	disabled Trezor until protobuf fixes are available; disabled moneropulse issues; bumped version number	2024-08-16 20:47:03 +01:00
Some Random Crypto Guy	0ee3c669d6	disabled staking from secondary accounts; basic search+replace for Monero in translations	2024-08-16 15:05:26 +01:00
Some Random Crypto Guy	addd26cd47	Fixes include: - setting DEFAULT_STACK_TRACE=OFF for all release builds (prevents boost weak_ptr crash on some Linux systems) - setting RPC-SSL to disabled by default (fixes "no connection to daemon" error) - updated BlockchainLMDB::get_circulating_supply() to report staked coins as something other than BURNT - bumped to v0.4.5	2024-08-16 14:01:11 +01:00
Some Random Crypto Guy	beffdd7ed9	fixed refresh height for testnet/stagenet; updated some DE translations; bumped version	2024-08-13 12:51:29 +01:00
Some Random Crypto Guy	9e96fcfe3a	Merge branch 'main' into develop	2024-08-12 11:34:08 +01:00
Some Random Crypto Guy	91d52ba063	updated fast sync checkpoints; bumped version for BETA1	2024-08-12 11:27:30 +01:00
Some Random Crypto Guy	71d50f1b3f	simplified blockchain height estimation, which should fix wallet restore height issue	2024-08-12 09:50:14 +01:00
Some Random Crypto Guy	1b0a1b6047	updated seed node IP addresses + port numbers	2024-08-12 09:49:32 +01:00
Some Random Crypto Guy	5a10a54563	changed seed URLs	2024-08-09 21:37:53 +01:00
Some Random Crypto Guy	2dfbcce6a4	possible fixes for 'make depends' build for Win64	2024-08-09 20:51:13 +01:00
Some Random Crypto Guy	9f34b46961	fixed wallet API to expose TX type to GUI wallet; updated Dockerfile	2024-08-09 16:03:18 +01:00
Some Random Crypto Guy	8a82655fa4	added GUI yield support	2024-07-31 12:39:06 +01:00
Some Random Crypto Guy	301f2973d7	various fixes to support GUI wallet; bumped version number	2024-07-31 10:52:58 +01:00
Some Random Crypto Guy	5f48afaf31	added support for GUI wallet staking	2024-07-26 10:51:20 +01:00
Some Random Crypto Guy	b4379b005a	revised error message when querying balance of empty wallet via RPC - thanks @GeraldoNonKYC	2024-07-10 12:56:49 +01:00
Some Random Crypto Guy	9c83633120	fixed RPC functionality for TRANSFER functionality; bumped version	2024-07-08 21:12:06 +01:00
Some Random Crypto Guy	c424c5d544	fixed incorrect message for time ahead / behind blockchain	2024-07-08 21:11:20 +01:00
Some Random Crypto Guy	8d5018ea0a	Updated README.md links; fixed pool segfault; tagged new version	2024-07-04 15:40:13 +01:00
Some Random Crypto Guy	c6a6ae724a	Merge branch 'develop'	2024-07-04 10:53:44 +01:00
Some Random Crypto Guy	a743288940	added checkpoints to mainnet for premine and early chain; removed extraneous logging; updated README; bumped version to 0.4.0	2024-07-04 09:54:26 +01:00
Some Random Crypto Guy	d91729268f	fixed output of split TXs with multiple blank lines	2024-07-03 12:22:50 +01:00
Some Random Crypto Guy	1c3d026972	fixed problem with RETURN_PAYMENT on SWEEP_ALL TX outputs; bumped version	2024-07-03 11:17:53 +01:00
Some Random Crypto Guy	847db19867	various fixes for show_transfers, locked_transfer command, blocking of invalid TXs	2024-07-02 21:00:29 +01:00
Some Random Crypto Guy	0663a5ead7	fixed support for XMRIG mining RandomX; updated genesis_tx for testnet to support RandomX; bumped version	2024-06-28 13:32:01 +01:00
Some Random Crypto Guy	7ad904a9ae	fixed output type checking for all HF versions; bumped TESTNET version; bumped version	2024-06-24 17:02:19 +01:00
Some Random Crypto Guy	12cf6be402	Merge branch 'main' into develop	2024-06-24 10:10:54 +01:00
Some Random Crypto Guy	292845d721	changed some errant monero strings to salvium	2024-06-24 10:10:13 +01:00
Some Random Crypto Guy	9bc0ccc14d	bumped version	2024-06-23 14:43:38 +01:00
Some Random Crypto Guy	c20ab30963	fixed error when popping blocks containing multiple STAKE TXs; fixed 'version' command in daemon; bumped version number	2024-06-23 08:56:59 +01:00
Some Random Crypto Guy	3e012bc1fb	fixed segfault in clean wallet when calling yield_info	2024-06-22 20:34:40 +01:00
Some Random Crypto Guy	f07d3942e1	fixed stake returned wallet balance; updated yield_info and supply_info commands	2024-06-22 19:40:19 +01:00
Neil Coggins	b93cf3a2d0	bumped chain version; updated premine wallet for testnet	2024-06-21 14:16:20 +01:00
Some Random Crypto Guy	9ce266cea2	changes to some URLs to .io domain	2024-06-21 12:58:14 +01:00
Some Random Crypto Guy	193a22d55c	fixed circulating supply calculation; more rebranding; bumped version number to v0.3.0	2024-06-20 12:02:43 +01:00
Some Random Crypto Guy	2f08b2fe2e	Fixed bug in handling of yield payouts	2024-06-18 23:48:45 +01:00
Some Random Crypto Guy	6404d34e33	added K-anonymity helper functions	2024-06-18 23:47:00 +01:00
Some Random Crypto Guy	f41c20ee7c	updated ringct function libraries; fixed build issue with blockchain_utilities	2024-06-18 23:16:45 +01:00
Some Random Crypto Guy	7bb90f57d4	updated external modules	2024-06-18 21:31:00 +01:00
Some Random Crypto Guy	226be59900	fixed some compilation issues on older compilers; disabled building of blockchain_utilities that prevent Mac from building statically	2024-06-17 14:14:32 +01:00
Some Random Crypto Guy	2be6890593	implemented static mac build through depends; bumped version	2024-06-17 12:11:03 +01:00
Some Random Crypto Guy	fac4a9ca23	Merge branch 'depends-mac-build'	2024-06-17 12:10:19 +01:00
Some Random Crypto Guy	6d695e0005	Mac ARM64 builds working with depends	2024-06-17 11:52:11 +01:00
Neil Coggins	7f64a43de9	added missing commit file; bumped to version 0.2.7	2024-06-12 17:58:45 +01:00
Neil Coggins	32c277c140	updated unlock times when constructing protocol_tx - missed a file on last commit; bumped version number to 0.2.7	2024-06-12 17:45:41 +01:00
Some Random Crypto Guy	69480b79e7	activated unlock_time checks; added versioning to TESTNET; bumped version to 0.2.6	2024-06-12 15:10:53 +01:00
Some Random Crypto Guy	203cc7ee45	disabled unlock_time security checks for TESTNET pre-V6	2024-06-12 13:52:45 +01:00
Some Random Crypto Guy	075ba14f9f	fix to wallet issue on all transfers _after_ an aborted one; disabled update checking on moneropulse; bumped version number to 0.2.5	2024-06-12 12:48:42 +01:00
Some Random Crypto Guy	126caed899	removed remaining lightwallet code - maybe this time!	2024-06-10 18:30:06 +01:00
Some Random Crypto Guy	3a2be26feb	removed remaining lightwallet code	2024-06-10 18:24:01 +01:00
Some Random Crypto Guy	aeea005c95	fixed wallet API usage in GUI wallet	2024-06-10 18:12:46 +01:00
somerandomcryptoguy	2a0c17480e	Merge pull request #1 from somerandomcryptoguy/rebase-v0.18.3.3 fixed up some missing copyright messages; added unlock_time validatio…	2024-06-10 15:02:45 +01:00
Some Random Crypto Guy	584890ab25	fixed up some missing copyright messages; added unlock_time validation for protocol_tx outputs	2024-06-10 14:54:57 +01:00
Neil Coggins	759531eff5	merged develop into main	2024-06-07 21:25:48 +01:00
Neil Coggins	f582757dae	Merge branch 'rebase-v0.18.3.3' into develop	2024-06-07 21:22:42 +01:00
Neil Coggins	43eaed7a76	bumped testnet version to prevent Fulmofan from trashing the testnet before it even gets running	2024-05-27 17:01:06 +01:00
Some Random Crypto Guy	32d9edee1a	disabled return_payment mechanism for alpha testing	2024-05-27 12:06:06 +01:00
Some Random Crypto Guy	c49aacf389	prep for alpha binary release	2024-05-27 11:36:36 +01:00
Some Random Crypto Guy	2726b0556a	prep for alpha binary release	2024-05-27 11:35:34 +01:00
Some Random Crypto Guy	2e33174d2e	prep for alpha binary release	2024-05-27 11:34:43 +01:00