diff --git a/indexedDb/channels/implementation.go b/indexedDb/channels/implementation.go
index 9fcdf5fdccf867ccedb9eb6f0123db433d83e7c9..6ac4d47db8be84f2ab56a648f2bcd41a168b0317 100644
--- a/indexedDb/channels/implementation.go
+++ b/indexedDb/channels/implementation.go
@@ -13,11 +13,13 @@ import (
"crypto/ed25519"
"encoding/base64"
"encoding/json"
- "gitlab.com/elixxir/xxdk-wasm/indexedDb"
+ "strings"
"sync"
"syscall/js"
"time"
+ "gitlab.com/elixxir/xxdk-wasm/indexedDb"
+
"github.com/hack-pad/go-indexeddb/idb"
"github.com/pkg/errors"
jww "github.com/spf13/jwalterweatherman"
@@ -26,6 +28,7 @@ import (
"gitlab.com/elixxir/client/v4/cmix/rounds"
cryptoBroadcast "gitlab.com/elixxir/crypto/broadcast"
cryptoChannel "gitlab.com/elixxir/crypto/channel"
+ "gitlab.com/elixxir/crypto/message"
"gitlab.com/elixxir/xxdk-wasm/utils"
"gitlab.com/xx_network/primitives/id"
)
@@ -41,7 +44,7 @@ type wasmModel struct {
}
// DeleteMessage removes a message with the given messageID from storage.
-func (w *wasmModel) DeleteMessage(messageID cryptoChannel.MessageID) error {
+func (w *wasmModel) DeleteMessage(messageID message.ID) error {
msgId := js.ValueOf(base64.StdEncoding.EncodeToString(messageID.Bytes()))
return indexedDb.DeleteIndex(w.db, messageStoreName,
messageStoreMessageIndex, pkeyName, msgId)
@@ -150,10 +153,10 @@ func (w *wasmModel) deleteMsgByChannel(channelID *id.ID) error {
// It may be called multiple times on the same message; it is incumbent on the
// user of the API to filter such called by message ID.
func (w *wasmModel) ReceiveMessage(channelID *id.ID,
- messageID cryptoChannel.MessageID, nickname, text string,
- pubKey ed25519.PublicKey, codeset uint8, timestamp time.Time,
- lease time.Duration, round rounds.Round, mType channels.MessageType,
- status channels.SentStatus, hidden bool) uint64 {
+ messageID message.ID, nickname, text string,
+ pubKey ed25519.PublicKey, dmToken uint32, codeset uint8,
+ timestamp time.Time, lease time.Duration, round rounds.Round,
+ mType channels.MessageType, status channels.SentStatus, hidden bool) uint64 {
textBytes := []byte(text)
var err error
@@ -167,9 +170,9 @@ func (w *wasmModel) ReceiveMessage(channelID *id.ID,
}
msgToInsert := buildMessage(
- channelID.Marshal(), messageID.Bytes(), nil, nickname, textBytes,
- pubKey, codeset, timestamp, lease, round.ID, mType, false, hidden,
- status)
+ channelID.Marshal(), messageID.Bytes(), nil, nickname,
+ textBytes, pubKey, dmToken, codeset, timestamp, lease, round.ID, mType,
+ false, hidden, status)
uuid, err := w.receiveHelper(msgToInsert, false)
if err != nil {
@@ -187,8 +190,8 @@ func (w *wasmModel) ReceiveMessage(channelID *id.ID,
// Messages may arrive our of order, so a reply, in theory, can arrive before
// the initial message. As a result, it may be important to buffer replies.
func (w *wasmModel) ReceiveReply(channelID *id.ID,
- messageID cryptoChannel.MessageID, replyTo cryptoChannel.MessageID,
- nickname, text string, pubKey ed25519.PublicKey, codeset uint8,
+ messageID message.ID, replyTo message.ID,
+ nickname, text string, pubKey ed25519.PublicKey, dmToken uint32, codeset uint8,
timestamp time.Time, lease time.Duration, round rounds.Round,
mType channels.MessageType, status channels.SentStatus, hidden bool) uint64 {
textBytes := []byte(text)
@@ -203,10 +206,9 @@ func (w *wasmModel) ReceiveReply(channelID *id.ID,
}
}
- msgToInsert := buildMessage(
- channelID.Marshal(), messageID.Bytes(), replyTo.Bytes(), nickname,
- textBytes, pubKey, codeset, timestamp, lease, round.ID, mType, false,
- hidden, status)
+ msgToInsert := buildMessage(channelID.Marshal(), messageID.Bytes(),
+ replyTo.Bytes(), nickname, textBytes, pubKey, dmToken, codeset,
+ timestamp, lease, round.ID, mType, hidden, false, status)
uuid, err := w.receiveHelper(msgToInsert, false)
@@ -224,8 +226,8 @@ func (w *wasmModel) ReceiveReply(channelID *id.ID,
// Messages may arrive our of order, so a reply, in theory, can arrive before
// the initial message. As a result, it may be important to buffer reactions.
func (w *wasmModel) ReceiveReaction(channelID *id.ID,
- messageID cryptoChannel.MessageID, reactionTo cryptoChannel.MessageID,
- nickname, reaction string, pubKey ed25519.PublicKey, codeset uint8,
+ messageID message.ID, reactionTo message.ID,
+ nickname, reaction string, pubKey ed25519.PublicKey, dmToken uint32, codeset uint8,
timestamp time.Time, lease time.Duration, round rounds.Round,
mType channels.MessageType, status channels.SentStatus, hidden bool) uint64 {
textBytes := []byte(reaction)
@@ -242,7 +244,7 @@ func (w *wasmModel) ReceiveReaction(channelID *id.ID,
msgToInsert := buildMessage(
channelID.Marshal(), messageID.Bytes(), reactionTo.Bytes(), nickname,
- textBytes, pubKey, codeset, timestamp, lease, round.ID, mType,
+ textBytes, pubKey, dmToken, codeset, timestamp, lease, round.ID, mType,
false, hidden, status)
uuid, err := w.receiveHelper(msgToInsert, false)
@@ -253,16 +255,13 @@ func (w *wasmModel) ReceiveReaction(channelID *id.ID,
return uuid
}
-// UpdateFromMessageID is called whenever a message with the message ID is
-// modified.
-//
// The API needs to return the UUID of the modified message that can be
// referenced at a later time.
//
// timestamp, round, pinned, and hidden are all nillable and may be updated
// based upon the UUID at a later date. If a nil value is passed, then make
// no update.
-func (w *wasmModel) UpdateFromMessageID(messageID cryptoChannel.MessageID,
+func (w *wasmModel) UpdateFromMessageID(messageID message.ID,
timestamp *time.Time, round *rounds.Round, pinned, hidden *bool,
status *channels.SentStatus) uint64 {
parentErr := errors.New("failed to UpdateFromMessageID")
@@ -298,7 +297,7 @@ func (w *wasmModel) UpdateFromMessageID(messageID cryptoChannel.MessageID,
// updated based upon the UUID at a later date. If a nil value is passed, then
// make no update.
func (w *wasmModel) UpdateFromUUID(uuid uint64,
- messageID *cryptoChannel.MessageID, timestamp *time.Time,
+ messageID *message.ID, timestamp *time.Time,
round *rounds.Round, pinned, hidden *bool, status *channels.SentStatus) {
parentErr := errors.New("failed to UpdateFromUUID")
@@ -329,7 +328,7 @@ func (w *wasmModel) UpdateFromUUID(uuid uint64,
// updateMessage is a helper for updating a stored message.
func (w *wasmModel) updateMessage(currentMsgJson string,
- messageID *cryptoChannel.MessageID, timestamp *time.Time,
+ messageID *message.ID, timestamp *time.Time,
round *rounds.Round, pinned, hidden *bool,
status *channels.SentStatus) (uint64, error) {
@@ -343,7 +342,7 @@ func (w *wasmModel) updateMessage(currentMsgJson string,
newMessage.Status = uint8(*status)
}
if messageID != nil {
- newMessage.MessageID = messageID.Marshal()
+ newMessage.MessageID = messageID.Bytes()
}
if round != nil {
@@ -381,7 +380,7 @@ func (w *wasmModel) updateMessage(currentMsgJson string,
// autoincrement key by default. If you are trying to overwrite an existing
// message, then you need to set it manually yourself.
func buildMessage(channelID, messageID, parentID []byte, nickname string,
- text []byte, pubKey ed25519.PublicKey, codeset uint8, timestamp time.Time,
+ text []byte, pubKey ed25519.PublicKey, dmToken uint32, codeset uint8, timestamp time.Time,
lease time.Duration, round id.Round, mType channels.MessageType,
pinned, hidden bool, status channels.SentStatus) *Message {
return &Message{
@@ -399,6 +398,7 @@ func buildMessage(channelID, messageID, parentID []byte, nickname string,
Round: uint64(round),
// User Identity Info
Pubkey: pubKey,
+ DmToken: dmToken,
CodesetVersion: codeset,
}
}
@@ -423,19 +423,18 @@ func (w *wasmModel) receiveHelper(newMessage *Message, isUpdate bool) (uint64,
}
// Store message to database
- addReq, err := indexedDb.Put(w.db, messageStoreName, messageObj)
- if err != nil {
+ result, err := indexedDb.Put(w.db, messageStoreName, messageObj)
+ if err != nil && !strings.Contains(err.Error(),
+ "at least one key does not satisfy the uniqueness requirements") {
+ // Only return non-unique constraint errors so that the case
+ // below this one can be hit and handle duplicate entries properly.
return 0, errors.Errorf("Unable to put Message: %+v", err)
}
- res, err := addReq.Result()
- if err != nil {
- return 0, errors.Errorf("Unable to get Message result: %+v", err)
- }
// NOTE: Sometimes the insert fails to return an error but hits a duplicate
// insert, so this fallthrough returns the UUID entry in that case.
- if res.IsUndefined() {
- msgID := cryptoChannel.MessageID{}
+ if result.IsUndefined() {
+ msgID := message.ID{}
copy(msgID[:], newMessage.MessageID)
msg, errLookup := w.msgIDLookup(msgID)
if msg.ID != 0 && errLookup == nil {
@@ -443,14 +442,14 @@ func (w *wasmModel) receiveHelper(newMessage *Message, isUpdate bool) (uint64,
}
return 0, errors.Errorf("uuid lookup failure: %+v", err)
}
- uuid := uint64(res.Int())
+ uuid := uint64(result.Int())
jww.DEBUG.Printf("Successfully stored message %d", uuid)
return uuid, nil
}
// GetMessage returns the message with the given [channel.MessageID].
-func (w *wasmModel) GetMessage(messageID cryptoChannel.MessageID) (channels.ModelMessage, error) {
+func (w *wasmModel) GetMessage(messageID message.ID) (channels.ModelMessage, error) {
lookupResult, err := w.msgIDLookup(messageID)
if err != nil {
return channels.ModelMessage{}, err
@@ -464,9 +463,9 @@ func (w *wasmModel) GetMessage(messageID cryptoChannel.MessageID) (channels.Mode
}
}
- var parentMsgId cryptoChannel.MessageID
+ var parentMsgId message.ID
if lookupResult.ParentMessageID != nil {
- parentMsgId, err = cryptoChannel.UnmarshalMessageID(lookupResult.ParentMessageID)
+ parentMsgId, err = message.UnmarshalID(lookupResult.ParentMessageID)
if err != nil {
return channels.ModelMessage{}, err
}
@@ -492,7 +491,7 @@ func (w *wasmModel) GetMessage(messageID cryptoChannel.MessageID) (channels.Mode
}
// msgIDLookup gets the UUID of the Message with the given messageID.
-func (w *wasmModel) msgIDLookup(messageID cryptoChannel.MessageID) (*Message,
+func (w *wasmModel) msgIDLookup(messageID message.ID) (*Message,
error) {
msgIDStr := js.ValueOf(base64.StdEncoding.EncodeToString(messageID.Bytes()))
resultObj, err := indexedDb.GetIndex(w.db, messageStoreName,
diff --git a/indexedDb/channels/implementation_test.go b/indexedDb/channels/implementation_test.go
index 689133d3002b0567bc50545c6716d88273355601..92d9b62204bf5e7f7b255fc34c79ba626259e180 100644
--- a/indexedDb/channels/implementation_test.go
+++ b/indexedDb/channels/implementation_test.go
@@ -13,6 +13,7 @@ import (
"encoding/json"
"fmt"
"github.com/hack-pad/go-indexeddb/idb"
+ "gitlab.com/elixxir/crypto/message"
"gitlab.com/elixxir/xxdk-wasm/indexedDb"
"gitlab.com/elixxir/xxdk-wasm/storage"
"gitlab.com/xx_network/crypto/csprng"
@@ -26,7 +27,6 @@ import (
"gitlab.com/elixxir/client/v4/channels"
"gitlab.com/elixxir/client/v4/cmix/rounds"
cryptoBroadcast "gitlab.com/elixxir/crypto/broadcast"
- "gitlab.com/elixxir/crypto/channel"
cryptoChannel "gitlab.com/elixxir/crypto/channel"
"gitlab.com/xx_network/primitives/id"
)
@@ -46,21 +46,22 @@ func TestWasmModel_msgIDLookup(t *testing.T) {
}
for _, c := range []cryptoChannel.Cipher{nil, cipher} {
cs := ""
- if cipher != nil {
+ if c != nil {
cs = "_withCipher"
}
t.Run(fmt.Sprintf("TestWasmModel_msgIDLookup%s", cs), func(t *testing.T) {
storage.GetLocalStorage().Clear()
- testString := "test"
- testMsgId := channel.MakeMessageID([]byte(testString), &id.ID{1})
+ testString := "TestWasmModel_msgIDLookup" + cs
+ testMsgId := message.DeriveChannelMessageID(&id.ID{1}, 0, []byte(testString))
+
eventModel, err := newWASMModel(testString, c, dummyCallback)
if err != nil {
t.Fatalf("%+v", err)
}
testMsg := buildMessage([]byte(testString), testMsgId.Bytes(), nil,
- testString, []byte(testString), []byte{8, 6, 7, 5}, 0,
+ testString, []byte(testString), []byte{8, 6, 7, 5}, 0, 0,
netTime.Now(), time.Second, 0, 0, false, false, channels.Sent)
_, err = eventModel.receiveHelper(testMsg, false)
if err != nil {
@@ -81,8 +82,8 @@ func TestWasmModel_msgIDLookup(t *testing.T) {
// Happy path, insert message and delete it
func TestWasmModel_DeleteMessage(t *testing.T) {
storage.GetLocalStorage().Clear()
- testString := "test"
- testMsgId := channel.MakeMessageID([]byte(testString), &id.ID{1})
+ testString := "TestWasmModel_DeleteMessage"
+ testMsgId := message.DeriveChannelMessageID(&id.ID{1}, 0, []byte(testString))
eventModel, err := newWASMModel(testString, nil, dummyCallback)
if err != nil {
t.Fatalf("%+v", err)
@@ -90,7 +91,7 @@ func TestWasmModel_DeleteMessage(t *testing.T) {
// Insert a message
testMsg := buildMessage([]byte(testString), testMsgId.Bytes(), nil,
- testString, []byte(testString), []byte{8, 6, 7, 5}, 0, netTime.Now(),
+ testString, []byte(testString), []byte{8, 6, 7, 5}, 0, 0, netTime.Now(),
time.Second, 0, 0, false, false, channels.Sent)
_, err = eventModel.receiveHelper(testMsg, false)
if err != nil {
@@ -130,13 +131,13 @@ func Test_wasmModel_UpdateSentStatus(t *testing.T) {
}
for _, c := range []cryptoChannel.Cipher{nil, cipher} {
cs := ""
- if cipher != nil {
+ if c != nil {
cs = "_withCipher"
}
t.Run(fmt.Sprintf("Test_wasmModel_UpdateSentStatus%s", cs), func(t *testing.T) {
storage.GetLocalStorage().Clear()
- testString := "test"
- testMsgId := channel.MakeMessageID([]byte(testString), &id.ID{1})
+ testString := "Test_wasmModel_UpdateSentStatus" + cs
+ testMsgId := message.DeriveChannelMessageID(&id.ID{1}, 0, []byte(testString))
eventModel, err := newWASMModel(testString, c, dummyCallback)
if err != nil {
t.Fatalf("%+v", err)
@@ -144,7 +145,7 @@ func Test_wasmModel_UpdateSentStatus(t *testing.T) {
// Store a test message
testMsg := buildMessage([]byte(testString), testMsgId.Bytes(), nil,
- testString, []byte(testString), []byte{8, 6, 7, 5}, 0, netTime.Now(),
+ testString, []byte(testString), []byte{8, 6, 7, 5}, 0, 0, netTime.Now(),
time.Second, 0, 0, false, false, channels.Sent)
uuid, err := eventModel.receiveHelper(testMsg, false)
if err != nil {
@@ -198,7 +199,7 @@ func Test_wasmModel_JoinChannel_LeaveChannel(t *testing.T) {
}
for _, c := range []cryptoChannel.Cipher{nil, cipher} {
cs := ""
- if cipher != nil {
+ if c != nil {
cs = "_withCipher"
}
t.Run(fmt.Sprintf("Test_wasmModel_JoinChannel_LeaveChannel%s", cs), func(t *testing.T) {
@@ -249,12 +250,12 @@ func Test_wasmModel_UUIDTest(t *testing.T) {
}
for _, c := range []cryptoChannel.Cipher{nil, cipher} {
cs := ""
- if cipher != nil {
+ if c != nil {
cs = "_withCipher"
}
t.Run(fmt.Sprintf("Test_wasmModel_UUIDTest%s", cs), func(t *testing.T) {
storage.GetLocalStorage().Clear()
- testString := "testHello"
+ testString := "testHello" + cs
eventModel, err := newWASMModel(testString, c, dummyCallback)
if err != nil {
t.Fatalf("%+v", err)
@@ -265,11 +266,11 @@ func Test_wasmModel_UUIDTest(t *testing.T) {
for i := 0; i < 10; i++ {
// Store a test message
channelID := id.NewIdFromBytes([]byte(testString), t)
- msgID := channel.MessageID{}
+ msgID := message.ID{}
copy(msgID[:], testString+fmt.Sprintf("%d", i))
rnd := rounds.Round{ID: id.Round(42)}
uuid := eventModel.ReceiveMessage(channelID, msgID, "test",
- testString+fmt.Sprintf("%d", i), []byte{8, 6, 7, 5}, 0,
+ testString+fmt.Sprintf("%d", i), []byte{8, 6, 7, 5}, 0, 0,
netTime.Now(), time.Hour, rnd, 0, channels.Sent, false)
uuids[i] = uuid
}
@@ -294,7 +295,7 @@ func Test_wasmModel_DuplicateReceives(t *testing.T) {
}
for _, c := range []cryptoChannel.Cipher{nil, cipher} {
cs := ""
- if cipher != nil {
+ if c != nil {
cs = "_withCipher"
}
t.Run(fmt.Sprintf("Test_wasmModel_DuplicateReceives%s", cs), func(t *testing.T) {
@@ -307,14 +308,14 @@ func Test_wasmModel_DuplicateReceives(t *testing.T) {
uuids := make([]uint64, 10)
- msgID := channel.MessageID{}
+ msgID := message.ID{}
copy(msgID[:], testString)
for i := 0; i < 10; i++ {
// Store a test message
channelID := id.NewIdFromBytes([]byte(testString), t)
rnd := rounds.Round{ID: id.Round(42)}
uuid := eventModel.ReceiveMessage(channelID, msgID, "test",
- testString+fmt.Sprintf("%d", i), []byte{8, 6, 7, 5}, 0,
+ testString+fmt.Sprintf("%d", i), []byte{8, 6, 7, 5}, 0, 0,
netTime.Now(), time.Hour, rnd, 0, channels.Sent, false)
uuids[i] = uuid
}
@@ -340,7 +341,7 @@ func Test_wasmModel_deleteMsgByChannel(t *testing.T) {
}
for _, c := range []cryptoChannel.Cipher{nil, cipher} {
cs := ""
- if cipher != nil {
+ if c != nil {
cs = "_withCipher"
}
t.Run(fmt.Sprintf("Test_wasmModel_deleteMsgByChannel%s", cs), func(t *testing.T) {
@@ -367,9 +368,9 @@ func Test_wasmModel_deleteMsgByChannel(t *testing.T) {
thisChannel = keepChannel
}
- testMsgId := channel.MakeMessageID([]byte(testStr), &id.ID{1})
+ testMsgId := message.DeriveChannelMessageID(&id.ID{byte(i)}, 0, []byte(testStr))
eventModel.ReceiveMessage(thisChannel, testMsgId, testStr, testStr,
- []byte{8, 6, 7, 5}, 0, netTime.Now(), time.Second,
+ []byte{8, 6, 7, 5}, 0, 0, netTime.Now(), time.Second,
rounds.Round{ID: id.Round(0)}, 0, channels.Sent, false)
}
@@ -409,7 +410,7 @@ func TestWasmModel_receiveHelper_UniqueIndex(t *testing.T) {
}
for i, c := range []cryptoChannel.Cipher{nil, cipher} {
cs := ""
- if cipher != nil {
+ if c != nil {
cs = "_withCipher"
}
t.Run(fmt.Sprintf("TestWasmModel_receiveHelper_UniqueIndex%s", cs), func(t *testing.T) {
@@ -441,55 +442,48 @@ func TestWasmModel_receiveHelper_UniqueIndex(t *testing.T) {
}
// First message insert should succeed
- testMsgId := channel.MakeMessageID([]byte(testString), &id.ID{1})
+ testMsgId := message.DeriveChannelMessageID(&id.ID{1}, 0, []byte(testString))
testMsg := buildMessage([]byte(testString), testMsgId.Bytes(), nil,
- testString, []byte(testString), []byte{8, 6, 7, 5}, 0,
+ testString, []byte(testString), []byte{8, 6, 7, 5}, 0, 0,
netTime.Now(), time.Second, 0, 0, false, false, channels.Sent)
- _, err = eventModel.receiveHelper(testMsg, false)
+ uuid, err := eventModel.receiveHelper(testMsg, false)
if err != nil {
t.Fatal(err)
}
- // The duplicate entry won't fail, but it just silently shouldn't happen
- _, err = eventModel.receiveHelper(testMsg, false)
- if err != nil {
- t.Fatalf("%+v", err)
- }
- results, err := indexedDb.Dump(eventModel.db, messageStoreName)
+ // The duplicate entry should return the same UUID
+ duplicateUuid, err := eventModel.receiveHelper(testMsg, false)
if err != nil {
- t.Fatalf("%+v", err)
+ t.Fatal(err)
}
- if len(results) != 1 {
- t.Fatalf("Expected only a single message, got %d", len(results))
+ if uuid != duplicateUuid {
+ t.Fatalf("Expected UUID %d to match %d", uuid, duplicateUuid)
}
// Now insert a message with a different message ID from the first
- testMsgId2 := channel.MakeMessageID([]byte(testString), &id.ID{2})
+ testMsgId2 := message.DeriveChannelMessageID(&id.ID{2}, 0, []byte(testString))
testMsg = buildMessage([]byte(testString), testMsgId2.Bytes(), nil,
- testString, []byte(testString), []byte{8, 6, 7, 5}, 0,
+ testString, []byte(testString), []byte{8, 6, 7, 5}, 0, 0,
netTime.Now(), time.Second, 0, 0, false, false, channels.Sent)
- primaryKey, err := eventModel.receiveHelper(testMsg, false)
+ uuid2, err := eventModel.receiveHelper(testMsg, false)
if err != nil {
t.Fatal(err)
}
+ if uuid2 == uuid {
+ t.Fatalf("Expected UUID %d to NOT match %d", uuid, duplicateUuid)
+ }
// Except this time, we update the second entry to have the same
// message ID as the first
- testMsg.ID = primaryKey
+ testMsg.ID = uuid
testMsg.MessageID = testMsgId.Bytes()
- _, err = eventModel.receiveHelper(testMsg, true)
+ duplicateUuid2, err := eventModel.receiveHelper(testMsg, true)
if err != nil {
t.Fatal(err)
}
-
- // The update to duplicate message ID won't fail,
- // but it just silently shouldn't happen
- results, err = indexedDb.Dump(eventModel.db, messageStoreName)
- if err != nil {
- t.Fatalf("%+v", err)
+ if duplicateUuid2 != duplicateUuid {
+ t.Fatalf("Expected UUID %d to match %d", uuid, duplicateUuid)
}
- // TODO: Convert JSON to Message, ensure Message ID fields differ
-
})
}
}
diff --git a/indexedDb/channels/model.go b/indexedDb/channels/model.go
index 02a3ebd42479a26cffa7e758c8d317a21a906099..078d6bd67f7c43d9e50373b7801f69937cfce2ac 100644
--- a/indexedDb/channels/model.go
+++ b/indexedDb/channels/model.go
@@ -61,6 +61,7 @@ type Message struct {
// User cryptographic Identity struct -- could be pulled out
Pubkey []byte `json:"pubkey"`
+ DmToken uint32 `json:"dm_token"`
CodesetVersion uint8 `json:"codeset_version"`
}
diff --git a/indexedDb/dm/implementation.go b/indexedDb/dm/implementation.go
new file mode 100644
index 0000000000000000000000000000000000000000..0b5e812dc731b6afd1187c58f7c997f4326babfe
--- /dev/null
+++ b/indexedDb/dm/implementation.go
@@ -0,0 +1,380 @@
+////////////////////////////////////////////////////////////////////////////////
+// Copyright © 2022 xx foundation //
+// //
+// Use of this source code is governed by a license that can be found in the //
+// LICENSE file. //
+////////////////////////////////////////////////////////////////////////////////
+
+//go:build js && wasm
+
+package channelEventModel
+
+import (
+ "crypto/ed25519"
+ "encoding/json"
+ "strings"
+ "sync"
+ "syscall/js"
+ "time"
+
+ "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/indexedDb"
+ "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"
+)
+
+// wasmModel implements [dm.Receiver] interface, which uses the channels
+// system passed an object that adheres to in order to get events on the
+// channel.
+type wasmModel struct {
+ db *idb.Database
+ cipher cryptoChannel.Cipher
+ receivedMessageCB MessageReceivedCallback
+ updateMux sync.Mutex
+}
+
+// joinConversation is used for joining new conversations.
+func (w *wasmModel) joinConversation(nickname string,
+ pubKey ed25519.PublicKey, dmToken uint32, codeset uint8) error {
+ parentErr := errors.New("failed to joinConversation")
+
+ // Build object
+ newConvo := Conversation{
+ Pubkey: pubKey,
+ Nickname: nickname,
+ Token: dmToken,
+ CodesetVersion: codeset,
+ Blocked: false,
+ }
+
+ // Convert to jsObject
+ newConvoJson, err := json.Marshal(&newConvo)
+ if err != nil {
+ return errors.WithMessagef(parentErr,
+ "Unable to marshal Conversation: %+v", err)
+ }
+ convoObj, err := utils.JsonToJS(newConvoJson)
+ if err != nil {
+ return errors.WithMessagef(parentErr,
+ "Unable to marshal Conversation: %+v", err)
+ }
+
+ _, err = indexedDb.Put(w.db, conversationStoreName, convoObj)
+ if err != nil {
+ return errors.WithMessagef(parentErr,
+ "Unable to put Conversation: %+v", err)
+ }
+ return nil
+}
+
+// buildMessage is a private helper that converts typical [dm.Receiver]
+// inputs into a basic Message structure for insertion into storage.
+//
+// NOTE: ID is not set inside this function because we want to use the
+// autoincrement key by default. If you are trying to overwrite an existing
+// message, then you need to set it manually yourself.
+func buildMessage(messageID, parentID []byte, text []byte,
+ pubKey ed25519.PublicKey, timestamp time.Time, round id.Round,
+ mType dm.MessageType, status dm.Status) *Message {
+ return &Message{
+ MessageID: messageID,
+ ConversationPubKey: pubKey,
+ ParentMessageID: parentID,
+ Timestamp: timestamp,
+ Status: uint8(status),
+ Text: text,
+ Type: uint16(mType),
+ Round: uint64(round),
+ }
+}
+
+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")
+ var err error
+
+ // If there is no extant Conversation, create one.
+ if _, err := indexedDb.Get(w.db, conversationStoreName, utils.CopyBytesToJS(pubKey)); err != nil {
+ if strings.Contains(err.Error(), indexedDb.ErrDoesNotExist) {
+ err = w.joinConversation(nickname, pubKey, dmToken, codeset)
+ if err != nil {
+ jww.ERROR.Printf("%+v", err)
+ }
+ } else {
+ jww.ERROR.Printf("%+v", errors.WithMessagef(parentErr,
+ "Unable to get Conversation: %+v", err))
+ }
+ return 0
+ } else {
+ jww.DEBUG.Printf("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)
+ return 0
+ }
+ }
+
+ msgToInsert := buildMessage(messageID.Bytes(), nil, text,
+ pubKey, timestamp, round.ID, mType, status)
+ uuid, err := w.receiveHelper(msgToInsert, false)
+ if err != nil {
+ jww.ERROR.Printf("Failed to receive Message: %+v", err)
+ }
+
+ go w.receivedMessageCB(uuid, pubKey, false)
+ return uuid
+}
+
+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")
+ var err error
+
+ // If there is no extant Conversation, create one.
+ if _, err := indexedDb.Get(w.db, conversationStoreName, utils.CopyBytesToJS(pubKey)); err != nil {
+ if strings.Contains(err.Error(), indexedDb.ErrDoesNotExist) {
+ err = w.joinConversation(nickname, pubKey, dmToken, codeset)
+ if err != nil {
+ jww.ERROR.Printf("%+v", err)
+ }
+ } else {
+ jww.ERROR.Printf("%+v", errors.WithMessagef(parentErr,
+ "Unable to get Conversation: %+v", err))
+ }
+ return 0
+ } else {
+ jww.DEBUG.Printf("Conversation with %s already joined", nickname)
+ }
+
+ // Handle encryption, if it is present
+ textBytes := []byte(text)
+ if w.cipher != nil {
+ textBytes, err = w.cipher.Encrypt(textBytes)
+ if err != nil {
+ jww.ERROR.Printf("Failed to encrypt Message: %+v", err)
+ return 0
+ }
+ }
+
+ msgToInsert := buildMessage(messageID.Bytes(), nil, textBytes,
+ pubKey, timestamp, round.ID, dm.TextType, status)
+
+ uuid, err := w.receiveHelper(msgToInsert, false)
+ if err != nil {
+ jww.ERROR.Printf("Failed to receive Message: %+v", err)
+ }
+
+ go w.receivedMessageCB(uuid, pubKey, false)
+ return uuid
+}
+
+func (w *wasmModel) ReceiveReply(messageID message.ID, 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")
+ var err error
+
+ // If there is no extant Conversation, create one.
+ if _, err := indexedDb.Get(w.db, conversationStoreName, utils.CopyBytesToJS(pubKey)); err != nil {
+ if strings.Contains(err.Error(), indexedDb.ErrDoesNotExist) {
+ err = w.joinConversation(nickname, pubKey, dmToken, codeset)
+ if err != nil {
+ jww.ERROR.Printf("%+v", err)
+ }
+ } else {
+ jww.ERROR.Printf("%+v", errors.WithMessagef(parentErr,
+ "Unable to get Conversation: %+v", err))
+ }
+ return 0
+ } else {
+ jww.DEBUG.Printf("Conversation with %s already joined", nickname)
+ }
+
+ // Handle encryption, if it is present
+ textBytes := []byte(text)
+ if w.cipher != nil {
+ textBytes, err = w.cipher.Encrypt(textBytes)
+ if err != nil {
+ jww.ERROR.Printf("Failed to encrypt Message: %+v", err)
+ return 0
+ }
+ }
+
+ msgToInsert := buildMessage(messageID.Bytes(), reactionTo.Marshal(), textBytes,
+ pubKey, timestamp, round.ID, dm.TextType, status)
+
+ uuid, err := w.receiveHelper(msgToInsert, false)
+ if err != nil {
+ jww.ERROR.Printf("Failed to receive Message: %+v", err)
+ }
+
+ go w.receivedMessageCB(uuid, pubKey, false)
+ return uuid
+}
+
+func (w *wasmModel) ReceiveReaction(messageID message.ID, reactionTo 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")
+ var err error
+
+ // If there is no extant Conversation, create one.
+ if _, err := indexedDb.Get(w.db, conversationStoreName, utils.CopyBytesToJS(pubKey)); err != nil {
+ if strings.Contains(err.Error(), indexedDb.ErrDoesNotExist) {
+ err = w.joinConversation(nickname, pubKey, dmToken, codeset)
+ if err != nil {
+ jww.ERROR.Printf("%+v", err)
+ }
+ } else {
+ jww.ERROR.Printf("%+v", errors.WithMessagef(parentErr,
+ "Unable to get Conversation: %+v", err))
+ }
+ return 0
+ } else {
+ jww.DEBUG.Printf("Conversation with %s already joined", nickname)
+ }
+
+ // Handle encryption, if it is present
+ textBytes := []byte(reaction)
+ if w.cipher != nil {
+ textBytes, err = w.cipher.Encrypt(textBytes)
+ if err != nil {
+ jww.ERROR.Printf("Failed to encrypt Message: %+v", err)
+ return 0
+ }
+ }
+
+ msgToInsert := buildMessage(messageID.Bytes(), nil, textBytes,
+ pubKey, timestamp, round.ID, dm.ReactionType, status)
+
+ uuid, err := w.receiveHelper(msgToInsert, false)
+ if err != nil {
+ jww.ERROR.Printf("Failed to receive Message: %+v", err)
+ }
+
+ go w.receivedMessageCB(uuid, pubKey, false)
+ return uuid
+}
+
+func (w *wasmModel) UpdateSentStatus(uuid uint64,
+ messageID message.ID, timestamp time.Time, round rounds.Round,
+ status dm.Status) {
+ parentErr := errors.New("failed to UpdateSentStatus")
+
+ // FIXME: this is a bit of race condition without the mux.
+ // This should be done via the transactions (i.e., make a
+ // special version of receiveHelper)
+ w.updateMux.Lock()
+ defer w.updateMux.Unlock()
+
+ // Convert messageID to the key generated by json.Marshal
+ key := js.ValueOf(uuid)
+
+ // Use the key to get the existing Message
+ currentMsg, err := indexedDb.Get(w.db, messageStoreName, key)
+ if err != nil {
+ jww.ERROR.Printf("%+v", errors.WithMessagef(parentErr,
+ "Unable to get message: %+v", err))
+ return
+ }
+
+ // Extract the existing Message and update the Status
+ newMessage := &Message{}
+ err = json.Unmarshal([]byte(utils.JsToJson(currentMsg)), newMessage)
+ if err != nil {
+ jww.ERROR.Printf("%+v", errors.WithMessagef(parentErr,
+ "Could not JSON unmarshal message: %+v", err))
+ return
+ }
+
+ newMessage.Status = uint8(status)
+ if !messageID.Equals(message.ID{}) {
+ newMessage.MessageID = messageID.Bytes()
+ }
+
+ if round.ID != 0 {
+ newMessage.Round = uint64(round.ID)
+ }
+
+ if !timestamp.Equal(time.Time{}) {
+ newMessage.Timestamp = timestamp
+ }
+
+ // Store the updated Message
+ _, err = w.receiveHelper(newMessage, true)
+ if err != nil {
+ jww.ERROR.Printf("%+v", errors.Wrap(parentErr, err.Error()))
+ }
+ go w.receivedMessageCB(uuid, newMessage.ConversationPubKey, true)
+}
+
+// receiveHelper is a private helper for receiving any sort of message.
+func (w *wasmModel) receiveHelper(newMessage *Message, isUpdate bool) (uint64,
+ error) {
+ // Convert to jsObject
+ newMessageJson, err := json.Marshal(newMessage)
+ if err != nil {
+ return 0, errors.Errorf("Unable to marshal Message: %+v", err)
+ }
+ messageObj, err := utils.JsonToJS(newMessageJson)
+ if err != nil {
+ return 0, errors.Errorf("Unable to marshal Message: %+v", err)
+ }
+
+ // Unset the primaryKey for inserts so that it can be auto-populated and
+ // incremented
+ if !isUpdate {
+ messageObj.Delete("id")
+ }
+
+ // Store message to database
+ result, err := indexedDb.Put(w.db, messageStoreName, messageObj)
+ if err != nil {
+ return 0, errors.Errorf("Unable to put Message: %+v", err)
+ }
+
+ // NOTE: Sometimes the insert fails to return an error but hits a duplicate
+ // insert, so this fallthrough returns the UUID entry in that case.
+ if result.IsUndefined() {
+ msgID := message.ID{}
+ copy(msgID[:], newMessage.MessageID)
+ uuid, errLookup := w.msgIDLookup(msgID)
+ if uuid != 0 && errLookup == nil {
+ return uuid, nil
+ }
+ return 0, errors.Errorf("uuid lookup failure: %+v", err)
+ }
+ uuid := uint64(result.Int())
+ jww.DEBUG.Printf("Successfully stored message %d", uuid)
+
+ return uuid, nil
+}
+
+// msgIDLookup gets the UUID of the Message with the given messageID.
+func (w *wasmModel) msgIDLookup(messageID message.ID) (uint64,
+ error) {
+ resultObj, err := indexedDb.GetIndex(w.db, messageStoreName,
+ messageStoreMessageIndex, utils.CopyBytesToJS(messageID.Marshal()))
+ if err != nil {
+ return 0, err
+ }
+
+ uuid := uint64(0)
+ if !resultObj.IsUndefined() {
+ uuid = uint64(resultObj.Get("id").Int())
+ }
+ return uuid, nil
+}
diff --git a/indexedDb/dm/init.go b/indexedDb/dm/init.go
new file mode 100644
index 0000000000000000000000000000000000000000..380df647c810d7fb6239cee9c4e7c1fc4181e4ca
--- /dev/null
+++ b/indexedDb/dm/init.go
@@ -0,0 +1,182 @@
+////////////////////////////////////////////////////////////////////////////////
+// Copyright © 2022 xx foundation //
+// //
+// Use of this source code is governed by a license that can be found in the //
+// LICENSE file. //
+////////////////////////////////////////////////////////////////////////////////
+
+//go:build js && wasm
+
+package channelEventModel
+
+import (
+ "crypto/ed25519"
+ "syscall/js"
+
+ "github.com/hack-pad/go-indexeddb/idb"
+ "github.com/pkg/errors"
+ jww "github.com/spf13/jwalterweatherman"
+ "gitlab.com/elixxir/client/v4/dm"
+ cryptoChannel "gitlab.com/elixxir/crypto/channel"
+ "gitlab.com/elixxir/xxdk-wasm/indexedDb"
+ "gitlab.com/elixxir/xxdk-wasm/storage"
+)
+
+const (
+ // databaseSuffix is the suffix to be appended to the name of
+ // the database.
+ databaseSuffix = "_speakeasy_dm"
+
+ // currentVersion is the current version of the IndexDb
+ // runtime. Used for migration purposes.
+ currentVersion uint = 1
+)
+
+// MessageReceivedCallback is called any time a message is received or updated.
+//
+// update is true if the row is old and was edited.
+type MessageReceivedCallback func(uuid uint64, pubKey ed25519.PublicKey, update bool)
+
+// NewWASMEventModel returns a [channels.EventModel] backed by a wasmModel.
+// The name should be a base64 encoding of the users public key.
+func NewWASMEventModel(path string, encryption cryptoChannel.Cipher,
+ cb MessageReceivedCallback) (dm.EventModel, error) {
+ databaseName := path + databaseSuffix
+ return newWASMModel(databaseName, encryption, cb)
+}
+
+// newWASMModel creates the given [idb.Database] and returns a wasmModel.
+func newWASMModel(databaseName string, encryption cryptoChannel.Cipher,
+ cb MessageReceivedCallback) (*wasmModel, error) {
+ // Attempt to open database object
+ ctx, cancel := indexedDb.NewContext()
+ defer cancel()
+ openRequest, err := idb.Global().Open(ctx, databaseName, currentVersion,
+ func(db *idb.Database, oldVersion, newVersion uint) error {
+ if oldVersion == newVersion {
+ jww.INFO.Printf("IndexDb version is current: v%d",
+ newVersion)
+ return nil
+ }
+
+ jww.INFO.Printf("IndexDb upgrade required: v%d -> v%d",
+ oldVersion, newVersion)
+
+ if oldVersion == 0 && newVersion >= 1 {
+ err := v1Upgrade(db)
+ if err != nil {
+ return err
+ }
+ oldVersion = 1
+ }
+
+ // if oldVersion == 1 && newVersion >= 2 { v2Upgrade(), oldVersion = 2 }
+ return nil
+ })
+ if err != nil {
+ return nil, err
+ }
+
+ // Wait for database open to finish
+ db, err := openRequest.Await(ctx)
+ if err != nil {
+ return nil, err
+ }
+
+ // Save the encryption status to storage
+ encryptionStatus := encryption != nil
+ loadedEncryptionStatus, err := storage.StoreIndexedDbEncryptionStatus(
+ databaseName, encryptionStatus)
+ if err != nil {
+ return nil, err
+ }
+
+ // Verify encryption status does not change
+ if encryptionStatus != loadedEncryptionStatus {
+ return nil, errors.New(
+ "Cannot load database with different encryption status.")
+ } else if !encryptionStatus {
+ jww.WARN.Printf("IndexedDb encryption disabled!")
+ }
+
+ // Attempt to ensure the database has been properly initialized
+ openRequest, err = idb.Global().Open(ctx, databaseName, currentVersion,
+ func(db *idb.Database, oldVersion, newVersion uint) error {
+ return nil
+ })
+ if err != nil {
+ return nil, err
+ }
+ // Wait for database open to finish
+ db, err = openRequest.Await(ctx)
+ if err != nil {
+ return nil, err
+ }
+ wrapper := &wasmModel{db: db, receivedMessageCB: cb, cipher: encryption}
+
+ return wrapper, nil
+}
+
+// v1Upgrade performs the v0 -> v1 database upgrade.
+//
+// This can never be changed without permanently breaking backwards
+// compatibility.
+func v1Upgrade(db *idb.Database) error {
+ indexOpts := idb.IndexOptions{
+ Unique: false,
+ MultiEntry: false,
+ }
+
+ // Build Message ObjectStore and Indexes
+ messageStoreOpts := idb.ObjectStoreOptions{
+ KeyPath: js.ValueOf(msgPkeyName),
+ AutoIncrement: true,
+ }
+ messageStore, err := db.CreateObjectStore(messageStoreName, messageStoreOpts)
+ if err != nil {
+ return err
+ }
+ _, err = messageStore.CreateIndex(messageStoreMessageIndex,
+ js.ValueOf(messageStoreMessage),
+ idb.IndexOptions{
+ Unique: true,
+ MultiEntry: false,
+ })
+ if err != nil {
+ return err
+ }
+ _, err = messageStore.CreateIndex(messageStoreConversationIndex,
+ js.ValueOf(messageStoreConversation), indexOpts)
+ if err != nil {
+ return err
+ }
+ _, err = messageStore.CreateIndex(messageStoreParentIndex,
+ js.ValueOf(messageStoreParent), indexOpts)
+ if err != nil {
+ return err
+ }
+ _, err = messageStore.CreateIndex(messageStoreTimestampIndex,
+ js.ValueOf(messageStoreTimestamp), indexOpts)
+ if err != nil {
+ return err
+ }
+
+ // Build Channel ObjectStore
+ conversationStoreOpts := idb.ObjectStoreOptions{
+ KeyPath: js.ValueOf(convoPkeyName),
+ AutoIncrement: false,
+ }
+ _, err = db.CreateObjectStore(conversationStoreName, conversationStoreOpts)
+ if err != nil {
+ return err
+ }
+
+ // Get the database name and save it to storage
+ if databaseName, err := db.Name(); err != nil {
+ return err
+ } else if err = storage.StoreIndexedDb(databaseName); err != nil {
+ return err
+ }
+
+ return nil
+}
diff --git a/indexedDb/dm/model.go b/indexedDb/dm/model.go
new file mode 100644
index 0000000000000000000000000000000000000000..bb6f34588aa2976c1689b629c6df31219de6b585
--- /dev/null
+++ b/indexedDb/dm/model.go
@@ -0,0 +1,63 @@
+////////////////////////////////////////////////////////////////////////////////
+// Copyright © 2022 xx foundation //
+// //
+// Use of this source code is governed by a license that can be found in the //
+// LICENSE file. //
+////////////////////////////////////////////////////////////////////////////////
+
+//go:build js && wasm
+
+package channelEventModel
+
+import (
+ "time"
+)
+
+const (
+ // Text representation of primary key value (keyPath).
+ msgPkeyName = "id"
+ convoPkeyName = "pub_key"
+
+ // Text representation of the names of the various [idb.ObjectStore].
+ messageStoreName = "messages"
+ conversationStoreName = "conversations"
+
+ // Message index names.
+ messageStoreMessageIndex = "message_id_index"
+ messageStoreConversationIndex = "conversation_id_index"
+ messageStoreParentIndex = "parent_message_id_index"
+ messageStoreTimestampIndex = "timestamp_index"
+
+ // Message keyPath names (must match json struct tags).
+ messageStoreMessage = "message_id"
+ messageStoreConversation = "conversation_id"
+ messageStoreParent = "parent_message_id"
+ messageStoreTimestamp = "timestamp"
+)
+
+// Message defines the IndexedDb representation of a single Message.
+//
+// A Message belongs to one Conversation.
+// A Message may belong to one Message (Parent).
+type Message struct {
+ ID uint64 `json:"id"` // Matches msgPkeyName
+ MessageID []byte `json:"message_id"` // Index
+ ConversationPubKey []byte `json:"conversation_pub_key"` // Index
+ ParentMessageID []byte `json:"parent_message_id"` // Index
+ Timestamp time.Time `json:"timestamp"` // Index
+ Status uint8 `json:"status"`
+ Text []byte `json:"text"`
+ Type uint16 `json:"type"`
+ Round uint64 `json:"round"`
+}
+
+// Conversation defines the IndexedDb representation of a single
+// message exchange between two recipients.
+// A Conversation has many Message.
+type Conversation struct {
+ Pubkey []byte `json:"pub_key"` // Matches convoPkeyName
+ Nickname string `json:"nickname"`
+ Token uint32 `json:"token"`
+ CodesetVersion uint8 `json:"codeset_version"`
+ Blocked bool `json:"blocked"`
+}
diff --git a/indexedDb/utils.go b/indexedDb/utils.go
index df25de1c7dc4d005d2d7f8da0e034de31df652e5..4b32064ae84254a42112c78feb36510c2501376d 100644
--- a/indexedDb/utils.go
+++ b/indexedDb/utils.go
@@ -22,9 +22,13 @@ import (
"time"
)
-// dbTimeout is the global timeout for operations with the storage
-// [context.Context].
-const dbTimeout = time.Second
+const (
+ // dbTimeout is the global timeout for operations with the storage
+ // [context.Context].
+ dbTimeout = time.Second
+ // ErrDoesNotExist is an error string for got undefined on Get operations.
+ ErrDoesNotExist = "result is undefined"
+)
// NewContext builds a context for indexedDb operations.
func NewContext() (context.Context, context.CancelFunc) {
@@ -63,8 +67,8 @@ func Get(db *idb.Database, objectStoreName string, key js.Value) (js.Value, erro
return js.Undefined(), errors.WithMessagef(parentErr,
"Unable to get from ObjectStore: %+v", err)
} else if resultObj.IsUndefined() {
- return js.Undefined(), errors.WithMessage(parentErr,
- "Unable to get from ObjectStore: result is undefined")
+ return js.Undefined(), errors.WithMessagef(parentErr,
+ "Unable to get from ObjectStore: %s", ErrDoesNotExist)
}
// Process result into string
@@ -112,8 +116,8 @@ func GetIndex(db *idb.Database, objectStoreName,
return js.Undefined(), errors.WithMessagef(parentErr,
"Unable to get from ObjectStore: %+v", err)
} else if resultObj.IsUndefined() {
- return js.Undefined(), errors.WithMessage(parentErr,
- "Unable to get from ObjectStore: result is undefined")
+ return js.Undefined(), errors.WithMessagef(parentErr,
+ "Unable to get from ObjectStore: %s", ErrDoesNotExist)
}
// Process result into string
@@ -124,33 +128,33 @@ func GetIndex(db *idb.Database, objectStoreName,
// Put is a generic helper for putting values into the given [idb.ObjectStore].
// Equivalent to insert if not exists else update.
-func Put(db *idb.Database, objectStoreName string, value js.Value) (*idb.Request, error) {
+func Put(db *idb.Database, objectStoreName string, value js.Value) (js.Value, error) {
// Prepare the Transaction
txn, err := db.Transaction(idb.TransactionReadWrite, objectStoreName)
if err != nil {
- return nil, errors.Errorf("Unable to create Transaction: %+v", err)
+ return js.Undefined(), errors.Errorf("Unable to create Transaction: %+v", err)
}
store, err := txn.ObjectStore(objectStoreName)
if err != nil {
- return nil, errors.Errorf("Unable to get ObjectStore: %+v", err)
+ return js.Undefined(), errors.Errorf("Unable to get ObjectStore: %+v", err)
}
// Perform the operation
request, err := store.Put(value)
if err != nil {
- return nil, errors.Errorf("Unable to Put: %+v", err)
+ return js.Undefined(), errors.Errorf("Unable to Put: %+v", err)
}
// Wait for the operation to return
ctx, cancel := NewContext()
- err = txn.Await(ctx)
+ result, err := request.Await(ctx)
cancel()
if err != nil {
- return nil, errors.Errorf("Putting value failed: %+v", err)
+ return js.Undefined(), errors.Errorf("Putting value failed: %+v", err)
}
jww.DEBUG.Printf("Successfully put value in %s: %s",
objectStoreName, utils.JsToJson(value))
- return request, nil
+ return result, nil
}
// Delete is a generic helper for removing values from the given [idb.ObjectStore].
diff --git a/main.go b/main.go
index 7194cffffd42c48edb25f495b372fcc009efe67f..de379dbdbf5eb3132e8cc546df5a6b601665e5e6 100644
--- a/main.go
+++ b/main.go
@@ -11,13 +11,14 @@ package main
import (
"fmt"
+ "os"
+ "syscall/js"
+
jww "github.com/spf13/jwalterweatherman"
"gitlab.com/elixxir/client/v4/bindings"
"gitlab.com/elixxir/xxdk-wasm/storage"
"gitlab.com/elixxir/xxdk-wasm/utils"
"gitlab.com/elixxir/xxdk-wasm/wasm"
- "os"
- "syscall/js"
)
func init() {
@@ -87,6 +88,15 @@ func main() {
js.Global().Set("NewChannelsDatabaseCipher",
js.FuncOf(wasm.NewChannelsDatabaseCipher))
+ // wasm/dm.go
+ js.Global().Set("NewDMClient", js.FuncOf(wasm.NewDMClient))
+ js.Global().Set("NewDMClientWithIndexedDb",
+ js.FuncOf(wasm.NewDMClientWithIndexedDb))
+ js.Global().Set("NewDMClientWithIndexedDbUnsafe",
+ js.FuncOf(wasm.NewDMClientWithIndexedDbUnsafe))
+ js.Global().Set("NewDMsDatabaseCipher",
+ js.FuncOf(wasm.NewDMsDatabaseCipher))
+
// wasm/cmix.go
js.Global().Set("NewCmix", js.FuncOf(wasm.NewCmix))
js.Global().Set("LoadCmix", js.FuncOf(wasm.LoadCmix))
diff --git a/wasm/channels.go b/wasm/channels.go
index 0c1be8ca72a4dd8f4da7657cc4c2ee72fa405259..d32737321c0efbab9ff732917b185a7b2cfbea99 100644
--- a/wasm/channels.go
+++ b/wasm/channels.go
@@ -1652,6 +1652,7 @@ func (em *eventModel) LeaveChannel(channelID []byte) {
// - nickname - The nickname of the sender of the message (string).
// - text - The content of the message (string).
// - pubKey - The sender's Ed25519 public key (Uint8Array).
+// - dmToken - The dmToken (int32).
// - codeset - The codeset version (int).
// - timestamp - Time the message was received; represented as nanoseconds
// since unix epoch (int).
@@ -1670,11 +1671,11 @@ func (em *eventModel) LeaveChannel(channelID []byte) {
// - A non-negative unique UUID for the message that it can be referenced by
// later with [eventModel.UpdateSentStatus].
func (em *eventModel) ReceiveMessage(channelID, messageID []byte, nickname,
- text string, pubKey []byte, codeset int, timestamp, lease, roundId, msgType,
+ text string, pubKey []byte, dmToken int32, codeset int, timestamp, lease, roundId, msgType,
status int64, hidden bool) int64 {
uuid := em.receiveMessage(utils.CopyBytesToJS(channelID),
utils.CopyBytesToJS(messageID), nickname, text,
- utils.CopyBytesToJS(pubKey), codeset, timestamp, lease, roundId,
+ utils.CopyBytesToJS(pubKey), dmToken, codeset, timestamp, lease, roundId,
msgType, status, hidden)
return int64(uuid.Int())
@@ -1696,6 +1697,7 @@ func (em *eventModel) ReceiveMessage(channelID, messageID []byte, nickname,
// - senderUsername - The username of the sender of the message (string).
// - text - The content of the message (string).
// - pubKey - The sender's Ed25519 public key (Uint8Array).
+// - dmToken - The dmToken (int32).
// - codeset - The codeset version (int).
// - timestamp - Time the message was received; represented as nanoseconds
// since unix epoch (int).
@@ -1714,11 +1716,11 @@ func (em *eventModel) ReceiveMessage(channelID, messageID []byte, nickname,
// - A non-negative unique UUID for the message that it can be referenced by
// later with [eventModel.UpdateSentStatus].
func (em *eventModel) ReceiveReply(channelID, messageID, reactionTo []byte,
- senderUsername, text string, pubKey []byte, codeset int, timestamp, lease,
+ senderUsername, text string, pubKey []byte, dmToken int32, codeset int, timestamp, lease,
roundId, msgType, status int64, hidden bool) int64 {
uuid := em.receiveReply(utils.CopyBytesToJS(channelID),
utils.CopyBytesToJS(messageID), utils.CopyBytesToJS(reactionTo),
- senderUsername, text, utils.CopyBytesToJS(pubKey), codeset,
+ senderUsername, text, utils.CopyBytesToJS(pubKey), dmToken, codeset,
timestamp, lease, roundId, msgType, status, hidden)
return int64(uuid.Int())
@@ -1740,6 +1742,7 @@ func (em *eventModel) ReceiveReply(channelID, messageID, reactionTo []byte,
// - senderUsername - The username of the sender of the message (string).
// - reaction - The contents of the reaction message (string).
// - pubKey - The sender's Ed25519 public key (Uint8Array).
+// - dmToken - The dmToken (int32).
// - codeset - The codeset version (int).
// - timestamp - Time the message was received; represented as nanoseconds
// since unix epoch (int).
@@ -1758,11 +1761,11 @@ func (em *eventModel) ReceiveReply(channelID, messageID, reactionTo []byte,
// - A non-negative unique UUID for the message that it can be referenced by
// later with [eventModel.UpdateSentStatus].
func (em *eventModel) ReceiveReaction(channelID, messageID, reactionTo []byte,
- senderUsername, reaction string, pubKey []byte, codeset int, timestamp,
+ senderUsername, reaction string, pubKey []byte, dmToken int32, codeset int, timestamp,
lease, roundId, msgType, status int64, hidden bool) int64 {
uuid := em.receiveReaction(utils.CopyBytesToJS(channelID),
utils.CopyBytesToJS(messageID), utils.CopyBytesToJS(reactionTo),
- senderUsername, reaction, utils.CopyBytesToJS(pubKey), codeset,
+ senderUsername, reaction, utils.CopyBytesToJS(pubKey), dmToken, codeset,
timestamp, lease, roundId, msgType, status, hidden)
return int64(uuid.Int())
diff --git a/wasm/dm.go b/wasm/dm.go
new file mode 100644
index 0000000000000000000000000000000000000000..678ca74f529f1ccce1a0a8cac63242b5073ed835
--- /dev/null
+++ b/wasm/dm.go
@@ -0,0 +1,872 @@
+////////////////////////////////////////////////////////////////////////////////
+// Copyright © 2022 xx foundation //
+// //
+// Use of this source code is governed by a license that can be found in the //
+// LICENSE file. //
+////////////////////////////////////////////////////////////////////////////////
+
+//go:build js && wasm
+
+package wasm
+
+import (
+ "crypto/ed25519"
+ "syscall/js"
+
+ indexDB "gitlab.com/elixxir/xxdk-wasm/indexedDb/dm"
+
+ "encoding/base64"
+
+ "gitlab.com/elixxir/client/v4/bindings"
+ "gitlab.com/elixxir/crypto/codename"
+ "gitlab.com/elixxir/xxdk-wasm/utils"
+)
+
+////////////////////////////////////////////////////////////////////////////////
+// Basic Channel API //
+////////////////////////////////////////////////////////////////////////////////
+
+// DMClient wraps the [bindings.DMClient] object so its methods
+// can be wrapped to be Javascript compatible.
+type DMClient struct {
+ api *bindings.DMClient
+}
+
+// newDMClientJS creates a new Javascript compatible object
+// (map[string]any) that matches the [DMClient] structure.
+func newDMClientJS(api *bindings.DMClient) map[string]any {
+ cm := DMClient{api}
+ dmClientMap := map[string]any{
+ // Basic Channel API
+ "GetID": js.FuncOf(cm.GetID),
+
+ // Identity and Nickname Controls
+ "GetPublicKey": js.FuncOf(cm.GetPublicKey),
+ "GetToken": js.FuncOf(cm.GetToken),
+ "GetIdentity": js.FuncOf(cm.GetIdentity),
+ "ExportPrivateIdentity": js.FuncOf(cm.ExportPrivateIdentity),
+ "SetNickname": js.FuncOf(cm.SetNickname),
+ "GetNickname": js.FuncOf(cm.GetNickname),
+
+ // DM Sending Methods and Reports
+ "SendText": js.FuncOf(cm.SendText),
+ "SendReply": js.FuncOf(cm.SendReply),
+ "SendReaction": js.FuncOf(cm.SendReaction),
+ "Send": js.FuncOf(cm.Send),
+ }
+
+ return dmClientMap
+}
+
+// GetPublicKey returns the ecdh Public Key for this [DMClient] in the
+// [DMClient] tracker.
+//
+// Returns:
+// - Tracker ID (int).
+func (ch *DMClient) GetID(js.Value, []js.Value) any {
+ return ch.api.GetID()
+}
+
+func (ch *DMClient) GetPublicKey(js.Value, []js.Value) any {
+ return ch.api.GetPublicKey()
+}
+
+func (ch *DMClient) GetToken(js.Value, []js.Value) any {
+ return ch.api.GetToken()
+}
+
+// dmReceiverBuilder adheres to the [bindings.DMReceiverBuilder] interface.
+type dmReceiverBuilder struct {
+ build func(args ...any) js.Value
+}
+
+// Build initializes and returns the event model. It wraps a Javascript object
+// that has all the methods in [bindings.EventModel] to make it adhere to the Go
+// interface [bindings.EventModel].
+func (emb *dmReceiverBuilder) Build(path string) bindings.DMReceiver {
+ emJs := emb.build(path)
+ return &dmReceiver{
+ receive: utils.WrapCB(emJs, "ReceiveText"),
+ receiveText: utils.WrapCB(emJs, "ReceiveText"),
+ receiveReply: utils.WrapCB(emJs, "ReceiveReply"),
+ receiveReaction: utils.WrapCB(emJs, "ReceiveReaction"),
+ updateSentStatus: utils.WrapCB(emJs, "UpdateSentStatus"),
+ }
+}
+
+// NewDMClient creates a new [DMClient] from a new private
+// identity ([channel.PrivateIdentity]).
+//
+// This is for creating a manager for an identity for the first time. For
+// generating a new one channel identity, use [GenerateChannelIdentity]. To
+// reload this channel manager, use [LoadDMClient], passing in the
+// storage tag retrieved by [DMClient.GetStorageTag].
+//
+// Parameters:
+// - args[0] - ID of [Cmix] object in tracker (int). This can be retrieved
+// using [Cmix.GetID].
+// - args[1] - Bytes of a private identity ([channel.PrivateIdentity]) that is
+// generated by [GenerateChannelIdentity] (Uint8Array).
+// - args[2] - A function that initialises and returns a Javascript object
+// that matches the [bindings.EventModel] interface. The function must match
+// the Build function in [bindings.EventModelBuilder].
+//
+// Returns:
+// - Javascript representation of the [DMClient] object.
+// - Throws a TypeError if creating the manager fails.
+func NewDMClient(_ js.Value, args []js.Value) any {
+ privateIdentity := utils.CopyBytesToGo(args[1])
+
+ em := &dmReceiverBuilder{args[2].Invoke}
+
+ cm, err := bindings.NewDMClient(args[0].Int(), privateIdentity, em)
+ if err != nil {
+ utils.Throw(utils.TypeError, err)
+ return nil
+ }
+
+ return newDMClientJS(cm)
+}
+
+// NewDMClientWithIndexedDb creates a new [DMClient] from a new
+// private identity ([channel.PrivateIdentity]) and using indexedDb as a backend
+// to manage the event model.
+//
+// This is for creating a manager for an identity for the first time. For
+// generating a new one channel identity, use [GenerateChannelIdentity]. To
+// reload this channel manager, use [LoadDMClientWithIndexedDb], passing
+// in the storage tag retrieved by [DMClient.GetStorageTag].
+//
+// This function initialises an indexedDb database.
+//
+// Parameters:
+// - args[0] - ID of [Cmix] object in tracker (int). This can be retrieved
+// using [Cmix.GetID].
+// - args[1] - Bytes of a private identity ([channel.PrivateIdentity]) that is
+// generated by [GenerateChannelIdentity] (Uint8Array).
+// - args[2] - Function that takes in the same parameters as
+// [indexedDb.MessageReceivedCallback]. On the Javascript side, the UUID is
+// returned as an int and the channelID as a Uint8Array. The row in the
+// database that was updated can be found using the UUID. The channel ID is
+// provided so that the recipient can filter if they want to the processes
+// the update now or not. An "update" bool is present which tells you if the
+// row is new or if it is an edited old row.
+// - args[3] - ID of [ChannelDbCipher] object in tracker (int). Create this
+// object with [NewChannelsDatabaseCipher] and get its id with
+// [ChannelDbCipher.GetID].
+//
+// Returns a promise:
+// - Resolves to a Javascript representation of the [DMClient] object.
+// - Rejected with an error if loading indexedDb or the manager fails.
+// - Throws a TypeError if the cipher ID does not correspond to a cipher.
+func NewDMClientWithIndexedDb(_ js.Value, args []js.Value) any {
+ cmixID := args[0].Int()
+ privateIdentity := utils.CopyBytesToGo(args[1])
+ messageReceivedCB := args[2]
+ cipherID := args[3].Int()
+
+ cipher, err := bindings.GetChannelDbCipherTrackerFromID(cipherID)
+ if err != nil {
+ utils.Throw(utils.TypeError, err)
+ }
+
+ return newDMClientWithIndexedDb(
+ cmixID, privateIdentity, messageReceivedCB, cipher)
+}
+
+// NewDMClientWithIndexedDbUnsafe creates a new [DMClient] from a
+// new private identity ([channel.PrivateIdentity]) and using indexedDb as a
+// backend to manage the event model. However, the data is written in plain text
+// and not encrypted. It is recommended that you do not use this in production.
+//
+// This is for creating a manager for an identity for the first time. For
+// generating a new one channel identity, use [GenerateChannelIdentity]. To
+// reload this channel manager, use [LoadDMClientWithIndexedDbUnsafe],
+// passing in the storage tag retrieved by [DMClient.GetStorageTag].
+//
+// This function initialises an indexedDb database.
+//
+// Parameters:
+// - args[0] - ID of [Cmix] object in tracker (int). This can be retrieved
+// using [Cmix.GetID].
+// - args[1] - Bytes of a private identity ([channel.PrivateIdentity]) that is
+// generated by [GenerateChannelIdentity] (Uint8Array).
+// - args[2] - Function that takes in the same parameters as
+// [indexedDb.MessageReceivedCallback]. On the Javascript side, the UUID is
+// returned as an int and the channelID as a Uint8Array. The row in the
+// database that was updated can be found using the UUID. The channel ID is
+// provided so that the recipient can filter if they want to the processes
+// the update now or not. An "update" bool is present which tells you if
+// the row is new or if it is an edited old row
+//
+// Returns a promise:
+// - Resolves to a Javascript representation of the [DMClient] object.
+// - Rejected with an error if loading indexedDb or the manager fails.
+func NewDMClientWithIndexedDbUnsafe(_ js.Value, args []js.Value) any {
+ cmixID := args[0].Int()
+ privateIdentity := utils.CopyBytesToGo(args[1])
+ messageReceivedCB := args[2]
+
+ return newDMClientWithIndexedDb(
+ cmixID, privateIdentity, messageReceivedCB, nil)
+}
+
+func newDMClientWithIndexedDb(cmixID int, privateIdentity []byte,
+ cb js.Value, cipher *bindings.ChannelDbCipher) any {
+
+ messageReceivedCB := func(uuid uint64, pubKey ed25519.PublicKey,
+ update bool) {
+ cb.Invoke(uuid, utils.CopyBytesToJS(pubKey[:]), update)
+ }
+
+ promiseFn := func(resolve, reject func(args ...any) js.Value) {
+
+ pi, err := codename.UnmarshalPrivateIdentity(privateIdentity)
+ if err != nil {
+ reject(utils.JsTrace(err))
+ }
+ dmPath := base64.RawStdEncoding.EncodeToString(pi.PubKey[:])
+ model, err := indexDB.NewWASMEventModel(dmPath, cipher,
+ messageReceivedCB)
+ if err != nil {
+ reject(utils.JsTrace(err))
+ }
+
+ cm, err := bindings.NewDMClientWithGoEventModel(
+ cmixID, privateIdentity, model)
+ if err != nil {
+ reject(utils.JsTrace(err))
+ } else {
+ resolve(newDMClientJS(cm))
+ }
+ }
+
+ return utils.CreatePromise(promiseFn)
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Channel Sending Methods and Reports //
+////////////////////////////////////////////////////////////////////////////////
+
+// SendGeneric is used to send a raw message over a channel. In general, it
+// should be wrapped in a function which defines the wire protocol. If the final
+// message, before being sent over the wire, is too long, this will return an
+// error. Due to the underlying encoding using compression, it isn't possible to
+// define the largest payload that can be sent, but it will always be possible
+// to send a payload of 802 bytes at minimum. The meaning of validUntil depends
+// on the use case.
+//
+// Parameters:
+// - args[0] - Marshalled bytes of the channel [id.ID] (Uint8Array).
+// - args[1] - The message type of the message. This will be a valid
+// [channels.MessageType] (int).
+// - args[2] - The contents of the message (Uint8Array).
+// - args[3] - The lease of the message. This will be how long the message is
+// valid until, in milliseconds. As per the [channels.Manager]
+// documentation, this has different meanings depending on the use case.
+// These use cases may be generic enough that they will not be enumerated
+// here (int).
+// - args[4] - JSON of [xxdk.CMIXParams]. If left empty
+// [bindings.GetDefaultCMixParams] will be used internally (Uint8Array).
+//
+// Returns a promise:
+// - Resolves to the JSON of [bindings.ChannelSendReport] (Uint8Array).
+// - Rejected with an error if sending fails.
+func (ch *DMClient) Send(_ js.Value, args []js.Value) any {
+ messageType := args[0].Int()
+ partnerPubKeyBytes := utils.CopyBytesToGo(args[1])
+ partnerToken := args[2].Int()
+ message := utils.CopyBytesToGo(args[3])
+ leaseTimeMS := int64(args[4].Int())
+ cmixParamsJSON := utils.CopyBytesToGo(args[5])
+
+ promiseFn := func(resolve, reject func(args ...any) js.Value) {
+ sendReport, err := ch.api.Send(messageType, partnerPubKeyBytes,
+ uint32(partnerToken), message, leaseTimeMS,
+ cmixParamsJSON)
+ if err != nil {
+ reject(utils.JsTrace(err))
+ } else {
+ resolve(utils.CopyBytesToJS(sendReport))
+ }
+ }
+
+ return utils.CreatePromise(promiseFn)
+}
+
+// SendMessage is used to send a formatted message over a channel.
+// Due to the underlying encoding using compression, it isn't possible to define
+// the largest payload that can be sent, but it will always be possible to send
+// a payload of 798 bytes at minimum.
+//
+// The message will auto delete validUntil after the round it is sent in,
+// lasting forever if [channels.ValidForever] is used.
+//
+// Parameters:
+// - args[0] - Marshalled bytes of the channel [id.ID] (Uint8Array).
+// - args[1] - The contents of the message (string).
+// - args[2] - The lease of the message. This will be how long the message is
+// valid until, in milliseconds. As per the [channels.Manager]
+// documentation, this has different meanings depending on the use case.
+// These use cases may be generic enough that they will not be enumerated
+// here (int).
+// - args[3] - JSON of [xxdk.CMIXParams]. If left empty
+// [bindings.GetDefaultCMixParams] will be used internally (Uint8Array).
+//
+// Returns a promise:
+// - Resolves to the JSON of [bindings.ChannelSendReport] (Uint8Array).
+// - Rejected with an error if sending fails.
+func (ch *DMClient) SendText(_ js.Value, args []js.Value) any {
+ partnerPubKeyBytes := utils.CopyBytesToGo(args[0])
+ partnerToken := args[1].Int()
+ message := args[2].String()
+ leaseTimeMS := int64(args[3].Int())
+ cmixParamsJSON := utils.CopyBytesToGo(args[4])
+
+ promiseFn := func(resolve, reject func(args ...any) js.Value) {
+ sendReport, err := ch.api.SendText(partnerPubKeyBytes,
+ uint32(partnerToken), message, leaseTimeMS,
+ cmixParamsJSON)
+ if err != nil {
+ reject(utils.JsTrace(err))
+ } else {
+ resolve(utils.CopyBytesToJS(sendReport))
+ }
+ }
+
+ return utils.CreatePromise(promiseFn)
+}
+
+// SendReply is used to send a formatted message over a channel. Due to the
+// underlying encoding using compression, it isn't possible to define the
+// largest payload that can be sent, but it will always be possible to send a
+// payload of 766 bytes at minimum.
+//
+// If the message ID the reply is sent to is nonexistent, the other side will
+// post the message as a normal message and not a reply. The message will auto
+// delete validUntil after the round it is sent in, lasting forever if
+// [channels.ValidForever] is used.
+//
+// Parameters:
+// - args[0] - Marshalled bytes of the channel [id.ID] (Uint8Array).
+// - args[1] - The contents of the message. The message should be at most 510
+// bytes. This is expected to be Unicode, and thus a string data type is
+// expected (string).
+// - args[2] - JSON of [channel.MessageID] of the message you wish to reply
+// to. This may be found in the [bindings.ChannelSendReport] if replying to
+// your own. Alternatively, if reacting to another user's message, you may
+// retrieve it via the [bindings.ChannelMessageReceptionCallback] registered
+// using RegisterReceiveHandler (Uint8Array).
+// - args[3] - The lease of the message. This will be how long the message is
+// valid until, in milliseconds. As per the [channels.Manager]
+// documentation, this has different meanings depending on the use case.
+// These use cases may be generic enough that they will not be enumerated
+// here (int).
+// - args[4] - JSON of [xxdk.CMIXParams]. If left empty
+// [bindings.GetDefaultCMixParams] will be used internally (Uint8Array).
+//
+// Returns a promise:
+// - Resolves to the JSON of [bindings.ChannelSendReport] (Uint8Array).
+// - Rejected with an error if sending fails.
+func (ch *DMClient) SendReply(_ js.Value, args []js.Value) any {
+ partnerPubKeyBytes := utils.CopyBytesToGo(args[0])
+ partnerToken := args[1].Int()
+ replyID := utils.CopyBytesToGo(args[2])
+ message := args[3].String()
+ leaseTimeMS := int64(args[4].Int())
+ cmixParamsJSON := utils.CopyBytesToGo(args[5])
+
+ promiseFn := func(resolve, reject func(args ...any) js.Value) {
+ sendReport, err := ch.api.SendReply(partnerPubKeyBytes,
+ uint32(partnerToken), message, replyID, leaseTimeMS,
+ cmixParamsJSON)
+ if err != nil {
+ reject(utils.JsTrace(err))
+ } else {
+ resolve(utils.CopyBytesToJS(sendReport))
+ }
+ }
+
+ return utils.CreatePromise(promiseFn)
+}
+
+// SendReaction is used to send a reaction to a message over a channel.
+// The reaction must be a single emoji with no other characters, and will
+// be rejected otherwise.
+// Users will drop the reaction if they do not recognize the reactTo message.
+//
+// Parameters:
+// - args[0] - Marshalled bytes of the channel [id.ID] (Uint8Array).
+// - args[1] - The user's reaction. This should be a single emoji with no
+// other characters. As such, a Unicode string is expected (string).
+// - args[2] - JSON of [channel.MessageID] of the message you wish to reply
+// to. This may be found in the [bindings.ChannelSendReport] if replying to
+// your own. Alternatively, if reacting to another user's message, you may
+// retrieve it via the ChannelMessageReceptionCallback registered using
+// RegisterReceiveHandler (Uint8Array).
+// - args[3] - JSON of [xxdk.CMIXParams]. If left empty
+// [bindings.GetDefaultCMixParams] will be used internally (Uint8Array).
+//
+// Returns a promise:
+// - Resolves to the JSON of [bindings.ChannelSendReport] (Uint8Array).
+// - Rejected with an error if sending fails.
+func (ch *DMClient) SendReaction(_ js.Value, args []js.Value) any {
+ partnerPubKeyBytes := utils.CopyBytesToGo(args[0])
+ partnerToken := args[1].Int()
+ replyID := utils.CopyBytesToGo(args[2])
+ message := args[3].String()
+ cmixParamsJSON := utils.CopyBytesToGo(args[4])
+
+ promiseFn := func(resolve, reject func(args ...any) js.Value) {
+ sendReport, err := ch.api.SendReaction(partnerPubKeyBytes,
+ uint32(partnerToken), message, replyID,
+ cmixParamsJSON)
+ if err != nil {
+ reject(utils.JsTrace(err))
+ } else {
+ resolve(utils.CopyBytesToJS(sendReport))
+ }
+ }
+
+ return utils.CreatePromise(promiseFn)
+}
+
+// GetIdentity returns the marshaled public identity ([codename.Identity]) that
+// the client is using.
+//
+// Returns:
+// - JSON of the [channel.Identity] (Uint8Array).
+// - Throws TypeError if marshalling the identity fails.
+func (ch *DMClient) GetIdentity(js.Value, []js.Value) any {
+ i := ch.api.GetIdentity()
+
+ return utils.CopyBytesToJS(i)
+}
+
+// ExportPrivateIdentity encrypts and exports the private identity to a portable
+// string.
+//
+// Parameters:
+// - args[0] - Password to encrypt the identity with (string).
+//
+// Returns:
+// - JSON of the encrypted private identity (Uint8Array).
+// - Throws TypeError if exporting the identity fails.
+func (ch *DMClient) ExportPrivateIdentity(_ js.Value, args []js.Value) any {
+ i, err := ch.api.ExportPrivateIdentity(args[0].String())
+ if err != nil {
+ utils.Throw(utils.TypeError, err)
+ return nil
+ }
+
+ return utils.CopyBytesToJS(i)
+}
+
+// SetNickname sets the nickname for a given channel. The nickname must be valid
+// according to [IsNicknameValid].
+//
+// Parameters:
+// - args[0] - The nickname to set (string).
+// - args[1] - Marshalled bytes if the channel's [id.ID] (Uint8Array).
+//
+// Returns:
+// - Throws TypeError if unmarshalling the ID fails or the nickname is
+// invalid.
+func (ch *DMClient) SetNickname(_ js.Value, args []js.Value) any {
+ ch.api.SetNickname(args[0].String())
+ return nil
+}
+
+// GetNickname returns the nickname set for a given channel. Returns an error if
+// there is no nickname set.
+//
+// Parameters:
+// - args[0] - Marshalled bytes if the channel's [id.ID] (Uint8Array).
+//
+// Returns:
+// - The nickname (string).
+// - Throws TypeError if the channel has no nickname set.
+func (ch *DMClient) GetNickname(_ js.Value, args []js.Value) any {
+ nickname, err := ch.api.GetNickname(utils.CopyBytesToGo(args[0]))
+ if err != nil {
+ utils.Throw(utils.TypeError, err)
+ return nil
+ }
+
+ return nickname
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Channel Receiving Logic and Callback Registration //
+////////////////////////////////////////////////////////////////////////////////
+
+// channelMessageReceptionCallback wraps Javascript callbacks to adhere to the
+// [bindings.ChannelMessageReceptionCallback] interface.
+type dmReceptionCallback struct {
+ callback func(args ...any) js.Value
+}
+
+// Callback returns the context for a channel message.
+//
+// Parameters:
+// - receivedChannelMessageReport - Returns the JSON of
+// [bindings.ReceivedChannelMessageReport] (Uint8Array).
+// - err - Returns an error on failure (Error).
+//
+// Returns:
+// - It must return a unique UUID for the message that it can be referenced by
+// later (int).
+func (cmrCB *dmReceptionCallback) Callback(
+ receivedChannelMessageReport []byte, err error) int {
+ uuid := cmrCB.callback(
+ utils.CopyBytesToJS(receivedChannelMessageReport),
+ utils.JsTrace(err))
+
+ return uuid.Int()
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Event Model Logic //
+////////////////////////////////////////////////////////////////////////////////
+
+// dmReceiver wraps Javascript callbacks to adhere to the [bindings.EventModel]
+// interface.
+type dmReceiver struct {
+ receive func(args ...any) js.Value
+ receiveText func(args ...any) js.Value
+ receiveReply func(args ...any) js.Value
+ receiveReaction func(args ...any) js.Value
+ updateSentStatus func(args ...any) js.Value
+}
+
+// ReceiveMessage is called whenever a message is received on a given channel.
+// It may be called multiple times on the same message. It is incumbent on the
+// user of the API to filter such called by message ID.
+//
+// Parameters:
+// - channelID - Marshalled bytes of the channel [id.ID] (Uint8Array).
+// - messageID - The bytes of the [channel.MessageID] of the received message
+// (Uint8Array).
+// - nickname - The nickname of the sender of the message (string).
+// - text - The content of the message (string).
+// - pubKey - The sender's Ed25519 public key (Uint8Array).
+// - dmToken - The dmToken (int32).
+// - codeset - The codeset version (int).
+// - timestamp - Time the message was received; represented as nanoseconds
+// since unix epoch (int).
+// - lease - The number of nanoseconds that the message is valid for (int).
+// - roundId - The ID of the round that the message was received on (int).
+// - msgType - The type of message ([channels.MessageType]) to send (int).
+// - status - The [channels.SentStatus] of the message (int).
+//
+// Statuses will be enumerated as such:
+//
+// Sent = 0
+// Delivered = 1
+// Failed = 2
+//
+// Returns:
+// - A non-negative unique UUID for the message that it can be referenced by
+// later with [dmReceiver.UpdateSentStatus].
+func (em *dmReceiver) Receive(messageID []byte, nickname string,
+ text []byte, pubKey []byte, dmToken int32, codeset int, timestamp,
+ roundId, mType, status int64) int64 {
+ uuid := em.receive(messageID, nickname, text, pubKey, dmToken,
+ codeset, timestamp, roundId, mType, status)
+
+ return int64(uuid.Int())
+}
+
+// ReceiveText is called whenever a message is received that is a reply on a
+// given channel. It may be called multiple times on the same message. It is
+// incumbent on the user of the API to filter such called by message ID.
+//
+// Messages may arrive our of order, so a reply in theory can arrive before the
+// initial message. As a result, it may be important to buffer replies.
+//
+// Parameters:
+// - channelID - Marshalled bytes of the channel [id.ID] (Uint8Array).
+// - messageID - The bytes of the [channel.MessageID] of the received message
+// (Uint8Array).
+// - reactionTo - The [channel.MessageID] for the message that received a
+// reply (Uint8Array).
+// - senderUsername - The username of the sender of the message (string).
+// - text - The content of the message (string).
+// - pubKey - The sender's Ed25519 public key (Uint8Array).
+// - dmToken - The dmToken (int32).
+// - codeset - The codeset version (int).
+// - timestamp - Time the message was received; represented as nanoseconds
+// since unix epoch (int).
+// - lease - The number of nanoseconds that the message is valid for (int).
+// - roundId - The ID of the round that the message was received on (int).
+// - msgType - The type of message ([channels.MessageType]) to send (int).
+// - status - The [channels.SentStatus] of the message (int).
+//
+// Statuses will be enumerated as such:
+//
+// Sent = 0
+// Delivered = 1
+// Failed = 2
+//
+// Returns:
+// - A non-negative unique UUID for the message that it can be referenced by
+// later with [dmReceiver.UpdateSentStatus].
+func (em *dmReceiver) ReceiveText(messageID []byte, nickname, text string,
+ pubKey []byte, dmToken int32, codeset int, timestamp,
+ roundId, status int64) int64 {
+
+ uuid := em.receiveText(messageID, nickname, text, pubKey, dmToken,
+ codeset, timestamp, roundId, status)
+
+ return int64(uuid.Int())
+}
+
+// ReceiveReply is called whenever a message is received that is a reply on a
+// given channel. It may be called multiple times on the same message. It is
+// incumbent on the user of the API to filter such called by message ID.
+//
+// Messages may arrive our of order, so a reply in theory can arrive before the
+// initial message. As a result, it may be important to buffer replies.
+//
+// Parameters:
+// - channelID - Marshalled bytes of the channel [id.ID] (Uint8Array).
+// - messageID - The bytes of the [channel.MessageID] of the received message
+// (Uint8Array).
+// - reactionTo - The [channel.MessageID] for the message that received a
+// reply (Uint8Array).
+// - senderUsername - The username of the sender of the message (string).
+// - text - The content of the message (string).
+// - pubKey - The sender's Ed25519 public key (Uint8Array).
+// - dmToken - The dmToken (int32).
+// - codeset - The codeset version (int).
+// - timestamp - Time the message was received; represented as nanoseconds
+// since unix epoch (int).
+// - lease - The number of nanoseconds that the message is valid for (int).
+// - roundId - The ID of the round that the message was received on (int).
+// - msgType - The type of message ([channels.MessageType]) to send (int).
+// - status - The [channels.SentStatus] of the message (int).
+//
+// Statuses will be enumerated as such:
+//
+// Sent = 0
+// Delivered = 1
+// Failed = 2
+//
+// Returns:
+// - A non-negative unique UUID for the message that it can be referenced by
+// later with [dmReceiver.UpdateSentStatus].
+func (em *dmReceiver) ReceiveReply(messageID, replyTo []byte, nickname,
+ text string, pubKey []byte, dmToken int32, codeset int,
+ timestamp, roundId, status int64) int64 {
+ uuid := em.receiveReply(messageID, replyTo, nickname, text, pubKey,
+ dmToken, codeset, timestamp, roundId, status)
+
+ return int64(uuid.Int())
+}
+
+// ReceiveReaction is called whenever a reaction to a message is received on a
+// given channel. It may be called multiple times on the same reaction. It is
+// incumbent on the user of the API to filter such called by message ID.
+//
+// Messages may arrive our of order, so a reply in theory can arrive before the
+// initial message. As a result, it may be important to buffer reactions.
+//
+// Parameters:
+// - channelID - Marshalled bytes of the channel [id.ID] (Uint8Array).
+// - messageID - The bytes of the [channel.MessageID] of the received message
+// (Uint8Array).
+// - reactionTo - The [channel.MessageID] for the message that received a
+// reply (Uint8Array).
+// - senderUsername - The username of the sender of the message (string).
+// - reaction - The contents of the reaction message (string).
+// - pubKey - The sender's Ed25519 public key (Uint8Array).
+// - dmToken - The dmToken (int32).
+// - codeset - The codeset version (int).
+// - timestamp - Time the message was received; represented as nanoseconds
+// since unix epoch (int).
+// - lease - The number of nanoseconds that the message is valid for (int).
+// - roundId - The ID of the round that the message was received on (int).
+// - msgType - The type of message ([channels.MessageType]) to send (int).
+// - status - The [channels.SentStatus] of the message (int).
+//
+// Statuses will be enumerated as such:
+//
+// Sent = 0
+// Delivered = 1
+// Failed = 2
+//
+// Returns:
+// - A non-negative unique UUID for the message that it can be referenced by
+// later with [dmReceiver.UpdateSentStatus].
+func (em *dmReceiver) ReceiveReaction(messageID, reactionTo []byte,
+ nickname, reaction string, pubKey []byte, dmToken int32,
+ codeset int, timestamp, roundId,
+ status int64) int64 {
+ uuid := em.receiveReaction(messageID, reactionTo, nickname, reaction,
+ pubKey, dmToken, codeset, timestamp, roundId, status)
+
+ return int64(uuid.Int())
+}
+
+// UpdateSentStatus is called whenever the sent status of a message has
+// changed.
+//
+// Parameters:
+// - uuid - The unique identifier for the message (int).
+// - messageID - The bytes of the [channel.MessageID] of the received message
+// (Uint8Array).
+// - timestamp - Time the message was received; represented as nanoseconds
+// since unix epoch (int).
+// - roundId - The ID of the round that the message was received on (int).
+// - status - The [channels.SentStatus] of the message (int).
+//
+// Statuses will be enumerated as such:
+//
+// Sent = 0
+// Delivered = 1
+// Failed = 2
+func (em *dmReceiver) UpdateSentStatus(uuid int64, messageID []byte,
+ timestamp, roundID, status int64) {
+ em.updateSentStatus(uuid, utils.CopyBytesToJS(messageID),
+ timestamp, roundID, status)
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// DM DB Cipher //
+////////////////////////////////////////////////////////////////////////////////
+
+// DMDbCipher wraps the [bindings.DMDbCipher] object so its methods
+// can be wrapped to be Javascript compatible.
+type DMDbCipher struct {
+ api *bindings.DMDbCipher
+}
+
+// newDMDbCipherJS creates a new Javascript compatible object
+// (map[string]any) that matches the [DMDbCipher] structure.
+func newDMDbCipherJS(api *bindings.DMDbCipher) map[string]any {
+ c := DMDbCipher{api}
+ channelDbCipherMap := map[string]any{
+ "GetID": js.FuncOf(c.GetID),
+ "Encrypt": js.FuncOf(c.Encrypt),
+ "Decrypt": js.FuncOf(c.Decrypt),
+ "MarshalJSON": js.FuncOf(c.MarshalJSON),
+ "UnmarshalJSON": js.FuncOf(c.UnmarshalJSON),
+ }
+
+ return channelDbCipherMap
+}
+
+// NewDMsDatabaseCipher constructs a [DMDbCipher] object.
+//
+// Parameters:
+// - args[0] - The tracked [Cmix] object ID (int).
+// - args[1] - The password for storage. This should be the same password
+// passed into [NewCmix] (Uint8Array).
+// - args[2] - The maximum size of a payload to be encrypted. A payload passed
+// into [DMDbCipher.Encrypt] that is larger than this value will result
+// in an error (int).
+//
+// Returns:
+// - JavaScript representation of the [DMDbCipher] object.
+// - Throws a TypeError if creating the cipher fails.
+func NewDMsDatabaseCipher(_ js.Value, args []js.Value) any {
+ cmixId := args[0].Int()
+ password := utils.CopyBytesToGo(args[1])
+ plaintTextBlockSize := args[2].Int()
+
+ cipher, err := bindings.NewDMsDatabaseCipher(
+ cmixId, password, plaintTextBlockSize)
+ if err != nil {
+ utils.Throw(utils.TypeError, err)
+ return nil
+ }
+
+ return newDMDbCipherJS(cipher)
+}
+
+// GetID returns the ID for this [bindings.DMDbCipher] in the
+// channelDbCipherTracker.
+//
+// Returns:
+// - Tracker ID (int).
+func (c *DMDbCipher) GetID(js.Value, []js.Value) any {
+ return c.api.GetID()
+}
+
+// Encrypt will encrypt the raw data. It will return a ciphertext. Padding is
+// done on the plaintext so all encrypted data looks uniform at rest.
+//
+// Parameters:
+// - args[0] - The data to be encrypted (Uint8Array). This must be smaller
+// than the block size passed into [NewDMsDatabaseCipher]. If it is
+// larger, this will return an error.
+//
+// Returns:
+// - The ciphertext of the plaintext passed in (Uint8Array).
+// - Throws a TypeError if it fails to encrypt the plaintext.
+func (c *DMDbCipher) Encrypt(_ js.Value, args []js.Value) any {
+ ciphertext, err := c.api.Encrypt(utils.CopyBytesToGo(args[0]))
+ if err != nil {
+ utils.Throw(utils.TypeError, err)
+ return nil
+ }
+
+ return utils.CopyBytesToJS(ciphertext)
+}
+
+// Decrypt will decrypt the passed in encrypted value. The plaintext will be
+// returned by this function. Any padding will be discarded within this
+// function.
+//
+// Parameters:
+// - args[0] - the encrypted data returned by [DMDbCipher.Encrypt]
+// (Uint8Array).
+//
+// Returns:
+// - The plaintext of the ciphertext passed in (Uint8Array).
+// - Throws a TypeError if it fails to encrypt the plaintext.
+func (c *DMDbCipher) Decrypt(_ js.Value, args []js.Value) any {
+ plaintext, err := c.api.Decrypt(utils.CopyBytesToGo(args[0]))
+ if err != nil {
+ utils.Throw(utils.TypeError, err)
+ return nil
+ }
+
+ return utils.CopyBytesToJS(plaintext)
+}
+
+// MarshalJSON marshals the cipher into valid JSON.
+//
+// Returns:
+// - JSON of the cipher (Uint8Array).
+// - Throws a TypeError if marshalling fails.
+func (c *DMDbCipher) MarshalJSON(js.Value, []js.Value) any {
+ data, err := c.api.MarshalJSON()
+ if err != nil {
+ utils.Throw(utils.TypeError, err)
+ return nil
+ }
+
+ return utils.CopyBytesToJS(data)
+}
+
+// UnmarshalJSON unmarshalls JSON into the cipher. This function adheres to the
+// json.Unmarshaler interface.
+//
+// Note that this function does not transfer the internal RNG. Use
+// [channel.NewCipherFromJSON] to properly reconstruct a cipher from JSON.
+//
+// Parameters:
+// - args[0] - JSON data to unmarshal (Uint8Array).
+//
+// Returns:
+// - JSON of the cipher (Uint8Array).
+// - Throws a TypeError if marshalling fails.
+func (c *DMDbCipher) UnmarshalJSON(_ js.Value, args []js.Value) any {
+ err := c.api.UnmarshalJSON(utils.CopyBytesToGo(args[0]))
+ if err != nil {
+ utils.Throw(utils.TypeError, err)
+ return nil
+ }
+ return nil
+}
diff --git a/wasm/docs.go b/wasm/docs.go
index 5e0466b523642f81398eaebac5cfc820ea69adf6..b2d6f4894014b15873b2649118e2af09a8cd7091 100644
--- a/wasm/docs.go
+++ b/wasm/docs.go
@@ -24,11 +24,11 @@ import (
"gitlab.com/elixxir/client/v4/restlike"
"gitlab.com/elixxir/client/v4/single"
"gitlab.com/elixxir/crypto/broadcast"
- "gitlab.com/elixxir/crypto/channel"
"gitlab.com/elixxir/crypto/contact"
"gitlab.com/elixxir/crypto/cyclic"
"gitlab.com/elixxir/crypto/fileTransfer"
"gitlab.com/elixxir/crypto/group"
+ cryptoMessage "gitlab.com/elixxir/crypto/message"
"gitlab.com/elixxir/primitives/fact"
"gitlab.com/elixxir/primitives/format"
"gitlab.com/xx_network/primitives/id"
@@ -51,7 +51,7 @@ var (
_ = connect.Callback(nil)
_ = partner.Manager(nil)
_ = ndf.NetworkDefinition{}
- _ = channel.MessageID{}
+ _ = cryptoMessage.ID{}
_ = channels.SentStatus(0)
_ = ftE2e.Params{}
_ = fileTransfer.TransferID{}
diff --git a/wasm_test.go b/wasm_test.go
index 97aab01dceb11834f53a541c57a4be2de0ccc069..68cc545ba79c45b67cf1eefdb596e28c69b5eba3 100644
--- a/wasm_test.go
+++ b/wasm_test.go
@@ -48,6 +48,12 @@ func TestPublicFunctions(t *testing.T) {
// client versions
"GetGitVersion": {},
"GetDependencies": {},
+
+ // DM Functions these are used but not exported by
+ // WASM bindins, so are not exposed.
+ "NewDMReceiver": {},
+ "NewDMClientWithGoEventModel": {},
+ "GetDMDbCipherTrackerFromID": {},
}
wasmFuncs := getPublicFunctions("wasm", t)
bindingsFuncs := getPublicFunctions(