fix for latest client release

indexedDb/impl/dm/implementation.go

@@ -17,17 +17,17 @@ import (
 	"syscall/js"
 	"time"
 
+	"github.com/hack-pad/go-indexeddb/idb"
 	"github.com/pkg/errors"
 	jww "github.com/spf13/jwalterweatherman"
+
 	"gitlab.com/elixxir/client/v4/cmix/rounds"
 	"gitlab.com/elixxir/client/v4/dm"
-	"gitlab.com/elixxir/xxdk-wasm/utils"
-	"gitlab.com/xx_network/primitives/id"
-
-	"github.com/hack-pad/go-indexeddb/idb"
 	cryptoChannel "gitlab.com/elixxir/crypto/channel"
 	"gitlab.com/elixxir/crypto/message"
 	"gitlab.com/elixxir/xxdk-wasm/indexedDb/impl"
+	"gitlab.com/elixxir/xxdk-wasm/utils"
+	"gitlab.com/xx_network/primitives/id"
 )
 
 // wasmModel implements dm.EventModel interface, which uses the channels system
@@ -81,13 +81,15 @@ func (w *wasmModel) joinConversation(nickname string,
 // message, then you need to set it manually yourself.
 func buildMessage(messageID, parentID, text []byte, pubKey ed25519.PublicKey,
 	timestamp time.Time, round id.Round, mType dm.MessageType,
-	status dm.Status) *Message {
+	codeset uint8, status dm.Status) *Message {
 	return &Message{
 		MessageID:          messageID,
 		ConversationPubKey: pubKey,
 		ParentMessageID:    parentID,
 		Timestamp:          timestamp,
+		SenderPubKey:       pubKey[:],
 		Status:             uint8(status),
+		CodesetVersion:     codeset,
 		Text:               text,
 		Type:               uint16(mType),
 		Round:              uint64(round),
@@ -98,40 +100,48 @@ func (w *wasmModel) Receive(messageID message.ID, nickname string, text []byte,
 	pubKey ed25519.PublicKey, dmToken uint32, codeset uint8, timestamp time.Time,
 	round rounds.Round, mType dm.MessageType, status dm.Status) uint64 {
 	parentErr := errors.New("failed to Receive")
+	jww.TRACE.Printf("[DM indexedDB] Receive(%s)", messageID)
 
 	// If there is no extant Conversation, create one.
 	_, err := impl.Get(w.db, conversationStoreName, utils.CopyBytesToJS(pubKey))
 	if err != nil {
 		if strings.Contains(err.Error(), impl.ErrDoesNotExist) {
-			err = w.joinConversation(nickname, pubKey, dmToken, codeset)
+			err = w.joinConversation(nickname, pubKey, dmToken,
+				codeset)
 			if err != nil {
-				jww.ERROR.Printf("%+v", err)
+				jww.ERROR.Printf("[DM indexedDB] %+v", err)
+				return 0
 			}
 		} else {
-			jww.ERROR.Printf("%+v", errors.WithMessagef(parentErr,
-				"Unable to get Conversation: %+v", err))
+			jww.ERROR.Printf("[DM indexedDB] %+v", errors.WithMessagef(
+				parentErr, "Unable to get Conversation: %+v", err))
+			return 0
 		}
-		return 0
 	} else {
-		jww.DEBUG.Printf("Conversation with %s already joined", nickname)
+		jww.DEBUG.Printf(
+			"[DM indexedDB] Conversation with %s already joined", nickname)
 	}
 
 	// Handle encryption, if it is present
 	if w.cipher != nil {
 		text, err = w.cipher.Encrypt(text)
 		if err != nil {
-			jww.ERROR.Printf("Failed to encrypt Message: %+v", err)
+			jww.ERROR.Printf(
+				"[DM indexedDB] Failed to encrypt Message: %+v", err)
 			return 0
 		}
 	}
 
 	msgToInsert := buildMessage(messageID.Bytes(), nil, text, pubKey, timestamp,
-		round.ID, mType, status)
+		round.ID, mType, codeset, status)
 	uuid, err := w.receiveHelper(msgToInsert, false)
 	if err != nil {
-		jww.ERROR.Printf("Failed to receive Message: %+v", err)
+		jww.ERROR.Printf("[DM indexedDB] Failed to receive Message: %+v", err)
+		return 0
 	}
 
+	jww.TRACE.Printf(
+		"[DM indexedDB] Calling ReceiveMessageCB(%v, %v, f)", uuid, pubKey)
 	go w.receivedMessageCB(uuid, pubKey, false)
 	return uuid
 }
@@ -140,22 +150,27 @@ func (w *wasmModel) ReceiveText(messageID message.ID, nickname, text string,
 	pubKey ed25519.PublicKey, dmToken uint32, codeset uint8,
 	timestamp time.Time, round rounds.Round, status dm.Status) uint64 {
 	parentErr := errors.New("failed to ReceiveText")
+	jww.TRACE.Printf("[DM indexedDB] ReceiveText(%s)", messageID)
 
 	// If there is no extant Conversation, create one.
 	_, err := impl.Get(w.db, conversationStoreName, utils.CopyBytesToJS(pubKey))
 	if err != nil {
 		if strings.Contains(err.Error(), impl.ErrDoesNotExist) {
-			err = w.joinConversation(nickname, pubKey, dmToken, codeset)
+			err = w.joinConversation(nickname, pubKey, dmToken,
+				codeset)
 			if err != nil {
-				jww.ERROR.Printf("%+v", err)
+				jww.ERROR.Printf("[DM indexedDB] %+v", err)
+				return 0
 			}
 		} else {
-			jww.ERROR.Printf("%+v", errors.WithMessagef(parentErr,
-				"Unable to get Conversation: %+v", err))
+			jww.ERROR.Printf("[DM indexedDB] %+v", errors.WithMessagef(
+				parentErr, "Unable to get Conversation: %+v", err))
+			return 0
 		}
-		return 0
 	} else {
-		jww.DEBUG.Printf("Conversation with %s already joined", nickname)
+		jww.DEBUG.Printf(
+			"[DM indexedDB] Conversation with %s already joined", nickname)
+		return 0
 	}
 
 	// Handle encryption, if it is present
@@ -163,19 +178,23 @@ func (w *wasmModel) ReceiveText(messageID message.ID, nickname, text string,
 	if w.cipher != nil {
 		textBytes, err = w.cipher.Encrypt(textBytes)
 		if err != nil {
-			jww.ERROR.Printf("Failed to encrypt Message: %+v", err)
+			jww.ERROR.Printf(
+				"[DM indexedDB] Failed to encrypt Message: %+v", err)
 			return 0
 		}
 	}
 
 	msgToInsert := buildMessage(messageID.Bytes(), nil, textBytes,
-		pubKey, timestamp, round.ID, dm.TextType, status)
+		pubKey, timestamp, round.ID, dm.TextType, codeset, status)
 
 	uuid, err := w.receiveHelper(msgToInsert, false)
 	if err != nil {
-		jww.ERROR.Printf("Failed to receive Message: %+v", err)
+		jww.ERROR.Printf("[DM indexedDB] Failed to receive Message: %+v", err)
+		return 0
 	}
 
+	jww.TRACE.Printf(
+		"[DM indexedDB] Calling ReceiveMessageCB(%v, %v, f)", uuid, pubKey)
 	go w.receivedMessageCB(uuid, pubKey, false)
 	return uuid
 }
@@ -184,22 +203,26 @@ func (w *wasmModel) ReceiveReply(messageID, reactionTo message.ID, nickname,
 	text string, pubKey ed25519.PublicKey, dmToken uint32, codeset uint8,
 	timestamp time.Time, round rounds.Round, status dm.Status) uint64 {
 	parentErr := errors.New("failed to ReceiveReply")
+	jww.TRACE.Printf("[DM indexedDB] ReceiveReply(%s)", messageID)
 
 	// If there is no extant Conversation, create one.
 	_, err := impl.Get(w.db, conversationStoreName, utils.CopyBytesToJS(pubKey))
 	if err != nil {
 		if strings.Contains(err.Error(), impl.ErrDoesNotExist) {
-			err = w.joinConversation(nickname, pubKey, dmToken, codeset)
+			err = w.joinConversation(nickname, pubKey, dmToken,
+				codeset)
 			if err != nil {
-				jww.ERROR.Printf("%+v", err)
+				jww.ERROR.Printf("[DM indexedDB] %+v", err)
+				return 0
 			}
 		} else {
-			jww.ERROR.Printf("%+v", errors.WithMessagef(parentErr,
-				"Unable to get Conversation: %+v", err))
+			jww.ERROR.Printf("[DM indexedDB] %+v", errors.WithMessagef(
+				parentErr, "Unable to get Conversation: %+v", err))
+			return 0
 		}
-		return 0
 	} else {
-		jww.DEBUG.Printf("Conversation with %s already joined", nickname)
+		jww.DEBUG.Printf("[DM indexedDB] Conversation with %s already joined",
+			nickname)
 	}
 
 	// Handle encryption, if it is present
@@ -207,19 +230,24 @@ func (w *wasmModel) ReceiveReply(messageID, reactionTo message.ID, nickname,
 	if w.cipher != nil {
 		textBytes, err = w.cipher.Encrypt(textBytes)
 		if err != nil {
-			jww.ERROR.Printf("Failed to encrypt Message: %+v", err)
+			jww.ERROR.Printf(
+				"[DM indexedDB] Failed to encrypt Message: %+v", err)
 			return 0
 		}
 	}
 
-	msgToInsert := buildMessage(messageID.Bytes(), reactionTo.Marshal(), textBytes,
-		pubKey, timestamp, round.ID, dm.TextType, status)
+	msgToInsert := buildMessage(messageID.Bytes(), reactionTo.Marshal(),
+		textBytes, pubKey, timestamp, round.ID, dm.TextType, codeset,
+		status)
 
 	uuid, err := w.receiveHelper(msgToInsert, false)
 	if err != nil {
-		jww.ERROR.Printf("Failed to receive Message: %+v", err)
+		jww.ERROR.Printf("[DM indexedDB] Failed to receive Message: %+v", err)
+		return 0
 	}
 
+	jww.TRACE.Printf(
+		"[DM indexedDB] Calling ReceiveMessageCB(%v, %v, f)", uuid, pubKey)
 	go w.receivedMessageCB(uuid, pubKey, false)
 	return uuid
 }
@@ -228,22 +256,26 @@ func (w *wasmModel) ReceiveReaction(messageID, _ message.ID, nickname,
 	reaction string, pubKey ed25519.PublicKey, dmToken uint32, codeset uint8,
 	timestamp time.Time, round rounds.Round, status dm.Status) uint64 {
 	parentErr := errors.New("failed to ReceiveText")
+	jww.TRACE.Printf("[DM indexedDB] ReceiveReaction(%s)", messageID)
 
 	// If there is no extant Conversation, create one.
 	_, err := impl.Get(w.db, conversationStoreName, utils.CopyBytesToJS(pubKey))
 	if err != nil {
 		if strings.Contains(err.Error(), impl.ErrDoesNotExist) {
-			err = w.joinConversation(nickname, pubKey, dmToken, codeset)
+			err = w.joinConversation(nickname, pubKey, dmToken,
+				codeset)
 			if err != nil {
-				jww.ERROR.Printf("%+v", err)
+				jww.ERROR.Printf("[DM indexedDB] %+v", err)
+				return 0
 			}
 		} else {
-			jww.ERROR.Printf("%+v", errors.WithMessagef(parentErr,
-				"Unable to get Conversation: %+v", err))
+			jww.ERROR.Printf("[DM indexedDB] %+v", errors.WithMessagef(
+				parentErr, "Unable to get Conversation: %+v", err))
+			return 0
 		}
-		return 0
 	} else {
-		jww.DEBUG.Printf("Conversation with %s already joined", nickname)
+		jww.DEBUG.Printf(
+			"[DM indexedDB] Conversation with %s already joined", nickname)
 	}
 
 	// Handle encryption, if it is present
@@ -251,19 +283,22 @@ func (w *wasmModel) ReceiveReaction(messageID, _ message.ID, nickname,
 	if w.cipher != nil {
 		textBytes, err = w.cipher.Encrypt(textBytes)
 		if err != nil {
-			jww.ERROR.Printf("Failed to encrypt Message: %+v", err)
+			jww.ERROR.Printf("[DM indexedDB] Failed to encrypt Message: %+v", err)
 			return 0
 		}
 	}
 
-	msgToInsert := buildMessage(messageID.Bytes(), nil, textBytes,
-		pubKey, timestamp, round.ID, dm.ReactionType, status)
+	msgToInsert := buildMessage(messageID.Bytes(), nil, textBytes, pubKey,
+		timestamp, round.ID, dm.ReactionType, codeset, status)
 
 	uuid, err := w.receiveHelper(msgToInsert, false)
 	if err != nil {
-		jww.ERROR.Printf("Failed to receive Message: %+v", err)
+		jww.ERROR.Printf("[DM indexedDB] Failed to receive Message: %+v", err)
+		return 0
 	}
 
+	jww.TRACE.Printf("[DM indexedDB] Calling ReceiveMessageCB(%v, %v, f)",
+		uuid, pubKey)
 	go w.receivedMessageCB(uuid, pubKey, false)
 	return uuid
 }
@@ -277,6 +312,8 @@ func (w *wasmModel) UpdateSentStatus(uuid uint64, messageID message.ID,
 	//        special version of receiveHelper)
 	w.updateMux.Lock()
 	defer w.updateMux.Unlock()
+	jww.TRACE.Printf(
+		"[DM indexedDB] UpdateSentStatus(%d, %s, ...)", uuid, messageID)
 
 	// Convert messageID to the key generated by json.Marshal
 	key := js.ValueOf(uuid)
@@ -284,7 +321,7 @@ func (w *wasmModel) UpdateSentStatus(uuid uint64, messageID message.ID,
 	// Use the key to get the existing Message
 	currentMsg, err := impl.Get(w.db, messageStoreName, key)
 	if err != nil {
-		jww.ERROR.Printf("%+v", errors.WithMessagef(parentErr,
+		jww.ERROR.Printf("[DM indexedDB] %+v", errors.WithMessagef(parentErr,
 			"Unable to get message: %+v", err))
 		return
 	}
@@ -293,7 +330,7 @@ func (w *wasmModel) UpdateSentStatus(uuid uint64, messageID message.ID,
 	newMessage := &Message{}
 	err = json.Unmarshal([]byte(utils.JsToJson(currentMsg)), newMessage)
 	if err != nil {
-		jww.ERROR.Printf("%+v", errors.WithMessagef(parentErr,
+		jww.ERROR.Printf("[DM indexedDB] %+v", errors.WithMessagef(parentErr,
 			"Could not JSON unmarshal message: %+v", err))
 		return
 	}
@@ -314,8 +351,13 @@ func (w *wasmModel) UpdateSentStatus(uuid uint64, messageID message.ID,
 	// Store the updated Message
 	_, err = w.receiveHelper(newMessage, true)
 	if err != nil {
-		jww.ERROR.Printf("%+v", errors.Wrap(parentErr, err.Error()))
+		jww.ERROR.Printf("[DM indexedDB] %+v",
+			errors.Wrap(parentErr, err.Error()))
+		return
 	}
+
+	jww.TRACE.Printf("[DM indexedDB] Calling ReceiveMessageCB(%v, %v, t)",
+		uuid, newMessage.ConversationPubKey)
 	go w.receivedMessageCB(uuid, newMessage.ConversationPubKey, true)
 }
 
@@ -351,12 +393,14 @@ func (w *wasmModel) receiveHelper(
 		copy(msgID[:], newMessage.MessageID)
 		uuid, errLookup := w.msgIDLookup(msgID)
 		if uuid != 0 && errLookup == nil {
+			jww.WARN.Printf("[DM indexedDB] Result undefined, but found"+
+				" duplicate? %d, %s", uuid, msgID)
 			return uuid, nil
 		}
 		return 0, errors.Errorf("uuid lookup failure: %+v", err)
 	}
 	uuid := uint64(result.Int())
-	jww.DEBUG.Printf("Successfully stored message %d", uuid)
+	jww.DEBUG.Printf("[DM indexedDB] Successfully stored message %d", uuid)
 
 	return uuid, nil
 }