diff --git a/src/blockchain_db/blockchain_db.cpp b/src/blockchain_db/blockchain_db.cpp
index dcbb2e2de..b090ac57f 100644
--- a/src/blockchain_db/blockchain_db.cpp
+++ b/src/blockchain_db/blockchain_db.cpp
@@ -320,6 +320,11 @@ void BlockchainDB::remove_transaction(const crypto::hash& tx_hash)
   remove_transaction_data(tx_hash, tx);
 }
 
+void BlockchainDB::revert_transaction(const crypto::hash &tx_hash)
+{
+  remove_transaction(tx_hash);
+}
+
 block BlockchainDB::get_block_from_height(const uint64_t& height) const
 {
   blobdata bd = get_block_blob_from_height(height);
diff --git a/src/blockchain_db/blockchain_db.h b/src/blockchain_db/blockchain_db.h
index 0492e31ba..a07ebc29c 100644
--- a/src/blockchain_db/blockchain_db.h
+++ b/src/blockchain_db/blockchain_db.h
@@ -39,6 +39,7 @@
 #include <safex/safex_account.h>
 #include <safex/safex_offer.h>
 #include <safex/safex_purchase.h>
+#include <safex/safex_feedback.h>
 #include "common/command_line.h"
 #include "crypto/hash.h"
 #include "cryptonote_basic/blobdatatype.h"
@@ -1185,6 +1186,17 @@ namespace cryptonote
       virtual uint64_t height() const = 0;
 
 
+      // helper function to remove transaction from blockchain
+      /**
+       * @brief helper function to remove transaction from the blockchain
+       *
+       * This function encapsulates aspects of removing a transaction.
+       *
+       * @param tx_hash the hash of the transaction to be removed
+       */
+      void revert_transaction(const crypto::hash &tx_hash);
+
+
       /**
        * <!--
        * TODO: Rewrite (if necessary) such that all calls to remove_* are
@@ -1800,6 +1812,24 @@ namespace cryptonote
        */
       virtual bool get_safex_offers( std::vector<safex::safex_offer> &safex_offers) const = 0;
 
+      /**
+      * @brief fetch safex feedbacks for given offer id from the blockchain
+      *
+      * The subclass should return safex feedbacks data
+      *
+      * @return True if no error ocurred
+      */
+      virtual bool get_safex_feedbacks( std::vector<safex::safex_feedback> &safex_feedbacks, const crypto::hash& offer_id) const = 0;
+
+      /**
+       * @brief fetch safex offer's stars from the blockchain
+       *
+       * The subclass should return safex offer stars received
+       *
+       * @return True if no error ocurred
+       */
+      virtual bool get_offer_stars_given(const crypto::hash offer_id, uint64_t &stars_received) const = 0;
+
       //
       // Hard fork related storage
       //
diff --git a/src/blockchain_db/lmdb/db_lmdb.cpp b/src/blockchain_db/lmdb/db_lmdb.cpp
index 995adb049..081718b06 100644
--- a/src/blockchain_db/lmdb/db_lmdb.cpp
+++ b/src/blockchain_db/lmdb/db_lmdb.cpp
@@ -319,7 +319,7 @@ const char* const LMDB_NETWORK_FEE_SUM = "network_fee_sum";
 const char* const LMDB_TOKEN_LOCK_EXPIRY = "token_lock_expiry";
 const char* const LMDB_SAFEX_ACCOUNT = "safex_account";
 const char* const LMDB_SAFEX_OFFER = "safex_offer";
-
+const char* const LMDB_SAFEX_FEEDBACK = "safex_feedback";
 
 const char* const LMDB_PROPERTIES = "properties";
 
@@ -1394,7 +1394,7 @@ void BlockchainLMDB::remove_tx_outputs(const uint64_t tx_id, const transaction&
         safex::create_purchase_data purchase_output_data;
         parse_and_validate_object_from_blob(blobdata1, purchase_output_data);
         remove_safex_purchase(purchase_output_data.offer_id,purchase_output_data.quantity);
-    } else if(output_type == tx_out_type::out_network_fee){
+    } else if(output_type == tx_out_type::out_network_fee || output_type == tx_out_type::out_safex_feedback_token){
         remove_last_advanced_output();
     }
     else {
@@ -1629,6 +1629,22 @@ void BlockchainLMDB::process_command_input(const cryptonote::txin_to_script &txi
       safex::safex_purchase sfx_purchase{result->quantity, result->price, result->offer_id, result->shipping};
       create_safex_purchase(sfx_purchase);
 
+  }
+  else if (txin.command_type == safex::command_t::create_feedback)
+  {
+
+      std::unique_ptr<safex::command> cmd = safex::safex_command_serializer::parse_safex_object(txin.script, txin.command_type);
+      std::unique_ptr<safex::create_feedback_result> result(dynamic_cast<safex::create_feedback_result*>(cmd->execute(*this, txin)));
+      if (result->status != safex::execution_status::ok)
+      {
+          LOG_ERROR("Execution of safex purchase command failed, status:" << static_cast<int>(result->status));
+          throw1(DB_ERROR("Error executing safex purchase command"));
+      }
+
+      std::string comment{result->comment.begin(),result->comment.end()};
+      safex::safex_feedback sfx_feedback{result->stars_given, comment, result->offer_id};
+      create_safex_feedback(sfx_feedback);
+
   }
   else {
     throw1(DB_ERROR("Unknown safex command type"));
@@ -1824,6 +1840,7 @@ void BlockchainLMDB::open(const std::string& filename, const int db_flags)
   lmdb_db_open(txn, LMDB_TOKEN_LOCK_EXPIRY, MDB_INTEGERKEY | MDB_CREATE | MDB_DUPSORT | MDB_DUPFIXED, m_token_lock_expiry, "Failed to open db handle for m_token_lock_expiry");
   lmdb_db_open(txn, LMDB_SAFEX_ACCOUNT, MDB_CREATE, m_safex_account, "Failed to open db handle for m_safex_account");
   lmdb_db_open(txn, LMDB_SAFEX_OFFER, MDB_CREATE, m_safex_offer, "Failed to open db handle for m_safex_offer");
+  lmdb_db_open(txn, LMDB_SAFEX_FEEDBACK, MDB_CREATE, m_safex_feedback, "Failed to open db handle for m_safex_offer");
 
 
   lmdb_db_open(txn, LMDB_PROPERTIES, MDB_CREATE, m_properties, "Failed to open db handle for m_properties");
@@ -1843,7 +1860,7 @@ void BlockchainLMDB::open(const std::string& filename, const int db_flags)
   mdb_set_compare(txn, m_txpool_blob, compare_hash32);
   mdb_set_compare(txn, m_safex_account, compare_hash32);
   mdb_set_compare(txn, m_safex_offer, compare_hash32);
-
+  mdb_set_compare(txn, m_safex_feedback, compare_hash32);
 
     mdb_set_compare(txn, m_properties, compare_string);
 
@@ -2011,6 +2028,8 @@ void BlockchainLMDB::reset()
     throw0(DB_ERROR(lmdb_error("Failed to drop m_safex_account: ", result).c_str()));
   if (auto result = mdb_drop(txn, m_safex_offer, 0))
     throw0(DB_ERROR(lmdb_error("Failed to drop m_safex_offer: ", result).c_str()));
+  if (auto result = mdb_drop(txn, m_safex_feedback, 0))
+    throw0(DB_ERROR(lmdb_error("Failed to drop m_safex_feedback: ", result).c_str()));
 
   if (auto result = mdb_drop(txn, m_properties, 0))
     throw0(DB_ERROR(lmdb_error("Failed to drop m_properties: ", result).c_str()));
@@ -5177,6 +5196,9 @@ bool BlockchainLMDB::is_valid_transaction_output_type(const txout_target_v &txou
             const cryptonote::blobdata accblob((uint8_t*)v.mv_data, (uint8_t*)v.mv_data+v.mv_size);
             cryptonote::parse_and_validate_from_blob(accblob, sfx_offer);
 
+            if(sfx_offer.quantity - purchase.quantity > sfx_offer.quantity)
+              throw0(DB_ERROR("DB error attempting to create purchase: Not enough quantity of item"));
+
             sfx_offer.quantity -= purchase.quantity;
 
 
@@ -5195,6 +5217,50 @@ bool BlockchainLMDB::is_valid_transaction_output_type(const txout_target_v &txou
         }
     }
 
+    void BlockchainLMDB::create_safex_feedback(const safex::safex_feedback& feedback) {
+        LOG_PRINT_L3("BlockchainLMDB::" << __func__);
+        check_open();
+        mdb_txn_cursors *m_cursors = &m_wcursors;
+        MDB_cursor *cur_safex_feedback;
+        CURSOR(safex_feedback)
+        cur_safex_feedback = m_cur_safex_feedback;
+
+
+        int result;
+        MDB_val_set(k, feedback.offer_id);
+        MDB_val v;
+
+        result = mdb_cursor_get(cur_safex_feedback, &k, &v, MDB_SET);
+        if (result == MDB_SUCCESS)
+        {
+            std::vector<safex::safex_feedback_db_data> sfx_feedbacks;
+            const cryptonote::blobdata feedbackblob((uint8_t*)v.mv_data, (uint8_t*)v.mv_data+v.mv_size);
+            cryptonote::parse_and_validate_from_blob(feedbackblob, sfx_feedbacks);
+
+            sfx_feedbacks.emplace_back(feedback.stars_given,feedback.comment);
+
+            MDB_val_copy<blobdata> vupdate(t_serializable_object_to_blob(sfx_feedbacks));
+            auto result2 = mdb_cursor_put(cur_safex_feedback, &k, &vupdate, (unsigned int) MDB_CURRENT);
+            if (result2 != MDB_SUCCESS)
+                throw0(DB_ERROR(lmdb_error("Failed to add feedback for offer id: "+boost::lexical_cast<std::string>(feedback.offer_id), result2).c_str()));
+        }
+        else if (result == MDB_NOTFOUND)
+        {
+            std::vector<safex::safex_feedback_db_data> sfx_feedbacks;
+            sfx_feedbacks.emplace_back(feedback.stars_given,feedback.comment);
+
+            MDB_val_copy<blobdata> vupdate(t_serializable_object_to_blob(sfx_feedbacks));
+
+            result = mdb_cursor_put(cur_safex_feedback, (MDB_val *)&k, &vupdate, MDB_NOOVERWRITE);
+            if (result)
+                throw0(DB_ERROR(lmdb_error("Failed to add offer data to db transaction: ", result).c_str()));
+        }
+        else
+        {
+            throw0(DB_ERROR(lmdb_error("DB error attempting to create feedback: ", result).c_str()));
+        }
+    }
+
     bool BlockchainLMDB::get_account_key(const safex::account_username &username, crypto::public_key &pkey) const {
 
     LOG_PRINT_L3("BlockchainLMDB::" << __func__);
@@ -5404,7 +5470,51 @@ bool BlockchainLMDB::is_valid_transaction_output_type(const txout_target_v &txou
         return true;
     }
 
-  bool BlockchainLMDB::get_account_data(const safex::account_username &username, std::vector<uint8_t> &data) const {
+  bool BlockchainLMDB::get_offer_stars_given(const crypto::hash offer_id, uint64_t &stars_received) const{
+      LOG_PRINT_L3("BlockchainLMDB::" << __func__);
+      check_open();
+
+      TXN_PREFIX_RDONLY();
+
+      MDB_cursor *cur_safex_feedback;
+      RCURSOR(safex_feedback)
+      cur_safex_feedback = m_cur_safex_feedback;
+
+
+      uint8_t temp[SAFEX_OFFER_DATA_MAX_SIZE*10];
+
+      MDB_val_set(k, offer_id);
+      MDB_val_set(v, temp);
+      auto get_result = mdb_cursor_get(cur_safex_feedback, &k, &v, MDB_SET);
+      if (get_result == MDB_NOTFOUND)
+      {
+          //throw0(DB_ERROR(lmdb_error(std::string("DB error account not found: ").append(username.c_str()), get_result).c_str()));
+          return false;
+      }
+      else if (get_result)
+      {
+          throw0(DB_ERROR(lmdb_error(std::string("DB error attempting to fetch offer with id: ").append(offer_id.data), get_result).c_str()));
+      }
+      else if (get_result == MDB_SUCCESS)
+      {
+          std::vector<safex::safex_feedback_db_data> feedbacks;
+          blobdata tmp{(char*)v.mv_data, v.mv_size};
+          parse_and_validate_object_from_blob<std::vector<safex::safex_feedback_db_data>>(tmp,feedbacks);
+
+          stars_received = 0;
+
+          for(auto it: feedbacks)
+              stars_received += it.stars_given;
+          stars_received /= feedbacks.size();
+      }
+
+      TXN_POSTFIX_RDONLY();
+
+      return true;
+    }
+
+
+    bool BlockchainLMDB::get_account_data(const safex::account_username &username, std::vector<uint8_t> &data) const {
       LOG_PRINT_L3("BlockchainLMDB::" << __func__);
       check_open();
 
@@ -5474,6 +5584,8 @@ bool BlockchainLMDB::is_valid_transaction_output_type(const txout_target_v &txou
             std::string tmp{(char*)v.mv_data, v.mv_size};
             parse_and_validate_object_from_blob<safex::create_offer_result>(tmp,offer_result);
 
+            offer.quantity = offer_result.quantity;
+
             outputID = offer_result.output_ids.back();
         }
 
@@ -5500,7 +5612,6 @@ bool BlockchainLMDB::is_valid_transaction_output_type(const txout_target_v &txou
 
             offer.description = offer_result.description;
             offer.seller = std::string{offer_result.seller.begin(),offer_result.seller.end()};
-            offer.quantity = offer_result.quantity;
             offer.price = offer_result.price;
             offer.offer_id = offer_result.offer_id;
             offer.active = offer_result.active;
@@ -5679,6 +5790,46 @@ bool BlockchainLMDB::is_valid_transaction_output_type(const txout_target_v &txou
         return true;
     }
 
+    bool BlockchainLMDB::get_safex_feedbacks( std::vector<safex::safex_feedback> &safex_feedbacks, const crypto::hash& offer_id) const{
+      LOG_PRINT_L3("BlockchainLMDB::" << __func__);
+      check_open();
+
+      TXN_PREFIX_RDONLY();
+
+      MDB_cursor *cur_safex_feedback;
+      RCURSOR(safex_feedback)
+      cur_safex_feedback = m_cur_safex_feedback;
+
+
+      uint8_t temp[SAFEX_OFFER_DATA_MAX_SIZE*10];
+
+      MDB_val_set(k, offer_id);
+      MDB_val_set(v, temp);
+      auto get_result = mdb_cursor_get(cur_safex_feedback, &k, &v, MDB_SET);
+      if (get_result == MDB_NOTFOUND)
+      {
+        //throw0(DB_ERROR(lmdb_error(std::string("DB error account not found: ").append(username.c_str()), get_result).c_str()));
+        return false;
+      }
+      else if (get_result)
+      {
+        throw0(DB_ERROR(lmdb_error(std::string("DB error attempting to fetch offer with id: ").append(offer_id.data), get_result).c_str()));
+      }
+      else if (get_result == MDB_SUCCESS)
+      {
+        std::vector<safex::safex_feedback_db_data> feedbacks;
+        blobdata tmp{(char*)v.mv_data, v.mv_size};
+        parse_and_validate_object_from_blob<std::vector<safex::safex_feedback_db_data>>(tmp,feedbacks);
+
+        for(auto it: feedbacks) {
+          std::string comment{it.comment.begin(),it.comment.end()};
+          safex_feedbacks.emplace_back(it.stars_given, comment, offer_id);
+        }
+      }
+
+      TXN_POSTFIX_RDONLY();
+
+      return true;    }
 
 
 
diff --git a/src/blockchain_db/lmdb/db_lmdb.h b/src/blockchain_db/lmdb/db_lmdb.h
index 66df42a88..3683956c3 100644
--- a/src/blockchain_db/lmdb/db_lmdb.h
+++ b/src/blockchain_db/lmdb/db_lmdb.h
@@ -39,6 +39,7 @@
 #include <safex/safex_account.h>
 #include <safex/safex_offer.h>
 #include <safex/safex_purchase.h>
+#include <safex/safex_feedback.h>
 #include <safex/command.h>
 
 #define ENABLE_AUTO_RESIZE
@@ -75,7 +76,7 @@ typedef struct mdb_txn_cursors
   MDB_cursor *m_txc_token_lock_expiry;
   MDB_cursor *m_txc_safex_account;
   MDB_cursor *m_txc_safex_offer;
-
+  MDB_cursor *m_txc_safex_feedback;
 
 } mdb_txn_cursors;
 
@@ -100,7 +101,7 @@ typedef struct mdb_txn_cursors
 #define m_cur_token_lock_expiry	m_cursors->m_txc_token_lock_expiry
 #define m_cur_safex_account	m_cursors->m_txc_safex_account
 #define m_cur_safex_offer	m_cursors->m_txc_safex_offer
-
+#define m_cur_safex_feedback	m_cursors->m_txc_safex_feedback
 
 typedef struct mdb_rflags
 {
@@ -126,6 +127,7 @@ typedef struct mdb_rflags
   bool m_rf_token_lock_expiry;
   bool m_rf_safex_account;
   bool m_rf_safex_offer;
+  bool m_rf_safex_feedback;
 } mdb_rflags;
 
 typedef struct mdb_threadinfo
@@ -326,9 +328,12 @@ class BlockchainLMDB : public BlockchainDB
   virtual bool get_safex_offers(std::vector<safex::safex_offer> &offers) const;
   virtual bool get_create_account_output_id(const safex::account_username &username, uint64_t& output_id) const;
   virtual bool get_create_offer_output_id(const crypto::hash& offer_id, uint64_t& output_id) const;
+  virtual bool get_offer_stars_given(const crypto::hash offer_id, uint64_t &stars_received) const;
+  virtual bool get_safex_feedbacks( std::vector<safex::safex_feedback> &safex_feedbacks, const crypto::hash& offer_id) const;
+
 
 
-  virtual uint64_t add_block( const block& blk
+    virtual uint64_t add_block( const block& blk
                             , const size_t& block_size
                             , const difficulty_type& cumulative_difficulty
                             , const uint64_t& coins_generated
@@ -539,12 +544,22 @@ class BlockchainLMDB : public BlockchainDB
     /**
     * Create purchase in database
     *
-    * @param result safex purchase data
+    * @param purchase safex purchase data
     *
     * If any of this cannot be done, it throw the corresponding subclass of DB_EXCEPTION
     *
     */
-    void create_safex_purchase(const safex::safex_purchase& result);
+    void create_safex_purchase(const safex::safex_purchase& purchase);
+
+    /**
+    * Create feedback in database
+    *
+    * @param feedback safex feedback data
+    *
+    * If any of this cannot be done, it throw the corresponding subclass of DB_EXCEPTION
+    *
+    */
+    void create_safex_feedback(const safex::safex_feedback& feedback);
     /**
     * Remove advanced output from DB
     *
@@ -651,10 +666,10 @@ class BlockchainLMDB : public BlockchainDB
   MDB_dbi m_token_lock_expiry;
   MDB_dbi m_safex_account;
   MDB_dbi m_safex_offer;
+  MDB_dbi m_safex_feedback;
 
 
-
-    mutable uint64_t m_cum_size;	// used in batch size estimation
+  mutable uint64_t m_cum_size;	// used in batch size estimation
   mutable unsigned int m_cum_count;
   std::string m_folder;
   mdb_txn_safe* m_write_txn; // may point to either a short-lived txn or a batch txn
diff --git a/src/cryptonote_basic/cryptonote_basic.h b/src/cryptonote_basic/cryptonote_basic.h
index 999610464..6d20ca40c 100644
--- a/src/cryptonote_basic/cryptonote_basic.h
+++ b/src/cryptonote_basic/cryptonote_basic.h
@@ -228,6 +228,8 @@ namespace cryptonote
     out_safex_offer = 20,
     out_safex_offer_update = 21,
     out_safex_purchase = 30,
+    out_safex_feedback_token = 40,
+    out_safex_feedback = 41,
     out_invalid = 100
   };
 
diff --git a/src/cryptonote_core/blockchain.cpp b/src/cryptonote_core/blockchain.cpp
index abc6f98b6..bf087e5da 100644
--- a/src/cryptonote_core/blockchain.cpp
+++ b/src/cryptonote_core/blockchain.cpp
@@ -357,6 +357,9 @@ bool Blockchain::scan_outputkeys_for_indexes<Blockchain::outputs_generic_visitor
         //TODO: Check and set correct value
         output_type = tx_out_type::out_cash;
         break;
+      case safex::command_t::create_feedback:
+          output_type = tx_out_type::out_safex_feedback_token;
+          break;
     default:
       MERROR_VER("Unknown command type");
       return false;
@@ -373,6 +376,7 @@ bool Blockchain::scan_outputkeys_for_indexes<Blockchain::outputs_generic_visitor
   {
     case tx_out_type::out_staked_token:
     case tx_out_type::out_safex_account:
+    case tx_out_type::out_safex_feedback_token:
     {
       absolute_offsets = txin.key_offsets;
       break;
@@ -510,7 +514,8 @@ bool Blockchain::scan_outputkeys_for_indexes<Blockchain::outputs_generic_visitor
 /* Handle advanced outputs that should be spend in the transaction */
   else if ((output_type == tx_out_type::out_staked_token)
            || (output_type == tx_out_type::out_network_fee)
-           || (output_type == tx_out_type::out_safex_account)) {
+           || (output_type == tx_out_type::out_safex_account)
+           || (output_type == tx_out_type::out_safex_feedback_token)) {
 
     std::vector<output_advanced_data_t> outputs;
     bool found = false;
@@ -3380,6 +3385,21 @@ bool Blockchain::check_safex_tx(const transaction &tx, tx_verification_context &
           return false;
       }
   }
+  else if (command_type == safex::command_t::create_feedback)
+  {
+      //TODO: Make additional checks
+      for (const auto &vout: tx.vout)
+      {
+          if (vout.target.type() == typeid(txout_to_script) && get_tx_out_type(vout.target) == cryptonote::tx_out_type::out_safex_feedback)
+          {
+              const txout_to_script &out = boost::get<txout_to_script>(vout.target);
+              safex::create_feedback_data feedback;
+              const cryptonote::blobdata feedbackblob(std::begin(out.data), std::end(out.data));
+              cryptonote::parse_and_validate_from_blob(feedbackblob, feedback);
+              //TODO: check if OfferID exists
+          }
+      }
+  }
   else
   {
     MERROR("Unsupported safex command");
@@ -3534,6 +3554,11 @@ bool Blockchain::check_advanced_tx_input(const txin_to_script &txin, tx_verifica
       if (txin.amount == 0 || txin.token_amount > 0)
           return false;
   }
+  else if (txin.command_type == safex::command_t::create_feedback)
+  {
+      if (txin.amount > 0 || txin.token_amount > 0)
+          return false;
+  }
   else
   {
     MERROR_VER("Unknown input command type");
@@ -3756,7 +3781,8 @@ bool Blockchain::check_tx_inputs(transaction& tx, tx_verification_context &tvc,
           tpool.submit(&waiter, boost::bind(&Blockchain::check_migration_signature, this, std::cref(tx_prefix_hash), std::cref(tx.signatures[sig_index][0]), std::ref(results[sig_index])));
         }
         else if ((txin.type() == typeid(txin_to_script)) && (boost::get<txin_to_script>(txin).command_type == safex::command_t::distribute_network_fee ||
-                                                             boost::get<txin_to_script>(txin).command_type == safex::command_t::simple_purchase)) {
+                boost::get<txin_to_script>(txin).command_type == safex::command_t::simple_purchase ||
+                boost::get<txin_to_script>(txin).command_type == safex::command_t::create_feedback)) {
           //todo atana nothing to do here
           results[sig_index] = true;
         }
@@ -3793,7 +3819,8 @@ bool Blockchain::check_tx_inputs(transaction& tx, tx_verification_context &tvc,
         if (txin.type() == typeid(txin_token_migration)) {
           check_migration_signature(tx_prefix_hash, tx.signatures[sig_index][0], results[sig_index]);
         } else if ((txin.type() == typeid(txin_to_script)) && (boost::get<txin_to_script>(txin).command_type == safex::command_t::distribute_network_fee ||
-                                                               boost::get<txin_to_script>(txin).command_type == safex::command_t::simple_purchase)) {
+                                                               boost::get<txin_to_script>(txin).command_type == safex::command_t::simple_purchase ||
+                                                               boost::get<txin_to_script>(txin).command_type == safex::command_t::create_feedback)) {
           //todo atana nothing to do here
           results[sig_index] = true;
         } else if ((txin.type() == typeid(txin_to_script)) && (boost::get<txin_to_script>(txin).command_type == safex::command_t::edit_account)) {
@@ -4745,8 +4772,15 @@ bool Blockchain::handle_block_to_main_chain(const block& bl, const crypto::hash&
     }
     catch (const std::exception& e)
     {
+
+      for(auto tx: txs){
+        cryptonote::transaction tmp;
+        if(m_db->get_tx(tx.hash,tmp))
+          m_db->revert_transaction(tx.hash);
+      }
       //TODO: figure out the best way to deal with this failure
       LOG_ERROR("Error adding block with hash: " << id << " to blockchain, what = " << e.what());
+      bvc.m_verifivation_failed = true;
       return_tx_to_pool(txs);
       return false;
     }
@@ -6037,6 +6071,18 @@ bool Blockchain::get_safex_offer_active_status(const crypto::hash &offerID, bool
     }
 }
 
+bool Blockchain::get_safex_offer_rating(const crypto::hash &offerID, uint64_t &rating) const
+{
+    try {
+        bool result = m_db->get_offer_stars_given(offerID, rating);
+        return result;
+    }
+    catch (std::exception &ex) {
+        MERROR("Error fetching offer active status: "+std::string(ex.what()));
+        return false;
+    }
+}
+
 bool Blockchain::get_safex_accounts( std::vector<std::pair<std::string,std::string>> &safex_accounts) const
 {
     LOG_PRINT_L3("Blockchain::" << __func__);
@@ -6051,6 +6097,14 @@ bool Blockchain::get_safex_offers( std::vector<safex::safex_offer> &safex_offers
     return m_db->get_safex_offers(safex_offers);
 }
 
+bool Blockchain::get_safex_feedbacks(std::vector<safex::safex_feedback>& safex_feedbacks, const crypto::hash& offer_id) const
+{
+  LOG_PRINT_L3("Blockchain::" << __func__);
+
+  return m_db->get_safex_feedbacks(safex_feedbacks, offer_id);
+}
+
+
 std::vector<crypto::public_key> Blockchain::is_safex_purchase_right_address(crypto::secret_key seller_secret_view_key, crypto::public_key public_seller_spend_key, const cryptonote::transaction& tx) {
 
     crypto::public_key pkey;
diff --git a/src/cryptonote_core/blockchain.h b/src/cryptonote_core/blockchain.h
index 20cf30672..afcf5ff5e 100644
--- a/src/cryptonote_core/blockchain.h
+++ b/src/cryptonote_core/blockchain.h
@@ -1041,9 +1041,11 @@ namespace cryptonote
     bool get_safex_offer_price(const crypto::hash &offerID, uint64_t &price) const;
     bool get_safex_offer_quantity(const crypto::hash &offerID, uint64_t &quantity) const;
     bool get_safex_offer_active_status(const crypto::hash &offerID, bool &active) const;
+    bool get_safex_offer_rating(const crypto::hash &offerID, uint64_t &rating) const;
 
     bool get_safex_accounts( std::vector<std::pair<std::string,std::string>> &safex_accounts) const;
     bool get_safex_offers(std::vector<safex::safex_offer> &safex_offers) const;
+    bool get_safex_feedbacks(std::vector<safex::safex_feedback>& safex_feedbacks, const crypto::hash& offer_id) const;
   private:
 
     struct outputs_generic_visitor
diff --git a/src/cryptonote_core/cryptonote_core.cpp b/src/cryptonote_core/cryptonote_core.cpp
index e0ad421ff..315520790 100644
--- a/src/cryptonote_core/cryptonote_core.cpp
+++ b/src/cryptonote_core/cryptonote_core.cpp
@@ -336,6 +336,12 @@ namespace cryptonote
       return m_blockchain_storage.get_safex_offers(safex_offers);
   }
 
+  bool core::get_safex_feedbacks( std::vector<safex::safex_feedback> &safex_feedbacks, const crypto::hash& offer_id) const
+  {
+    return m_blockchain_storage.get_safex_feedbacks(safex_feedbacks,offer_id);
+  }
+
+
     //-----------------------------------------------------------------------------------------------
   void core::get_blockchain_top(uint64_t& height, crypto::hash& top_id) const
   {
diff --git a/src/cryptonote_core/cryptonote_core.h b/src/cryptonote_core/cryptonote_core.h
index fecf72de7..5d0a227bc 100644
--- a/src/cryptonote_core/cryptonote_core.h
+++ b/src/cryptonote_core/cryptonote_core.h
@@ -809,12 +809,19 @@ namespace cryptonote
        bool get_safex_accounts( std::vector<std::pair<std::string,std::string>> &safex_accounts) const;
 
        /**
-       * @brief gets pair of elements <username, safex_account_description>
+       * @brief gets all offers inside the Blockchain
        *
        * @return True if we get the elements from Blockchain
        */
        bool get_safex_offers( std::vector<safex::safex_offer> &safex_offers) const;
 
+       /**
+      * @brief gets feedbacks for given offer_id
+      *
+      * @return True if we get the elements from Blockchain
+      */
+       bool get_safex_feedbacks( std::vector<safex::safex_feedback> &safex_feedbacks, const crypto::hash& offer_id) const;
+
      /**
       * @brief get the network type we're on
       *
diff --git a/src/cryptonote_core/cryptonote_tx_utils.cpp b/src/cryptonote_core/cryptonote_tx_utils.cpp
index bc5f47652..0c181b4ef 100644
--- a/src/cryptonote_core/cryptonote_tx_utils.cpp
+++ b/src/cryptonote_core/cryptonote_tx_utils.cpp
@@ -745,6 +745,25 @@ namespace cryptonote
         safex::safex_command_serializer::serialize_safex_object(cmd, input.script);
 
 
+    }
+    else if (src_entr.command_type == safex::command_t::create_feedback)
+    {
+        input.k_image = img;
+
+        //fill outputs array and use relative offsets
+        for (const tx_source_entry::output_entry &out_entry: src_entr.outputs)
+            input.key_offsets.push_back(out_entry.first);
+
+        input.key_offsets = absolute_output_offsets_to_relative(input.key_offsets);
+
+        safex::create_feedback_data feedback;
+        parse_and_validate_from_blob(src_entr.command_safex_data, feedback);
+
+        safex::create_feedback cmd(SAFEX_COMMAND_PROTOCOL_VERSION, feedback);
+
+        safex::safex_command_serializer::serialize_safex_object(cmd, input.script);
+
+
     }
     else
     {
@@ -972,6 +991,48 @@ namespace cryptonote
             return matched_inputs;
 
         }
+        case tx_out_type::out_safex_feedback_token:
+        {
+            counter = std::count_if(sources.begin(), sources.end(), [](const tx_source_entry &entry)
+            { return entry.command_type == safex::command_t::simple_purchase; });
+            SAFEX_COMMAND_CHECK_AND_ASSERT_THROW_MES(counter == 1, "Must be one purchase command per transaction", safex::command_t::simple_purchase);
+
+            std::for_each(inputs.begin(), inputs.end(), [&](const txin_v &txin)
+            {
+                if (txin.type() == typeid(txin_to_script))
+                {
+                    const txin_to_script &cmd = boost::get<txin_to_script>(txin);
+                    if (cmd.command_type == safex::command_t::simple_purchase)
+                    {
+                        matched_inputs.push_back(&cmd);
+                    };
+                }
+            });
+
+            return matched_inputs;
+
+        }
+        case tx_out_type::out_safex_feedback:
+        {
+            counter = std::count_if(sources.begin(), sources.end(), [](const tx_source_entry &entry)
+            { return entry.command_type == safex::command_t::create_feedback; });
+            SAFEX_COMMAND_CHECK_AND_ASSERT_THROW_MES(counter == 1, "Must be one purchase command per transaction", safex::command_t::create_feedback);
+
+            std::for_each(inputs.begin(), inputs.end(), [&](const txin_v &txin)
+            {
+                if (txin.type() == typeid(txin_to_script))
+                {
+                    const txin_to_script &cmd = boost::get<txin_to_script>(txin);
+                    if (cmd.command_type == safex::command_t::create_feedback)
+                    {
+                        matched_inputs.push_back(&cmd);
+                    };
+                }
+            });
+
+            return matched_inputs;
+
+        }
       default:
         SAFEX_COMMAND_ASSERT_MES_AND_THROW("Unknown safex output type", safex::command_t::invalid_command);
     }
@@ -1309,7 +1370,7 @@ namespace cryptonote
         txs.keys.push_back(out_eph_public_key);
         //find matching script input
         const std::vector<const txin_to_script*> matched_inputs = match_inputs(dst_entr, sources, tx.vin);
-        SAFEX_COMMAND_CHECK_AND_ASSERT_THROW_MES(matched_inputs.size() > 0, "Missing command on inputs to create newtork fee output", safex::command_t::donate_network_fee);
+        SAFEX_COMMAND_CHECK_AND_ASSERT_THROW_MES(matched_inputs.size() > 0, "Missing command on inputs to create network fee output", safex::command_t::donate_network_fee);
 
         //nothing else to do with matched inputs, create txout data field
         safex::safex_command_serializer::serialize_safex_object(safex::donate_fee_data{}, txs.data);
@@ -1391,6 +1452,36 @@ namespace cryptonote
           out.target = txs;
           tx.vout.push_back(out);
       }
+      else if (dst_entr.output_type == tx_out_type::out_safex_feedback_token)
+      {
+          out.token_amount = 0;
+          txout_to_script txs = AUTO_VAL_INIT(txs);
+          txs.output_type = static_cast<uint8_t>(tx_out_type::out_safex_feedback_token);
+          txs.keys.push_back(out_eph_public_key);
+          txs.data = std::vector<uint8_t>(std::begin(dst_entr.output_data), std::end(dst_entr.output_data));
+
+          //find matching script input
+          const std::vector<const txin_to_script*> matched_inputs = match_inputs(dst_entr, sources, tx.vin);
+          SAFEX_COMMAND_CHECK_AND_ASSERT_THROW_MES(matched_inputs.size() > 0, "Missing command on inputs to create feedback token", safex::command_t::simple_purchase);
+
+          out.target = txs;
+          tx.vout.push_back(out);
+      }
+      else if (dst_entr.output_type == tx_out_type::out_safex_feedback)
+      {
+          out.token_amount = 0;
+          txout_to_script txs = AUTO_VAL_INIT(txs);
+          txs.output_type = static_cast<uint8_t>(tx_out_type::out_safex_feedback);
+          txs.keys.push_back(out_eph_public_key);
+          txs.data = std::vector<uint8_t>(std::begin(dst_entr.output_data), std::end(dst_entr.output_data));
+
+          //find matching script input
+          const std::vector<const txin_to_script*> matched_inputs = match_inputs(dst_entr, sources, tx.vin);
+          SAFEX_COMMAND_CHECK_AND_ASSERT_THROW_MES(matched_inputs.size() > 0, "Missing command on inputs to create feedback", safex::command_t::create_feedback);
+
+          out.target = txs;
+          tx.vout.push_back(out);
+      }
       else
       {
         LOG_ERROR("Wrong transaction output type");
@@ -1477,6 +1568,10 @@ namespace cryptonote
             //todo Atana, figure out how to handle this case
             MCINFO("construct_tx", "donation " << get_transaction_hash(tx) << ENDL << obj_to_json_str(tx) << ENDL << ss_ring_s.str());
           }
+          else if (src_entr.referenced_output_type == tx_out_type::out_safex_feedback_token && src_entr.command_type == safex::command_t::create_feedback) {
+              //todo Atana, figure out how to handle this case
+              MCINFO("construct_tx", "feedback " << get_transaction_hash(tx) << ENDL << obj_to_json_str(tx) << ENDL << ss_ring_s.str());
+          }
           else {
             crypto::generate_ring_signature(tx_prefix_hash, k_image, keys_ptrs, in_contexts[i].in_ephemeral.sec, src_entr.real_output, sigs.data());
           }
diff --git a/src/rpc/core_rpc_server.cpp b/src/rpc/core_rpc_server.cpp
index f304a23d4..268c590c2 100644
--- a/src/rpc/core_rpc_server.cpp
+++ b/src/rpc/core_rpc_server.cpp
@@ -190,7 +190,27 @@ namespace cryptonote
         res.status = CORE_RPC_STATUS_OK;
         return true;
     }
-  //------------------------------------------------------------------------------------------------------------------------------
+    //------------------------------------------------------------------------------------------------------------------------------
+    bool core_rpc_server::on_get_safex_ratings(const COMMAND_RPC_GET_SAFEX_RATINGS::request& req, COMMAND_RPC_GET_SAFEX_RATINGS::response& res)
+    {
+      PERF_TIMER(on_get_safex_ratings);
+      bool r;
+      if (use_bootstrap_daemon_if_necessary<COMMAND_RPC_GET_SAFEX_RATINGS>(invoke_http_mode::JON, "/get_safex_ratings", req, res, r))
+        return r;
+
+      std::vector<safex::safex_feedback> feedbacks;
+      bool result  = m_core.get_safex_feedbacks(feedbacks, req.offer_id);
+
+      for(auto feedback: feedbacks) {
+        COMMAND_RPC_GET_SAFEX_RATINGS::entry ent{feedback.stars_given,feedback.comment};
+        res.ratings.push_back(ent);
+      }
+      res.offer_id = feedbacks.at(0).offer_id;
+      res.status = CORE_RPC_STATUS_OK;
+      return true;
+    }
+
+    //------------------------------------------------------------------------------------------------------------------------------
   bool core_rpc_server::on_get_height(const COMMAND_RPC_GET_HEIGHT::request& req, COMMAND_RPC_GET_HEIGHT::response& res)
   {
     PERF_TIMER(on_get_height);
diff --git a/src/rpc/core_rpc_server.h b/src/rpc/core_rpc_server.h
index a0497bb72..aec9d6334 100644
--- a/src/rpc/core_rpc_server.h
+++ b/src/rpc/core_rpc_server.h
@@ -124,6 +124,7 @@ namespace cryptonote
       MAP_URI_AUTO_JON2("/get_safex_account_info", on_get_safex_account_info, COMMAND_RPC_SAFEX_ACCOUNT_INFO)
       MAP_URI_AUTO_JON2("/get_safex_accounts", on_get_safex_accounts, COMMAND_RPC_GET_SAFEX_ACCOUNTS)
       MAP_URI_AUTO_JON2("/get_safex_offers", on_get_safex_offers, COMMAND_RPC_GET_SAFEX_OFFERS)
+      MAP_URI_AUTO_JON2("/get_safex_ratings", on_get_safex_ratings, COMMAND_RPC_GET_SAFEX_RATINGS)
       MAP_URI_AUTO_JON2("/get_limit", on_get_limit, COMMAND_RPC_GET_LIMIT)
       MAP_URI_AUTO_JON2_IF("/set_limit", on_set_limit, COMMAND_RPC_SET_LIMIT, !m_restricted)
       MAP_URI_AUTO_JON2_IF("/out_peers", on_out_peers, COMMAND_RPC_OUT_PEERS, !m_restricted)
@@ -176,7 +177,7 @@ namespace cryptonote
     bool on_get_network_fee(const COMMAND_RPC_NETWORK_FEE::request& req, COMMAND_RPC_NETWORK_FEE::response& res);
     bool on_get_safex_accounts(const COMMAND_RPC_GET_SAFEX_ACCOUNTS::request& req, COMMAND_RPC_GET_SAFEX_ACCOUNTS::response& res);
     bool on_get_safex_offers(const COMMAND_RPC_GET_SAFEX_OFFERS::request& req, COMMAND_RPC_GET_SAFEX_OFFERS::response& res);
-
+    bool on_get_safex_ratings(const COMMAND_RPC_GET_SAFEX_RATINGS::request& req, COMMAND_RPC_GET_SAFEX_RATINGS::response& res);
 
     bool on_get_output_histogram_protobuf(const COMMAND_RPC_GET_OUTPUT_HISTOGRAM_PROTOBUF::request& req, COMMAND_RPC_GET_OUTPUT_HISTOGRAM_PROTOBUF::response& res);
     bool on_send_proto_raw_tx(const COMMAND_RPC_PROTO_SEND_RAW_TX::request& req, COMMAND_RPC_PROTO_SEND_RAW_TX::response& res);
diff --git a/src/rpc/core_rpc_server_commands_defs.h b/src/rpc/core_rpc_server_commands_defs.h
index a9c36631e..fe7788bc0 100644
--- a/src/rpc/core_rpc_server_commands_defs.h
+++ b/src/rpc/core_rpc_server_commands_defs.h
@@ -161,6 +161,46 @@ namespace cryptonote
         typedef epee::misc_utils::struct_init<response_t> response;
     };
 
+    struct COMMAND_RPC_GET_SAFEX_RATINGS
+    {
+        struct request_t
+        {
+            crypto::hash offer_id;
+
+          BEGIN_KV_SERIALIZE_MAP()
+              KV_SERIALIZE_VAL_POD_AS_BLOB(offer_id)
+            END_KV_SERIALIZE_MAP()
+        };
+        typedef epee::misc_utils::struct_init<request_t> request;
+
+        struct entry
+        {
+            uint64_t star_rating;
+            std::string comment;
+
+        BEGIN_KV_SERIALIZE_MAP()
+                KV_SERIALIZE(star_rating)
+                KV_SERIALIZE(comment)
+            END_KV_SERIALIZE_MAP()
+        };
+
+        struct response_t
+        {
+            crypto::hash offer_id;
+            std::vector<entry> ratings;
+            std::string status;
+            bool untrusted;
+
+        BEGIN_KV_SERIALIZE_MAP()
+                KV_SERIALIZE_VAL_POD_AS_BLOB(offer_id)
+                KV_SERIALIZE(ratings)
+                KV_SERIALIZE(status)
+                KV_SERIALIZE(untrusted);
+            END_KV_SERIALIZE_MAP()
+        };
+        typedef epee::misc_utils::struct_init<response_t> response;
+    };
+
   struct COMMAND_RPC_GET_BLOCKS_FAST
   {
 
diff --git a/src/safex/CMakeLists.txt b/src/safex/CMakeLists.txt
index 1d0d6117d..d6a88d375 100644
--- a/src/safex/CMakeLists.txt
+++ b/src/safex/CMakeLists.txt
@@ -36,6 +36,8 @@ set(safex_core_sources
         safex_account.cpp
         safex_offer.cpp
         safex_purchase.cpp
+        safex_feedback_token.cpp
+        safex_feedback.cpp
         )
 
 set(safex_core_headers
@@ -43,7 +45,9 @@ set(safex_core_headers
         fee_distribution.h
         safex_account.h
         safex_offer.h
-        safex_purchase.h)
+        safex_purchase.h
+        safex_feedback_token.h
+        safex_feedback.h)
 
 set(safex_core_private_headers)
 
diff --git a/src/safex/command.cpp b/src/safex/command.cpp
index d94820a98..0dd0bf141 100644
--- a/src/safex/command.cpp
+++ b/src/safex/command.cpp
@@ -349,6 +349,42 @@ namespace safex
         return result;
     };
 
+    create_feedback_result* create_feedback::execute(const cryptonote::BlockchainDB &blokchainDB, const cryptonote::txin_to_script &txin)
+    {
+        execution_status result = validate(blokchainDB, txin);
+        SAFEX_COMMAND_CHECK_AND_ASSERT_THROW_MES(result == execution_status::ok, "Failed to validate create feedback command", this->get_command_type());
+
+        create_feedback_result *cr = new create_feedback_result{this->offer_id,this->comment,this->stars_given};
+        cr->valid = true;
+        cr->status = execution_status::ok;
+
+        return cr;
+    };
+
+    execution_status create_feedback::validate(const cryptonote::BlockchainDB &blokchainDB, const cryptonote::txin_to_script &txin)
+    {
+
+        execution_status result = execution_status::ok;
+//        std::unique_ptr<safex::edit_offer> cmd = safex::safex_command_serializer::parse_safex_command<safex::edit_offer>(txin.script);
+//
+//        for (auto ch: cmd->get_seller()) {
+//            if (!std::isalnum(ch) && ch!='_') {
+//                result = execution_status::error_invalid_account_name;
+//            }
+//        }
+//
+//        std::vector<uint8_t>  dummy{};
+//        if (!blokchainDB.get_account_data(cmd->get_seller(), dummy)) {
+//            result = execution_status::error_account_non_existant;
+//        }
+//
+//        safex::safex_offer sfx_dummy{};
+//        if (!blokchainDB.get_offer(cmd->get_offerid(), sfx_dummy)) {
+//            result = execution_status::error_offer_non_existant;
+//        }
+        return result;
+    };
+
 
   bool validate_safex_command(const cryptonote::BlockchainDB &blokchainDB, const cryptonote::txin_to_script &txin)
   {
diff --git a/src/safex/command.h b/src/safex/command.h
index 8b8135f0e..17ee249d2 100644
--- a/src/safex/command.h
+++ b/src/safex/command.h
@@ -21,6 +21,7 @@
 #include "misc_log_ex.h"
 #include "safex_offer.h"
 #include "safex_purchase.h"
+#include "safex_feedback.h"
 
 #define CHECK_COMMAND_TYPE(TYPE_TO_CHECK,EXPECTED_TYPE) SAFEX_COMMAND_CHECK_AND_ASSERT_THROW_MES((TYPE_TO_CHECK == EXPECTED_TYPE), "Could not create command, wrong command type", TYPE_TO_CHECK);
 
@@ -204,6 +205,27 @@ struct edit_offer_result : public execution_result
         FIELD(output_id)
     END_SERIALIZE()
 
+};
+
+struct create_feedback_result : public execution_result
+{
+
+    create_feedback_result(){}
+
+    create_feedback_result(crypto::hash _offer_id, std::vector<uint8_t> _comment, uint64_t _stars_given): offer_id{_offer_id},comment{_comment},stars_given{_stars_given} {
+
+    }
+
+    crypto::hash offer_id{}; //unique id of the offer
+    uint64_t stars_given;
+    std::vector<uint8_t> comment{};
+
+    BEGIN_SERIALIZE_OBJECT()
+        FIELD(offer_id)
+        FIELD(stars_given)
+        FIELD(comment)
+    END_SERIALIZE()
+
 };
 
   struct command_data
@@ -350,6 +372,40 @@ struct edit_offer_result : public execution_result
         END_SERIALIZE()
     };
 
+    struct create_feedback_token_data : public command_data
+    {
+        crypto::hash offer_id{}; //unique id of the offer
+
+
+        create_feedback_token_data() {}
+        create_feedback_token_data(const safex::safex_purchase& purchase): offer_id{purchase.offer_id}
+        {
+        }
+
+        BEGIN_SERIALIZE_OBJECT()
+            FIELD(offer_id)
+        END_SERIALIZE()
+    };
+
+    struct create_feedback_data : public command_data
+    {
+        crypto::hash offer_id{}; //unique id of the offer
+        uint64_t stars_given;
+        std::vector<uint8_t> comment{};
+
+        create_feedback_data() {}
+        create_feedback_data(const safex::safex_feedback& feedback): offer_id{feedback.offer_id},stars_given{feedback.stars_given},comment{feedback.comment.begin(),feedback.comment.end()}{
+        }
+        create_feedback_data(const crypto::hash &_offer_id, const uint64_t &_stars_given, const std::vector<uint8_t> _comment):
+                offer_id{_offer_id},stars_given{_stars_given},comment{_comment}{}
+
+        BEGIN_SERIALIZE_OBJECT()
+            FIELD(offer_id)
+            FIELD(stars_given)
+            FIELD(comment)
+        END_SERIALIZE()
+    };
+
   /**
   * @brief script command representation
   *
@@ -796,6 +852,42 @@ class edit_offer : public command
     bool active{};
 };
 
+class create_feedback : public command
+{
+public:
+    friend class safex_command_serializer;
+
+    /**
+     * @param _version Safex command protocol version
+     * @param _offerid //ID of the offer
+    * */
+    create_feedback(const uint32_t _version, const safex::create_feedback_data &feedback) :
+            command(_version, command_t::create_feedback), offer_id(feedback.offer_id), comment{feedback.comment}, stars_given{feedback.stars_given}{
+    }
+
+    create_feedback() : command(0, command_t::create_feedback), offer_id{}, stars_given{}, comment{} {}
+
+    crypto::hash get_offerid() const { return offer_id; }
+    std::vector<uint8_t> get_comment() const { return comment; }
+    uint64_t get_stars_given() const { return stars_given; }
+
+    virtual create_feedback_result* execute(const cryptonote::BlockchainDB &blokchain, const cryptonote::txin_to_script &txin) override;
+    virtual execution_status validate(const cryptonote::BlockchainDB &blokchain, const cryptonote::txin_to_script &txin) override;
+
+    BEGIN_SERIALIZE_OBJECT()
+        FIELDS(*static_cast<command *>(this))
+        CHECK_COMMAND_TYPE(this->get_command_type(),  command_t::create_feedback);
+        FIELD(offer_id)
+        FIELD(stars_given)
+        FIELD(comment)
+    END_SERIALIZE()
+
+private:
+    crypto::hash offer_id{}; //unique id of the offer
+    uint64_t stars_given;
+    std::vector<uint8_t> comment{};
+};
+
   bool execute_safex_command(const cryptonote::BlockchainDB &blokchain, const cryptonote::txin_to_script &txin);
   /* Validation is like execution, but without effects on the database */
   bool validate_safex_command(const cryptonote::BlockchainDB &blockchain, const cryptonote::txin_to_script &txin);
@@ -855,6 +947,9 @@ class edit_offer : public command
           case safex::command_t::edit_offer:
              return std::unique_ptr<command>(parse_safex_object<edit_offer>(buffer));
              break;
+          case safex::command_t::create_feedback:
+             return std::unique_ptr<command>(parse_safex_object<create_feedback>(buffer));
+             break;
           default:
             SAFEX_COMMAND_ASSERT_MES_AND_THROW("Unknown safex command type", safex::command_t::invalid_command);
             break;
diff --git a/src/safex/safex_core.h b/src/safex/safex_core.h
index 2bf5d97db..0e11d5df1 100644
--- a/src/safex/safex_core.h
+++ b/src/safex/safex_core.h
@@ -69,6 +69,7 @@ namespace safex
       edit_account = 0x0B, /* Edit Safex account */
       create_offer = 0x10,
       edit_offer = 0x11,
+      create_feedback = 0x12,
       invalid_command
   };
 
diff --git a/src/safex/safex_feedback.cpp b/src/safex/safex_feedback.cpp
new file mode 100644
index 000000000..bb834f00f
--- /dev/null
+++ b/src/safex/safex_feedback.cpp
@@ -0,0 +1,20 @@
+//
+// Created by Igor Grkavac on 24.01.20..
+//
+
+#include <vector>
+#include <iostream>
+#include <stdint.h>
+
+#include "cryptonote_basic/cryptonote_format_utils.h"
+#include "cryptonote_core/cryptonote_core.h"
+#include "safex/command.h"
+#include "safex_feedback.h"
+
+
+
+namespace safex
+{
+
+
+}
diff --git a/src/safex/safex_feedback.h b/src/safex/safex_feedback.h
new file mode 100644
index 000000000..22607bec7
--- /dev/null
+++ b/src/safex/safex_feedback.h
@@ -0,0 +1,104 @@
+//
+// Created by Igor Grkavac on 24.01.20.
+//
+
+#ifndef SAFEX_SAFEX_FEEDBACK_H
+#define SAFEX_SAFEX_FEEDBACK_H
+
+
+#include <string>
+#include <cryptonote_basic/cryptonote_basic.h>
+
+#include "device/device.hpp"
+#include "crypto/crypto.h"
+#include "serialization/keyvalue_serialization.h"
+#include "cryptonote_basic/cryptonote_format_utils.h"
+
+
+#include "safex_core.h"
+
+#undef SAFEX_DEFAULT_LOG_CATEGORY
+#define SAFEX_DEFAULT_LOG_CATEGORY "safex_feedback"
+
+namespace safex
+{
+
+  struct safex_feedback
+  {
+
+    public:
+      safex_feedback(): comment{}, stars_given{}, offer_id{0}{
+      }
+
+      safex_feedback(const uint64_t _stars_given, const std::string _comment, const crypto::hash &_id):stars_given{_stars_given},comment{_comment},
+                                                                                            offer_id{_id}
+      {
+      }
+
+
+    BEGIN_KV_SERIALIZE_MAP()
+        KV_SERIALIZE(offer_id)
+        KV_SERIALIZE(stars_given)
+        KV_SERIALIZE(comment)
+      END_KV_SERIALIZE_MAP()
+
+      BEGIN_SERIALIZE_OBJECT()
+        FIELD(offer_id)
+        FIELD(stars_given)
+        FIELD(comment)
+      END_SERIALIZE()
+
+      template<class t_archive>
+      inline void serialize(t_archive &a, const unsigned int /*ver*/)
+      {
+        a & offer_id;
+        a & stars_given;
+        a & comment;
+      }
+
+      crypto::hash offer_id{}; //unique id of the offer
+      uint64_t stars_given;
+      std::string comment{};
+  private:
+
+
+  };
+
+    struct safex_feedback_db_data
+    {
+
+    public:
+        safex_feedback_db_data(): comment{}, stars_given{}{
+        }
+
+        safex_feedback_db_data(const uint64_t _stars_given, const std::string _comment):stars_given{_stars_given},comment{_comment.begin(),_comment.end()}
+        {
+        }
+
+
+    BEGIN_KV_SERIALIZE_MAP()
+            KV_SERIALIZE(stars_given)
+            KV_SERIALIZE(comment)
+        END_KV_SERIALIZE_MAP()
+
+        BEGIN_SERIALIZE_OBJECT()
+            FIELD(stars_given)
+            FIELD(comment)
+        END_SERIALIZE()
+
+        template<class t_archive>
+        inline void serialize(t_archive &a, const unsigned int /*ver*/)
+        {
+            a & stars_given;
+            a & comment;
+        }
+        uint64_t stars_given;
+        std::vector<uint8_t> comment{};
+    private:
+
+
+    };
+}
+
+
+#endif //SAFEX_SAFEX_FEEDBACK_H
diff --git a/src/safex/safex_feedback_token.cpp b/src/safex/safex_feedback_token.cpp
new file mode 100644
index 000000000..a86ab30c0
--- /dev/null
+++ b/src/safex/safex_feedback_token.cpp
@@ -0,0 +1,20 @@
+//
+// Created by Igor Grkavac on 24.01.20..
+//
+
+#include <vector>
+#include <iostream>
+#include <stdint.h>
+
+#include "cryptonote_basic/cryptonote_format_utils.h"
+#include "cryptonote_core/cryptonote_core.h"
+#include "safex/command.h"
+#include "safex_feedback_token.h"
+
+
+
+namespace safex
+{
+
+
+}
diff --git a/src/safex/safex_feedback_token.h b/src/safex/safex_feedback_token.h
new file mode 100644
index 000000000..138f84142
--- /dev/null
+++ b/src/safex/safex_feedback_token.h
@@ -0,0 +1,74 @@
+//
+// Created by Igor Grkavac on 24.01.20.
+//
+
+#ifndef SAFEX_SAFEX_FEEDBACK_TOKEN_H
+#define SAFEX_SAFEX_FEEDBACK_TOKEN_H
+
+
+#include <string>
+#include <cryptonote_basic/cryptonote_basic.h>
+
+#include "device/device.hpp"
+#include "crypto/crypto.h"
+#include "serialization/keyvalue_serialization.h"
+#include "cryptonote_basic/cryptonote_format_utils.h"
+
+
+#include "safex_core.h"
+
+#undef SAFEX_DEFAULT_LOG_CATEGORY
+#define SAFEX_DEFAULT_LOG_CATEGORY "safex_feedback_token"
+
+namespace safex
+{
+
+  struct safex_feedback_token
+  {
+
+    public:
+      safex_feedback_token(): quantity{}, price{}, shipping{}, offer_id{0}{
+
+      }
+
+      safex_feedback_token(const uint64_t _quantity, const uint64_t _price, crypto::hash &_id, bool _shipping):quantity{_quantity},price{_price},
+                                                                                            offer_id{_id},shipping{_shipping}
+      {
+      }
+
+
+    BEGIN_KV_SERIALIZE_MAP()
+        KV_SERIALIZE(offer_id)
+        KV_SERIALIZE(quantity)
+        KV_SERIALIZE(price)
+        KV_SERIALIZE(shipping)
+      END_KV_SERIALIZE_MAP()
+
+      BEGIN_SERIALIZE_OBJECT()
+        FIELD(offer_id)
+        FIELD(quantity)
+        FIELD(price)
+        FIELD(shipping)
+      END_SERIALIZE()
+
+      template<class t_archive>
+      inline void serialize(t_archive &a, const unsigned int /*ver*/)
+      {
+        a & offer_id;
+        a & quantity;
+        a & price;
+        a & shipping;
+      }
+
+      crypto::hash offer_id;
+      uint64_t quantity;
+      uint64_t price;
+      bool shipping;
+  private:
+
+
+  };
+}
+
+
+#endif //SAFEX_SAFEX_FEEDBACK_TOKEN_H
diff --git a/src/simplewallet/simplewallet.cpp b/src/simplewallet/simplewallet.cpp
index e668bf5a6..5c4e5d525 100644
--- a/src/simplewallet/simplewallet.cpp
+++ b/src/simplewallet/simplewallet.cpp
@@ -1223,6 +1223,13 @@ simple_wallet::simple_wallet()
                            tr("safex_purchase [index=<N1>[,<N2>,...]] [<priority>] [<ring_size>] <offer_id> <quantity>\"),"),
                            tr("Safex purchase. 95% of cash sent is given to the seller, 5% is taken as fee"));
 
+  m_cmd_binder.set_handler("safex_feedback",
+                           boost::bind(&simple_wallet::safex_feedback, this, _1),
+                           tr("safex_feedback \n"
+                              "safex_feedback [index=<N1>[,<N2>,...]] [<priority>] [<ring_size>] <offer_id> <star_rating> <comment>\n"),
+                           tr("If no arguments are given, show all offers that you can give feedback\n"
+                              "If arguments are given, give feedback for purchased offer with <offer_id> with <star_rating> and <comment>"));
+
   m_cmd_binder.set_handler("donate_safex_fee",
                            boost::bind(&simple_wallet::donate_safex_fee, this, _1),
                            tr("donate_safex_fee [index=<N1>[,<N2>,...]] [<priority>] [<ring_size>] <cash_amount> [<payment_id>]"),
@@ -1233,6 +1240,11 @@ simple_wallet::simple_wallet()
                            tr("list_offers"),
                            tr("List current offers in the Blockchain."));
 
+    m_cmd_binder.set_handler("list_ratings",
+                             boost::bind(&simple_wallet::list_ratings, this, _1),
+                             tr("list_ratings <offer_id>"),
+                             tr("List ratings in the Blockchain for given offer."));
+
   m_cmd_binder.set_handler("get_my_interest",
                            boost::bind(&simple_wallet::get_my_interest, this, _1),
                            tr("get_my_interest"),
diff --git a/src/simplewallet/simplewallet.h b/src/simplewallet/simplewallet.h
index 7e3cb6e77..5d8ed8fc5 100644
--- a/src/simplewallet/simplewallet.h
+++ b/src/simplewallet/simplewallet.h
@@ -75,7 +75,7 @@ namespace cryptonote
     TransferEditAccount,
     TransferCreateOffer,
     TransferEditOffer,
-    TransferCloseOffer
+    TransferFeedback
   };
 
   /*!
@@ -253,10 +253,11 @@ namespace cryptonote
     bool get_my_interest(const std::vector<std::string>& args);
     void print_safex_accounts();
     void print_my_safex_offers();
+    void print_not_given_feedbacks();
 
     bool list_offers(const std::vector<std::string>& args);
-
-    // Function responsible for 
+    bool list_ratings(const std::vector<std::string>& args);
+    // Function responsible for
     bool create_command(CommandType command_type, const std::vector<std::string> &args);
 
     bool stake_token(const std::vector<std::string> &args);
@@ -268,6 +269,8 @@ namespace cryptonote
     bool safex_offer(const std::vector<std::string> &args);
 
     bool safex_purchase(const std::vector<std::string>& args);
+
+    bool safex_feedback(const std::vector<std::string>& args);
     /****************************************************************************************************************/
 
     /*!
diff --git a/src/simplewallet/simplewallet_safex.cpp b/src/simplewallet/simplewallet_safex.cpp
index 30ceb20cc..5ed454880 100644
--- a/src/simplewallet/simplewallet_safex.cpp
+++ b/src/simplewallet/simplewallet_safex.cpp
@@ -69,6 +69,26 @@ namespace cryptonote
         return tx_destination_entry{0, to, false, tx_out_type::out_safex_offer_update, blobdata};
     }
 
+    tx_destination_entry create_safex_purchase_destination(const cryptonote::account_public_address  &to, const safex::safex_purchase &sfx_purchase)
+    {
+        safex::create_purchase_data safex_purchase_output_data{sfx_purchase};
+        blobdata blobdata = cryptonote::t_serializable_object_to_blob(safex_purchase_output_data);
+        return tx_destination_entry{0, to, false, tx_out_type::out_safex_purchase, blobdata};
+    }
+
+    tx_destination_entry create_safex_feedback_token_destination(const cryptonote::account_public_address  &to, const safex::create_feedback_token_data &safex_feedback_token_output_data)
+    {
+        blobdata blobdata = cryptonote::t_serializable_object_to_blob(safex_feedback_token_output_data);
+        return tx_destination_entry{0, to, false, tx_out_type::out_safex_feedback_token,blobdata};
+    }
+
+    tx_destination_entry create_safex_feedback_destination(const cryptonote::account_public_address  &to, const safex::safex_feedback &sfx_feedback)
+    {
+        safex::create_feedback_data safex_feedback_output_data{sfx_feedback};
+        blobdata blobdata = cryptonote::t_serializable_object_to_blob(safex_feedback_output_data);
+        return tx_destination_entry{0, to, false, tx_out_type::out_safex_feedback,blobdata};
+    }
+
 
   bool simple_wallet::create_command(CommandType command_type, const std::vector<std::string> &args_)
   {
@@ -87,6 +107,7 @@ namespace cryptonote
       case CommandType::TransferEditAccount:
       case CommandType::TransferCreateOffer:
       case CommandType::TransferEditOffer:
+      case CommandType::TransferFeedback:
         //do nothing
         break;
       default:
@@ -156,6 +177,9 @@ namespace cryptonote
         min_args = 1;
       break;
 
+      case CommandType::TransferFeedback:
+        min_args = 3;
+
       default:
         //min_args is 2
         break;
@@ -171,7 +195,8 @@ namespace cryptonote
     std::vector<uint8_t> extra;
     bool payment_id_seen = false;
     bool command_supports_payment_id = (command_type != CommandType::TransferCreateAccount) && (command_type != CommandType::TransferEditAccount) &&
-                                        (command_type != CommandType::TransferCreateOffer) && (command_type != CommandType::TransferEditOffer);
+                                        (command_type != CommandType::TransferCreateOffer) && (command_type != CommandType::TransferEditOffer) &&
+                                        (command_type != CommandType::TransferFeedback);
     bool expect_even = (min_args % 2 == 1);
     if (command_supports_payment_id && ((expect_even ? 0 : 1) == local_args.size() % 2))
     {
@@ -364,16 +389,60 @@ namespace cryptonote
             fail_msg_writer() << tr("failed to parse address");
             return true;
         }
-
+        //Purchase
         safex::create_purchase_data safex_purchase_output_data{purchase_offer_id,quantity_to_purchase,offer_to_purchase->price};
         blobdata blobdata = cryptonote::t_serializable_object_to_blob(safex_purchase_output_data);
-        de_purchase = tx_destination_entry{0, info.address, false, tx_out_type::out_safex_purchase, blobdata};
+        de_purchase = tx_destination_entry{0, offer_to_purchase->seller_address, false, tx_out_type::out_safex_purchase, blobdata};
         dsts.push_back(de_purchase);
 
+        //Feedback token
+        safex::create_feedback_token_data safex_feedback_token_output_data;
+        safex_feedback_token_output_data.offer_id = purchase_offer_id;
+        cryptonote::tx_destination_entry de_feedback_token = AUTO_VAL_INIT(de_feedback_token);
+        de_feedback_token = create_safex_feedback_token_destination(info.address, safex_feedback_token_output_data);
+        dsts.push_back(de_feedback_token);
+
         de.addr = offer_to_purchase->seller_address;
 
         dsts.push_back(de);
     }
+    else if (command_type == CommandType::TransferFeedback)
+    {
+        crypto::hash purchase_offer_id{};
+        uint64_t stars_given;
+        std::string comment;
+
+        cryptonote::address_parse_info info = AUTO_VAL_INIT(info);
+        std::string destination_addr = m_wallet->get_subaddress_as_str({m_current_subaddress_account, 0});
+        if (!cryptonote::get_account_address_from_str(info, m_wallet->nettype(), destination_addr))
+        {
+            fail_msg_writer() << tr("failed to parse address");
+            return true;
+        }
+
+        if(!epee::string_tools::hex_to_pod(local_args.front(), purchase_offer_id)){
+            fail_msg_writer() << tr("Bad offer ID given!!!");
+            return true;
+        }
+        local_args.erase(local_args.begin());
+
+        if (!epee::string_tools::get_xtype_from_string(stars_given, local_args.front())){
+            fail_msg_writer() << tr("Bad stars rating format given!!!");
+            return true;
+        }
+
+        std::ostringstream comment_ostr;
+        std::copy(local_args.begin() + 1, local_args.end(), ostream_iterator<string>(comment_ostr, " "));
+        comment = comment_ostr.str();
+
+        safex::safex_feedback sfx_feedback{stars_given,comment,purchase_offer_id};
+
+
+        cryptonote::tx_destination_entry de = AUTO_VAL_INIT(de);
+
+        tx_destination_entry de_feedback = create_safex_feedback_destination(info.address, sfx_feedback);
+        dsts.push_back(de_feedback);
+    }
     else
     {
 
@@ -523,6 +592,10 @@ namespace cryptonote
           command = safex::command_t::edit_offer;
           break;
 
+        case CommandType::TransferFeedback:
+          command = safex::command_t::create_feedback;
+          break;
+
         default:
           LOG_ERROR("Unknown command method, using original");
           return true;
@@ -788,6 +861,17 @@ namespace cryptonote
     return create_command(CommandType::TransferPurchase, args);
   }
 
+    bool simple_wallet::safex_feedback(const std::vector<std::string>& args) {
+      if (args.empty())
+      {
+        // print all the possible feedbacks to give
+        LOCK_IDLE_SCOPE();
+        print_not_given_feedbacks();
+        return true;
+      }
+        return create_command(CommandType::TransferFeedback, args);
+    }
+
   bool simple_wallet::list_offers(const std::vector<std::string>& args) {
 
     success_msg_writer() << boost::format("%30s %10s %10s %30s %60s %20s") % tr("Offer title") %  tr("Price") % tr("Quantity") % tr("Seller") % tr("Description") %tr("Offer ID");
@@ -798,6 +882,30 @@ namespace cryptonote
     return true;
   }
 
+    void simple_wallet::print_not_given_feedbacks(){
+      success_msg_writer() << tr("Safex feedbacks left to give for offers:");
+      success_msg_writer() << boost::format("%30s")  %tr("Offer ID");
+      for (auto &offer_id: m_wallet->get_my_safex_feedbacks_to_give()) {
+        success_msg_writer() << boost::format("%30s ") % offer_id;
+      }
+  }
+
+    bool simple_wallet::list_ratings(const std::vector<std::string>& args) {
+
+        crypto::hash offer_id;
+        if(args.empty() || !epee::string_tools::hex_to_pod(args.front(), offer_id)) {
+            fail_msg_writer() << tr("Bad offer ID given!!!");
+            return true;
+        }
+
+        success_msg_writer() << boost::format("%30s %10s") % tr("Offer ID") %tr(args.front().c_str());
+        success_msg_writer() << boost::format("%6s %60s") % tr("Rating") %tr("Comment");
+        for (auto &rating: m_wallet->get_safex_ratings(offer_id)) {
+            success_msg_writer() << boost::format("%6s %60s") % rating.stars_given % rating.comment;
+        }
+        return true;
+    }
+
   bool simple_wallet::get_my_interest(const std::vector<std::string>& args)
   {
     std::vector<std::pair<uint64_t, uint64_t>> interest_per_output;
@@ -1032,6 +1140,47 @@ namespace cryptonote
 
         m_wallet->update_safex_offer(sfx_offer);
 
+    } else if (txout.output_type == static_cast<uint8_t>(tx_out_type::out_safex_purchase)){
+        safex::create_purchase_data purchase_data;
+        const cryptonote::blobdata offblob(std::begin(txout.data), std::end(txout.data));
+        cryptonote::parse_and_validate_from_blob(offblob, purchase_data);
+
+        safex::safex_offer my_offer = m_wallet->get_my_safex_offer(purchase_data.offer_id);
+
+        message_writer(console_color_blue, false) << "\r" <<
+                                                  tr("Height ") << height << ", " <<
+                                                  tr("txid ") << txid << ", " <<
+                                                  tr("Updated for account, username: ") << my_offer.seller <<
+                                                  tr("Purchased offer: ") << my_offer.title << " received, " <<
+                                                  tr("Quantity purchased: ") << purchase_data.quantity <<
+                                                  tr("idx ") << subaddr_index;
+        m_wallet->update_safex_offer(purchase_data);
+
+    } else if (txout.output_type == static_cast<uint8_t>(tx_out_type::out_safex_feedback_token)){
+        safex::create_feedback_token_data feedback_token;
+        const cryptonote::blobdata offblob(std::begin(txout.data), std::end(txout.data));
+        cryptonote::parse_and_validate_from_blob(offblob, feedback_token);
+        message_writer(console_color_blue, false) << "\r" <<
+                                          tr("Height ") << height << ", " <<
+                                          tr("txid ") << txid << ", " <<
+                                          tr("Feedback token received for offer: ") << feedback_token.offer_id << " received, " <<
+                                          tr("idx ") << subaddr_index;
+        m_wallet->add_safex_feedback_token(feedback_token);
+
+    } else if (txout.output_type == static_cast<uint8_t>(tx_out_type::out_safex_feedback)){
+        safex::create_feedback_data feedback;
+        const cryptonote::blobdata offblob(std::begin(txout.data), std::end(txout.data));
+        cryptonote::parse_and_validate_from_blob(offblob, feedback);
+        std::string comment{feedback.comment.begin(),feedback.comment.end()};
+        message_writer(console_color_blue, false) << "\r" <<
+                                                  tr("Height ") << height << ", " <<
+                                                  tr("txid ") << txid << ", " <<
+                                                  tr("Feedback sent received for offer: ") << feedback.offer_id << " received, " <<
+                                                  tr("Stars given: ") << feedback.stars_given <<
+                                                  tr("Comment given: ") << comment <<
+                                                  tr("idx ") << subaddr_index;
+        m_wallet->remove_safex_feedback_token(feedback.offer_id);
+
     }
 
 
diff --git a/src/wallet/wallet.cpp b/src/wallet/wallet.cpp
index 7140412e7..32020910a 100644
--- a/src/wallet/wallet.cpp
+++ b/src/wallet/wallet.cpp
@@ -1058,9 +1058,12 @@ void wallet::process_new_transaction(const crypto::hash &txid, const cryptonote:
           if (tx_scan_info[i].received)
           {
             if ((tx_scan_info[i].output_type == tx_out_type::out_safex_account)
-                    || (tx_scan_info[i].output_type == tx_out_type::out_safex_account_update
+                    || (tx_scan_info[i].output_type == tx_out_type::out_safex_account_update)
                     || (tx_scan_info[i].output_type == tx_out_type::out_safex_offer)
-                    || (tx_scan_info[i].output_type == tx_out_type::out_safex_offer_update))){
+                    || (tx_scan_info[i].output_type == tx_out_type::out_safex_offer_update)
+                    || (tx_scan_info[i].output_type == tx_out_type::out_safex_feedback_token)
+                    || (tx_scan_info[i].output_type == tx_out_type::out_safex_purchase)
+                    || (tx_scan_info[i].output_type == tx_out_type::out_safex_feedback)){
               outs.push_back(i);
               num_vouts_received++;
               continue;
@@ -1092,7 +1095,10 @@ void wallet::process_new_transaction(const crypto::hash &txid, const cryptonote:
           if ((tx_scan_info[i].output_type == tx_out_type::out_safex_account)
               || (tx_scan_info[i].output_type == tx_out_type::out_safex_account_update)
               || (tx_scan_info[i].output_type == tx_out_type::out_safex_offer)
-              || (tx_scan_info[i].output_type == tx_out_type::out_safex_offer_update)) {
+                 || (tx_scan_info[i].output_type == tx_out_type::out_safex_offer_update)
+                 || (tx_scan_info[i].output_type == tx_out_type::out_safex_feedback_token)
+                 || (tx_scan_info[i].output_type == tx_out_type::out_safex_purchase)
+                 || (tx_scan_info[i].output_type == tx_out_type::out_safex_feedback)){
             outs.push_back(i);
             num_vouts_received++;
             continue;
@@ -1117,7 +1123,10 @@ void wallet::process_new_transaction(const crypto::hash &txid, const cryptonote:
           if ((tx_scan_info[i].output_type == tx_out_type::out_safex_account)
               || (tx_scan_info[i].output_type == tx_out_type::out_safex_account_update)
               || (tx_scan_info[i].output_type == tx_out_type::out_safex_offer)
-              || (tx_scan_info[i].output_type == tx_out_type::out_safex_offer_update)) {
+                 || (tx_scan_info[i].output_type == tx_out_type::out_safex_offer_update)
+                 || (tx_scan_info[i].output_type == tx_out_type::out_safex_feedback_token)
+                 || (tx_scan_info[i].output_type == tx_out_type::out_safex_purchase)
+                 || (tx_scan_info[i].output_type == tx_out_type::out_safex_feedback)){
               outs.push_back(i);
               num_vouts_received++;
               continue;
@@ -1155,8 +1164,10 @@ void wallet::process_new_transaction(const crypto::hash &txid, const cryptonote:
             || (kit != m_pub_keys.end() && (cryptonote::get_tx_out_type(tx.vout[o].target) == tx_out_type::out_safex_account_update
                                                        || cryptonote::get_tx_out_type(tx.vout[o].target) == tx_out_type::out_safex_account
                                                        || cryptonote::get_tx_out_type(tx.vout[o].target) == tx_out_type::out_safex_offer
-                                                       || cryptonote::get_tx_out_type(tx.vout[o].target) == tx_out_type::out_safex_offer_update))
-           )
+                                                       || cryptonote::get_tx_out_type(tx.vout[o].target) == tx_out_type::out_safex_offer_update
+                                                       || cryptonote::get_tx_out_type(tx.vout[o].target) == tx_out_type::out_safex_purchase
+                                                       || cryptonote::get_tx_out_type(tx.vout[o].target) == tx_out_type::out_safex_feedback_token
+                                                       || cryptonote::get_tx_out_type(tx.vout[o].target) == tx_out_type::out_safex_feedback)))
         {
           uint64_t amount = tx.vout[o].amount ? tx.vout[o].amount : tx_scan_info[o].amount;
           uint64_t token_amount = tx.vout[o].token_amount ? tx.vout[o].token_amount : tx_scan_info[o].token_amount;
@@ -1199,7 +1210,10 @@ void wallet::process_new_transaction(const crypto::hash &txid, const cryptonote:
               else if ((output_type == tx_out_type::out_safex_account) ||
                       (output_type == tx_out_type::out_safex_account_update) ||
                       (output_type == tx_out_type::out_safex_offer) ||
-                      (output_type == tx_out_type::out_safex_offer_update)) {
+                      (output_type == tx_out_type::out_safex_offer_update)||
+                      (output_type == tx_out_type::out_safex_purchase)||
+                      (output_type == tx_out_type::out_safex_feedback_token)||
+                      (output_type == tx_out_type::out_safex_feedback)) {
                 const txout_to_script &txout = boost::get<txout_to_script>(tx.vout[o].target);
                 m_callback->on_advanced_output_received(height, txid, tx, txout, td.m_subaddr_index);
               }
@@ -1314,7 +1328,11 @@ void wallet::process_new_transaction(const crypto::hash &txid, const cryptonote:
                 m_callback->on_tokens_received(height, txid, tx, td.m_token_amount, td.m_subaddr_index);
               else if ((td.m_output_type == tx_out_type::out_safex_account) ||
                        (td.m_output_type == tx_out_type::out_safex_account_update) ||
-                      (td.m_output_type == tx_out_type::out_safex_offer)) {
+                      (td.m_output_type == tx_out_type::out_safex_offer) ||
+                      (td.m_output_type == tx_out_type::out_safex_offer_update) ||
+                      (td.m_output_type == tx_out_type::out_safex_purchase) ||
+                      (td.m_output_type == tx_out_type::out_safex_feedback_token) ||
+                      (td.m_output_type == tx_out_type::out_safex_feedback)) {
                 const txout_to_script &txout = boost::get<txout_to_script>(tx.vout[o].target);
                 m_callback->on_advanced_output_received(height, txid, tx, txout, td.m_subaddr_index);
               }
@@ -4400,6 +4418,38 @@ size_t wallet::pop_best_value_from(const transfer_container &transfers, std::vec
 
     return candidates[idx];
   }
+
+    size_t wallet::pop_advanced_output_from(const transfer_container &transfers, const std::vector<size_t>& selected_transfers, const crypto::hash& offer_id,  const cryptonote::tx_out_type out_type) const
+    {
+        std::vector<size_t> candidates;
+        for (size_t n = 0; n < transfers.size(); ++n)
+        {
+            const transfer_details &candidate = transfers[n];
+            if (candidate.get_out_type() != out_type) continue;
+            candidates.push_back(n);
+        }
+
+
+        THROW_WALLET_EXCEPTION_IF(candidates.empty(), error::safex_unknown_account);
+
+        int idx = -1;
+        for (size_t n = 0; n < candidates.size(); ++n)
+        {
+            const transfer_details &td = transfers[candidates[n]];
+            if (out_type == tx_out_type::out_safex_feedback_token && td.get_out_type() == tx_out_type::out_safex_feedback_token)
+            {
+                const txout_to_script &current = boost::get<const cryptonote::txout_to_script&>(td.m_tx.vout[td.m_internal_output_index].target);
+                const cryptonote::blobdata blobdata1(begin(current.data), end(current.data));
+                safex::create_feedback_token_data feedback_token_output_data;
+                parse_and_validate_object_from_blob(blobdata1, feedback_token_output_data);
+                if (offer_id == feedback_token_output_data.offer_id) idx = (int)n;
+            }
+        }
+
+        THROW_WALLET_EXCEPTION_IF(idx == -1, error::safex_unknown_account);
+
+        return candidates[idx];
+    }
 //----------------------------------------------------------------------------------------------------
 size_t wallet::pop_best_value(std::vector<size_t> &unused_indices, const std::vector<size_t>& selected_transfers, bool smallest, const cryptonote::tx_out_type out_type) const
 {
@@ -4416,6 +4466,12 @@ size_t wallet::pop_ideal_value(std::vector<size_t> &unused_indices, const std::v
     const std::string acc_username_str(acc_username.begin(), acc_username.end());
     return pop_advanced_output_from(m_transfers, selected_transfers,  acc_username_str, out_type);
   }
+
+  size_t wallet::pop_advanced_output(const std::vector<size_t>& selected_transfers, const  safex::create_feedback_data &sfx_feedback, const cryptonote::tx_out_type out_type) const
+  {
+      const crypto::hash offer_id = sfx_feedback.offer_id;
+      return pop_advanced_output_from(m_transfers, selected_transfers,  offer_id, out_type);
+  }
 //----------------------------------------------------------------------------------------------------
 // Select random input sources for transaction.
 // returns:
@@ -5809,7 +5865,8 @@ void wallet::get_outs(std::vector<std::vector<tools::wallet::get_outs_entry>> &o
     for(size_t idx: selected_transfers)
     {
       if (m_transfers[idx].m_output_type == cryptonote::tx_out_type::out_safex_account ||
-            m_transfers[idx].m_output_type == cryptonote::tx_out_type::out_safex_offer) //no fake outputs count for accounts and offers
+            m_transfers[idx].m_output_type == cryptonote::tx_out_type::out_safex_offer ||
+            m_transfers[idx].m_output_type == cryptonote::tx_out_type::out_safex_feedback_token) //no fake outputs count for accounts and offers
         continue;
 
       cash_token_selected_transfers.push_back(idx);
@@ -6567,6 +6624,8 @@ void wallet::transfer_advanced(safex::command_t command_type, const std::vector<
         get_outs(outs, selected_transfers, 0, tx_out_type::out_safex_account); // may throw
     else if (command_type == safex::command_t::edit_offer)
         get_outs(outs, selected_transfers, 0, tx_out_type::out_safex_offer); // may throw
+    else if (command_type == safex::command_t::create_feedback)
+        get_outs(outs, selected_transfers, 0, tx_out_type::out_safex_feedback_token); // may throw
   }
 
 
@@ -6580,7 +6639,7 @@ void wallet::transfer_advanced(safex::command_t command_type, const std::vector<
     for (auto out: cash_fee_outs)
       outs.push_back(out);
   }
-  else if (command_type == safex::command_t::donate_network_fee || command_type == safex::command_t::simple_purchase)
+  else if (command_type == safex::command_t::donate_network_fee || command_type == safex::command_t::simple_purchase || command_type == safex::command_t::create_feedback)
   {
     //do nothing
   }
@@ -6617,7 +6676,8 @@ void wallet::transfer_advanced(safex::command_t command_type, const std::vector<
       src.referenced_output_type = (src.token_amount > 0) ? tx_out_type::out_token : tx_out_type::out_cash;
 
     //paste keys (fake and real)
-    const size_t fake_outputs_count_revised = (src.referenced_output_type == tx_out_type::out_safex_account || src.referenced_output_type == tx_out_type::out_safex_offer) ? 0 : fake_outputs_count;
+    const size_t fake_outputs_count_revised = (src.referenced_output_type == tx_out_type::out_safex_account || src.referenced_output_type == tx_out_type::out_safex_offer
+                                                || src.referenced_output_type == tx_out_type::out_safex_feedback_token) ? 0 : fake_outputs_count;
     for (size_t n = 0; n < fake_outputs_count_revised + 1; ++n)
     {
       tx_output_entry oe = AUTO_VAL_INIT(oe);
@@ -6713,6 +6773,12 @@ void wallet::transfer_advanced(safex::command_t command_type, const std::vector<
         bool res = get_safex_account_keys(sfx_acc.username, my_safex_keys);
         THROW_WALLET_EXCEPTION_IF(!res, error::wallet_internal_error, "safex account keys missing");
     }
+    else if (command_type == safex::command_t::create_feedback && m_transfers[idx].m_output_type == tx_out_type::out_safex_feedback_token)
+    {
+        const cryptonote::tx_destination_entry &dt_account = find_matching_advanced_output(tx_out_type::out_safex_feedback);
+        src.command_safex_data = dt_account.output_data;
+        src.command_type = safex::command_t::create_feedback;
+    }
 
     detail::print_source_entry(src);
     ++out_index;
@@ -8635,7 +8701,7 @@ std::vector<wallet::pending_tx> wallet::create_transactions_advanced(safex::comm
 
       }
       else if (command_type == safex::command_t::simple_purchase) {
-          if (dt.script_output == false || dt.output_type == tx_out_type::out_network_fee) {
+          if (dt.script_output == false || dt.output_type == tx_out_type::out_network_fee || dt.output_type == tx_out_type::out_safex_feedback_token) {
               needed_cash += dt.amount;
           } else {
               THROW_WALLET_EXCEPTION_IF(dt.output_type != tx_out_type::out_safex_purchase, error::safex_invalid_output_error);
@@ -8897,7 +8963,8 @@ std::vector<wallet::pending_tx> wallet::create_transactions_advanced(safex::comm
                               || dsts[0].output_type == tx_out_type::out_safex_account_update
                               || dsts[0].output_type == tx_out_type::out_safex_offer
                               || dsts[0].output_type == tx_out_type::out_safex_offer_update
-                              || dsts[0].output_type == tx_out_type::out_safex_purchase)) || adding_fee)
+                              || dsts[0].output_type == tx_out_type::out_safex_purchase
+                              || dsts[0].output_type == tx_out_type::out_safex_feedback)) || adding_fee)
     {
       ADVANCED_TX &tx = txes.back();
 
@@ -8910,7 +8977,7 @@ std::vector<wallet::pending_tx> wallet::create_transactions_advanced(safex::comm
       LOG_PRINT_L2("adding_fee " << adding_fee);
 
       const bool advanced_output_reference = (dsts[0].output_type == tx_out_type::out_safex_account_update || dsts[0].output_type == tx_out_type::out_safex_offer
-                                                    || dsts[0].output_type == tx_out_type::out_safex_offer_update);
+                                                    || dsts[0].output_type == tx_out_type::out_safex_offer_update || dsts[0].output_type == tx_out_type::out_safex_feedback);
 
 
       // if we need to spend cash and don't have any left, we fail
@@ -9041,6 +9108,12 @@ std::vector<wallet::pending_tx> wallet::create_transactions_advanced(safex::comm
             //find offer output
             idx = pop_advanced_output(tx.selected_transfers, offer.seller, tx_out_type::out_safex_offer);
         }
+        else if (dsts[0].output_type == tx_out_type::out_safex_feedback) {
+            safex::create_feedback_data feedback;
+            cryptonote::parse_and_validate_from_blob(dsts[0].output_data, feedback);
+            //find feedback_token output
+            idx = pop_advanced_output(tx.selected_transfers, feedback, tx_out_type::out_safex_feedback_token);
+        }
       }
       else if (adding_fee)
       {
@@ -9080,7 +9153,12 @@ std::vector<wallet::pending_tx> wallet::create_transactions_advanced(safex::comm
             //find offer output
             idx = pop_advanced_output(tx.selected_transfers, offer.seller, tx_out_type::out_safex_offer);
         }
-
+        else if (dsts[0].output_type == tx_out_type::out_safex_feedback) {
+            safex::create_feedback_data feedback;
+            cryptonote::parse_and_validate_from_blob(dsts[0].output_data, feedback);
+            //find feedback_token output
+            idx = pop_advanced_output(tx.selected_transfers, feedback, tx_out_type::out_safex_feedback_token);
+        }
       }
 
 
diff --git a/src/wallet/wallet.h b/src/wallet/wallet.h
index 455bb8442..0c3846217 100644
--- a/src/wallet/wallet.h
+++ b/src/wallet/wallet.h
@@ -40,6 +40,7 @@
 #include <boost/serialization/vector.hpp>
 #include <boost/serialization/deque.hpp>
 #include <atomic>
+#include <safex/command.h>
 
 #include "include_base_utils.h"
 #include "cryptonote_basic/account.h"
@@ -779,6 +780,8 @@ namespace tools
 
       a & m_safex_offers;
 
+      a & m_safex_feedback_tokens;
+
     }
 
       static std::string get_default_ringdb_path()
@@ -937,6 +940,8 @@ namespace tools
     size_t pop_best_value(std::vector<size_t> &unused_dust_indices, const std::vector<size_t>& selected_transfers, bool smallest = false, const cryptonote::tx_out_type out_type = cryptonote::tx_out_type::out_cash) const;
     size_t pop_ideal_value(std::vector<size_t> &unused_indices, const std::vector<size_t>& selected_transfers, const cryptonote::tx_out_type out_type, const uint64_t cash_amount, const uint64_t token_amount) const;
     size_t pop_advanced_output(const std::vector<size_t>& selected_transfers, const std::vector<uint8_t> &acc_username, const cryptonote::tx_out_type out_type) const;
+    size_t pop_advanced_output(const std::vector<size_t>& selected_transfers, const  safex::create_feedback_data &sfx_feedback, const cryptonote::tx_out_type out_type) const;
+    size_t pop_advanced_output_from(const transfer_container &transfers, const std::vector<size_t>& selected_transfers, const crypto::hash& offer_id,  const cryptonote::tx_out_type out_type) const;
 
     void set_tx_note(const crypto::hash &txid, const std::string &note);
     std::string get_tx_note(const crypto::hash &txid) const;
@@ -1083,9 +1088,15 @@ namespace tools
 
     bool add_safex_offer(const safex::safex_offer& offer);
     bool update_safex_offer(const safex::safex_offer& offer);
+    bool update_safex_offer(const safex::create_purchase_data& purchase);
+    bool add_safex_feedback_token(const safex::create_feedback_token_data& feedback_token);
+    bool remove_safex_feedback_token(const crypto::hash& offer_id);
 
     std::vector<safex::safex_offer> get_safex_offers();
+    std::vector<safex::safex_feedback> get_safex_ratings(const crypto::hash& offer_id);
     std::vector<safex::safex_offer> get_my_safex_offers();
+    std::vector<crypto::hash> get_my_safex_feedbacks_to_give();
+    safex::safex_offer get_my_safex_offer(crypto::hash& offer_id);
 
   private:
     /*!
@@ -1262,6 +1273,8 @@ namespace tools
     std::vector<safex::safex_account_keys> m_safex_accounts_keys;
 
     std::vector<safex::safex_offer> m_safex_offers;
+
+    std::vector<crypto::hash> m_safex_feedback_tokens;
   };
 }
 BOOST_CLASS_VERSION(tools::wallet, 1)
diff --git a/src/wallet/wallet_safex.cpp b/src/wallet/wallet_safex.cpp
index 8a70a7add..eb76b0d85 100644
--- a/src/wallet/wallet_safex.cpp
+++ b/src/wallet/wallet_safex.cpp
@@ -364,6 +364,20 @@ namespace tools
         return true;
     }
 
+    bool wallet::update_safex_offer(const safex::create_purchase_data& purchase){
+
+      for (auto & m_safex_offer : m_safex_offers)
+      {
+        if (m_safex_offer.offer_id == purchase.offer_id)
+        {
+          m_safex_offer.quantity -= purchase.quantity;
+          return true;
+        }
+      }
+
+      return true;
+    }
+
   std::vector<safex::safex_offer> wallet::get_safex_offers()
   {
       cryptonote::COMMAND_RPC_GET_SAFEX_OFFERS::request req = AUTO_VAL_INIT(req);
@@ -386,10 +400,65 @@ namespace tools
 
       return offers;
   }
+
+  std::vector<safex::safex_feedback> wallet::get_safex_ratings(const crypto::hash& offer_id)
+  {
+      cryptonote::COMMAND_RPC_GET_SAFEX_RATINGS::request req = AUTO_VAL_INIT(req);
+      cryptonote::COMMAND_RPC_GET_SAFEX_RATINGS::response res = AUTO_VAL_INIT(res);
+
+      std::vector<safex::safex_feedback> feedbacks;
+
+      req.offer_id = offer_id;
+
+      m_daemon_rpc_mutex.lock();
+      bool r = net_utils::invoke_http_json("/get_safex_ratings", req, res, m_http_client, rpc_timeout);
+      m_daemon_rpc_mutex.unlock();
+
+      THROW_WALLET_EXCEPTION_IF(!r, error::no_connection_to_daemon, "get_safex_ratings");
+      THROW_WALLET_EXCEPTION_IF(res.status != "OK", error::no_connection_to_daemon, "Failed to get safex ratings");
+
+      for (auto &item : res.ratings) {
+        feedbacks.emplace_back(item.star_rating,item.comment,res.offer_id);
+      }
+
+      return feedbacks;
+  }
+
+    bool wallet::add_safex_feedback_token(const safex::create_feedback_token_data& feedback_token){
+
+      m_safex_feedback_tokens.push_back(feedback_token.offer_id);
+
+      return true;
+    }
+
+    bool wallet::remove_safex_feedback_token(const crypto::hash& offer_id){
+
+      for(auto it = m_safex_feedback_tokens.begin(); it!=m_safex_feedback_tokens.end();it++)
+        if(*it==offer_id) {
+          m_safex_feedback_tokens.erase(it);
+          return true;
+        }
+
+      return true;
+    }
+
   std::vector<safex::safex_offer> wallet::get_my_safex_offers()
   {
         return m_safex_offers;
   }
 
+    std::vector<crypto::hash> wallet::get_my_safex_feedbacks_to_give()
+    {
+      return m_safex_feedback_tokens;
+    }
+
+  safex::safex_offer wallet::get_my_safex_offer(crypto::hash& offer_id)
+  {
+        for(auto it: m_safex_offers)
+            if(it.offer_id == offer_id)
+                return it;
+        return safex::safex_offer{};
+  }
+
 }
 
diff --git a/tests/core_tests/chaingen.cpp b/tests/core_tests/chaingen.cpp
index edf479168..13b4c608f 100644
--- a/tests/core_tests/chaingen.cpp
+++ b/tests/core_tests/chaingen.cpp
@@ -430,7 +430,24 @@ bool init_output_indices(map_output_idx_t& outs, std::map<uint64_t, std::vector<
               }
 
             }
-
+            else if (out_type == cryptonote::tx_out_type::out_safex_feedback && out.target.type() == typeid(cryptonote::txout_to_script))
+            {
+                const txout_to_script &temp = boost::get<txout_to_script>(out.target);
+                if(temp.output_type ==  static_cast<uint8_t>(tx_out_type::out_safex_feedback_token))
+                {
+                    output_index oi(out.target, out.amount, out.token_amount, boost::get<txin_gen>(*blk.miner_tx.vin.begin()).height, i, j, &blk, vtx[i]);
+                    outs[static_cast<uint64_t>(temp.output_type)].push_back(oi);
+                    size_t tx_global_idx = outs[static_cast<uint64_t>(temp.output_type)].size() - 1;
+                    outs[static_cast<uint64_t>(temp.output_type)][tx_global_idx].idx = tx_global_idx;
+                    outs[static_cast<uint64_t>(temp.output_type)][tx_global_idx].advanced_output_id = output_id_counter-1;
+                    outs[static_cast<uint64_t>(temp.output_type)][tx_global_idx].blk_height = block_height;
+                    outs[static_cast<uint64_t>(temp.output_type)][tx_global_idx].out_type = static_cast<cryptonote::tx_out_type>(temp.output_type);
+                    if (is_out_to_acc(from.get_keys(), out_key, get_tx_pub_key_from_extra(tx), get_additional_tx_pub_keys_from_extra(tx), j))
+                    {
+                        outs_mine[static_cast<uint64_t>(temp.output_type)].push_back(tx_global_idx);
+                    }
+                }
+            }
 
             }
         }
@@ -684,6 +701,8 @@ bool fill_tx_sources(std::vector<tx_source_entry>& sources, const std::vector<te
             if (out_type == cryptonote::tx_out_type::out_safex_offer_update && oi.out_type != cryptonote::tx_out_type::out_safex_offer)
                 continue;
 
+            if(out_type == cryptonote::tx_out_type::out_safex_feedback && oi.out_type != cryptonote::tx_out_type::out_safex_feedback_token)
+                continue;
 
             cryptonote::tx_source_entry ts = AUTO_VAL_INIT(ts);
             if (out_type == cryptonote::tx_out_type::out_cash)
@@ -735,6 +754,11 @@ bool fill_tx_sources(std::vector<tx_source_entry>& sources, const std::vector<te
                 ts.referenced_output_type = cryptonote::tx_out_type::out_cash;
                 ts.command_type = safex::command_t::simple_purchase;
             }
+            else if (out_type == cryptonote::tx_out_type::out_safex_feedback)
+            {
+                ts.referenced_output_type = cryptonote::tx_out_type::out_safex_feedback_token;
+                ts.command_type = safex::command_t::create_feedback;
+            }
             else
             {
               throw std::runtime_error("unknown referenced output type");
@@ -748,6 +772,7 @@ bool fill_tx_sources(std::vector<tx_source_entry>& sources, const std::vector<te
               case cryptonote::tx_out_type::out_safex_account_update:
               case cryptonote::tx_out_type::out_safex_offer:
               case cryptonote::tx_out_type::out_safex_offer_update:
+              case cryptonote::tx_out_type::out_safex_feedback:
                 {
                   if (!fill_output_entries_advanced(outs[static_cast<uint64_t>(ts.referenced_output_type)], sender_out, nmix, realOutput, ts.outputs))
                     continue;
@@ -787,8 +812,8 @@ bool fill_tx_sources(std::vector<tx_source_entry>& sources, const std::vector<te
               sources_token_amount += ts.token_amount;
               sources_found = value_amount <= sources_token_amount;
             }
-
-
+            else if (out_type == cryptonote::tx_out_type::out_safex_feedback)
+                sources_found = true;
         }
 
         if (sources_found)
@@ -1140,11 +1165,25 @@ tx_destination_entry create_edit_safex_offer_destination(const cryptonote::accou
     return tx_destination_entry{0, to.get_keys().m_account_address, false, tx_out_type::out_safex_offer_update, blobdata};
 }
 
-tx_destination_entry create_safex_purchase_destination(const cryptonote::account_base &to, const safex::safex_purchase &sfx_purchase)
+tx_destination_entry create_safex_purchase_destination(const cryptonote::account_public_address  &to, const safex::safex_purchase &sfx_purchase)
 {
     safex::create_purchase_data safex_purchase_output_data{sfx_purchase};
     blobdata blobdata = cryptonote::t_serializable_object_to_blob(safex_purchase_output_data);
-    return tx_destination_entry{0, to.get_keys().m_account_address, false, tx_out_type::out_safex_purchase, blobdata};
+    return tx_destination_entry{0, to, false, tx_out_type::out_safex_purchase, blobdata};
+}
+
+tx_destination_entry create_safex_feedback_token_destination(const cryptonote::account_public_address  &to, const safex::safex_purchase &sfx_purchase)
+{
+    safex::create_feedback_token_data safex_feedback_token_output_data{sfx_purchase};
+    blobdata blobdata = cryptonote::t_serializable_object_to_blob(safex_feedback_token_output_data);
+    return tx_destination_entry{0, to, false, tx_out_type::out_safex_feedback_token,blobdata};
+}
+
+tx_destination_entry create_safex_feedback_destination(const cryptonote::account_public_address  &to, const safex::safex_feedback &sfx_feedback)
+{
+    safex::create_feedback_data safex_feedback_output_data{sfx_feedback};
+    blobdata blobdata = cryptonote::t_serializable_object_to_blob(safex_feedback_output_data);
+    return tx_destination_entry{0, to, false, tx_out_type::out_safex_feedback,blobdata};
 }
 
 void fill_token_stake_tx_sources_and_destinations(const std::vector<test_event_entry> &events, const block &blk_head,
@@ -1477,9 +1516,13 @@ void fill_create_purchase_tx_sources_and_destinations(const std::vector<test_eve
     }
 
     //purchase
-    tx_destination_entry de_purchase = create_safex_purchase_destination(from, sfx_purchase);
+    tx_destination_entry de_purchase = create_safex_purchase_destination(seller_address, sfx_purchase);
     destinations.push_back(de_purchase);
 
+    //feedback_token
+    tx_destination_entry de_feedback_token = create_safex_feedback_token_destination(from.get_keys().m_account_address, sfx_purchase);
+    destinations.push_back(de_feedback_token);
+
 
     tx_destination_entry de_donation_fee = AUTO_VAL_INIT(de_donation_fee);
     de_donation_fee.addr = from.get_keys().m_account_address;
@@ -1495,6 +1538,48 @@ void fill_create_purchase_tx_sources_and_destinations(const std::vector<test_eve
     destinations.push_back(item_purchase_fee);
 }
 
+void fill_create_feedback_tx_sources_and_destinations(const std::vector<test_event_entry>& events, const block& blk_head,
+                                                      const cryptonote::account_base &from, uint64_t cash_amount, uint64_t fee,
+                                                      size_t nmix, const safex::safex_feedback &sfx_feedback,
+                                                      std::vector<tx_source_entry> &sources,
+                                                      std::vector<tx_destination_entry> &destinations)
+{
+    sources.clear();
+    destinations.clear();
+
+    const cryptonote::account_base &to = from;
+
+    //fill cache sources for fee
+    if (!fill_tx_sources(sources, events, blk_head,  from, fee, nmix, cryptonote::tx_out_type::out_cash))
+        throw std::runtime_error("couldn't fill transaction sources");
+    //fill cache sources for feedback
+    if (!fill_tx_sources(sources, events, blk_head,  from, 0, nmix, cryptonote::tx_out_type::out_safex_feedback))
+        throw std::runtime_error("couldn't fill transaction sources for create feedback");
+
+
+
+    //update source with create feedback data
+    for (auto &ts: sources) {
+        if (ts.command_type == safex::command_t::create_feedback) {
+            safex::create_feedback_data feedback_data{sfx_feedback};
+            ts.command_safex_data = t_serializable_object_to_blob(feedback_data);
+        }
+    }
+
+    //destinations
+
+    //sender change for fee
+    uint64_t cache_back = get_inputs_amount(sources) - fee;
+    if (0 < cache_back)
+    {
+        tx_destination_entry de_change = create_tx_destination(from, cache_back);
+        destinations.push_back(de_change);
+    }
+
+    //feedback
+    tx_destination_entry de_feedback = create_safex_feedback_destination(from.get_keys().m_account_address, sfx_feedback);
+    destinations.push_back(de_feedback);
+}
 
 void fill_nonce(cryptonote::block& blk, const difficulty_type& diffic, uint64_t height)
 {
@@ -1671,6 +1756,16 @@ bool construct_create_purchase_transaction(const std::vector<test_event_entry>&
     return construct_tx(from.get_keys(), sources, destinations, from.get_keys().m_account_address, std::vector<uint8_t>(), tx, 0);
 }
 
+bool construct_create_feedback_transaction(const std::vector<test_event_entry>& events, cryptonote::transaction &tx, const cryptonote::block& blk_head, const cryptonote::account_base &from, uint64_t fee,
+                                           size_t nmix, const safex::safex_feedback &sfx_feedback){
+
+    std::vector<tx_source_entry> sources;
+    std::vector<tx_destination_entry> destinations;
+    fill_create_feedback_tx_sources_and_destinations(events, blk_head, from, 0, fee, nmix, sfx_feedback, sources, destinations);
+
+    return construct_tx(from.get_keys(), sources, destinations, from.get_keys().m_account_address, std::vector<uint8_t>(), tx, 0);
+}
+
 uint64_t get_balance(const cryptonote::account_base& addr, const std::vector<cryptonote::block>& blockchain, const map_hash2tx_t& mtx) {
     uint64_t res = 0;
     std::map<uint64_t, std::vector<output_index> > outs;
diff --git a/tests/core_tests/chaingen.h b/tests/core_tests/chaingen.h
index f314ab996..de90cf259 100644
--- a/tests/core_tests/chaingen.h
+++ b/tests/core_tests/chaingen.h
@@ -269,6 +269,9 @@ bool construct_edit_offer_transaction(const std::vector<test_event_entry>& event
 bool construct_create_purchase_transaction(const std::vector<test_event_entry>& events, cryptonote::transaction &tx, const cryptonote::block& blk_head, const cryptonote::account_base &from, uint64_t fee,
                                        size_t nmix, const safex::safex_purchase &sfx_purchase, const cryptonote::account_public_address seller_address);
 
+bool construct_create_feedback_transaction(const std::vector<test_event_entry>& events, cryptonote::transaction &tx, const cryptonote::block& blk_head, const cryptonote::account_base &from, uint64_t fee,
+                                           size_t nmix, const safex::safex_feedback &sfx_feedback);
+
 void get_confirmed_txs(const std::vector<cryptonote::block>& blockchain, const map_hash2tx_t& mtx, map_hash2tx_t& confirmed_txs);
 bool find_block_chain(const std::vector<test_event_entry>& events, std::vector<cryptonote::block>& blockchain, map_hash2tx_t& mtx, const crypto::hash& head);
 void fill_tx_sources_and_destinations(const std::vector<test_event_entry>& events, const cryptonote::block& blk_head,
@@ -879,6 +882,20 @@ inline bool do_replay_file(const std::string& filename)
     std::list<cryptonote::transaction> SET_NAME; \
     MAKE_CREATE_SAFEX_PURCHASE_TX_LIST(VEC_EVENTS, SET_NAME, FROM, SFX_PURCHASE, SELLER_ADDR, HEAD);
 
+#define MAKE_CREATE_SAFEX_FEEDBACK_TX_MIX_LIST(VEC_EVENTS, SET_NAME, FROM, SFX_FEEDBACK, NMIX, HEAD) \
+  {                                                                                      \
+    cryptonote::transaction t;                                                           \
+    construct_create_feedback_transaction(VEC_EVENTS, t, HEAD, FROM, TESTS_DEFAULT_FEE, NMIX, SFX_FEEDBACK); \
+    SET_NAME.push_back(t);                                                               \
+    VEC_EVENTS.push_back(t);                                                             \
+  }
+
+#define MAKE_CREATE_SAFEX_FEEDBACK_TX_LIST(VEC_EVENTS, SET_NAME, FROM, SFX_FEEDBACK, HEAD) MAKE_CREATE_SAFEX_FEEDBACK_TX_MIX_LIST(VEC_EVENTS, SET_NAME, FROM, SFX_FEEDBACK, 0, HEAD)
+
+#define MAKE_TX_CREATE_SAFEX_FEEDBACK_LIST_START(VEC_EVENTS, SET_NAME, FROM, SFX_FEEDBACK, HEAD) \
+    std::list<cryptonote::transaction> SET_NAME; \
+    MAKE_CREATE_SAFEX_FEEDBACK_TX_LIST(VEC_EVENTS, SET_NAME, FROM, SFX_FEEDBACK, HEAD);
+
 
 #define MAKE_MINER_TX_MANUALLY(TX, BLK) MAKE_MINER_TX_AND_KEY_MANUALLY(TX, BLK, 0)
 
diff --git a/tests/core_tests/safex_purchase.cpp b/tests/core_tests/safex_purchase.cpp
index 8470f8677..118319325 100644
--- a/tests/core_tests/safex_purchase.cpp
+++ b/tests/core_tests/safex_purchase.cpp
@@ -66,6 +66,8 @@ uint64_t  gen_safex_purchase_001::expected_bob_balance;
 uint64_t  gen_safex_purchase_001::expected_bob_offer_quantity;
 crypto::hash  gen_safex_purchase_001::expected_purchased_offer_id;
 
+uint64_t gen_safex_purchase_001::expected_alice_feedback_star_rating;
+
 gen_safex_purchase_001::gen_safex_purchase_001()
 {
 
@@ -107,6 +109,8 @@ gen_safex_purchase_001::gen_safex_purchase_001()
 
   safex_alice_purchase_from_bob = safex::safex_purchase{1, safex_offer_bob.price, safex_offer_bob.offer_id, false};
 
+  safex_alice_feedback = safex::safex_feedback{4,"Perfect for my concert next week.",safex_offer_bob.offer_id};
+
 
     if (!expected_data_fields_intialized)
   {
@@ -132,6 +136,9 @@ gen_safex_purchase_001::gen_safex_purchase_001()
 
     expected_network_fee += safex_alice_purchase_from_bob.price*5/100;
 
+    expected_alice_feedback_star_rating = safex_alice_feedback.stars_given;
+    expected_alice_balance -= TESTS_DEFAULT_FEE;
+
   }
 
   REGISTER_CALLBACK("verify_safex_purchase", gen_safex_purchase_001::verify_safex_purchase);
@@ -196,6 +203,11 @@ bool gen_safex_purchase_001::generate(std::vector<test_event_entry> &events)
     MAKE_NEXT_BLOCK_TX_LIST(events, blk_13, blk_12, miner, txlist_6);
     REWIND_BLOCKS(events, blk_14, blk_13, miner);
 
+    //create feedbackl
+    MAKE_TX_CREATE_SAFEX_FEEDBACK_LIST_START(events, txlist_7, alice, safex_alice_feedback,  blk_14);
+    MAKE_NEXT_BLOCK_TX_LIST(events, blk_15, blk_14, miner, txlist_7);
+    REWIND_BLOCKS(events, blk_16, blk_15, miner);
+
     DO_CALLBACK(events, "verify_safex_purchase");
 
     return true;
@@ -237,5 +249,9 @@ bool gen_safex_purchase_001::verify_safex_purchase(cryptonote::core &c, size_t e
     c.get_blockchain_storage().get_safex_offer_quantity(expected_purchased_offer_id,offer_quantity);
     CHECK_EQ(expected_bob_offer_quantity, offer_quantity);
 
+    uint64_t offer_rating;
+    c.get_blockchain_storage().get_safex_offer_rating(expected_purchased_offer_id,offer_rating);
+    CHECK_EQ(expected_alice_feedback_star_rating, offer_rating);
+
     return true;
 }
diff --git a/tests/core_tests/safex_purchase.h b/tests/core_tests/safex_purchase.h
index 9db685191..db4222155 100644
--- a/tests/core_tests/safex_purchase.h
+++ b/tests/core_tests/safex_purchase.h
@@ -31,6 +31,7 @@
 
 #pragma once
 
+#include "safex/safex_feedback.h"
 #include "safex/safex_purchase.h"
 #include "chaingen.h"
 #include "block_reward.h"
@@ -76,14 +77,15 @@ class gen_safex_purchase_001: public test_chain_unit_base
 
   safex::safex_purchase safex_alice_purchase_from_bob;
 
+  safex::safex_feedback safex_alice_feedback;
 
   static const std::string data2_alternative;
   static const std::string data2_alternative_2;
   static const std::string data3_alternative;
 
 
-  static const size_t expected_blockchain_total_transactions = 445;
-  static const size_t expected_blockchain_height = 429;
+  static const size_t expected_blockchain_total_transactions = 507;
+  static const size_t expected_blockchain_height = 490;
 
   static bool expected_data_fields_intialized;
 
@@ -92,6 +94,7 @@ class gen_safex_purchase_001: public test_chain_unit_base
   static uint64_t  expected_bob_balance;
   static uint64_t  expected_bob_offer_quantity;
   static crypto::hash  expected_purchased_offer_id;
+  static uint64_t expected_alice_feedback_star_rating;
 
 };
 
diff --git a/tests/unit_tests/hardfork.cpp b/tests/unit_tests/hardfork.cpp
index 37c7fbd4a..5408bcdb3 100644
--- a/tests/unit_tests/hardfork.cpp
+++ b/tests/unit_tests/hardfork.cpp
@@ -124,8 +124,11 @@ class TestDB: public BlockchainDB {
   virtual bool get_safex_offers(std::vector<safex::safex_offer> &offers) const { return true; };
   virtual bool get_create_account_output_id(const safex::account_username &username, uint64_t& output_id) const { return true; };
   virtual bool get_create_offer_output_id(const crypto::hash& offer_id, uint64_t& output_id) const { return true; };
+  virtual bool get_offer_stars_given(const crypto::hash offer_id, uint64_t &stars_received) const { return true; };
+  virtual bool get_safex_feedbacks( std::vector<safex::safex_feedback> &safex_feedbacks, const crypto::hash& offer_id) const { return true; };
 
-  virtual bool for_all_key_images(std::function<bool(const crypto::key_image&)>) const { return true; }
+
+    virtual bool for_all_key_images(std::function<bool(const crypto::key_image&)>) const { return true; }
   virtual bool for_blocks_range(const uint64_t&, const uint64_t&, std::function<bool(uint64_t, const crypto::hash&, const cryptonote::block&)>) const { return true; }
   virtual bool for_all_transactions(std::function<bool(const crypto::hash&, const cryptonote::transaction&)>) const { return true; }
   virtual bool for_all_outputs(std::function<bool(uint64_t amount, const crypto::hash &tx_hash, uint64_t height, size_t tx_idx)> f, const tx_out_type output_type) const { return true; }
diff --git a/tests/unit_tests/safex_commands.cpp b/tests/unit_tests/safex_commands.cpp
index 89f8f1caf..d8635860e 100644
--- a/tests/unit_tests/safex_commands.cpp
+++ b/tests/unit_tests/safex_commands.cpp
@@ -312,6 +312,9 @@ class TestBlockchainDB : public cryptonote::BlockchainDB
     virtual bool get_safex_offers(std::vector<safex::safex_offer> &offers) const { return true; };
     virtual bool get_create_account_output_id(const safex::account_username &username, uint64_t& output_id) const { return true; };
     virtual bool get_create_offer_output_id(const crypto::hash& offer_id, uint64_t& output_id) const { return true; };
+    virtual bool get_offer_stars_given(const crypto::hash offer_id, uint64_t &stars_received) const { return true; };
+    virtual bool get_safex_feedbacks( std::vector<safex::safex_feedback> &safex_feedbacks, const crypto::hash& offer_id) const { return true; };
+
 
     virtual void add_block(const cryptonote::block &blk, const size_t &block_size, const cryptonote::difficulty_type &cumulative_difficulty,
             const uint64_t &coins_generated, const uint64_t &tokens_migrated, const crypto::hash &blk_hash)
diff --git a/tests/unit_tests/safex_test_common.cpp b/tests/unit_tests/safex_test_common.cpp
index ec428a376..5735bc304 100644
--- a/tests/unit_tests/safex_test_common.cpp
+++ b/tests/unit_tests/safex_test_common.cpp
@@ -9,6 +9,7 @@
 #include <chrono>
 #include <thread>
 #include <safex/command.h>
+#include <safex/safex_feedback.h>
 
 #include "gtest/gtest.h"
 
@@ -129,11 +130,25 @@ tx_destination_entry edit_safex_offer_destination(const cryptonote::account_base
     return tx_destination_entry{0, to.get_keys().m_account_address, false, tx_out_type::out_safex_offer_update, blobdata};
 }
 
-tx_destination_entry create_safex_purchase_destination(const cryptonote::account_base &to, const safex::safex_purchase &sfx_purchase)
+tx_destination_entry create_safex_purchase_destination(const cryptonote::account_public_address  &to, const safex::safex_purchase &sfx_purchase)
 {
     safex::create_purchase_data safex_purchase_output_data{sfx_purchase};
     blobdata blobdata = cryptonote::t_serializable_object_to_blob(safex_purchase_output_data);
-    return tx_destination_entry{0, to.get_keys().m_account_address, false, tx_out_type::out_safex_purchase, blobdata};
+    return tx_destination_entry{0, to, false, tx_out_type::out_safex_purchase, blobdata};
+}
+
+tx_destination_entry create_safex_feedback_token_destination(const cryptonote::account_public_address  &to, const safex::safex_purchase &sfx_purchase)
+{
+    safex::create_feedback_token_data safex_feedback_token_output_data{sfx_purchase};
+    blobdata blobdata = cryptonote::t_serializable_object_to_blob(safex_feedback_token_output_data);
+    return tx_destination_entry{0, to, false, tx_out_type::out_safex_feedback_token,blobdata};
+}
+
+tx_destination_entry create_safex_feedback_destination(const cryptonote::account_public_address  &to, const safex::safex_feedback &sfx_feedback)
+{
+    safex::create_feedback_data safex_feedback_output_data{sfx_feedback};
+    blobdata blobdata = cryptonote::t_serializable_object_to_blob(safex_feedback_output_data);
+    return tx_destination_entry{0, to, false, tx_out_type::out_safex_feedback,blobdata};
 }
 
 bool init_output_indices(map_hash2tx_t &txmap, map_output_idx_t &outs, std::map<uint64_t, std::vector<size_t> > &outs_mine, const std::vector<cryptonote::block> &blockchain,
@@ -229,6 +244,24 @@ bool init_output_indices(map_hash2tx_t &txmap, map_output_idx_t &outs, std::map<
                 }
 
               }
+              else if (out_type == cryptonote::tx_out_type::out_safex_feedback && out.target.type() == typeid(cryptonote::txout_to_script))
+              {
+                  const txout_to_script &temp = boost::get<txout_to_script>(out.target);
+                  if(temp.output_type ==  static_cast<uint8_t>(tx_out_type::out_safex_feedback_token))
+                  {
+                      output_index oi(out.target, out.amount, out.token_amount, boost::get<txin_gen>(*blk.miner_tx.vin.begin()).height, i, j, &blk, vtx[i]);
+                      outs[static_cast<uint64_t>(temp.output_type)].push_back(oi);
+                      size_t tx_global_idx = outs[static_cast<uint64_t>(temp.output_type)].size() - 1;
+                      outs[static_cast<uint64_t>(temp.output_type)][tx_global_idx].idx = tx_global_idx;
+                      outs[static_cast<uint64_t>(temp.output_type)][tx_global_idx].advanced_output_id = output_id_counter-1;
+                      outs[static_cast<uint64_t>(temp.output_type)][tx_global_idx].blk_height = block_height;
+                      outs[static_cast<uint64_t>(temp.output_type)][tx_global_idx].out_type = static_cast<cryptonote::tx_out_type>(temp.output_type);
+                      if (is_out_to_acc(from.get_keys(), out_key, get_tx_pub_key_from_extra(tx), get_additional_tx_pub_keys_from_extra(tx), j))
+                      {
+                          outs_mine[static_cast<uint64_t>(temp.output_type)].push_back(tx_global_idx);
+                      }
+                  }
+              }
             }
           }
           block_height++;
@@ -546,6 +579,9 @@ bool fill_tx_sources(map_hash2tx_t &txmap,  std::vector<block> &blocks,std::vect
             if (out_type == cryptonote::tx_out_type::out_safex_offer_update && oi.out_type != cryptonote::tx_out_type::out_safex_offer)
                 continue;
 
+            if(out_type == cryptonote::tx_out_type::out_safex_feedback && oi.out_type != cryptonote::tx_out_type::out_safex_feedback_token)
+                continue;
+
             cryptonote::tx_source_entry ts = AUTO_VAL_INIT(ts);
             if (out_type == cryptonote::tx_out_type::out_cash)
             {
@@ -596,6 +632,11 @@ bool fill_tx_sources(map_hash2tx_t &txmap,  std::vector<block> &blocks,std::vect
                 ts.referenced_output_type = cryptonote::tx_out_type::out_cash;
                 ts.command_type = safex::command_t::simple_purchase;
             }
+            else if (out_type == cryptonote::tx_out_type::out_safex_feedback)
+            {
+                ts.referenced_output_type = cryptonote::tx_out_type::out_safex_feedback_token;
+                ts.command_type = safex::command_t::create_feedback;
+            }
             else
             {
               throw std::runtime_error("unknown referenced output type");
@@ -648,6 +689,8 @@ bool fill_tx_sources(map_hash2tx_t &txmap,  std::vector<block> &blocks,std::vect
               sources_token_amount += ts.token_amount;
               sources_found = value_amount <= sources_token_amount;
             }
+            else if (out_type == cryptonote::tx_out_type::out_safex_feedback)
+                sources_found = true;
 
 
           }
@@ -903,9 +946,13 @@ void fill_create_purchase_tx_sources_and_destinations(map_hash2tx_t &txmap,  std
     }
 
     //purchase
-    tx_destination_entry de_purchase = create_safex_purchase_destination(from, sfx_purchase);
+    tx_destination_entry de_purchase = create_safex_purchase_destination(seller_address, sfx_purchase);
     destinations.push_back(de_purchase);
 
+    //feedback_token
+    tx_destination_entry de_feedback_token = create_safex_feedback_token_destination(from.get_keys().m_account_address, sfx_purchase);
+    destinations.push_back(de_feedback_token);
+
 
     tx_destination_entry de_donation_fee = AUTO_VAL_INIT(de_donation_fee);
     de_donation_fee.addr = from.get_keys().m_account_address;
@@ -922,6 +969,47 @@ void fill_create_purchase_tx_sources_and_destinations(map_hash2tx_t &txmap,  std
 
 }
 
+void fill_create_feedback_tx_sources_and_destinations(map_hash2tx_t &txmap,  std::vector<block> &blocks, const cryptonote::account_base &from, uint64_t cash_amount,
+                                                      uint64_t fee, size_t nmix, const safex::safex_feedback &sfx_feedback, std::vector<tx_source_entry> &sources,
+                                                      std::vector<tx_destination_entry> &destinations)
+{
+    sources.clear();
+    destinations.clear();
+
+    const cryptonote::account_base &to = from;
+
+    //fill cache sources for fee
+    if (!fill_tx_sources(txmap, blocks, sources, from, fee, nmix, cryptonote::tx_out_type::out_cash))
+        throw std::runtime_error("couldn't fill transaction sources");
+    //fill cache sources for feedback token
+    if (!fill_tx_sources(txmap, blocks, sources, from, 0, nmix, cryptonote::tx_out_type::out_safex_feedback))
+        throw std::runtime_error("couldn't fill transaction sources for create feedback");
+
+
+
+    //update source with create purchase data
+    for (auto &ts: sources) {
+        if (ts.command_type == safex::command_t::create_feedback) {
+            safex::create_feedback_data feedback_data{sfx_feedback};
+            ts.command_safex_data = t_serializable_object_to_blob(feedback_data);
+        }
+    }
+
+    //destinations
+
+    //sender change for fee
+    uint64_t cache_back = get_inputs_amount(sources) - fee;
+    if (0 < cache_back)
+    {
+        tx_destination_entry de_change = create_tx_destination(from, cache_back);
+        destinations.push_back(de_change);
+    }
+
+    //feedback
+    tx_destination_entry de_feedback = create_safex_feedback_destination(from.get_keys().m_account_address,sfx_feedback);
+    destinations.push_back(de_feedback);
+}
+
 void fill_tx_sources_and_destinations(map_hash2tx_t &txmap,  std::vector<block> &blocks, const cryptonote::account_base &from, const cryptonote::account_base &to,
                                       uint64_t amount, uint64_t fee, size_t nmix, std::vector<tx_source_entry> &sources,
                                       std::vector<tx_destination_entry> &destinations)
@@ -1185,6 +1273,16 @@ bool construct_create_purchase_transaction(map_hash2tx_t &txmap,  std::vector<bl
     return construct_tx(from.get_keys(), sources, destinations, from.get_keys().m_account_address, std::vector<uint8_t>(), tx, 0);
 }
 
+bool construct_create_feedback_transaction(map_hash2tx_t &txmap,  std::vector<block> &blocks, cryptonote::transaction &tx, const cryptonote::account_base &from,
+                                           uint64_t fee, size_t nmix, const safex::safex_feedback &sfx_feedback)
+{
+    std::vector<tx_source_entry> sources;
+    std::vector<tx_destination_entry> destinations;
+    fill_create_feedback_tx_sources_and_destinations(txmap, blocks, from, 0, fee, nmix, sfx_feedback, sources, destinations);
+
+    return construct_tx(from.get_keys(), sources, destinations, from.get_keys().m_account_address, std::vector<uint8_t>(), tx, 0);
+}
+
 uint64_t get_inputs_token_amount(const std::vector<cryptonote::tx_source_entry> &s)
 {
   uint64_t r = 0;
diff --git a/tests/unit_tests/safex_test_common.h b/tests/unit_tests/safex_test_common.h
index c16c18d8c..9e810a371 100644
--- a/tests/unit_tests/safex_test_common.h
+++ b/tests/unit_tests/safex_test_common.h
@@ -12,6 +12,7 @@
 #include "safex/safex_account.h"
 #include "safex/safex_offer.h"
 #include "safex/safex_purchase.h"
+#include "safex/safex_feedback.h"
 
 struct output_index
 {
@@ -131,6 +132,9 @@ bool construct_edit_offer_transaction(map_hash2tx_t &txmap, std::vector<cryptono
 bool construct_create_purchase_transaction(map_hash2tx_t &txmap,  std::vector<cryptonote::block> &blocks, cryptonote::transaction &tx, const cryptonote::account_base &from,
                                            uint64_t fee, size_t nmix, const safex::safex_purchase &sfx_purchase, const cryptonote::account_public_address seller_address);
 
+bool construct_create_feedback_transaction(map_hash2tx_t &txmap,  std::vector<cryptonote::block> &blocks, cryptonote::transaction &tx, const cryptonote::account_base &from,
+                                           uint64_t fee, size_t nmix, const safex::safex_feedback &sfx_feedback);
+
 bool construct_block(cryptonote::block &blk, uint64_t height, const crypto::hash &prev_id, const cryptonote::account_base &miner_acc,
         uint64_t timestamp, size_t &block_size, std::list<cryptonote::transaction> tx_list);
 
diff --git a/tests/unit_tests/simple_purchase.cpp b/tests/unit_tests/simple_purchase.cpp
index 103ac81aa..3c92a2b32 100644
--- a/tests/unit_tests/simple_purchase.cpp
+++ b/tests/unit_tests/simple_purchase.cpp
@@ -42,6 +42,7 @@
 #include "safex/safex_account.h"
 #include "safex/safex_offer.h"
 #include "safex/safex_purchase.h"
+#include "safex/safex_feedback.h"
 #include "safex_test_common.h"
 
 
@@ -106,6 +107,8 @@ namespace
 
         m_safex_purchase = safex::safex_purchase{1, m_safex_offer[0].price, m_safex_offer[0].offer_id, true};
 
+        m_safex_feedback = safex::safex_feedback{4,"Eating it all day", m_safex_offer[0].offer_id};
+
         offers_total_fee = m_safex_purchase.price*5/100;
 
 
@@ -191,6 +194,13 @@ namespace
               construct_create_purchase_transaction(m_txmap, m_blocks, tx, m_users_acc[0], default_miner_fee, 0, m_safex_purchase,m_users_acc[1].get_keys().m_account_address);
               m_txmap[get_transaction_hash(tx)] = tx;
           }
+          else if (i == 25)
+          {
+              tx_list.resize(tx_list.size() + 1);
+              cryptonote::transaction &tx = tx_list.back();                                                           \
+              construct_create_feedback_transaction(m_txmap, m_blocks, tx, m_users_acc[0], default_miner_fee, 0, m_safex_feedback);
+              m_txmap[get_transaction_hash(tx)] = tx;
+          }
 
 
           construct_block(blk, i, prev_hash, m_miner_acc, 0, m_test_sizes[i], tx_list);
@@ -235,6 +245,8 @@ namespace
 
       safex::safex_purchase m_safex_purchase;
 
+      safex::safex_feedback m_safex_feedback;
+
       std::vector<uint8_t> data1_new;
 
       uint64_t offers_total_fee;
@@ -327,7 +339,7 @@ namespace
         safex::safex_offer purchased_offer;
         result = this->m_db->get_offer(this->m_safex_purchase.offer_id,purchased_offer);
         ASSERT_TRUE(result);
-        ASSERT_EQ(this->m_safex_offer[0].quantity, purchased_offer.quantity);
+        ASSERT_EQ(this->m_safex_offer[0].quantity-this->m_safex_purchase.quantity, purchased_offer.quantity);
         //Checking edited offer
         safex::safex_offer saved_offer;
 
@@ -336,6 +348,11 @@ namespace
                                                   this->m_test_coins[i], this->m_test_tokens[i], this->m_txs[i]));
         }
 
+        uint64_t stars_given;
+        result = this->m_db->get_offer_stars_given(this->m_safex_purchase.offer_id, stars_given);
+        ASSERT_TRUE(result);
+        ASSERT_EQ(this->m_safex_feedback.stars_given, stars_given);
+
         uint64_t fee_sum = 0;
 
         for(int i=0;i<NUMBER_OF_BLOCKS3; i++) {