diff --git a/libretroshare/src/gxs/rsdataservice.cc b/libretroshare/src/gxs/rsdataservice.cc
index 04a3a0c8c..43f7c19cc 100644
--- a/libretroshare/src/gxs/rsdataservice.cc
+++ b/libretroshare/src/gxs/rsdataservice.cc
@@ -15,38 +15,76 @@
 #define KEY_IDENTITY_SIGN std::string("idSign")
 #define KEY_TIME_STAMP std::string("timeStamp")
 #define KEY_NXS_FLAGS std::string("flags")
+#define KEY_NXS_META std::string("meta")
+
 
 // grp table columns
 #define KEY_ADMIN_SIGN std::string("adminSign")
 #define KEY_KEY_SET std::string("keySet")
+#define KEY_GRP_NAME std::string("grpName")
 
+// grp local
+#define KEY_GRP_SUBCR_FLAG std::string("subscribeFlag")
+#define KEY_GRP_POP std::string("popularity")
+#define KEY_MSG_COUNT std::string("msgCount")
+#define KEY_GRP_STATUS std::string("grpStatus")
+#define KEY_GRP_LAST_POST std::string("lastPost")
 
 
 // msg table columns
 #define KEY_PUBLISH_SIGN std::string("publishSign")
 #define KEY_MSG_ID std::string("msgId")
 #define KEY_ORIG_MSG_ID std::string("origMsgId")
+#define KEY_MSG_PARENT_ID std::string("parentId")
+#define KEY_MSG_THREAD_ID std::string("threadId")
+#define KEY_MSG_NAME std::string("msgName")
 
+// msg local
+#define KEY_MSG_STATUS std::string("msgStatus")
+#define KEY_CHILD_TS std::string("childTs")
+
+
+
+
+/*** actual data col numbers ***/
+
+// generic
+#define COL_ACT_GROUP_ID 0
+#define COL_NXS_FILE 1
+#define COL_NXS_FILE_OFFSET 2
+#define COL_NXS_FILE_LEN 3
+#define COL_META_DATA 4
+#define COL_ACT_MSG_ID 5
+
+/*** meta column numbers ***/
 
 // grp col numbers
-#define COL_GRP_ID 0
-#define COL_ADMIN_SIGN 1
-#define COL_KEY_SET 9
+
+#define COL_ADMIN_SIGN 5
+#define COL_KEY_SET 6
+#define COL_GRP_SUBCR_FLAG 7
+#define COL_GRP_POP 8
+#define COL_MSG_COUNT 9
+#define COL_GRP_STATUS 11
+#define COL_GRP_NAME 12
+#define COL_GRP_LAST_POST 13
 
 // msg col numbers
-#define COL_PUBLISH_SIGN 1
-#define COL_MSG_ID 9
-#define COL_ORIG_MSG_ID 10
-
-// generic col numbers
-#define COL_NXS_FILE 2
-#define COL_NXS_FILE_OFFSET 3
-#define COL_NXS_FILE_LEN 4
-#define COL_TIME_STAMP 5
-#define COL_NXS_FLAGS 6
-#define COL_IDENTITY_SIGN 7
-#define COL_IDENTITY 8
+#define COL_PUBLISH_SIGN 5
+#define COL_MSG_ID 6
+#define COL_ORIG_MSG_ID 7
+#define COL_MSG_STATUS 8
+#define COL_CHILD_TS 9
+#define COL_PARENT_ID 10
+#define COL_THREAD_ID 11
+#define COL_MSG_NAME 12
 
+// generic meta shared col numbers
+#define COL_GRP_ID 0
+#define COL_TIME_STAMP 1
+#define COL_NXS_FLAGS 2
+#define COL_IDENTITY_SIGN 3
+#define COL_IDENTITY 4
 
 #define RS_DATA_SERVICE_DEBUG
 
@@ -56,15 +94,27 @@ RsDataService::RsDataService(const std::string &serviceDir, const std::string &d
 
     initialise();
 
-    msgColumns.push_back(KEY_GRP_ID); msgColumns.push_back(KEY_PUBLISH_SIGN);  msgColumns.push_back(KEY_NXS_FILE);
-    msgColumns.push_back(KEY_NXS_FILE_OFFSET); msgColumns.push_back(KEY_NXS_FILE_LEN); msgColumns.push_back(KEY_TIME_STAMP);
-    msgColumns.push_back(KEY_NXS_FLAGS); msgColumns.push_back(KEY_IDENTITY_SIGN); msgColumns.push_back(KEY_NXS_IDENTITY);
-    msgColumns.push_back(KEY_MSG_ID); msgColumns.push_back(KEY_ORIG_MSG_ID);
+    // for retrieving msg meta
+    msgMetaColumns.push_back(KEY_GRP_ID); msgMetaColumns.push_back(KEY_TIME_STAMP); msgMetaColumns.push_back(KEY_NXS_FLAGS);
+    msgMetaColumns.push_back(KEY_IDENTITY_SIGN); msgMetaColumns.push_back(KEY_NXS_IDENTITY); msgMetaColumns.push_back(KEY_PUBLISH_SIGN);
+    msgMetaColumns.push_back(KEY_MSG_ID); msgMetaColumns.push_back(KEY_ORIG_MSG_ID); msgMetaColumns.push_back(KEY_MSG_STATUS);
+    msgMetaColumns.push_back(KEY_CHILD_TS); msgMetaColumns.push_back(KEY_MSG_PARENT_ID); msgMetaColumns.push_back(KEY_MSG_THREAD_ID);
+    msgMetaColumns.push_back(KEY_MSG_NAME);
 
-    grpColumns.push_back(KEY_GRP_ID); grpColumns.push_back(KEY_ADMIN_SIGN); grpColumns.push_back(KEY_NXS_FILE);
-    grpColumns.push_back(KEY_NXS_FILE_OFFSET);  grpColumns.push_back(KEY_NXS_FILE_LEN); grpColumns.push_back(KEY_TIME_STAMP);
-    grpColumns.push_back(KEY_NXS_FLAGS); grpColumns.push_back(KEY_IDENTITY_SIGN);
-    grpColumns.push_back(KEY_NXS_IDENTITY); grpColumns.push_back(KEY_KEY_SET);
+    // for retrieving actual data
+    msgColumns.push_back(KEY_GRP_ID);  msgColumns.push_back(KEY_NXS_FILE); msgColumns.push_back(KEY_NXS_FILE_OFFSET);
+    msgColumns.push_back(KEY_NXS_FILE_LEN); msgColumns.push_back(KEY_NXS_META); msgColumns.push_back(KEY_MSG_ID);
+
+    // for retrieving grp meta data
+    grpMetaColumns.push_back(KEY_GRP_ID);  grpMetaColumns.push_back(KEY_TIME_STAMP); grpMetaColumns.push_back(KEY_NXS_FLAGS);
+    grpMetaColumns.push_back(KEY_IDENTITY_SIGN); grpMetaColumns.push_back(KEY_NXS_IDENTITY); grpMetaColumns.push_back(KEY_ADMIN_SIGN);
+    grpMetaColumns.push_back(KEY_KEY_SET); grpMetaColumns.push_back(KEY_GRP_SUBCR_FLAG); grpMetaColumns.push_back(KEY_GRP_POP);
+    grpMetaColumns.push_back(KEY_MSG_COUNT); grpMetaColumns.push_back(KEY_GRP_STATUS); grpMetaColumns.push_back(KEY_GRP_NAME);
+    grpMetaColumns.push_back(KEY_GRP_LAST_POST);
+
+    // for retrieving actual grp data
+    grpColumns.push_back(KEY_GRP_ID); grpColumns.push_back(KEY_NXS_FILE); grpColumns.push_back(KEY_NXS_FILE_OFFSET);
+    grpColumns.push_back(KEY_NXS_FILE_LEN); grpColumns.push_back(KEY_NXS_META);
 }
 
 RsDataService::~RsDataService(){
@@ -77,23 +127,89 @@ void RsDataService::initialise(){
     // initialise database
     mDb = new RetroDb(mDbName, RetroDb::OPEN_READWRITE_CREATE);
 
-    // create table for msgs
+    // create table for msg data
     mDb->execSQL("CREATE TABLE " + MSG_TABLE_NAME + "(" + KEY_MSG_ID
                  + " TEXT," + KEY_GRP_ID +  " TEXT," + KEY_NXS_FLAGS + " INT,"  + KEY_ORIG_MSG_ID +  " TEXT,"
                   + KEY_TIME_STAMP + " INT," + KEY_PUBLISH_SIGN + " BLOB," + KEY_NXS_IDENTITY + " TEXT,"
                  + KEY_IDENTITY_SIGN + " BLOB," + KEY_NXS_FILE + " TEXT,"+ KEY_NXS_FILE_OFFSET + " INT,"
+                 + KEY_MSG_STATUS + " INT," + KEY_CHILD_TS + " INT,"+ KEY_NXS_META + " BLOB,"
+                 + KEY_MSG_THREAD_ID + " TEXT," + KEY_MSG_PARENT_ID + " TEXT,"+ KEY_MSG_NAME + " TEXT,"
                  + KEY_NXS_FILE_LEN+ " INT);");
 
-    // create table for grps
+    // create table for grp data
     mDb->execSQL("CREATE TABLE " + GRP_TABLE_NAME + "(" + KEY_GRP_ID +
                  " TEXT," + KEY_TIME_STAMP + " INT," +
                  KEY_ADMIN_SIGN + " BLOB," + " BLOB," + KEY_NXS_FILE +
                   " TEXT," + KEY_NXS_FILE_OFFSET + " INT," + KEY_KEY_SET + " BLOB," + KEY_NXS_FILE_LEN + " INT,"
+                   + KEY_NXS_META + " BLOB," + KEY_GRP_NAME + " TEXT," + KEY_GRP_LAST_POST + " INT,"
+                    + KEY_GRP_LAST_POST + " INT," + KEY_GRP_POP + " INT," + KEY_MSG_COUNT + " INT,"
+                    + KEY_GRP_SUBCR_FLAG + " INT," + KEY_GRP_STATUS + " INT,"
                   + KEY_NXS_IDENTITY + " TEXT," + KEY_NXS_FLAGS + " INT," + KEY_IDENTITY_SIGN + " BLOB);");
 
 }
 
-RsNxsGrp* RsDataService::getGroup(RetroCursor &c){
+RsGxsGrpMetaData* RsDataService::getGrpMeta(RetroCursor &c)
+{
+    RsGxsGrpMetaData* grpMeta = new RsGxsGrpMetaData();
+
+    bool ok = true;
+
+    // for manipulating raw data
+    uint32_t offset = 0;
+    char* data = NULL;
+    uint32_t data_len = 0;
+
+    // grpId
+    c.getString(COL_GRP_ID, grpMeta->mGroupId);
+
+    // required definition of a group
+    ok &= !grpMeta->mGroupId.empty();
+
+    // identity if any
+    c.getString(COL_IDENTITY, grpMeta->mAuthorId);
+    c.getString(COL_GRP_NAME, grpMeta->mGroupName);
+
+    grpMeta->mPublishTs = c.getInt32(COL_TIME_STAMP);
+    grpMeta->mGroupFlags = c.getInt32(COL_NXS_FLAGS);
+
+
+    if(!grpMeta->mAuthorId.empty() && ok){
+        offset = 0;
+        data = (char*)c.getData(COL_IDENTITY_SIGN, data_len);
+        if(data)
+            grpMeta->idSign.GetTlv(data, data_len, &offset);
+    }
+
+    offset = 0;
+    data = (char*)c.getData(COL_ADMIN_SIGN, data_len);
+    if(data)
+        grpMeta->adminSign.GetTlv(data, data_len, &offset);
+
+
+    offset = 0; data = NULL; data_len = 0;
+    data = (char*)c.getData(COL_KEY_SET, data_len);
+
+    if(data)
+        ok &= grpMeta->keys.GetTlv(data, data_len, &offset);
+
+    // local meta
+    grpMeta->mSubscribeFlags = c.getInt32(COL_GRP_SUBCR_FLAG);
+    grpMeta->mPop = c.getInt32(COL_GRP_POP);
+    grpMeta->mMsgCount = c.getInt32(COL_MSG_COUNT);
+    grpMeta->mLastPost = c.getInt32(COL_GRP_LAST_POST);
+    grpMeta->mGroupStatus = c.getInt32(COL_GRP_STATUS);
+
+
+    if(ok)
+        return grpMeta;
+    else
+        delete grpMeta;
+
+    return NULL;
+}
+
+RsNxsGrp* RsDataService::getGroup(RetroCursor &c)
+{
 
     /*!
      * grpId, pub admin and pub publish key
@@ -109,43 +225,21 @@ RsNxsGrp* RsDataService::getGroup(RetroCursor &c){
     uint32_t data_len = 0;
 
     // grpId
-    c.getString(COL_GRP_ID, grp->grpId);
+    c.getString(COL_ACT_GROUP_ID, grp->grpId);
     ok &= !grp->grpId.empty();
 
-    // identity if any
-    c.getString(COL_IDENTITY, grp->identity);
-    grp->timeStamp = c.getInt32(COL_TIME_STAMP);
+    offset = 0; data_len = 0;
+    if(ok){
 
-    if(!( grp->identity.empty() ) && ok){
-        offset = 0;
-        data = (char*)c.getData(COL_IDENTITY_SIGN, data_len);
-        if(data){
-
-            grp->idSign.GetTlv(data, data_len, &offset);
-        }
-    }
-
-    offset = 0;
-    data = (char*)c.getData(COL_ADMIN_SIGN, data_len);
-    if(data){
-        grp->adminSign.GetTlv(data, data_len, &offset);
-    }
-
-
-
-    grp->grpFlag = c.getInt32(COL_NXS_FLAGS);
-
-    offset = 0; data = NULL; data_len = 0;
-
-    data = (char*)c.getData(COL_KEY_SET, data_len);
-    if(data){
-        ok &= grp->keys.GetTlv(data, data_len, &offset);
+        data = (char*)c.getData(COL_META_DATA, data_len);
+        if(data)
+            grp->meta.GetTlv(data, data_len, &offset);
     }
 
+    /* now retrieve grp data from file */
     std::string grpFile;
     c.getString(COL_NXS_FILE, grpFile);
     ok &= !grpFile.empty();
-    /* now retrieve grp data from file */
 
     if(ok){
 
@@ -170,8 +264,65 @@ RsNxsGrp* RsDataService::getGroup(RetroCursor &c){
     return NULL;
 }
 
+RsGxsMsgMetaData* RsDataService::getMsgMeta(RetroCursor &c)
+{
 
-RsNxsMsg* RsDataService::getMessage(RetroCursor &c){
+    RsGxsMsgMetaData* msgMeta = new RsGxsMsgMetaData();
+
+    bool ok = true;
+    uint32_t data_len = 0,
+    offset = 0;
+    char* data = NULL;
+
+
+    c.getString(COL_GRP_ID, msgMeta->mGroupId);
+    c.getString(COL_MSG_ID, msgMeta->mMsgId);
+
+    // without these, a msg is meaningless
+    ok &= (!msgMeta->mGroupId.empty()) && (!msgMeta->mMsgId.empty());
+
+    c.getString(COL_ORIG_MSG_ID, msgMeta->mOrigMsgId);
+    c.getString(COL_IDENTITY, msgMeta->mAuthorId);
+    c.getString(COL_MSG_NAME, msgMeta->mMsgName);
+
+    if(!msgMeta->mAuthorId.empty()){
+        offset = 0;
+        data = (char*)c.getData(COL_IDENTITY_SIGN, data_len);
+        msgMeta->idSign.GetTlv(data, data_len, &offset);
+    }
+
+    msgMeta->mMsgFlags = c.getInt32(COL_NXS_FLAGS);
+    msgMeta->mPublishTs = c.getInt32(COL_TIME_STAMP);
+
+    offset = 0; data_len = 0;
+    if(ok){
+
+        data = (char*)c.getData(COL_PUBLISH_SIGN, data_len);
+        if(data)
+            msgMeta->pubSign.GetTlv(data, data_len, &offset);
+
+    }
+
+    // thread and parent id
+    c.getString(COL_THREAD_ID, msgMeta->mThreadId);
+    c.getString(COL_PARENT_ID, msgMeta->mParentId);
+
+    // local meta
+    msgMeta->mMsgStatus = c.getInt32(COL_MSG_STATUS);
+    msgMeta->mChildTs = c.getInt32(COL_CHILD_TS);
+
+    if(ok)
+        return msgMeta;
+    else
+        delete msgMeta;
+
+    return NULL;
+}
+
+
+
+RsNxsMsg* RsDataService::getMessage(RetroCursor &c)
+{
 
     RsNxsMsg* msg = new RsNxsMsg(mServType);
 
@@ -179,37 +330,25 @@ RsNxsMsg* RsDataService::getMessage(RetroCursor &c){
     uint32_t data_len = 0,
     offset = 0;
     char* data = NULL;
-    c.getString(COL_GRP_ID, msg->grpId);
-    c.getString(COL_MSG_ID, msg->msgId);
+    c.getString(COL_ACT_GROUP_ID, msg->grpId);
+    c.getString(COL_ACT_MSG_ID, msg->msgId);
 
     ok &= (!msg->grpId.empty()) && (!msg->msgId.empty());
 
-    c.getString(COL_IDENTITY, msg->identity);
-
-    if(!msg->identity.empty()){
-        offset = 0;
-        data = (char*)c.getData(COL_IDENTITY_SIGN, data_len);
-        msg->idSign.GetTlv(data, data_len, &offset);
-    }
-
-    msg->msgFlag = c.getInt32(COL_NXS_FLAGS);
-    msg->timeStamp = c.getInt32(COL_TIME_STAMP);
-
     offset = 0; data_len = 0;
     if(ok){
 
-        data = (char*)c.getData(COL_PUBLISH_SIGN, data_len);
+        data = (char*)c.getData(COL_META_DATA, data_len);
         if(data)
-            msg->publishSign.GetTlv(data, data_len, &offset);
-
+            msg->meta.GetTlv(data, data_len, &offset);
     }
 
+    /* now retrieve grp data from file */
     std::string msgFile;
     c.getString(COL_NXS_FILE, msgFile);
     offset = c.getInt32(COL_NXS_FILE_OFFSET);
     data_len = c.getInt32(COL_NXS_FILE_LEN);
     ok &= !msgFile.empty();
-    /* now retrieve grp data from file */
 
     if(ok){
 
@@ -231,44 +370,60 @@ RsNxsMsg* RsDataService::getMessage(RetroCursor &c){
     return NULL;
 }
 
-int RsDataService::storeMessage(std::set<RsNxsMsg *> &msg){
-
-
-    std::set<RsNxsMsg*>::iterator sit = msg.begin();
+int RsDataService::storeMessage(std::map<RsNxsMsg *, RsGxsMsgMetaData *> &msg)
+{
+    std::map<RsNxsMsg*, RsGxsMsgMetaData* >::iterator mit = msg.begin();
 
+    // start a transaction
     mDb->execSQL("BEGIN;");
 
+    for(; mit != msg.end(); mit++){
 
-    for(; sit != msg.end(); sit++){
+        RsNxsMsg* msgPtr = mit->first;
+        RsGxsMsgMetaData* msgMetaPtr = mit->second;
 
-        RsNxsMsg* msgPtr = *sit;
+        // create or access file in binary
         std::string msgFile = mServiceDir + "/" + msgPtr->grpId + "-msgs";
         std::fstream ostrm(msgFile.c_str(), std::ios::binary | std::ios::app | std::ios::out);
         ostrm.seekg(0, std::ios::end); // go to end to append
         uint32_t offset = ostrm.tellg(); // get fill offset
 
         ContentValue cv;
+
         cv.put(KEY_NXS_FILE_OFFSET, (int32_t)offset);
         cv.put(KEY_NXS_FILE, msgFile);
         cv.put(KEY_NXS_FILE_LEN, (int32_t)msgPtr->msg.TlvSize());
-        cv.put(KEY_MSG_ID, msgPtr->msgId);
-        cv.put(KEY_GRP_ID, msgPtr->grpId);
-        char pubSignData[msgPtr->publishSign.TlvSize()];
+        cv.put(KEY_MSG_ID, msgMetaPtr->mMsgId);
+        cv.put(KEY_GRP_ID, msgMetaPtr->mGroupId);
+        char pubSignData[msgMetaPtr->pubSign.TlvSize()];
         offset = 0;
-        msgPtr->publishSign.SetTlv(pubSignData, msgPtr->publishSign.TlvSize(), &offset);
-        cv.put(KEY_PUBLISH_SIGN, msgPtr->publishSign.TlvSize(), pubSignData);
+        msgMetaPtr->pubSign.SetTlv(pubSignData, msgMetaPtr->pubSign.TlvSize(), &offset);
+        cv.put(KEY_PUBLISH_SIGN, msgMetaPtr->pubSign.TlvSize(), pubSignData);
 
 
-        if(! (msgPtr->identity.empty()) ){
-            char idSignData[msgPtr->idSign.TlvSize()];
+        if(! (msgMetaPtr->mAuthorId.empty()) ){
+            char idSignData[msgMetaPtr->idSign.TlvSize()];
             offset = 0;
-            msgPtr->idSign.SetTlv(idSignData, msgPtr->idSign.TlvSize(), &offset);
-            cv.put(KEY_IDENTITY_SIGN, msgPtr->idSign.TlvSize(), idSignData);
-            cv.put(KEY_NXS_IDENTITY, msgPtr->identity);
+            msgMetaPtr->idSign.SetTlv(idSignData, msgMetaPtr->idSign.TlvSize(), &offset);
+            cv.put(KEY_IDENTITY_SIGN, msgMetaPtr->idSign.TlvSize(), idSignData);
+            cv.put(KEY_NXS_IDENTITY, msgMetaPtr->mAuthorId);
         }
 
-        cv.put(KEY_NXS_FLAGS, (int32_t) msgPtr->msgFlag);
-        cv.put(KEY_TIME_STAMP, (int32_t) msgPtr->timeStamp);
+        cv.put(KEY_NXS_FLAGS, (int32_t) msgMetaPtr->mMsgFlags);
+        cv.put(KEY_TIME_STAMP, (int32_t) msgMetaPtr->mPublishTs);
+
+        offset = 0;
+        char metaData[msgPtr->meta.TlvSize()];
+        msgPtr->meta.SetTlv(metaData, msgPtr->meta.TlvSize(), &offset);
+        cv.put(KEY_NXS_META, msgPtr->meta.TlvSize(), metaData);
+
+        cv.put(KEY_MSG_PARENT_ID, msgMetaPtr->mParentId);
+        cv.put(KEY_MSG_THREAD_ID, msgMetaPtr->mThreadId);
+        cv.put(KEY_MSG_NAME, msgMetaPtr->mMsgName);
+
+        // now local meta
+        cv.put(KEY_MSG_STATUS, (int32_t)msgMetaPtr->mMsgStatus);
+        cv.put(KEY_CHILD_TS, (int32_t)msgMetaPtr->mChildTs);
 
         offset = 0;
         char msgData[msgPtr->msg.TlvSize()];
@@ -276,58 +431,77 @@ int RsDataService::storeMessage(std::set<RsNxsMsg *> &msg){
         ostrm.write(msgData, msgPtr->msg.TlvSize());
         ostrm.close();
 
-
         mDb->sqlInsert(MSG_TABLE_NAME, "", cv);
     }
 
+    // finish transaction
     return mDb->execSQL("COMMIT;");;
 }
 
 
-int RsDataService::storeGroup(std::set<RsNxsGrp *> &grp){
-
-
-    std::set<RsNxsGrp*>::iterator sit = grp.begin();
+int RsDataService::storeGroup(std::map<RsNxsGrp *, RsGxsGrpMetaData *> &grp)
+{
+    std::map<RsNxsGrp*, RsGxsGrpMetaData* >::iterator sit = grp.begin();
 
+    // begin transaction
     mDb->execSQL("BEGIN;");
 
     for(; sit != grp.end(); sit++){
 
-        RsNxsGrp* grpPtr = *sit;
+        RsNxsGrp* grpPtr = sit->first;
+        RsGxsGrpMetaData* grpMetaPtr = sit->second;
 
         std::string grpFile = mServiceDir + "/" + grpPtr->grpId;
         std::fstream ostrm(grpFile.c_str(), std::ios::binary | std::ios::app | std::ios::out);
         ostrm.seekg(0, std::ios::end); // go to end to append
         uint32_t offset = ostrm.tellg(); // get fill offset
 
+        /*!
+         * STORE file offset, file length, file name,
+         * grpId, flags, publish time stamp, identity,
+         * id signature, admin signatue, key set, last posting ts
+         * and meta data
+         **/
         ContentValue cv;
         cv.put(KEY_NXS_FILE_OFFSET, (int32_t)offset);
         cv.put(KEY_NXS_FILE_LEN, (int32_t)grpPtr->grp.TlvSize());
         cv.put(KEY_NXS_FILE, grpFile);
-        cv.put(KEY_GRP_ID, grpPtr->grpId);
-        cv.put(KEY_NXS_FLAGS, (int32_t)grpPtr->grpFlag);
-        cv.put(KEY_TIME_STAMP, (int32_t)grpPtr->timeStamp);
+        cv.put(KEY_GRP_ID, grpMetaPtr->mGroupId);
+        cv.put(KEY_NXS_FLAGS, (int32_t)grpMetaPtr->mGroupFlags);
+        cv.put(KEY_TIME_STAMP, (int32_t)grpMetaPtr->mPublishTs);
 
-        if(! (grpPtr->identity.empty()) ){
-            cv.put(KEY_NXS_IDENTITY, grpPtr->identity);
+        if(! (grpMetaPtr->mAuthorId.empty()) ){
+            cv.put(KEY_NXS_IDENTITY, grpMetaPtr->mAuthorId);
 
-            char idSignData[grpPtr->idSign.TlvSize()];
+            char idSignData[grpMetaPtr->idSign.TlvSize()];
             offset = 0;
-            grpPtr->idSign.SetTlv(idSignData, grpPtr->idSign.TlvSize(), &offset);
-            cv.put(KEY_IDENTITY_SIGN, grpPtr->idSign.TlvSize(), idSignData);
-            std::string wat(idSignData, grpPtr->idSign.TlvSize());
+            grpMetaPtr->idSign.SetTlv(idSignData, grpMetaPtr->idSign.TlvSize(), &offset);
+            cv.put(KEY_IDENTITY_SIGN, grpMetaPtr->idSign.TlvSize(), idSignData);
+            std::string wat(idSignData, grpMetaPtr->idSign.TlvSize());
             std::cerr << wat << std::endl;
         }
 
-        char adminSignData[grpPtr->adminSign.TlvSize()];
+        char adminSignData[grpMetaPtr->adminSign.TlvSize()];
         offset = 0;
-        grpPtr->adminSign.SetTlv(adminSignData, grpPtr->adminSign.TlvSize(), &offset);
-        cv.put(KEY_ADMIN_SIGN, grpPtr->adminSign.TlvSize(), adminSignData);
+        grpMetaPtr->adminSign.SetTlv(adminSignData, grpMetaPtr->adminSign.TlvSize(), &offset);
+        cv.put(KEY_ADMIN_SIGN, grpMetaPtr->adminSign.TlvSize(), adminSignData);
 
         offset = 0;
-        char keySetData[grpPtr->keys.TlvSize()];
-        grpPtr->keys.SetTlv(keySetData, grpPtr->keys.TlvSize(), &offset);
-        cv.put(KEY_KEY_SET, grpPtr->keys.TlvSize(), keySetData);
+        char keySetData[grpMetaPtr->keys.TlvSize()];
+        grpMetaPtr->keys.SetTlv(keySetData, grpMetaPtr->keys.TlvSize(), &offset);
+        cv.put(KEY_KEY_SET, grpMetaPtr->keys.TlvSize(), keySetData);
+
+        offset = 0;
+        char metaData[grpPtr->meta.TlvSize()];
+        grpPtr->meta.SetTlv(metaData, grpPtr->meta.TlvSize(), &offset);
+        cv.put(KEY_NXS_META, grpPtr->meta.TlvSize(), metaData);
+
+        // local meta data
+        cv.put(KEY_GRP_SUBCR_FLAG, (int32_t)grpMetaPtr->mSubscribeFlags);
+        cv.put(KEY_GRP_POP, (int32_t)grpMetaPtr->mPop);
+        cv.put(KEY_MSG_COUNT, (int32_t)grpMetaPtr->mMsgCount);
+        cv.put(KEY_GRP_STATUS, (int32_t)grpMetaPtr->mGroupStatus);
+        cv.put(KEY_GRP_LAST_POST, (int32_t)grpMetaPtr->mLastPost);
 
         offset = 0;
         char grpData[grpPtr->grp.TlvSize()];
@@ -337,11 +511,11 @@ int RsDataService::storeGroup(std::set<RsNxsGrp *> &grp){
 
         mDb->sqlInsert(GRP_TABLE_NAME, "", cv);
     }
-
+    // finish transaction
     return mDb->execSQL("COMMIT;");
 }
 
-int RsDataService::retrieveGrps(std::map<std::string, RsNxsGrp*> &grp, bool cache){
+int RsDataService::retrieveNxsGrps(std::map<std::string, RsNxsGrp *> &grp, bool cache){
 
     RetroCursor* c = mDb->sqlQuery(GRP_TABLE_NAME, grpColumns, "", "");
 
@@ -353,19 +527,9 @@ int RsDataService::retrieveGrps(std::map<std::string, RsNxsGrp*> &grp, bool cach
             RsNxsGrp* g = getGroup(*c);
 
             // only add the latest grp info
-            if(g){
-                bool exists = grp.find(g->grpId) != grp.end();
-                if(exists){
-
-                    if(grp[g->grpId]->timeStamp < g->timeStamp){
-                        delete grp[g->grpId];
-                        grp[g->grpId] = g;
-                    }else{
-                        delete g;
-                    }
-                }else{
-                    grp[g->grpId] = g;
-                }
+            if(g)
+            {
+                grp[g->grpId] = g;
             }
             valid = c->moveToNext();
         }
@@ -377,111 +541,128 @@ int RsDataService::retrieveGrps(std::map<std::string, RsNxsGrp*> &grp, bool cach
     }
 }
 
-int RsDataService::retrieveMsgs(const std::string &grpId, std::map<std::string, RsNxsMsg *>& msg, bool cache){
+int RsDataService::retrieveNxsMsgs(const GxsMsgReq &reqIds, GxsMsgResult &msg, bool cache)
+{
 
-    RetroCursor* c = mDb->sqlQuery(MSG_TABLE_NAME, msgColumns, KEY_GRP_ID+ "='" + grpId + "'", "");
+    GxsMsgReq::const_iterator mit = reqIds.begin();
 
-    if(c){
+    for(; mit != reqIds.end(); mit++)
+    {
 
-        bool valid = c->moveToFirst();
-        while(valid){
-            RsNxsMsg* m = getMessage(*c);
+        const std::string& grpId = mit->first;
 
-            if(m){
-                // only add the latest grp info
-                bool exists = msg.find(m->msgId) != msg.end();
-                if(exists){
+        // if vector empty then request all messages
+        const std::set<std::string>& msgIdSet = mit->second;
+        std::vector<RsNxsMsg*> msgSet;
 
-                    if(msg[m->msgId]->timeStamp < m->timeStamp){
-                        delete msg[m->msgId];
-                        msg[m->msgId] = m;
-                    }else{
-                        delete m;
-                    }
-                }else{
-                    msg[m->msgId] = m;
-                }
+        if(msgIdSet.empty()){
+            RetroCursor* c = mDb->sqlQuery(MSG_TABLE_NAME, msgColumns, KEY_GRP_ID+ "='" + grpId + "'", "");
 
+            if(c)
+                retrieveMessages(c, msgSet);
+        }else{
 
+            // request each grp
+            std::set<std::string>::const_iterator sit = msgIdSet.begin();
+
+            for(; sit!=msgIdSet.end();sit++){
+                const std::string& msgId = *sit;
+                RetroCursor* c = mDb->sqlQuery(MSG_TABLE_NAME, msgColumns, KEY_GRP_ID+ "='" + grpId + "','" + msgId + "'", "");
+                retrieveMessages(c, msgSet);
             }
-            valid = c->moveToNext();
         }
 
-        delete c;
-        return 1;
-    }else{
-        return 0;
+        msg[grpId] = msgSet;
     }
 }
 
-int RsDataService::retrieveGrpVersions(const std::string &grpId, std::set<RsNxsGrp *> &grp, bool cache){
+void RsDataService::retrieveMessages(RetroCursor *c, std::vector<RsNxsMsg *> &msgs)
+{
+    bool valid = c->moveToFirst();
+    while(valid){
+        RsNxsMsg* m = getMessage(*c);
 
-    std::string selection = KEY_GRP_ID + "='" + grpId + "'";
-    RetroCursor* c = mDb->sqlQuery(GRP_TABLE_NAME, grpColumns, selection, "");
+        if(m){
+            msgs.push_back(m);;
+        }else{
+            delete m;
+        }
 
-    if(c){
+        valid = c->moveToNext();
+    }
+    return;
+}
 
+int RsDataService::retrieveGxsMsgMetaData(const std::vector<std::string> &grpIds, GxsMsgMetaResult &msgMeta)
+{
+    std::vector<std::string>::const_iterator vit = grpIds.begin();
+
+    for(; vit != grpIds.end(); vit++)
+    {
+        const std::string& grpId = *vit;
+
+        std::vector<RsGxsMsgMetaData*> meta;
+
+        RetroCursor* c = mDb->sqlQuery(MSG_TABLE_NAME, msgMetaColumns, "", KEY_GRP_ID+ "='" + grpId + "'");
+
+        if(c)
+        {
+            bool valid = c->moveToFirst();
+            while(valid){
+                RsGxsMsgMetaData* m = getMsgMeta(*c);
+
+                if(m){
+                    meta.push_back(m);
+                }else{
+                    delete m;
+                }
+                valid = c->moveToNext();
+            }
+
+            msgMeta[grpId] = meta;
+        }
+
+    }
+    return 1;
+}
+
+int RsDataService::retrieveGxsGrpMetaData(std::map<std::string, RsGxsGrpMetaData *>& grp)
+{
+    RetroCursor* c = mDb->sqlQuery(GRP_TABLE_NAME, grpMetaColumns, "", "");
+
+    if(c)
+    {
         bool valid = c->moveToFirst();
-        while(valid){
-            RsNxsGrp* g = getGroup(*c);
+
+        while(valid)
+        {
+            RsGxsGrpMetaData* g = getGrpMeta(*c);
 
             if(g)
-                grp.insert(g);
-
+            {
+                grp[g->mGroupId] = g;
+            }
             valid = c->moveToNext();
         }
-
-        delete c;
-        return 1;
-    }else{
-        return 0;
-    }
-}
-
-RsNxsGrp* RsDataService::retrieveGrpVersion(const RsGxsGrpId &grpId){
-
-    std::set<RsNxsGrp*> grps;
-    retrieveGrpVersions(grpId.grpId, grps, false);
-    RsNxsGrp* grp = NULL;
-
-    if(!grps.empty()){
-
-        // find grp with comparable sign
-        std::set<RsNxsGrp*>::iterator sit = grps.begin();
-
-        for(; sit != grps.end(); sit++){
-            grp = *sit;
-            if(!memcmp(grp->adminSign.signData.bin_data, grpId.adminSign.signData.bin_data,
-                      grpId.adminSign.signData.bin_len)){
-                break;
-            }
-            grp = NULL;
-        }
-
-        if(grp){
-            grps.erase(grp);
-            // release memory for non matching grps
-            for(sit = grps.begin(); sit != grps.end(); sit++)
-                delete *sit;
-        }
-
     }
 
-    return grp;
+    return 1;
 }
 
-
-int RsDataService::resetDataStore(){
+int RsDataService::resetDataStore()
+{
 
 #ifdef RS_DATA_SERVICE_DEBUG
     std::cerr << "resetDataStore() " << std::endl;
 #endif
 
     std::map<std::string, RsNxsGrp*> grps;
-    retrieveGrps(grps, false);
+
+    retrieveNxsGrps(grps, false);
     std::map<std::string, RsNxsGrp*>::iterator mit
             = grps.begin();
 
+    // remove all grp msgs files from service dir
     for(; mit != grps.end(); mit++){
         std::string file = mServiceDir + "/" + mit->first;
         std::string msgFile = file + "-msgs";
@@ -490,19 +671,33 @@ int RsDataService::resetDataStore(){
     }
 
     mDb->closeDb();
-    remove(mDbName.c_str());
+    remove(mDbName.c_str()); // remove db file
 
+    // recreate database
     initialise();
 
     return 1;
 }
 
-int RsDataService::removeGroups(const std::list<RsGxsGrpId> &grpIds){
+int RsDataService::removeGroups(const std::vector<std::string> &grpIds)
+{
 
     return 0;
 }
 
-int RsDataService::removeMsgs(const std::list<RsGxsMsgId> &msgIds){
+int RsDataService::updateGroupMetaData(GrpLocMetaData *meta)
+{
+    return 0;
+}
+
+int RsDataService::updateMessageMetaData(MsgLocMetaData *metaData)
+{
+    return 0;
+}
+
+
+int RsDataService::removeMsgs(const std::string grpId, const std::vector<std::string> &msgIds)
+{
     return 0;
 }
 
@@ -510,15 +705,8 @@ uint32_t RsDataService::cacheSize() const {
     return 0;
 }
 
-int RsDataService::setCacheSize(uint32_t size) {
+int RsDataService::setCacheSize(uint32_t size)
+{
     return 0;
 }
 
-int RsDataService::searchGrps(RsGxsSearch *search, std::list<RsGxsSrchResGrpCtx *> &result) {
-
-    return 0;
-}
-
-int RsDataService::searchMsgs(RsGxsSearch *search, std::list<RsGxsSrchResMsgCtx *> &result) {
-    return 0;
-}
diff --git a/libretroshare/src/gxs/rsdataservice.h b/libretroshare/src/gxs/rsdataservice.h
index 2a449cde3..e19167a43 100644
--- a/libretroshare/src/gxs/rsdataservice.h
+++ b/libretroshare/src/gxs/rsdataservice.h
@@ -13,67 +13,52 @@ public:
     virtual ~RsDataService();
 
     /*!
-     * Retrieves latest version of msgs for a service
-     * @param msgIds ids of messagesto retrieve
+     * Retrieves all msgs
+     * @param reqIds requested msg ids (grpId,msgId), leave msg list empty to get all msgs for the grp
      * @param msg result of msg retrieval
-     * @param cache whether to store retrieval in memory for faster later retrieval
+     * @param cache whether to store results of this retrieval in memory for faster later retrieval
      * @return error code
      */
-    int retrieveMsgs(const std::string& grpId, std::map<std::string, RsNxsMsg*>& msg, bool cache);
+    int retrieveNxsMsgs(const GxsMsgReq& reqIds, GxsMsgResult& msg, bool cache);
 
     /*!
-     * Retrieves latest version of groups for a service
-     * @param grpId the Id of the groups to retrieve
-     * @param grp results of retrieval
+     * Retrieves all groups stored (most current versions only)
+     * @param grp retrieved groups
      * @param cache whether to store retrieval in mem for faster later retrieval
      * @return error code
      */
-    int retrieveGrps(std::map<std::string, RsNxsGrp*>& grp, bool cache);
+    int retrieveNxsGrps(std::map<std::string, RsNxsGrp*>& grp, bool cache);
 
     /*!
-     * Retrieves all the versions of a group
-     * @param grpId the id of the group to get versions for
-     * @param cache whether to store the result in memory
-     * @return errCode
+     * Retrieves meta data of all groups stored (most current versions only)
+     * @param cache whether to store retrieval in mem for faster later retrieval
+     * @return error code
      */
-    int retrieveGrpVersions(const std::string &grpId, std::set<RsNxsGrp *> &grp, bool cache);
+    int retrieveGxsGrpMetaData(std::map<std::string, RsGxsGrpMetaData*>& grp);
 
     /*!
-     * @param grpId the id of the group to retrieve
-     * @return NULL if group does not exist or pointer to grp if found
+     * Retrieves meta data of all groups stored (most current versions only)
+     * @param grpIds grpIds for which to retrieve meta data
+     * @param msgMeta meta data result as map of grpIds to array of metadata for that grpId
+     * @param cache whether to store retrieval in mem for faster later retrieval
+     * @return error code
      */
-    RsNxsGrp* retrieveGrpVersion(const RsGxsGrpId& grpId);
+    int retrieveGxsMsgMetaData(const std::vector<std::string>& grpIds, GxsMsgMetaResult& msgMeta);
 
     /*!
-     * remove msgs in data store listed in msgIds param
+     * remove msgs in data store
+     * @param grpId group Id of message to be removed
      * @param msgIds ids of messages to be removed
      * @return error code
      */
-    int removeMsgs(const std::list<RsGxsMsgId>& msgIds);
+    int removeMsgs(const std::string grpId, const std::vector<std::string>& msgIds);
 
     /*!
      * remove groups in data store listed in grpIds param
      * @param grpIds ids of groups to be removed
      * @return error code
      */
-    int removeGroups(const std::list<RsGxsGrpId>& grpIds);
-
-
-    /*!
-     * allows for more complex queries specific to the service
-     * @param search generally stores parameters needed for query
-     * @param msgId is set with msg ids which satisfy the gxs search
-     * @return error code
-     */
-    int searchMsgs(RsGxsSearch* search, std::list<RsGxsSrchResMsgCtx*>& result);
-
-    /*!
-     * allows for more complex queries specific to the associated service
-     * @param search generally stores parameters needed for query
-     * @param msgId is set with msg ids which satisfy the gxs search
-     * @return error code
-     */
-    int searchGrps(RsGxsSearch* search, std::list<RsGxsSrchResGrpCtx*>& result);
+    int removeGroups(const std::vector<std::string>& grpIds);
 
     /*!
      * @return the cache size set for this RsGeneralDataService in bytes
@@ -83,43 +68,92 @@ public:
     /*!
      * @param size size of cache to set in bytes
      */
-    virtual int setCacheSize(uint32_t size);
+    int setCacheSize(uint32_t size);
 
     /*!
-     * Stores a list signed messages into data store
-     * @param msg list of signed messages to store
+     * Stores a list of signed messages into data store
+     * @param msg map of message and decoded meta data information
      * @return error code
      */
-    int storeMessage(std::set<RsNxsMsg*>& msg);
+    int storeMessage(std::map<RsNxsMsg*, RsGxsMsgMetaData*>& msg);
 
     /*!
      * Stores a list of groups in data store
-     * @param msg list of messages
+     * @param grp map of group and decoded meta data
      * @return error code
      */
-    int storeGroup(std::set<RsNxsGrp*>& grp);
+    int storeGroup(std::map<RsNxsGrp*, RsGxsGrpMetaData*>& grp);
+
+    /*!
+     * @param metaData The meta data item to update
+     * @return error code
+     */
+    int updateMessageMetaData(MsgLocMetaData* metaData);
+
+    /*!
+     * @param metaData The meta data item to update
+     * @return error code
+     */
+    int updateGroupMetaData(GrpLocMetaData* meta);
+
 
     /*!
      * Completely clear out data stored in
-     * this data store and returns this to a state
+     * and returns this to a state
      * as it was when first constructed
-     * This also clears any data store items created in service directory
+     * @return error code
      */
     int resetDataStore();
 
 private:
 
+    /*!
+     * Retrieves all the msg results from a cursor
+     * @param c cursor to result set
+     * @param msgs messages retrieved from cursor are stored here
+     */
+    void retrieveMessages(RetroCursor* c, std::vector<RsNxsMsg*>& msgs);
 
+    /*!
+     * extracts a msg meta item from a cursor at its
+     * current position
+     */
+    RsGxsMsgMetaData* getMsgMeta(RetroCursor& c);
+
+    /*!
+     * extracts a grp meta item from a cursor at its
+     * current position
+     */
+    RsGxsGrpMetaData* getGrpMeta(RetroCursor& c);
+
+    /*!
+     * extracts a msg item from a cursor at its
+     * current position
+     */
     RsNxsMsg* getMessage(RetroCursor& c);
+
+    /*!
+     * extracts a grp item from a cursor at its
+     * current position
+     */
     RsNxsGrp* getGroup(RetroCursor& c);
+
+    /*!
+     * Creates an sql database and its associated file
+     * also creates the message and groups table
+     */
     void initialise();
 
 private:
 
 
     RetroDb* mDb;
+
     std::list<std::string> msgColumns;
+    std::list<std::string> msgMetaColumns;
+
     std::list<std::string> grpColumns;
+    std::list<std::string> grpMetaColumns;
 
     std::string mServiceDir, mDbName;
     uint16_t mServType;
diff --git a/libretroshare/src/gxs/rsgds.h b/libretroshare/src/gxs/rsgds.h
index 976812842..687eeddd8 100644
--- a/libretroshare/src/gxs/rsgds.h
+++ b/libretroshare/src/gxs/rsgds.h
@@ -34,6 +34,7 @@
 
 #include "serialiser/rsgxsitems.h"
 #include "serialiser/rsnxsitems.h"
+#include "gxs/rsgxsdata.h"
 
 
 class RsGxsSearchModule  {
@@ -47,6 +48,17 @@ public:
 
 };
 
+class MsgLocMetaData {
+
+};
+
+class GrpLocMetaData {
+
+};
+
+typedef std::map<std::string, std::set<std::string> > GxsMsgReq; // <grpId, msgIds>
+typedef std::map<std::string, std::vector<RsNxsMsg*> > GxsMsgResult; // <grpId, msgs>
+typedef std::map<std::string, std::vector<RsGxsMsgMetaData*> > GxsMsgMetaResult; // <grpId, msg metadatas>
 
 /*!
  * The main role of GDS is the preparation and handing out of messages requested from
@@ -74,67 +86,54 @@ class RsGeneralDataService
 
 public:
 
-    virtual ~RsGeneralDataService(){return;};
-    /*!
-     * Retrieves signed message
-     * @param grpId
-     * @param msg result of msg retrieval
-     * @param cache whether to store retrieval in memory for faster later retrieval
-     * @return error code
-     */
-    virtual int retrieveMsgs(const std::string& grpId, std::map<std::string, RsNxsMsg*>& msg, bool cache) = 0;
+    virtual ~RsGeneralDataService(){return;}
 
     /*!
-     * Retrieves a group item by grpId
-     * @param grpId the Id of the groups to retrieve
-     * @param grp results of retrieval
+     * Retrieves all msgs
+     * @param reqIds requested msg ids (grpId,msgId), leave msg list empty to get all msgs for the grp
+     * @param msg result of msg retrieval
+     * @param cache whether to store results of this retrieval in memory for faster later retrieval
+     * @return error code
+     */
+    virtual int retrieveNxsMsgs(const GxsMsgReq& reqIds, GxsMsgResult& msg, bool cache) = 0;
+
+    /*!
+     * Retrieves all groups stored
+     * @param grp retrieved groups
      * @param cache whether to store retrieval in mem for faster later retrieval
      * @return error code
      */
-    virtual int retrieveGrps(std::map<std::string, RsNxsGrp*>& grp, bool cache) = 0;
+    virtual int retrieveNxsGrps(std::map<std::string, RsNxsGrp*>& grp, bool cache) = 0;
 
     /*!
-     * @param grpId the id of the group to get versions for
-     * @param cache whether to store the result in memory
-     * @param errCode
-     */
-    virtual int retrieveGrpVersions(const std::string& grpId, std::set<RsNxsGrp*>& grp, bool cache) = 0;
-
-    /*!
-     * @param grpId the id of the group to retrieve
-     * @return NULL if group does not exist or pointer to grp if found
-     */
-    virtual RsNxsGrp* retrieveGrpVersion(const RsGxsGrpId& grpId) = 0;
-
-    /*!
-     * allows for more complex queries specific to the service
-     * @param search generally stores parameters needed for query
-     * @param msgId is set with msg ids which satisfy the gxs search
+     * Retrieves meta data of all groups stored (most current versions only)
+     * @param cache whether to store retrieval in mem for faster later retrieval
      * @return error code
      */
-    virtual int searchMsgs(RsGxsSearch* search, std::list<RsGxsSrchResMsgCtx*>& result) = 0;
+    virtual int retrieveGxsGrpMetaData(std::map<std::string, RsGxsGrpMetaData*>& grp) = 0;
 
     /*!
-     * allows for more complex queries specific to the associated service
-     * @param search generally stores parameters needed for query
-     * @param msgId is set with msg ids which satisfy the gxs search
+     * Retrieves meta data of all groups stored (most current versions only)
+     * @param grpIds grpIds for which to retrieve meta data
+     * @param msgMeta meta data result as map of grpIds to array of metadata for that grpId
+     * @param cache whether to store retrieval in mem for faster later retrieval
      * @return error code
      */
-    virtual int searchGrps(RsGxsSearch* search, std::list<RsGxsSrchResGrpCtx*>& result) = 0;
+    virtual int retrieveGxsMsgMetaData(const std::vector<std::string>& grpIds, GxsMsgMetaResult& msgMeta) = 0;
 
     /*!
      * remove msgs in data store listed in msgIds param
      * @param msgIds ids of messages to be removed
      * @return error code
      */
-    virtual int removeMsgs(const std::list<RsGxsMsgId>& msgIds) = 0;
+    virtual int removeMsgs(const std::string grpId, const std::vector<std::string>& msgIds) = 0;
 
     /*!
      * remove groups in data store listed in grpIds param
      * @param grpIds ids of groups to be removed
      * @return error code
      */
-    virtual int removeGroups(const std::list<RsGxsGrpId>& grpIds) = 0;
+    virtual int removeGroups(const std::vector<std::string>& grpIds) = 0;
 
     /*!
      * @return the cache size set for this RsGeneralDataService in bytes
@@ -147,18 +146,29 @@ public:
     virtual int setCacheSize(uint32_t size) = 0;
 
     /*!
-     * Stores a list signed messages into data store
-     * @param msg list of signed messages to store
+     * Stores a list of signed messages into data store
+     * @param msg map of message and decoded meta data information
      * @return error code
      */
-    virtual int storeMessage(std::set<RsNxsMsg*>& msg) = 0;
+    virtual int storeMessage(std::map<RsNxsMsg*, RsGxsMsgMetaData*>& msg);
 
     /*!
      * Stores a list of groups in data store
-     * @param msg list of messages
+     * @param grp map of group and decoded meta data
      * @return error code
      */
-    virtual int storeGroup(std::set<RsNxsGrp*>& grp) = 0;
+    virtual int storeGroup(std::map<RsNxsGrp*, RsGxsGrpMetaData*>& grp);
+
+
+    /*!
+     * @param metaData
+     */
+    virtual int updateMessageMetaData(MsgLocMetaData* metaData) = 0;
+
+    /*!
+     * @param metaData
+     */
+    virtual int updateGroupMetaData(GrpLocMetaData* meta) = 0;
 
 
     /*!
diff --git a/libretroshare/src/gxs/rsgxs.h b/libretroshare/src/gxs/rsgxs.h
index 00f211fab..a772f13e1 100644
--- a/libretroshare/src/gxs/rsgxs.h
+++ b/libretroshare/src/gxs/rsgxs.h
@@ -50,6 +50,17 @@
 
 typedef uint64_t    RsGroupId ;
 
+class RsTokReqOptions
+{
+        public:
+        RsTokReqOptions() { mOptions = 0; mBefore = 0; mAfter = 0; }
+
+        uint32_t mOptions;
+        time_t   mBefore;
+        time_t   mAfter;
+};
+
+
 
 
 /*!
@@ -97,75 +108,37 @@ public:
     virtual uint16_t getServiceType() const = 0;
 
     /*!
-     * Request group, not intialising version member of RsGxsGrpId
-     * results in the latest version of groups being returned
-     * @return token for request
+     * Request group information
+     * @param token this initialised with a token that can be redeemed for this request
+     * @param ansType type of group result wanted, summary
+     * @param opts token options
+     * @param groupIds list of group ids wanted, leaving this empty will result in a request for only list of group ids for the service
+     * @return false if request failed, true otherwise
      * @see receiveGrp()
      */
-    int requestGrps();
+    bool requestGroupInfo(uint32_t &token, uint32_t ansType, const RsTokReqOptions &opts, const std::list<std::string> &groupIds);
 
     /*!
-     * Request group, not intialising version member of RsGxsGrpId
-     * results in the latest version of group being returned
-     * @return token for request
-     * @see receiveGrpList()
+     * Request message information for a list of groups
+     * @param token this initialised with a token that can be redeemed for this request
+     * @param ansType type of msg info result
+     * @param opts token options
+     * @param groupIds groups ids for which message info will be requested
+     * @return false if request failed, true otherwise
+     * @see receiveGrp()
      */
-    int requestSubscribedGrps();
+    virtual bool requestMsgInfo(uint32_t &token, uint32_t ansType, const RsTokReqOptions &opts, const std::list<std::string> &groupIds);
 
     /*!
-     * Request all versions of a group
-     * @param grpId group id to request version for
-     * @return token for request
+     * Request message information for a list of groups
+     * @param token this initialised with a token that can be redeemed for this request
+     * @param ansType type of msg info result
+     * @param opts token options
+     * @param groupIds groups ids for which message info will be requested
+     * @return false if request failed, true otherwise
+     * @see receiveGrp()
      */
-    int requestAllGrpVersions(const std::string& grpId);
-
-    /*!
-     * Event call back from Gxs runner
-     * after requested Grp(s) have been retrieved
-     * @param token the token to be redeemed
-     * @param errCode error code, can be exchanged for error string
-     * @param grps list of groups associated to request token
-     */
-    virtual void receiveGrp(int token, int errCode, std::set<RsGxsGroup*>& grps) = 0;
-
-
-    /*************** Start: Msg request receive API ********************/
-
-    /*  Messages a level below grps on the hiearchy hence group requests */
-    /*  are intrinsically linked to their grp Id                         */
-
-    /*!
-     * request latest version of messages for groups
-     * listed
-     * @param grpIds list of grpIds to get msgs for
-     * @return token for request
-     * @see receiveMsg()
-     */
-    int requestGrpMsgs(const std::list<std::string>& grpIds);
-
-    /*!
-     * request latest version of messages for group
-     * @param grpIds list of grpIds to get msgs for
-     * @return token for request
-     * @see receiveMsg()
-     */
-    int requestAllMsgVersions(const std::list<RsGxsMsgId>& msgIds);
-
-    /*!
-     *
-     *
-     */
-    int requestMsgVersion(const RsGxsMsgId& msgId);
-
-    /*!
-     * Event call back from GxsRunner
-     * after request msg(s) have been received
-     * @param token token to be redeemed
-     */
-    virtual void receiveMsg(int token, int errCode, std::set<RsGxsMsg*>& msgs) = 0;
-
-    /*************** End: Msg request receive API ********************/
-
+    bool requestMsgRelatedInfo(uint32_t &token, uint32_t ansType, const RsTokReqOptions &opts, const std::list<std::string> &msgIds);
 
     /*********** Start: publication *****************/
 
@@ -207,27 +180,6 @@ public:
 
     /*********** End: publication *****************/
 
-    /*************************************************************************/
-    // The main idea here is each RsGroup needs permission set for each RsGxsGroup
-    // Thus a
-    // This is a configuration thing.
-    /*************************************************************************/
-    /*********** Start: groups *****************/
-
-
-    /*!
-     * This says listed group can are only ones that can
-     * share grp/msgs between themselves for grpId
-     * Default behaviour on group sharing is share with between all peers
-     * @param rsGrpId list of group id sharing will be allowed
-     * @param grpId groupId that share behaviour is being set
-     * @return status token to be redeemed
-     */
-    int setShareGroup(const std::list<RsGroupId>& rsGrpId, const std::string grpId);
-
-    /*********** End: Identity control and groups *****************/
-
-
     /****************************************************************************************************/
     // Interface for Message Read Status
     // At the moment this is overloaded to handle autodownload flags too.
@@ -241,7 +193,7 @@ public:
      * @param GrpMsgMap flags this msg,version pair as read
      * @param read set to true for read and false for unread
      */
-    int flagMsgRead(const RsGxsMsgId& msgId, bool read) ;
+    int flagMsgRead(const std::string& msgId, bool read) ;
 
 
     /*!
@@ -266,32 +218,7 @@ public:
      * and not circulated. Entry will later be removed
      * once discard age is reached
      */
-    int requestDeleteGrp(const RsGxsGroup& grp);
-
-
-    /******************* Start: Configuration *************************/
-
-
-    /*!
-     * How long to keep subscribed groups
-     * @param length how long to keep group in seconds
-     */
-    int setSubscribedGroupDiscardAge(uint32_t length);
-
-    /*!
-     * How long to keep unsubscribed groups
-     * @param length how long to keep groups in seconds
-     * @return status token to be redeemed
-     * @see statusMsg()
-     */
-    int setUnsubscribedGrpDiscardAge(uint32_t length);
-
-    /*!
-     * How long to keep messages, group discard age supercedes this \n
-     * discard age
-     * @param length how long to keep messages in seconds
-     */
-    int setMsgDiscardAge(uint32_t length);
+     bool requestDeleteGrp(uint32_t& token, const RsGxsGroup& grp);
 
 
     /*!
@@ -300,7 +227,7 @@ public:
      * @param subscribe set to false to unsubscribe and true otherwise
      * @return token to redeem
      */
-    int requestSubscribeToGrp(const std::string& grpId, bool subscribe);
+    bool requestSubscribeToGrp(uint32_t token, const std::string& grpId, bool subscribe);
 
 public:
 
@@ -310,7 +237,7 @@ public:
      * @param errCode error code, can be exchanged for error string
      * @param gxsStatus the status of subscription request
      */
-    virtual void receiveSubscribeToGrp(int token, int errCode) = 0;
+    virtual void receiveSubscribeToGrp(int token, int errCode);
 
     /*!
      *
@@ -328,7 +255,7 @@ public:
      * have been updated or newly arrived
      * @param grpId ids of groups that have changed or newly arrived
      */
-    virtual void notifyGroupChanged(std::list<std::string> grpIds) = 0;
+    virtual void notifyGroupChanged(std::list<std::string> grpIds);
 
 
     /*!
@@ -336,108 +263,27 @@ public:
      * have been updated or newly arrived
      * @param msgId ids of msgs that have changed or newly arrived
      */
-    virtual void notifyMsgChanged(std::list<RsGxsMsgId> msgId) = 0;
+    virtual void notifyMsgChanged(std::list<std::string> msgId);
 
 
     /****************** End: Notifications from event runner ***************/
 
-
-    /****************** Start: Search from event runner ***************/
-
     // Users can either search groups or messages
 
-    /*!
-     * Users
-     * Some standard search terms are supported
-     * @param term this allows users to search their local storage defined terms
-     * @return token to redeem search
-     */
-    int requestLocalSearch(RsGxsSearch* term);
 
-    /*!
-     *
-     * @param token
-     * @param errCode error code, can be exchanged for error string
-     * @param grpIds list of grp ids
-     */
-    virtual void receiveLocalSearchGrps(int token, int errCode, std::list<RsGxsGroup*>& grps);
-
-    /*!
-     *
-     * @param token the request token to be redeemed
-     * @param errCode error code, can be exchanged for error string
-     * @param msgIds the message ids that contain contain search term
-     */
-    virtual void receiveLocalSearchMsgs(int token, int errCode, std::list<RsGxsMsg*> &msgs) = 0;
-
-    /*!
-     *
-     * @param token request token to be redeemed
-     * @param errCode error code, can be exchanged for error string
-     * @param grps
-     */
-    virtual void receiveRemoteSearchGrps(int token, int errCode, std::list<RsGxsGroup*>& grps) = 0;
-
-    /*!
-     *
-     * @param token the request token to be redeemed
-     * @param errCode error code, can be exchanged for error string
-     * @param msgIds
-     */
-    virtual void recieveRemoteSearchMsgs(int token, int errCode, std::list<RsGxsMsg*>& msgs) = 0;
-
-    /* the following are protected to prevent RsGxsNetService calling below
-     * and causing infinite recursion
-     */
-
-    // Remote Search...(2 hops ?)
-    /*!
-     *
-     * @param term This contains the search term
-     * @param hops how many hops from your immediate peer on the network for search
-     * @param delay lenght of time search should persist (if you are online search will be saved \n
-     *        delay seconds, max is 2 days
-     * @return token to redeem search
-     */
-    int requestRemoteSearchGrps(RsGxsSearch* term, uint32_t hops, uint32_t delay, bool immediate);
-
-    // Remote Search...(2 hops ?)
-    /*!
-     *
-     * @param term This contains the search term
-     * @param hops how many hops from your immediate peer on the network for search
-     * @param delay lenght of time search should persist (if you are online search will be saved \n
-     *        delay seconds, max is 2 days
-     * @return token to redeem search
-     */
-    int requestRemoteSearchMsgs(RsGxsSearch* term, uint32_t hops, uint32_t delay, bool immediate);
+    /* Generic Lists */
+    bool getGroupList(const uint32_t &token, std::list<std::string> &groupIds);
+    bool getMsgList(const uint32_t &token, std::list<std::string> &msgIds);
 
 
-    /*!
-     * Note if parent group is not present this will be requested \n
-     * by the event runner
-     * @param msgIds the ids of the remote messages being requested
-     * @return token to be redeemed
-     * @see receiveMsg()
-     */
-    int requestRemoteMsg(std::list<RsGxsMsgId>& msgIds);
 
-    /*!
-     * @param grpIds the ids of the group being requested
-     * @return token to be redeemed
-     * @see receiveGrp()
-     */
-    int requestRemoteGrp(std::list<RsGxsGrpId>& grpIds);
+    /* Poll */
+    uint32_t requestStatus(const uint32_t token);
 
-    /****************** End: Search from event runner ***************/
+    /* Cancel Request */
+    bool cancelRequest(const uint32_t &token);
 
-    /*!
-     * @param msgIds ids of messages to be deleted
-     * @return token to be redeemed
-     */
-    virtual int deleteRemoteMsg(std::list<RsGxsMsgId>& msgIds);
-
-    virtual int deleteRemoteGrp(std::list<RsGxsGrpId>& grpIds);
+    bool groupShareKeys(const std::string &groupId, std::list<std::string>& peers);
 };
 
 #endif // RSGXS_H
diff --git a/libretroshare/src/gxs/rsgxsdata.cc b/libretroshare/src/gxs/rsgxsdata.cc
new file mode 100644
index 000000000..3da3f6106
--- /dev/null
+++ b/libretroshare/src/gxs/rsgxsdata.cc
@@ -0,0 +1,176 @@
+
+#include "rsgxsdata.h"
+#include "serialiser/rsbaseserial.h"
+
+RsGxsGrpMetaData::RsGxsGrpMetaData()
+{
+
+}
+
+uint32_t RsGxsGrpMetaData::serial_size()
+{
+    uint32_t s = 8; // header size
+
+    s += GetTlvStringSize(mGroupId);
+    s += GetTlvStringSize(mOrigGrpId);
+    s += GetTlvStringSize(mGroupName);
+    s += 4;
+    s += 4;
+    s += GetTlvStringSize(mAuthorId);
+    s += adminSign.TlvSize();
+    s += keys.TlvSize();
+    s += idSign.TlvSize();
+
+    return s;
+}
+
+bool RsGxsGrpMetaData::serialise(void *data, uint32_t &pktsize)
+{
+
+    uint32_t tlvsize = serial_size() ;
+    uint32_t offset = 0;
+
+    if (pktsize < tlvsize)
+            return false; /* not enough space */
+
+    pktsize = tlvsize;
+
+    bool ok = true;
+
+    ok &= setRsItemHeader(data, tlvsize, 0, tlvsize);
+
+#ifdef GXS_DEBUG
+    std::cerr << "RsGxsGrpMetaData serialise()" << std::endl;
+    std::cerr << "RsGxsGrpMetaData serialise(): Header: " << ok << std::endl;
+    std::cerr << "RsGxsGrpMetaData serialise(): Size: " << tlvsize << std::endl;
+#endif
+
+    /* skip header */
+    offset += 8;
+
+    ok &= SetTlvString(data, tlvsize, &offset, 0, mGroupId);
+    ok &= SetTlvString(data, tlvsize, &offset, 0, mOrigGrpId);
+    ok &= SetTlvString(data, tlvsize, &offset, 0, mGroupName);
+    ok &= setRawUInt32(data, tlvsize, &offset, mGroupFlags);
+    ok &= setRawUInt32(data, tlvsize, &offset, mPublishTs);
+    ok &= SetTlvString(data, tlvsize, &offset, 0, mAuthorId);
+
+    ok &= adminSign.SetTlv(data, tlvsize, &offset);
+    ok &= keys.SetTlv(data, tlvsize, &offset);
+    ok &= idSign.SetTlv(data, tlvsize, &offset);
+
+    return ok;
+}
+
+bool RsGxsGrpMetaData::deserialise(void *data, uint32_t &pktsize)
+{
+
+    uint32_t offset = 8; // skip the header
+    uint32_t rssize = getRsItemSize(data);
+
+    bool ok = true ;
+
+    ok &= rssize != pktsize;
+
+    if(!ok) return false;
+
+    ok &= GetTlvString(data, pktsize, &offset, 0, mGroupId);
+    ok &= GetTlvString(data, pktsize, &offset, 0, mOrigGrpId);
+    ok &= GetTlvString(data, pktsize, &offset, 0, mOrigGrpId);
+    ok &= getRawUInt32(data, pktsize, &offset, &mGroupFlags);
+    ok &= getRawUInt32(data, pktsize, &offset, &mPublishTs);
+    ok &= GetTlvString(data, pktsize, &offset, 0, mAuthorId);
+
+    ok &= adminSign.GetTlv(data, pktsize, &offset);
+    ok &= keys.SetTlv(data, pktsize, &offset);
+    ok &= idSign.SetTlv(data, pktsize, &offset);
+
+    return ok;
+}
+
+uint32_t RsGxsMsgMetaData::serial_size()
+{
+
+    uint32_t s = 8; // header size
+
+    s += GetTlvStringSize(mGroupId);
+    s += GetTlvStringSize(mMsgId);
+    s += GetTlvStringSize(mThreadId);
+    s += GetTlvStringSize(mParentId);
+    s += GetTlvStringSize(mOrigMsgId);
+
+    s += pubSign.TlvSize();
+    s += idSign.TlvSize();
+    s += GetTlvStringSize(mMsgName);
+    s += 4;
+    s += 4;
+
+    return s;
+}
+
+bool RsGxsMsgMetaData::serialise(void *data, uint32_t *size)
+{
+    uint32_t tlvsize = serial_size() ;
+    uint32_t offset = 0;
+
+    if (*size < tlvsize)
+            return false; /* not enough space */
+
+    *size = tlvsize;
+
+    bool ok = true;
+
+    ok &= setRsItemHeader(data, tlvsize, 0, tlvsize);
+
+#ifdef GXS_DEBUG
+    std::cerr << "RsGxsGrpMetaData serialise()" << std::endl;
+    std::cerr << "RsGxsGrpMetaData serialise(): Header: " << ok << std::endl;
+    std::cerr << "RsGxsGrpMetaData serialise(): Size: " << tlvsize << std::endl;
+#endif
+
+    /* skip header */
+    offset += 8;
+
+    ok &= SetTlvString(data, *size, &offset, 0, mGroupId);
+    ok &= SetTlvString(data, *size, &offset, 0, mMsgId);
+    ok &= SetTlvString(data, *size, &offset, 0, mThreadId);
+    ok &= SetTlvString(data, *size, &offset, 0, mParentId);
+    ok &= SetTlvString(data, *size, &offset, 0, mOrigMsgId);
+
+    ok &= pubSign.SetTlv(data, *size, &offset);
+    ok &= idSign.SetTlv(data, *size, &offset);
+    ok &= SetTlvString(data, *size, &offset, 0, mMsgName);
+    ok &= setRawUInt32(data, *size, &offset, mPublishTs);
+    ok &= setRawUInt32(data, *size, &offset, mMsgFlags);
+
+    return ok;
+}
+
+
+bool RsGxsMsgMetaData::deserialise(void *data, uint32_t *size)
+{
+    uint32_t offset = 8; // skip the header
+    uint32_t rssize = getRsItemSize(data);
+
+    bool ok = true ;
+
+    ok &= rssize != *size;
+
+    if(!ok) return false;
+
+    ok &= GetTlvString(data, *size, &offset, 0, mGroupId);
+    ok &= GetTlvString(data, *size, &offset, 0, mMsgId);
+    ok &= GetTlvString(data, *size, &offset, 0, mThreadId);
+    ok &= GetTlvString(data, *size, &offset, 0, mParentId);
+    ok &= GetTlvString(data, *size, &offset, 0, mOrigMsgId);
+
+    ok &= pubSign.GetTlv(data, *size, &offset);
+    ok &= idSign.GetTlv(data, *size, &offset);
+    ok &= GetTlvString(data, *size, &offset, 0, mMsgName);
+    uint32_t t;
+    ok &= getRawUInt32(data, *size, &offset, &t);
+    mPublishTs = t;
+    ok &= getRawUInt32(data, *size, &offset, &mMsgFlags);
+
+    return ok;
+}
diff --git a/libretroshare/src/gxs/rsgxsdata.h b/libretroshare/src/gxs/rsgxsdata.h
new file mode 100644
index 000000000..c2918b33f
--- /dev/null
+++ b/libretroshare/src/gxs/rsgxsdata.h
@@ -0,0 +1,85 @@
+#ifndef RSGXSMETA_H
+#define RSGXSMETA_H
+
+#include <string>
+
+#include "serialiser/rsserial.h"
+#include "serialiser/rstlvbase.h"
+#include "serialiser/rstlvtypes.h"
+#include "serialiser/rstlvkeys.h"
+
+class RsGxsGrpMetaData
+{
+public:
+
+    RsGxsGrpMetaData();
+    bool deserialise(void *data, uint32_t &pktsize);
+    bool serialise(void* data, uint32_t &pktsize);
+    uint32_t serial_size();
+
+
+    std::string mGroupId;
+    std::string mOrigGrpId;
+    std::string mGroupName;
+    uint32_t    mGroupFlags;
+    uint32_t    mPublishTs;
+    std::string mAuthorId;
+
+
+    RsTlvKeySignature adminSign;
+    RsTlvSecurityKeySet keys;
+    RsTlvKeySignature idSign;
+
+
+
+    // BELOW HERE IS LOCAL DATA, THAT IS NOT FROM MSG.
+
+    uint32_t    mSubscribeFlags;
+
+    uint32_t    mPop; // HOW DO WE DO THIS NOW.
+    uint32_t    mMsgCount; // ???
+    time_t      mLastPost; // ???
+
+    uint32_t    mGroupStatus;
+
+};
+
+
+
+
+class RsGxsMsgMetaData
+{
+public:
+
+    RsGxsMsgMetaData();
+    bool deserialise(void *data, uint32_t *size);
+    bool serialise(void* data, uint32_t *size);
+    uint32_t serial_size();
+
+    std::string mGroupId;
+    std::string mMsgId;
+
+    std::string mThreadId;
+    std::string mParentId;
+    std::string mOrigMsgId;
+    std::string mAuthorId;
+
+    RsTlvKeySignature pubSign;
+    RsTlvKeySignature idSign;
+
+    std::string mMsgName;
+    time_t      mPublishTs;
+    uint32_t    mMsgFlags; // Whats this for?
+
+    // BELOW HERE IS LOCAL DATA, THAT IS NOT FROM MSG.
+    // normally READ / UNREAD flags. LOCAL Data.
+    uint32_t    mMsgStatus;
+    time_t      mChildTs;
+
+};
+
+
+
+
+
+#endif // RSGXSMETA_H
diff --git a/libretroshare/src/gxs/rsgxsnetservice.cc b/libretroshare/src/gxs/rsgxsnetservice.cc
index 57a8b18d8..fe19323c9 100644
--- a/libretroshare/src/gxs/rsgxsnetservice.cc
+++ b/libretroshare/src/gxs/rsgxsnetservice.cc
@@ -415,6 +415,7 @@ void RsGxsNetService::genReqMsgTransaction(NxsTransaction* tr)
 
 	std::list<RsNxsItem*>::iterator lit = tr->mItems.begin();
 
+        // first get item list sent from transaction
 	for(; lit != tr->mItems.end(); lit++)
 	{
 		RsNxsSyncMsgItem* item = dynamic_cast<RsNxsSyncMsgItem*>(*lit);
@@ -424,7 +425,7 @@ void RsGxsNetService::genReqMsgTransaction(NxsTransaction* tr)
 		}else
 		{
 #ifdef NXS_NET_DEBUG
-			std::cerr << "RsGxsNetService::genReqMsgTransaction(): item failed to caste to RsNxsSyncMsgItem* "
+                        std::cerr << "RsGxsNetService::genReqMsgTransaction(): item failed cast to RsNxsSyncMsgItem* "
 					  << std::endl;
 #endif
 			delete item;
@@ -432,22 +433,36 @@ void RsGxsNetService::genReqMsgTransaction(NxsTransaction* tr)
 		}
 	}
 
-	RsNxsSyncMsgItem* item = msgItemL.front();
-	const std::string& grpId = item->grpId;
-	std::map<std::string, RsNxsMsg*> msgMap;
-	mDataStore->retrieveMsgs(grpId, msgMap, false);
 
-	// now do compare and add loop
-	std::list<RsNxsSyncMsgItem*>::iterator llit = msgItemL.begin();
-	std::list<RsNxsItem*> reqList;
+        // get grp id for this transaction
+        RsNxsSyncMsgItem* item = msgItemL.front();
+        const std::string& grpId = item->grpId;
+        std::vector<std::string> grpIdV;
+        grpIdV.push_back(grpId);
+        GxsMsgMetaResult result;
+        mDataStore->retrieveGxsMsgMetaData(grpIdV, result);
+        std::vector<RsGxsMsgMetaData*> &msgMetaV = result[grpId];
 
+        std::vector<RsGxsMsgMetaData*>::const_iterator vit = msgMetaV.begin();
+        std::set<std::string> msgIdSet;
+
+        // put ids in set for each searching
+        for(; vit != msgMetaV.end(); vit++)
+            msgIdSet.insert((*vit)->mMsgId);
+
+        // get unique id for this transaction
 	uint32_t transN = getTransactionId();
 
+
+        // now do compare and add loop
+        std::list<RsNxsSyncMsgItem*>::iterator llit = msgItemL.begin();
+        std::list<RsNxsItem*> reqList;
+
 	for(; llit != msgItemL.end(); llit++)
 	{
 		const std::string& msgId = (*llit)->msgId;
 
-		if(msgMap.find(msgId) == msgMap.end()){
+                if(msgIdSet.find(msgId) == msgIdSet.end()){
 			RsNxsSyncMsgItem* msgItem = new RsNxsSyncMsgItem(mServType);
 			msgItem->grpId = grpId;
 			msgItem->msgId = msgId;
@@ -506,8 +521,8 @@ void RsGxsNetService::genReqGrpTransaction(NxsTransaction* tr)
 
 	RsNxsSyncGrpItem* item = grpItemL.front();
 	const std::string& grpId = item->grpId;
-	std::map<std::string, RsNxsGrp*> grpMap;
-	mDataStore->retrieveGrps(grpMap, false);
+        std::map<std::string, RsGxsGrpMetaData*> grpMetaMap;
+        mDataStore->retrieveGxsGrpMetaData(grpMetaMap);
 
 	// now do compare and add loop
 	std::list<RsNxsSyncGrpItem*>::iterator llit = grpItemL.begin();
@@ -519,7 +534,7 @@ void RsGxsNetService::genReqGrpTransaction(NxsTransaction* tr)
 	{
 		const std::string& grpId = (*llit)->grpId;
 
-		if(grpMap.find(grpId) == grpMap.end()){
+                if(grpMetaMap.find(grpId) == grpMetaMap.end()){
 			RsNxsSyncGrpItem* grpItem = new RsNxsSyncGrpItem(mServType);
 
 			grpItem->grpId = grpId;
diff --git a/libretroshare/src/gxs/rsgxsnetservice.h b/libretroshare/src/gxs/rsgxsnetservice.h
index cad742679..048d52e37 100644
--- a/libretroshare/src/gxs/rsgxsnetservice.h
+++ b/libretroshare/src/gxs/rsgxsnetservice.h
@@ -111,7 +111,7 @@ public:
      * @param peerId Id of peer
      * @param grpId id of group to request messages for
      */
-    void requestMessagesOfPeer(const std::string& peerId, const RsGxsGrpId& grpId){ return; }
+    void requestMessagesOfPeer(const std::string& peerId, const std::string& grpId){ return; }
 
     /*!
      * Initiates a search through the network
@@ -154,7 +154,7 @@ public:
      * @param enabled set to false to disable pause, and true otherwise
      * @return request token to be redeemed
      */
-    int requestGrp(const std::list<RsGxsGrpId>& grpId, uint8_t hops){ return 0;}
+    int requestGrp(const std::list<std::string>& grpId, uint8_t hops){ return 0;}
 
 
 
diff --git a/libretroshare/src/gxs/rsnxs.h b/libretroshare/src/gxs/rsnxs.h
index ffaa414e1..7a877ce1b 100644
--- a/libretroshare/src/gxs/rsnxs.h
+++ b/libretroshare/src/gxs/rsnxs.h
@@ -81,7 +81,7 @@ public:
      * @param peerId Id of peer
      * @param grpId id of group to request messages for
      */
-    virtual void requestMessagesOfPeer(const std::string& peerId, const RsGxsGrpId& grpId) = 0;
+    virtual void requestMessagesOfPeer(const std::string& peerId, const std::string& grpId) = 0;
 
     /*!
      * Initiates a search through the network
@@ -124,7 +124,7 @@ public:
      * @param enabled set to false to disable pause, and true otherwise
      * @return request token to be redeemed
      */
-    virtual int requestGrp(const std::list<RsGxsGrpId>& grpId, uint8_t hops) = 0;
+    virtual int requestGrp(const std::list<std::string>& grpId, uint8_t hops) = 0;
 
 
 };
diff --git a/libretroshare/src/libretroshare.pro b/libretroshare/src/libretroshare.pro
index 461020aae..5bbc5d387 100644
--- a/libretroshare/src/libretroshare.pro
+++ b/libretroshare/src/libretroshare.pro
@@ -157,11 +157,9 @@ PUBLIC_HEADERS =	retroshare/rsblogs.h \
 					retroshare/rsconfig.h
 
 HEADERS += plugins/pluginmanager.h \
-				plugins/dlfcn_win32.h \
-                                serialiser/rspluginitems.h \
-    gxs/rsdataservice.h \
-    gxs/rsgxsflags.h \
-    gxs/rsgenexchange.h
+        plugins/dlfcn_win32.h \
+        serialiser/rspluginitems.h \
+    gxs/rsgxsdata.h
 
 
 HEADERS += $$PUBLIC_HEADERS
@@ -666,8 +664,12 @@ newcache {
 HEADERS += serialiser/rsnxsitems.h \
             gxs/rsgds.h \
             gxs/rsgxs.h \
-            gxs/rsdataservice/h \
-            gxs/rsgxsnetservice.h
+            gxs/rsdataservice.h \
+            gxs/rsgxsnetservice.h \
+            gxs/rsgxsflags.h \
+            gxs/rsgenexchange.h \
+            gxs/rsgenexchange.h \
+            gxs/rsnxsobserver.h
 
 SOURCES += serialiser/rsnxsitems.cc \
                 gxs/rsdataservice.cc \
@@ -703,4 +705,9 @@ SOURCES += services/p3photoservice.cc \
 #	rsserver/p3photo.cc \
 }
 
+SOURCES += \
 
+SOURCES +=
+
+SOURCES += \
+    gxs/rsgxsdata.cc
diff --git a/libretroshare/src/serialiser/rsgxsitems.h b/libretroshare/src/serialiser/rsgxsitems.h
index 172411526..08bb3ba9b 100644
--- a/libretroshare/src/serialiser/rsgxsitems.h
+++ b/libretroshare/src/serialiser/rsgxsitems.h
@@ -34,6 +34,7 @@
 #include "serialiser/rstlvbase.h"
 #include "serialiser/rstlvtypes.h"
 #include "serialiser/rstlvkeys.h"
+#include "gxs/rsgxsdata.h"
 
 
 
@@ -50,26 +51,8 @@ public:
     RsGxsMsg() : RsItem(0) {}
     virtual ~RsGxsMsg(){ return; }
 
-
-    /***** Don not serialise or set these members *****/
-
-    std::string grpId; /// group id
-    std::string msgId; /// message id
-    uint32_t timeStamp; /// UTC time when created
-    std::string identity; /// identity associated with (no id means no signed)
-
-    /*!
-     * The purpose of the flag is to note
-     * If this message is an edit (note that edits only applies to
-     * signed msgs)
-     */
-    uint32_t msgFlag;
-
-    /***** Don not serialise or set these members *****/
-
 };
 
-
 /*!
  * Base class used by client API
  * for groups.
@@ -82,8 +65,6 @@ class RsGxsGroup : public RsItem
 
 public:
 
-
-
     /*** type of msgs ***/
 
     RsGxsGroup(uint16_t servtype, uint8_t subtype)
@@ -91,13 +72,6 @@ public:
 
     virtual ~RsGxsGroup() { return; }
 
-
-    std::string grpId; /// group id
-    std::string identity; /// identity associated with group
-    uint32_t timeStamp; /// UTC time
-    bool subscribed;
-    bool read;
-
     /*!
      * Three thing flag represents:
      * Is it signed by identity?
diff --git a/libretroshare/src/serialiser/rsnxsitems.cc b/libretroshare/src/serialiser/rsnxsitems.cc
index b1c1969a3..06150bef5 100644
--- a/libretroshare/src/serialiser/rsnxsitems.cc
+++ b/libretroshare/src/serialiser/rsnxsitems.cc
@@ -232,14 +232,9 @@ bool RsNxsSerialiser::serialiseNxsMsg(RsNxsMsg *item, void *data, uint32_t *size
 
     ok &= setRawUInt32(data, *size, &offset, item->transactionNumber);
     ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_MSGID, item->msgId);
-    ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_MSGID, item->originalMsgId);
     ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_GROUPID, item->grpId);
-    ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_NAME, item->identity);
-    ok &= setRawUInt32(data, tlvsize, &offset, item->timeStamp);
-    ok &= setRawUInt32(data, tlvsize, &offset, item->msgFlag);
-    ok &= item->idSign.SetTlv(data, tlvsize, &offset);
-    ok &= item->publishSign.SetTlv(data, tlvsize, &offset);
     ok &= item->msg.SetTlv(data, tlvsize, &offset);
+    ok &= item->meta.SetTlv(data, *size, &offset);
 
 
     if(offset != tlvsize){
@@ -288,13 +283,8 @@ bool RsNxsSerialiser::serialiseNxsGrp(RsNxsGrp *item, void *data, uint32_t *size
     // grp id
     ok &= setRawUInt32(data, *size, &offset, item->transactionNumber);
     ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_GROUPID, item->grpId);
-    ok &= SetTlvString(data, tlvsize, &offset, TLV_TYPE_STR_NAME, item->identity);
-    ok &= setRawUInt32(data, tlvsize, &offset, item->grpFlag);
-    ok &= setRawUInt32(data, tlvsize, &offset, item->timeStamp);
-    ok &= item->idSign.SetTlv(data, tlvsize, &offset);
-    ok &= item->adminSign.SetTlv(data, tlvsize, &offset);
-    ok &= item->keys.SetTlv(data, tlvsize, &offset);
     ok &= item->grp.SetTlv(data, tlvsize, &offset);
+    ok &= item->meta.SetTlv(data, *size, &offset);
 
     if(offset != tlvsize){
 #ifdef RSSERIAL_DEBUG
@@ -422,7 +412,7 @@ bool RsNxsSerialiser::serialiseNxsSyncGrpItem(RsNxsSyncGrpItem *item, void *data
 
     if(*size < tlvsize){
 #ifdef RSSERIAL_DEBUG
-        std::cerr << "RsNxsSerialiser::serialiseNxsSyncGrpItem() size do not match" << std::endl;
+        std::cerr << "RsNxsSerialiser::serialiseNxsSyncm() size do not match" << std::endl;
 #endif
         return false;
     }
@@ -436,16 +426,16 @@ bool RsNxsSerialiser::serialiseNxsSyncGrpItem(RsNxsSyncGrpItem *item, void *data
     /* skip the header */
     offset += 8;
 
-    /* RsNxsSyncGrpItem */
+    /* RsNxsSyncm */
 
     ok &= setRawUInt32(data, *size, &offset, item->transactionNumber);
     ok &= setRawUInt8(data, *size, &offset, item->flag);
     ok &= SetTlvString(data, *size, &offset, TLV_TYPE_STR_GROUPID, item->grpId);
-    ok &= item->adminSign.SetTlv(data, *size, &offset);
+    ok &= setRawUInt32(data, *size, &offset, item->publishTs);
 
     if(offset != tlvsize){
 #ifdef RSSERIAL_DEBUG
-        std::cerr << "RsNxsSerialiser::serialiseNxsSyncGrpItem( FAIL Size Error! " << std::endl;
+        std::cerr << "RsNxsSerialiser::serialiseNxsSyncm( FAIL Size Error! " << std::endl;
 #endif
         ok = false;
     }
@@ -453,7 +443,7 @@ bool RsNxsSerialiser::serialiseNxsSyncGrpItem(RsNxsSyncGrpItem *item, void *data
 #ifdef RSSERIAL_DEBUG
     if (!ok)
     {
-        std::cerr << "RsNxsSerialiser::serialiseNxsSyncGrpItem() NOK" << std::endl;
+        std::cerr << "RsNxsSerialiser::serialiseNxsSyncm() NOK" << std::endl;
     }
 #endif
 
@@ -558,13 +548,8 @@ RsNxsGrp* RsNxsSerialiser::deserialNxsGrp(void *data, uint32_t *size){
 
     ok &= getRawUInt32(data, *size, &offset, &(item->transactionNumber));
     ok &= GetTlvString(data, *size, &offset, TLV_TYPE_STR_GROUPID, item->grpId);
-    ok &= GetTlvString(data, *size, &offset, TLV_TYPE_STR_NAME, item->identity);
-    ok &= getRawUInt32(data, *size, &offset, &(item->grpFlag));
-    ok &= getRawUInt32(data, *size, &offset, &(item->timeStamp));
-    ok &= item->idSign.GetTlv(data, *size, &offset);
-    ok &= item->adminSign.GetTlv(data, *size, &offset);
-    ok &= item->keys.GetTlv(data, *size, &offset);
     ok &= item->grp.GetTlv(data, *size, &offset);
+    ok &= item->meta.GetTlv(data, *size, &offset);
 
     if (offset != rssize)
     {
@@ -631,14 +616,9 @@ RsNxsMsg* RsNxsSerialiser::deserialNxsMsg(void *data, uint32_t *size){
 
     ok &= getRawUInt32(data, *size, &offset, &(item->transactionNumber));
     ok &= GetTlvString(data, *size, &offset, TLV_TYPE_STR_MSGID, item->msgId);
-    ok &= GetTlvString(data, *size, &offset, TLV_TYPE_STR_MSGID, item->originalMsgId);
     ok &= GetTlvString(data, *size, &offset, TLV_TYPE_STR_GROUPID, item->grpId);
-    ok &= GetTlvString(data, *size, &offset, TLV_TYPE_STR_NAME, item->identity);
-    ok &= getRawUInt32(data, *size, &offset, &(item->timeStamp));
-    ok &= getRawUInt32(data, *size, &offset, &(item->msgFlag));
-    ok &= item->idSign.GetTlv(data, *size, &offset);
-    ok &= item->publishSign.GetTlv(data, *size, &offset);
-    ok &= item->msg.GetTlv(data, *size, &offset);;
+    ok &= item->msg.GetTlv(data, *size, &offset);
+    ok &= item->meta.GetTlv(data, *size, &offset);
 
     if (offset != rssize)
     {
@@ -772,7 +752,7 @@ RsNxsSyncGrpItem* RsNxsSerialiser::deserialNxsSyncGrpItem(void *data, uint32_t *
     ok &= getRawUInt32(data, *size, &offset, &(item->transactionNumber));
     ok &= getRawUInt8(data, *size, &offset, &(item->flag));
     ok &= GetTlvString(data, *size, &offset, TLV_TYPE_STR_GROUPID, item->grpId);
-    ok &= item->adminSign.GetTlv(data, *size, &offset);
+    ok &= getRawUInt32(data, *size, &offset, &(item->publishTs));
 
     if (offset != rssize)
     {
@@ -1020,13 +1000,8 @@ uint32_t RsNxsSerialiser::sizeNxsMsg(RsNxsMsg *item)
     s += 4; // transaction number
     s += GetTlvStringSize(item->grpId);
     s += GetTlvStringSize(item->msgId);
-    s += GetTlvStringSize(item->identity);
-    s += GetTlvStringSize(item->originalMsgId);
-    s += 4; // msgFlag
-    s += 4; // timeStamp
-    s += item->publishSign.TlvSize();
-    s += item->idSign.TlvSize();
     s += item->msg.TlvSize();
+    s += item->meta.TlvSize();
 
     return s;
 }
@@ -1037,13 +1012,8 @@ uint32_t RsNxsSerialiser::sizeNxsGrp(RsNxsGrp *item)
 
     s += 4; // transaction number
     s += GetTlvStringSize(item->grpId);
-    s += GetTlvStringSize(item->identity);
-    s += 4; // grpFlag
-    s += 4; // timestamp
-    s += item->adminSign.TlvSize();
-    s += item->idSign.TlvSize();
-    s += item->keys.TlvSize();
     s += item->grp.TlvSize();
+    s += item->meta.TlvSize();
 
     return s;
 }
@@ -1067,9 +1037,9 @@ uint32_t RsNxsSerialiser::sizeNxsSyncGrpItem(RsNxsSyncGrpItem *item)
     uint32_t s = 8; // header size
 
     s += 4; // transaction number
+    s += 4; // publishTs
     s += 1; // flag
     s += GetTlvStringSize(item->grpId);
-    s += item->adminSign.TlvSize();
 
     return s;
 }
@@ -1124,27 +1094,16 @@ uint32_t RsNxsSerialiser::sizeNxsExtended(RsNxsExtended *item){
 
 void RsNxsMsg::clear()
 {
+
     msg.TlvClear();
-    grpId.clear();
-    msgId.clear();
-    msgFlag = 0;
-    timeStamp = 0;
-    publishSign.TlvClear();
-    idSign.TlvClear();
-    identity.clear();
-    originalMsgId.clear();
+    meta.TlvClear();
 }
 
 void RsNxsGrp::clear()
 {
     grpId.clear();
-    timeStamp = 0;
     grp.TlvClear();
-    adminSign.TlvClear();
-    keys.TlvClear();
-    identity.clear();
-    grpFlag = 0;
-    idSign.TlvClear();
+    meta.TlvClear();
 }
 
 void RsNxsSyncGrp::clear()
@@ -1165,7 +1124,7 @@ void RsNxsSyncMsg::clear()
 void RsNxsSyncGrpItem::clear()
 {
     flag = 0;
-    adminSign.TlvClear();
+    publishTs = 0;
     grpId.clear();
 }
 
@@ -1209,7 +1168,7 @@ std::ostream& RsNxsExtended::print(std::ostream &out, uint16_t indent){
     printIndent(out , int_Indent);
     out << "type: " << type << std::endl;
     printIndent(out , int_Indent);
-    extData.print(out, indent);
+    extData.print(out, int_Indent);
 
     printRsItemEnd(out ,"RsNxsExtended", indent);
 
@@ -1244,8 +1203,7 @@ std::ostream& RsNxsSyncGrpItem::print(std::ostream &out, uint16_t indent)
     printIndent(out , int_Indent);
     out << "grpId: " << grpId << std::endl;
     printIndent(out , int_Indent);
-    adminSign.print(out, indent);
-    printIndent(out , int_Indent);
+    out << "publishTs: " << publishTs << std::endl;
 
     printRsItemEnd(out , "RsNxsSyncGrpItem", indent);
     return out;
@@ -1277,17 +1235,10 @@ std::ostream& RsNxsGrp::print(std::ostream &out, uint16_t indent){
 
     out << "grpId: " << grpId << std::endl;
     printIndent(out , int_Indent);
-    out << "timeStamp: " << timeStamp << std::endl;
-    printIndent(out , int_Indent);
-    out << "identity: " << identity << std::endl;
-    printIndent(out , int_Indent);
-    out << "grpFlag: " << grpFlag << std::endl;
-    out << "adminSign: " << std::endl;
-    adminSign.print(out, indent);
-    out << "idSign: " << std::endl;
-    idSign.print(out, indent);
-    out << "keys: " << std::endl;
-    keys.print(out, indent);
+    out << "grp: " << std::endl;
+    grp.print(out, int_Indent);
+    out << "meta: " << std::endl;
+    meta.print(out, int_Indent);
 
     printRsItemEnd(out, "RsNxsGrp", indent);
     return out;
@@ -1302,16 +1253,10 @@ std::ostream& RsNxsMsg::print(std::ostream &out, uint16_t indent){
     printIndent(out , int_Indent);
     out << "grpId: " << grpId << std::endl;
     printIndent(out , int_Indent);
-    out << "msgFlag: " << msgFlag << std::endl;
-    printIndent(out , int_Indent);
-    out << "identity: " << identity << std::endl;
-    printIndent(out , int_Indent);
-    out << "timeStamp: " << timeStamp << std::endl;
-    printIndent(out , int_Indent);
-    out << "pub sign: " << std::endl;
-    publishSign.print(out, indent);
-    out << "id sign: " << std::endl;
-    idSign.print(out, indent);
+    out << "msg: " << std::endl;
+    msg.print(out, indent);
+    out << "meta: " << std::endl;
+    meta.print(out, int_Indent);
 
     printRsItemEnd(out ,"RsNxsMsg", indent);
     return out;
diff --git a/libretroshare/src/serialiser/rsnxsitems.h b/libretroshare/src/serialiser/rsnxsitems.h
index 1d0712e1c..b4fec30d8 100644
--- a/libretroshare/src/serialiser/rsnxsitems.h
+++ b/libretroshare/src/serialiser/rsnxsitems.h
@@ -111,8 +111,8 @@ class RsNxsTransac : public RsNxsItem {
 
 public:
 
-	static const uint16_t FLAG_TRANS_MASK = 0xf;
-	static const uint16_t FLAG_TYPE_MASK = 0xff;
+    static const uint16_t FLAG_TRANS_MASK = 0xf;
+    static const uint16_t FLAG_TYPE_MASK = 0xff;
 
     /** transaction **/
     static const uint16_t FLAG_BEGIN_P1;
@@ -165,8 +165,9 @@ public:
 
     uint8_t flag; // request or response
 
-    /// groups held by sending peer
-    RsTlvKeySignature adminSign;
+    uint32_t publishTs; // to compare to Ts of receiving peer's grp of same id
+
+    /// grpId of grp held by sending peer
     std::string grpId;
 
 };
@@ -181,20 +182,22 @@ class RsNxsGrp : public RsNxsItem
 
 public:
 
-    RsNxsGrp(uint16_t servtype) : RsNxsItem(servtype, RS_PKT_SUBTYPE_NXS_GRP), grp(servtype) { clear(); return; }
+    RsNxsGrp(uint16_t servtype) : RsNxsItem(servtype, RS_PKT_SUBTYPE_NXS_GRP), grp(servtype), meta(servtype) { clear(); return; }
 
 
     virtual void clear();
     virtual std::ostream &print(std::ostream &out, uint16_t indent);
 
     std::string grpId; /// group Id, needed to complete version Id (ncvi)
-    uint32_t timeStamp; /// UTC time, ncvi
+
     RsTlvBinaryData grp; /// actual group data
-    RsTlvKeySignature adminSign; /// signature of admin (needed to complete version Id
-    RsTlvSecurityKeySet keys;
-    std::string identity;
-    RsTlvKeySignature idSign; /// identity sign if applicable
-    uint32_t grpFlag;
+
+    /*!
+     * This should contains all the data
+     * which is not specific to the Gxs service data
+     */
+    RsTlvBinaryData meta;
+
 };
 
 /*!
@@ -251,21 +254,25 @@ class RsNxsMsg : public RsNxsItem
 {
 public:
 
-    RsNxsMsg(uint16_t servtype) : RsNxsItem(servtype, RS_PKT_SUBTYPE_NXS_MSG), msg(servtype) { clear(); return; }
-
+    RsNxsMsg(uint16_t servtype) : RsNxsItem(servtype, RS_PKT_SUBTYPE_NXS_MSG), msg(servtype), meta(servtype) { clear(); return; }
 
     virtual void clear();
     virtual std::ostream &print(std::ostream &out, uint16_t indent);
 
     std::string grpId; /// group id, forms part of version id
     std::string msgId; /// msg id
-    std::string originalMsgId;
-    uint32_t msgFlag;
-    uint32_t timeStamp; /// UTC time create,
+
+    /*!
+     * This should contains all the data
+     * which is not specific to the Gxs service data
+     */
+    RsTlvBinaryData meta;
+
+    /*!
+     * This contains Gxs specific data
+     * only client of API knows who to decode this
+     */
     RsTlvBinaryData msg;
-    RsTlvKeySignature publishSign; /// publish signature
-    RsTlvKeySignature idSign; /// identity signature
-    std::string identity;
 
 };
 
@@ -445,24 +452,4 @@ private:
 };
 
 
-
-class RsGxsMsgId {
-
-public:
-
-    std::string grpId;
-    std::string msgId;
-    RsTlvKeySignature idSign;
-};
-
-
-class RsGxsGrpId {
-
-public:
-
-    std::string grpId;
-    RsTlvKeySignature adminSign;
-};
-
-
 #endif // RSNXSITEMS_H
diff --git a/libretroshare/src/tests/serialiser/rsnxsitems_test.cc b/libretroshare/src/tests/serialiser/rsnxsitems_test.cc
index 1acf49a7c..c3fea8bd4 100644
--- a/libretroshare/src/tests/serialiser/rsnxsitems_test.cc
+++ b/libretroshare/src/tests/serialiser/rsnxsitems_test.cc
@@ -11,26 +11,12 @@ INITTEST();
 
 RsSerialType* init_item(RsNxsGrp& nxg)
 {
+    nxg.clear();
 
-    randString(SHORT_STR, nxg.identity);
     randString(SHORT_STR, nxg.grpId);
-    nxg.timeStamp = rand()%23;
     nxg.transactionNumber = rand()%23;
-    nxg.grpFlag = rand()%242;
     init_item(nxg.grp);
-
-    init_item(nxg.adminSign);
-    init_item(nxg.idSign);
-
-    int nKey = rand()%12;
-
-    for(int i=0; i < nKey; i++){
-        nxg.keys.groupId  = nxg.grpId;
-        std::string s;
-        RsTlvSecurityKey k;
-        init_item(k);
-        nxg.keys.keys[k.keyId] = k;
-    }
+    init_item(nxg.meta);
 
     return new RsNxsSerialiser(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM);
 }
@@ -38,15 +24,12 @@ RsSerialType* init_item(RsNxsGrp& nxg)
 
 RsSerialType* init_item(RsNxsMsg& nxm)
 {
+    nxm.clear();
+
     randString(SHORT_STR, nxm.msgId);
     randString(SHORT_STR, nxm.grpId);
-    randString(SHORT_STR, nxm.identity);
-
-    init_item(nxm.publishSign);
-    init_item(nxm.idSign);
     init_item(nxm.msg);
-    nxm.msgFlag = rand()%4252;
-    nxm.timeStamp = rand()%246;
+    init_item(nxm.meta);
     nxm.transactionNumber = rand()%23;
 
     return new RsNxsSerialiser(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM);
@@ -55,7 +38,6 @@ RsSerialType* init_item(RsNxsMsg& nxm)
 RsSerialType* init_item(RsNxsSyncGrp& rsg)
 {
     rsg.clear();
-
     rsg.flag = RsNxsSyncGrp::FLAG_USE_SYNC_HASH;
     rsg.syncAge = rand()%2423;
     randString(3124,rsg.syncHash);
@@ -82,9 +64,8 @@ RsSerialType* init_item(RsNxsSyncGrpItem& rsgl)
 
     rsgl.flag = RsNxsSyncGrpItem::FLAG_RESPONSE;
     rsgl.transactionNumber = rand()%23;
+    rsgl.publishTs = rand()%23;
     randString(SHORT_STR, rsgl.grpId);
-    init_item(rsgl.adminSign);
-
 
     return new RsNxsSerialiser(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM);
 }
@@ -115,26 +96,11 @@ RsSerialType* init_item(RsNxsTransac& rstx){
 
 bool operator==(const RsNxsGrp& l, const RsNxsGrp& r){
 
-    if(!(l.adminSign == r.adminSign)) return false;
-    if(!(l.idSign == r.idSign)) return false;
-    if(l.timeStamp != r.timeStamp) return false;
-    if(l.grpFlag != r.grpFlag) return false;
-    if(l.identity != r.identity) return false;
     if(l.grpId != r.grpId) return false;
-    if(l.keys.groupId != r.keys.groupId) return false;
     if(!(l.grp == r.grp) ) return false;
+    if(!(l.meta == r.meta) ) return false;
     if(l.transactionNumber != r.transactionNumber) return false;
 
-    std::map<std::string, RsTlvSecurityKey>::const_iterator mit =
-            l.keys.keys.begin(), mit_end = l.keys.keys.end();
-
-    for(; mit != mit_end; mit++){
-        const RsTlvSecurityKey& lk = l.keys.keys.find(mit->first)->second;
-        const RsTlvSecurityKey& rk = r.keys.keys.find(mit->first)->second;
-
-        if(! ( lk == rk) ) return false;
-    }
-
     return true;
 }
 
@@ -142,12 +108,8 @@ bool operator==(const RsNxsMsg& l, const RsNxsMsg& r){
 
     if(l.msgId != r.msgId) return false;
     if(l.grpId != r.grpId) return false;
-    if(l.identity != r.identity) return false;
-    if(l.timeStamp != r.timeStamp) return false;
-    if(l.msgFlag != r.msgFlag) return false;
     if(! (l.msg == r.msg) ) return false;
-    if(! (l.publishSign == r.publishSign) ) return false;
-    if(! (l.idSign == r.idSign) ) return false;
+    if(! (l.meta == r.meta) ) return false;
     if(l.transactionNumber != r.transactionNumber) return false;
 
     return true;
@@ -179,7 +141,7 @@ bool operator==(const RsNxsSyncMsg& l, const RsNxsSyncMsg& r)
 bool operator==(const RsNxsSyncGrpItem& l, const RsNxsSyncGrpItem& r)
 {
     if(l.flag != r.flag) return false;
-    if(! (l.adminSign == r.adminSign) ) return false;
+    if(l.publishTs != r.publishTs) return false;
     if(l.grpId != r.grpId) return false;
     if(l.transactionNumber != r.transactionNumber) return false;
 
diff --git a/libretroshare/src/util/retrodb.cc b/libretroshare/src/util/retrodb.cc
index 000b2b58c..a9a17bda5 100644
--- a/libretroshare/src/util/retrodb.cc
+++ b/libretroshare/src/util/retrodb.cc
@@ -724,7 +724,8 @@ ContentValue::ContentValue(){
 }
 
 ContentValue::~ContentValue(){
-
+    // release resources held in data
+    clearData();
 }
 
 ContentValue::ContentValue(ContentValue &from){
@@ -861,46 +862,51 @@ void ContentValue::put(const std::string &key, uint32_t len, const char* value){
 
 bool ContentValue::getAsBool(const std::string &key, bool& value) const{
 
-    if(mKvBool.find(key) == mKvBool.end())
+    std::map<std::string, bool>::const_iterator it;
+    if((it = mKvBool.find(key)) == mKvBool.end())
         return false;
 
-  value = mKvBool.at(key);
+  value = it->second;
   return true;
 }
 
 bool ContentValue::getAsInt32(const std::string &key, int32_t& value) const{
 
-    if(mKvInt32.find(key) == mKvInt32.end())
+    std::map<std::string, int32_t>::const_iterator it;
+    if((it = mKvInt32.find(key)) == mKvInt32.end())
         return false;
 
-    value = mKvInt32.at(key);
+    value = it->second;
     return true;
 }
 
 bool ContentValue::getAsInt64(const std::string &key, int64_t& value) const{
 
-    if(mKvInt64.find(key) == mKvInt64.end())
+    std::map<std::string, int64_t>::const_iterator it;
+    if((it = mKvInt64.find(key)) == mKvInt64.end())
         return false;
 
-    value = mKvInt64.at(key);
+    value = it->second;
     return true;
 }
 
 bool ContentValue::getAsString(const std::string &key, std::string &value) const{
 
-    if(mKvString.find(key) == mKvString.end())
+    std::map<std::string, std::string>::const_iterator it;
+    if((it = mKvString.find(key)) == mKvString.end())
         return false;
 
-    value = mKvString.at(key);
+    value = it->second;
     return true;
 }
 
 bool ContentValue::getAsData(const std::string& key, uint32_t &len, char*& value) const{
 
-    if(mKvData.find(key) == mKvData.end())
+    std::map<std::string, std::pair<uint32_t, char*> >::const_iterator it;
+    if((it = mKvData.find(key)) == mKvData.end())
         return false;
 
-    const std::pair<uint32_t, char*> &kvRef = mKvData.at(key);
+    const std::pair<uint32_t, char*> &kvRef = it->second;
 
     len = kvRef.first;
     value = kvRef.second;
@@ -909,10 +915,11 @@ bool ContentValue::getAsData(const std::string& key, uint32_t &len, char*& value
 
 bool ContentValue::getAsDouble(const std::string &key, double& value) const{
 
-    if(mKvDouble.find(key) == mKvDouble.end())
+    std::map<std::string, double>::const_iterator it;
+    if((it = mKvDouble.find(key)) == mKvDouble.end())
         return false;
 
-    value = mKvDouble.at(key);
+    value = it->second;
     return true;
 }