It comiles, but will not work properly.

https://github.com/moneroexamples/openmonero/issues/99

src/CurrentBlockchainStatus.cpp

@@ -293,17 +293,20 @@ bool
 CurrentBlockchainStatus::get_random_outputs(
         const vector<uint64_t>& amounts,
         const uint64_t& outs_count,
-        vector<COMMAND_RPC_GET_OUTPUTS_BIN
-            ::outs>& found_outputs)
+        vector<COMMAND_RPC_GET_OUTPUT_HISTOGRAM::entry>& found_outputs)
 {
 
-    COMMAND_RPC_GET_OUTPUTS_BIN::request req;
-    COMMAND_RPC_GET_OUTPUTS_BIN::response res;
+    COMMAND_RPC_GET_OUTPUT_HISTOGRAM::request req;
+    COMMAND_RPC_GET_OUTPUT_HISTOGRAM::response res;
 
-    req.outs_count = outs_count;
     req.amounts = amounts;
+    req.unlocked = true;
+    req.recent_cutoff = 0;
+    req.min_count = outs_count;
+    req.max_count = 0;
 
-    //req.outputs.emplace_back();
+    //req.outs_count = outs_count;
+   // req.amounts = amounts;
 
     if (!mcore->get_random_outs_for_amounts(req, res))
     {
@@ -311,7 +314,28 @@ CurrentBlockchainStatus::get_random_outputs(
         return false;
     }
 
-    found_outputs = res.outs;
+    found_outputs = res.histogram;
+
+    struct gamma_engine
+    {
+      typedef uint64_t result_type;
+      static constexpr result_type min() { return 0; }
+      static constexpr result_type max() { return std::numeric_limits<result_type>::max(); }
+      result_type operator()() { return crypto::rand<result_type>(); }
+    } engine;
+
+    static const double shape = 19.28/*16.94*/;
+    //static const double shape = m_testnet ? 17.02 : 17.28;
+    static const double scale = 1/1.61;
+    std::gamma_distribution<double> gamma(shape, scale);
+
+    uint64_t num_outs_found {0};
+
+    while (num_outs_found < outs_count)
+    {
+
+    }
+
 
     return true;
 }

src/CurrentBlockchainStatus.h

@@ -135,8 +135,8 @@ public:
     virtual bool
     get_random_outputs(const vector<uint64_t>& amounts,
                        const uint64_t& outs_count,
-                       vector<COMMAND_RPC_GET_OUTPUTS_BIN
-                        ::outs_for_amount>& found_outputs);
+                       vector<COMMAND_RPC_GET_OUTPUT_HISTOGRAM::entry>&
+                        found_outputs);
 
     virtual uint64_t
     get_dynamic_per_kb_fee_estimate() const;

src/MicroCore.h

@@ -139,10 +139,52 @@ public:
 
     virtual bool
     get_random_outs_for_amounts(
-            COMMAND_RPC_GET_RANDOM_OUTS::request const& req,
-            COMMAND_RPC_GET_RANDOM_OUTS::response& res) const
+            COMMAND_RPC_GET_OUTPUT_HISTOGRAM::request const& req,
+            COMMAND_RPC_GET_OUTPUT_HISTOGRAM::response& res) const
     {
-        return core_storage.get_random_outs_for_amounts(req, res);
+        // based on bool core_rpc_server::on_get_output_histogram(const ...
+
+
+
+        //   <amoumt,
+        //    tuple<total_instances, unlocked_instances, recent_instances>
+        std::map<uint64_t,
+                std::tuple<uint64_t,  uint64_t, uint64_t>> histogram;
+
+        try
+        {
+            core_storage.get_output_histogram(
+                        req.amounts,
+                        req.unlocked,
+                        req.recent_cutoff,
+                        req.min_count);
+        }
+        catch (std::exception const& e)
+        {
+            res.status = "Failed to get output histogram";
+            return false;
+        }
+
+        res.histogram.clear();
+        res.histogram.reserve(histogram.size());
+
+        for (auto const& i: histogram)
+        {
+          if (std::get<0>(i.second)
+                  >= req.min_count
+                  && (std::get<0>(i.second) <= req.max_count
+                      || req.max_count == 0))
+            res.histogram.push_back(
+                        COMMAND_RPC_GET_OUTPUT_HISTOGRAM::entry(
+                            i.first,
+                            std::get<0>(i.second),
+                            std::get<1>(i.second),
+                            std::get<2>(i.second)));
+        }
+
+        res.status = CORE_RPC_STATUS_OK;
+
+        return true;
     }
 
     virtual bool

src/YourMoneroRequests.cpp

@@ -815,9 +815,9 @@ YourMoneroRequests::get_random_outs(
         return;
     }
 
-    using rpc_outs = COMMAND_RPC_GET_OUTPUTS_BIN;
+    using rpc_outs = COMMAND_RPC_GET_OUTPUT_HISTOGRAM;
 
-    vector<rpc_outs::outs_for_amount> found_outputs;
+    vector<rpc_outs::entry> found_outputs;
 
     if (current_bc_status->get_random_outputs(amounts, count, found_outputs))
     {
@@ -831,28 +831,26 @@ YourMoneroRequests::get_random_outs(
 
             json& j_outputs = j_outs["outputs"];
 
-            for (auto  const& out: outs.outs)
-            {
-                uint64_t global_amount_index = out.global_amount_index;
-
-                tuple<string, string, string>
-                        rct_field = current_bc_status
-                            ->construct_output_rct_field(
-                                    global_amount_index, outs.amount);
+//            for (auto  const& out: outs.outs)
+//            {
+//                tuple<string, string, string>
+//                        rct_field = current_bc_status
+//                            ->construct_output_rct_field(
+//                                    out.global_amount_index, outs.amount);
 
-                string rct = std::get<0>(rct_field)    // rct_pk
-                             + std::get<1>(rct_field)  // rct_mask
-                             + std::get<2>(rct_field); // rct_amount
+//                string rct = std::get<0>(rct_field)    // rct_pk
+//                             + std::get<1>(rct_field)  // rct_mask
+//                             + std::get<2>(rct_field); // rct_amount
 
-                json out_details {
-                        {"global_index", out.global_amount_index},
-                        {"public_key"  , pod_to_hex(out.out_key)},
-                        {"rct"         , rct}
-                };
+//                json out_details {
+//                        {"global_index", out.global_amount_index},
+//                        {"public_key"  , pod_to_hex(out.out_key)},
+//                        {"rct"         , rct}
+//                };
 
-                j_outputs.push_back(out_details);
+//                j_outputs.push_back(out_details);
 
-            } // for (const COMMAND_RPC_GET_RANDOM_OUTPUTS_FOR_AM
+//            } // for (const COMMAND_RPC_GET_RANDOM_OUTPUTS_FOR_AM
 
             j_amount_outs.push_back(j_outs);
 

src/monero_headers.h

@@ -15,6 +15,7 @@
 #define OUTPUT_EXPORT_FILE_MAGIC "Monero output export\003"
 
 #define FEE_ESTIMATE_GRACE_BLOCKS 10
+#define RECENT_OUTPUT_ZONE ((time_t)(RECENT_OUTPUT_DAYS * 86400))
 
 #include "version.h"