Merge branch 'multisig' into develop

disabled staking on multisig wallets
updated to support multisig wallets; fixed a couple of minor bugs; removed some extraneous code; bumped version
2024-10-03 13:48:42 +01:00 · 2024-10-03 13:20:25 +01:00 · 2024-10-03 10:01:29 +01:00 · 2024-09-30 14:38:41 +01:00 · 2024-09-30 13:08:07 +01:00 · 2024-09-27 16:15:42 +01:00
96 changed files with 65827 additions and 275540 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
@@ -538,7 +538,7 @@ 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)
@@ -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"]

@@ -1,4 +1,4 @@
-# Salvium Zero v0.4.1
+# Salvium Zero v0.5.3

 Copyright (c) 2023-2024, Salvium
 Portions Copyright (c) 2014-2023, The Monero Project
@@ -251,7 +251,7 @@ Tested on a Raspberry Pi Zero with a clean install of minimal Raspbian Stretch (
    ```bash
    git clone https://github.com/salvium/salvium
    cd salvium
-    git checkout v0.4.1
+    git checkout v0.5.3
    ```

 * Build:
@@ -370,10 +370,10 @@ application.
    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.4.1'. If you don't care about the version and just want binaries from master, skip this step:
+* If you would like a specific [version/tag](https://github.com/salvium/salvium/tags), do a git checkout for that version. eg. 'v0.5.3'. If you don't care about the version and just want binaries from master, skip this step:

    ```bash
-    git checkout v0.4.1
+    git checkout v0.5.3
    ```

 * If you are on a 64-bit system, run:
@@ -6,10 +6,10 @@ function(_trezor_default_val val_name val_default)
 endfunction()

 # Define default options via env vars
-_trezor_default_val(USE_DEVICE_TREZOR ON)
+_trezor_default_val(USE_DEVICE_TREZOR OFF)
 _trezor_default_val(USE_DEVICE_TREZOR_MANDATORY OFF)
-_trezor_default_val(USE_DEVICE_TREZOR_PROTOBUF_TEST ON)
-_trezor_default_val(USE_DEVICE_TREZOR_LIBUSB ON)
+_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)
@@ -1,4 +1,4 @@
-mingw32_CFLAGS=-pipe
+mingw32_CFLAGS=-pipe -pthread
 mingw32_CXXFLAGS=$(mingw32_CFLAGS)
 mingw32_ARFLAGS=cr

@@ -5,7 +5,7 @@ $(package)_file_name=$(package)-$($(package)_version).tar.gz
 $(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
@@ -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 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
+
+# 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
+
+# Finish
@@ -1915,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;

  
  /**
@@ -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;
 }
@@ -3469,9 +3473,12 @@ 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();
  
@@ -3480,8 +3487,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)
  {
@@ -3513,7 +3518,11 @@ std::map<std::string,uint64_t> BlockchainLMDB::get_circulating_supply() const
  if (circulating_supply.empty()) {
    circulating_supply["SAL"] = m_coinbase;
  }
-  circulating_supply["BURN"] = m_coinbase - circulating_supply["SAL"];
+
+  // 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;
 }

@@ -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;
@@ -249,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))
@@ -170,13 +170,15 @@ namespace boost
    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;
+    if (x.type != cryptonote::transaction_type::PROTOCOL) {
      a & x.amount_burnt;
-      a & x.amount_slippage_limit;
+      if (x.type != cryptonote::transaction_type::MINER) {
+        a & x.return_address;
+        a & x.return_pubkey;
+        a & x.source_asset_type;
+        a & x.destination_asset_type;
+        a & x.amount_slippage_limit;
+      }
    }
  }

@@ -1478,7 +1478,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");
@@ -1488,6 +1488,17 @@ 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;
@@ -4900,12 +4911,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;
@@ -6049,7 +6056,7 @@ void Blockchain::cancel()
 }

 #if defined(PER_BLOCK_CHECKPOINT)
-static const char expected_block_hashes_hash[] = "df3f619804a92fdb4057192dc43dd748ea778adc52bc498ce80524c014b81119";
+static const char expected_block_hashes_hash[] = "7f60b4980ea16b32e3f9fc1959d9d4116ba91f2b067bd70b3e21c44520096d14";
 void Blockchain::load_compiled_in_block_hashes(const GetCheckpointsCallback& get_checkpoints)
 {
  if (get_checkpoints == nullptr || !m_fast_sync)
@@ -1521,7 +1521,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
@@ -1898,7 +1898,7 @@ namespace cryptonote
    if (!tools::check_updates(software, buildtag, version, hash))
      return false;

-    if (tools::vercmp(version.c_str(), MONERO_VERSION) <= 0)
+    if (tools::vercmp(version.c_str(), SALVIUM_VERSION) <= 0)
    {
      m_update_available = false;
      return true;
@@ -1102,26 +1102,7 @@ namespace cryptonote
        if (sources[i].rct)
          boost::get<txin_to_key>(tx.vin[i]).amount = 0;
      }
-      std::vector<bool> zero_masks;
-      zero_masks.reserve(tx.vout.size());
      for (size_t i = 0; i < tx.vout.size(); ++i) {
-        if (tx.type == cryptonote::transaction_type::STAKE) {
-          uint64_t unlock_time = 0;
-          bool ok = get_output_unlock_time(tx.vout[i], unlock_time);
-          if (!ok) {
-            LOG_ERROR("failed to get output asset type for tx.vout[" << i << "]");
-            return false;
-          }
-          if (unlock_time == 0) {
-            zero_masks.emplace_back(false);
-          } else {
-            zero_masks.emplace_back(true);
-          }
-        } else {
-          zero_masks.emplace_back(false);
-        }
-
-        // Clear the amount in the output
        tx.vout[i].amount = 0;
      }
      
@@ -1136,7 +1117,6 @@ namespace cryptonote
          tx_type,
          source_asset,
          destination_asset_types,
-          zero_masks,
          inamounts,
          outamounts,
          fee,
@@ -150,6 +150,7 @@ namespace cryptonote
      FIELD(original)
      VARINT_FIELD(amount)
      FIELD(addr)
+      FIELD(asset_type)
      FIELD(is_subaddress)
      FIELD(is_integrated)
      FIELD(is_change)
@@ -84,13 +84,15 @@ namespace multisig
  }
  //----------------------------------------------------------------------------------------------------------------------
  bool generate_multisig_composite_key_image(const cryptonote::account_keys &keys,
-    const std::unordered_map<crypto::public_key, cryptonote::subaddress_index> &subaddresses,
-    const crypto::public_key &out_key,
-    const crypto::public_key &tx_public_key,
-    const std::vector<crypto::public_key> &additional_tx_public_keys,
-    std::size_t real_output_index,
-    const std::vector<crypto::key_image> &pkis,
-    crypto::key_image &ki)
+                                             const std::unordered_map<crypto::public_key, cryptonote::subaddress_index> &subaddresses,
+                                             const crypto::public_key &out_key,
+                                             const crypto::public_key &tx_public_key,
+                                             const std::vector<crypto::public_key> &additional_tx_public_keys,
+                                             std::size_t real_output_index,
+                                             const std::vector<crypto::key_image> &pkis,
+                                             crypto::key_image &ki,
+                                             const bool use_origin_data,
+                                             const cryptonote::origin_data& origin_tx_data)
  {
    // create a multisig partial key image
    // KI_partial = ([view key component] + [subaddress component] + [multisig privkeys]) * Hp(output one-time address)
@@ -98,11 +100,7 @@ namespace multisig
    // - later, we add in the components held by other participants
    cryptonote::keypair in_ephemeral;

-    // Populate this struct if you want to make use of multisig for Salvium!!!
-    assert(false);
-    cryptonote::origin_data origin_tx_data;
-    
-    if (!cryptonote::generate_key_image_helper(keys, subaddresses, out_key, tx_public_key, additional_tx_public_keys, real_output_index, in_ephemeral, ki, keys.get_device(), true, origin_tx_data))
+    if (!cryptonote::generate_key_image_helper(keys, subaddresses, out_key, tx_public_key, additional_tx_public_keys, real_output_index, in_ephemeral, ki, keys.get_device(), use_origin_data, origin_tx_data))
      return false;
    std::unordered_set<crypto::key_image> used;

@@ -59,11 +59,14 @@ namespace multisig
    crypto::public_key &L,
    crypto::public_key &R);
  bool generate_multisig_composite_key_image(const cryptonote::account_keys &keys,
-    const std::unordered_map<crypto::public_key, cryptonote::subaddress_index> &subaddresses,
-    const crypto::public_key &out_key,
-    const crypto::public_key &tx_public_key,
-    const std::vector<crypto::public_key> &additional_tx_public_keys,
-    std::size_t real_output_index,
-    const std::vector<crypto::key_image> &pkis,
-    crypto::key_image &ki);
+                                             const std::unordered_map<crypto::public_key, cryptonote::subaddress_index> &subaddresses,
+                                             const crypto::public_key &out_key,
+                                             const crypto::public_key &tx_public_key,
+                                             const std::vector<crypto::public_key> &additional_tx_public_keys,
+                                             std::size_t real_output_index,
+                                             const std::vector<crypto::key_image> &pkis,
+                                             crypto::key_image &ki,
+                                             const bool use_origin_data,
+                                             const cryptonote::origin_data& origin_tx_data
+                                             );
 } //namespace multisig
@@ -58,6 +58,67 @@

 namespace multisig {

+  rct::key sm(rct::key y, int n, const rct::key &x)
+  {
+    while (n--)
+      sc_mul(y.bytes, y.bytes, y.bytes);
+    sc_mul(y.bytes, y.bytes, x.bytes);
+    return y;
+  }
+
+  // Compute the inverse of a scalar, the clever way
+  rct::key invert(const rct::key &x)
+  {
+    rct::key _1, _10, _100, _11, _101, _111, _1001, _1011, _1111;
+
+    _1 = x;
+    sc_mul(_10.bytes, _1.bytes, _1.bytes);
+    sc_mul(_100.bytes, _10.bytes, _10.bytes);
+    sc_mul(_11.bytes, _10.bytes, _1.bytes);
+    sc_mul(_101.bytes, _10.bytes, _11.bytes);
+    sc_mul(_111.bytes, _10.bytes, _101.bytes);
+    sc_mul(_1001.bytes, _10.bytes, _111.bytes);
+    sc_mul(_1011.bytes, _10.bytes, _1001.bytes);
+    sc_mul(_1111.bytes, _100.bytes, _1011.bytes);
+
+    rct::key inv;
+    sc_mul(inv.bytes, _1111.bytes, _1.bytes);
+
+    inv = sm(inv, 123 + 3, _101);
+    inv = sm(inv, 2 + 2, _11);
+    inv = sm(inv, 1 + 4, _1111);
+    inv = sm(inv, 1 + 4, _1111);
+    inv = sm(inv, 4, _1001);
+    inv = sm(inv, 2, _11);
+    inv = sm(inv, 1 + 4, _1111);
+    inv = sm(inv, 1 + 3, _101);
+    inv = sm(inv, 3 + 3, _101);
+    inv = sm(inv, 3, _111);
+    inv = sm(inv, 1 + 4, _1111);
+    inv = sm(inv, 2 + 3, _111);
+    inv = sm(inv, 2 + 2, _11);
+    inv = sm(inv, 1 + 4, _1011);
+    inv = sm(inv, 2 + 4, _1011);
+    inv = sm(inv, 6 + 4, _1001);
+    inv = sm(inv, 2 + 2, _11);
+    inv = sm(inv, 3 + 2, _11);
+    inv = sm(inv, 3 + 2, _11);
+    inv = sm(inv, 1 + 4, _1001);
+    inv = sm(inv, 1 + 3, _111);
+    inv = sm(inv, 2 + 4, _1111);
+    inv = sm(inv, 1 + 4, _1011);
+    inv = sm(inv, 3, _101);
+    inv = sm(inv, 2 + 4, _1111);
+    inv = sm(inv, 3, _101);
+    inv = sm(inv, 1 + 2, _11);
+
+    // Sanity check for successful inversion
+    rct::key tmp;
+    sc_mul(tmp.bytes, inv.bytes, x.bytes);
+    CHECK_AND_ASSERT_THROW_MES(tmp == rct::identity(), "invert failed");
+    return inv;
+  }
+  
 namespace signing {
 //----------------------------------------------------------------------------------------------------------------------
 //----------------------------------------------------------------------------------------------------------------------
@@ -108,9 +169,12 @@ static bool compute_keys_for_sources(
    if (src.real_output >= src.outputs.size())
      return false;

+    /*
    // Populate this struct if you want to make use of multisig for Salvium!!!
    assert(false);
    cryptonote::origin_data origin_tx_data;
+    */
+    bool use_origin_data = (src.origin_tx_data.tx_type != cryptonote::transaction_type::UNSET);

    if (not cryptonote::generate_key_image_helper(
      account_keys,
@@ -122,8 +186,8 @@ static bool compute_keys_for_sources(
      tmp_keys,
      tmp_key_image,
      hwdev,
-      true,
-      origin_tx_data
+      use_origin_data,
+      src.origin_tx_data
    )) {
      return false;
    }
@@ -338,27 +402,28 @@ static bool compute_keys_for_destinations(
  std::vector<crypto::secret_key>& tx_aux_secret_keys,
  rct::keyV& output_public_keys,
  rct::keyV& output_amount_secret_keys,
+  std::vector<std::string>& asset_types,
  std::vector<crypto::view_tag>& view_tags,
+  std::vector<uint64_t>& destination_amounts,
+  const cryptonote::transaction_type& tx_type,
+  bool& found_change,
+  std::size_t& change_index,
  cryptonote::transaction& unsigned_tx
 )
 {
  hw::device &hwdev = account_keys.get_device();

-  // check non-zero change amount case
-  if (change.amount > 0)
-  {
-    // the change output must be directed to the local account
-    if (change.addr != hwdev.get_subaddress(account_keys, {subaddr_account}))
-      return false;
+  // the change output must be directed to the local account
+  if (change.addr != hwdev.get_subaddress(account_keys, {subaddr_account}))
+    return false;

-    // expect the change destination to be in the destination set
-    if (std::find_if(destinations.begin(), destinations.end(),
-        [&change](const auto &destination) -> bool
-        {
-          return destination.addr == change.addr;
-        }) == destinations.end())
-      return false;
-  }
+  // expect the change destination to be in the destination set
+  if (std::find_if(destinations.begin(), destinations.end(),
+                   [&change](const auto &destination) -> bool
+                   {
+                     return destination.addr == change.addr;
+                   }) == destinations.end())
+    return false;

  // collect non-change recipients into normal/subaddress buckets
  std::unordered_set<cryptonote::account_public_address> unique_subbaddr_recipients;
@@ -423,12 +488,35 @@ static bool compute_keys_for_destinations(
  }

  // additional tx pubkeys: R_t
-  output_public_keys.resize(num_destinations);
-  view_tags.resize(num_destinations);
+  output_public_keys.clear();
+  view_tags.clear();
+  asset_types.clear();
+  destination_amounts.clear();
+  found_change = false;
  std::vector<crypto::public_key> tx_aux_public_keys;
  crypto::public_key temp_output_public_key;
-
+  size_t output_index = 0;
+  uint64_t amount_burnt = 0;
+  uint64_t amount_slippage_limit = 0;
  for (std::size_t i = 0; i < num_destinations; ++i) {
+
+    // Is this a BURN or CONVERT TX?
+    if (tx_type == cryptonote::transaction_type::BURN || tx_type == cryptonote::transaction_type::CONVERT) {
+      // Do not create outputs that are for the destination asset type - discard them as unused
+      if (destinations[i].asset_type == unsigned_tx.destination_asset_type) {
+        amount_burnt += destinations[i].amount;
+        amount_slippage_limit = destinations[i].slippage_limit;
+        continue;
+      }
+    } else if (tx_type == cryptonote::transaction_type::STAKE) {
+      // Do not create outputs that are staked for yield - discard them as unused
+      if (!destinations[i].is_change) {
+        amount_burnt += destinations[i].amount;
+        continue;
+      }
+    }
+
+    crypto::view_tag vt; // Temporary variable to hold the view tag in case we create one
    if (not hwdev.generate_output_ephemeral_keys(
      unsigned_tx.version,
      account_keys,
@@ -436,23 +524,42 @@ static bool compute_keys_for_destinations(
      tx_secret_key,
      destinations[i],
      change.addr,
-      i,
+      output_index,
      need_tx_aux_keys,
      tx_aux_secret_keys,
      tx_aux_public_keys,
      output_amount_secret_keys,
      temp_output_public_key,
      use_view_tags,
-      view_tags[i]  //unused variable if use_view_tags is not set
+      vt
    )) {
      return false;
    }
-    output_public_keys[i] = rct::pk2rct(temp_output_public_key);
+    output_public_keys.push_back(rct::pk2rct(temp_output_public_key));
+    asset_types.push_back(destinations[i].asset_type);
+    if (use_view_tags)
+      view_tags.push_back(vt);
+    destination_amounts.push_back(destinations[i].amount);    
+    if (destinations[i].is_change) {
+      found_change = true;
+      change_index = output_index; // Store the change_index - we will need this
+    }    
+    output_index++;
  }

-  if (num_destinations != output_amount_secret_keys.size())
-    return false;
+  //if (num_destinations != output_amount_secret_keys.size())
+  //  return false;

+  if (reconstruction) {
+    // Verify the values match the unsigned_tx
+    CHECK_AND_ASSERT_MES(amount_burnt == unsigned_tx.amount_burnt, false, "Internal error - amount_burnt does not match unsigned_tx");
+    CHECK_AND_ASSERT_MES(amount_slippage_limit == unsigned_tx.amount_slippage_limit, false, "Internal error - amount_slippage_limit does not match unsigned_tx");
+  } else {
+    // Store the calculated values
+    unsigned_tx.amount_burnt = amount_burnt;
+    unsigned_tx.amount_slippage_limit = amount_slippage_limit;
+  }
+  
  CHECK_AND_ASSERT_MES(
    tx_aux_public_keys.size() == tx_aux_secret_keys.size(),
    false,
@@ -500,7 +607,11 @@ static bool onetime_addresses_are_unique(const rct::keyV& output_public_keys)
 }
 //----------------------------------------------------------------------------------------------------------------------
 //----------------------------------------------------------------------------------------------------------------------
-static bool set_tx_outputs(const rct::keyV& output_public_keys, cryptonote::transaction& unsigned_tx)
+static bool set_tx_outputs(
+  const rct::keyV& output_public_keys,
+  const std::vector<std::string>& asset_types,
+  cryptonote::transaction& unsigned_tx
+)
 {
  // sanity check: all onetime addresses should be unique
  if (not onetime_addresses_are_unique(output_public_keys))
@@ -508,9 +619,11 @@ static bool set_tx_outputs(const rct::keyV& output_public_keys, cryptonote::tran

  // set the tx outputs
  const std::size_t num_destinations = output_public_keys.size();
+  CHECK_AND_ASSERT_MES(asset_types.size() == num_destinations, false,
+    "multisig signing protocol: internal error, asset_type array size mismatch.");
  unsigned_tx.vout.resize(num_destinations);
  for (std::size_t i = 0; i < num_destinations; ++i)
-    cryptonote::set_tx_out(0, "SAL", 0, rct::rct2pk(output_public_keys[i]), false, crypto::view_tag{}, unsigned_tx.vout[i]);
+    cryptonote::set_tx_out(0, asset_types[i], 0, rct::rct2pk(output_public_keys[i]), false, crypto::view_tag{}, unsigned_tx.vout[i]);

  return true;
 }
@@ -518,6 +631,7 @@ static bool set_tx_outputs(const rct::keyV& output_public_keys, cryptonote::tran
 //----------------------------------------------------------------------------------------------------------------------
 static bool set_tx_outputs_with_view_tags(
  const rct::keyV& output_public_keys,
+  const std::vector<std::string>& asset_types,
  const std::vector<crypto::view_tag>& view_tags,
  cryptonote::transaction& unsigned_tx
 )
@@ -528,11 +642,13 @@ static bool set_tx_outputs_with_view_tags(

  // set the tx outputs (with view tags)
  const std::size_t num_destinations = output_public_keys.size();
+  CHECK_AND_ASSERT_MES(asset_types.size() == num_destinations, false,
+    "multisig signing protocol: internal error, asset_type array size mismatch.");
  CHECK_AND_ASSERT_MES(view_tags.size() == num_destinations, false,
    "multisig signing protocol: internal error, view tag size mismatch.");
  unsigned_tx.vout.resize(num_destinations);
  for (std::size_t i = 0; i < num_destinations; ++i)
-    cryptonote::set_tx_out(0, "SAL", 0, rct::rct2pk(output_public_keys[i]), true, view_tags[i], unsigned_tx.vout[i]);
+    cryptonote::set_tx_out(0, asset_types[i], 0, rct::rct2pk(output_public_keys[i]), true, view_tags[i], unsigned_tx.vout[i]);

  return true;
 }
@@ -589,11 +705,101 @@ static bool try_reconstruct_range_proofs(const int bp_version,
  return false;
 }
 //----------------------------------------------------------------------------------------------------------------------
+static bool set_tx_return_address_information(const cryptonote::account_keys& account_keys,
+                                              size_t change_index,
+                                              crypto::public_key& txkey_pub,
+                                              cryptonote::transaction& unsigned_tx
+                                              )
+{
+  if (unsigned_tx.type == cryptonote::transaction_type::TRANSFER || unsigned_tx.type == cryptonote::transaction_type::STAKE) {
+
+    // Get the output public key for the change output
+    crypto::public_key P_change = crypto::null_pkey;
+    if (unsigned_tx.type == cryptonote::transaction_type::TRANSFER)
+      CHECK_AND_ASSERT_MES(unsigned_tx.vout.size() == 2, false, "Internal error - incorrect number of outputs (!=2) for TRANSFER tx");
+    else if (unsigned_tx.type == cryptonote::transaction_type::STAKE)
+      CHECK_AND_ASSERT_MES(unsigned_tx.vout.size() == 1, false, "Internal error - incorrect number of outputs (!=1) for YIELD tx");
+    CHECK_AND_ASSERT_MES(change_index < unsigned_tx.vout.size(), false, "Internal error - invalid change_index");
+    CHECK_AND_ASSERT_MES(cryptonote::get_output_public_key(unsigned_tx.vout[change_index], P_change), false, "Internal error - failed to get TX change output public key");
+    CHECK_AND_ASSERT_MES(P_change != crypto::null_pkey, false, "Internal error - not found TX change output for TRANSFER tx");
+      
+    // Get the uniqueness for this TX
+    crypto::ec_scalar y;
+    struct {
+      char domain_separator[8];
+      crypto::public_key pubkey;
+    } buf;
+    std::memset(buf.domain_separator, 0x0, sizeof(buf.domain_separator));
+    std::strncpy(buf.domain_separator, "RETURN", 7);
+    buf.pubkey = P_change;
+    crypto::hash_to_scalar(&buf, sizeof(buf), y);
+
+    hw::device& hwdev = account_keys.get_device();
+  
+    // First, we need to produce the multiplicative inverse of the scalar "y" (aka "y^-1")
+    rct::key key_y        = (rct::key&)(y);
+    rct::key key_inv_y    = invert(key_y);
+    crypto::public_key pk_aP_change = rct::rct2pk(rct::scalarmultKey(rct::pk2rct(P_change), rct::sk2rct(account_keys.m_view_secret_key)));
+
+    // Sanity check that we can reverse the invert safely
+    rct::key key_aP_change = rct::pk2rct(pk_aP_change);
+    rct::key key_F         = rct::scalarmultKey(key_aP_change, key_inv_y);
+    rct::key key_verify    = rct::scalarmultKey(key_F, key_y);
+    CHECK_AND_ASSERT_MES(key_verify == key_aP_change, false, "at get_return_address: failed to verify invert() function with smK() approach");
+
+    if (unsigned_tx.type == cryptonote::transaction_type::TRANSFER) {
+
+      // Store the F point - we do not need to generate a full return address in this instance
+      unsigned_tx.return_address = rct::rct2pk(key_F);
+      
+      // Clear the pubkey, because it isn't used
+      unsigned_tx.return_pubkey = crypto::null_pkey;
+
+    } else if (unsigned_tx.type == cryptonote::transaction_type::STAKE) {
+      
+      // CONVERT / YIELD Semantics
+      // From this point forward, we are departing from the original "return address" scheme
+      // We have to derive the full return address and TX pubkey, because PROTOCOL_TX cannot
+
+      // First, create a secret TX key (= s) - this will be lost at the end of this function, but that's OK
+      crypto::secret_key s = cryptonote::keypair::generate(hw::get_device("default")).sec;
+      
+      // Next, calculate the corresponding TX public key (= sP_change)
+      // This has to be done using smK() call because of g_k_d() performing a torsion clear
+      unsigned_tx.return_pubkey = rct::rct2pk(rct::scalarmultKey(rct::pk2rct(P_change), rct::sk2rct(s)));
+
+      // Next, calculate a derivation using the TX public key and our secret view key
+      crypto::key_derivation derivation = AUTO_VAL_INIT(derivation);
+      bool r = hwdev.generate_key_derivation(unsigned_tx.return_pubkey, account_keys.m_view_secret_key, derivation);
+      CHECK_AND_ASSERT_MES(r, false, "in get_return_address(): failed to generate_key_derivation(" << unsigned_tx.return_pubkey << ", <view secret key>)");
+
+      // Finally, calculate the onetime address to be used for returns
+      crypto::public_key out_eph_public_key = AUTO_VAL_INIT(out_eph_public_key);
+      r = crypto::derive_public_key(derivation, 0, P_change, out_eph_public_key);
+      CHECK_AND_ASSERT_MES(r, false, "in get_return_address(): failed to derive_public_key(" << derivation << ", " << key_y << ", "<< P_change << ")");
+
+      // Sanity checks
+      crypto::public_key P_change_verify = crypto::null_pkey;
+      r = crypto::derive_subaddress_public_key(out_eph_public_key, derivation, 0, P_change_verify);
+      CHECK_AND_ASSERT_MES(r, false, "in get_return_address(): failed sanity check derive_subaddress_public_key(" << out_eph_public_key << ", " << derivation << ", " << key_y << ", " << P_change_verify << ")");
+      CHECK_AND_ASSERT_MES(P_change == P_change_verify, false, "in get_return_address(): failed sanity check (keys do not match)");
+
+      // All is well - copy the return address
+      unsigned_tx.return_address = out_eph_public_key;
+
+    } else {
+
+      assert(false);
+    }
+  }
+  
+  return true;
+}
 //----------------------------------------------------------------------------------------------------------------------
 static bool set_tx_rct_signatures(
  const std::uint64_t fee,
  const std::vector<cryptonote::tx_source_entry>& sources,
-  const std::vector<cryptonote::tx_destination_entry>& destinations,
+  const std::vector<uint64_t>& destination_amounts,
  const rct::keyV& input_secret_keys,
  const rct::keyV& output_public_keys,
  const rct::keyV& output_amount_secret_keys,
@@ -610,7 +816,7 @@ static bool set_tx_rct_signatures(
  if (rct_config.range_proof_type != rct::RangeProofPaddedBulletproof)
    return false;

-  const std::size_t num_destinations = destinations.size();
+  const std::size_t num_destinations = destination_amounts.size();
  const std::size_t num_sources = sources.size();

  // rct_signatures component of tx
@@ -633,7 +839,7 @@ static bool set_tx_rct_signatures(
  rv.outPk.resize(num_destinations);
  for (std::size_t i = 0; i < num_destinations; ++i) {
    rv.outPk[i].dest = output_public_keys[i];
-    output_amounts[i] = destinations[i].amount;
+    output_amounts[i] = destination_amounts[i];
    output_amount_masks[i] = genCommitmentMask(output_amount_secret_keys[i]);
    rv.ecdhInfo[i].amount = rct::d2h(output_amounts[i]);
    rct::addKeys2(
@@ -677,35 +883,38 @@ static bool set_tx_rct_signatures(
  if (not reconstruction) {
    a.resize(num_sources);
    rv.p.pseudoOuts.resize(num_sources);
-    a[num_sources - 1] = rct::zero();
+    rct::key difference = rct::zero();
+    rct::key sumpouts = rct::zero();
+    rct::key sumouts = rct::zero();
    for (std::size_t i = 0; i < num_destinations; ++i) {
      sc_add(
-        a[num_sources - 1].bytes,
-        a[num_sources - 1].bytes,
+        sumouts.bytes,
+        sumouts.bytes,
        output_amount_masks[i].bytes
      );
    }
-    for (std::size_t i = 0; i < num_sources - 1; ++i) {
+    for (std::size_t i = 0; i < num_sources; ++i) {
      rct::skGen(a[i]);
-      sc_sub(
-        a[num_sources - 1].bytes,
-        a[num_sources - 1].bytes,
+      sc_add(
+        sumpouts.bytes,
+        sumpouts.bytes,
        a[i].bytes
      );
      rct::genC(rv.p.pseudoOuts[i], a[i], sources[i].amount);
    }
-    rct::genC(
-      rv.p.pseudoOuts[num_sources - 1],
-      a[num_sources - 1],
-      sources[num_sources - 1].amount
-    );
+    sc_sub(difference.bytes, sumpouts.bytes, sumouts.bytes);
+    rct::genC(rv.p_r, difference, 0);
  }
  // check balance if reconstructing the tx
  else {
    rv.p.pseudoOuts = unsigned_tx.rct_signatures.p.pseudoOuts;
+    rv.p_r = unsigned_tx.rct_signatures.p_r;
    if (num_sources != rv.p.pseudoOuts.size())
      return false;
    rct::key balance_accumulator = rct::scalarmultH(rct::d2h(fee));
+    rct::key txnAmountBurntKey = rct::scalarmultH(rct::d2h(unsigned_tx.amount_burnt));
+    rct::addKeys(balance_accumulator, balance_accumulator, rv.p_r);
+    rct::addKeys(balance_accumulator, balance_accumulator, txnAmountBurntKey);
    for (const auto& e: rv.outPk)
      rct::addKeys(balance_accumulator, balance_accumulator, e.mask);
    for (const auto& pseudoOut: rv.p.pseudoOuts)
@@ -828,6 +1037,7 @@ tx_builder_ringct_t::~tx_builder_ringct_t()
 bool tx_builder_ringct_t::init(
  const cryptonote::account_keys& account_keys,
  const std::vector<std::uint8_t>& extra,
+  const cryptonote::transaction_type& tx_type,
  const std::uint64_t unlock_time,
  const std::uint32_t subaddr_account,
  const std::set<std::uint32_t>& subaddr_minor_indices,
@@ -863,6 +1073,12 @@ bool tx_builder_ringct_t::init(
  // misc. fields
  unsigned_tx.version = 2;  //rct = 2
  unsigned_tx.unlock_time = unlock_time;
+  unsigned_tx.type = (tx_type == cryptonote::transaction_type::RETURN) ? cryptonote::TRANSFER : tx_type;
+  unsigned_tx.source_asset_type = "SAL";
+  if (tx_type == cryptonote::transaction_type::BURN)
+    unsigned_tx.destination_asset_type = "BURN";
+  else
+    unsigned_tx.destination_asset_type = "SAL";

  // sort inputs
  sort_sources(sources);
@@ -899,7 +1115,11 @@ bool tx_builder_ringct_t::init(
  // prepare outputs
  rct::keyV output_public_keys;
  rct::keyV output_amount_secret_keys;
+  std::vector<std::string> asset_types;
  std::vector<crypto::view_tag> view_tags;
+  std::vector<uint64_t> destination_amounts;
+  bool found_change{false};
+  std::size_t change_index;
  auto output_amount_secret_keys_wiper = epee::misc_utils::create_scope_leave_handler([&]{
    memwipe(static_cast<rct::key *>(output_amount_secret_keys.data()), output_amount_secret_keys.size() * sizeof(rct::key));
  });
@@ -915,25 +1135,44 @@ bool tx_builder_ringct_t::init(
      tx_aux_secret_keys,
      output_public_keys,
      output_amount_secret_keys,
+      asset_types,
      view_tags,
+      destination_amounts,
+      tx_type,
+      found_change,
+      change_index,
      unsigned_tx))
    return false;

+  // Check that the change element was found
+  if (!found_change)
+    return false;
+  
  // add inputs to tx
  set_tx_inputs(sources, unsigned_tx);

  // add output one-time addresses to tx
  bool set_tx_outputs_result{false};
  if (use_view_tags)
-    set_tx_outputs_result = set_tx_outputs_with_view_tags(output_public_keys, view_tags, unsigned_tx);
+    set_tx_outputs_result = set_tx_outputs_with_view_tags(output_public_keys, asset_types, view_tags, unsigned_tx);
  else
-    set_tx_outputs_result = set_tx_outputs(output_public_keys, unsigned_tx);
+    set_tx_outputs_result = set_tx_outputs(output_public_keys, asset_types, unsigned_tx);

  if (not set_tx_outputs_result)
    return false;

+  if (unsigned_tx.type == cryptonote::transaction_type::TRANSFER || unsigned_tx.type == cryptonote::transaction_type::STAKE) {
+
+    // Get the tx public key
+    crypto::public_key txkey_pub = crypto::null_pkey;
+    
+    // Calculate the return_address information needed
+    if (not set_tx_return_address_information(account_keys, change_index, txkey_pub, unsigned_tx))
+      return false;
+  }
+
  // prepare input signatures
-  if (not set_tx_rct_signatures(fee, sources, destinations, input_secret_keys, output_public_keys, output_amount_secret_keys,
+  if (not set_tx_rct_signatures(fee, sources, destination_amounts, input_secret_keys, output_public_keys, output_amount_secret_keys,
      rct_config, reconstruction, unsigned_tx, CLSAG_contexts, cached_w))
    return false;

@@ -29,6 +29,7 @@

 #pragma once

+#include "cryptonote_protocol/enums.h"
 #include "ringct/rctTypes.h"

 #include <set>
@@ -71,6 +72,7 @@ public:
  bool init(
    const cryptonote::account_keys& account_keys,
    const std::vector<std::uint8_t>& extra,
+    const cryptonote::transaction_type& type,
    const std::uint64_t unlock_time,
    const std::uint32_t subaddr_account,
    const std::set<std::uint32_t>& subaddr_minor_indices,
@@ -299,10 +299,9 @@ namespace nodetool

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

    bool islimitup=false;
@@ -705,32 +705,24 @@ namespace nodetool
    std::set<std::string> full_addrs;
    if (m_nettype == cryptonote::TESTNET)
    {
-      full_addrs.insert("176.9.0.187:28080");
-      full_addrs.insert("88.99.173.38:28080");
-      full_addrs.insert("51.79.173.165:28080");
-      full_addrs.insert("192.99.8.110:28080");
-      full_addrs.insert("37.187.74.171:28080");
+      full_addrs.insert("152.42.130.46:29080");
+      full_addrs.insert("45.55.138.87:29080");
+      full_addrs.insert("209.97.164.15:29080");
    }
    else if (m_nettype == cryptonote::STAGENET)
    {
-      full_addrs.insert("176.9.0.187:38080");
-      full_addrs.insert("88.99.173.38:38080");
-      full_addrs.insert("51.79.173.165:38080");
-      full_addrs.insert("192.99.8.110:38080");
-      full_addrs.insert("37.187.74.171:38080");
+      full_addrs.insert("152.42.130.46:39080");
+      full_addrs.insert("45.55.138.87:39080");
+      full_addrs.insert("209.97.164.15:39080");
    }
    else if (m_nettype == cryptonote::FAKECHAIN)
    {
    }
    else
    {
-      full_addrs.insert("176.9.0.187:18080");
-      full_addrs.insert("88.198.163.90:18080");
-      full_addrs.insert("66.85.74.134:18080");
-      full_addrs.insert("88.99.173.38:18080");
-      full_addrs.insert("51.79.173.165:18080");
-      full_addrs.insert("192.99.8.110:18080");
-      full_addrs.insert("37.187.74.171:18080");
+      full_addrs.insert("152.42.130.46:19080");
+      full_addrs.insert("45.55.138.87:19080");
+      full_addrs.insert("209.97.164.15:19080");
    }
    return full_addrs;
  }
@@ -1110,7 +1110,6 @@ namespace rct {
      const cryptonote::transaction_type tx_type,
      const std::string& in_asset_type,
      const std::vector<std::string> & destination_asset_types,
-      const std::vector<bool> &zero_masks,
      const std::vector<xmr_amount> &inamounts,
      const std::vector<xmr_amount> &outamounts,
      xmr_amount txnFee,
@@ -1127,7 +1126,6 @@ namespace rct {
        CHECK_AND_ASSERT_THROW_MES(inamounts.size() == inSk.size(), "Different number of inamounts/inSk");
        CHECK_AND_ASSERT_THROW_MES(outamounts.size() == destinations.size(), "Different number of amounts/destinations");
        CHECK_AND_ASSERT_THROW_MES(amount_keys.size() == destinations.size(), "Different number of amount_keys/destinations");
-        CHECK_AND_ASSERT_THROW_MES(zero_masks.size() == destinations.size(), "Different number of zero_masks/destinations");
        CHECK_AND_ASSERT_THROW_MES(index.size() == inSk.size(), "Different number of index/inSk");
        CHECK_AND_ASSERT_THROW_MES(mixRing.size() == inSk.size(), "Different number of mixRing/inSk");
        for (size_t n = 0; n < mixRing.size(); ++n) {
@@ -1312,7 +1310,6 @@ namespace rct {
      const cryptonote::transaction_type tx_type,
      const std::string& in_asset_type,
      const std::vector<std::string> & destination_asset_types,
-      const std::vector<bool> &zero_masks,
      const std::vector<xmr_amount> &inamounts,
      const std::vector<xmr_amount> &outamounts,
      const keyV &amount_keys,
@@ -1330,7 +1327,7 @@ namespace rct {
          mixRing[i].resize(mixin+1);
          index[i] = populateFromBlockchainSimple(mixRing[i], inPk[i], mixin);
        }
-        return genRctSimple(message, inSk, destinations, tx_type, in_asset_type, destination_asset_types, zero_masks, inamounts, outamounts, txnFee, mixRing, amount_keys, index, outSk, rct_config, hwdev);
+        return genRctSimple(message, inSk, destinations, tx_type, in_asset_type, destination_asset_types, inamounts, outamounts, txnFee, mixRing, amount_keys, index, outSk, rct_config, hwdev);
    }

    //RingCT protocol
@@ -136,7 +136,6 @@ namespace rct {
        const cryptonote::transaction_type tx_type,
        const std::string& in_asset_type,
        const std::vector<std::string> & destination_asset_types,
-        const std::vector<bool> &zero_masks,
        const std::vector<xmr_amount> & inamounts,
        const std::vector<xmr_amount> & outamounts,
        const keyV &amount_keys,
@@ -152,7 +151,6 @@ namespace rct {
        const cryptonote::transaction_type tx_type,
        const std::string& in_asset_type,
        const std::vector<std::string> & destination_asset_types,
-        const std::vector<bool> &zero_masks,
        const std::vector<xmr_amount> & inamounts,
        const std::vector<xmr_amount> & outamounts,
        xmr_amount txnFee,
@@ -3183,7 +3183,7 @@ namespace cryptonote
      return true;
    }

-    static const char software[] = "monero";
+    static const char software[] = "salvium";
 #ifdef BUILD_TAG
    static const char buildtag[] = BOOST_PP_STRINGIZE(BUILD_TAG);
    static const char subdir[] = "cli";
@@ -3204,7 +3204,7 @@ namespace cryptonote
      res.status = "Error checking for updates";
      return true;
    }
-    if (tools::vercmp(version.c_str(), MONERO_VERSION) <= 0)
+    if (tools::vercmp(version.c_str(), SALVIUM_VERSION) <= 0)
    {
      res.update = false;
      res.status = CORE_RPC_STATUS_OK;
@@ -98,7 +98,7 @@ namespace cryptonote
     , rpc_login({"rpc-login", rpc_args::tr("Specify username[:password] required for RPC server"), "", true})
     , confirm_external_bind({"confirm-external-bind", rpc_args::tr("Confirm rpc-bind-ip value is NOT a loopback (local) IP")})
     , rpc_access_control_origins({"rpc-access-control-origins", rpc_args::tr("Specify a comma separated list of origins to allow cross origin resource sharing"), ""})
-     , rpc_ssl({"rpc-ssl", rpc_args::tr("Enable SSL on RPC connections: enabled|disabled|autodetect"), "autodetect"})
+     , rpc_ssl({"rpc-ssl", rpc_args::tr("Enable SSL on RPC connections: enabled|disabled|autodetect"), "disabled"})
     , rpc_ssl_private_key({"rpc-ssl-private-key", rpc_args::tr("Path to a PEM format private key"), ""})
     , rpc_ssl_certificate({"rpc-ssl-certificate", rpc_args::tr("Path to a PEM format certificate"), ""})
     , rpc_ssl_ca_certificates({"rpc-ssl-ca-certificates", rpc_args::tr("Path to file containing concatenated PEM format certificate(s) to replace system CA(s)."), ""})
@@ -269,6 +269,17 @@ void toJsonValue(rapidjson::Writer<epee::byte_stream>& dest, const cryptonote::t
  INSERT_INTO_JSON_OBJECT(dest, inputs, tx.vin);
  INSERT_INTO_JSON_OBJECT(dest, outputs, tx.vout);
  INSERT_INTO_JSON_OBJECT(dest, extra, tx.extra);
+  INSERT_INTO_JSON_OBJECT(dest, type, static_cast<uint8_t>(tx.type));
+  if (tx.type != cryptonote::transaction_type::PROTOCOL) {
+    INSERT_INTO_JSON_OBJECT(dest, amount_burnt, tx.amount_burnt);
+    if (tx.type != cryptonote::transaction_type::MINER) {
+      INSERT_INTO_JSON_OBJECT(dest, return_address, tx.return_address);
+      INSERT_INTO_JSON_OBJECT(dest, return_pubkey, tx.return_pubkey);
+      INSERT_INTO_JSON_OBJECT(dest, source_asset_type, tx.source_asset_type);
+      INSERT_INTO_JSON_OBJECT(dest, destination_asset_type, tx.destination_asset_type);
+      INSERT_INTO_JSON_OBJECT(dest, amount_slippage_limit, tx.amount_slippage_limit);
+    }
+  }
  if (!tx.pruned)
  {
    INSERT_INTO_JSON_OBJECT(dest, signatures, tx.signatures);
@@ -291,6 +302,19 @@ void fromJsonValue(const rapidjson::Value& val, cryptonote::transaction& tx)
  GET_FROM_JSON_OBJECT(val, tx.vin, inputs);
  GET_FROM_JSON_OBJECT(val, tx.vout, outputs);
  GET_FROM_JSON_OBJECT(val, tx.extra, extra);
+  uint8_t tx_type = 0;
+  GET_FROM_JSON_OBJECT(val, tx_type, type);
+  tx.type = static_cast<cryptonote::transaction_type>(tx_type);
+  if (tx.type != cryptonote::transaction_type::PROTOCOL) {
+    GET_FROM_JSON_OBJECT(val, tx.amount_burnt, amount_burnt);
+    if (tx.type != cryptonote::transaction_type::MINER) {
+      GET_FROM_JSON_OBJECT(val, tx.return_address, return_address);
+      GET_FROM_JSON_OBJECT(val, tx.return_pubkey, return_pubkey);
+      GET_FROM_JSON_OBJECT(val, tx.source_asset_type, source_asset_type);
+      GET_FROM_JSON_OBJECT(val, tx.destination_asset_type, destination_asset_type);
+      GET_FROM_JSON_OBJECT(val, tx.amount_slippage_limit, amount_slippage_limit);
+    }
+  }
  GET_FROM_JSON_OBJECT(val, tx.rct_signatures, ringct);

  const auto& sigs = val.FindMember("signatures");
@@ -1138,6 +1162,7 @@ void toJsonValue(rapidjson::Writer<epee::byte_stream>& dest, const rct::rctSig&
    INSERT_INTO_JSON_OBJECT(dest, encrypted, sig.ecdhInfo);
    INSERT_INTO_JSON_OBJECT(dest, commitments, transform(sig.outPk, just_mask));
    INSERT_INTO_JSON_OBJECT(dest, fee, sig.txnFee);
+    INSERT_INTO_JSON_OBJECT(dest, p_r, sig.p_r);
  }

  // prunable
@@ -1174,6 +1199,7 @@ void fromJsonValue(const rapidjson::Value& val, rct::rctSig& sig)
    GET_FROM_JSON_OBJECT(val, sig.ecdhInfo, encrypted);
    GET_FROM_JSON_OBJECT(val, sig.outPk, commitments);
    GET_FROM_JSON_OBJECT(val, sig.txnFee, fee);
+    GET_FROM_JSON_OBJECT(val, sig.p_r, p_r);
  }

  // prunable
@@ -1691,7 +1691,7 @@ bool simple_wallet::export_raw_multisig(const std::vector<std::string> &args)
    for (auto &ptx: txs.m_ptx)
    {
      const crypto::hash txid = cryptonote::get_transaction_hash(ptx.tx);
-      const std::string filename = std::string("raw_multisig_monero_tx_") + epee::string_tools::pod_to_hex(txid);
+      const std::string filename = std::string("raw_multisig_salvium_tx_") + epee::string_tools::pod_to_hex(txid);
      if (!filenames.empty())
        filenames += ", ";
      filenames += filename;
@@ -3432,7 +3432,7 @@ simple_wallet::simple_wallet()
                           boost::bind(&simple_wallet::on_command, this, &simple_wallet::sign_transfer, _1),
                           tr(USAGE_SIGN_TRANSFER),
                           tr("Sign a transaction from a file. If the parameter \"export_raw\" is specified, transaction raw hex data suitable for the daemon RPC /sendrawtransaction is exported.\n"
-                              "Use the parameter <filename> to specify the file to read from. If not specified, the default \"unsigned_monero_tx\" will be used."));
+                              "Use the parameter <filename> to specify the file to read from. If not specified, the default \"unsigned_salvium_tx\" will be used."));
  m_cmd_binder.set_handler("submit_transfer",
                           boost::bind(&simple_wallet::on_command, this, &simple_wallet::submit_transfer, _1),
                           tr("Submit a signed transaction from a file."));
@@ -7141,7 +7141,7 @@ bool simple_wallet::transfer_main(
    }
    else if (m_wallet->multisig())
    {
-      bool r = m_wallet->save_multisig_tx(ptx_vector, "multisig_monero_tx");
+      bool r = m_wallet->save_multisig_tx(ptx_vector, "multisig_salvium_tx");
      if (!r)
      {
        fail_msg_writer() << tr("Failed to write transaction(s) to file");
@@ -7149,7 +7149,7 @@ bool simple_wallet::transfer_main(
      }
      else
      {
-        success_msg_writer(true) << tr("Unsigned transaction(s) successfully written to file: ") << "multisig_monero_tx";
+        success_msg_writer(true) << tr("Unsigned transaction(s) successfully written to file: ") << "multisig_salvium_tx";
      }
    }
    else if (m_wallet->get_account().get_device().has_tx_cold_sign())
@@ -7178,7 +7178,7 @@ bool simple_wallet::transfer_main(
    }
    else if (m_wallet->watch_only())
    {
-      bool r = m_wallet->save_tx(ptx_vector, "unsigned_monero_tx");
+      bool r = m_wallet->save_tx(ptx_vector, "unsigned_salvium_tx");
      if (!r)
      {
        fail_msg_writer() << tr("Failed to write transaction(s) to file");
@@ -7186,7 +7186,7 @@ bool simple_wallet::transfer_main(
      }
      else
      {
-        success_msg_writer(true) << tr("Unsigned transaction(s) successfully written to file: ") << "unsigned_monero_tx";
+        success_msg_writer(true) << tr("Unsigned transaction(s) successfully written to file: ") << "unsigned_salvium_tx";
      }
    }
    else
@@ -7344,26 +7344,26 @@ bool simple_wallet::sweep_unmixable(const std::vector<std::string> &args_)
    if (m_wallet->multisig())
    {
      CHECK_MULTISIG_ENABLED();
-      bool r = m_wallet->save_multisig_tx(ptx_vector, "multisig_monero_tx");
+      bool r = m_wallet->save_multisig_tx(ptx_vector, "multisig_salvium_tx");
      if (!r)
      {
        fail_msg_writer() << tr("Failed to write transaction(s) to file");
      }
      else
      {
-        success_msg_writer(true) << tr("Unsigned transaction(s) successfully written to file: ") << "multisig_monero_tx";
+        success_msg_writer(true) << tr("Unsigned transaction(s) successfully written to file: ") << "multisig_salvium_tx";
      }
    }
    else if (m_wallet->watch_only())
    {
-      bool r = m_wallet->save_tx(ptx_vector, "unsigned_monero_tx");
+      bool r = m_wallet->save_tx(ptx_vector, "unsigned_salvium_tx");
      if (!r)
      {
        fail_msg_writer() << tr("Failed to write transaction(s) to file");
      }
      else
      {
-        success_msg_writer(true) << tr("Unsigned transaction(s) successfully written to file: ") << "unsigned_monero_tx";
+        success_msg_writer(true) << tr("Unsigned transaction(s) successfully written to file: ") << "unsigned_salvium_tx";
      }
    }
    else
@@ -7652,14 +7652,14 @@ bool simple_wallet::sweep_main(uint32_t account, uint64_t below, bool locked, co
    if (m_wallet->multisig())
    {
      CHECK_MULTISIG_ENABLED();
-      bool r = m_wallet->save_multisig_tx(ptx_vector, "multisig_monero_tx");
+      bool r = m_wallet->save_multisig_tx(ptx_vector, "multisig_salvium_tx");
      if (!r)
      {
        fail_msg_writer() << tr("Failed to write transaction(s) to file");
      }
      else
      {
-        success_msg_writer(true) << tr("Unsigned transaction(s) successfully written to file: ") << "multisig_monero_tx";
+        success_msg_writer(true) << tr("Unsigned transaction(s) successfully written to file: ") << "multisig_salvium_tx";
      }
    }
    else if (m_wallet->get_account().get_device().has_tx_cold_sign())
@@ -7689,14 +7689,14 @@ bool simple_wallet::sweep_main(uint32_t account, uint64_t below, bool locked, co
    }
    else if (m_wallet->watch_only())
    {
-      bool r = m_wallet->save_tx(ptx_vector, "unsigned_monero_tx");
+      bool r = m_wallet->save_tx(ptx_vector, "unsigned_salvium_tx");
      if (!r)
      {
        fail_msg_writer() << tr("Failed to write transaction(s) to file");
      }
      else
      {
-        success_msg_writer(true) << tr("Unsigned transaction(s) successfully written to file: ") << "unsigned_monero_tx";
+        success_msg_writer(true) << tr("Unsigned transaction(s) successfully written to file: ") << "unsigned_salvium_tx";
      }
    }
    else
@@ -7887,14 +7887,14 @@ bool simple_wallet::sweep_single(const std::vector<std::string> &args_)
    if (m_wallet->multisig())
    {
      CHECK_MULTISIG_ENABLED();
-      bool r = m_wallet->save_multisig_tx(ptx_vector, "multisig_monero_tx");
+      bool r = m_wallet->save_multisig_tx(ptx_vector, "multisig_salvium_tx");
      if (!r)
      {
        fail_msg_writer() << tr("Failed to write transaction(s) to file");
      }
      else
      {
-        success_msg_writer(true) << tr("Unsigned transaction(s) successfully written to file: ") << "multisig_monero_tx";
+        success_msg_writer(true) << tr("Unsigned transaction(s) successfully written to file: ") << "multisig_salvium_tx";
      }
    }
    else if (m_wallet->get_account().get_device().has_tx_cold_sign())
@@ -7925,14 +7925,14 @@ bool simple_wallet::sweep_single(const std::vector<std::string> &args_)
    }
    else if (m_wallet->watch_only())
    {
-      bool r = m_wallet->save_tx(ptx_vector, "unsigned_monero_tx");
+      bool r = m_wallet->save_tx(ptx_vector, "unsigned_salvium_tx");
      if (!r)
      {
        fail_msg_writer() << tr("Failed to write transaction(s) to file");
      }
      else
      {
-        success_msg_writer(true) << tr("Unsigned transaction(s) successfully written to file: ") << "unsigned_monero_tx";
+        success_msg_writer(true) << tr("Unsigned transaction(s) successfully written to file: ") << "unsigned_salvium_tx";
      }
    }
    else
@@ -8110,14 +8110,14 @@ bool simple_wallet::return_payment(const std::vector<std::string> &args_)
    if (m_wallet->multisig())
    {
      CHECK_MULTISIG_ENABLED();
-      bool r = m_wallet->save_multisig_tx(ptx_vector, "multisig_monero_tx");
+      bool r = m_wallet->save_multisig_tx(ptx_vector, "multisig_salvium_tx");
      if (!r)
      {
        fail_msg_writer() << tr("Failed to write transaction(s) to file");
      }
      else
      {
-        success_msg_writer(true) << tr("Unsigned transaction(s) successfully written to file: ") << "multisig_monero_tx";
+        success_msg_writer(true) << tr("Unsigned transaction(s) successfully written to file: ") << "multisig_salvium_tx";
      }
    }
    else if (m_wallet->get_account().get_device().has_tx_cold_sign())
@@ -8152,14 +8152,14 @@ bool simple_wallet::return_payment(const std::vector<std::string> &args_)
    }
    else if (m_wallet->watch_only())
    {
-      bool r = m_wallet->save_tx(ptx_vector, "unsigned_monero_tx");
+      bool r = m_wallet->save_tx(ptx_vector, "unsigned_salvium_tx");
      if (!r)
      {
        fail_msg_writer() << tr("Failed to write transaction(s) to file");
      }
      else
      {
-        success_msg_writer(true) << tr("Unsigned transaction(s) successfully written to file: ") << "unsigned_monero_tx";
+        success_msg_writer(true) << tr("Unsigned transaction(s) successfully written to file: ") << "unsigned_salvium_tx";
      }
    }
    else
@@ -8306,6 +8306,12 @@ bool simple_wallet::stake(const std::vector<std::string> &args_)
    return true;
  }

+  if(m_wallet->multisig())
+  {
+     fail_msg_writer() << tr("This is a multisig wallet, staking is not currently supported");
+     return true;
+  }
+  
  std::vector<std::string> local_args;
  local_args.push_back(m_wallet->get_subaddress_as_str({m_current_subaddress_account,0}));
  local_args.insert(local_args.end(), args_.begin(), args_.end());
@@ -8394,86 +8400,43 @@ bool simple_wallet::supply_info(const std::vector<std::string> &args) {
 //----------------------------------------------------------------------------------------------------
 bool simple_wallet::yield_info(const std::vector<std::string> &args) {

-  // Get the total circulating supply of SALs
-  std::vector<std::pair<std::string, std::string>> supply_amounts;
-  if(!m_wallet->get_circulating_supply(supply_amounts)) {
-    fail_msg_writer() << "failed to get circulating supply. Make sure you are connected to a daemon.";
-    return false;
-  }
-  boost::multiprecision::uint128_t total_supply_128 = 0;
-  for (auto supply_asset: supply_amounts) {
-    if (supply_asset.first == "SAL") {
-      boost::multiprecision::uint128_t supply_128(supply_asset.second);
-      total_supply_128 = supply_128;
-      break;
-    }
-  }
+  // EXPERIMENTAL - change to get_yield_summary_info() method
+  uint64_t t_burnt, t_supply, t_locked, t_yield, yps, ybi_size;
+  std::vector<std::tuple<size_t, std::string, uint64_t, uint64_t>> yield_payouts;
+  bool ok = m_wallet->get_yield_summary_info(t_burnt, t_supply, t_locked, t_yield, yps, ybi_size, yield_payouts);

-  // Get the yield data from the blockchain
-  std::vector<cryptonote::yield_block_info> ybi_data;
-  bool r = m_wallet->get_yield_info(ybi_data);
-  if (!r)
-    return false;
-
-  // Scan the entries we have received to gather the state (total yield over period captured)
-  uint64_t total_burnt = 0;
-  uint64_t total_yield = 0;
-  uint64_t yield_per_stake = 0;
-  for (size_t idx=1; idx<ybi_data.size(); ++idx) {
-    if (ybi_data[idx].locked_coins_tally == 0) {
-      total_burnt += ybi_data[idx].slippage_total_this_block;
-    } else {
-      total_yield += ybi_data[idx].slippage_total_this_block;
-    }
-  }
-
-  // Calculate the yield_per_staked_SAL value
-  if (ybi_data.back().locked_coins_tally > 0) {
-    boost::multiprecision::uint128_t yield_per_stake_128 = ybi_data.back().slippage_total_this_block;
-    yield_per_stake_128 *= COIN;
-    yield_per_stake_128 /= ybi_data.back().locked_coins_tally;
-    yield_per_stake = yield_per_stake_128.convert_to<uint64_t>();
-  }
+  // Get the chain height
+  const uint64_t blockchain_height = m_wallet->get_blockchain_current_height();
  
-  // Output the necessary information about yield stats
-  message_writer(console_color_default, false) << boost::format(tr("YIELD INFO:\n\tSupply coins burnt over last %s: %d\n\tTotal coins locked: %d\n\tYield accrued over last %s: %d\n\tYield per SAL staked: %d"))
-    % get_human_readable_timespan((ybi_data.size()-1) * DIFFICULTY_TARGET_V2)
-    % print_money(total_burnt)
-    % print_money(ybi_data.back().locked_coins_tally)
-    % get_human_readable_timespan((ybi_data.size()-1) * DIFFICULTY_TARGET_V2)
-    % print_money(total_yield)
-    % print_money(yield_per_stake);
-
-  // Now summarise our own YIELD TXs that are yet to mature
-  tools::wallet2::transfer_container transfers;
-  m_wallet->get_transfers(transfers);
-  if (transfers.empty())
-    return true;
-  
-  std::map<size_t, size_t> payouts;
  message_writer(console_color_default, false) << boost::format(tr("\nSTAKED FUNDS:"));
-  for (size_t idx = transfers.size()-1; idx>0; --idx) {
-    const tools::wallet2::transfer_details& td = transfers[idx];
-    //if (td.m_block_height < ybi_data[0].block_height) break;
-    if (td.m_tx.type == cryptonote::transaction_type::STAKE) {
-      if (payouts.count(idx)) {
-	message_writer(console_color_green, true) << boost::format(tr("Height %d, txid %s, staked %s SAL, earned %s SAL"))
-	  % td.m_block_height
-	  % td.m_txid
-	  % print_money(td.m_tx.amount_burnt)
-	  % print_money(transfers[payouts[idx]].m_amount - td.m_tx.amount_burnt);
-      } else {
-	message_writer(console_color_green, false) << boost::format(tr("Height %d, txid %s, staked %s SAL"))
-	  % td.m_block_height
-	  % td.m_txid
-	  % print_money(td.m_tx.amount_burnt);
-      }
-    } else if (td.m_tx.type == cryptonote::transaction_type::PROTOCOL) {
-      // Store list of reverse-lookup indices to tell YIELD TXs how much they earned
-      if (transfers[td.m_td_origin_idx].m_tx.type == cryptonote::transaction_type::STAKE)
-	payouts[td.m_td_origin_idx] = idx;
-    }
-  }
+  for (auto &p: yield_payouts) {
+    uint64_t height, burnt, yield;
+    std::string txid;
+    std::tie(height, txid, burnt, yield) = p;
+    if (blockchain_height > ybi_size + height)
+      message_writer(console_color_green, true) << boost::format(tr("Height %d, txid %s, staked %s SAL, earned %s SAL"))
+        % height
+        % txid
+        % print_money(burnt)
+        % print_money(yield);
+    else 
+      message_writer(console_color_green, false) << boost::format(tr("Height %d (matures %d), txid %s, staked %s SAL, %s SAL accrued so far"))
+        % height
+        % (height + 21601)
+        % txid
+        % print_money(burnt)
+        % print_money(yield);
+ }
+
+  // Output the necessary information about yield stats
+  message_writer(console_color_default, false) << boost::format(tr("\nYIELD INFO:\n\tSupply coins burnt over last %s: %d\n\tTotal coins locked: %d\n\tYield accrued over last %s: %d\n\tYield per SAL staked: %d"))
+    % get_human_readable_timespan((ybi_size-1) * DIFFICULTY_TARGET_V2)
+    % print_money(t_burnt)
+    % print_money(t_locked)
+    % get_human_readable_timespan((ybi_size-1) * DIFFICULTY_TARGET_V2)
+    % print_money(t_yield)
+    % print_money(yps);
+  
  return true;
 }
 //----------------------------------------------------------------------------------------------------
@@ -8722,7 +8685,7 @@ bool simple_wallet::sign_transfer(const std::vector<std::string> &args_)
  }

  bool export_raw = false;
-  std::string unsigned_filename = "unsigned_monero_tx";
+  std::string unsigned_filename = "unsigned_salvium_tx";
  if (args_.size() > 2 || (args_.size() == 2 && args_[0] != "export_raw"))
  {
    PRINT_USAGE(USAGE_SIGN_TRANSFER);
@@ -8746,7 +8709,7 @@ bool simple_wallet::sign_transfer(const std::vector<std::string> &args_)
  std::vector<tools::wallet2::pending_tx> ptx;
  try
  {
-    bool r = m_wallet->sign_tx(unsigned_filename, "signed_monero_tx", ptx, [&](const tools::wallet2::unsigned_tx_set &tx){ return accept_loaded_tx(tx); }, export_raw);
+    bool r = m_wallet->sign_tx(unsigned_filename, "signed_salvium_tx", ptx, [&](const tools::wallet2::unsigned_tx_set &tx){ return accept_loaded_tx(tx); }, export_raw);
    if (!r)
    {
      fail_msg_writer() << tr("Failed to sign transaction");
@@ -8766,7 +8729,7 @@ bool simple_wallet::sign_transfer(const std::vector<std::string> &args_)
      txids_as_text += (", ");
    txids_as_text += epee::string_tools::pod_to_hex(get_transaction_hash(t.tx));
  }
-  success_msg_writer(true) << tr("Transaction successfully signed to file ") << "signed_monero_tx" << ", txid " << txids_as_text;
+  success_msg_writer(true) << tr("Transaction successfully signed to file ") << "signed_salvium_tx" << ", txid " << txids_as_text;
  if (export_raw)
  {
    std::string rawfiles_as_text;
@@ -8774,7 +8737,7 @@ bool simple_wallet::sign_transfer(const std::vector<std::string> &args_)
    {
      if (i > 0)
        rawfiles_as_text += ", ";
-      rawfiles_as_text += "signed_monero_tx_raw" + (ptx.size() == 1 ? "" : ("_" + std::to_string(i)));
+      rawfiles_as_text += "signed_salvium_tx_raw" + (ptx.size() == 1 ? "" : ("_" + std::to_string(i)));
    }
    success_msg_writer(true) << tr("Transaction raw hex data exported to ") << rawfiles_as_text;
  }
@@ -8794,7 +8757,7 @@ bool simple_wallet::submit_transfer(const std::vector<std::string> &args_)
  try
  {
    std::vector<tools::wallet2::pending_tx> ptx_vector;
-    bool r = m_wallet->load_tx("signed_monero_tx", ptx_vector, [&](const tools::wallet2::signed_tx_set &tx){ return accept_loaded_tx(tx); });
+    bool r = m_wallet->load_tx("signed_salvium_tx", ptx_vector, [&](const tools::wallet2::signed_tx_set &tx){ return accept_loaded_tx(tx); });
    if (!r)
    {
      fail_msg_writer() << tr("Failed to load transaction from file");
@@ -11401,7 +11364,7 @@ void simple_wallet::commit_or_save(std::vector<tools::wallet2::pending_tx>& ptx_
      cryptonote::blobdata blob;
      tx_to_blob(ptx.tx, blob);
      const std::string blob_hex = epee::string_tools::buff_to_hex_nodelimer(blob);
-      const std::string filename = "raw_monero_tx" + (ptx_vector.size() == 1 ? "" : ("_" + std::to_string(i++)));
+      const std::string filename = "raw_salvium_tx" + (ptx_vector.size() == 1 ? "" : ("_" + std::to_string(i++)));
      if (m_wallet->save_to_file(filename, blob_hex, true))
        success_msg_writer(true) << tr("Transaction successfully saved to ") << filename << tr(", txid ") << txid;
      else
@@ -1,5 +1,5 @@
 #define DEF_SALVIUM_VERSION_TAG "@VERSIONTAG@"
-#define DEF_SALVIUM_VERSION "0.4.2"
+#define DEF_SALVIUM_VERSION "0.5.3"
 #define DEF_MONERO_VERSION_TAG "release"
 #define DEF_MONERO_VERSION "0.18.3.3"
 #define DEF_MONERO_RELEASE_NAME "Zero"
@@ -150,6 +150,7 @@ void TransactionHistoryImpl::refresh()
        ti->m_timestamp = pd.m_timestamp;
        ti->m_confirmations = (wallet_height > pd.m_block_height) ? wallet_height - pd.m_block_height : 0;
        ti->m_unlock_time = pd.m_unlock_time;
+        ti->m_type = static_cast<Monero::transaction_type>(static_cast<uint8_t>(pd.m_tx_type));
        m_history.push_back(ti);

    }
@@ -193,6 +194,7 @@ void TransactionHistoryImpl::refresh()
        ti->m_label = pd.m_subaddr_indices.size() == 1 ? m_wallet->m_wallet->get_subaddress_label({pd.m_subaddr_account, *pd.m_subaddr_indices.begin()}) : "";
        ti->m_timestamp = pd.m_timestamp;
        ti->m_confirmations = (wallet_height > pd.m_block_height) ? wallet_height - pd.m_block_height : 0;
+        ti->m_type = static_cast<Monero::transaction_type>(static_cast<uint8_t>(pd.m_tx.type));

        // single output transaction might contain multiple transfers
        for (const auto &d: pd.m_dests) {
@@ -229,6 +231,7 @@ void TransactionHistoryImpl::refresh()
        ti->m_label = pd.m_subaddr_indices.size() == 1 ? m_wallet->m_wallet->get_subaddress_label({pd.m_subaddr_account, *pd.m_subaddr_indices.begin()}) : "";
        ti->m_timestamp = pd.m_timestamp;
        ti->m_confirmations = 0;
+        ti->m_type = static_cast<Monero::transaction_type>(static_cast<uint8_t>(pd.m_tx.type));
        for (const auto &d : pd.m_dests)
        {
            ti->m_transfers.push_back({d.amount, d.address(m_wallet->m_wallet->nettype(), pd.m_payment_id)});
@@ -258,6 +261,7 @@ void TransactionHistoryImpl::refresh()
        ti->m_label     = m_wallet->m_wallet->get_subaddress_label(pd.m_subaddr_index);
        ti->m_timestamp = pd.m_timestamp;
        ti->m_confirmations = 0;
+        ti->m_type = static_cast<Monero::transaction_type>(static_cast<uint8_t>(pd.m_tx_type));
        m_history.push_back(ti);
        
        LOG_PRINT_L1(__FUNCTION__ << ": Unconfirmed payment found " << pd.m_amount);
@@ -149,4 +149,9 @@ uint64_t TransactionInfoImpl::unlockTime() const
    return m_unlock_time;
 }

+Monero::transaction_type TransactionInfoImpl::type() const
+{
+  return m_type;
+}
+  
 } // namespace
@@ -62,6 +62,7 @@ public:
    virtual const std::vector<Transfer> &transfers() const override;
    virtual uint64_t confirmations() const override;
    virtual uint64_t unlockTime() const override;
+    virtual Monero::transaction_type type() const override;

 private:
    int         m_direction;
@@ -81,6 +82,7 @@ private:
    std::vector<Transfer> m_transfers;
    uint64_t    m_confirmations;
    uint64_t    m_unlock_time;
+    Monero::transaction_type m_type;

    friend class TransactionHistoryImpl;

@@ -49,7 +49,7 @@ enum NetworkType : uint8_t {
    STAGENET
 };

-enum transaction_type {
+enum transaction_type : uint8_t {
    UNSET = 0,
    MINER = 1,
    PROTOCOL = 2,
@@ -233,6 +233,7 @@ struct TransactionInfo
    virtual std::string paymentId() const = 0;
    //! only applicable for output transactions
    virtual const std::vector<Transfer> & transfers() const = 0;
+    virtual Monero::transaction_type type() const = 0;
 };
 /**
 * @brief The TransactionHistory - interface for displaying transaction history
@@ -370,7 +370,7 @@ std::tuple<bool, std::string, std::string, std::string, std::string> WalletManag
    if (!tools::check_updates(software, buildtag, version, hash))
      return std::make_tuple(false, "", "", "", "");

-    if (tools::vercmp(version.c_str(), current_version != nullptr ? current_version : MONERO_VERSION) > 0)
+    if (tools::vercmp(version.c_str(), current_version != nullptr ? current_version : SALVIUM_VERSION) > 0)
    {
      std::string user_url = tools::get_update_url(software, subdir, buildtag, version, true);
      std::string auto_url = tools::get_update_url(software, subdir, buildtag, version, false);
@@ -2411,6 +2411,28 @@ bool wallet2::get_yield_summary_info(uint64_t &total_burnt,
    return false;

  ybi_data_size = ybi_data.size();
+
+  // Iterate over the transfers in our wallet
+  std::map<size_t, size_t> map_payouts;
+  std::map<std::string, std::pair<size_t, std::pair<uint64_t, uint64_t>>> payouts_active;
+  if (m_transfers.size() > 0) {
+    for (size_t idx = m_transfers.size()-1; idx>0; --idx) {
+      const tools::wallet2::transfer_details& td = m_transfers[idx];
+      //if (td.m_block_height < ybi_data[0].block_height) break;
+      if (td.m_tx.type == cryptonote::transaction_type::STAKE) {
+        if (map_payouts.count(idx)) {
+          payouts.push_back(std::make_tuple(td.m_block_height, epee::string_tools::pod_to_hex(td.m_txid), td.m_tx.amount_burnt, m_transfers[map_payouts[idx]].m_amount - td.m_tx.amount_burnt));
+        } else {
+          //payouts.push_back(std::make_tuple(td.m_block_height, epee::string_tools::pod_to_hex(td.m_txid), td.m_tx.amount_burnt, 0));
+          payouts_active[epee::string_tools::pod_to_hex(td.m_txid)] = std::make_pair(td.m_block_height, std::make_pair(td.m_tx.amount_burnt, 0));
+        }
+      } else if (td.m_tx.type == cryptonote::transaction_type::PROTOCOL) {
+        // Store list of reverse-lookup indices to tell YIELD TXs how much they earned
+        if (m_transfers[td.m_td_origin_idx].m_tx.type == cryptonote::transaction_type::STAKE)
+          map_payouts[td.m_td_origin_idx] = idx;
+      }
+    }
+  }
  
  // Scan the entries we have received to gather the state (total yield over period captured)
  total_burnt = 0;
@@ -2421,9 +2443,23 @@ bool wallet2::get_yield_summary_info(uint64_t &total_burnt,
      total_burnt += ybi_data[idx].slippage_total_this_block;
    } else {
      total_yield += ybi_data[idx].slippage_total_this_block;
+
+      // EXPERIMENTAL - add up yield earned for active STAKE TXs
+      for (auto &payout: payouts_active) {
+        if (ybi_data[idx].block_height < payout.second.first) continue; 
+        boost::multiprecision::uint128_t amount_128 = ybi_data[idx].slippage_total_this_block;
+        amount_128 *= payout.second.second.first;
+        amount_128 /= ybi_data[idx].locked_coins_tally;
+        payout.second.second.second += amount_128.convert_to<uint64_t>();
+      }
    }
  }

+  for (auto &payout: payouts_active) {
+    // Copy to the list of payouts proper
+    payouts.push_back(std::make_tuple(payout.second.first, payout.first, payout.second.second.first, payout.second.second.second));
+  }
+
  // Get the total currently locked
  total_locked = ybi_data.back().locked_coins_tally;
  
@@ -2434,51 +2470,11 @@ bool wallet2::get_yield_summary_info(uint64_t &total_burnt,
    yield_per_stake_128 /= ybi_data.back().locked_coins_tally;
    yield_per_stake = yield_per_stake_128.convert_to<uint64_t>();
  }
-
-  // Iterate over the transfers in our wallet
-  std::map<size_t, size_t> map_payouts;
-  for (size_t idx = m_transfers.size()-1; idx>0; --idx) {
-    const tools::wallet2::transfer_details& td = m_transfers[idx];
-    //if (td.m_block_height < ybi_data[0].block_height) break;
-    if (td.m_tx.type == cryptonote::transaction_type::STAKE) {
-      if (map_payouts.count(idx)) {
-        payouts.push_back(std::make_tuple(td.m_block_height, epee::string_tools::pod_to_hex(td.m_txid), td.m_tx.amount_burnt, m_transfers[map_payouts[idx]].m_amount - td.m_tx.amount_burnt));
-      } else {
-        payouts.push_back(std::make_tuple(td.m_block_height, epee::string_tools::pod_to_hex(td.m_txid), td.m_tx.amount_burnt, 0));
-      }
-    } else if (td.m_tx.type == cryptonote::transaction_type::PROTOCOL) {
-      // Store list of reverse-lookup indices to tell YIELD TXs how much they earned
-      if (m_transfers[td.m_td_origin_idx].m_tx.type == cryptonote::transaction_type::STAKE)
-        map_payouts[td.m_td_origin_idx] = idx;
-    }
-  }
  
  // Return success to caller
  return true;
 }
 //----------------------------------------------------------------------------------------------------
-bool wallet2::get_yield_payouts(std::vector<std::tuple<size_t, std::string, uint64_t, uint64_t>> &payouts) {
-
-  // Iterate over the transfers in our wallet
-  std::map<size_t, size_t> map_payouts;
-  for (size_t idx = m_transfers.size()-1; idx>0; --idx) {
-    const tools::wallet2::transfer_details& td = m_transfers[idx];
-    //if (td.m_block_height < ybi_data[0].block_height) break;
-    if (td.m_tx.type == cryptonote::transaction_type::STAKE) {
-      if (map_payouts.count(idx)) {
-        payouts.push_back(std::make_tuple(td.m_block_height, epee::string_tools::pod_to_hex(td.m_txid), td.m_tx.amount_burnt, m_transfers[map_payouts[idx]].m_amount - td.m_tx.amount_burnt));
-      } else {
-        payouts.push_back(std::make_tuple(td.m_block_height, epee::string_tools::pod_to_hex(td.m_txid), td.m_tx.amount_burnt, 0));
-      }
-    } else if (td.m_tx.type == cryptonote::transaction_type::PROTOCOL) {
-      // Store list of reverse-lookup indices to tell YIELD TXs how much they earned
-      if (m_transfers[td.m_td_origin_idx].m_tx.type == cryptonote::transaction_type::STAKE)
-        map_payouts[td.m_td_origin_idx] = idx;
-    }
-  }
-  return true;
-}
-//----------------------------------------------------------------------------------------------------
 void wallet2::process_new_transaction(const crypto::hash &txid, const cryptonote::transaction& tx, const std::vector<uint64_t> &o_indices, const std::vector<uint64_t> &asset_type_output_indices, uint64_t height, uint8_t block_version, uint64_t ts, bool miner_tx, bool pool, bool double_spend_seen, const tx_cache_data &tx_cache_data, std::map<std::pair<uint64_t, uint64_t>, size_t> *output_tracker_cache, bool ignore_callbacks)
 {
  PERF_TIMER(process_new_transaction);
@@ -2714,9 +2710,9 @@ void wallet2::process_new_transaction(const crypto::hash &txid, const cryptonote
            THROW_WALLET_EXCEPTION_IF(!cryptonote::get_output_asset_type(tx.vout[o], asset_type), error::wallet_internal_error, "failed to get output_asset_type");
            m_transfers.push_back(transfer_details{});
            if (m_transfers_indices.count(asset_type) == 0) {
-              m_transfers_indices[asset_type] = std::vector<size_t>{};
+              m_transfers_indices[asset_type] = std::set<size_t>{};
            }
-            m_transfers_indices[asset_type].push_back(m_transfers.size()-1);
+            m_transfers_indices[asset_type].insert(m_transfers.size()-1);
            transfer_details& td = m_transfers.back();
            td.m_block_height = height;
            td.m_internal_output_index = o;
@@ -6921,7 +6917,7 @@ uint64_t wallet2::balance(uint32_t index_major, const std::string& asset_type, b
  uint64_t amount = 0;
  for (const auto& i : balance_per_subaddress(index_major, asset_type, strict))
    amount += i.second;
-  if (asset_type == "SAL") {
+  if (index_major == 0 && asset_type == "SAL") {
    // Iterate over the locked coins, adding them to the _locked_ balance
    for (const auto& i : m_locked_coins)
      amount += i.second.m_amount;
@@ -8293,6 +8289,7 @@ bool wallet2::sign_multisig_tx(multisig_tx_set &exported_txs, std::vector<crypto
      not multisig_tx_builder.init(
        m_account.get_keys(),
        ptx.construction_data.extra,
+        ptx.tx.type,
        ptx.construction_data.unlock_time,
        ptx.construction_data.subaddr_account,
        ptx.construction_data.subaddr_indices,
@@ -10103,9 +10100,12 @@ void wallet2::transfer_selected_rct(std::vector<cryptonote::tx_destination_entry
    for (size_t idx: selected_transfers) {
      subaddr_minor_indices.insert(m_transfers[idx].m_subaddr_index.minor);
    }
+    // Store the TX type
+    tx.type = tx_type;
    THROW_WALLET_EXCEPTION_IF(
      not multisig_tx_builder.init(m_account.get_keys(),
        extra,
+        tx_type,
        unlock_time,
        subaddr_account,
        subaddr_minor_indices,
@@ -10284,7 +10284,7 @@ std::vector<size_t> wallet2::pick_preferred_rct_inputs(uint64_t needed_money, ui
  }
  
  // try to find a rct input of enough size
-  for (size_t& i: m_transfers_indices[asset_type])
+  for (size_t i: m_transfers_indices[asset_type])
  {
    const transfer_details& td = m_transfers[i];
    if (!is_spent(td, false) && !td.m_frozen && td.is_rct() && td.amount() >= needed_money && is_transfer_unlocked(td) && td.m_subaddr_index.major == subaddr_account && subaddr_indices.count(td.m_subaddr_index.minor) == 1)
@@ -10304,25 +10304,28 @@ std::vector<size_t> wallet2::pick_preferred_rct_inputs(uint64_t needed_money, ui
  // this could be made better by picking one of the outputs to be a small one, since those
  // are less useful since often below the needed money, so if one can be used in a pair,
  // it gets rid of it for the future
-  for (size_t i = 0; i < m_transfers_indices[asset_type].size(); i++)
+  for (auto i=m_transfers_indices[asset_type].begin(); i!= m_transfers_indices[asset_type].end(); ++i)
  {
-    size_t idx = m_transfers_indices[asset_type][i];
-    const transfer_details& td = m_transfers[i];
+    size_t idx = *i;
+    const transfer_details& td = m_transfers[idx];
    if (!is_spent(td, false) && !td.m_frozen && !td.m_key_image_partial && td.is_rct() && is_transfer_unlocked(td) && td.m_subaddr_index.major == subaddr_account && subaddr_indices.count(td.m_subaddr_index.minor) == 1)
    {
      if (td.amount() > m_ignore_outputs_above || td.amount() < m_ignore_outputs_below)
      {
-        MDEBUG("Ignoring output " << i << " of amount " << print_money(td.amount()) << " which is outside prescribed range [" << print_money(m_ignore_outputs_below) << ", " << print_money(m_ignore_outputs_above) << "]");
+        MDEBUG("Ignoring output " << idx << " of amount " << print_money(td.amount()) << " which is outside prescribed range [" << print_money(m_ignore_outputs_below) << ", " << print_money(m_ignore_outputs_above) << "]");
        continue;
      }
-      LOG_PRINT_L2("Considering input " << i << ", " << print_money(td.amount()));
-      for (size_t j = i + 1; j < m_transfers_indices[asset_type].size(); ++j)
+      LOG_PRINT_L2("Considering input " << idx << ", " << print_money(td.amount()));
+      if (i == m_transfers_indices[asset_type].end()) continue;
+      auto j = i;
+      std::advance(j, 1);
+      for (; j!=m_transfers_indices[asset_type].end(); ++j)
      {
-        size_t idx2 = m_transfers_indices[asset_type][j];
+        size_t idx2 = *j;
        const transfer_details& td2 = m_transfers[idx2];
        if (td2.amount() > m_ignore_outputs_above || td2.amount() < m_ignore_outputs_below)
        {
-          MDEBUG("Ignoring output " << j << " of amount " << print_money(td2.amount()) << " which is outside prescribed range [" << print_money(m_ignore_outputs_below) << ", " << print_money(m_ignore_outputs_above) << "]");
+          MDEBUG("Ignoring output " << idx2 << " of amount " << print_money(td2.amount()) << " which is outside prescribed range [" << print_money(m_ignore_outputs_below) << ", " << print_money(m_ignore_outputs_above) << "]");
          continue;
        }
        if (!is_spent(td2, false) && !td2.m_frozen && !td2.m_key_image_partial && td2.is_rct() && td.amount() + td2.amount() >= needed_money && is_transfer_unlocked(td2) && td2.m_subaddr_index == td.m_subaddr_index)
@@ -10331,16 +10334,16 @@ std::vector<size_t> wallet2::pick_preferred_rct_inputs(uint64_t needed_money, ui
          // already found. If the same, don't update, and oldest suitable outputs
          // will be used in preference.
          float relatedness = get_output_relatedness(td, td2);
-          LOG_PRINT_L2("  with input " << j << ", " << print_money(td2.amount()) << ", relatedness " << relatedness);
+          LOG_PRINT_L2("  with input " << idx2 << ", " << print_money(td2.amount()) << ", relatedness " << relatedness);
          if (relatedness < current_output_relatdness)
          {
            // reset the current picks with those, and return them directly
            // if they're unrelated. If they are related, we'll end up returning
            // them if we find nothing better
            picks.clear();
-            picks.push_back(i);
-            picks.push_back(j);
-            LOG_PRINT_L0("we could use " << i << " and " << j);
+            picks.push_back(idx);
+            picks.push_back(idx2);
+            LOG_PRINT_L0("we could use " << idx << " and " << idx2);
            if (relatedness == 0.0f)
              return picks;
            current_output_relatdness = relatedness;
@@ -10592,6 +10595,7 @@ std::vector<wallet2::pending_tx> wallet2::create_transactions_2(std::vector<cryp
    break;
  case transaction_type::STAKE:
    THROW_WALLET_EXCEPTION_IF(dest_asset != "SAL", error::wallet_internal_error, "Yield TX must specify 'SAL' destination asset type");
+    THROW_WALLET_EXCEPTION_IF(subaddr_account != 0, error::wallet_internal_error, "Staking is only permitted from main account, not secondary accounts");
    break;
  default:
    THROW_WALLET_EXCEPTION(error::wallet_internal_error, "Invalid tx type specified: " + static_cast<uint64_t>(tx_type));
@@ -10656,7 +10660,7 @@ std::vector<wallet2::pending_tx> wallet2::create_transactions_2(std::vector<cryp
  // Verify that we have outputs in our wallet for the correct asset_type
  THROW_WALLET_EXCEPTION_IF(!m_transfers_indices.count(source_asset), error::wallet_internal_error, "Cannot find outputs with correct asset_type to pay for TX");
  
-  for (size_t& i: m_transfers_indices[source_asset])
+  for (size_t i: m_transfers_indices[source_asset])
  {
    const transfer_details& td = m_transfers[i];
    if (m_ignore_fractional_outputs && td.amount() < fractional_threshold)
@@ -13106,18 +13110,16 @@ uint64_t wallet2::get_daemon_blockchain_target_height(string &err)

 uint64_t wallet2::get_approximate_blockchain_height() const
 {
-  // time of v2 fork
-  const time_t fork_time = m_nettype == TESTNET ? 1448285909 : m_nettype == STAGENET ? 1520937818 : 1458748658;
-  // v2 fork block
-  const uint64_t fork_block = m_nettype == TESTNET ? 624634 : m_nettype == STAGENET ? 32000 : 1009827;
+  if (m_nettype != MAINNET) return 0;
+  
+  // time of v1 fork
+  const time_t fork_time = 1719997643;
+  // v1 fork block
+  const uint64_t fork_block = 0;
  // avg seconds per block
  const int seconds_per_block = DIFFICULTY_TARGET_V2;
  // Calculated blockchain height
  uint64_t approx_blockchain_height = fork_block + (time(NULL) - fork_time)/seconds_per_block;
-  // testnet and stagenet got some huge rollbacks, so the estimation is way off
-  static const uint64_t approximate_rolled_back_blocks = m_nettype == TESTNET ? 342100 : 30000;
-  if ((m_nettype == TESTNET || m_nettype == STAGENET) && approx_blockchain_height > approximate_rolled_back_blocks)
-    approx_blockchain_height -= approximate_rolled_back_blocks;
  LOG_PRINT_L2("Calculated blockchain height: " << approx_blockchain_height);
  return approx_blockchain_height;
 }
@@ -14403,7 +14405,21 @@ crypto::key_image wallet2::get_multisig_composite_key_image(size_t n) const
  for (const auto &info: td.m_multisig_info)
    for (const auto &pki: info.m_partial_key_images)
      pkis.push_back(pki);
-  bool r = multisig::generate_multisig_composite_key_image(get_account().get_keys(), m_subaddresses, td.get_public_key(), tx_key, additional_tx_keys, td.m_internal_output_index, pkis, ki);
+
+  // SRCG: work out if we have origin data to use
+  bool use_origin_data = false;
+  cryptonote::origin_data origin_tx_data;
+  if (td.m_td_origin_idx != (uint64_t)-1) {
+  
+    // Flag to indicate this is a TX that uses a return_address
+    const transfer_details& td_origin = get_transfer_details(td.m_td_origin_idx);
+    origin_tx_data.tx_pub_key = get_tx_pub_key_from_extra(td_origin.m_tx);
+    origin_tx_data.output_index = td_origin.m_internal_output_index;
+    origin_tx_data.tx_type = td_origin.m_tx.type;
+    use_origin_data = true;
+  }
+  
+  bool r = multisig::generate_multisig_composite_key_image(get_account().get_keys(), m_subaddresses, td.get_public_key(), tx_key, additional_tx_keys, td.m_internal_output_index, pkis, ki, use_origin_data, origin_tx_data);
  THROW_WALLET_EXCEPTION_IF(!r, error::wallet_internal_error, "Failed to generate key image");
  return ki;
 }
@@ -625,7 +625,7 @@ private:
    };

    typedef std::vector<transfer_details> transfer_container;
-    typedef serializable_unordered_map<std::string, std::vector<size_t>> transfer_details_indices;
+    typedef serializable_unordered_map<std::string, std::set<size_t>> transfer_details_indices;
    typedef serializable_unordered_multimap<crypto::hash, payment_details> payment_container;
    typedef std::set<uint32_t> unique_index_container;

@@ -1755,7 +1755,6 @@ private:
                                uint64_t &ybi_data_size,
                                std::vector<std::tuple<size_t, std::string, uint64_t, uint64_t>> &payouts
                                );
-    bool get_yield_payouts(std::vector<std::tuple<size_t, std::string, uint64_t, uint64_t>> &payouts);
    
  private:
    /*!
@@ -1,4 +1,10 @@
+de
+es
 fr
 it
 ja
+nl
+pt-pt
+ru
 sv
+zh-cn
@@ -0,0 +1,89 @@
+#!/usr/bin/perl -w -CS
+
+use 5.010;
+use strict;
+use utf8;
+use warnings;
+
+use HTML::Entities;
+use XML::LibXML;
+
+use open qw( :std :encoding(UTF-8) );
+
+#Name of the CSV File
+my $csvfile = $ARGV[0];
+my $lang;
+if ($csvfile =~ /salvium_([a-z]{2}).csv/) {
+    # got a match
+    $lang = $1;
+} else {
+    die "input language code '$lang' is invalid";
+}
+
+# Open the correct input file
+open(CSV, $csvfile) or die "Failed to open $csvfile: $!\n";
+
+# Open the correct output file
+my $xmlfile = "salvium_$lang.ts";
+open(TS, '>', $xmlfile) or die "Failed to open $xmlfile: $!\n";
+
+# Print the preamble
+print TS "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<!DOCTYPE TS>\n<TS version=\"2.1\" language=\"$lang\">\n";
+
+# Print the records
+my $context_name = "";
+my $first_context = 1;
+while (my $csv_line = <CSV>) {
+    # Split the current line based on "===" delimiter
+    my @fields = split("===", $csv_line);
+    if ($fields[0] ne $context_name) {
+        $context_name = $fields[0];
+        if ($first_context) {
+            $first_context = 0;
+        } else {
+            print TS "</context>\n";
+        }
+        print TS "<context>\n    <name>$context_name</name>\n";
+    }
+
+    print TS "    <message>\n";
+
+    # Split the location entries
+    my @locations = split(/\^/, $fields[3]);
+    foreach (@locations) {
+        if ($_ ne "") {
+            # Split into filename + line
+            my($filename, $line) = split(":", $_, 2);
+            $line =~ s/\\n/\n/g;
+            $line =~ s/\r\n/\n/g;
+            $line =~ s/\r//g;
+            chomp($line);
+            print TS "        <location filename=\"$filename\" line=\"$line\"/>\n";
+        }
+    }
+
+    # Output source + translation
+    my $source = $fields[1];
+    $source =~ s/\\n/\n/g;
+    $source =~ s/\r\n/\n/g;
+    $source =~ s/\r//g;
+    my $translation = $fields[2];
+    $translation =~ s/\\n/\n/g;
+    $translation =~ s/\r\n/\n/g;
+    $translation =~ s/\r//g;
+    print TS "        <source>" . $source . "</source>\n";
+    if (length($translation)) {
+        print TS "        <translation>" . $translation . "</translation>\n";
+    } else {
+        print TS "        <translation type=\"unfinished\">" . $translation . "</translation>\n";
+    }
+    print TS "    </message>\n";
+}
+
+# Print the postamble
+print TS "</context>\n";
+print TS "</TS>\n";
+
+# Close the files
+close($xmlfile);
+close($csvfile);
@@ -0,0 +1,39 @@
+#!/usr/bin/perl -w -CS
+
+use 5.010;
+use strict;
+use utf8;
+use warnings;
+
+use HTML::Entities;
+use XML::LibXML;
+
+use open qw( :std :encoding(UTF-8) );
+
+#Name of the XML File
+my $xmlfile = "salvium.ts";
+my $lang = $ARGV[0];
+if (length($lang) != 2) {
+    die "input language code '$lang' is invalid";
+}
+my $csvfile = "salvium_$lang.csv";
+open(CSV, '>', $csvfile);
+
+#Collect the XML and set nodes
+my $dom = XML::LibXML->load_xml(location=>$xmlfile);
+foreach my $context ($dom->findnodes('/TS/context')) {
+    foreach my $message ($context->findnodes('./message')) {
+        my $source = $message->findvalue('./source');
+        $source =~ s/\n/\\n/g;
+        print CSV $context->findvalue('./name') . "===";
+        print CSV encode_entities($source,'<>&"') . "======";
+        my @locations = ();
+        foreach my $location ($message->findnodes('./location')) {
+            my $temp = $location->getAttribute('filename') . ":" . $location->getAttribute('line');
+            push(@locations, $temp);
+        }
+        print CSV join("^", @locations) . "\n";
+    }
+}
+
+close($csvfile);
@@ -0,0 +1,8 @@
+# Configuration for salviumd
+# Syntax: any command line option may be specified as 'clioptionname=value'.
+#         Boolean options such as 'no-igd' are specified as 'no-igd=1'.
+# See 'salviumd --help' for all available options.
+
+data-dir=/var/lib/salvium
+log-file=/var/log/salvium/salvium.log
+log-level=0
@@ -0,0 +1,20 @@
+[Unit]
+Description=Salvium Full Node
+After=network.target
+
+[Service]
+User=salvium
+Group=salvium
+WorkingDirectory=~
+StateDirectory=salvium
+LogsDirectory=salvium
+
+Type=simple
+ExecStart=/usr/bin/salviumd --config-file /etc/salviumd.conf --non-interactive
+StandardOutput=null
+StandardError=null
+
+Restart=always
+
+[Install]
+WantedBy=multi-user.target
@@ -21,7 +21,7 @@ then
  languages=""
  for language in $(cat translations/ready)
  do
-    languages="$languages translations/monero_$language.ts"
+    languages="$languages translations/salvium_$language.ts"
  done
 else
  languages="translations/*.ts"
Author	SHA1	Message	Date
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	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