rpc: Added RPC endpoints for Compressed Transactions

src/rpc/rawtransaction.cpp

@@ -12,6 +12,7 @@
 #include <index/txindex.h>
 #include <key_io.h>
 #include <node/blockstorage.h>
+#include <node/chainstate.h>
 #include <node/coin.h>
 #include <node/context.h>
 #include <node/psbt.h>
@@ -20,6 +21,7 @@
 #include <policy/policy.h>
 #include <policy/rbf.h>
 #include <primitives/transaction.h>
+#include <primitives/compression.h>
 #include <psbt.h>
 #include <random.h>
 #include <rpc/blockchain.h>
@@ -494,6 +496,104 @@ static RPCHelpMan decoderawtransaction()
     };
 }
 
+static RPCHelpMan compressrawtransaction()
+{
+    return RPCHelpMan{"compressrawtransaction",
+                "Return a JSON object representing the compressed, serialized, hex-encoded transaction.",
+                {
+                    {"hexstring", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The transaction hex string"},
+                },
+                RPCResult{
+                    RPCResult::Type::OBJ, "", "",
+                    {
+                        {RPCResult::Type::STR_HEX, "result", "The compressed transaction hex string"},
+                        {RPCResult::Type::ARR, "warnings", "",
+                        {
+                            {RPCResult::Type::STR_HEX, "warning", "Warnings given for each input"}
+                        }}
+                    }
+                },
+                RPCExamples{
+                    HelpExampleCli("compressrawtransaction", "\"hexstring\"")
+            + HelpExampleRpc("compressrawtransaction", "\"hexstring\"")
+                },
+        [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
+{
+    const NodeContext& node = EnsureAnyNodeContext(request.context);
+
+    UniValue r(UniValue::VOBJ);
+    UniValue warnings(UniValue::VARR);
+    CMutableTransaction mtx;
+    if (DecodeHexTx(mtx, request.params[0].get_str(), true, true)) {
+        CTransaction tx = CTransaction(mtx);
+        LOCK(cs_main);
+        std::vector<std::string> warning_strings;
+        std::tuple<uint32_t, std::vector<CCompressedInput>> cinputstup = EnsureChainman(node).ActiveChainstate().CompressOutPoints(tx, warning_strings);
+        CCompressedTransaction ctx = CCompressedTransaction(CTransaction(mtx), std::get<0>(cinputstup), std::get<1>(cinputstup));
+        for (const auto& warning : warning_strings) {
+            warnings.push_back(warning);
+        }
+        for (size_t index = 0; index < ctx.vin().size(); index++) {
+            if (ctx.vin()[index].warning() != "") warnings.push_back(strprintf("UTXO(%u): %s", index, ctx.vin()[index].warning()));
+        }
+
+        DataStream stream;
+        ctx.Serialize(stream);
+        std::vector<unsigned char> hex(stream.size());
+        stream.read(MakeWritableByteSpan(hex));
+
+        r.pushKV("result", HexStr(hex));
+        r.pushKV("warnings", warnings);
+        return r;
+    }
+    throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "TX decode failed");
+},
+    };
+}
+
+static RPCHelpMan decompressrawtransaction()
+{
+    return RPCHelpMan{"decompressrawtransaction",
+                "Return a JSON object representing the decompressed, serialized, hex-encoded transaction.",
+                {
+                    {"hexstring", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The compressed transaction hex string"},
+                },
+                RPCResult{
+                       RPCResult::Type::STR_HEX, "result", "The decompressed transaction hex string"
+                },
+                RPCExamples{
+                    HelpExampleCli("decompressrawtransaction", "\"hexstring\"")
+            + HelpExampleRpc("decompressrawtransaction", "\"hexstring\"")
+                },
+        [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
+{
+    const NodeContext& node = EnsureAnyNodeContext(request.context);
+    UniValue r(UniValue::VOBJ);
+    try {
+        DataStream ssData(ParseHex(request.params[0].get_str()));
+        CCompressedTransaction tx = CCompressedTransaction(deserialize, ssData);
+        LOCK(cs_main);
+
+        std::vector<COutPoint> prevouts = EnsureChainman(node).ActiveChainstate().UncompressOutPoints(tx);
+        std::vector<Coin> coins = FindCoins(node, prevouts);
+        std::vector<CTxOut> outs;
+        outs.reserve(coins.size());
+        for (auto& coin : coins) {
+            outs.push_back(coin.out);
+        }
+
+//          std::tuple<std::vector<COutPoint>, std::vector<CTxOut>> Index = std::make_tuple(prevouts, outs);
+//          if (std::get<0>(Index).size() != std::get<1>(Index).size() || std::get<1>(Index).size() != tx.vin().size()) throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "Compressed TX decode failed");
+//          return EncodeHexTx(CTransaction(CMutableTransaction(tx, std::get<0>(Index), std::get<1>(Index))));
+        return "0x03";
+    } catch (const std::exception& exc) {
+        // Fall through.
+    }
+    throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "Compressed TX decode failed");
+},
+    };
+}
+
 static RPCHelpMan decodescript()
 {
     return RPCHelpMan{
@@ -2007,6 +2107,8 @@ void RegisterRawTransactionRPCCommands(CRPCTable& t)
         {"rawtransactions", &getrawtransaction},
         {"rawtransactions", &createrawtransaction},
         {"rawtransactions", &decoderawtransaction},
+        {"rawtransactions", &compressrawtransaction},
+        {"rawtransactions", &decompressrawtransaction},
         {"rawtransactions", &decodescript},
         {"rawtransactions", &combinerawtransaction},
         {"rawtransactions", &signrawtransactionwithkey},