diff --git a/src/Makefile.am b/src/Makefile.am
index 8f7c3fe1fada6..4d2b25b9a1860 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -205,6 +205,7 @@ BLSCT_H = \
   blsct/tokens/predicate_parser.h \
   blsct/tokens/rpc.h \
   blsct/wallet/address.h \
+  blsct/wallet/balance_proof.h \
   blsct/wallet/hdchain.h \
   blsct/wallet/helpers.h \
   blsct/wallet/import_wallet_type.h \
@@ -214,6 +215,7 @@ BLSCT_H = \
   blsct/wallet/txfactory.h \
   blsct/wallet/txfactory_base.h \
   blsct/wallet/txfactory_global.h \
+  blsct/wallet/unsigned_transaction.h \
   blsct/wallet/verification.h
 
 BLSCT_CPP = \
@@ -268,6 +270,7 @@ BLSCT_CPP = \
   blsct/wallet/txfactory.cpp \
   blsct/wallet/txfactory_base.cpp \
   blsct/wallet/txfactory_global.cpp \
+  blsct/wallet/unsigned_transaction.cpp \
   blsct/wallet/verification.cpp
 
 .PHONY: FORCE check-symbols check-security
@@ -576,12 +579,13 @@ libbitcoin_node_a_SOURCES = \
   blsct/range_proof/generators.cpp \
   blsct/range_proof/msg_amt_cipher.cpp \
   blsct/range_proof/proof_base.cpp \
+  blsct/range_proof/rpc.cpp \
   blsct/set_mem_proof/set_mem_proof.cpp \
   blsct/set_mem_proof/set_mem_proof_setup.cpp \
   blsct/set_mem_proof/set_mem_proof_prover.cpp \
   blsct/tokens/info.cpp \
   blsct/tokens/rpc.cpp \
-  blsct/wallet/rpc.cpp \
+  blsct/wallet/unsigned_transaction.cpp \
   blsct/wallet/verification.cpp \
   blsct/signature.cpp \
   chain.cpp \
@@ -736,9 +740,11 @@ libbitcoin_wallet_a_SOURCES = \
   blsct/set_mem_proof/set_mem_proof_setup.cpp \
   blsct/signature.cpp \
   blsct/wallet/address.cpp \
+  blsct/wallet/balance_proof.cpp \
   blsct/wallet/helpers.cpp \
   blsct/wallet/keyman.cpp \
   blsct/wallet/keyring.cpp \
+  blsct/wallet/unsigned_transaction.cpp \
   blsct/wallet/rpc.cpp \
   blsct/wallet/txfactory.cpp \
   blsct/wallet/txfactory_base.cpp \
@@ -907,6 +913,7 @@ libbitcoin_consensus_a_SOURCES = \
   blsct/set_mem_proof/set_mem_proof_prover.cpp \
   blsct/pos/helpers.cpp \
   blsct/pos/proof.cpp \
+  blsct/public_key.cpp \
   blsct/signature.cpp \
   consensus/amount.h \
   consensus/merkle.cpp \
@@ -987,6 +994,7 @@ libbitcoin_common_a_SOURCES = \
   blsct/tokens/predicate_parser.cpp \
   blsct/wallet/address.cpp \
   blsct/wallet/txfactory_global.cpp \
+  blsct/wallet/unsigned_transaction.cpp \
   chainparams.cpp \
   coins.cpp \
   common/args.cpp \
@@ -1317,6 +1325,7 @@ libnaviokernel_la_SOURCES = \
   blsct/tokens/predicate_exec.cpp \
   blsct/tokens/predicate_parser.cpp \
   blsct/wallet/txfactory_global.cpp \
+  blsct/wallet/unsigned_transaction.cpp \
   blsct/wallet/verification.cpp \
   chain.cpp \
   clientversion.cpp \
diff --git a/src/Makefile.test.include b/src/Makefile.test.include
index 2244cb30f9be7..4c2b9098992bf 100644
--- a/src/Makefile.test.include
+++ b/src/Makefile.test.include
@@ -109,6 +109,7 @@ BITCOIN_TESTS =\
   test/blsct/set_mem_proof/set_mem_proof_tests.cpp \
   test/blsct/signature_tests.cpp \
   test/blsct/sign_verify_tests.cpp \
+  test/blsct_signature_checker_tests.cpp \
   test/bswap_tests.cpp \
   test/checkqueue_tests.cpp \
   test/coins_tests.cpp \
diff --git a/src/Makefile.test_util.include b/src/Makefile.test_util.include
index e58b8410a1b40..1e28676269e71 100644
--- a/src/Makefile.test_util.include
+++ b/src/Makefile.test_util.include
@@ -19,6 +19,7 @@ TEST_UTIL_H = \
   blsct/public_key.h \
   blsct/public_keys.h \
   blsct/signature.h \
+  blsct/wallet/unsigned_transaction.h \
   blsct/wallet/txfactory_global.h \
   test/util/blockfilter.h \
   test/util/chainstate.h \
@@ -54,6 +55,7 @@ libtest_util_a_SOURCES = \
   blsct/public_key.cpp \
   blsct/public_keys.cpp \
   blsct/signature.cpp \
+  blsct/wallet/unsigned_transaction.cpp \
   blsct/wallet/rpc.cpp \
   blsct/wallet/txfactory_global.cpp \
   test/util/blockfilter.cpp \
diff --git a/src/bench/bech32_mod.cpp b/src/bench/bech32_mod.cpp
index 3ef6c904c0fb2..3525e647380b6 100644
--- a/src/bench/bech32_mod.cpp
+++ b/src/bench/bech32_mod.cpp
@@ -25,7 +25,7 @@ static void Bech32ModEncode(benchmark::Bench& bench)
 
 static void Bech32ModDecode(benchmark::Bench& bench)
 {
-    std::string addr = "nv1d3fqq4j2w384smpjxgm95anexe4rjwzr2pc553t0xduxuc3sd35nvatcxpnn2mjyde45sqrtfapnws3kwfc85sm3v9ekzc2r2ajnquzf09282e62xddykn25x3";
+    std::string addr = "nav1d3fqq4j2w384smpjxgm95anexe4rjwzr2pc553t0xduxuc3sd35nvatcxpnn2mjyde45sqrtfapnws3kwfc85sm3v9ekzc2r2ajnquzf09282e62xddykn25x3";
     bench.batch(addr.size()).unit("byte").run([&] {
         bech32_mod::Decode(addr);
     });
diff --git a/src/blockencodings.cpp b/src/blockencodings.cpp
index 18a5fdbed1810..001d1b872139e 100644
--- a/src/blockencodings.cpp
+++ b/src/blockencodings.cpp
@@ -31,7 +31,10 @@ CBlockHeaderAndShortTxIDs::CBlockHeaderAndShortTxIDs(const CBlock& block) :
 
 void CBlockHeaderAndShortTxIDs::FillShortTxIDSelector() const {
     DataStream stream{};
-    stream << header << posProof << nonce;
+    stream << header;
+    if (header.IsProofOfStake())
+        stream << posProof;
+    stream << nonce;
     CSHA256 hasher;
     hasher.Write((unsigned char*)&(*stream.begin()), stream.end() - stream.begin());
     uint256 shorttxidhash;
diff --git a/src/blsct/key_io.h b/src/blsct/key_io.h
index 8ae2bd74f9444..35c8b9b484d5d 100644
--- a/src/blsct/key_io.h
+++ b/src/blsct/key_io.h
@@ -19,13 +19,13 @@ namespace blsct {
 // - 1-byte separator '1'
 // - 154-byte data
 // - 8-byte checksum
-constexpr size_t DOUBLE_PUBKEY_ENC_SIZE = 2 + 1 + bech32_mod::DOUBLE_PUBKEY_DATA_ENC_SIZE + 8;
+constexpr size_t DOUBLE_PUBKEY_ENC_SIZE = 3 + 1 + bech32_mod::DOUBLE_PUBKEY_DATA_ENC_SIZE + 8;
 
 namespace bech32_hrp {
-    const std::string Main = "nv";
-    const std::string TestNet = "tn";
-    const std::string SigNet = "tn";
-    const std::string RegTest = "nr";
+    const std::string Main = "nav";
+    const std::string TestNet = "tnv";
+    const std::string SigNet = "snv";
+    const std::string RegTest = "rnav";
 }
 
 /** Encode DoublePublicKey to Bech32 or Bech32m string. Encoding must be one of BECH32 or BECH32M. */
diff --git a/src/blsct/range_proof/rpc.cpp b/src/blsct/range_proof/rpc.cpp
new file mode 100644
index 0000000000000..2c93a52a7ab23
--- /dev/null
+++ b/src/blsct/range_proof/rpc.cpp
@@ -0,0 +1,80 @@
+// Copyright (c) 2024 The Navio Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <blsct/wallet/balance_proof.h>
+#include <blsct/wallet/rpc.h>
+#include <blsct/wallet/unsigned_transaction.h>
+#include <coins.h>
+#include <core_io.h>
+#include <primitives/transaction.h>
+#include <rpc/server.h>
+#include <rpc/server_util.h>
+#include <rpc/util.h>
+#include <univalue.h>
+#include <validation.h>
+
+RPCHelpMan verifyblsctbalanceproof()
+{
+    return RPCHelpMan{
+        "verifyblsctbalanceproof",
+        "Verifies a zero-knowledge balance proof\n",
+        {
+            {"proof", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The serialized balance proof"},
+            {"additional_commitment", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "The additional commitment to use for the proof signature verification"},
+        },
+        RPCResult{
+            RPCResult::Type::OBJ, "", "", {
+                                              {RPCResult::Type::BOOL, "valid", "Whether the proof is valid"},
+                                              {RPCResult::Type::NUM, "min_amount", "The minimum amount proven"},
+                                          }},
+        RPCExamples{HelpExampleCli("verifyblsctbalanceproof", "\"<hex>\"") + HelpExampleRpc("verifyblsctbalanceproof", "\"<hex>\"")},
+        [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue {
+            LOCK(cs_main);
+            ChainstateManager& chainman = EnsureAnyChainman(request.context);
+            Chainstate& active_chainstate = chainman.ActiveChainstate();
+
+            CCoinsViewCache* coins_view;
+            coins_view = &active_chainstate.CoinsTip();
+
+            // Deserialize the proof
+            std::vector<unsigned char> proof_data = ParseHex(request.params[0].get_str());
+            uint256 hash = MessageHash("BLSCT_BALANCE_PROOF_" + (!request.params[1].isNull() ? request.params[1].get_str() : ""));
+            blsct::Message additional_commitment(hash.begin(), hash.end());
+            DataStream ss{proof_data};
+            blsct::BalanceProof proof;
+            try {
+                ss >> proof;
+            } catch (const std::exception) {
+                throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid proof format");
+            }
+
+            // Verify the proof
+            bool valid = proof.Verify(coins_view, additional_commitment);
+
+            UniValue result(UniValue::VOBJ);
+            result.pushKV("valid", valid);
+            result.pushKV("min_amount", ValueFromAmount(proof.GetMinAmount()));
+
+            return result;
+        },
+    };
+}
+
+void RegisterRangeProofRPCCommands(CRPCTable& t)
+{
+    static const CRPCCommand commands[]{
+        {"blsct", &verifyblsctbalanceproof},
+    };
+    for (const auto& c : commands) {
+        t.appendCommand(c.name, &c);
+    }
+}
+
+Span<const CRPCCommand> GetRangeProofRPCCommands()
+{
+    static const CRPCCommand commands[]{
+        {"blsct", &verifyblsctbalanceproof},
+    };
+    return commands;
+}
\ No newline at end of file
diff --git a/src/blsct/signature.h b/src/blsct/signature.h
index 5c1d1f9fc6ce8..2b38c7449cbf3 100644
--- a/src/blsct/signature.h
+++ b/src/blsct/signature.h
@@ -21,6 +21,9 @@ class Signature
 {
 public:
     Signature();
+    Signature(const std::vector<uint8_t>& vch) {
+        SetVch(vch);
+    };
 
     static Signature Aggregate(const std::vector<blsct::Signature>& sigs);
 
diff --git a/src/blsct/tokens/rpc.cpp b/src/blsct/tokens/rpc.cpp
index db2c662538012..6f79ea5f9d482 100644
--- a/src/blsct/tokens/rpc.cpp
+++ b/src/blsct/tokens/rpc.cpp
@@ -18,7 +18,7 @@ std::vector<RPCResult> tokenInfoResult = {
     RPCResult{RPCResult::Type::OBJ_DYN, "metadata", "the token metadata", {{RPCResult::Type::STR, "xxxx", "value"}}},
     RPCResult{RPCResult::Type::NUM, "maxSupply", "the token max supply"},
     RPCResult{RPCResult::Type::NUM, "currentSupply", true, "the token current supply"},
-    RPCResult{RPCResult::Type::OBJ_DYN, "mintedNft", "the nfts already minted", {{RPCResult::Type::OBJ_DYN, "index", "metadata", {{RPCResult::Type::STR, "xxxx", "value"}}}}},
+    RPCResult{RPCResult::Type::OBJ_DYN, "mintedNft", true, "the nfts already minted", {{RPCResult::Type::OBJ_DYN, "index", "metadata", {{RPCResult::Type::STR, "xxxx", "value"}}}}},
 
 };
 
diff --git a/src/blsct/wallet/balance_proof.cpp b/src/blsct/wallet/balance_proof.cpp
new file mode 100644
index 0000000000000..d41904e10e395
--- /dev/null
+++ b/src/blsct/wallet/balance_proof.cpp
@@ -0,0 +1,6 @@
+#include <blsct/wallet/balance_proof.h>
+#include <coins.h>
+
+namespace blsct {
+// Implementation is in the header file since it's all inline
+} // namespace blsct
diff --git a/src/blsct/wallet/balance_proof.h b/src/blsct/wallet/balance_proof.h
new file mode 100644
index 0000000000000..0ca73b6dd7700
--- /dev/null
+++ b/src/blsct/wallet/balance_proof.h
@@ -0,0 +1,123 @@
+// src/blsct/wallet/balance_proof.h
+#ifndef BITCOIN_BLSCT_WALLET_BALANCE_PROOF_H
+#define BITCOIN_BLSCT_WALLET_BALANCE_PROOF_H
+
+#include <blsct/range_proof/bulletproofs_plus/range_proof.h>
+#include <blsct/range_proof/bulletproofs_plus/range_proof_logic.h>
+#include <coins.h>
+#include <primitives/transaction.h>
+#include <serialize.h>
+#include <wallet/wallet.h>
+
+namespace blsct {
+
+class BalanceProof
+{
+private:
+    std::vector<COutPoint> m_outpoints;
+    CAmount m_min_amount;
+    bulletproofs_plus::RangeProof<Mcl> m_proof;
+    blsct::Signature m_signature;
+    uint16_t m_index;
+
+public:
+    BalanceProof() = default;
+    BalanceProof(const std::vector<COutPoint>& outpoints, CAmount min_amount, const bulletproofs_plus::RangeProof<Mcl>& proof, const blsct::Signature& signature)
+        : m_outpoints(outpoints), m_min_amount(min_amount), m_proof(proof), m_signature(signature), m_index(0) {}
+
+    BalanceProof(const std::vector<COutPoint>& outpoints, CAmount min_amount, const wallet::CWallet& wallet, const blsct::Message& additional_commitment)
+    {
+        m_outpoints = outpoints;
+        m_min_amount = min_amount;
+
+        // Sum up all commitments from the outputs
+        MclScalar value = 0;
+        MclScalar gamma = 0;
+
+        if (outpoints.empty()) {
+            throw std::runtime_error("No outpoints provided");
+        }
+
+        const auto& blsct_km = const_cast<wallet::CWallet&>(wallet).GetOrCreateBLSCTKeyMan();
+        blsct::PrivateKey private_key;
+        bool has_private_key = false;
+        uint16_t index = 0;
+
+        for (const auto& outpoint : outpoints) {
+            const wallet::CWalletTx* wtx = wallet.GetWalletTx(outpoint.hash);
+            if (!wtx) {
+                throw std::runtime_error("Outpoint not found in wallet");
+            }
+
+            if (outpoint.n >= wtx->tx->vout.size()) {
+                throw std::runtime_error("Invalid output index");
+            }
+            const CTxOut& txout = wtx->tx->vout[outpoint.n];
+            if (!has_private_key) {
+                has_private_key = blsct_km->GetSpendingKeyForOutput(txout, private_key);
+                m_index = index;
+            }
+            if (!txout.HasBLSCTRangeProof()) {
+                throw std::runtime_error("Outpoint does not have BLSCT range proof");
+            }
+            auto recoveryData = wtx->GetBLSCTRecoveryData(outpoint.n);
+            value = value + MclScalar(recoveryData.amount);
+            gamma = gamma + MclScalar(recoveryData.gamma);
+            index++;
+        }
+
+        // Create range proof
+        bulletproofs_plus::RangeProofLogic<Mcl> prover;
+        range_proof::GammaSeed<Mcl> nonce(Elements<MclScalar>{1, gamma});
+        std::vector<uint8_t> message;
+        m_proof = prover.Prove({1, value}, nonce, message, TokenId(), MclScalar(min_amount));
+        m_signature = private_key.Sign(additional_commitment);
+    }
+
+    const std::vector<COutPoint>& GetOutpoints() const { return m_outpoints; }
+    CAmount GetMinAmount() const { return m_min_amount; }
+    const bulletproofs_plus::RangeProof<Mcl>& GetProof() const { return m_proof; }
+
+    bool Verify(const CCoinsViewCache& view, const blsct::Message& additional_commitment) const
+    {
+        // Sum up all commitments from the outputs
+        MclG1Point sum_commitment;
+        MclG1Point public_key;
+        uint16_t index = 0;
+        for (const auto& outpoint : m_outpoints) {
+            Coin coin;
+            if (!view.GetCoin(outpoint, coin)) {
+                return false;
+            }
+            if (!coin.out.HasBLSCTRangeProof()) {
+                return false;
+            }
+            if (index == m_index) {
+                public_key = coin.out.blsctData.spendingKey;
+            }
+            sum_commitment = sum_commitment + coin.out.blsctData.rangeProof.Vs[0];
+            index++;
+        }
+
+        const_cast<bulletproofs_plus::RangeProof<Mcl>&>(m_proof).Vs.Clear();
+        const_cast<bulletproofs_plus::RangeProof<Mcl>&>(m_proof).Vs.Add(sum_commitment);
+
+        // Create a range proof with seed for verification
+        bulletproofs_plus::RangeProofWithSeed<Mcl> proof(m_proof, TokenId(), MclScalar(m_min_amount));
+        std::vector<bulletproofs_plus::RangeProofWithSeed<Mcl>> proofs;
+        proofs.push_back(proof);
+
+        // Verify the range proof
+        bulletproofs_plus::RangeProofLogic<Mcl> prover;
+        return prover.Verify(proofs) && blsct::PublicKey(public_key).Verify(additional_commitment, m_signature);
+    }
+
+    SERIALIZE_METHODS(BalanceProof, obj)
+    {
+        READWRITE(obj.m_outpoints, obj.m_min_amount, obj.m_proof, obj.m_signature, obj.m_index);
+    }
+};
+
+} // namespace blsct
+
+#endif // BITCOIN_BLSCT_WALLET_BALANCE_PROOF_H
\ No newline at end of file
diff --git a/src/blsct/wallet/keyman.cpp b/src/blsct/wallet/keyman.cpp
index 19866868e954e..db4c120a93014 100644
--- a/src/blsct/wallet/keyman.cpp
+++ b/src/blsct/wallet/keyman.cpp
@@ -4,6 +4,7 @@
 
 #include <blsct/eip_2333/bls12_381_keygen.h>
 #include <blsct/wallet/keyman.h>
+#include <script/script.h>
 
 namespace blsct {
 bool KeyMan::IsHDEnabled() const
@@ -638,51 +639,53 @@ blsct::PrivateKey KeyMan::GetSpendingKey() const
     return ret;
 }
 
-blsct::PrivateKey KeyMan::GetSpendingKeyForOutput(const CTxOut& out) const
+bool KeyMan::GetSpendingKeyForOutput(const CTxOut& out, blsct::PrivateKey& key) const
 {
     auto hashId = GetHashId(out);
 
-    return GetSpendingKeyForOutput(out, hashId);
+    return GetSpendingKeyForOutput(out, hashId, key);
 }
 
-blsct::PrivateKey KeyMan::GetSpendingKeyForOutput(const CTxOut& out, const CKeyID& hashId) const
+bool KeyMan::GetSpendingKeyForOutput(const CTxOut& out, const CKeyID& hashId, blsct::PrivateKey& key) const
 {
     SubAddressIdentifier id;
 
     if (!GetSubAddressId(hashId, id))
-        throw std::runtime_error(strprintf("%s: could not read subaddress id", __func__));
+        return false;
 
-    return GetSpendingKeyForOutput(out, id);
+    return GetSpendingKeyForOutput(out, id, key);
 }
 
-blsct::PrivateKey KeyMan::GetSpendingKeyForOutput(const CTxOut& out, const SubAddressIdentifier& id) const
+bool KeyMan::GetSpendingKeyForOutput(const CTxOut& out, const SubAddressIdentifier& id, blsct::PrivateKey& key) const
 {
     if (!fViewKeyDefined || !viewKey.IsValid())
         throw std::runtime_error(strprintf("%s: the wallet has no view key available", __func__));
 
     auto sk = GetSpendingKey();
 
-    return CalculatePrivateSpendingKey(out.blsctData.blindingKey, viewKey.GetScalar(), sk.GetScalar(), id.account, id.address);
+    key = CalculatePrivateSpendingKey(out.blsctData.blindingKey, viewKey.GetScalar(), sk.GetScalar(), id.account, id.address);
+
+    return true;
 }
 
-blsct::PrivateKey KeyMan::GetSpendingKeyForOutputWithCache(const CTxOut& out)
+bool KeyMan::GetSpendingKeyForOutputWithCache(const CTxOut& out, blsct::PrivateKey& key)
 {
     auto hashId = GetHashId(out);
 
-    return GetSpendingKeyForOutput(out, hashId);
+    return GetSpendingKeyForOutput(out, hashId, key);
 }
 
-blsct::PrivateKey KeyMan::GetSpendingKeyForOutputWithCache(const CTxOut& out, const CKeyID& hashId)
+bool KeyMan::GetSpendingKeyForOutputWithCache(const CTxOut& out, const CKeyID& hashId, blsct::PrivateKey& key)
 {
     SubAddressIdentifier id;
 
     if (!GetSubAddressId(hashId, id))
-        throw std::runtime_error(strprintf("%s: could not read subaddress id", __func__));
+        return false;
 
-    return GetSpendingKeyForOutput(out, id);
+    return GetSpendingKeyForOutput(out, id, key);
 }
 
-blsct::PrivateKey KeyMan::GetSpendingKeyForOutputWithCache(const CTxOut& out, const SubAddressIdentifier& id)
+bool KeyMan::GetSpendingKeyForOutputWithCache(const CTxOut& out, const SubAddressIdentifier& id, blsct::PrivateKey& key)
 {
     if (!fViewKeyDefined || !viewKey.IsValid())
         throw std::runtime_error(strprintf("%s: the wallet has no view key available", __func__));
@@ -691,16 +694,14 @@ blsct::PrivateKey KeyMan::GetSpendingKeyForOutputWithCache(const CTxOut& out, co
 
     auto outId = (HashWriter() << out.blsctData.blindingKey << viewKey.GetScalar() << sk.GetScalar() << id.account << id.address).GetHash();
 
-    blsct::PrivateKey ret;
-
-    if (GetOutKey(outId, ret))
-        return ret;
+    if (GetOutKey(outId, key))
+        return true;
 
-    ret = CalculatePrivateSpendingKey(out.blsctData.blindingKey, viewKey.GetScalar(), sk.GetScalar(), id.account, id.address);
+    key = CalculatePrivateSpendingKey(out.blsctData.blindingKey, viewKey.GetScalar(), sk.GetScalar(), id.account, id.address);
 
-    AddKeyOutKey(ret, outId);
+    AddKeyOutKey(key, outId);
 
-    return ret;
+    return true;
 }
 
 blsct::PrivateKey KeyMan::GetTokenKey(const uint256& tokenId) const
@@ -734,6 +735,12 @@ bulletproofs_plus::AmountRecoveryResult<Arith> KeyMan::RecoverOutputs(const std:
     return rp.RecoverAmounts(reqs);
 }
 
+bool KeyMan::IsMine(const CScript& script) const
+{
+    LOCK(cs_KeyStore);
+    return setWatchOnly.count(script) > 0;
+}
+
 bool KeyMan::IsMine(const blsct::PublicKey& blindingKey, const blsct::PublicKey& spendingKey, const uint16_t& viewTag)
 {
     if (!fViewKeyDefined || !viewKey.IsValid())
@@ -1057,4 +1064,36 @@ int64_t KeyMan::GetTimeFirstKey() const
     LOCK(cs_KeyStore);
     return nTimeFirstKey;
 }
+
+bool KeyMan::ExtractSpendingKeyFromScript(const CScript& script, blsct::PublicKey& spendingKey) const
+{
+    // Parse the script to find OP_BLSCHECKSIG and extract the public key before it
+    CScript::const_iterator pc = script.begin();
+    opcodetype opcode;
+    std::vector<unsigned char> vch;
+    std::vector<unsigned char> lastData; // Keep track of the last data pushed
+
+    if (script.size() != 50) return false;
+
+    while (pc < script.end()) {
+        if (!script.GetOp(pc, opcode, vch)) {
+            return false;
+        }
+
+        if (opcode == OP_BLSCHECKSIG) {
+            // We found OP_BLSCHECKSIG, the public key should be the last data pushed before this opcode
+            if (lastData.size() == 48) { // BLS public keys are 48 bytes
+                return spendingKey.SetVch(lastData);
+            }
+            return false;
+        }
+
+        // If this is a data push (not an opcode), store it as the last data
+        if (opcode <= OP_PUSHDATA4) {
+            lastData = vch;
+        }
+    }
+
+    return false;
+}
 } // namespace blsct
diff --git a/src/blsct/wallet/keyman.h b/src/blsct/wallet/keyman.h
index 7819b645db986..d7579302da02b 100644
--- a/src/blsct/wallet/keyman.h
+++ b/src/blsct/wallet/keyman.h
@@ -17,6 +17,7 @@
 #include <blsct/wallet/import_wallet_type.h>
 #include <blsct/wallet/keyring.h>
 #include <logging.h>
+#include <util/strencodings.h>
 #include <wallet/crypter.h>
 #include <wallet/scriptpubkeyman.h>
 #include <wallet/walletdb.h>
@@ -61,6 +62,7 @@ class KeyMan : public Manager, public KeyRing
     using SubAddressMap = std::map<CKeyID, SubAddressIdentifier>;
     using SubAddressStrMap = std::map<SubAddress, CKeyID>;
     using SubAddressPoolMapSet = std::map<int64_t, std::set<uint64_t>>;
+    using WatchOnlyScriptMap = std::map<CScriptID, wallet::CKeyMetadata>;
 
     CryptedKeyMap mapCryptedKeys GUARDED_BY(cs_KeyStore);
     CryptedOutKeyMap mapCryptedOutKeys GUARDED_BY(cs_KeyStore);
@@ -68,6 +70,8 @@ class KeyMan : public Manager, public KeyRing
     SubAddressStrMap mapSubAddressesStr GUARDED_BY(cs_KeyStore);
     SubAddressPoolMapSet setSubAddressPool GUARDED_BY(cs_KeyStore);
     SubAddressPoolMapSet setSubAddressReservePool GUARDED_BY(cs_KeyStore);
+    std::set<CScript> setWatchOnly GUARDED_BY(cs_KeyStore);
+    WatchOnlyScriptMap m_script_metadata GUARDED_BY(cs_KeyStore);
 
     int64_t nTimeFirstKey GUARDED_BY(cs_KeyStore) = 0;
     //! Number of pre-generated SubAddresses
@@ -142,9 +146,33 @@ class KeyMan : public Manager, public KeyRing
     bool DeleteKeys();
 
     /** Detect ownership of outputs **/
-    bool IsMine(const CTxOut& txout) { return IsMine(txout.blsctData.blindingKey, txout.blsctData.spendingKey, txout.blsctData.viewTag); };
+    bool IsMine(const CTxOut& txout)
+    {
+        if (txout.blsctData.spendingKey.IsZero()) {
+            blsct::PublicKey extractedSpendingKey;
+            if (ExtractSpendingKeyFromScript(txout.scriptPubKey, extractedSpendingKey)) {
+                return IsMine(txout.blsctData.blindingKey, extractedSpendingKey, txout.blsctData.viewTag);
+            }
+            return false;
+        }
+        return IsMine(txout.blsctData.blindingKey, txout.blsctData.spendingKey, txout.blsctData.viewTag);
+    };
     bool IsMine(const blsct::PublicKey& blindingKey, const blsct::PublicKey& spendingKey, const uint16_t& viewTag);
-    CKeyID GetHashId(const CTxOut& txout) const { return GetHashId(txout.blsctData.blindingKey, txout.blsctData.spendingKey); }
+    bool IsMine(const CScript& script) const;
+    CKeyID GetHashId(const CTxOut& txout) const
+    {
+        if (!txout.scriptPubKey.IsSpendable()) {
+            return CKeyID();
+        }
+        if (txout.blsctData.spendingKey.IsZero()) {
+            blsct::PublicKey extractedSpendingKey;
+            if (ExtractSpendingKeyFromScript(txout.scriptPubKey, extractedSpendingKey)) {
+                return GetHashId(txout.blsctData.blindingKey, extractedSpendingKey);
+            }
+            return CKeyID();
+        }
+        return GetHashId(txout.blsctData.blindingKey, txout.blsctData.spendingKey);
+    }
     CKeyID GetHashId(const blsct::PublicKey& blindingKey, const blsct::PublicKey& spendingKey) const;
     CTxDestination GetDestination(const CTxOut& txout) const;
     blsct::PrivateKey GetMasterSeedKey() const;
@@ -152,12 +180,12 @@ class KeyMan : public Manager, public KeyRing
     blsct::PublicKey GetPublicSpendingKey() const;
     blsct::PrivateKey GetMasterTokenKey() const;
     blsct::PrivateKey GetSpendingKey() const;
-    blsct::PrivateKey GetSpendingKeyForOutput(const CTxOut& out) const;
-    blsct::PrivateKey GetSpendingKeyForOutput(const CTxOut& out, const CKeyID& id) const;
-    blsct::PrivateKey GetSpendingKeyForOutput(const CTxOut& out, const SubAddressIdentifier& id) const;
-    blsct::PrivateKey GetSpendingKeyForOutputWithCache(const CTxOut& out);
-    blsct::PrivateKey GetSpendingKeyForOutputWithCache(const CTxOut& out, const CKeyID& id);
-    blsct::PrivateKey GetSpendingKeyForOutputWithCache(const CTxOut& out, const SubAddressIdentifier& id);
+    bool GetSpendingKeyForOutput(const CTxOut& out, blsct::PrivateKey& key) const;
+    bool GetSpendingKeyForOutput(const CTxOut& out, const CKeyID& id, blsct::PrivateKey& key) const;
+    bool GetSpendingKeyForOutput(const CTxOut& out, const SubAddressIdentifier& id, blsct::PrivateKey& key) const;
+    bool GetSpendingKeyForOutputWithCache(const CTxOut& out, blsct::PrivateKey& key);
+    bool GetSpendingKeyForOutputWithCache(const CTxOut& out, const CKeyID& id, blsct::PrivateKey& key);
+    bool GetSpendingKeyForOutputWithCache(const CTxOut& out, const SubAddressIdentifier& id, blsct::PrivateKey& key);
     bulletproofs_plus::AmountRecoveryResult<Mcl> RecoverOutputs(const std::vector<CTxOut>& outs);
 
     blsct::PrivateKey GetTokenKey(const uint256& tokenId) const;
@@ -199,6 +227,9 @@ class KeyMan : public Manager, public KeyRing
     {
         LogPrintf(("%s " + fmt).c_str(), m_storage.GetDisplayName(), parameters...);
     };
+
+    // Helper function to extract spending key from OP_BLSCHECKSIG script
+    bool ExtractSpendingKeyFromScript(const CScript& script, blsct::PublicKey& spendingKey) const;
 };
 } // namespace blsct
 
diff --git a/src/blsct/wallet/rpc.cpp b/src/blsct/wallet/rpc.cpp
index 37901096d2d39..f1e010540dccf 100644
--- a/src/blsct/wallet/rpc.cpp
+++ b/src/blsct/wallet/rpc.cpp
@@ -2,7 +2,9 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
+#include <blsct/wallet/balance_proof.h>
 #include <blsct/wallet/rpc.h>
+#include <blsct/wallet/unsigned_transaction.h>
 #include <coins.h>
 #include <core_io.h>
 #include <primitives/transaction.h>
@@ -646,6 +648,7 @@ RPCHelpMan sendtokentoblsctaddress()
 
             const bool verbose{request.params[4].isNull() ? false : request.params[11].get_bool()};
 
+            blsct::SubAddress subAddress(std::get<blsct::DoublePublicKey>(destination));
             blsct::CreateTransactionData transactionData(address, AmountFromValue(request.params[2]), sMemo, TokenId(token_id), blsct::CreateTransactionType::NORMAL, 0);
 
             EnsureWalletIsUnlocked(*pwallet);
@@ -723,6 +726,7 @@ RPCHelpMan sendnfttoblsctaddress()
 
             const bool verbose{request.params[4].isNull() ? false : request.params[4].get_bool()};
 
+            blsct::SubAddress subAddress(std::get<blsct::DoublePublicKey>(destination));
             blsct::CreateTransactionData transactionData(address, 1, sMemo, TokenId(token_id, nft_id), blsct::CreateTransactionType::NORMAL, 0);
 
             EnsureWalletIsUnlocked(*pwallet);
@@ -952,7 +956,7 @@ RPCHelpMan listblsctunspent()
                 cctl.m_min_depth = nMinDepth;
                 cctl.m_max_depth = nMaxDepth;
                 LOCK(pwallet->cs_wallet);
-                vecOutputs = AvailableBlsctCoins(*pwallet, &cctl, filter_coins).All();
+                vecOutputs = (pwallet->IsWalletFlagSet(wallet::WALLET_FLAG_BLSCT_OUTPUT_STORAGE) ? AvailableBlsctCoins(*pwallet, &cctl, filter_coins) : AvailableCoins(*pwallet, nullptr, std::nullopt, filter_coins)).All();
             }
 
             LOCK(pwallet->cs_wallet);
@@ -970,6 +974,12 @@ RPCHelpMan listblsctunspent()
                 entry.pushKV("txid", out.outpoint.hash.GetHex());
                 entry.pushKV("vout", (int)out.outpoint.n);
 
+                CTxDestination script_address;
+
+                if (ExtractDestination(out.txout.scriptPubKey, script_address)) {
+                    entry.pushKV("scriptAddress", EncodeDestination(script_address));
+                }
+
                 if (fValidAddress) {
                     entry.pushKV("address", EncodeDestination(address));
 
@@ -1106,6 +1116,897 @@ RPCHelpMan listblscttransactions()
     };
 };
 
+
+static RPCHelpMan setblsctseed()
+{
+    return RPCHelpMan{
+        "setblsctseed",
+        "\nSet or generate a new BLSCT wallet seed. Non-BLSCT wallets will not be upgraded to being a BLSCT wallet. Wallets that are already\n"
+        "BLSCT will have a new BLSCT seed set so that new keys added to the keypool will be derived from this new seed.\n"
+        "\nNote that you will need to MAKE A NEW BACKUP of your wallet after setting the BLSCT wallet seed." +
+            wallet::HELP_REQUIRING_PASSPHRASE,
+        {
+            {"seed", RPCArg::Type::STR, RPCArg::DefaultHint{"random seed"}, "The WIF private key to use as the new HD seed.\n"},
+        },
+        RPCResult{RPCResult::Type::NONE, "", ""},
+        RPCExamples{
+            HelpExampleCli("setblsctseed", "") + HelpExampleCli("setblsctseed", "") + HelpExampleCli("setblsctseed", "\"wifkey\"") + HelpExampleRpc("setblsctseed", "\"wifkey\"")},
+        [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue {
+            std::shared_ptr<wallet::CWallet> const pwallet = wallet::GetWalletForJSONRPCRequest(request);
+            if (!pwallet) return UniValue::VNULL;
+
+            auto blsct_km = pwallet->GetOrCreateBLSCTKeyMan();
+
+            if (pwallet->IsWalletFlagSet(wallet::WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
+                throw JSONRPCError(RPC_WALLET_ERROR, "Cannot set a BLSCT seed to a wallet with private keys disabled");
+            }
+
+            LOCK2(pwallet->cs_wallet, blsct_km->cs_KeyStore);
+
+            // Do not do anything to non-HD wallets
+            if (!pwallet->IsWalletFlagSet(wallet::WALLET_FLAG_BLSCT)) {
+                throw JSONRPCError(RPC_WALLET_ERROR, "Cannot set a BLSCT seed on a non-BLSCT wallet.");
+            }
+
+            EnsureWalletIsUnlocked(*pwallet);
+
+            blsct::PrivateKey master_priv_key;
+            if (request.params[1].isNull()) {
+                master_priv_key = blsct_km->GenerateNewSeed();
+            } else {
+                CKey key = DecodeSecret(request.params[1].get_str());
+                if (!key.IsValid()) {
+                    throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid private key");
+                }
+
+                if (blsct_km->HaveKey(key.GetPubKey().GetID())) {
+                    throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Already have this key (either as an BLSCT seed or as a loose private key)");
+                }
+
+                master_priv_key = key.GetPrivKey();
+            }
+
+            blsct_km->SetHDSeed(master_priv_key);
+
+            return UniValue::VNULL;
+        },
+    };
+}
+
+RPCHelpMan createblsctbalanceproof()
+{
+    return RPCHelpMan{
+        "createblsctbalanceproof",
+        "Creates a zero-knowledge proof that the wallet has at least the specified balance\n",
+        {
+            {"amount", RPCArg::Type::AMOUNT, RPCArg::Optional::NO, "The minimum balance to prove"},
+            {"additional_commitment", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "The additional commitment to use for the proof signature"},
+        },
+        RPCResult{
+            RPCResult::Type::OBJ, "", "", {
+                                              {RPCResult::Type::STR_HEX, "proof", "The serialized balance proof"},
+                                          }},
+        RPCExamples{HelpExampleCli("createblsctbalanceproof", "1.0 \"order id: 100\"") + HelpExampleRpc("createblsctbalanceproof", "1.0 \"order id: 100\"")},
+        [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue {
+            std::vector<COutPoint> outpoints;
+            CAmount target_amount = AmountFromValue(request.params[0]);
+
+            uint256 hash = MessageHash("BLSCT_BALANCE_PROOF_" + (!request.params[1].isNull() ? request.params[1].get_str() : ""));
+            blsct::Message additional_commitment(hash.begin(), hash.end());
+
+            std::shared_ptr<wallet::CWallet> const pwallet = wallet::GetWalletForJSONRPCRequest(request);
+            if (!pwallet) return UniValue::VNULL;
+
+            if (!pwallet->IsWalletFlagSet(wallet::WALLET_FLAG_BLSCT)) {
+                throw JSONRPCError(RPC_WALLET_ERROR, "BLSCT must be enabled for this wallet");
+            }
+
+            LOCK(pwallet->cs_wallet);
+
+            if (target_amount <= 0) {
+                throw JSONRPCError(RPC_INVALID_PARAMETER, "Amount must be positive");
+            }
+
+            // Get available BLSCT coins
+            wallet::CoinFilterParams filter_coins;
+            filter_coins.only_blsct = true;
+            filter_coins.skip_locked = false;
+            filter_coins.include_immature_coinbase = false;
+            wallet::CoinsResult available_coins = AvailableCoins(*pwallet, nullptr, std::nullopt, filter_coins);
+
+            if (available_coins.GetTotalAmount() < target_amount) {
+                throw JSONRPCError(RPC_WALLET_INSUFFICIENT_FUNDS, "Insufficient funds");
+            }
+
+            // Collect outpoints and create balance proof
+            for (const auto& [type, outputs] : available_coins.coins) {
+                for (const auto& output : outputs) {
+                    outpoints.push_back(output.outpoint);
+                }
+            }
+
+            blsct::BalanceProof proof(outpoints, target_amount, *pwallet, additional_commitment);
+
+            // Serialize the proof
+            DataStream ss{};
+            ss << proof;
+
+            UniValue result(UniValue::VOBJ);
+            result.pushKV("proof", HexStr(ss));
+
+            return result;
+        },
+    };
+}
+
+RPCHelpMan createblsctrawtransaction()
+{
+    return RPCHelpMan{
+        "createblsctrawtransaction",
+        "\nCreate a unsigned transaction spending the given inputs and creating new outputs.\n"
+        "Returns hex-encoded raw unsigned transaction.\n"
+        "Note that the transaction's inputs are not signed, and\n"
+        "it is not stored in the wallet or transmitted to the network.\n",
+        {
+            {
+                "inputs",
+                RPCArg::Type::ARR,
+                RPCArg::Optional::NO,
+                "A json array of json objects",
+                {
+                    {
+                        "",
+                        RPCArg::Type::OBJ,
+                        RPCArg::Optional::OMITTED,
+                        "",
+                        {
+                            {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The transaction id"},
+                            {"vout", RPCArg::Type::NUM, RPCArg::Optional::NO, "The output number"},
+                            {"value", RPCArg::Type::NUM, RPCArg::Optional::OMITTED, "The input value in satoshis"},
+                            {"gamma", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED, "The gamma value for the input (hex string)"},
+                            {"private_key", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED, "The private key for signing this input (hex string)"},
+                            {"is_staked_commitment", RPCArg::Type::BOOL, RPCArg::Optional::OMITTED, "Whether this input is a staked commitment"},
+                        },
+                    },
+                },
+            },
+            {
+                "outputs",
+                RPCArg::Type::ARR,
+                RPCArg::Optional::NO,
+                "A json array with outputs (key-value pairs)",
+                {
+                    {
+                        "",
+                        RPCArg::Type::OBJ,
+                        RPCArg::Optional::OMITTED,
+                        "",
+                        {
+                            {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "The BLSCT address to send to"},
+                            {"amount", RPCArg::Type::AMOUNT, RPCArg::Optional::NO, "The amount in " + CURRENCY_UNIT},
+                            {"memo", RPCArg::Type::STR, RPCArg::Default{""}, "A memo used to store in the transaction.\n"
+                                                                             "The recipient will see its value."},
+                            {"token_id", RPCArg::Type::STR_HEX, RPCArg::Default{""}, "The token id for token transactions"},
+                            {"script", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED, "The script in hex format to use for this output"},
+                        },
+                    },
+                },
+            },
+        },
+        RPCResult{
+            RPCResult::Type::STR_HEX, "transaction", "hex string of the transaction"},
+        RPCExamples{
+            HelpExampleCli("createblsctrawtransaction", "\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0,\\\"value\\\":1000000,\\\"gamma\\\":\\\"1234567890abcdef\\\",\\\"private_key\\\":\\\"abcdef1234567890\\\"}]\" \"[{\\\"address\\\":\\\"address\\\",\\\"amount\\\":0.01,\\\"memo\\\":\\\"memo\\\",\\\"token_id\\\":\\\"tokenid\\\"}]\"") +
+            HelpExampleCli("createblsctrawtransaction", "\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]\" \"[{\\\"address\\\":\\\"address\\\",\\\"amount\\\":0.01}]\"") +
+            HelpExampleCli("createblsctrawtransaction", "\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]\" \"[{\\\"address\\\":\\\"address\\\",\\\"amount\\\":0.01,\\\"script\\\":\\\"51\\\"}]\"")},
+        [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue {
+            std::shared_ptr<wallet::CWallet> const pwallet = wallet::GetWalletForJSONRPCRequest(request);
+            if (!pwallet) return UniValue::VNULL;
+
+            // Make sure the results are valid at least up to the most recent block
+            // the user could have gotten from another RPC command prior to now
+            pwallet->BlockUntilSyncedToCurrentChain();
+
+            LOCK(pwallet->cs_wallet);
+
+            auto blsct_km = pwallet->GetOrCreateBLSCTKeyMan();
+
+            // Parse inputs
+            const UniValue& inputs = request.params[0].get_array();
+            std::vector<blsct::UnsignedInput> unsigned_inputs;
+            for (unsigned int idx = 0; idx < inputs.size(); idx++) {
+                const UniValue& input = inputs[idx];
+                const UniValue& o = input.get_obj();
+
+                const Txid txid = Txid::FromUint256(ParseHashO(o, "txid"));
+                const int nOut = o.find_value("vout").getInt<int>();
+                if (nOut < 0)
+                    throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "vout must be positive");
+
+                blsct::UnsignedInput unsigned_input;
+                unsigned_input.in.prevout = COutPoint(txid, nOut);
+
+                // Parse optional value field
+                if (o.exists("value")) {
+                    CAmount value = o["value"].getInt<CAmount>();
+                    if (value < 0)
+                        throw JSONRPCError(RPC_INVALID_PARAMETER, "Input value must be positive");
+                    unsigned_input.value = Scalar(value);
+                }
+
+                // Parse optional gamma field
+                if (o.exists("gamma")) {
+                    std::string gamma_hex = o["gamma"].get_str();
+                    if (!gamma_hex.empty()) {
+                        try {
+                            std::vector<unsigned char> gamma_bytes = ParseHex(gamma_hex);
+                            if (gamma_bytes.size() != 32) {
+                                throw JSONRPCError(RPC_INVALID_PARAMETER, "Gamma must be 32 bytes (64 hex characters)");
+                            }
+                            unsigned_input.gamma = Scalar(gamma_bytes);
+                        } catch (const std::exception& e) {
+                            throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Invalid gamma hex string: %s", e.what()));
+                        }
+                    }
+                }
+
+                // Parse optional private key field
+                if (o.exists("private_key")) {
+                    std::string sk_hex = o["private_key"].get_str();
+                    if (!sk_hex.empty()) {
+                        try {
+                            std::vector<unsigned char> sk_bytes = ParseHex(sk_hex);
+                            if (sk_bytes.size() != 32) {
+                                throw JSONRPCError(RPC_INVALID_PARAMETER, "Private key must be 32 bytes (64 hex characters)");
+                            }
+                            unsigned_input.sk = blsct::PrivateKey(Scalar(sk_bytes));
+                        } catch (const std::exception& e) {
+                            throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Invalid private key hex string: %s", e.what()));
+                        }
+                    }
+                }
+
+                // Parse optional is_staked_commitment field
+                if (o.exists("is_staked_commitment")) {
+                    unsigned_input.is_staked_commitment = o["is_staked_commitment"].get_bool();
+                }
+
+                // If value or gamma are not provided, try to get them from the wallet
+                if (!o.exists("value") || !o.exists("gamma")) {
+                    // Get the transaction from the wallet
+                    auto wallet_tx = pwallet->GetWalletTx(txid);
+                    if (!wallet_tx) {
+                        throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Transaction %s not found in wallet", txid.GetHex()));
+                    }
+
+                    // Get BLSCT recovery data for this output
+                    auto recovery_data = wallet_tx->GetBLSCTRecoveryData(nOut);
+                    if (recovery_data.amount == 0 && recovery_data.gamma == Scalar(0) && recovery_data.id == 0 && recovery_data.message == "") {
+                        throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("BLSCT recovery data not available for output %s:%d", txid.GetHex(), nOut));
+                    }
+
+                    // Set value if not provided
+                    if (!o.exists("value")) {
+                        unsigned_input.value = Scalar(recovery_data.amount);
+                    }
+
+                    // Set gamma if not provided
+                    if (!o.exists("gamma")) {
+                        unsigned_input.gamma = recovery_data.gamma;
+                    }
+                }
+
+                // If private key is not provided, try to get it from the wallet
+                if (!o.exists("private_key")) {
+                    // Get the output to determine the token ID
+                    auto wallet_tx = pwallet->GetWalletTx(txid);
+                    if (!wallet_tx) {
+                        throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Transaction %s not found in wallet", txid.GetHex()));
+                    }
+
+                    const CTxOut& txout = wallet_tx->tx->vout[nOut];
+
+                    // Get the spending key for this output
+                    blsct::PrivateKey spending_key;
+                    if (!blsct_km->GetSpendingKeyForOutputWithCache(txout, spending_key) || !spending_key.IsValid()) {
+                        throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Spending key not available for output %s:%d", txid.GetHex(), nOut));
+                    }
+
+                    unsigned_input.sk = spending_key;
+                }
+
+                unsigned_inputs.push_back(unsigned_input);
+            }
+
+            // Parse type
+            blsct::CreateTransactionType type = blsct::NORMAL;
+            if (!request.params[2].isNull()) {
+                std::string type_str = request.params[2].get_str();
+                if (type_str == "create_token") {
+                    type = blsct::TX_CREATE_TOKEN;
+                } else if (type_str == "mint_token") {
+                    type = blsct::TX_MINT_TOKEN;
+                } else if (type_str == "mint_nft") {
+                    type = blsct::TX_MINT_TOKEN;
+                } else if (type_str != "normal") {
+                    throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid transaction type");
+                }
+            }
+
+            // Parse outputs
+            const UniValue& outputs = request.params[1].get_array();
+            std::vector<blsct::UnsignedOutput> unsigned_outputs;
+            for (unsigned int idx = 0; idx < outputs.size(); idx++) {
+                const UniValue& output = outputs[idx];
+                const UniValue& o = output.get_obj();
+
+                if (!o.exists("address") || !o.exists("amount")) {
+                    throw JSONRPCError(RPC_INVALID_PARAMETER, "Each output must have an address and amount");
+                }
+
+                std::string address = o["address"].get_str();
+                CTxDestination destination = DecodeDestination(address);
+                if (!IsValidDestination(destination) || destination.index() != 8) {
+                    throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, std::string("Invalid BLSCT address: ") + address);
+                }
+
+                CAmount nAmount = AmountFromValue(o["amount"]);
+                if (nAmount < 0)
+                    throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid amount, must be positive");
+
+                std::string memo = o.exists("memo") ? o["memo"].get_str() : "";
+                TokenId token_id;
+                if (o.exists("token_id") && !o["token_id"].get_str().empty()) {
+                    token_id = TokenId(ParseHashV(o["token_id"], "token_id"));
+                }
+
+                blsct::SubAddress subAddress(std::get<blsct::DoublePublicKey>(destination));
+                blsct::UnsignedOutput unsigned_output;
+
+                // Check if script is provided
+                if (o.exists("script") && !o["script"].get_str().empty()) {
+                    std::string script_hex = o["script"].get_str();
+                    try {
+                        std::vector<unsigned char> script_bytes = ParseHex(script_hex);
+                        CScript script(script_bytes.begin(), script_bytes.end());
+                        unsigned_output = CreateOutput(std::make_pair(subAddress.GetKeys(), script), nAmount, memo, token_id, Scalar::Rand(), type, 0);
+                    } catch (const std::exception& e) {
+                        throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Invalid script hex string: %s", e.what()));
+                    }
+                } else {
+                    unsigned_output = CreateOutput(subAddress.GetKeys(), nAmount, memo, token_id, Scalar::Rand(), type);
+                }
+
+                unsigned_outputs.push_back(unsigned_output);
+            }
+
+            // Create unsigned transaction
+            blsct::UnsignedTransaction unsigned_tx;
+
+            unsigned_tx = blsct::UnsignedTransaction();
+
+            // Add inputs and outputs
+            for (const auto& input : unsigned_inputs) {
+                unsigned_tx.AddInput(input);
+            }
+            for (const auto& output : unsigned_outputs) {
+                unsigned_tx.AddOutput(output);
+            }
+
+            // Serialize the transaction
+            return HexStr(unsigned_tx.Serialize());
+        },
+    };
+}
+
+RPCHelpMan fundblsctrawtransaction()
+{
+    return RPCHelpMan{
+        "fundblsctrawtransaction",
+        "\nAdd inputs to a BLSCT transaction until it has enough value to cover outputs and fee.\n",
+        {
+            {"hexstring", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The hex string of the raw transaction"},
+            {"changeaddress", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "The BLSCT address to receive the change"},
+        },
+        RPCResult{
+            RPCResult::Type::STR_HEX, "transaction", "hex string of the funded transaction"},
+        RPCExamples{
+            HelpExampleCli("fundblsctrawtransaction", "\"hexstring\"") +
+            HelpExampleCli("fundblsctrawtransaction", "\"hexstring\" \"changeaddress\"")},
+        [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue {
+            std::shared_ptr<wallet::CWallet> const pwallet = wallet::GetWalletForJSONRPCRequest(request);
+            if (!pwallet) return UniValue::VNULL;
+
+            // Make sure the results are valid at least up to the most recent block
+            pwallet->BlockUntilSyncedToCurrentChain();
+
+            LOCK(pwallet->cs_wallet);
+
+            auto blsct_km = pwallet->GetOrCreateBLSCTKeyMan();
+
+            // Parse the unsigned transaction
+            std::vector<unsigned char> txData = ParseHex(request.params[0].get_str());
+            auto unsigned_tx_opt = blsct::UnsignedTransaction::Deserialize(txData);
+            if (!unsigned_tx_opt) {
+                throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "Transaction deserialization failed");
+            }
+            auto& unsigned_tx = unsigned_tx_opt.value();
+
+            // Calculate total output amount
+            CAmount output_value = 0;
+            for (const auto& out : unsigned_tx.GetOutputs()) {
+                output_value += out.value.GetUint64();
+                if (!MoneyRange(output_value)) {
+                    throw JSONRPCError(RPC_INVALID_PARAMETER, "Output value is too large");
+                }
+            }
+
+            // Calculate total input amount from existing inputs
+            CAmount existing_input_value = 0;
+            std::set<COutPoint> existing_inputs;
+            for (const auto& input : unsigned_tx.GetInputs()) {
+                existing_input_value += input.value.GetUint64();
+                existing_inputs.insert(input.in.prevout);
+            }
+
+            // Add fixed fee
+            CAmount required_value = output_value + COIN / 100; // 0.01 fixed fee
+            unsigned_tx.SetFee(COIN / 100);
+
+            // Calculate how much more we need
+            CAmount additional_required = required_value - existing_input_value;
+
+            // Get change address (needed for both cases)
+            CTxDestination change_dest;
+            if (!request.params[1].isNull()) {
+                change_dest = DecodeDestination(request.params[1].get_str());
+                if (!IsValidDestination(change_dest) || change_dest.index() != 8) {
+                    throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid BLSCT change address");
+                }
+            } else {
+                // Get new change address from wallet
+                change_dest = std::get<blsct::DoublePublicKey>(blsct_km->GetNewDestination(blsct::CHANGE_ACCOUNT).value());
+            }
+
+            // Check if we need a change output even without additional inputs
+            if (additional_required <= 0) {
+                // Add change output if needed
+                CAmount total_input_value = existing_input_value;
+
+                if (total_input_value > required_value) {
+                    CAmount change_value = total_input_value - required_value;
+                    blsct::SubAddress change_subaddr(std::get<blsct::DoublePublicKey>(change_dest));
+                    blsct::UnsignedOutput change_output = CreateOutput(change_subaddr.GetKeys(), change_value, "", TokenId(), Scalar::Rand());
+                    unsigned_tx.AddOutput(change_output);
+                }
+
+                return HexStr(unsigned_tx.Serialize());
+            }
+
+            // Find unspent outputs to use as inputs
+            wallet::CoinFilterParams filter_coins;
+            filter_coins.only_blsct = true;
+            filter_coins.skip_locked = false;
+            filter_coins.include_immature_coinbase = false;
+            wallet::CoinsResult available_outputs = AvailableCoins(*pwallet, nullptr, std::nullopt, filter_coins);
+
+            CAmount additional_input_value = 0;
+            for (const auto& [type, outputs] : available_outputs.coins) {
+                for (const auto& output : outputs) {
+                    // Skip if this output is already used as an input
+                    if (existing_inputs.count(output.outpoint) > 0) {
+                        continue;
+                    }
+
+                    auto wallet_tx = pwallet->GetWalletTx(output.outpoint.hash);
+                    if (!wallet_tx) {
+                        throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Transaction %s not found in wallet", output.outpoint.hash.GetHex()));
+                    }
+
+                    // Get BLSCT recovery data for this output
+                    auto recovery_data = wallet_tx->GetBLSCTRecoveryData(output.outpoint.n);
+
+                    if (recovery_data.amount == 0 && recovery_data.gamma == Scalar(0) && recovery_data.id == 0 && recovery_data.message == "") {
+                        throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("BLSCT recovery data not available for output %s:%d", output.outpoint.hash.GetHex(), output.outpoint.n));
+                    }
+
+                    blsct::UnsignedInput input;
+                    input.in.prevout = output.outpoint;
+                    input.value = Scalar(recovery_data.amount);
+                    input.gamma = recovery_data.gamma;
+
+                    // Get the spending key for this output
+                    blsct::PrivateKey spending_key;
+                    if (!blsct_km->GetSpendingKeyForOutputWithCache(output.txout, spending_key) || !spending_key.IsValid()) {
+                        throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Spending key not available for output %s:%d", output.outpoint.hash.GetHex(), output.outpoint.n));
+                    }
+
+                    input.sk = spending_key;
+
+                    unsigned_tx.AddInput(input);
+                    additional_input_value += recovery_data.amount;
+
+                    if (additional_input_value >= additional_required) break;
+                }
+
+                if (additional_input_value >= additional_required) break;
+            }
+
+            if (additional_input_value < additional_required) {
+                throw JSONRPCError(RPC_WALLET_INSUFFICIENT_FUNDS, "Insufficient funds");
+            }
+
+            // Add change output if needed
+            CAmount total_input_value = existing_input_value + additional_input_value;
+
+            if (total_input_value > required_value) {
+                CAmount change_value = total_input_value - required_value;
+                blsct::SubAddress change_subaddr(std::get<blsct::DoublePublicKey>(change_dest));
+                blsct::UnsignedOutput change_output = CreateOutput(change_subaddr.GetKeys(), change_value, "", TokenId(), Scalar::Rand());
+                unsigned_tx.AddOutput(change_output);
+            }
+
+            return HexStr(unsigned_tx.Serialize());
+        },
+    };
+}
+
+RPCHelpMan signblsctrawtransaction()
+{
+    return RPCHelpMan{
+        "signblsctrawtransaction",
+        "\nSigns a BLSCT raw transaction by adding BLSCT signatures.\n",
+        {
+            {"hexstring", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The transaction hex string"},
+        },
+        RPCResult{
+            RPCResult::Type::STR_HEX, "hex", "The signed transaction hex"},
+        RPCExamples{
+            HelpExampleRpc("signblsctrawtransaction", "\"hexstring\"")},
+        [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue {
+            std::shared_ptr<wallet::CWallet> const pwallet = wallet::GetWalletForJSONRPCRequest(request);
+            if (!pwallet) return UniValue::VNULL;
+
+            // Make sure the results are valid at least up to the most recent block
+            // the user could have gotten from another RPC command prior to now
+            pwallet->BlockUntilSyncedToCurrentChain();
+
+            LOCK(pwallet->cs_wallet);
+
+            std::vector<unsigned char> tx_data = ParseHex(request.params[0].get_str());
+            auto unsigned_tx_opt = blsct::UnsignedTransaction::Deserialize(tx_data);
+            if (!unsigned_tx_opt) {
+                throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "Transaction deserialization failed");
+            }
+            auto& unsigned_tx = unsigned_tx_opt.value();
+
+            // Sign the transaction
+            const auto& tx_opt = unsigned_tx.Sign();
+            if (!tx_opt) {
+                throw JSONRPCError(RPC_WALLET_ERROR, "Failed to sign transaction");
+            }
+            auto tx = tx_opt.value();
+
+            return EncodeHexTx(tx);
+        },
+    };
+}
+
+RPCHelpMan decodeblsctrawtransaction()
+{
+    return RPCHelpMan{
+        "decodeblsctrawtransaction",
+        "\nDecode a BLSCT raw transaction and return a JSON object describing the transaction structure.\n",
+        {
+            {"hexstring", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The transaction hex string"},
+        },
+        RPCResult{
+            RPCResult::Type::OBJ, "", "", {
+                                              {RPCResult::Type::ARR, "inputs", "Array of transaction inputs", {
+                                                                                                                  {RPCResult::Type::OBJ, "", "", {
+                                                                                                                                                     {RPCResult::Type::STR_HEX, "txid", "The transaction id"},
+                                                                                                                                                     {RPCResult::Type::NUM, "vout", "The output number"},
+                                                                                                                                                     {RPCResult::Type::NUM, "value", "The input value"},
+                                                                                                                                                     {RPCResult::Type::STR_HEX, "gamma", "The gamma value (hex string)"},
+                                                                                                                                                     {RPCResult::Type::BOOL, "is_staked_commitment", "Whether this input is a staked commitment"},
+                                                                                                                                                 }},
+                                                                                                              }},
+                                              {RPCResult::Type::ARR, "outputs", "Array of transaction outputs", {
+                                                                                                                    {RPCResult::Type::OBJ, "", "", {
+                                                                                                                                                       {RPCResult::Type::STR_AMOUNT, "amount", "The amount in " + CURRENCY_UNIT},
+                                                                                                                                                       {RPCResult::Type::STR_HEX, "blinding_key", "The blinding key (hex string)"},
+                                                                                                                                                       {RPCResult::Type::STR_HEX, "gamma", "The gamma value (hex string)"},
+                                                                                                                                                   }},
+                                                                                                                }},
+                                              {RPCResult::Type::STR_AMOUNT, "fee", "The transaction fee in " + CURRENCY_UNIT},
+                                          }},
+        RPCExamples{HelpExampleCli("decodeblsctrawtransaction", "\"hexstring\"") + HelpExampleRpc("decodeblsctrawtransaction", "\"hexstring\"")},
+        [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue {
+            std::vector<unsigned char> tx_data = ParseHex(request.params[0].get_str());
+            auto unsigned_tx_opt = blsct::UnsignedTransaction::Deserialize(tx_data);
+            if (!unsigned_tx_opt) {
+                throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "Transaction deserialization failed");
+            }
+            auto& unsigned_tx = unsigned_tx_opt.value();
+
+            UniValue result(UniValue::VOBJ);
+
+            // Decode inputs
+            UniValue inputs(UniValue::VARR);
+            for (const auto& input : unsigned_tx.GetInputs()) {
+                UniValue input_obj(UniValue::VOBJ);
+                input_obj.pushKV("txid", input.in.prevout.hash.GetHex());
+                input_obj.pushKV("vout", (int)input.in.prevout.n);
+                input_obj.pushKV("value", ValueFromAmount(input.value.GetUint64()));
+                input_obj.pushKV("gamma", HexStr(input.gamma.GetVch()));
+                input_obj.pushKV("is_staked_commitment", input.is_staked_commitment);
+                inputs.push_back(input_obj);
+            }
+            result.pushKV("inputs", inputs);
+
+            // Decode outputs
+            UniValue outputs(UniValue::VARR);
+            for (const auto& output : unsigned_tx.GetOutputs()) {
+                UniValue output_obj(UniValue::VOBJ);
+
+                // Decode the address from the CTxOut
+                CTxDestination destination;
+                if (ExtractDestination(output.out.scriptPubKey, destination)) {
+                    output_obj.pushKV("scriptAddress", EncodeDestination(destination));
+                } else {
+                    output_obj.pushKV("scriptAddress", "");
+                }
+
+                output_obj.pushKV("amount", ValueFromAmount(output.value.GetUint64()));
+
+                output_obj.pushKV("blinding_key", HexStr(output.blindingKey.GetVch()));
+                output_obj.pushKV("gamma", HexStr(output.gamma.GetVch()));
+                outputs.push_back(output_obj);
+            }
+            result.pushKV("outputs", outputs);
+
+            // Add fee
+            result.pushKV("fee", ValueFromAmount(unsigned_tx.GetFee()));
+
+            return result;
+        },
+    };
+}
+
+static RPCHelpMan getblsctrecoverydata()
+{
+    return RPCHelpMan{
+        "getblsctrecoverydata",
+        "\nGet BLSCT recovery data for transaction output(s)\n",
+        {
+            {"txid_or_hex", RPCArg::Type::STR, RPCArg::Optional::NO, "The transaction id or raw transaction hex"},
+            {"vout", RPCArg::Type::NUM, RPCArg::Optional::OMITTED, "The output index. If omitted, shows data for all outputs."},
+        },
+        RPCResult{
+            RPCResult::Type::OBJ, "", "", {
+                                              {RPCResult::Type::ARR, "outputs", "Array of outputs with recovery data", {
+                                                                                                                           {RPCResult::Type::OBJ, "", "", {
+                                                                                                                                                              {RPCResult::Type::NUM, "vout", "Output index"},
+                                                                                                                                                              {RPCResult::Type::STR_HEX, "script", "The script hex"},
+                                                                                                                                                              {RPCResult::Type::STR_AMOUNT, "amount", "The recovered amount in " + CURRENCY_UNIT},
+                                                                                                                                                              {RPCResult::Type::STR_HEX, "gamma", "The gamma value (hex string)"},
+                                                                                                                                                              {RPCResult::Type::STR, "message", "The memo/message associated with this output"},
+                                                                                                                                                          }},
+                                                                                                                       }},
+                                          }},
+        RPCExamples{HelpExampleCli("getblsctrecoverydata", "\"mytxid\"") + HelpExampleCli("getblsctrecoverydata", "\"mytxid\" 1") + HelpExampleRpc("getblsctrecoverydata", "\"mytxid\", 1")},
+        [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue {
+            std::shared_ptr<wallet::CWallet> const wallet = wallet::GetWalletForJSONRPCRequest(request);
+            if (!wallet) return NullUniValue;
+
+            LOCK(wallet->cs_wallet);
+
+            CMutableTransaction mtx;
+            uint256 hash;
+            bool is_hex_input = false;
+
+            // Parse input as either txid or hex
+            std::string input = request.params[0].get_str();
+            if (input.length() == 64) {
+                hash = uint256S(input);
+                auto tx = wallet->GetWalletTx(hash);
+                if (!tx) {
+                    throw JSONRPCError(RPC_INVALID_PARAMETER, "Transaction not found in wallet");
+                }
+                mtx = CMutableTransaction(*tx->tx);
+            } else {
+                if (!DecodeHexTx(mtx, input)) {
+                    throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "Transaction decode failed");
+                }
+                hash = mtx.GetHash();
+                is_hex_input = true;
+            }
+
+            int specific_vout = -1;
+            if (!request.params[1].isNull()) {
+                specific_vout = request.params[1].getInt<int>();
+                if (specific_vout < 0 || specific_vout >= (int)mtx.vout.size()) {
+                    throw JSONRPCError(RPC_INVALID_PARAMETER, "vout index out of range");
+                }
+            }
+
+            UniValue result(UniValue::VOBJ);
+            UniValue outputs(UniValue::VARR);
+
+            if (is_hex_input) {
+                // For hex input, use BLSCT key manager to recover outputs
+                auto blsct_km = wallet->GetOrCreateBLSCTKeyMan();
+
+                for (size_t i = 0; i < mtx.vout.size(); i++) {
+                    if (specific_vout != -1 && specific_vout != (int)i) {
+                        continue;
+                    }
+
+                    const CTxOut& out = mtx.vout[i];
+                    UniValue output(UniValue::VOBJ);
+                    output.pushKV("vout", (int)i);
+                    output.pushKV("script", HexStr(out.scriptPubKey));
+
+                    // Use RecoverOutputs for hex input
+                    auto result = blsct_km->RecoverOutputs({out});
+                    if (!out.HasBLSCTRangeProof()) {
+                        // If recovery failed, show what we can
+                        output.pushKV("amount", ValueFromAmount(out.nValue));
+                        output.pushKV("gamma", "");
+                        output.pushKV("message", "");
+                        outputs.push_back(output);
+                    } else if (result.is_completed && !result.amounts.empty()) {
+                        auto recovery_data = result.amounts[0];
+                        output.pushKV("amount", ValueFromAmount(recovery_data.amount));
+                        output.pushKV("gamma", HexStr(recovery_data.gamma.GetVch()));
+                        output.pushKV("message", recovery_data.message);
+                        outputs.push_back(output);
+                    }
+                }
+            } else {
+                // For txid input, use wallet transaction
+                auto wallet_tx = wallet->GetWalletTx(hash);
+                if (!wallet_tx) {
+                    throw JSONRPCError(RPC_INVALID_PARAMETER, "Transaction not found in wallet");
+                }
+
+                for (size_t i = 0; i < mtx.vout.size(); i++) {
+                    if (specific_vout != -1 && specific_vout != (int)i) {
+                        continue;
+                    }
+
+                    UniValue output(UniValue::VOBJ);
+                    output.pushKV("vout", (int)i);
+                    output.pushKV("script", HexStr(mtx.vout[i].scriptPubKey));
+
+                    // Get recovery data from wallet transaction
+                    auto recovery_data = wallet_tx->GetBLSCTRecoveryData(i);
+                    output.pushKV("amount", ValueFromAmount(recovery_data.amount));
+                    output.pushKV("gamma", HexStr(recovery_data.gamma.GetVch()));
+                    output.pushKV("message", recovery_data.message);
+
+                    outputs.push_back(output);
+                }
+            }
+
+            result.pushKV("outputs", outputs);
+            return result;
+        },
+    };
+}
+
+static RPCHelpMan signblsmessage()
+{
+    return RPCHelpMan{
+        "signblsmessage",
+        "\nSign a message using a BLS private key.\n",
+        {
+            {"private_key", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The BLS private key in hex format"},
+            {"message", RPCArg::Type::STR, RPCArg::Optional::NO, "The message to sign"},
+        },
+        RPCResult{
+            RPCResult::Type::OBJ, "", "", {
+                                              {RPCResult::Type::STR_HEX, "signature", "The signature in hex format"},
+                                              {RPCResult::Type::STR_HEX, "public_key", "The public key corresponding to the private key"},
+                                          }},
+        RPCExamples{HelpExampleCli("signblsmessage", "\"private_key_hex\" \"Hello, world!\"") + HelpExampleRpc("signblsmessage", "\"private_key_hex\", \"Hello, world!\"")},
+        [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue {
+            std::string private_key_hex = request.params[0].get_str();
+            std::string message = request.params[1].get_str();
+
+            // Parse private key from hex
+            std::vector<unsigned char> private_key_bytes;
+            try {
+                private_key_bytes = ParseHex(private_key_hex);
+                if (private_key_bytes.size() != 32) {
+                    throw JSONRPCError(RPC_INVALID_PARAMETER, "Private key must be 32 bytes (64 hex characters)");
+                }
+            } catch (const std::exception& e) {
+                throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Invalid private key hex string: %s", e.what()));
+            }
+
+            // Create private key object
+            blsct::PrivateKey private_key = MclScalar(private_key_bytes);
+            if (!private_key.IsValid()) {
+                throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid private key");
+            }
+
+            // Hash the message with prefix
+            uint256 message_hash = MessageHash("BLSCT_MESSAGE_SIGN_" + message);
+            blsct::Message blsct_message(message_hash.begin(), message_hash.end());
+
+            // Sign the message
+            blsct::Signature signature = private_key.Sign(blsct_message);
+
+            // Get the public key
+            blsct::PublicKey public_key = private_key.GetPublicKey();
+
+            UniValue result(UniValue::VOBJ);
+            result.pushKV("signature", HexStr(signature.GetVch()));
+            result.pushKV("public_key", HexStr(public_key.GetVch()));
+
+            return result;
+        },
+    };
+}
+
+static RPCHelpMan verifyblsmessage()
+{
+    return RPCHelpMan{
+        "verifyblsmessage",
+        "\nVerify a BLS message signature.\n",
+        {
+            {"public_key", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The BLS public key in hex format"},
+            {"message", RPCArg::Type::STR, RPCArg::Optional::NO, "The message that was signed"},
+            {"signature", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The signature in hex format"},
+        },
+        RPCResult{
+            RPCResult::Type::BOOL, "valid", "Whether the signature is valid"},
+        RPCExamples{HelpExampleCli("verifyblsmessage", "\"public_key_hex\" \"Hello, world!\" \"signature_hex\"") + HelpExampleRpc("verifyblsmessage", "\"public_key_hex\", \"Hello, world!\", \"signature_hex\"")},
+        [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue {
+            std::string public_key_hex = request.params[0].get_str();
+            std::string message = request.params[1].get_str();
+            std::string signature_hex = request.params[2].get_str();
+
+            // Parse public key from hex
+            std::vector<unsigned char> public_key_bytes;
+            try {
+                public_key_bytes = ParseHex(public_key_hex);
+                if (public_key_bytes.size() != 48) {
+                    throw JSONRPCError(RPC_INVALID_PARAMETER, "Public key must be 48 bytes (96 hex characters)");
+                }
+            } catch (const std::exception& e) {
+                throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Invalid public key hex string: %s", e.what()));
+            }
+
+            // Parse signature from hex
+            std::vector<unsigned char> signature_bytes;
+            try {
+                signature_bytes = ParseHex(signature_hex);
+                if (signature_bytes.size() != 96) {
+                    throw JSONRPCError(RPC_INVALID_PARAMETER, "Signature must be 96 bytes (192 hex characters)");
+                }
+            } catch (const std::exception& e) {
+                throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Invalid signature hex string: %s", e.what()));
+            }
+
+            // Create public key and signature objects
+            blsct::PublicKey public_key(public_key_bytes);
+            blsct::Signature signature(signature_bytes);
+
+            // Hash the message with prefix
+            uint256 message_hash = MessageHash("BLSCT_MESSAGE_SIGN_" + message);
+            blsct::Message blsct_message(message_hash.begin(), message_hash.end());
+
+            // Verify the signature
+            bool valid = public_key.Verify(blsct_message, signature);
+
+            return valid;
+        },
+    };
+}
+
+
 Span<const CRPCCommand> GetBLSCTWalletRPCCommands()
 {
     static const CRPCCommand commands[]{
@@ -1123,6 +2024,15 @@ Span<const CRPCCommand> GetBLSCTWalletRPCCommands()
         {"blsct", &sendtokentoblsctaddress},
         {"blsct", &stakelock},
         {"blsct", &stakeunlock},
+        {"blsct", &setblsctseed},
+        {"blsct", &createblsctbalanceproof},
+        {"blsct", &createblsctrawtransaction},
+        {"blsct", &fundblsctrawtransaction},
+        {"blsct", &signblsctrawtransaction},
+        {"blsct", &decodeblsctrawtransaction},
+        {"blsct", &getblsctrecoverydata},
+        {"blsct", &signblsmessage},
+        {"blsct", &verifyblsmessage},
     };
     return commands;
 }
\ No newline at end of file
diff --git a/src/blsct/wallet/rpc.h b/src/blsct/wallet/rpc.h
index 18fe40c1e5b73..4e1a7ab62e00f 100644
--- a/src/blsct/wallet/rpc.h
+++ b/src/blsct/wallet/rpc.h
@@ -18,7 +18,6 @@ UniValue SendTransaction(wallet::CWallet& wallet, const blsct::CreateTransaction
 }
 
 class CRPCCommand;
-
 Span<const CRPCCommand> GetBLSCTWalletRPCCommands();
 
 #endif // BITCOIN_BLSCT_WALLET_RPC_H
\ No newline at end of file
diff --git a/src/blsct/wallet/txfactory.cpp b/src/blsct/wallet/txfactory.cpp
index e025a0a8edb59..457a38d1fa470 100644
--- a/src/blsct/wallet/txfactory.cpp
+++ b/src/blsct/wallet/txfactory.cpp
@@ -27,7 +27,16 @@ bool TxFactory::AddInput(const CCoinsViewCache& cache, const COutPoint& outpoint
     if (vInputs.count(coin.out.tokenId) == 0)
         vInputs[coin.out.tokenId] = std::vector<UnsignedInput>();
 
-    vInputs[coin.out.tokenId].push_back({CTxIn(outpoint, CScript(), rbf ? MAX_BIP125_RBF_SEQUENCE : CTxIn::SEQUENCE_FINAL), recoveredInfo.amounts[0].amount, recoveredInfo.amounts[0].gamma, km->GetSpendingKeyForOutputWithCache(coin.out), stakedCommitment});
+    try {
+        blsct::PrivateKey spending_key;
+        if (!km->GetSpendingKeyForOutputWithCache(coin.out, spending_key)) {
+            return false;
+        }
+        vInputs[coin.out.tokenId].push_back({CTxIn(outpoint, CScript(), rbf ? MAX_BIP125_RBF_SEQUENCE : CTxIn::SEQUENCE_FINAL), recoveredInfo.amounts[0].amount, recoveredInfo.amounts[0].gamma, spending_key, stakedCommitment});
+    } catch (const std::exception& e) {
+        LogPrintf("Error adding input: %s\n", e.what());
+        return false;
+    }
 
     if (nAmounts.count(coin.out.tokenId) == 0)
         nAmounts[coin.out.tokenId] = {0, 0, 0};
@@ -67,8 +76,17 @@ bool TxFactory::AddInput(wallet::CWallet* wallet, const COutPoint& outpoint, con
     if (vInputs.count(out.tokenId) == 0)
         vInputs[out.tokenId] = std::vector<UnsignedInput>();
 
-    vInputs[out.tokenId]
-        .push_back({CTxIn(outpoint, CScript(), rbf ? MAX_BIP125_RBF_SEQUENCE : CTxIn::SEQUENCE_FINAL), recoveredInfo.amount, recoveredInfo.gamma, km->GetSpendingKeyForOutputWithCache(out), stakedCommitment});
+    try {
+        blsct::PrivateKey spending_key;
+        if (!km->GetSpendingKeyForOutputWithCache(out, spending_key)) {
+            return false;
+        }
+        vInputs[out.tokenId]
+            .push_back({CTxIn(outpoint, CScript(), rbf ? MAX_BIP125_RBF_SEQUENCE : CTxIn::SEQUENCE_FINAL), recoveredInfo.amount, recoveredInfo.gamma, spending_key, stakedCommitment});
+    } catch (const std::exception& e) {
+        LogPrintf("Error adding input: %s\n", e.what());
+        return false;
+    }
 
     if (nAmounts.count(out.tokenId) == 0)
         nAmounts[out.tokenId] = {0, 0, 0};
@@ -135,7 +153,16 @@ void TxFactory::AddAvailableCoins(wallet::CWallet* wallet, blsct::KeyMan* blsct_
         }
         auto value = out.HasBLSCTRangeProof() ? recoveredInfo.amount : out.nValue;
 
-        inputCandidates.push_back({value, recoveredInfo.gamma, blsct_km->GetSpendingKeyForOutputWithCache(out), out.tokenId, COutPoint(output.outpoint.hash, output.outpoint.n), out.IsStakedCommitment()});
+        try {
+            blsct::PrivateKey spending_key;
+            if (!blsct_km->GetSpendingKeyForOutputWithCache(out, spending_key)) {
+                continue;
+            }
+            inputCandidates.push_back({value, recoveredInfo.gamma, spending_key, out.tokenId, COutPoint(output.outpoint.hash, output.outpoint.n), out.IsStakedCommitment()});
+        } catch (const std::exception& e) {
+            LogPrintf("Error adding input: %s\n", e.what());
+            continue;
+        }
         nTotalAdded += value;
 
         if (nTotalAdded > nAmountLimit)
diff --git a/src/blsct/wallet/txfactory_global.cpp b/src/blsct/wallet/txfactory_global.cpp
index 5cb2720273700..c489624d9e3b6 100644
--- a/src/blsct/wallet/txfactory_global.cpp
+++ b/src/blsct/wallet/txfactory_global.cpp
@@ -4,6 +4,7 @@
 
 #include <blsct/tokens/predicate_parser.h>
 #include <blsct/wallet/txfactory_global.h>
+#include <util/strencodings.h>
 
 using T = Mcl;
 using Point = T::Point;
@@ -19,6 +20,7 @@ void UnsignedOutput::GenerateKeys(Scalar blindingKey, DoublePublicKey destKeys)
     Point vk, sk;
 
     if (!destKeys.GetViewKey(vk)) {
+        assert(false);
         throw std::runtime_error(strprintf("%s: could not get view key from destination address\n", __func__));
     }
 
@@ -133,6 +135,67 @@ UnsignedOutput CreateOutput(const blsct::DoublePublicKey& destKeys, const CAmoun
         ret.GenerateKeys(ret.blindingKey, destKeys);
         HashWriter hash{};
         hash << nonce;
+
+        ret.out.blsctData.viewTag = (hash.GetHash().GetUint64(0) & 0xFFFF);
+    } else {
+        ret.out.scriptPubKey = CScript(OP_RETURN);
+    }
+
+    return ret;
+}
+
+UnsignedOutput CreateOutput(const std::pair<blsct::DoublePublicKey, CScript>& destination, const CAmount& nAmount, std::string sMemo, const TokenId& tokenId, const Scalar& blindingKey, const CreateTransactionType& type, const CAmount& minStake)
+{
+    bulletproofs_plus::RangeProofLogic<T> rp;
+    auto ret = UnsignedOutput();
+
+    ret.type = type;
+
+    ret.out.nValue = 0;
+    ret.out.tokenId = tokenId;
+
+    Scalars vs;
+    vs.Add(nAmount);
+
+    ret.blindingKey = blindingKey.IsZero() ? MclScalar::Rand() : blindingKey;
+
+    Points nonces;
+    Point vk;
+
+    if (!destination.first.GetViewKey(vk)) {
+        throw std::runtime_error(strprintf("%s: could not get view key from destination address\n", __func__));
+    }
+
+    auto nonce = vk * ret.blindingKey;
+    nonces.Add(nonce);
+
+    ret.value = nAmount;
+    ret.gamma = nonce.GetHashWithSalt(100);
+
+    std::vector<unsigned char> memo{sMemo.begin(), sMemo.end()};
+
+    if (nAmount > 0) {
+        ret.out.scriptPubKey = destination.second;
+
+        if (type == STAKED_COMMITMENT && tokenId.IsNull()) {
+            auto stakeRp = rp.Prove(vs, nonce, {}, tokenId, minStake);
+
+            stakeRp.Vs.Clear();
+
+            DataStream ss{};
+            ss << Using<bulletproofs_plus::RangeProofWithoutVs<T>>(stakeRp);
+
+            ret.out.scriptPubKey = CScript() << OP_STAKED_COMMITMENT << blsct::Common::DataStreamToVector(ss) << OP_DROP << OP_TRUE;
+        }
+        if (tokenId.IsNFT()) {
+            ret.out.nValue = nAmount;
+        } else {
+            auto p = rp.Prove(vs, nonce, memo, tokenId);
+            ret.out.blsctData.rangeProof = p;
+        }
+        ret.GenerateKeys(ret.blindingKey, destination.first);
+        HashWriter hash{};
+        hash << nonce;
         ret.out.blsctData.viewTag = (hash.GetHash().GetUint64(0) & 0xFFFF);
     } else {
         ret.out.scriptPubKey = CScript(OP_RETURN);
diff --git a/src/blsct/wallet/txfactory_global.h b/src/blsct/wallet/txfactory_global.h
index 4bb95b5257826..74446b22ca4e0 100644
--- a/src/blsct/wallet/txfactory_global.h
+++ b/src/blsct/wallet/txfactory_global.h
@@ -66,12 +66,48 @@ struct UnsignedInput {
     Scalar gamma;
     PrivateKey sk;
     bool is_staked_commitment;
+
+    template <typename Stream>
+    void Serialize(Stream& s) const
+    {
+        ::Serialize(s, in);
+        ::Serialize(s, value);
+        ::Serialize(s, gamma);
+        ::Serialize(s, sk);
+        ::Serialize(s, is_staked_commitment);
+    }
+
+    template <typename Stream>
+    void Unserialize(Stream& s)
+    {
+        ::Unserialize(s, in);
+        ::Unserialize(s, value);
+        ::Unserialize(s, gamma);
+        ::Unserialize(s, sk);
+        ::Unserialize(s, is_staked_commitment);
+    }
 };
 
 struct Amounts {
     CAmount nFromInputs;
     CAmount nFromOutputs;
     CAmount nFromFee;
+
+    template <typename Stream>
+    void Serialize(Stream& s) const
+    {
+        ::Serialize(s, nFromInputs);
+        ::Serialize(s, nFromOutputs);
+        ::Serialize(s, nFromFee);
+    }
+
+    template <typename Stream>
+    void Unserialize(Stream& s)
+    {
+        ::Unserialize(s, nFromInputs);
+        ::Unserialize(s, nFromOutputs);
+        ::Unserialize(s, nFromFee);
+    }
 };
 
 CTransactionRef
@@ -80,6 +116,7 @@ UnsignedOutput CreateOutput(const Scalar& tokenKey, const blsct::TokenInfo& toke
 UnsignedOutput CreateOutput(const blsct::DoublePublicKey& destKeys, const CAmount& nAmount, const Scalar& blindingKey, const Scalar& tokenKey, const blsct::PublicKey& tokenPublicKey);
 UnsignedOutput CreateOutput(const blsct::DoublePublicKey& destKeys, const Scalar& blindingKey, const Scalar& tokenKey, const blsct::PublicKey& tokenPublicKey, const uint64_t& nftId, const std::map<std::string, std::string>& nftMetadata);
 UnsignedOutput CreateOutput(const blsct::DoublePublicKey& destination, const CAmount& nAmount, std::string sMemo, const TokenId& tokenId = TokenId(), const Scalar& blindingKey = Scalar::Rand(), const CreateTransactionType& type = NORMAL, const CAmount& minStake = 0);
+UnsignedOutput CreateOutput(const std::pair<blsct::DoublePublicKey, CScript>& destination, const CAmount& nAmount, std::string sMemo, const TokenId& tokenId = TokenId(), const Scalar& blindingKey = Scalar::Rand(), const CreateTransactionType& type = NORMAL, const CAmount& minStake = 0);
 int32_t GetTransactionWeight(const CTransaction& tx);
 int32_t GetTransactioOutputWeight(const CTxOut& out);
 } // namespace blsct
diff --git a/src/blsct/wallet/unsigned_transaction.cpp b/src/blsct/wallet/unsigned_transaction.cpp
new file mode 100644
index 0000000000000..ae1b7e5be21f2
--- /dev/null
+++ b/src/blsct/wallet/unsigned_transaction.cpp
@@ -0,0 +1,95 @@
+// Copyright (c) 2024 The Navio Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <blsct/wallet/unsigned_transaction.h>
+
+namespace blsct {
+
+void UnsignedTransaction::AddInput(const UnsignedInput& input)
+{
+    m_inputs.push_back(input);
+}
+
+void UnsignedTransaction::AddOutput(const UnsignedOutput& output)
+{
+    m_outputs.push_back(output);
+}
+
+std::vector<unsigned char> UnsignedTransaction::Serialize() const
+{
+    DataStream stream;
+    stream << *this;
+    return blsct::Common::DataStreamToVector(stream);
+}
+
+std::optional<UnsignedTransaction> UnsignedTransaction::Deserialize(const std::vector<unsigned char>& data)
+{
+    try {
+        DataStream stream(data);
+        UnsignedTransaction tx;
+        stream >> tx;
+        return tx;
+    } catch (const std::exception&) {
+        return std::nullopt;
+    }
+}
+
+std::optional<CTransaction> UnsignedTransaction::Sign() const
+{
+    try {
+        // Create a mutable transaction
+        CMutableTransaction tx;
+        tx.nVersion |= CTransaction::BLSCT_MARKER;
+
+        // Add inputs
+        std::vector<Signature> txSigs;
+        Scalar gammaAcc;
+
+        // Add outputs first to calculate gamma
+        for (const auto& out : m_outputs) {
+            tx.vout.push_back(out.out);
+            auto outHash = out.out.GetHash();
+
+            if (out.out.HasBLSCTRangeProof()) {
+                gammaAcc = gammaAcc - out.gamma;
+            }
+            if (out.out.HasBLSCTKeys()) {
+                txSigs.push_back(PrivateKey(out.blindingKey).Sign(outHash));
+            }
+
+            if (out.type == TX_CREATE_TOKEN || out.type == TX_MINT_TOKEN) {
+                txSigs.push_back(PrivateKey(out.tokenKey).Sign(outHash));
+            }
+        }
+
+        // Add inputs and their signatures
+        for (const auto& in : m_inputs) {
+            tx.vin.push_back(in.in);
+            gammaAcc = gammaAcc + in.gamma;
+            txSigs.push_back(in.sk.Sign(in.in.GetHash()));
+        }
+
+        // Calculate fee based on transaction weight
+        CAmount fee = m_fee;
+
+        // Add fee output
+        CTxOut fee_out{fee, CScript(OP_RETURN)};
+        auto feeKey = blsct::PrivateKey(Scalar::Rand());
+        fee_out.predicate = blsct::PayFeePredicate(feeKey.GetPublicKey()).GetVch();
+        tx.vout.push_back(fee_out);
+
+        // Add balance and fee signatures
+        txSigs.push_back(PrivateKey(gammaAcc).SignBalance());
+        txSigs.push_back(PrivateKey(feeKey).SignFee());
+
+        // Aggregate all signatures
+        tx.txSig = Signature::Aggregate(txSigs);
+
+        return CTransaction(tx);
+    } catch (const std::exception&) {
+        return std::nullopt;
+    }
+}
+
+} // namespace blsct
\ No newline at end of file
diff --git a/src/blsct/wallet/unsigned_transaction.h b/src/blsct/wallet/unsigned_transaction.h
new file mode 100644
index 0000000000000..deebd5a07b3cb
--- /dev/null
+++ b/src/blsct/wallet/unsigned_transaction.h
@@ -0,0 +1,55 @@
+// Copyright (c) 2024 The Navio Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BLSCT_UNSIGNED_TRANSACTION_H
+#define BLSCT_UNSIGNED_TRANSACTION_H
+
+#include <blsct/arith/mcl/mcl.h>
+#include <blsct/tokens/info.h>
+#include <blsct/wallet/address.h>
+#include <blsct/wallet/txfactory_global.h>
+#include <primitives/transaction.h>
+#include <serialize.h>
+#include <streams.h>
+
+namespace blsct {
+
+class UnsignedTransaction
+{
+private:
+    // Inputs and outputs
+    std::vector<UnsignedInput> m_inputs;
+    std::vector<UnsignedOutput> m_outputs;
+    CAmount m_fee{0};
+
+public:
+    UnsignedTransaction() = default;
+
+    // Getters
+    const std::vector<UnsignedInput>& GetInputs() const { return m_inputs; }
+    const std::vector<UnsignedOutput>& GetOutputs() const { return m_outputs; }
+    CAmount GetFee() const { return m_fee; }
+
+    // Setters
+    void AddInput(const UnsignedInput& input);
+    void AddOutput(const UnsignedOutput& output);
+    void SetFee(CAmount fee) { m_fee = fee; }
+
+    // Serialization
+    SERIALIZE_METHODS(UnsignedTransaction, obj)
+    {
+        READWRITE(obj.m_inputs, obj.m_outputs, obj.m_fee);
+    }
+
+    // Serialization helpers
+    std::vector<unsigned char> Serialize() const;
+    static std::optional<UnsignedTransaction> Deserialize(const std::vector<unsigned char>& data);
+
+    // Signing
+    std::optional<CTransaction> Sign() const;
+};
+
+} // namespace blsct
+
+#endif // BLSCT_UNSIGNED_TRANSACTION_H
\ No newline at end of file
diff --git a/src/blsct/wallet/verification.cpp b/src/blsct/wallet/verification.cpp
index 201aa2506841a..07641c8334b92 100644
--- a/src/blsct/wallet/verification.cpp
+++ b/src/blsct/wallet/verification.cpp
@@ -9,6 +9,7 @@
 #include <blsct/range_proof/bulletproofs_plus/range_proof_logic.h>
 #include <blsct/range_proof/generators.h>
 #include <blsct/wallet/verification.h>
+#include <script/interpreter.h>
 #include <util/strencodings.h>
 
 namespace blsct {
@@ -23,6 +24,8 @@ bool VerifyTx(const CTransaction& tx, CCoinsViewCache& view, TxValidationState&
     std::vector<bulletproofs_plus::RangeProofWithSeed<Mcl>> vProofs;
     std::vector<Message> vMessages;
     std::vector<PublicKey> vPubKeys;
+
+
     MclG1Point balanceKey;
 
     if (blockReward > 0) {
@@ -31,6 +34,7 @@ bool VerifyTx(const CTransaction& tx, CCoinsViewCache& view, TxValidationState&
     }
 
     if (!tx.IsCoinBase()) {
+        size_t i = 0;
         for (auto& in : tx.vin) {
             Coin coin;
 
@@ -38,9 +42,24 @@ bool VerifyTx(const CTransaction& tx, CCoinsViewCache& view, TxValidationState&
                 return state.Invalid(TxValidationResult::TX_MISSING_INPUTS, "bad-input-unknown");
             }
 
-            vPubKeys.emplace_back(coin.out.blsctData.spendingKey);
-            auto in_hash = in.GetHash();
-            vMessages.emplace_back(in_hash.begin(), in_hash.end());
+            TransactionSignatureChecker checker(&tx, i++, 0, MissingDataBehavior::FAIL);
+            ScriptError serror;
+            uint32_t flags = SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_STRICTENC;
+
+            if (!VerifyScript(coin.out.scriptPubKey, in.scriptSig, nullptr, flags, checker, &serror)) {
+                return state.Invalid(TxValidationResult::TX_CONSENSUS, "failed-script-check");
+            }
+
+            for (const auto& pair : checker.GetKeyMessagePairs()) {
+                vPubKeys.emplace_back(pair.first);
+                vMessages.emplace_back(pair.second.begin(), pair.second.end());
+            }
+
+            if (!coin.out.blsctData.spendingKey.IsZero()) {
+                vPubKeys.emplace_back(coin.out.blsctData.spendingKey);
+                auto in_hash = in.GetHash();
+                vMessages.emplace_back(in_hash.begin(), in_hash.end());
+            }
 
             if (coin.out.HasBLSCTRangeProof())
                 balanceKey = balanceKey + coin.out.blsctData.rangeProof.Vs[0];
diff --git a/src/kernel/chainparams.cpp b/src/kernel/chainparams.cpp
index 001cb2acf317b..bc81e8faf4b1b 100644
--- a/src/kernel/chainparams.cpp
+++ b/src/kernel/chainparams.cpp
@@ -187,7 +187,7 @@ static CBlock CreateGenesisBlock(uint32_t nTime, uint32_t nNonce, uint32_t nBits
         pchMessageStart[3] = 0xac;
         nDefaultPort = 8333;
         nPruneAfterHeight = 100000;
-        m_assumed_blockchain_size = 10;
+        m_assumed_blockchain_size = 1;
         m_assumed_chain_state_size = 9;
 
         genesis = CreateGenesisBlock(1231006505, 2083236893, 0x1d00ffff, 1, 50 * COIN);
@@ -218,7 +218,7 @@ static CBlock CreateGenesisBlock(uint32_t nTime, uint32_t nNonce, uint32_t nBits
         base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x88, 0xAD, 0xE4};
 
         bech32_hrp = "bc";
-        bech32_mod_hrp = "nv";
+        bech32_mod_hrp = "nav";
 
         vFixedSeeds = std::vector<uint8_t>(std::begin(chainparams_seed_main), std::end(chainparams_seed_main));
 
@@ -313,7 +313,7 @@ static CBlock CreateGenesisBlock(uint32_t nTime, uint32_t nNonce, uint32_t nBits
         pchMessageStart[3] = 0xdf;
         nDefaultPort = 33570;
         nPruneAfterHeight = 1000;
-        m_assumed_blockchain_size = 10;
+        m_assumed_blockchain_size = 1;
         m_assumed_chain_state_size = 3;
 
         genesis = CreateBLSCTGenesisBlock(1743259590, 2, 0x207fffff, 0x40000000UL, "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");
@@ -335,7 +335,7 @@ static CBlock CreateGenesisBlock(uint32_t nTime, uint32_t nNonce, uint32_t nBits
         base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x35, 0x83, 0x94};
 
         bech32_hrp = "tb";
-        bech32_mod_hrp = "tn";
+        bech32_mod_hrp = "tnv";
 
         vFixedSeeds = std::vector<uint8_t>(std::begin(chainparams_seed_test), std::end(chainparams_seed_test));
 
@@ -465,7 +465,7 @@ static CBlock CreateGenesisBlock(uint32_t nTime, uint32_t nNonce, uint32_t nBits
             base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x35, 0x83, 0x94};
 
             bech32_hrp = "tb";
-            bech32_mod_hrp = "nv";
+            bech32_mod_hrp = "nav";
 
             fDefaultConsistencyChecks = false;
             m_is_mockable_chain = false;
@@ -605,7 +605,7 @@ static CBlock CreateGenesisBlock(uint32_t nTime, uint32_t nNonce, uint32_t nBits
             base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x35, 0x83, 0x94};
 
             bech32_hrp = "bcrt";
-            bech32_mod_hrp = "nr";
+            bech32_mod_hrp = "rnv";
         }
     };
 
@@ -723,7 +723,7 @@ static CBlock CreateGenesisBlock(uint32_t nTime, uint32_t nNonce, uint32_t nBits
             base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x35, 0x83, 0x94};
 
             bech32_hrp = "bcrt";
-            bech32_mod_hrp = "nr";
+            bech32_mod_hrp = "rnv";
         }
     };
 
diff --git a/src/rpc/blockchain.cpp b/src/rpc/blockchain.cpp
index a266cdc1af666..7275bc04f02bf 100644
--- a/src/rpc/blockchain.cpp
+++ b/src/rpc/blockchain.cpp
@@ -1347,7 +1347,7 @@ RPCHelpMan getdeploymentinfo()
             RPCResult::Type::OBJ, "", "", {
                                               {RPCResult::Type::STR, "hash", "requested block hash (or tip)"},
                                               {RPCResult::Type::NUM, "height", "requested block height (or tip)"},
-                                              {RPCResult::Type::OBJ_DYN, "deployments", "", {{RPCResult::Type::STR, "xxxx", "name of the deployment"}}},
+                                              {RPCResult::Type::OBJ_DYN, "deployments", "", {{RPCResult::Type::OBJ, "xxxx", "name of the deployment", RPCHelpForDeployment}}},
                                           }},
         RPCExamples{HelpExampleCli("getdeploymentinfo", "") + HelpExampleRpc("getdeploymentinfo", "")},
         [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue {
diff --git a/src/rpc/client.cpp b/src/rpc/client.cpp
index 441ac9d9fa01d..b76b1256f426d 100644
--- a/src/rpc/client.cpp
+++ b/src/rpc/client.cpp
@@ -29,6 +29,9 @@ class CRPCConvertParam
  */
 static const CRPCConvertParam vRPCConvertParams[] =
 {
+    {"createblsctrawtransaction", 0, "inputs"},
+    {"createblsctrawtransaction", 1, "outputs"},
+    { "createblsctbalanceproof", 0, "amount" },
     { "setmocktime", 0, "timestamp" },
     { "mockscheduler", 0, "delta_time" },
     { "utxoupdatepsbt", 1, "descriptors" },
@@ -350,6 +353,7 @@ static const CRPCConvertParam vRPCConvertParams[] =
     { "minttoken", 2, "amount"},
     { "mintnft", 1, "nft_id"},
     { "mintnft", 3, "metadata"},
+    { "getblsctrecoverydata", 1, "vout" },
 };
 // clang-format on
 
diff --git a/src/rpc/mempool.cpp b/src/rpc/mempool.cpp
index 04d2e68939853..526df1bb0c768 100644
--- a/src/rpc/mempool.cpp
+++ b/src/rpc/mempool.cpp
@@ -74,7 +74,7 @@ static RPCHelpMan sendrawtransaction()
             }
 
             for (const auto& out : mtx.vout) {
-                if((out.scriptPubKey.IsUnspendable() || !out.scriptPubKey.HasValidOps()) && out.nValue > max_burn_amount) {
+                if ((out.scriptPubKey.IsUnspendable() || !out.scriptPubKey.HasValidOps()) && out.nValue > max_burn_amount && !out.IsFee()) {
                     throw JSONRPCTransactionError(TransactionError::MAX_BURN_EXCEEDED);
                 }
             }
diff --git a/src/rpc/rawtransaction.cpp b/src/rpc/rawtransaction.cpp
index 3f1b85f0213eb..6d30bc0d3cbd3 100644
--- a/src/rpc/rawtransaction.cpp
+++ b/src/rpc/rawtransaction.cpp
@@ -125,9 +125,9 @@ static std::vector<RPCResult> DecodeTxDoc(const std::string& txid_field_doc)
                                                                                   {RPCResult::Type::STR_HEX, "ephemeralKey", /*optional=*/true, "hex-encoded ephemeral key"},
                                                                                   {RPCResult::Type::STR_HEX, "spendingKey", /*optional=*/true, "hex-encoded spending key"},
                                                                                   {RPCResult::Type::OBJ, "rangeProof", /*optional=*/true, "output's range proof", {
-                                                                                                                                                                      {RPCResult::Type::ARR, "Vs", "Vs", {
-                                                                                                                                                                                                             {RPCResult::Type::STR_HEX, "", "hex-encoded point (if any)"},
-                                                                                                                                                                                                         }},
+                                                                                                                                                                      {RPCResult::Type::ARR, "Vs", true, "Vs", {
+                                                                                                                                                                                                                   {RPCResult::Type::STR_HEX, "", "hex-encoded point (if any)"},
+                                                                                                                                                                                                               }},
                                                                                                                                                                       {RPCResult::Type::ARR, "Ls", /*optional=*/true, "Ls", {
                                                                                                                                                                                                                                 {RPCResult::Type::STR_HEX, "", "hex-encoded point (if any)"},
                                                                                                                                                                                                                             }},
diff --git a/src/rpc/register.h b/src/rpc/register.h
index 54d9b2780d7ed..eeccaf051d360 100644
--- a/src/rpc/register.h
+++ b/src/rpc/register.h
@@ -21,7 +21,7 @@ void RegisterSignMessageRPCCommands(CRPCTable&);
 void RegisterSignerRPCCommands(CRPCTable &tableRPC);
 void RegisterTxoutProofRPCCommands(CRPCTable&);
 void RegisterTokenRPCCommands(CRPCTable&);
-
+void RegisterRangeProofRPCCommands(CRPCTable&);
 static inline void RegisterAllCoreRPCCommands(CRPCTable &t)
 {
     RegisterBlockchainRPCCommands(t);
@@ -38,6 +38,7 @@ static inline void RegisterAllCoreRPCCommands(CRPCTable &t)
 #endif // ENABLE_EXTERNAL_SIGNER
     RegisterTxoutProofRPCCommands(t);
     RegisterTokenRPCCommands(t);
+    RegisterRangeProofRPCCommands(t);
 }
 
 #endif // BITCOIN_RPC_REGISTER_H
diff --git a/src/rpc/util.cpp b/src/rpc/util.cpp
index 94d214e310b6b..68eb9fac20daf 100644
--- a/src/rpc/util.cpp
+++ b/src/rpc/util.cpp
@@ -25,7 +25,7 @@
 
 const std::string UNIX_EPOCH_TIME = "UNIX epoch time";
 const std::string EXAMPLE_ADDRESS[2] = {"bc1q09vm5lfy0j5reeulh4x5752q25uqqvz34hufdl", "bc1q02ad21edsxd23d32dfgqqsz4vv4nmtfzuklhy3"};
-const std::string BLSCT_EXAMPLE_ADDRESS[2] = {"nv1d3fqq4j2w384smpjxgm95anexe4rjwzr2pc553t0xduxuc3sd35nvatcxpnn2mjyde45sqrtfapnws3kwfc85sm3v9ekzc2r2ajnquzf09282e62xddykn25x3", "nv1d3fqq4j2w384smpjxgm95anexe4rjwzr2pc553t0xduxuc3sd35nvatcxpnn2mjyde45sqrtfapnws3kwfc85sm3v9ekzc2r2ajnquzf09282e62xddykn25x3"};
+const std::string BLSCT_EXAMPLE_ADDRESS[2] = {"nav1d3fqq4j2w384smpjxgm95anexe4rjwzr2pc553t0xduxuc3sd35nvatcxpnn2mjyde45sqrtfapnws3kwfc85sm3v9ekzc2r2ajnquzf09282e62xddykn25x3", "nav1d3fqq4j2w384smpjxgm95anexe4rjwzr2pc553t0xduxuc3sd35nvatcxpnn2mjyde45sqrtfapnws3kwfc85sm3v9ekzc2r2ajnquzf09282e62xddykn25x3"};
 
 std::string GetAllOutputTypes()
 {
diff --git a/src/script/interpreter.cpp b/src/script/interpreter.cpp
index 3f0233b7e988b..fda06b6922029 100644
--- a/src/script/interpreter.cpp
+++ b/src/script/interpreter.cpp
@@ -590,7 +590,6 @@ bool EvalScript(std::vector<std::vector<unsigned char>>& stack, const CScript& s
                 }
 
                 case OP_NOP1:
-                case OP_NOP4:
                 case OP_NOP5:
                 case OP_NOP6:
                 case OP_NOP7:
@@ -1036,6 +1035,24 @@ bool EvalScript(std::vector<std::vector<unsigned char>>& stack, const CScript& s
                     stack.push_back((num + (success ? 1 : 0)).getvch());
                 } break;
 
+                case OP_BLSCHECKSIG: {
+                    // (pubkey -- bool)
+                    if (stack.size() < 1)
+                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
+
+                    const valtype& vchPubKey = stacktop(-1);
+
+                    // Validate public key size (BLS public keys are 48 or 64 bytes)
+                    if (vchPubKey.size() != 48 && vchPubKey.size() != 64) {
+                        return set_error(serror, SCRIPT_ERR_INVALID_PUBKEY);
+                    }
+
+                    bool fSuccess = checker.CheckBlsSignature(vchPubKey);
+
+                    popstack(stack);
+                    stack.push_back(fSuccess ? vchTrue : vchFalse);
+                } break;
+
                 case OP_CHECKMULTISIG:
                 case OP_CHECKMULTISIGVERIFY: {
                     if (sigversion == SigVersion::TAPSCRIPT) return set_error(serror, SCRIPT_ERR_TAPSCRIPT_CHECKMULTISIG);
@@ -1606,6 +1623,28 @@ bool GenericTransactionSignatureChecker<T>::CheckECDSASignature(const std::vecto
     return true;
 }
 
+template <class T>
+bool GenericTransactionSignatureChecker<T>::CheckBlsSignature(Span<const unsigned char> pubkey) const
+{
+    blsct::PublicKey blsPubKey;
+    if (!blsPubKey.SetVch(std::vector<unsigned char>(pubkey.begin(), pubkey.end()))) {
+        return false;
+    }
+
+    CTxIn txin = txTo->vin[nIn];
+    uint256 sighash = txin.GetHash();
+
+    m_key_message_pairs.emplace_back(blsPubKey, sighash);
+
+    return true;
+}
+
+template <class T>
+std::vector<std::pair<blsct::PublicKey, uint256>>& GenericTransactionSignatureChecker<T>::GetKeyMessagePairs() const
+{
+    return m_key_message_pairs;
+}
+
 template <class T>
 bool GenericTransactionSignatureChecker<T>::CheckSchnorrSignature(Span<const unsigned char> sig, Span<const unsigned char> pubkey_in, SigVersion sigversion, ScriptExecutionData& execdata, ScriptError* serror) const
 {
diff --git a/src/script/interpreter.h b/src/script/interpreter.h
index 836c2e7982a20..1f216e1ec6c44 100644
--- a/src/script/interpreter.h
+++ b/src/script/interpreter.h
@@ -13,6 +13,10 @@
 #include <span.h>
 #include <uint256.h>
 
+// BLSCT includes for DeferredBlsSignatureChecker
+#include <blsct/public_key.h>
+#include <blsct/signature.h>
+
 #include <cstddef>
 #include <cstdint>
 #include <optional>
@@ -255,6 +259,11 @@ class BaseSignatureChecker
         return false;
     }
 
+    virtual bool CheckBlsSignature(Span<const unsigned char> pubkey) const
+    {
+        return false;
+    }
+
     virtual bool CheckLockTime(const CScriptNum& nLockTime) const
     {
          return false;
@@ -289,6 +298,7 @@ class GenericTransactionSignatureChecker : public BaseSignatureChecker
     unsigned int nIn;
     const CAmount amount;
     const PrecomputedTransactionData* txdata;
+    mutable std::vector<std::pair<blsct::PublicKey, uint256>> m_key_message_pairs;
 
 protected:
     virtual bool VerifyECDSASignature(const std::vector<unsigned char>& vchSig, const CPubKey& vchPubKey, const uint256& sighash) const;
@@ -299,8 +309,10 @@ class GenericTransactionSignatureChecker : public BaseSignatureChecker
     GenericTransactionSignatureChecker(const T* txToIn, unsigned int nInIn, const CAmount& amountIn, const PrecomputedTransactionData& txdataIn, MissingDataBehavior mdb) : txTo(txToIn), m_mdb(mdb), nIn(nInIn), amount(amountIn), txdata(&txdataIn) {}
     bool CheckECDSASignature(const std::vector<unsigned char>& scriptSig, const std::vector<unsigned char>& vchPubKey, const CScript& scriptCode, SigVersion sigversion) const override;
     bool CheckSchnorrSignature(Span<const unsigned char> sig, Span<const unsigned char> pubkey, SigVersion sigversion, ScriptExecutionData& execdata, ScriptError* serror = nullptr) const override;
+    bool CheckBlsSignature(Span<const unsigned char> pubkey) const override;
     bool CheckLockTime(const CScriptNum& nLockTime) const override;
     bool CheckSequence(const CScriptNum& nSequence) const override;
+    std::vector<std::pair<blsct::PublicKey, uint256>>& GetKeyMessagePairs() const;
 };
 
 using TransactionSignatureChecker = GenericTransactionSignatureChecker<CTransaction>;
@@ -324,6 +336,11 @@ class DeferringSignatureChecker : public BaseSignatureChecker
         return m_checker.CheckSchnorrSignature(sig, pubkey, sigversion, execdata, serror);
     }
 
+    bool CheckBlsSignature(Span<const unsigned char> pubkey) const override
+    {
+        return m_checker.CheckBlsSignature(pubkey);
+    }
+
     bool CheckLockTime(const CScriptNum& nLockTime) const override
     {
         return m_checker.CheckLockTime(nLockTime);
diff --git a/src/script/script.cpp b/src/script/script.cpp
index dcc216a3f4529..83b07ac788b24 100644
--- a/src/script/script.cpp
+++ b/src/script/script.cpp
@@ -138,7 +138,7 @@ std::string GetOpName(opcodetype opcode)
     case OP_NOP1                   : return "OP_NOP1";
     case OP_CHECKLOCKTIMEVERIFY    : return "OP_CHECKLOCKTIMEVERIFY";
     case OP_CHECKSEQUENCEVERIFY    : return "OP_CHECKSEQUENCEVERIFY";
-    case OP_NOP4                   : return "OP_NOP4";
+    case OP_NOP4: return "OP_BLSCHECKSIG";
     case OP_NOP5                   : return "OP_NOP5";
     case OP_NOP6                   : return "OP_NOP6";
     case OP_NOP7                   : return "OP_NOP7";
diff --git a/src/script/script.h b/src/script/script.h
index 035734b4dcfc3..c19bd2aaf0c51 100644
--- a/src/script/script.h
+++ b/src/script/script.h
@@ -196,7 +196,8 @@ enum opcodetype {
     OP_NOP2 = OP_CHECKLOCKTIMEVERIFY,
     OP_CHECKSEQUENCEVERIFY = 0xb2,
     OP_NOP3 = OP_CHECKSEQUENCEVERIFY,
-    OP_NOP4 = 0xb3,
+    OP_BLSCHECKSIG = 0xb3,
+    OP_NOP4 = OP_BLSCHECKSIG,
     OP_NOP5 = 0xb4,
     OP_NOP6 = 0xb5,
     OP_NOP7 = 0xb6,
@@ -208,11 +209,12 @@ enum opcodetype {
     // Opcode added by BIP 342 (Tapscript)
     OP_CHECKSIGADD = 0xba,
 
+
     OP_INVALIDOPCODE = 0xff,
 };
 
 // Maximum value that an opcode can be
-static const unsigned int MAX_OPCODE = OP_NOP10;
+static const unsigned int MAX_OPCODE = OP_CHECKSIGADD;
 
 std::string GetOpName(opcodetype opcode);
 
@@ -554,6 +556,11 @@ class CScript : public CScriptBase
         return (size() > 0 && *begin() == OP_RETURN) || (size() > MAX_SCRIPT_SIZE);
     }
 
+    bool IsSpendable() const
+    {
+        return (size() == 1 && *begin() == OP_TRUE);
+    }
+
     bool IsFee() const
     {
         return (size() == 1 && *begin() == OP_RETURN);
diff --git a/src/script/script_error.h b/src/script/script_error.h
index 44e68fe0fae30..d14835f8054b9 100644
--- a/src/script/script_error.h
+++ b/src/script/script_error.h
@@ -8,8 +8,7 @@
 
 #include <string>
 
-typedef enum ScriptError_t
-{
+typedef enum ScriptError_t {
     SCRIPT_ERR_OK = 0,
     SCRIPT_ERR_UNKNOWN_ERROR,
     SCRIPT_ERR_EVAL_FALSE,
@@ -29,6 +28,7 @@ typedef enum ScriptError_t
     SCRIPT_ERR_CHECKMULTISIGVERIFY,
     SCRIPT_ERR_CHECKSIGVERIFY,
     SCRIPT_ERR_NUMEQUALVERIFY,
+    SCRIPT_ERR_INVALID_PUBKEY,
 
     /* Logical/Format/Canonical errors */
     SCRIPT_ERR_BAD_OPCODE,
diff --git a/src/test/blsct/pos/pos_chain_tests.cpp b/src/test/blsct/pos/pos_chain_tests.cpp
index ce7316e3c6dcc..f26bdb1e6054f 100644
--- a/src/test/blsct/pos/pos_chain_tests.cpp
+++ b/src/test/blsct/pos/pos_chain_tests.cpp
@@ -40,14 +40,11 @@ BOOST_FIXTURE_TEST_CASE(StakedCommitment, TestBLSCTChain100Setup)
 
     SeedInsecureRand(SeedRand::ZEROS);
     CCoinsViewDB base{{.path = "test", .cache_bytes = 1 << 23, .memory_only = true}, {}};
-
     CWallet wallet(m_node.chain.get(), "", CreateMockableWalletDatabase());
     wallet.InitWalletFlags(wallet::WALLET_FLAG_BLSCT);
-
     LOCK(wallet.cs_wallet);
     auto blsct_km = wallet.GetOrCreateBLSCTKeyMan();
     BOOST_CHECK(blsct_km->SetupGeneration({}, blsct::IMPORT_MASTER_KEY, true));
-
     auto recvAddress = std::get<blsct::DoublePublicKey>(blsct_km->GetNewDestination(0).value());
 
     COutPoint outpoint{Txid::FromUint256(InsecureRand256()), /*nIn=*/0};
diff --git a/src/test/blsct/wallet/address_tests.cpp b/src/test/blsct/wallet/address_tests.cpp
index 7b2f2a09cfafc..c3af33f3406c4 100644
--- a/src/test/blsct/wallet/address_tests.cpp
+++ b/src/test/blsct/wallet/address_tests.cpp
@@ -40,7 +40,7 @@ BOOST_FIXTURE_TEST_CASE(address_test, BasicTestingSetup)
 
     BOOST_CHECK(subAddressDoubleKey.GetID().ToString() == "dc103f3afbfa5fccf51bfcba8a65fb14ddd0c1a7");
 
-    BOOST_CHECK(subAddress.GetString() == "nv1szddvednme8p63xcxhcm3h3k4tlw5vnesudwe66km0w6jrqyymqz969xmknnz0w9unqczu58sp0rhqjc4tdmgt6hmtn9tpavrzckfdfcuwyx4w0s7dgvjce34377psjen6ug4s2xfg9smrw6qx70xtja6s8wrt28dc");
+    BOOST_CHECK(subAddress.GetString() == "nav1szddvednme8p63xcxhcm3h3k4tlw5vnesudwe66km0w6jrqyymqz969xmknnz0w9unqczu58sp0rhqjc4tdmgt6hmtn9tpavrzckfdfcuwyx4w0s7dgvjce34377psjen6ug4s2xfg9smrw6qx70xtja6syg55uu8z");
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/blsct/wallet/keyman_tests.cpp b/src/test/blsct/wallet/keyman_tests.cpp
index 08e83e1e948a5..cc103758fbbb8 100644
--- a/src/test/blsct/wallet/keyman_tests.cpp
+++ b/src/test/blsct/wallet/keyman_tests.cpp
@@ -28,16 +28,16 @@ BOOST_FIXTURE_TEST_CASE(wallet_test, TestingSetup)
     BOOST_CHECK(blsct_km->NewSubAddressPool(-1));
 
     std::vector<std::string> expectedAddresses = {
-        "nv14h85k6mf4l5fu3j4v0nuuswjwrz5entvzcw9jl3s8uknsndu0pfzaze4992n36uq7hpcy8yeuu854p0gmhq4m2u0tf5znazc527cxy4j7c39qxlc89wg4nca8pazkecx0p6wmu3pwrma3ercgrk8s7k475xxa5pl2w",
-        "nv1kq8zphgry92d02j7sm460c8xv88avuxcqlxrl7unxva9c4uawuvskx3s3pd6g3nychcq0ksy0tlpmgyt35384dnqdtudafa00yrjpcsffef404xur6cegkm98llf5xptkj6napgqk6g9dpa0x24qe4cgaq3v9scy0m",
-        "nv1s48u8dtxseguw6s7ecewph2szrxwy3fzx47rzdtppgzrnxrp0p0peetjx5h2f6gpwy3ar65tmw4p39z30pzt0t6san07th0694pffc0f6dghnskfujfanzwjdzep8fn0ezdeg7ejmvulj8nymrzkw8wdvqmhvl6gt5",
-        "nv1k34crux0s5urxtcndupcd37ehkakkz6da8n5ghmx388vfynhqa4k9zmrp8qmyw485ujvpkjwcasqhq5rqpxrkvhm0tg3ap3er8eycgwu5ew5xq5u84vzxsaqgc37ud67g5j9jvynlqacx78zl6l2flw82gvv2w5wzw",
-        "nv13qq8el3522u4jxd4e8y54du9d5fqlqlcmz8n90k8hc6e72dqky99ajgfarmd3puzx9zz9hazr99zrggharvuh9ulg9ugnu6nf5hfvq9mw03nv2g9xz9v2vnvn6uumrwxcv93ae54kuzjmz49g4mx0u2pzq2dmup8dn",
-        "nv1kh6n54xfhq0nmsr8rrqsff8xtegr8hvsdsvn2sdtk3w25w9fkescwqeqlnasm9ngcr895ycxx4ave2m5crya7hgyydhsa66ct995lrvywpgseu8cq4yjwcjm7dkh367pg3dhtxnwsfsct7my5tzu0c8jwsnddq2xw3",
-        "nv15gxjtgw289m82any2fn75gdh09cyte4c6qlzrms7wr4a4vyqdd8epl2qncrhspdflru3kcc4kdpzrrqtcvrq3qzxdjrh3l2lqr9v5jnjw22ut4axj9czcajj8pfyy0mm99n0q8088z99uame7ckrk8k3yvzc6em4d6",
-        "nv1j08knwnjcuukjl88vyt06c2h7unqjurflvtqaa9ljw08mz6swp2je7zg962u5qke9dc3cnhz3rkfdg0uhyw3zw6jk2akd08krzxqms74lcm9paapjygl3kglru3gaumy682qysl2hy6cgujqs9ugfxvqzcpmrge5pg",
-        "nv15vn8346nl5ttuu28w7dhwetq5vlu8tv3dgdqdhks769ye9gd9ssaszk5unwtejp6vftw82936k20m93sc4z9z29zz4f2rneexfw770ducywzxt3wp6vc7c3lhgxn2jxxufv74hwppcxd3prcn2yf2qgk6stntwl9lg",
-        "nv1kag0sqeuzz64stxmc5ztrafqvyx7lv4k09leasauyku5eg6zdsh23nyauzwrszyqysj02ecqmzkdrdym02w7u5y6ed7ptwe5adqyqufnqfj5hqve2et935gw8p8jculfnr66qpk8u86f35zaxs053920gs84wlan8z"};
+        "nav14h85k6mf4l5fu3j4v0nuuswjwrz5entvzcw9jl3s8uknsndu0pfzaze4992n36uq7hpcy8yeuu854p0gmhq4m2u0tf5znazc527cxy4j7c39qxlc89wg4nca8pazkecx0p6wmu3pwrma3ercgrk8s7k4759q2thyq5",
+        "nav1kq8zphgry92d02j7sm460c8xv88avuxcqlxrl7unxva9c4uawuvskx3s3pd6g3nychcq0ksy0tlpmgyt35384dnqdtudafa00yrjpcsffef404xur6cegkm98llf5xptkj6napgqk6g9dpa0x24qe4cgaqj2j0wl9p",
+        "nav1s48u8dtxseguw6s7ecewph2szrxwy3fzx47rzdtppgzrnxrp0p0peetjx5h2f6gpwy3ar65tmw4p39z30pzt0t6san07th0694pffc0f6dghnskfujfanzwjdzep8fn0ezdeg7ejmvulj8nymrzkw8wdvqc3mqvnpw",
+        "nav1k34crux0s5urxtcndupcd37ehkakkz6da8n5ghmx388vfynhqa4k9zmrp8qmyw485ujvpkjwcasqhq5rqpxrkvhm0tg3ap3er8eycgwu5ew5xq5u84vzxsaqgc37ud67g5j9jvynlqacx78zl6l2flw82g02a3z4g5",
+        "nav13qq8el3522u4jxd4e8y54du9d5fqlqlcmz8n90k8hc6e72dqky99ajgfarmd3puzx9zz9hazr99zrggharvuh9ulg9ugnu6nf5hfvq9mw03nv2g9xz9v2vnvn6uumrwxcv93ae54kuzjmz49g4mx0u2pzqftvrhu8f",
+        "nav1kh6n54xfhq0nmsr8rrqsff8xtegr8hvsdsvn2sdtk3w25w9fkescwqeqlnasm9ngcr895ycxx4ave2m5crya7hgyydhsa66ct995lrvywpgseu8cq4yjwcjm7dkh367pg3dhtxnwsfsct7my5tzu0c8jwsst6luayt",
+        "nav15gxjtgw289m82any2fn75gdh09cyte4c6qlzrms7wr4a4vyqdd8epl2qncrhspdflru3kcc4kdpzrrqtcvrq3qzxdjrh3l2lqr9v5jnjw22ut4axj9czcajj8pfyy0mm99n0q8088z99uame7ckrk8k3yvp7dxdw8q",
+        "nav1j08knwnjcuukjl88vyt06c2h7unqjurflvtqaa9ljw08mz6swp2je7zg962u5qke9dc3cnhz3rkfdg0uhyw3zw6jk2akd08krzxqms74lcm9paapjygl3kglru3gaumy682qysl2hy6cgujqs9ugfxvqzcza5h00tj",
+        "nav15vn8346nl5ttuu28w7dhwetq5vlu8tv3dgdqdhks769ye9gd9ssaszk5unwtejp6vftw82936k20m93sc4z9z29zz4f2rneexfw770ducywzxt3wp6vc7c3lhgxn2jxxufv74hwppcxd3prcn2yf2qgk6sg4u3f74j",
+        "nav1kag0sqeuzz64stxmc5ztrafqvyx7lv4k09leasauyku5eg6zdsh23nyauzwrszyqysj02ecqmzkdrdym02w7u5y6ed7ptwe5adqyqufnqfj5hqve2et935gw8p8jculfnr66qpk8u86f35zaxs053920gsyneqtgdc"};
 
     for (size_t i = 0; i < 10; i++) {
         auto recvAddress = blsct::SubAddress(std::get<blsct::DoublePublicKey>(blsct_km->GetNewDestination(0).value()));
diff --git a/src/test/blsct/wallet/txfactory_global_tests.cpp b/src/test/blsct/wallet/txfactory_global_tests.cpp
index 272a3168b4d8b..4487db0241e3f 100644
--- a/src/test/blsct/wallet/txfactory_global_tests.cpp
+++ b/src/test/blsct/wallet/txfactory_global_tests.cpp
@@ -12,16 +12,16 @@ BOOST_AUTO_TEST_SUITE(blsct_txfactory_global_tests)
 
 BOOST_FIXTURE_TEST_CASE(create_output_test, TestingSetup)
 {
-    std::string destAddr = "nv1szddvednme8p63xcxhcm3h3k4tlw5vnesudwe66km0w6jrqyymqz969xmknnz0w9unqczu58sp0rhqjc4tdmgt6hmtn9tpavrzckfdfcuwyx4w0s7dgvjce34377psjen6ug4s2xfg9smrw6qx70xtja6s8wrt28dc";
+    std::string destAddr = "nav14h85k6mf4l5fu3j4v0nuuswjwrz5entvzcw9jl3s8uknsndu0pfzaze4992n36uq7hpcy8yeuu854p0gmhq4m2u0tf5znazc527cxy4j7c39qxlc89wg4nca8pazkecx0p6wmu3pwrma3ercgrk8s7k4759q2thyq5";
     MclScalar blindingKey{ParseHex("42c0926471b3bd01ae130d9382c5fca2e2b5000abbf826a93132696ffa5f2c65")};
 
     auto out = blsct::CreateOutput(blsct::SubAddress(destAddr).GetKeys(), 1, "", TokenId(), blindingKey);
 
-    BOOST_CHECK(out.out.blsctData.viewTag == 20232);
-    BOOST_CHECK(HexStr(out.out.blsctData.spendingKey.GetVch()) == "84ee3e9c40fe65f91776033b5ddb3bf280bbd549924028280dad0d6ea464bb728886910f53bd66bcc2b59e37f1b8f55e");
-    BOOST_CHECK(HexStr(out.out.blsctData.blindingKey.GetVch()) == "80e845ca79807a66ab93121dd57971ee2acbb3ef20d94c0750eb33eaa64bf58fe0f5cd775dcf73b49117260e806e8708");
+    BOOST_CHECK(out.out.blsctData.viewTag == 52098);
+    BOOST_CHECK(HexStr(out.out.blsctData.spendingKey.GetVch()) == "90a498638b6d13a89b2dd1bbcb1caf419577878bff4c2d6426d602b9d74f3878d4a89feda5c2a59dc862a55c4e25a265");
+    BOOST_CHECK(HexStr(out.out.blsctData.blindingKey.GetVch()) == "b96f2eae5089b87e1f9c39f49cccc779c840d861ab0a722d9597273c4c6e9f4075ce5562c82efba02f46146bf17bad72");
     BOOST_CHECK(HexStr(out.out.blsctData.ephemeralKey.GetVch()) == "935963399885ba1dd51dd272fb9be541896ac619570315e55f06c1e3a42d28ffb300fe6a3247d484bb491b25ecf7fb8a");
-    BOOST_CHECK(out.gamma.GetString() == "77fb7a5ff31f1c28037942b94e23270338fa788e065855dffa6860be93073ee");
+    BOOST_CHECK(out.gamma.GetString() == "37763c3ba24138ed73aafc33881e221d942bd81b20acc840033eb0a7bc0be4b5");
     BOOST_CHECK(out.blindingKey.GetString() == "42c0926471b3bd01ae130d9382c5fca2e2b5000abbf826a93132696ffa5f2c65");
 }
 
diff --git a/src/test/blsct/wallet/validation_tests.cpp b/src/test/blsct/wallet/validation_tests.cpp
index 96f981a287f43..65ad2aff7c0c5 100644
--- a/src/test/blsct/wallet/validation_tests.cpp
+++ b/src/test/blsct/wallet/validation_tests.cpp
@@ -66,7 +66,7 @@ BOOST_FIXTURE_TEST_CASE(validation_reward_test, TestingSetup)
     CMutableTransaction tx;
     TxValidationState tx_state;
 
-    auto out = blsct::CreateOutput(blsct::DoublePublicKey(), 900 * COIN, " Reward ");
+    auto out = blsct::CreateOutput(blsct::DoublePublicKey(MclG1Point::Rand(), MclG1Point::Rand()), 900 * COIN, " Reward ");
     tx.vout.push_back(out.out);
     tx.txSig = out.GetSignature();
 
diff --git a/src/test/blsct_signature_checker_tests.cpp b/src/test/blsct_signature_checker_tests.cpp
new file mode 100644
index 0000000000000..89cdfb30e022b
--- /dev/null
+++ b/src/test/blsct_signature_checker_tests.cpp
@@ -0,0 +1,258 @@
+// Copyright (c) 2023 The Navio developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <blsct/private_key.h>
+#include <blsct/public_key.h>
+#include <blsct/signature.h>
+#include <blsct/wallet/verification.h>
+#include <coins.h>
+#include <primitives/transaction.h>
+#include <script/interpreter.h>
+#include <script/script.h>
+#include <test/util/setup_common.h>
+#include <validation.h>
+
+#include <boost/test/unit_test.hpp>
+
+BOOST_FIXTURE_TEST_SUITE(blsct_signature_checker_tests, BasicTestingSetup)
+
+BOOST_AUTO_TEST_CASE(test_transaction_signature_checker_bls_signature_storage)
+{
+    // Create a transaction with one input
+    CMutableTransaction tx;
+    tx.nVersion = 1;
+    tx.nLockTime = 0;
+
+    // Add a transaction input
+    CTxIn txin;
+    txin.prevout.hash = Txid::FromUint256(uint256::ONE); // Previous transaction hash
+    txin.prevout.n = 0;
+    txin.nSequence = 0xffffffff;
+    tx.vin.push_back(txin);
+
+    // Add a transaction output
+    CTxOut txout;
+    txout.nValue = 1000000; // 0.01 NAV
+    txout.scriptPubKey = CScript() << OP_1;
+    tx.vout.push_back(txout);
+
+    // Create the transaction
+    CTransaction transaction(tx);
+
+    // Create a TransactionSignatureChecker for the first input
+    TransactionSignatureChecker checker(&transaction, 0, 1000000, MissingDataBehavior::FAIL);
+
+    // Create test BLS public keys
+    std::vector<unsigned char> pubkey1_data = MclG1Point::Rand().GetVch();
+    std::vector<unsigned char> pubkey2_data = MclG1Point::Rand().GetVch();
+
+    // Create scriptSig (unlocking script) - empty for BLS signatures
+    CScript scriptSig;
+
+    // Create scriptPubKey (locking script) with multiple OP_BLSCHECKSIG calls
+    CScript scriptPubKey;
+    scriptPubKey << pubkey1_data << OP_BLSCHECKSIG;
+    scriptPubKey << pubkey2_data << OP_BLSCHECKSIG;
+
+    // Execute the script verification
+    ScriptError serror;
+    uint32_t flags = SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_STRICTENC;
+
+    bool result = VerifyScript(scriptSig, scriptPubKey, nullptr, flags, checker, &serror);
+
+    // Should succeed
+    BOOST_CHECK(result);
+    BOOST_CHECK_EQUAL(serror, SCRIPT_ERR_OK);
+
+    // Get the expected input hash (this is what should be stored as the message)
+    uint256 expected_input_hash = txin.GetHash();
+
+    // Verify that the key-message pairs were added to the internal vector
+    // We need to access the private member, so we'll test this indirectly
+    // by checking that the method returns true for valid public keys
+    // The actual verification would require access to the private key_message_pairs vector
+
+
+    // Verify that the input hash is what we expect
+    BOOST_CHECK_EQUAL(checker.GetKeyMessagePairs().size(), 2);
+    BOOST_CHECK_EQUAL(expected_input_hash, checker.GetKeyMessagePairs()[0].second);
+    BOOST_CHECK_EQUAL(expected_input_hash, checker.GetKeyMessagePairs()[1].second);
+}
+
+BOOST_AUTO_TEST_CASE(test_transaction_signature_checker_conditional_bls_signature)
+{
+    // Test with conditional OP_BLSCHECKSIG calls
+    CMutableTransaction tx;
+    tx.nVersion = 1;
+    tx.nLockTime = 0;
+
+    // Add a transaction input
+    CTxIn txin;
+    txin.prevout.hash = Txid::FromUint256(uint256::ZERO);
+    txin.prevout.n = 1;
+    txin.nSequence = 0xffffffff;
+    tx.vin.push_back(txin);
+
+    // Add a transaction output
+    CTxOut txout;
+    txout.nValue = 1000000; // 0.01 NAV
+    txout.scriptPubKey = CScript() << OP_1;
+    tx.vout.push_back(txout);
+
+    // Create the transaction
+    CTransaction transaction(tx);
+
+    // Create a TransactionSignatureChecker for the first input
+    TransactionSignatureChecker checker(&transaction, 0, 1000000, MissingDataBehavior::FAIL);
+
+    // Create test BLS public keys
+    std::vector<unsigned char> pubkey1_data = MclG1Point::Rand().GetVch();
+    std::vector<unsigned char> pubkey2_data = MclG1Point::Rand().GetVch();
+
+    // Create scriptSig (unlocking script) - empty for BLS signatures
+    CScript scriptSig;
+
+    // Create scriptPubKeys (locking scripts) with conditional OP_BLSCHECKSIG calls
+    CScript scriptPubKey1, scriptPubKey2;
+
+    // Script1: true path (first pubkey)
+    scriptSig << std::vector<unsigned char>{1};
+    scriptPubKey1 << std::vector<unsigned char>{1} << OP_EQUAL;
+    scriptPubKey1 << OP_IF << pubkey1_data << OP_BLSCHECKSIG;
+    scriptPubKey1 << OP_ELSE << pubkey2_data << OP_BLSCHECKSIG << OP_ENDIF;
+
+    // Script2: false path (second pubkey)
+    scriptPubKey2 << std::vector<unsigned char>{2} << OP_EQUAL;
+    scriptPubKey2 << OP_IF << pubkey1_data << OP_BLSCHECKSIG;
+    scriptPubKey2 << OP_ELSE << pubkey2_data << OP_BLSCHECKSIG << OP_ENDIF;
+
+    // Execute the script verification
+    ScriptError serror1, serror2;
+    uint32_t flags = SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_STRICTENC;
+
+    bool result1 = VerifyScript(scriptSig, scriptPubKey1, nullptr, flags, checker, &serror1);
+    bool result2 = VerifyScript(scriptSig, scriptPubKey2, nullptr, flags, checker, &serror2);
+
+    // Both should succeed
+    BOOST_CHECK(result1);
+    BOOST_CHECK(result2);
+    BOOST_CHECK_EQUAL(serror1, SCRIPT_ERR_OK);
+    BOOST_CHECK_EQUAL(serror2, SCRIPT_ERR_OK);
+
+    // Verify that the key-message pairs were added correctly
+    BOOST_CHECK_EQUAL(checker.GetKeyMessagePairs().size(), 2);
+
+    // First execution should use pubkey1
+    BOOST_CHECK(checker.GetKeyMessagePairs()[0].first == MclG1Point(pubkey1_data));
+
+    // Second execution should use pubkey2
+    BOOST_CHECK(checker.GetKeyMessagePairs()[1].first == MclG1Point(pubkey2_data));
+}
+
+
+BOOST_AUTO_TEST_CASE(test_transaction_signature_checker_single_bls_signature)
+{
+    // Test with a single OP_BLSCHECKSIG call
+    CMutableTransaction tx;
+    tx.nVersion = 1;
+    tx.nLockTime = 0;
+
+    // Add a transaction input
+    CTxIn txin;
+    txin.prevout.hash = Txid::FromUint256(uint256::ZERO); // Different previous transaction hash
+    txin.prevout.n = 1;
+    txin.nSequence = 0xffffffff;
+    tx.vin.push_back(txin);
+
+    // Add a transaction output
+    CTxOut txout;
+    txout.nValue = 5000000; // 0.05 NAV
+    txout.scriptPubKey = CScript() << OP_2;
+    tx.vout.push_back(txout);
+
+    // Create the transaction
+    CTransaction transaction(tx);
+
+    // Create a TransactionSignatureChecker for the first input
+    TransactionSignatureChecker checker(&transaction, 0, 5000000, MissingDataBehavior::FAIL);
+
+    // Create a test BLS public key
+    std::vector<unsigned char> pubkey_data = MclG1Point::Rand().GetVch();
+
+    // Create scriptSig (unlocking script) - empty for BLS signatures
+    CScript scriptSig;
+
+    // Create scriptPubKey (locking script) with OP_BLSCHECKSIG
+    CScript scriptPubKey;
+    scriptPubKey << pubkey_data << OP_BLSCHECKSIG;
+
+    // Execute the script verification
+    ScriptError serror;
+    uint32_t flags = SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_STRICTENC;
+
+    bool result = VerifyScript(scriptSig, scriptPubKey, nullptr, flags, checker, &serror);
+
+    // Should succeed
+    BOOST_CHECK(result);
+    BOOST_CHECK_EQUAL(serror, SCRIPT_ERR_OK);
+
+    // Get the expected input hash
+    uint256 expected_input_hash = txin.GetHash();
+
+    // Verify that the input hash is what we expect
+    BOOST_CHECK_EQUAL(checker.GetKeyMessagePairs().size(), 1);
+    BOOST_CHECK_EQUAL(expected_input_hash, checker.GetKeyMessagePairs()[0].second);
+}
+
+BOOST_AUTO_TEST_CASE(test_transaction_signature_checker_invalid_pubkey)
+{
+    // Test with invalid public key
+    CMutableTransaction tx;
+    tx.nVersion = 1;
+    tx.nLockTime = 0;
+
+    // Add a transaction input
+    CTxIn txin;
+    txin.prevout.hash = Txid::FromUint256(uint256::ONE);
+    txin.prevout.n = 0;
+    txin.nSequence = 0xffffffff;
+    tx.vin.push_back(txin);
+
+    // Add a transaction output
+    CTxOut txout;
+    txout.nValue = 1000000;
+    txout.scriptPubKey = CScript() << OP_1;
+    tx.vout.push_back(txout);
+
+    // Create the transaction
+    CTransaction transaction(tx);
+
+    // Create a TransactionSignatureChecker for the first input
+    TransactionSignatureChecker checker(&transaction, 0, 1000000, MissingDataBehavior::FAIL);
+
+    // Create an invalid public key (wrong size)
+    std::vector<unsigned char> invalid_pubkey = {0x01, 0x02, 0x03}; // Too short
+
+    // Create scriptSig (unlocking script) - empty for BLS signatures
+    CScript scriptSig;
+
+    // Create scriptPubKey (locking script) with OP_BLSCHECKSIG
+    CScript scriptPubKey;
+    scriptPubKey << invalid_pubkey << OP_BLSCHECKSIG;
+
+    // Execute the script verification
+    ScriptError serror;
+    uint32_t flags = SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_STRICTENC;
+
+    bool result = VerifyScript(scriptSig, scriptPubKey, nullptr, flags, checker, &serror);
+
+    // Should fail with invalid pubkey error
+    BOOST_CHECK(!result);
+    BOOST_CHECK_EQUAL(serror, SCRIPT_ERR_INVALID_PUBKEY);
+
+    // Verify that the key-message pairs were not added to the internal vector
+    BOOST_CHECK_EQUAL(checker.GetKeyMessagePairs().size(), 0);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
\ No newline at end of file
diff --git a/src/test/data/script_tests.json b/src/test/data/script_tests.json
index d5a41da413119..5f439ce3c26c3 100644
--- a/src/test/data/script_tests.json
+++ b/src/test/data/script_tests.json
@@ -246,12 +246,12 @@
 
 [
     "1",
-    "NOP1 CHECKLOCKTIMEVERIFY CHECKSEQUENCEVERIFY NOP4 NOP5 NOP6 NOP7 NOP8 NOP9 STAKED_COMMITMENT 1 EQUAL",
+    "NOP1 CHECKLOCKTIMEVERIFY CHECKSEQUENCEVERIFY NOP5 NOP6 NOP7 NOP8 NOP9 STAKED_COMMITMENT 1 EQUAL",
     "P2SH,STRICTENC",
     "OK"
 ],
 [
-    "'NOP_1_to_10' NOP1 CHECKLOCKTIMEVERIFY CHECKSEQUENCEVERIFY NOP4 NOP5 NOP6 NOP7 NOP8 NOP9 STAKED_COMMITMENT",
+    "'NOP_1_to_10' NOP1 CHECKLOCKTIMEVERIFY CHECKSEQUENCEVERIFY NOP5 NOP6 NOP7 NOP8 NOP9 STAKED_COMMITMENT",
     "'NOP_1_to_10' EQUAL",
     "P2SH,STRICTENC",
     "OK"
@@ -469,8 +469,12 @@
 
 ["NOP", "NOP1 1", "P2SH,STRICTENC", "OK"],
 ["NOP", "CHECKLOCKTIMEVERIFY 1", "P2SH,STRICTENC", "OK"],
-["NOP", "CHECKSEQUENCEVERIFY 1", "P2SH,STRICTENC", "OK"],
-["NOP", "NOP4 1", "P2SH,STRICTENC", "OK"],
+[
+    "NOP",
+    "CHECKSEQUENCEVERIFY 1",
+    "P2SH,STRICTENC",
+    "OK"
+],
 ["NOP", "NOP5 1", "P2SH,STRICTENC", "OK"],
 ["NOP", "NOP6 1", "P2SH,STRICTENC", "OK"],
 ["NOP", "NOP7 1", "P2SH,STRICTENC", "OK"],
@@ -891,20 +895,24 @@
 
 [
     "1",
-    "NOP1 CHECKLOCKTIMEVERIFY CHECKSEQUENCEVERIFY NOP4 NOP5 NOP6 NOP7 NOP8 NOP9 STAKED_COMMITMENT 2 EQUAL",
+    "NOP1 CHECKLOCKTIMEVERIFY CHECKSEQUENCEVERIFY NOP5 NOP6 NOP7 NOP8 NOP9 STAKED_COMMITMENT 2 EQUAL",
     "P2SH,STRICTENC",
     "EVAL_FALSE"
 ],
 [
-    "'NOP_1_to_10' NOP1 CHECKLOCKTIMEVERIFY CHECKSEQUENCEVERIFY NOP4 NOP5 NOP6 NOP7 NOP8 NOP9 STAKED_COMMITMENT",
+    "'NOP_1_to_10' NOP1 CHECKLOCKTIMEVERIFY CHECKSEQUENCEVERIFY NOP5 NOP6 NOP7 NOP8 NOP9 STAKED_COMMITMENT",
     "'NOP_1_to_11' EQUAL",
     "P2SH,STRICTENC",
     "EVAL_FALSE"
 ],
 
 ["Ensure 100% coverage of discouraged NOPS"],
-["1", "NOP1",  "P2SH,DISCOURAGE_UPGRADABLE_NOPS", "DISCOURAGE_UPGRADABLE_NOPS"],
-["1", "NOP4",  "P2SH,DISCOURAGE_UPGRADABLE_NOPS", "DISCOURAGE_UPGRADABLE_NOPS"],
+[
+    "1",
+    "NOP1",
+    "P2SH,DISCOURAGE_UPGRADABLE_NOPS",
+    "DISCOURAGE_UPGRADABLE_NOPS"
+],
 ["1", "NOP5",  "P2SH,DISCOURAGE_UPGRADABLE_NOPS", "DISCOURAGE_UPGRADABLE_NOPS"],
 ["1", "NOP6",  "P2SH,DISCOURAGE_UPGRADABLE_NOPS", "DISCOURAGE_UPGRADABLE_NOPS"],
 ["1", "NOP7",  "P2SH,DISCOURAGE_UPGRADABLE_NOPS", "DISCOURAGE_UPGRADABLE_NOPS"],
@@ -2652,6 +2660,5 @@
 ["0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0x09 0x300602010102010101", "0x01 0x14 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0x01 0x14 CHECKMULTISIG NOT", "DERSIG,NULLFAIL", "NULLFAIL", "BIP66-compliant but not NULLFAIL-compliant"],
 ["0 0x09 0x300602010102010101 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0", "0x01 0x14 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0x01 0x14 CHECKMULTISIG NOT", "DERSIG", "OK", "BIP66-compliant but not NULLFAIL-compliant"],
 ["0 0x09 0x300602010102010101 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0", "0x01 0x14 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0x01 0x14 CHECKMULTISIG NOT", "DERSIG,NULLFAIL", "NULLFAIL", "BIP66-compliant but not NULLFAIL-compliant"],
-
 ["The End"]
 ]
diff --git a/src/test/fuzz/rpc.cpp b/src/test/fuzz/rpc.cpp
index 24c8985a6a49a..83c037474ca42 100644
--- a/src/test/fuzz/rpc.cpp
+++ b/src/test/fuzz/rpc.cpp
@@ -68,12 +68,12 @@ std::string g_limit_to_rpc_command;
 // reading or writing to a filename passed as an RPC parameter, RPC commands
 // resulting in network activity, etc.
 const std::vector<std::string> RPC_COMMANDS_NOT_SAFE_FOR_FUZZING{
-    "addconnection",          // avoid DNS lookups
-    "addnode",                // avoid DNS lookups
-    "addpeeraddress",         // avoid DNS lookups
-    "dumptxoutset",           // avoid writing to disk
-    "dumpwallet",             // avoid writing to disk
-    "echoipc",                // avoid assertion failure (Assertion `"EnsureAnyNodeContext(request.context).init" && check' failed.)
+    "addconnection",  // avoid DNS lookups
+    "addnode",        // avoid DNS lookups
+    "addpeeraddress", // avoid DNS lookups
+    "dumptxoutset",   // avoid writing to disk
+    "dumpwallet",     // avoid writing to disk
+    "echoipc",        // avoid assertion failure (Assertion `"EnsureAnyNodeContext(request.context).init" && check' failed.)
     "enumeratesigners",
     "generatetoaddress",      // avoid prohibitively slow execution (when `num_blocks` is large)
     "generatetoblsctaddress", // avoid prohibitively slow execution (when `num_blocks` is large)
@@ -195,7 +195,12 @@ const std::vector<std::string> RPC_COMMANDS_SAFE_FOR_FUZZING{
     "minttoken",
     "mintnft",
     "gettokenbalance",
-    "getnftbalance"
+    "getnftbalance",
+    "verifyblsctbalanceproof",
+    "getblsctbalanceproof",
+    "createblsctrawtransaction",
+    "signblsctrawtransaction",
+    "fundblsctaddress",
 };
 
 std::string ConsumeScalarRPCArgument(FuzzedDataProvider& fuzzed_data_provider, bool& good_data)
diff --git a/src/test/key_io_tests.cpp b/src/test/key_io_tests.cpp
index 23b6aa0f068f4..b36d3965a6797 100644
--- a/src/test/key_io_tests.cpp
+++ b/src/test/key_io_tests.cpp
@@ -163,7 +163,7 @@ BOOST_AUTO_TEST_CASE(key_io_double_public_key_endode_decode)
 BOOST_AUTO_TEST_CASE(key_io_double_public_key_decode_encode)
 {
     // a valid bech32_mod encoded double public key
-    std::string dpk_bech32_mod = "nv1jlca8fe3jltegf54vwxyl2dvplpk3rz0ja6tjpdpfcar79cm43vxc40g8luh5xh0lva0qzkmytrthftje04fqnt8g6yq3j8t2z552ryhy8dnpyfgqyj58ypdptp43f32u28htwu0r37y9su6332jn0c0fcvan8l53m";
+    std::string dpk_bech32_mod = "nav1szddvednme8p63xcxhcm3h3k4tlw5vnesudwe66km0w6jrqyymqz969xmknnz0w9unqczu58sp0rhqjc4tdmgt6hmtn9tpavrzckfdfcuwyx4w0s7dgvjce34377psjen6ug4s2xfg9smrw6qx70xtja6syg55uu8z";
 
     // check if decoding and then encoding it produces
     // the original bech32_mod encoded double public key
diff --git a/src/test/script_parse_tests.cpp b/src/test/script_parse_tests.cpp
index bd7040f108628..64924940594e3 100644
--- a/src/test/script_parse_tests.cpp
+++ b/src/test/script_parse_tests.cpp
@@ -50,6 +50,6 @@ BOOST_AUTO_TEST_CASE(parse_script)
 
     BOOST_CHECK_EXCEPTION(ParseScript("11111111111111111111"), std::runtime_error, HasReason("script parse error: decimal numeric value only allowed in the range -0xFFFFFFFF...0xFFFFFFFF"));
     BOOST_CHECK_EXCEPTION(ParseScript("11111111111"), std::runtime_error, HasReason("script parse error: decimal numeric value only allowed in the range -0xFFFFFFFF...0xFFFFFFFF"));
-    BOOST_CHECK_EXCEPTION(ParseScript("OP_CHECKSIGADD"), std::runtime_error, HasReason("script parse error: unknown opcode"));
+    BOOST_CHECK_EXCEPTION(ParseScript("bb"), std::runtime_error, HasReason("script parse error: unknown opcode"));
 }
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/util/setup_common.h b/src/test/util/setup_common.h
index bc74c429a9769..f05b2d2e7eda3 100644
--- a/src/test/util/setup_common.h
+++ b/src/test/util/setup_common.h
@@ -10,20 +10,20 @@
 #include <blsct/wallet/address.h>
 #include <chainparamsbase.h>
 #include <common/args.h> // IWYU pragma: export
+#include <functional>
 #include <key.h>
 #include <node/caches.h>
 #include <node/context.h> // IWYU pragma: export
 #include <primitives/transaction.h>
 #include <pubkey.h>
 #include <stdexcept>
+#include <type_traits>
 #include <util/chaintype.h> // IWYU pragma: export
 #include <util/check.h>
 #include <util/fs.h>
+#include <util/strencodings.h>
 #include <util/string.h>
 #include <util/vector.h>
-
-#include <functional>
-#include <type_traits>
 #include <vector>
 
 class CFeeRate;
@@ -219,6 +219,7 @@ struct TestChain100Setup : public TestingSetup {
  * Testing fixture that pre-creates a 100-block REGTEST-mode BLSCT block chain
  */
 struct TestBLSCTChain100Setup : public TestingSetup {
+    volatile MclInit for_side_effect_only;
     blsct::SubAddress coinbaseDest;
 
     TestBLSCTChain100Setup(
diff --git a/src/wallet/rpc/backup.cpp b/src/wallet/rpc/backup.cpp
index 8f73916c11410..7cb60e1e2da10 100644
--- a/src/wallet/rpc/backup.cpp
+++ b/src/wallet/rpc/backup.cpp
@@ -2013,4 +2013,91 @@ RPCHelpMan restorewallet()
 },
     };
 }
-} // namespace wallet
+
+// RPCHelpMan importblsctscript()
+// {
+//     return RPCHelpMan{"importblsctscript",
+//                       "\nImport BLSCT scripts for watching. Requires a new wallet backup.\n"
+//                       "The imported scripts will be watch-only and cannot be used to spend.\n"
+//                       "Note: This call can take over an hour to complete if rescan is true, during that time, other rpc calls\n"
+//                       "may report that the imported scripts exist but related transactions are still missing.\n"
+//                       "The rescan parameter can be set to false if the script was never used to create transactions. If it is set to false,\n"
+//                       "but the script was used to create transactions, rescanblockchain needs to be called with the appropriate block range.\n"
+//                       "Note: Use \"getwalletinfo\" to query the scanning progress.\n",
+//                       {
+//                           {"label", RPCArg::Type::STR, RPCArg::Default{""}, "An optional label"},
+//                           {"scripts", RPCArg::Type::ARR, RPCArg::Optional::NO, "Array of scripts to import", {
+//                                                                                                                  {"script", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "A script"},
+//                                                                                                              }},
+//                           {"have_solving_data", RPCArg::Type::BOOL, RPCArg::Default{false}, "Whether the wallet has the data to solve the script"},
+//                           {"apply_label", RPCArg::Type::BOOL, RPCArg::Default{false}, "Whether to apply the label to the imported scripts"},
+//                           {"timestamp", RPCArg::Type::NUM, RPCArg::Default{0}, "Creation time of the script expressed in " + UNIX_EPOCH_TIME + ".\n"
+//                                                                                                                                                "The timestamp of the oldest script will determine how far back blockchain rescans need to begin for missing wallet transactions.\n"
+//                                                                                                                                                "0 can be specified to scan the entire blockchain. Blocks up to 2 hours before the earliest script\n"
+//                                                                                                                                                "creation time of all scripts being imported will be scanned."},
+//                       },
+//                       RPCResult{RPCResult::Type::BOOL, "", "true if successful"},
+//                       RPCExamples{HelpExampleCli("importblsctscript", "\"my label\" '[\"<script1>\", \"<script2>\"]' false true 0")},
+//                       [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue {
+//                           std::shared_ptr<CWallet> const pwallet = GetWalletForJSONRPCRequest(request);
+//                           if (!pwallet) return UniValue::VNULL;
+//                           CWallet& wallet{*pwallet};
+
+//                           // Make sure the results are valid at least up to the most recent block
+//                           // the user could have gotten from another RPC command prior to now
+//                           wallet.BlockUntilSyncedToCurrentChain();
+
+//                           std::string label = request.params[0].isNull() ? "" : request.params[0].get_str();
+
+//                           const UniValue& script_pub_keys = request.params[1];
+//                           if (!script_pub_keys.isArray()) {
+//                               throw JSONRPCError(RPC_TYPE_ERROR, "script_pub_keys must be an array");
+//                           }
+
+//                           std::set<CScript> scripts;
+//                           for (const UniValue& script : script_pub_keys.getValues()) {
+//                               if (!script.isStr()) {
+//                                   throw JSONRPCError(RPC_TYPE_ERROR, "script must be a string");
+//                               }
+
+//                               std::string script_str = script.get_str();
+//                               if (script_str.empty()) {
+//                                   throw JSONRPCError(RPC_INVALID_PARAMETER, "Empty script provided");
+//                               }
+
+//                               // Parse the script
+//                               std::vector<unsigned char> script_data;
+//                               if (!IsHex(script_str)) {
+//                                   throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid script: not hex");
+//                               }
+
+//                               try {
+//                                   script_data = ParseHex(script_str);
+//                               } catch (const std::exception& e) {
+//                                   throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid script: " + std::string(e.what()));
+//                               }
+
+//                               if (script_data.empty()) {
+//                                   throw JSONRPCError(RPC_INVALID_PARAMETER, "Empty script after parsing");
+//                               }
+
+//                               scripts.insert(CScript(script_data.begin(), script_data.end()));
+//                           }
+
+//                           if (scripts.empty()) {
+//                               throw JSONRPCError(RPC_INVALID_PARAMETER, "No scripts provided");
+//                           }
+
+//                           bool have_solving_data = request.params[2].isNull() ? false : request.params[2].get_bool();
+//                           bool apply_label = request.params[3].isNull() ? false : request.params[3].get_bool();
+//                           int64_t timestamp = request.params[4].isNull() ? 0 : request.params[4].getInt<int64_t>();
+
+//                           // Import the scripts
+//                           if (!wallet.importblsctscript(label, scripts, have_solving_data, apply_label, timestamp)) {
+//                               throw JSONRPCError(RPC_WALLET_ERROR, "Error importing BLSCT scripts");
+//                           }
+
+//                           return true;
+//                       }};
+// }
+} // namespace wallet
\ No newline at end of file
diff --git a/src/wallet/rpc/wallet.cpp b/src/wallet/rpc/wallet.cpp
index 489cb33feb1d2..cab5936dcdc6f 100644
--- a/src/wallet/rpc/wallet.cpp
+++ b/src/wallet/rpc/wallet.cpp
@@ -107,12 +107,20 @@ static RPCHelpMan getwalletinfo()
             }
             obj.pushKV("keypoolsize", (int64_t)kpExternalSize);
 
-            LegacyScriptPubKeyMan* spk_man = pwallet->GetLegacyScriptPubKeyMan();
-            if (spk_man) {
-                CKeyID seed_id = spk_man->GetHDChain().seed_id;
+            auto blsct_km = pwallet->GetBLSCTKeyMan();
+            if (blsct_km) {
+                CKeyID seed_id = blsct_km->GetHDChain().seed_id;
                 if (!seed_id.IsNull()) {
                     obj.pushKV("hdseedid", seed_id.GetHex());
                 }
+            } else {
+                LegacyScriptPubKeyMan* spk_man = pwallet->GetLegacyScriptPubKeyMan();
+                if (spk_man) {
+                    CKeyID seed_id = spk_man->GetHDChain().seed_id;
+                    if (!seed_id.IsNull()) {
+                        obj.pushKV("hdseedid", seed_id.GetHex());
+                    }
+                }
             }
 
             if (pwallet->CanSupportFeature(FEATURE_HD_SPLIT)) {
@@ -519,72 +527,69 @@ static RPCHelpMan unloadwallet()
 
 static RPCHelpMan sethdseed()
 {
-    return RPCHelpMan{"sethdseed",
-                "\nSet or generate a new HD wallet seed. Non-HD wallets will not be upgraded to being a HD wallet. Wallets that are already\n"
-                "HD will have a new HD seed set so that new keys added to the keypool will be derived from this new seed.\n"
-                "\nNote that you will need to MAKE A NEW BACKUP of your wallet after setting the HD wallet seed." + HELP_REQUIRING_PASSPHRASE +
-                "Note: This command is only compatible with legacy wallets.\n",
-                {
-                    {"newkeypool", RPCArg::Type::BOOL, RPCArg::Default{true}, "Whether to flush old unused addresses, including change addresses, from the keypool and regenerate it.\n"
-                                         "If true, the next address from getnewaddress and change address from getrawchangeaddress will be from this new seed.\n"
-                                         "If false, addresses (including change addresses if the wallet already had HD Chain Split enabled) from the existing\n"
-                                         "keypool will be used until it has been depleted."},
-                    {"seed", RPCArg::Type::STR, RPCArg::DefaultHint{"random seed"}, "The WIF private key to use as the new HD seed.\n"
-                                         "The seed value can be retrieved using the dumpwallet command. It is the private key marked hdseed=1"},
-                },
-                RPCResult{RPCResult::Type::NONE, "", ""},
-                RPCExamples{
-                    HelpExampleCli("sethdseed", "")
-            + HelpExampleCli("sethdseed", "false")
-            + HelpExampleCli("sethdseed", "true \"wifkey\"")
-            + HelpExampleRpc("sethdseed", "true, \"wifkey\"")
-                },
-        [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
-{
-    std::shared_ptr<CWallet> const pwallet = GetWalletForJSONRPCRequest(request);
-    if (!pwallet) return UniValue::VNULL;
+    return RPCHelpMan{
+        "sethdseed",
+        "\nSet or generate a new HD wallet seed. Non-HD wallets will not be upgraded to being a HD wallet. Wallets that are already\n"
+        "HD will have a new HD seed set so that new keys added to the keypool will be derived from this new seed.\n"
+        "\nNote that you will need to MAKE A NEW BACKUP of your wallet after setting the HD wallet seed." +
+            HELP_REQUIRING_PASSPHRASE +
+            "Note: This command is only compatible with legacy wallets.\n",
+        {
+            {"newkeypool", RPCArg::Type::BOOL, RPCArg::Default{true}, "Whether to flush old unused addresses, including change addresses, from the keypool and regenerate it.\n"
+                                                                      "If true, the next address from getnewaddress and change address from getrawchangeaddress will be from this new seed.\n"
+                                                                      "If false, addresses (including change addresses if the wallet already had HD Chain Split enabled) from the existing\n"
+                                                                      "keypool will be used until it has been depleted."},
+            {"seed", RPCArg::Type::STR, RPCArg::DefaultHint{"random seed"}, "The WIF private key to use as the new HD seed.\n"
+                                                                            "The seed value can be retrieved using the dumpwallet command. It is the private key marked hdseed=1"},
+        },
+        RPCResult{RPCResult::Type::NONE, "", ""},
+        RPCExamples{
+            HelpExampleCli("sethdseed", "") + HelpExampleCli("sethdseed", "false") + HelpExampleCli("sethdseed", "true \"wifkey\"") + HelpExampleRpc("sethdseed", "true, \"wifkey\"")},
+        [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue {
+            std::shared_ptr<CWallet> const pwallet = GetWalletForJSONRPCRequest(request);
+            if (!pwallet) return UniValue::VNULL;
 
-    LegacyScriptPubKeyMan& spk_man = EnsureLegacyScriptPubKeyMan(*pwallet, true);
+            LegacyScriptPubKeyMan& spk_man = EnsureLegacyScriptPubKeyMan(*pwallet, true);
 
-    if (pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
-        throw JSONRPCError(RPC_WALLET_ERROR, "Cannot set a HD seed to a wallet with private keys disabled");
-    }
+            if (pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
+                throw JSONRPCError(RPC_WALLET_ERROR, "Cannot set a HD seed to a wallet with private keys disabled");
+            }
 
-    LOCK2(pwallet->cs_wallet, spk_man.cs_KeyStore);
+            LOCK2(pwallet->cs_wallet, spk_man.cs_KeyStore);
 
-    // Do not do anything to non-HD wallets
-    if (!pwallet->CanSupportFeature(FEATURE_HD)) {
-        throw JSONRPCError(RPC_WALLET_ERROR, "Cannot set an HD seed on a non-HD wallet. Use the upgradewallet RPC in order to upgrade a non-HD wallet to HD");
-    }
+            // Do not do anything to non-HD wallets
+            if (!pwallet->CanSupportFeature(FEATURE_HD)) {
+                throw JSONRPCError(RPC_WALLET_ERROR, "Cannot set an HD seed on a non-HD wallet. Use the upgradewallet RPC in order to upgrade a non-HD wallet to HD");
+            }
 
-    EnsureWalletIsUnlocked(*pwallet);
+            EnsureWalletIsUnlocked(*pwallet);
 
-    bool flush_key_pool = true;
-    if (!request.params[0].isNull()) {
-        flush_key_pool = request.params[0].get_bool();
-    }
+            bool flush_key_pool = true;
+            if (!request.params[0].isNull()) {
+                flush_key_pool = request.params[0].get_bool();
+            }
 
-    CPubKey master_pub_key;
-    if (request.params[1].isNull()) {
-        master_pub_key = spk_man.GenerateNewSeed();
-    } else {
-        CKey key = DecodeSecret(request.params[1].get_str());
-        if (!key.IsValid()) {
-            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid private key");
-        }
+            CPubKey master_pub_key;
+            if (request.params[1].isNull()) {
+                master_pub_key = spk_man.GenerateNewSeed();
+            } else {
+                CKey key = DecodeSecret(request.params[1].get_str());
+                if (!key.IsValid()) {
+                    throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid private key");
+                }
 
-        if (HaveKey(spk_man, key)) {
-            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Already have this key (either as an HD seed or as a loose private key)");
-        }
+                if (HaveKey(spk_man, key)) {
+                    throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Already have this key (either as an HD seed or as a loose private key)");
+                }
 
-        master_pub_key = spk_man.DeriveNewSeed(key);
-    }
+                master_pub_key = spk_man.DeriveNewSeed(key);
+            }
 
-    spk_man.SetHDSeed(master_pub_key);
-    if (flush_key_pool) spk_man.NewKeyPool();
+            spk_man.SetHDSeed(master_pub_key);
+            if (flush_key_pool) spk_man.NewKeyPool();
 
-    return UniValue::VNULL;
-},
+            return UniValue::VNULL;
+        },
     };
 }
 
@@ -903,6 +908,7 @@ RPCHelpMan abandontransaction();
 RPCHelpMan rescanblockchain();
 RPCHelpMan abortrescan();
 
+
 Span<const CRPCCommand> GetWalletRPCCommands()
 {
     static const CRPCCommand commands[]{
diff --git a/src/wallet/wallet.cpp b/src/wallet/wallet.cpp
index f14bf4aa795b3..04d992d96dca4 100644
--- a/src/wallet/wallet.cpp
+++ b/src/wallet/wallet.cpp
@@ -1266,7 +1266,12 @@ CWalletTx* CWallet::AddToWallet(CTransactionRef tx, const TxState& state, const
     if (wtx.tx->IsBLSCT()) {
         for (auto& out : wtx.tx->vout) {
             if (blsct_man->IsMine(out))
-                blsct_man->GetSpendingKeyForOutputWithCache(out);
+            {
+                blsct::PrivateKey spending_key;
+                if (!blsct_man->GetSpendingKeyForOutputWithCache(out, spending_key)) {
+                    continue;
+                }
+            }
         }
 
         if (blsct_man) {
@@ -2763,6 +2768,13 @@ util::Result<CTxDestination> CWallet::GetNewChangeDestination(const OutputType t
 std::optional<int64_t> CWallet::GetOldestKeyPoolTime() const
 {
     LOCK(cs_wallet);
+    if (IsWalletFlagSet(WALLET_FLAG_BLSCT)) {
+        auto blsct_km = GetBLSCTKeyMan();
+        if (blsct_km) {
+            return blsct_km->GetOldestSubAddressPoolTime(0);
+        }
+    }
+
     if (m_spk_managers.empty()) {
         return std::nullopt;
     }
diff --git a/src/wallet/wallet.h b/src/wallet/wallet.h
index efc92563765e0..0b477238dff77 100644
--- a/src/wallet/wallet.h
+++ b/src/wallet/wallet.h
@@ -723,7 +723,7 @@ class CWallet final : public WalletStorage, public interfaces::Chain::Notificati
     bool ImportScripts(const std::set<CScript> scripts, int64_t timestamp) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
     bool ImportPrivKeys(const std::map<CKeyID, CKey>& privkey_map, const int64_t timestamp) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
     bool ImportPubKeys(const std::vector<CKeyID>& ordered_pubkeys, const std::map<CKeyID, CPubKey>& pubkey_map, const std::map<CKeyID, std::pair<CPubKey, KeyOriginInfo>>& key_origins, const bool add_keypool, const bool internal, const int64_t timestamp) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
-    bool ImportScriptPubKeys(const std::string& label, const std::set<CScript>& script_pub_keys, const bool have_solving_data, const bool apply_label, const int64_t timestamp) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
+    bool ImportScriptPubKeys(const std::string& label, const std::set<CScript>& script_pub_keys, const bool have_solving_data, const bool apply_label, const int64_t timestamp);
 
     /** Updates wallet birth time if 'time' is below it */
     void MaybeUpdateBirthTime(int64_t time);
diff --git a/src/wallet/walletdb.cpp b/src/wallet/walletdb.cpp
index fc9f83448f316..f65d58d1679b5 100644
--- a/src/wallet/walletdb.cpp
+++ b/src/wallet/walletdb.cpp
@@ -73,8 +73,10 @@ const std::string WALLETDESCRIPTORCKEY{"walletdescriptorckey"};
 const std::string WALLETDESCRIPTORKEY{"walletdescriptorkey"};
 const std::string WATCHMETA{"watchmeta"};
 const std::string WATCHS{"watchs"};
+const std::string BLSCTWATCHMETA{"blsctwatchmeta"};
+const std::string BLSCTWATCHS{"blsctwatchs"};
 const std::unordered_set<std::string> LEGACY_TYPES{CRYPTED_KEY, CSCRIPT, DEFAULTKEY, HDCHAIN, KEYMETA, KEY, OLD_KEY, POOL, WATCHMETA, WATCHS};
-const std::unordered_set<std::string> BLSCT_TYPES{CRYPTED_BLSCTKEY, BLSCTKEY, VIEWKEY, SPENDKEY, BLSCTKEYMETA, BLSCTOUTKEY};
+const std::unordered_set<std::string> BLSCT_TYPES{CRYPTED_BLSCTKEY, BLSCTKEY, VIEWKEY, SPENDKEY, BLSCTKEYMETA, BLSCTOUTKEY, BLSCTWATCHMETA, BLSCTWATCHS};
 const std::unordered_set<std::string> BLSCTKEY_TYPES{CRYPTED_BLSCTKEY, BLSCTKEY, BLSCTOUTKEY, CRYPTED_BLSCTOUTKEY};
 } // namespace DBKeys
 
@@ -329,6 +331,22 @@ bool WalletBatch::EraseWatchOnly(const CScript& dest)
     return EraseIC(std::make_pair(DBKeys::WATCHS, dest));
 }
 
+bool WalletBatch::WriteBLSCTWatchOnly(const CScript& dest, const CKeyMetadata& keyMeta)
+{
+    if (!WriteIC(std::make_pair(DBKeys::BLSCTWATCHMETA, dest), keyMeta)) {
+        return false;
+    }
+    return WriteIC(std::make_pair(DBKeys::BLSCTWATCHS, dest), uint8_t{'1'});
+}
+
+bool WalletBatch::EraseBLSCTWatchOnly(const CScript& dest)
+{
+    if (!EraseIC(std::make_pair(DBKeys::BLSCTWATCHMETA, dest))) {
+        return false;
+    }
+    return EraseIC(std::make_pair(DBKeys::BLSCTWATCHS, dest));
+}
+
 bool WalletBatch::WriteBestBlock(const CBlockLocator& locator)
 {
     WriteIC(DBKeys::BESTBLOCK, CBlockLocator()); // Write empty block locator so versions that require a merkle branch automatically rescan
diff --git a/src/wallet/walletdb.h b/src/wallet/walletdb.h
index 6db71ada2b917..0fbe71fb722da 100644
--- a/src/wallet/walletdb.h
+++ b/src/wallet/walletdb.h
@@ -100,6 +100,8 @@ extern const std::string WALLETDESCRIPTORCKEY;
 extern const std::string WALLETDESCRIPTORKEY;
 extern const std::string WATCHMETA;
 extern const std::string WATCHS;
+extern const std::string BLSCTWATCHMETA;
+extern const std::string BLSCTWATCHS;
 
 // Keys in this set pertain only to the legacy wallet (LegacyScriptPubKeyMan) and are removed during migration from legacy to descriptors.
 extern const std::unordered_set<std::string> LEGACY_TYPES;
@@ -272,6 +274,8 @@ class WalletBatch
     bool WriteCScript(const uint160& hash, const CScript& redeemScript);
     bool WriteWatchOnly(const CScript& script, const CKeyMetadata& keymeta);
     bool EraseWatchOnly(const CScript& script);
+    bool WriteBLSCTWatchOnly(const CScript& script, const CKeyMetadata& keymeta);
+    bool EraseBLSCTWatchOnly(const CScript& script);
 
     bool WriteBestBlock(const CBlockLocator& locator);
     bool ReadBestBlock(CBlockLocator& locator);
diff --git a/test/functional/bls_message_signing.py b/test/functional/bls_message_signing.py
new file mode 100755
index 0000000000000..8a16b51f2bf37
--- /dev/null
+++ b/test/functional/bls_message_signing.py
@@ -0,0 +1,146 @@
+#!/usr/bin/env python3
+# Copyright (c) 2024 The Navio Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+"""Simple test for the BLS message signing and verification RPC methods."""
+
+from test_framework.test_framework import BitcoinTestFramework
+from test_framework.util import (
+    assert_equal,
+    assert_raises_rpc_error,
+)
+
+
+class BLSMessageSigningTest(BitcoinTestFramework):
+    def add_options(self, parser):
+        self.add_wallet_options(parser, blsct=True)
+
+    def set_test_params(self):
+        self.num_nodes = 1
+        self.chain = 'blsctregtest'
+        self.setup_clean_chain = True
+
+    def skip_test_if_missing_module(self):
+        self.skip_if_no_wallet()
+
+    def run_test(self):
+        self.log.info("Testing BLS message signing and verification")
+
+        # Create a BLSCT wallet
+        self.nodes[0].createwallet(wallet_name="test_wallet", blsct=True)
+        wallet = self.nodes[0].get_wallet_rpc("test_wallet")
+
+        # Test basic error handling for signblsmessage
+        self.test_signblsmessage_errors(wallet)
+
+        # Test basic error handling for verifyblsmessage
+        self.test_verifyblsmessage_errors(wallet)
+
+        # Test complete workflow: sign, verify, and verify with wrong message
+        self.test_complete_workflow(wallet)
+
+    def test_complete_workflow(self, wallet):
+        """Test complete workflow: sign message, verify it, then verify with wrong message"""
+        self.log.info("Testing complete workflow: sign -> verify -> verify with wrong message")
+
+        # Test private key (this is a test key - in real usage users would provide their own)
+        test_private_key = "1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef"
+        original_message = "Hello, this is the original message!"
+        wrong_message = "Hello, this is a different message!"
+
+        # Step 1: Sign the original message
+        sign_result = wallet.signblsmessage(test_private_key, original_message)
+        self.log.info(f"Signing result: {sign_result}")
+
+        # Verify the result structure
+        assert "signature" in sign_result, "Signature not found in result"
+        assert "public_key" in sign_result, "Public key not found in result"
+        
+        signature = sign_result["signature"]
+        public_key = sign_result["public_key"]
+        
+        # Verify they are valid hex strings with correct lengths
+        assert len(signature) == 192, f"Signature should be 192 hex characters, got {len(signature)}"
+        assert len(public_key) == 96, f"Public key should be 96 hex characters, got {len(public_key)}"
+        assert all(c in '0123456789abcdef' for c in signature.lower()), "Signature should be valid hex"
+        assert all(c in '0123456789abcdef' for c in public_key.lower()), "Public key should be valid hex"
+
+        # Step 2: Verify the signature with the original message (should succeed)
+        verify_result = wallet.verifyblsmessage(public_key, original_message, signature)
+        self.log.info(f"Verification with original message: {verify_result}")
+        
+        # Assert that verification result is a boolean
+        assert isinstance(verify_result, bool), f"Verification result should be boolean, got {type(verify_result)}"
+        assert_equal(verify_result, True)
+
+        # Step 3: Verify the signature with a different message (should fail)
+        wrong_verify_result = wallet.verifyblsmessage(public_key, wrong_message, signature)
+        self.log.info(f"Verification with wrong message: {wrong_verify_result}")
+        assert_equal(wrong_verify_result, False)
+
+    def test_signblsmessage_errors(self, wallet):
+        """Test error handling for signblsmessage"""
+        self.log.info("Testing signblsmessage error handling")
+
+        # Test with invalid private key length
+        invalid_private_key = "1234567890abcdef"  # 16 bytes instead of 32
+        assert_raises_rpc_error(-8, "Private key must be 32 bytes (64 hex characters)",
+                               wallet.signblsmessage, invalid_private_key, "test message")
+
+        # Test with invalid hex characters
+        invalid_hex_private_key = "1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdeg"
+        assert_raises_rpc_error(-8, "Private key must be 32 bytes (64 hex characters)",
+                               wallet.signblsmessage, invalid_hex_private_key, "test message")
+
+        # Test with empty private key
+        assert_raises_rpc_error(-8, "Private key must be 32 bytes (64 hex characters)",
+                               wallet.signblsmessage, "", "test message")
+
+        # Test with missing parameters
+        assert_raises_rpc_error(-1, "signblsmessage",
+                               wallet.signblsmessage)
+
+        # Test with only one parameter
+        assert_raises_rpc_error(-1, "signblsmessage",
+                               wallet.signblsmessage, "1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef")
+
+        self.log.info("signblsmessage error handling tests passed")
+
+    def test_verifyblsmessage_errors(self, wallet):
+        """Test error handling for verifyblsmessage"""
+        self.log.info("Testing verifyblsmessage error handling")
+
+        # Test with invalid public key length
+        invalid_public_key = "1234567890abcdef"  # Too short
+        test_signature = "1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef"
+        assert_raises_rpc_error(-8, "Public key must be 48 bytes (96 hex characters)",
+                               wallet.verifyblsmessage, invalid_public_key, "test message", test_signature)
+
+        # Test with invalid signature length
+        invalid_signature = "1234567890abcdef"  # Too short
+        test_public_key = "1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef"
+        assert_raises_rpc_error(-8, "Signature must be 96 bytes",
+                               wallet.verifyblsmessage, test_public_key, "test message", invalid_signature)
+
+        # Test with invalid hex characters in public key
+        invalid_hex_public_key = "1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdeg"
+        assert_raises_rpc_error(-8, "Public key must be 48 bytes (96 hex characters)",
+                               wallet.verifyblsmessage, invalid_hex_public_key, "test message", test_signature)
+
+        # Test with missing parameters
+        assert_raises_rpc_error(-1, "verifyblsmessage",
+                               wallet.verifyblsmessage)
+
+        # Test with only one parameter
+        assert_raises_rpc_error(-1, "verifyblsmessage",
+                               wallet.verifyblsmessage, test_public_key)
+
+        # Test with only two parameters
+        assert_raises_rpc_error(-1, "verifyblsmessage",
+                               wallet.verifyblsmessage, test_public_key, "test message")
+
+        self.log.info("verifyblsmessage error handling tests passed")
+
+if __name__ == '__main__':
+    BLSMessageSigningTest().main() 
\ No newline at end of file
diff --git a/test/functional/blsct_balance_proof.py b/test/functional/blsct_balance_proof.py
new file mode 100755
index 0000000000000..60dffcc92b6bb
--- /dev/null
+++ b/test/functional/blsct_balance_proof.py
@@ -0,0 +1,90 @@
+#!/usr/bin/env python3
+# Copyright (c) 2024 The Navio Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+from test_framework.test_framework import BitcoinTestFramework
+from test_framework.util import (
+    assert_equal,
+    assert_raises_rpc_error,
+)
+
+class NavioBlsctBalanceProofTest(BitcoinTestFramework):
+    def add_options(self, parser):
+        self.add_wallet_options(parser, blsct=True)
+
+    def set_test_params(self):
+        # Set up two nodes for the test
+        self.num_nodes = 2
+        self.chain = 'blsctregtest'
+        self.setup_clean_chain = True
+
+    def skip_test_if_missing_module(self):
+        self.skip_if_no_wallet()
+
+    def run_test(self):
+        self.log.info("Creating wallet1 with BLSCT")
+
+        # Create a new wallet
+        self.nodes[0].createwallet(wallet_name="wallet1", blsct=True)
+        self.nodes[1].createwallet(wallet_name="wallet1", blsct=True)
+        wallet = self.nodes[0].get_wallet_rpc("wallet1")
+        wallet_2 = self.nodes[1].get_wallet_rpc("wallet1")
+
+        self.log.info("Loading wallet1")
+
+        # Ensure wallet is loaded
+        wallets = self.nodes[0].listwallets()
+        assert "wallet1" in wallets, "wallet1 was not loaded successfully"
+
+        self.log.info("Generating BLSCT address")
+
+        # Generate a BLSCT address
+        blsct_address = wallet.getnewaddress(label="", address_type="blsct")
+        blsct_address_2 = wallet_2.getnewaddress(label="", address_type="blsct")
+
+        self.log.info(f"BLSCT address NODE 1: {blsct_address}")
+        self.log.info(f"BLSCT address NODE 2: {blsct_address_2}")
+
+        # Generate blocks and fund the BLSCT address
+        self.log.info(f"Generating 101 blocks to the BLSCT address {blsct_address}")
+        block_hashes = self.generatetoblsctaddress(self.nodes[0], 101, blsct_address)
+
+        self.log.info(f"Generated blocks: {len(block_hashes)}")
+
+        # Check the balance of the wallet
+        balance = wallet.getbalance()
+        self.log.info(f"Balance in wallet1: {balance}")
+
+        assert_equal(len(block_hashes), 101)
+        assert balance > 0, "Balance should be greater than zero after mining"
+
+        # Test creating a balance proof
+        self.log.info("Testing createblsctbalanceproof")
+
+        # Create a valid proof
+        proof_result = wallet.createblsctbalanceproof(balance / 2)
+        assert "proof" in proof_result, "Proof not found in result"
+        proof_hex = proof_result["proof"]
+
+        # Test verifying the proof
+        self.log.info("Testing verifyblsctbalanceproof")
+
+        # Test with invalid proof format
+        assert_raises_rpc_error(-8, "Invalid proof format", wallet.verifyblsctbalanceproof, "invalid")
+
+        # Test with modified proof (corrupt the hex string)
+        if len(proof_hex) > 2:
+            # Modify the last character of the hex string
+            modified_proof = proof_hex[::-1]
+            assert_raises_rpc_error(-8, "Invalid proof format",wallet_2.verifyblsctbalanceproof, modified_proof)
+
+        # Verify the valid proof
+        verify_result = wallet_2.verifyblsctbalanceproof(proof_hex)
+        assert "valid" in verify_result, "Valid field not found in result"
+        assert "min_amount" in verify_result, "Min amount field not found in result"
+        assert verify_result["valid"], "Proof should be valid"
+        assert_equal(verify_result["min_amount"], balance / 2)
+
+if __name__ == '__main__':
+    NavioBlsctBalanceProofTest().main()
diff --git a/test/functional/blsct_import_scriptpubkeys.py b/test/functional/blsct_import_scriptpubkeys.py
new file mode 100755
index 0000000000000..ffa8e0790353b
--- /dev/null
+++ b/test/functional/blsct_import_scriptpubkeys.py
@@ -0,0 +1,283 @@
+#!/usr/bin/env python3
+# Copyright (c) 2024 The Navio Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+"""Test BLSCT raw transaction with custom script outputs."""
+
+from test_framework.test_framework import BitcoinTestFramework
+from test_framework.util import (
+    assert_equal,
+    assert_greater_than,
+)
+import random
+from decimal import Decimal
+
+class BLSCTRawTransactionScriptTest(BitcoinTestFramework):
+    def add_options(self, parser):
+        self.add_wallet_options(parser, blsct=True)
+
+    def set_test_params(self):
+        self.num_nodes = 2
+        self.chain = 'blsctregtest'
+        self.setup_clean_chain = True
+
+    def skip_test_if_missing_module(self):
+        self.skip_if_no_wallet()
+
+    def setup_network(self):
+        self.setup_nodes()
+        self.connect_nodes(0, 1)
+
+    def create_random_script(self):
+        """Create a random script for testing"""
+        # Create random data (32 bytes)
+        random_data = ''.join(random.choices('0123456789abcdef', k=64))
+        # OP_RETURN followed by data length and data
+        script = f"6a20{random_data}"  # 6a = OP_RETURN, 20 = 32 bytes
+        return script
+
+    def run_test(self):
+        self.log.info("Setting up wallets and generating initial blocks")
+
+        # Create BLSCT wallets
+        self.nodes[0].createwallet(wallet_name="wallet1", blsct=True)
+        self.nodes[1].createwallet(wallet_name="wallet2", blsct=True)
+
+        wallet1 = self.nodes[0].get_wallet_rpc("wallet1")
+        wallet2 = self.nodes[1].get_wallet_rpc("wallet2")
+
+        # Generate BLSCT addresses
+        address1 = wallet1.getnewaddress(label="", address_type="blsct")
+        address2 = wallet2.getnewaddress(label="", address_type="blsct")
+
+        self.log.info(f"Address 1: {address1}")
+        self.log.info(f"Address 2: {address2}")
+
+        # Generate blocks to fund the first wallet
+        self.log.info("Generating 101 blocks to fund wallet1")
+        self.generatetoblsctaddress(self.nodes[0], 101, address1)
+
+        # Check initial balance
+        balance1 = wallet1.getbalance()
+        self.log.info(f"Initial balance in wallet1: {balance1}")
+        assert_greater_than(balance1, 0)
+
+        # Test BLSCT raw transaction with custom scripts
+        self.test_blsct_raw_transaction_with_script(wallet1, wallet2, address1, address2)
+        self.test_blsct_raw_transaction_multiple_scripts(wallet1, wallet2, address1, address2)
+        self.test_blsct_raw_transaction_script_verification(wallet1, wallet2, address1, address2)
+
+    def test_blsct_raw_transaction_with_script(self, wallet1, wallet2, address1, address2):
+        """Test creating a BLSCT raw transaction with a custom script output"""
+        self.log.info("Testing BLSCT raw transaction with custom script")
+
+        # Get unspent outputs from wallet1
+        unspent = wallet1.listblsctunspent()
+        assert_greater_than(len(unspent), 0)
+        utxo = unspent[0]
+
+        # Create a random script
+        custom_script = self.create_random_script()
+        self.log.info(f"Custom script: {custom_script}")
+
+        # Create transaction inputs
+        inputs = [{"txid": utxo['txid'], "vout": utxo['vout']}]
+
+        # Create transaction outputs
+        outputs = [
+            {"address": address2, "amount": 0.1, "memo": "Regular output"},
+            {"address": address2, "script": custom_script, "amount": 0.05, "memo": "Custom script output"}
+        ]
+
+        # Create raw transaction
+        raw_tx = wallet1.createblsctrawtransaction(inputs, outputs)
+        self.log.info(f"Created raw transaction: {raw_tx}")
+
+        # Fund the transaction
+        funded_tx = wallet1.fundblsctrawtransaction(raw_tx)
+        self.log.info(f"Funded transaction: {funded_tx}")
+
+        # Sign the transaction
+        signed_tx = wallet1.signblsctrawtransaction(funded_tx)
+        self.log.info(f"Signed transaction: {signed_tx}")
+
+        # Decode and verify the transaction
+        decoded_tx = wallet1.decoderawtransaction(signed_tx)
+        self.log.info(f"Decoded transaction: {decoded_tx}")
+
+        # Get BLSCT recovery data to extract amounts and script information
+        recovery_data = wallet2.getblsctrecoverydata(signed_tx)
+        self.log.info(f"Recovery data: {recovery_data}")
+
+        script_found = False
+
+        for output in recovery_data['outputs']:
+            print(f"Output: {output} {output['script']} {custom_script}")
+            if 'script' in output and output['script'] == custom_script:
+                script_found = True
+                assert_equal(output['amount'], Decimal('0.05'))
+                self.log.info(f"Found custom script in output: {output}")
+                break
+
+        assert_equal(script_found, True)
+
+        # Check that the custom script is in the outputs
+        script_found = False
+        for output in decoded_tx['vout']:
+            if 'scriptPubKey' in output and output['scriptPubKey']['hex'] == custom_script:
+                script_found = True
+                self.log.info(f"Found custom script in output: {output}")
+                break
+        assert_equal(script_found, True)
+
+        # Send the transaction
+        txid = self.nodes[0].sendrawtransaction(signed_tx)
+        self.log.info(f"Sent transaction {txid}")
+
+        # Generate a block to confirm the transaction
+        self.generatetoblsctaddress(self.nodes[0], 1, address1)
+
+        # Verify the transaction is in the mempool and then confirmed
+        self.sync_all()
+
+        # Check that wallet2 received the regular output
+        balance2 = wallet2.getbalance()
+        assert_greater_than(balance2, 0)
+
+        self.log.info("BLSCT raw transaction with custom script test passed")
+
+    def test_blsct_raw_transaction_multiple_scripts(self, wallet1, wallet2, address1, address2):
+        """Test creating a BLSCT raw transaction with multiple custom script outputs"""
+        self.log.info("Testing BLSCT raw transaction with multiple custom scripts")
+
+        # Get unspent outputs from wallet1
+        unspent = wallet1.listblsctunspent()
+        assert_greater_than(len(unspent), 0)
+        utxo = unspent[0]
+
+        # Create multiple random scripts
+        script1 = self.create_random_script()
+        script2 = self.create_random_script()
+        script3 = self.create_random_script()
+
+        self.log.info(f"Script 1: {script1}")
+        self.log.info(f"Script 2: {script2}")
+        self.log.info(f"Script 3: {script3}")
+
+        # Create transaction inputs
+        inputs = [{"txid": utxo['txid'], "vout": utxo['vout']}]
+
+        # Create transaction outputs with multiple scripts
+        outputs = [
+            {"address": address2, "script": script1, "amount": 0.02, "memo": "Script 1 output"},
+            {"address": address2, "script": script2, "amount": 0.03, "memo": "Script 2 output"},
+            {"address": address2, "script": script3, "amount": 0.04, "memo": "Script 3 output"}
+        ]
+
+        # Create raw transaction
+        raw_tx = wallet1.createblsctrawtransaction(inputs, outputs)
+
+        # Fund the transaction
+        funded_tx = wallet1.fundblsctrawtransaction(raw_tx)
+
+        # Sign the transaction
+        signed_tx = wallet1.signblsctrawtransaction(funded_tx)
+
+        # Get BLSCT recovery data to extract amounts and script information
+        recovery_data = wallet2.getblsctrecoverydata(signed_tx)
+        self.log.info(f"Recovery data: {recovery_data}")
+
+        # Verify the outputs
+        assert_equal(len(recovery_data['outputs']), 4)
+        # Check that all custom scripts are in the outputs
+        scripts_found = set()
+        for output in recovery_data['outputs']:
+            if 'script' in output and output['gamma'] != "":
+                scripts_found.add(output['script'])
+        expected_scripts = {script1, script2, script3}
+        assert_equal(scripts_found, expected_scripts)
+
+        # Send the transaction
+        txid = self.nodes[0].sendrawtransaction(signed_tx)
+        self.log.info(f"Sent transaction {txid} with multiple scripts")
+
+        # Generate a block to confirm the transaction
+        self.generatetoblsctaddress(self.nodes[0], 1, address1)
+
+        self.log.info("BLSCT raw transaction with multiple custom scripts test passed")
+
+    def test_blsct_raw_transaction_script_verification(self, wallet1, wallet2, address1, address2):
+        """Test that custom scripts in BLSCT transactions can be verified by the node"""
+        self.log.info("Testing BLSCT raw transaction script verification")
+
+        # Get unspent outputs from wallet1
+        unspent = wallet1.listblsctunspent()
+        assert_greater_than(len(unspent), 0)
+        utxo = unspent[0]
+
+        # Create a custom script
+        custom_script = self.create_random_script()
+        self.log.info(f"Custom script: {custom_script}")
+
+        # Create transaction inputs
+        inputs = [{"txid": utxo['txid'], "vout": utxo['vout']}]
+
+        # Create transaction outputs with custom script
+        outputs = [
+            {"address": address2, "amount": 0.05, "memo": "Regular output"},
+            {"address": address1, "script": custom_script, "amount": 0.01, "memo": "Custom script output"}
+        ]
+
+        # Create raw transaction
+        raw_tx = wallet1.createblsctrawtransaction(inputs, outputs)
+
+        # Fund the transaction
+        funded_tx = wallet1.fundblsctrawtransaction(raw_tx)
+
+        # Sign the transaction
+        signed_tx = wallet1.signblsctrawtransaction(funded_tx)
+
+        # Send the transaction
+        txid = self.nodes[0].sendrawtransaction(signed_tx)
+        self.log.info(f"Sent transaction {txid} with custom script")
+
+        # Generate a block to confirm the transaction
+        self.generatetoblsctaddress(self.nodes[0], 1, address1)
+
+        # Wait a moment for the transaction to be processed
+        self.sync_all()
+
+        # Also check listunspent for the new outputs
+        unspent_after = wallet1.listunspent()
+        self.log.info(f"Unspent outputs after transaction: {len(unspent_after)}")
+
+        script_output_found = False
+
+        for utxo in unspent_after:
+            self.log.info(f"Unspent output: {utxo}")
+            if utxo['scriptPubKey'] == custom_script:
+                self.log.info(f"Found custom script in unspent output: {utxo}")
+                script_output_found = True
+                break
+
+        assert_equal(script_output_found, True)
+        # Look for outputs with our custom script using recovery data
+        script_output_found = False
+        for utxo in unspent_after:
+            # Get recovery data for this specific output
+            recovery_data_utxo = wallet1.getblsctrecoverydata(utxo['txid'], utxo['vout'])
+            for output in recovery_data_utxo['outputs']:
+                if 'script' in output and output['script'] == custom_script:
+                    script_output_found = True
+                    self.log.info(f"Found custom script in unspent output recovery data: {output}")
+                    break
+            if script_output_found:
+                break
+        assert_equal(script_output_found, True)
+
+        self.log.info("BLSCT raw transaction script verification test passed")
+
+
+if __name__ == '__main__':
+    BLSCTRawTransactionScriptTest().main()
diff --git a/test/functional/blsct_rawtransaction.py b/test/functional/blsct_rawtransaction.py
new file mode 100755
index 0000000000000..2f6f74b23da81
--- /dev/null
+++ b/test/functional/blsct_rawtransaction.py
@@ -0,0 +1,329 @@
+#!/usr/bin/env python3
+# Copyright (c) 2024 The Navio Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+"""Test the BLSCT raw transaction RPC methods."""
+
+from test_framework.test_framework import BitcoinTestFramework
+from test_framework.util import (
+    assert_equal,
+    assert_raises_rpc_error,
+    assert_greater_than,
+)
+from test_framework.messages import COIN
+
+
+class BLSCTRawTransactionTest(BitcoinTestFramework):
+    def add_options(self, parser):
+        self.add_wallet_options(parser, blsct=True)
+
+    def set_test_params(self):
+        self.num_nodes = 2
+        self.chain = 'blsctregtest'
+        self.setup_clean_chain = True
+
+    def skip_test_if_missing_module(self):
+        self.skip_if_no_wallet()
+
+    def setup_network(self):
+        self.setup_nodes()
+        self.connect_nodes(0, 1)
+
+    def run_test(self):
+        self.log.info("Setting up wallets and generating initial blocks")
+
+        # Create BLSCT wallets
+        self.nodes[0].createwallet(wallet_name="wallet1", blsct=True)
+        self.nodes[1].createwallet(wallet_name="wallet2", blsct=True)
+
+        wallet1 = self.nodes[0].get_wallet_rpc("wallet1")
+        wallet2 = self.nodes[1].get_wallet_rpc("wallet2")
+
+        # Generate BLSCT addresses
+        address1 = wallet1.getnewaddress(label="", address_type="blsct")
+        address2 = wallet2.getnewaddress(label="", address_type="blsct")
+
+        self.log.info(f"Address 1: {address1}")
+        self.log.info(f"Address 2: {address2}")
+
+        # Generate blocks to fund the first wallet
+        self.log.info("Generating 101 blocks to fund wallet1")
+        self.generatetoblsctaddress(self.nodes[0], 101, address1)
+
+        # Check initial balance
+        balance1 = wallet1.getbalance()
+        self.log.info(f"Initial balance in wallet1: {balance1}")
+
+        # Test the three RPC methods
+        self.test_createblsctrawtransaction(wallet1, wallet2, address1, address2)
+        self.test_fundblsctrawtransaction(wallet1, wallet2, address1, address2)
+        self.test_signblsctrawtransaction(wallet1, wallet2, address1, address2)
+        self.test_decodeblsctrawtransaction(wallet1, wallet2, address1, address2)
+        self.test_getblsctrecoverydata(wallet1, wallet2, address1, address2)
+        self.test_integration_workflow(wallet1, wallet2, address1, address2)
+
+    def test_createblsctrawtransaction(self, wallet1, wallet2, address1, address2):
+        """Test createblsctrawtransaction RPC method"""
+        self.log.info("Testing createblsctrawtransaction")
+
+        # Get some unspent outputs
+        unspent = wallet1.listblsctunspent()
+        assert_greater_than(len(unspent), 0)
+
+        utxo = unspent[0]
+        self.log.info(f"Using UTXO: {utxo['txid']}:{utxo['vout']}")
+
+        # Test 1: Create raw transaction with minimal inputs (wallet will fill missing data)
+        inputs = [{"txid": utxo['txid'], "vout": utxo['vout']}]
+        outputs = [{"address": address2, "amount": 0.1, "memo": "Test transaction"}]
+
+        raw_tx = wallet1.createblsctrawtransaction(inputs, outputs)
+        self.log.info(f"Created raw transaction: {raw_tx[:100]}...")
+
+        # Test 2: Create raw transaction with all optional fields provided
+        inputs_with_data = [{
+            "txid": utxo['txid'],
+            "vout": utxo['vout'],
+            "value": int(utxo['amount'] * COIN),
+            "is_staked_commitment": False
+        }]
+
+        raw_tx_with_data = wallet1.createblsctrawtransaction(inputs_with_data, outputs)
+        self.log.info(f"Created raw transaction with data: {raw_tx_with_data[:100]}...")
+        # Test 3: Create raw transaction with multiple outputs
+        outputs_multi = [
+            {"address": address2, "amount": 0.05, "memo": "First output"},
+            {"address": address1, "amount": 0.03, "memo": "Second output"}
+        ]
+
+        raw_tx_multi = wallet1.createblsctrawtransaction(inputs, outputs_multi)
+        self.log.info(f"Created raw transaction with multiple outputs: {raw_tx_multi[:100]}...")
+        # Test 4: Error cases
+        # Invalid address
+        outputs_invalid = [{"address": "invalid_address", "amount": 0.1}]
+        assert_raises_rpc_error(-5, "Invalid BLSCT address",
+                               wallet1.createblsctrawtransaction, inputs, outputs_invalid)
+
+        # Negative amount
+        outputs_negative = [{"address": address2, "amount": -0.1}]
+        assert_raises_rpc_error(-3, "Amount out of range",
+                               wallet1.createblsctrawtransaction, inputs, outputs_negative)
+
+        self.log.info("createblsctrawtransaction tests passed")
+
+    def test_fundblsctrawtransaction(self, wallet1, wallet2, address1, address2):
+        """Test fundblsctrawtransaction RPC method"""
+        self.log.info("Testing fundblsctrawtransaction")
+
+        # Create a raw transaction with insufficient inputs
+        inputs = []  # No inputs
+        outputs = [{"address": address2, "amount": 0.1, "memo": "Test funding"}]
+
+        raw_tx = wallet1.createblsctrawtransaction(inputs, outputs)
+
+        # Fund the transaction
+        funded_tx = wallet1.fundblsctrawtransaction(raw_tx)
+        self.log.info(f"Funded transaction: {funded_tx[:100]}...")
+
+        # Verify the funded transaction is different from the original
+        assert funded_tx != raw_tx, "Funded transaction should be different from original"
+
+        # Test with custom change address
+        change_address = wallet2.getnewaddress(label="", address_type="blsct")
+        funded_tx_with_change = wallet1.fundblsctrawtransaction(raw_tx, change_address)
+        self.log.info(f"Funded transaction with change: {funded_tx_with_change[:100]}...")
+        # Test error cases
+        # Invalid hex string
+        assert_raises_rpc_error(-22, "Transaction deserialization failed",
+                               wallet1.fundblsctrawtransaction, "invalid_hex")
+
+        # Invalid change address
+        assert_raises_rpc_error(-5, "Invalid BLSCT change address",
+                               wallet1.fundblsctrawtransaction, raw_tx, "invalid_address")
+
+        # Test with insufficient funds (create a transaction larger than available balance)
+        balance = wallet1.getbalance()
+        large_outputs = [{"address": address2, "amount": balance + 1, "memo": "Too much"}]
+        large_raw_tx = wallet1.createblsctrawtransaction(inputs, large_outputs)
+
+        assert_raises_rpc_error(-6, "Insufficient funds",
+                               wallet1.fundblsctrawtransaction, large_raw_tx)
+
+        self.log.info("fundblsctrawtransaction tests passed")
+
+    def test_signblsctrawtransaction(self, wallet1, wallet2, address1, address2):
+        """Test signblsctrawtransaction RPC method"""
+        self.log.info("Testing signblsctrawtransaction")
+
+        # Create and fund a raw transaction
+        inputs = []
+        outputs = [{"address": address2, "amount": 0.1, "memo": "Test signing"}]
+
+        raw_tx = wallet1.createblsctrawtransaction(inputs, outputs)
+        funded_tx = wallet1.fundblsctrawtransaction(raw_tx)
+
+        # Sign the transaction
+        signed_tx = wallet1.signblsctrawtransaction(funded_tx)
+        self.log.info(f"Signed transaction: {signed_tx[:100]}...")
+
+        # Verify the signed transaction is different from the funded transaction
+        assert signed_tx != funded_tx, "Signed transaction should be different from funded transaction"
+
+        self.log.info("signblsctrawtransaction tests passed")
+
+    def test_decodeblsctrawtransaction(self, wallet1, wallet2, address1, address2):
+        """Test decodeblsctrawtransaction RPC method"""
+        self.log.info("Testing decodeblsctrawtransaction")
+
+        # Get some unspent outputs
+        unspent = wallet1.listblsctunspent()
+        assert_greater_than(len(unspent), 0)
+
+        utxo = unspent[0]
+        self.log.info(f"Using UTXO: {utxo['txid']}:{utxo['vout']}")
+
+        # Test 1: Decode a raw transaction
+        raw_tx = wallet1.createblsctrawtransaction([{"txid": utxo['txid'], "vout": utxo['vout']}], [])
+        decoded_tx = wallet1.decodeblsctrawtransaction(raw_tx)
+        self.log.info(f"Decoded transaction: {decoded_tx}")
+
+        # Test 2: Error cases
+        # Invalid hex string
+        assert_raises_rpc_error(-22, "Transaction deserialization failed",
+                               wallet1.decodeblsctrawtransaction, "invalid_hex")
+
+        self.log.info("decodeblsctrawtransaction tests passed")
+
+    def test_getblsctrecoverydata(self, wallet1, wallet2, address1, address2):
+        """Test getblsctrecoverydata RPC method"""
+        self.log.info("Testing getblsctrecoverydata")
+
+        # Get some unspent outputs
+        unspent = wallet1.listblsctunspent()
+        assert_greater_than(len(unspent), 0)
+
+        utxo = unspent[0]
+        self.log.info(f"Using UTXO: {utxo}")
+
+        # Test 1: Get recovery data for a raw transaction (hex input)
+        raw_tx = wallet1.createblsctrawtransaction([{"txid": utxo['txid'], "vout": utxo['vout']}], [{"address": address1, "amount": 0.005, "memo": "Test script output"}])
+        funded_tx = wallet1.fundblsctrawtransaction(raw_tx)
+        signed_tx = wallet1.signblsctrawtransaction(funded_tx)
+        recovery_data = wallet1.getblsctrecoverydata(signed_tx)
+        self.log.info(f"Recovery data from hex: {recovery_data}")
+
+        assert_equal(len(recovery_data["outputs"]), 3)
+        # Verify the structure
+        assert "outputs" in recovery_data
+        assert isinstance(recovery_data["outputs"], list)
+        if len(recovery_data["outputs"]) > 0:
+            output = recovery_data["outputs"][0]
+            assert "vout" in output
+            assert "amount" in output
+            assert "gamma" in output
+            assert "message" in output
+
+        # Test 2: Get recovery data for a specific vout
+        if len(recovery_data["outputs"]) > 0:
+            specific_vout = recovery_data["outputs"][0]["vout"]
+            recovery_data_specific = wallet1.getblsctrecoverydata(signed_tx, specific_vout)
+            self.log.info(f"Recovery data for vout {specific_vout}: {recovery_data_specific}")
+
+            # Should have exactly one output
+            assert_equal(len(recovery_data_specific["outputs"]), 1)
+            assert_equal(recovery_data_specific["outputs"][0]["vout"], specific_vout)
+
+        # Test 3: Create and broadcast a transaction, then get recovery data by txid
+        # Create a simple transaction
+        inputs = []
+        outputs = [{"address": address2, "amount": 0.01, "memo": "Test recovery data"}]
+
+        raw_tx = wallet1.createblsctrawtransaction(inputs, outputs)
+        funded_tx = wallet1.fundblsctrawtransaction(raw_tx)
+        signed_tx = wallet1.signblsctrawtransaction(funded_tx)
+
+        # Broadcast the transaction
+        txid = self.nodes[0].sendrawtransaction(signed_tx)
+        self.log.info(f"Broadcasted transaction: {txid}")
+
+        # Mine a block to confirm
+        self.generatetoblsctaddress(self.nodes[0], 1, address1)
+
+        # Get the last received transaction to get the actual txid
+        transactions = wallet1.listtransactions("*", 1, 0)
+        assert_greater_than(len(transactions), 0)
+        last_tx = transactions[0]
+        actual_txid = last_tx["txid"]
+        self.log.info(f"Last received transaction: {actual_txid}")
+
+        # Get recovery data by txid
+        recovery_data_txid = wallet1.getblsctrecoverydata(actual_txid)
+        recovery_data_signed = wallet1.getblsctrecoverydata(actual_txid)
+        self.log.info(f"Recovery data from txid: {recovery_data_txid}")
+        self.log.info(f"Recovery data from signed: {recovery_data_signed}")
+
+        assert_equal(recovery_data_txid, recovery_data_signed)
+
+        # Verify we can get recovery data for specific vout
+        if len(recovery_data_txid["outputs"]) > 0:
+            specific_vout = recovery_data_txid["outputs"][0]["vout"]
+            recovery_data_specific_txid = wallet1.getblsctrecoverydata(actual_txid, specific_vout)
+            assert_equal(len(recovery_data_specific_txid["outputs"]), 1)
+
+        # Test 4: Error cases
+        # Invalid hex string
+        assert_raises_rpc_error(-22, "Transaction decode failed",
+                               wallet1.getblsctrecoverydata, "invalid_hex")
+
+        # Invalid vout index
+        assert_raises_rpc_error(-8, "vout index out of range",
+                               wallet1.getblsctrecoverydata, signed_tx, 999)
+
+        # Transaction not found in wallet (for txid input)
+        fake_txid = "1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef"
+        assert_raises_rpc_error(-8, "Transaction not found in wallet",
+                               wallet1.getblsctrecoverydata, fake_txid)
+
+        self.log.info("getblsctrecoverydata tests passed")
+
+    def test_integration_workflow(self, wallet1, wallet2, address1, address2):
+        """Test the complete workflow: create -> fund -> sign -> broadcast"""
+        self.log.info("Testing complete BLSCT raw transaction workflow")
+
+        # Step 1: Create raw transaction
+        inputs = []
+        outputs = [{"address": address2, "amount": 0.05, "memo": "Integration test"}]
+
+        raw_tx = wallet1.createblsctrawtransaction(inputs, outputs)
+        self.log.info("Step 1: Created raw transaction")
+
+        # Step 2: Fund the transaction
+        funded_tx = wallet1.fundblsctrawtransaction(raw_tx)
+        self.log.info("Step 2: Funded transaction")
+
+        # Step 3: Sign the transaction
+        signed_tx = wallet1.signblsctrawtransaction(funded_tx)
+        self.log.info("Step 3: Signed transaction")
+
+        initial_balance2 = wallet2.getbalance()
+        self.log.info(f"Initial balance in wallet2: {initial_balance2}")
+
+        # Step 4: Broadcast the transaction
+        txid = self.nodes[0].sendrawtransaction(signed_tx)
+        self.log.info(f"Step 4: Broadcasted transaction with txid: {txid}")
+
+        # Step 5: Mine a block to confirm the transaction
+        block_hashes = self.generatetoblsctaddress(self.nodes[0], 1, address1)
+        self.log.info(f"Step 5: Mined block: {block_hashes[0]}")
+
+        # Step 7: Check that the recipient received the funds
+        balance2 = wallet2.getbalance()
+        self.log.info(f"Final balance in wallet2: {balance2}")
+        assert_greater_than(balance2, initial_balance2)
+
+        self.log.info("Complete BLSCT raw transaction workflow test passed")
+
+
+if __name__ == '__main__':
+    BLSCTRawTransactionTest().main()
diff --git a/test/functional/test_framework/messages.py b/test/functional/test_framework/messages.py
index c99c5411293c3..1020866c5ccfc 100755
--- a/test/functional/test_framework/messages.py
+++ b/test/functional/test_framework/messages.py
@@ -520,6 +520,50 @@ def serialize(self):
         return r
 
 class RangeProof:
+    __slots__ = 'Vs', 'Ls', 'Rs', 'A', 'A_wip', 'B', 'r_prime', 's_prime', 'delta_prime', 'alpha_hat', 'tau_x'
+
+    def __init__(self):
+        self.Vs = []
+        self.Ls = []
+        self.Rs = []
+        self.A = MclG1Point()
+        self.A_wip = MclG1Point()
+        self.B = MclG1Point()
+        self.r_prime = MclScalar()
+        self.s_prime = MclScalar()
+        self.delta_prime = MclScalar()
+        self.alpha_hat = MclScalar()
+        self.tau_x = MclScalar()
+
+    def deserialize(self, f):
+        self.Vs = deser_vector(f, MclG1Point)
+        self.Ls = deser_vector(f, MclG1Point)
+        self.Rs = deser_vector(f, MclG1Point)
+        self.A.deserialize(f)
+        self.A_wip.deserialize(f)
+        self.B.deserialize(f)
+        self.r_prime.deserialize(f)
+        self.s_prime.deserialize(f)
+        self.delta_prime.deserialize(f)
+        self.alpha_hat.deserialize(f)
+        self.tau_x.deserialize(f)
+
+    def serialize(self):
+        r = b""
+        r += ser_vector(self.Vs, "serialize")
+        r += ser_vector(self.Ls, "serialize")
+        r += ser_vector(self.Rs, "serialize")
+        r += self.A.serialize()
+        r += self.A_wip.serialize()
+        r += self.B.serialize()
+        r += self.r_prime.serialize()
+        r += self.s_prime.serialize()
+        r += self.delta_prime.serialize()
+        r += self.alpha_hat.serialize()
+        r += self.tau_x.serialize()
+        return r
+
+class RangeProof_old:
     __slots__ = ("Vs", "A", "T1", "T2", "mu", "tau_x", "Ls", "Rs", "a", "b", "t_hat")
 
     def __init__(self, proof=None):
@@ -942,6 +986,9 @@ def rehash(self):
         self.calc_sha256()
         return self.sha256
 
+    def IsProofOfStake(self):
+        return self.nVersion & 0x01000000
+
     def __repr__(self):
         return "CBlockHeader(nVersion=%i hashPrevBlock=%064x hashMerkleRoot=%064x nTime=%s nBits=%08x nNonce=%08x)" \
             % (self.nVersion, self.hashPrevBlock, self.hashMerkleRoot,
@@ -951,19 +998,24 @@ def __repr__(self):
 assert_equal(BLOCK_HEADER_SIZE, 80)
 
 class CBlock(CBlockHeader):
-    __slots__ = ("vtx",)
+    __slots__ = ("vtx", "posProof")
 
     def __init__(self, header=None):
         super().__init__(header)
         self.vtx = []
+        self.posProof = PosProof()
 
     def deserialize(self, f):
         super().deserialize(f)
+        if self.IsProofOfStake():
+            self.posProof.deserialize(f)
         self.vtx = deser_vector(f, CTransaction)
 
     def serialize(self, with_witness=True):
         r = b""
         r += super().serialize()
+        if self.IsProofOfStake():
+            r += self.posProof.serialize()
         if with_witness:
             r += ser_vector(self.vtx, "serialize_with_witness")
         else:
@@ -1061,11 +1113,97 @@ def serialize_with_witness(self):
     def __repr__(self):
         return "PrefilledTransaction(index=%d, tx=%s)" % (self.index, repr(self.tx))
 
+class SetMemProof:
+    __slots__ = ("phi", "A1", "A2", "S1", "S2", "S3", "T1", "T2", "tau_x", "mu", "z_alpha", "z_tau", "z_beta", "t", "Ls", "Rs", "a", "b", "omega")
+
+    def __init__(self):
+        self.phi = MclG1Point()
+        self.A1 = MclG1Point()
+        self.A2 = MclG1Point()
+        self.S1 = MclG1Point()
+        self.S2 = MclG1Point()
+        self.S3 = MclG1Point()
+        self.T1 = MclG1Point()
+        self.T2 = MclG1Point()
+        self.tau_x = MclScalar()
+        self.mu = MclScalar()
+        self.z_alpha = MclScalar()
+        self.z_tau = MclScalar()
+        self.z_beta = MclScalar()
+        self.t = MclScalar()
+        self.Ls = []
+        self.Rs = []
+        self.a = MclScalar()
+        self.b = MclScalar()
+        self.omega = MclScalar()
+
+    def deserialize(self, f):
+        self.phi.deserialize(f)
+        self.A1.deserialize(f)
+        self.A2.deserialize(f)
+        self.S1.deserialize(f)
+        self.S2.deserialize(f)
+        self.S3.deserialize(f)
+        self.T1.deserialize(f)
+        self.T2.deserialize(f)
+        self.tau_x.deserialize(f)
+        self.mu.deserialize(f)
+        self.z_alpha.deserialize(f)
+        self.z_tau.deserialize(f)
+        self.z_beta.deserialize(f)
+        self.t.deserialize(f)
+        self.Ls = deser_vector(f, MclG1Point)
+        self.Rs = deser_vector(f, MclG1Point)
+        self.a.deserialize(f)
+        self.b.deserialize(f)
+        self.omega.deserialize(f)
+
+    def serialize(self):
+        r = b""
+        r += self.phi.serialize()
+        r += self.A1.serialize()
+        r += self.A2.serialize()
+        r += self.S1.serialize()
+        r += self.S2.serialize()
+        r += self.S3.serialize()
+        r += self.T1.serialize()
+        r += self.T2.serialize()
+        r += self.tau_x.serialize()
+        r += self.mu.serialize()
+        r += self.z_alpha.serialize()
+        r += self.z_tau.serialize()
+        r += self.z_beta.serialize()
+        r += self.t.serialize()
+        r += ser_vector(self.Ls, "serialize")
+        r += ser_vector(self.Rs, "serialize")
+        r += self.a.serialize()
+        r += self.b.serialize()
+        r += self.omega.serialize()
+        return r
+
+class PosProof:
+    __slots__ = ("set_mem_proof", "range_proof")
+
+    def __init__(self, set_mem_proof=SetMemProof(), range_proof=RangeProof()):
+        self.set_mem_proof = set_mem_proof
+        self.range_proof = range_proof
+
+    def deserialize(self, f):
+        self.set_mem_proof = SetMemProof()
+        self.set_mem_proof.deserialize(f)
+        self.range_proof = RangeProof()
+        self.range_proof.deserialize(f)
+
+    def serialize(self):
+        r = b""
+        r += self.set_mem_proof.serialize()
+        r += self.range_proof.serialize()
+        return r
 
 # This is what we send on the wire, in a cmpctblock message.
 class P2PHeaderAndShortIDs:
     __slots__ = ("header", "nonce", "prefilled_txn", "prefilled_txn_length",
-                 "shortids", "shortids_length")
+                 "shortids", "shortids_length", "posProof")
 
     def __init__(self):
         self.header = CBlockHeader()
@@ -1074,9 +1212,12 @@ def __init__(self):
         self.shortids = []
         self.prefilled_txn_length = 0
         self.prefilled_txn = []
+        self.posProof = PosProof()
 
     def deserialize(self, f):
         self.header.deserialize(f)
+        if self.header.IsProofOfStake():
+            self.posProof.deserialize(f)
         self.nonce = struct.unpack("<Q", f.read(8))[0]
         self.shortids_length = deser_compact_size(f)
         for _ in range(self.shortids_length):
@@ -1090,6 +1231,8 @@ def deserialize(self, f):
     def serialize(self, with_witness=False):
         r = b""
         r += self.header.serialize()
+        if self.header.IsProofOfStake():
+            r += self.posProof.serialize()
         r += struct.pack("<Q", self.nonce)
         r += ser_compact_size(self.shortids_length)
         for x in self.shortids:
@@ -1122,7 +1265,7 @@ def calculate_shortid(k0, k1, tx_hash):
 # This version gets rid of the array lengths, and reinterprets the differential
 # encoding into indices that can be used for lookup.
 class HeaderAndShortIDs:
-    __slots__ = ("header", "nonce", "prefilled_txn", "shortids", "use_witness")
+    __slots__ = ("header", "nonce", "prefilled_txn", "shortids", "use_witness", "posProof")
 
     def __init__(self, p2pheaders_and_shortids = None):
         self.header = CBlockHeader()
@@ -1130,11 +1273,12 @@ def __init__(self, p2pheaders_and_shortids = None):
         self.shortids = []
         self.prefilled_txn = []
         self.use_witness = False
-
+        self.posProof = PosProof()
         if p2pheaders_and_shortids is not None:
             self.header = p2pheaders_and_shortids.header
             self.nonce = p2pheaders_and_shortids.nonce
             self.shortids = p2pheaders_and_shortids.shortids
+            self.posProof = p2pheaders_and_shortids.posProof
             last_index = -1
             for x in p2pheaders_and_shortids.prefilled_txn:
                 self.prefilled_txn.append(PrefilledTransaction(x.index + last_index + 1, x.tx))
@@ -1151,6 +1295,7 @@ def to_p2p(self):
         ret.shortids = self.shortids
         ret.prefilled_txn_length = len(self.prefilled_txn)
         ret.prefilled_txn = []
+        ret.posProof = self.posProof
         last_index = -1
         for x in self.prefilled_txn:
             ret.prefilled_txn.append(PrefilledTransaction(x.index - last_index - 1, x.tx))
@@ -1159,6 +1304,8 @@ def to_p2p(self):
 
     def get_siphash_keys(self):
         header_nonce = self.header.serialize()
+        if self.header.IsProofOfStake():
+            header_nonce += self.posProof.serialize()
         header_nonce += struct.pack("<Q", self.nonce)
         hash_header_nonce_as_str = sha256(header_nonce)
         key0 = struct.unpack("<Q", hash_header_nonce_as_str[0:8])[0]
@@ -1170,6 +1317,7 @@ def initialize_from_block(self, block, nonce=0, prefill_list=None, use_witness=F
         if prefill_list is None:
             prefill_list = [0]
         self.header = CBlockHeader(block)
+        self.posProof = block.posProof
         self.nonce = nonce
         self.prefilled_txn = [ PrefilledTransaction(i, block.vtx[i]) for i in prefill_list ]
         self.shortids = []
diff --git a/test/functional/test_runner.py b/test/functional/test_runner.py
index bf7ba7a5b4ca6..88343bf3800a1 100755
--- a/test/functional/test_runner.py
+++ b/test/functional/test_runner.py
@@ -397,7 +397,11 @@
     'p2p_dandelionpp_mempool_leak.py',
     'p2p_dandelionpp_probing.py',
     'blsct_token.py',
-    'blsct_nft.py'
+    'blsct_nft.py',
+    'blsct_balance_proof.py',
+    'blsct_rawtransaction.py',
+    'blsct_import_scriptpubkeys.py',
+    'bls_message_signing.py'
     # Don't append tests at the end to avoid merge conflicts
     # Put them in a random line within the section that fits their approximate run-time
 ]
@@ -802,7 +806,7 @@ def was_successful(self):
 def check_script_prefixes():
     """Check that test scripts start with one of the allowed name prefixes."""
 
-    good_prefixes_re = re.compile("^(example|feature|interface|mempool|mining|p2p|rpc|wallet|tool|blsct)_")
+    good_prefixes_re = re.compile("^(example|feature|interface|mempool|mining|p2p|rpc|wallet|tool|blsct|bls)_")
     bad_script_names = [script for script in ALL_SCRIPTS if good_prefixes_re.match(script) is None]
 
     if bad_script_names:
diff --git a/test/functional/wallet_keypool.py b/test/functional/wallet_keypool.py
index d2341fb12e037..41d0c0ae44baa 100755
--- a/test/functional/wallet_keypool.py
+++ b/test/functional/wallet_keypool.py
@@ -26,7 +26,7 @@ def run_test(self):
         addr_before_encrypting = nodes[0].getnewaddress()
         addr_before_encrypting_data = nodes[0].getaddressinfo(addr_before_encrypting)
         wallet_info_old = nodes[0].getwalletinfo()
-        if not self.options.descriptors:
+        if not self.options.descriptors and 'hdseedid' in addr_before_encrypting_data and 'hdseedid' in wallet_info_old:
             assert addr_before_encrypting_data['hdseedid'] == wallet_info_old['hdseedid']
 
         # Encrypt wallet and wait to terminate
@@ -81,7 +81,7 @@ def run_test(self):
         addr_data = nodes[0].getaddressinfo(addr)
         wallet_info = nodes[0].getwalletinfo()
         assert addr_before_encrypting_data['hdmasterfingerprint'] != addr_data['hdmasterfingerprint']
-        if not self.options.descriptors:
+        if not self.options.descriptors and 'hdseedid' in addr_data and 'hdseedid' in wallet_info:
             assert addr_data['hdseedid'] == wallet_info['hdseedid']
         assert_raises_rpc_error(-12, "Error: Keypool ran out, please call keypoolrefill first", nodes[0].getnewaddress)