slidge-whatsapp 0.2.5__cp311-cp311-manylinux_2_36_aarch64.whl → 0.3.0__cp311-cp311-manylinux_2_36_aarch64.whl

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/notification.go

@@ -7,8 +7,10 @@
 package whatsmeow
 
 import (
+	"context"
 	"encoding/json"
 	"errors"
+	"slices"
 
 	"google.golang.org/protobuf/proto"
 
@@ -20,7 +22,7 @@ import (
 	"go.mau.fi/whatsmeow/types/events"
 )
 
-func (cli *Client) handleEncryptNotification(node *waBinary.Node) {
+func (cli *Client) handleEncryptNotification(ctx context.Context, node *waBinary.Node) {
 	from := node.AttrGetter().JID("from")
 	if from == types.ServerJID {
 		count := node.GetChildByTag("count")
@@ -32,15 +34,15 @@ func (cli *Client) handleEncryptNotification(node *waBinary.Node) {
 		}
 		cli.Log.Infof("Got prekey count from server: %s", node.XMLString())
 		if otksLeft < MinPreKeyCount {
-			cli.uploadPreKeys()
+			cli.uploadPreKeys(ctx)
 		}
 	} else if _, ok := node.GetOptionalChildByTag("identity"); ok {
 		cli.Log.Debugf("Got identity change for %s: %s, deleting all identities/sessions for that number", from, node.XMLString())
-		err := cli.Store.Identities.DeleteAllIdentities(from.User)
+		err := cli.Store.Identities.DeleteAllIdentities(ctx, from.User)
 		if err != nil {
 			cli.Log.Warnf("Failed to delete all identities of %s from store after identity change: %v", from, err)
 		}
-		err = cli.Store.Sessions.DeleteAllSessions(from.User)
+		err = cli.Store.Sessions.DeleteAllSessions(ctx, from.User)
 		if err != nil {
 			cli.Log.Warnf("Failed to delete all sessions of %s from store after identity change: %v", from, err)
 		}
@@ -51,13 +53,13 @@ func (cli *Client) handleEncryptNotification(node *waBinary.Node) {
 	}
 }
 
-func (cli *Client) handleAppStateNotification(node *waBinary.Node) {
+func (cli *Client) handleAppStateNotification(ctx context.Context, node *waBinary.Node) {
 	for _, collection := range node.GetChildrenByTag("collection") {
 		ag := collection.AttrGetter()
 		name := appstate.WAPatchName(ag.String("name"))
 		version := ag.Uint64("version")
 		cli.Log.Debugf("Got server sync notification that app state %s has updated to version %d", name, version)
-		err := cli.FetchAppState(name, false, false)
+		err := cli.FetchAppState(ctx, name, false, false)
 		if errors.Is(err, ErrIQDisconnected) || errors.Is(err, ErrNotConnected) {
 			// There are some app state changes right before a remote logout, so stop syncing if we're disconnected.
 			cli.Log.Debugf("Failed to sync app state after notification: %v, not trying to sync other states", err)
@@ -68,7 +70,7 @@ func (cli *Client) handleAppStateNotification(node *waBinary.Node) {
 	}
 }
 
-func (cli *Client) handlePictureNotification(node *waBinary.Node) {
+func (cli *Client) handlePictureNotification(ctx context.Context, node *waBinary.Node) {
 	ts := node.AttrGetter().UnixTime("t")
 	for _, child := range node.GetChildren() {
 		ag := child.AttrGetter()
@@ -94,16 +96,26 @@ func (cli *Client) handlePictureNotification(node *waBinary.Node) {
 	}
 }
 
-func (cli *Client) handleDeviceNotification(node *waBinary.Node) {
+func (cli *Client) handleDeviceNotification(ctx context.Context, node *waBinary.Node) {
 	cli.userDevicesCacheLock.Lock()
 	defer cli.userDevicesCacheLock.Unlock()
 	ag := node.AttrGetter()
 	from := ag.JID("from")
+	fromLID := ag.OptionalJID("lid")
+	if fromLID != nil {
+		cli.StoreLIDPNMapping(ctx, *fromLID, from)
+	}
 	cached, ok := cli.userDevicesCache[from]
 	if !ok {
 		cli.Log.Debugf("No device list cached for %s, ignoring device list notification", from)
 		return
 	}
+	var cachedLID deviceCache
+	var cachedLIDHash string
+	if fromLID != nil {
+		cachedLID = cli.userDevicesCache[*fromLID]
+		cachedLIDHash = participantListHashV2(cachedLID.devices)
+	}
 	cachedParticipantHash := participantListHashV2(cached.devices)
 	for _, child := range node.GetChildren() {
 		if child.Tag != "add" && child.Tag != "remove" {
@@ -112,16 +124,24 @@ func (cli *Client) handleDeviceNotification(node *waBinary.Node) {
 		}
 		cag := child.AttrGetter()
 		deviceHash := cag.String("device_hash")
+		deviceLIDHash := cag.OptionalString("device_lid_hash")
 		deviceChild, _ := child.GetOptionalChildByTag("device")
 		changedDeviceJID := deviceChild.AttrGetter().JID("jid")
+		changedDeviceLID := deviceChild.AttrGetter().OptionalJID("lid")
 		switch child.Tag {
 		case "add":
 			cached.devices = append(cached.devices, changedDeviceJID)
+			if changedDeviceLID != nil {
+				cachedLID.devices = append(cachedLID.devices, *changedDeviceLID)
+			}
 		case "remove":
-			for i, jid := range cached.devices {
-				if jid == changedDeviceJID {
-					cached.devices = append(cached.devices[:i], cached.devices[i+1:]...)
-				}
+			cached.devices = slices.DeleteFunc(cached.devices, func(existing types.JID) bool {
+				return existing == changedDeviceJID
+			})
+			if changedDeviceLID != nil {
+				cachedLID.devices = slices.DeleteFunc(cachedLID.devices, func(existing types.JID) bool {
+					return existing == *changedDeviceLID
+				})
 			}
 		case "update":
 			// ???
@@ -134,10 +154,20 @@ func (cli *Client) handleDeviceNotification(node *waBinary.Node) {
 			cli.Log.Warnf("%s's device list hash changed from %s to %s (%s). New hash doesn't match (%s)", from, cachedParticipantHash, deviceHash, child.Tag, newParticipantHash)
 			delete(cli.userDevicesCache, from)
 		}
+		if fromLID != nil && changedDeviceLID != nil && deviceLIDHash != "" {
+			newLIDParticipantHash := participantListHashV2(cachedLID.devices)
+			if newLIDParticipantHash == deviceLIDHash {
+				cli.Log.Debugf("%s's device list hash changed from %s to %s (%s). New hash matches", fromLID, cachedLIDHash, deviceLIDHash, child.Tag)
+				cli.userDevicesCache[*fromLID] = cachedLID
+			} else {
+				cli.Log.Warnf("%s's device list hash changed from %s to %s (%s). New hash doesn't match (%s)", fromLID, cachedLIDHash, deviceLIDHash, child.Tag, newLIDParticipantHash)
+				delete(cli.userDevicesCache, *fromLID)
+			}
+		}
 	}
 }
 
-func (cli *Client) handleFBDeviceNotification(node *waBinary.Node) {
+func (cli *Client) handleFBDeviceNotification(ctx context.Context, node *waBinary.Node) {
 	cli.userDevicesCacheLock.Lock()
 	defer cli.userDevicesCacheLock.Unlock()
 	jid := node.AttrGetter().JID("from")
@@ -145,7 +175,7 @@ func (cli *Client) handleFBDeviceNotification(node *waBinary.Node) {
 	cli.userDevicesCache[jid] = userDevices
 }
 
-func (cli *Client) handleOwnDevicesNotification(node *waBinary.Node) {
+func (cli *Client) handleOwnDevicesNotification(ctx context.Context, node *waBinary.Node) {
 	cli.userDevicesCacheLock.Lock()
 	defer cli.userDevicesCacheLock.Unlock()
 	ownID := cli.getOwnID().ToNonAD()
@@ -177,7 +207,7 @@ func (cli *Client) handleOwnDevicesNotification(node *waBinary.Node) {
 	}
 }
 
-func (cli *Client) handleBlocklist(node *waBinary.Node) {
+func (cli *Client) handleBlocklist(ctx context.Context, node *waBinary.Node) {
 	ag := node.AttrGetter()
 	evt := events.Blocklist{
 		Action:    events.BlocklistAction(ag.OptionalString("action")),
@@ -199,29 +229,30 @@ func (cli *Client) handleBlocklist(node *waBinary.Node) {
 	cli.dispatchEvent(&evt)
 }
 
-func (cli *Client) handleAccountSyncNotification(node *waBinary.Node) {
+func (cli *Client) handleAccountSyncNotification(ctx context.Context, node *waBinary.Node) {
 	for _, child := range node.GetChildren() {
 		switch child.Tag {
 		case "privacy":
-			cli.handlePrivacySettingsNotification(&child)
+			cli.handlePrivacySettingsNotification(ctx, &child)
 		case "devices":
-			cli.handleOwnDevicesNotification(&child)
+			cli.handleOwnDevicesNotification(ctx, &child)
 		case "picture":
 			cli.dispatchEvent(&events.Picture{
 				Timestamp: node.AttrGetter().UnixTime("t"),
 				JID:       cli.getOwnID().ToNonAD(),
 			})
 		case "blocklist":
-			cli.handleBlocklist(&child)
+			cli.handleBlocklist(ctx, &child)
 		default:
 			cli.Log.Debugf("Unhandled account sync item %s", child.Tag)
 		}
 	}
 }
 
-func (cli *Client) handlePrivacyTokenNotification(node *waBinary.Node) {
-	ownID := cli.getOwnID().ToNonAD()
-	if ownID.IsEmpty() {
+func (cli *Client) handlePrivacyTokenNotification(ctx context.Context, node *waBinary.Node) {
+	ownJID := cli.getOwnID().ToNonAD()
+	ownLID := cli.getOwnLID().ToNonAD()
+	if ownJID.IsEmpty() {
 		cli.Log.Debugf("Ignoring privacy token notification, session was deleted")
 		return
 	}
@@ -240,8 +271,11 @@ func (cli *Client) handlePrivacyTokenNotification(node *waBinary.Node) {
 		ag := child.AttrGetter()
 		if child.Tag != "token" {
 			cli.Log.Warnf("privacy_token notification contained unexpected <%s> tag", child.Tag)
-		} else if targetUser := ag.JID("jid"); targetUser != ownID {
-			cli.Log.Warnf("privacy_token notification contained token for different user %s", targetUser)
+		} else if targetUser := ag.JID("jid"); targetUser != ownLID && targetUser != ownJID {
+			// Don't log about own privacy tokens for other users
+			if sender != ownJID && sender != ownLID {
+				cli.Log.Warnf("privacy_token notification contained token for different user %s", targetUser)
+			}
 		} else if tokenType := ag.String("type"); tokenType != "trusted_contact" {
 			cli.Log.Warnf("privacy_token notification contained unexpected token type %s", tokenType)
 		} else if token, ok := child.Content.([]byte); !ok {
@@ -251,7 +285,7 @@ func (cli *Client) handlePrivacyTokenNotification(node *waBinary.Node) {
 			if !ag.OK() {
 				cli.Log.Warnf("privacy_token notification is missing some fields: %v", ag.Error())
 			}
-			err := cli.Store.PrivacyTokens.PutPrivacyTokens(store.PrivacyToken{
+			err := cli.Store.PrivacyTokens.PutPrivacyTokens(ctx, store.PrivacyToken{
 				User:      sender,
 				Token:     token,
 				Timestamp: timestamp,
@@ -308,7 +342,7 @@ func (cli *Client) parseNewsletterMessages(node *waBinary.Node) []*types.Newslet
 	return output
 }
 
-func (cli *Client) handleNewsletterNotification(node *waBinary.Node) {
+func (cli *Client) handleNewsletterNotification(ctx context.Context, node *waBinary.Node) {
 	ag := node.AttrGetter()
 	liveUpdates := node.GetChildByTag("live_updates")
 	cli.dispatchEvent(&events.NewsletterLiveUpdate{
@@ -331,7 +365,7 @@ type newsletterEvent struct {
 	// _on_state_change -> id, is_requestor, state
 }
 
-func (cli *Client) handleMexNotification(node *waBinary.Node) {
+func (cli *Client) handleMexNotification(ctx context.Context, node *waBinary.Node) {
 	for _, child := range node.GetChildren() {
 		if child.Tag != "update" {
 			continue
@@ -356,7 +390,7 @@ func (cli *Client) handleMexNotification(node *waBinary.Node) {
 	}
 }
 
-func (cli *Client) handleStatusNotification(node *waBinary.Node) {
+func (cli *Client) handleStatusNotification(ctx context.Context, node *waBinary.Node) {
 	ag := node.AttrGetter()
 	child, found := node.GetOptionalChildByTag("set")
 	if !found {
@@ -376,44 +410,50 @@ func (cli *Client) handleStatusNotification(node *waBinary.Node) {
 }
 
 func (cli *Client) handleNotification(node *waBinary.Node) {
+	ctx := cli.BackgroundEventCtx
 	ag := node.AttrGetter()
 	notifType := ag.String("type")
 	if !ag.OK() {
 		return
 	}
-	defer cli.maybeDeferredAck(node)()
+	var cancelled bool
+	defer cli.maybeDeferredAck(ctx, node)(&cancelled)
 	switch notifType {
 	case "encrypt":
-		go cli.handleEncryptNotification(node)
+		go cli.handleEncryptNotification(ctx, node)
 	case "server_sync":
-		go cli.handleAppStateNotification(node)
+		go cli.handleAppStateNotification(ctx, node)
 	case "account_sync":
-		go cli.handleAccountSyncNotification(node)
+		go cli.handleAccountSyncNotification(ctx, node)
 	case "devices":
-		cli.handleDeviceNotification(node)
+		cli.handleDeviceNotification(ctx, node)
 	case "fbid:devices":
-		cli.handleFBDeviceNotification(node)
+		cli.handleFBDeviceNotification(ctx, node)
 	case "w:gp2":
-		evt, err := cli.parseGroupNotification(node)
+		evt, lidPairs, err := cli.parseGroupNotification(node)
 		if err != nil {
 			cli.Log.Errorf("Failed to parse group notification: %v", err)
 		} else {
-			cli.dispatchEvent(evt)
+			err = cli.Store.LIDs.PutManyLIDMappings(ctx, lidPairs)
+			if err != nil {
+				cli.Log.Errorf("Failed to store LID mappings from group notification: %v", err)
+			}
+			cancelled = cli.dispatchEvent(evt)
 		}
 	case "picture":
-		cli.handlePictureNotification(node)
+		cli.handlePictureNotification(ctx, node)
 	case "mediaretry":
-		cli.handleMediaRetryNotification(node)
+		cli.handleMediaRetryNotification(ctx, node)
 	case "privacy_token":
-		cli.handlePrivacyTokenNotification(node)
+		cli.handlePrivacyTokenNotification(ctx, node)
 	case "link_code_companion_reg":
-		go cli.tryHandleCodePairNotification(node)
+		go cli.tryHandleCodePairNotification(ctx, node)
 	case "newsletter":
-		cli.handleNewsletterNotification(node)
+		cli.handleNewsletterNotification(ctx, node)
 	case "mex":
-		cli.handleMexNotification(node)
+		cli.handleMexNotification(ctx, node)
 	case "status":
-		cli.handleStatusNotification(node)
+		cli.handleStatusNotification(ctx, node)
 	// Other types: business, disappearing_mode, server, status, pay, psa
 	default:
 		cli.Log.Debugf("Unhandled notification with type %s", notifType)

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/pair-code.go

@@ -7,6 +7,7 @@
 package whatsmeow
 
 import (
+	"context"
 	"crypto/aes"
 	"crypto/cipher"
 	"crypto/sha256"
@@ -86,22 +87,23 @@ func generateCompanionEphemeralKey() (ephemeralKeyPair *keys.KeyPair, ephemeralK
 // (the server will validate it and return 400 if it's wrong).
 //
 // See https://faq.whatsapp.com/1324084875126592 for more info
-func (cli *Client) PairPhone(phone string, showPushNotification bool, clientType PairClientType, clientDisplayName string) (string, error) {
+func (cli *Client) PairPhone(ctx context.Context, phone string, showPushNotification bool, clientType PairClientType, clientDisplayName string) (string, error) {
 	if cli == nil {
 		return "", ErrClientIsNil
 	}
 	ephemeralKeyPair, ephemeralKey, encodedLinkingCode := generateCompanionEphemeralKey()
 	phone = notNumbers.ReplaceAllString(phone, "")
 	if len(phone) <= 6 {
-		return "", fmt.Errorf("phone number too short")
+		return "", ErrPhoneNumberTooShort
 	} else if strings.HasPrefix(phone, "0") {
-		return "", fmt.Errorf("international phone number required (must not start with 0)")
+		return "", ErrPhoneNumberIsNotInternational
 	}
 	jid := types.NewJID(phone, types.DefaultUserServer)
 	resp, err := cli.sendIQ(infoQuery{
 		Namespace: "md",
 		Type:      iqSet,
 		To:        types.ServerJID,
+		Context:   ctx,
 		Content: []waBinary.Node{{
 			Tag: "link_code_companion_reg",
 			Attrs: waBinary.Attrs{
@@ -139,14 +141,14 @@ func (cli *Client) PairPhone(phone string, showPushNotification bool, clientType
 	return encodedLinkingCode[0:4] + "-" + encodedLinkingCode[4:], nil
 }
 
-func (cli *Client) tryHandleCodePairNotification(parentNode *waBinary.Node) {
-	err := cli.handleCodePairNotification(parentNode)
+func (cli *Client) tryHandleCodePairNotification(ctx context.Context, parentNode *waBinary.Node) {
+	err := cli.handleCodePairNotification(ctx, parentNode)
 	if err != nil {
 		cli.Log.Errorf("Failed to handle code pair notification: %s", err)
 	}
 }
 
-func (cli *Client) handleCodePairNotification(parentNode *waBinary.Node) error {
+func (cli *Client) handleCodePairNotification(ctx context.Context, parentNode *waBinary.Node) error {
 	node, ok := parentNode.GetOptionalChildByTag("link_code_companion_reg")
 	if !ok {
 		return &ElementMissingError{
@@ -225,6 +227,7 @@ func (cli *Client) handleCodePairNotification(parentNode *waBinary.Node) error {
 		Namespace: "md",
 		Type:      iqSet,
 		To:        types.ServerJID,
+		Context:   ctx,
 		Content: []waBinary.Node{{
 			Tag: "link_code_companion_reg",
 			Attrs: waBinary.Attrs{

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/pair.go

@@ -8,6 +8,7 @@ package whatsmeow
 
 import (
 	"bytes"
+	"context"
 	"crypto/hmac"
 	"crypto/sha256"
 	"encoding/base64"
@@ -24,6 +25,13 @@ import (
 	"go.mau.fi/whatsmeow/util/keys"
 )
 
+var (
+	AdvPrefixAccountSignature                                = []byte{6, 0}
+	AdvPrefixDeviceSignatureGenerate                         = []byte{6, 1}
+	AdvHostedPrefixDeviceIdentityAccountSignature            = []byte{6, 5}
+	AdvHostedPrefixDeviceIdentityDeviceSignatureVerification = []byte{6, 6}
+)
+
 func (cli *Client) handleIQ(node *waBinary.Node) {
 	children := node.GetChildren()
 	if len(children) != 1 || node.Attrs["from"] != types.ServerJID {
@@ -82,34 +90,40 @@ func (cli *Client) handlePairSuccess(node *waBinary.Node) {
 	deviceIdentityBytes, _ := pairSuccess.GetChildByTag("device-identity").Content.([]byte)
 	businessName, _ := pairSuccess.GetChildByTag("biz").Attrs["name"].(string)
 	jid, _ := pairSuccess.GetChildByTag("device").Attrs["jid"].(types.JID)
+	lid, _ := pairSuccess.GetChildByTag("device").Attrs["lid"].(types.JID)
 	platform, _ := pairSuccess.GetChildByTag("platform").Attrs["name"].(string)
 
 	go func() {
-		err := cli.handlePair(deviceIdentityBytes, id, businessName, platform, jid)
+		err := cli.handlePair(context.TODO(), deviceIdentityBytes, id, businessName, platform, jid, lid)
 		if err != nil {
 			cli.Log.Errorf("Failed to pair device: %v", err)
 			cli.Disconnect()
-			cli.dispatchEvent(&events.PairError{ID: jid, BusinessName: businessName, Platform: platform, Error: err})
+			cli.dispatchEvent(&events.PairError{ID: jid, LID: lid, BusinessName: businessName, Platform: platform, Error: err})
 		} else {
 			cli.Log.Infof("Successfully paired %s", cli.Store.ID)
-			cli.dispatchEvent(&events.PairSuccess{ID: jid, BusinessName: businessName, Platform: platform})
+			cli.dispatchEvent(&events.PairSuccess{ID: jid, LID: lid, BusinessName: businessName, Platform: platform})
 		}
 	}()
 }
 
-func (cli *Client) handlePair(deviceIdentityBytes []byte, reqID, businessName, platform string, jid types.JID) error {
+func (cli *Client) handlePair(ctx context.Context, deviceIdentityBytes []byte, reqID, businessName, platform string, jid, lid types.JID) error {
 	var deviceIdentityContainer waAdv.ADVSignedDeviceIdentityHMAC
 	err := proto.Unmarshal(deviceIdentityBytes, &deviceIdentityContainer)
 	if err != nil {
 		cli.sendPairError(reqID, 500, "internal-error")
 		return &PairProtoError{"failed to parse device identity container in pair success message", err}
 	}
+	isHostedAccount := deviceIdentityContainer.AccountType != nil && *deviceIdentityContainer.AccountType == waAdv.ADVEncryptionType_HOSTED
 
 	h := hmac.New(sha256.New, cli.Store.AdvSecretKey)
+	if isHostedAccount {
+		h.Write(AdvHostedPrefixDeviceIdentityAccountSignature)
+	}
 	h.Write(deviceIdentityContainer.Details)
+
 	if !bytes.Equal(h.Sum(nil), deviceIdentityContainer.HMAC) {
 		cli.Log.Warnf("Invalid HMAC from pair success message")
-		cli.sendPairError(reqID, 401, "not-authorized")
+		cli.sendPairError(reqID, 401, "hmac-mismatch")
 		return ErrPairInvalidDeviceIdentityHMAC
 	}
 
@@ -120,12 +134,12 @@ func (cli *Client) handlePair(deviceIdentityBytes []byte, reqID, businessName, p
 		return &PairProtoError{"failed to parse signed device identity in pair success message", err}
 	}
 
-	if !verifyDeviceIdentityAccountSignature(&deviceIdentity, cli.Store.IdentityKey) {
-		cli.sendPairError(reqID, 401, "not-authorized")
+	if !verifyDeviceIdentityAccountSignature(&deviceIdentity, cli.Store.IdentityKey, isHostedAccount) {
+		cli.sendPairError(reqID, 401, "signature-mismatch")
 		return ErrPairInvalidDeviceSignature
 	}
 
-	deviceIdentity.DeviceSignature = generateDeviceSignature(&deviceIdentity, cli.Store.IdentityKey)[:]
+	deviceIdentity.DeviceSignature = generateDeviceSignature(&deviceIdentity, cli.Store.IdentityKey, isHostedAccount)[:]
 
 	var deviceIdentityDetails waAdv.ADVDeviceIdentity
 	err = proto.Unmarshal(deviceIdentity.Details, &deviceIdentityDetails)
@@ -141,8 +155,8 @@ func (cli *Client) handlePair(deviceIdentityBytes []byte, reqID, businessName, p
 
 	cli.Store.Account = proto.Clone(&deviceIdentity).(*waAdv.ADVSignedDeviceIdentity)
 
-	mainDeviceJID := jid
-	mainDeviceJID.Device = 0
+	mainDeviceLID := lid
+	mainDeviceLID.Device = 0
 	mainDeviceIdentity := *(*[32]byte)(deviceIdentity.AccountSignatureKey)
 	deviceIdentity.AccountSignatureKey = nil
 
@@ -153,16 +167,18 @@ func (cli *Client) handlePair(deviceIdentityBytes []byte, reqID, businessName, p
 	}
 
 	cli.Store.ID = &jid
+	cli.Store.LID = lid
 	cli.Store.BusinessName = businessName
 	cli.Store.Platform = platform
-	err = cli.Store.Save()
+	err = cli.Store.Save(ctx)
 	if err != nil {
 		cli.sendPairError(reqID, 500, "internal-error")
 		return &PairDatabaseError{"failed to save device store", err}
 	}
-	err = cli.Store.Identities.PutIdentity(mainDeviceJID.SignalAddress().String(), mainDeviceIdentity)
+	cli.StoreLIDPNMapping(ctx, lid, jid)
+	err = cli.Store.Identities.PutIdentity(ctx, mainDeviceLID.SignalAddress().String(), mainDeviceIdentity)
 	if err != nil {
-		_ = cli.Store.Delete()
+		_ = cli.Store.Delete(ctx)
 		cli.sendPairError(reqID, 500, "internal-error")
 		return &PairDatabaseError{"failed to store main device identity", err}
 	}
@@ -189,7 +205,7 @@ func (cli *Client) handlePair(deviceIdentityBytes []byte, reqID, businessName, p
 		}},
 	})
 	if err != nil {
-		_ = cli.Store.Delete()
+		_ = cli.Store.Delete(ctx)
 		return fmt.Errorf("failed to send pairing confirmation: %w", err)
 	}
 	return nil
@@ -208,7 +224,7 @@ func concatBytes(data ...[]byte) []byte {
 	return output
 }
 
-func verifyDeviceIdentityAccountSignature(deviceIdentity *waAdv.ADVSignedDeviceIdentity, ikp *keys.KeyPair) bool {
+func verifyDeviceIdentityAccountSignature(deviceIdentity *waAdv.ADVSignedDeviceIdentity, ikp *keys.KeyPair, isHostedAccount bool) bool {
 	if len(deviceIdentity.AccountSignatureKey) != 32 || len(deviceIdentity.AccountSignature) != 64 {
 		return false
 	}
@@ -216,12 +232,20 @@ func verifyDeviceIdentityAccountSignature(deviceIdentity *waAdv.ADVSignedDeviceI
 	signatureKey := ecc.NewDjbECPublicKey(*(*[32]byte)(deviceIdentity.AccountSignatureKey))
 	signature := *(*[64]byte)(deviceIdentity.AccountSignature)
 
-	message := concatBytes([]byte{6, 0}, deviceIdentity.Details, ikp.Pub[:])
+	prefix := AdvPrefixAccountSignature
+	if isHostedAccount {
+		prefix = AdvHostedPrefixDeviceIdentityAccountSignature
+	}
+	message := concatBytes(prefix, deviceIdentity.Details, ikp.Pub[:])
 	return ecc.VerifySignature(signatureKey, message, signature)
 }
 
-func generateDeviceSignature(deviceIdentity *waAdv.ADVSignedDeviceIdentity, ikp *keys.KeyPair) *[64]byte {
-	message := concatBytes([]byte{6, 1}, deviceIdentity.Details, ikp.Pub[:], deviceIdentity.AccountSignatureKey)
+func generateDeviceSignature(deviceIdentity *waAdv.ADVSignedDeviceIdentity, ikp *keys.KeyPair, isHostedAccount bool) *[64]byte {
+	prefix := AdvPrefixDeviceSignatureGenerate
+	if isHostedAccount {
+		prefix = AdvHostedPrefixDeviceIdentityDeviceSignatureVerification
+	}
+	message := concatBytes(prefix, deviceIdentity.Details, ikp.Pub[:], deviceIdentity.AccountSignatureKey)
 	sig := ecc.CalculateSignature(ecc.NewDjbECPrivateKey(*ikp.Priv), message)
 	return &sig
 }

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/prekeys.go

@@ -29,11 +29,12 @@ const (
 	MinPreKeyCount = 5
 )
 
-func (cli *Client) getServerPreKeyCount() (int, error) {
+func (cli *Client) getServerPreKeyCount(ctx context.Context) (int, error) {
 	resp, err := cli.sendIQ(infoQuery{
 		Namespace: "encrypt",
 		Type:      "get",
 		To:        types.ServerJID,
+		Context:   ctx,
 		Content: []waBinary.Node{
 			{Tag: "count"},
 		},
@@ -47,11 +48,11 @@ func (cli *Client) getServerPreKeyCount() (int, error) {
 	return val, ag.Error()
 }
 
-func (cli *Client) uploadPreKeys() {
+func (cli *Client) uploadPreKeys(ctx context.Context) {
 	cli.uploadPreKeysLock.Lock()
 	defer cli.uploadPreKeysLock.Unlock()
 	if cli.lastPreKeyUpload.Add(10 * time.Minute).After(time.Now()) {
-		sc, _ := cli.getServerPreKeyCount()
+		sc, _ := cli.getServerPreKeyCount(ctx)
 		if sc >= WantedPreKeyCount {
 			cli.Log.Debugf("Canceling prekey upload request due to likely race condition")
 			return
@@ -59,13 +60,14 @@ func (cli *Client) uploadPreKeys() {
 	}
 	var registrationIDBytes [4]byte
 	binary.BigEndian.PutUint32(registrationIDBytes[:], cli.Store.RegistrationID)
-	preKeys, err := cli.Store.PreKeys.GetOrGenPreKeys(WantedPreKeyCount)
+	preKeys, err := cli.Store.PreKeys.GetOrGenPreKeys(ctx, WantedPreKeyCount)
 	if err != nil {
 		cli.Log.Errorf("Failed to get prekeys to upload: %v", err)
 		return
 	}
 	cli.Log.Infof("Uploading %d new prekeys to server", len(preKeys))
 	_, err = cli.sendIQ(infoQuery{
+		Context:   ctx,
 		Namespace: "encrypt",
 		Type:      "set",
 		To:        types.ServerJID,
@@ -82,11 +84,13 @@ func (cli *Client) uploadPreKeys() {
 		return
 	}
 	cli.Log.Debugf("Got response to uploading prekeys")
-	err = cli.Store.PreKeys.MarkPreKeysAsUploaded(preKeys[len(preKeys)-1].KeyID)
+	err = cli.Store.PreKeys.MarkPreKeysAsUploaded(ctx, preKeys[len(preKeys)-1].KeyID)
 	if err != nil {
 		cli.Log.Warnf("Failed to mark prekeys as uploaded: %v", err)
+		return
 	}
 	cli.lastPreKeyUpload = time.Now()
+	return
 }
 
 type preKeyResp struct {

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/presence.go

@@ -7,6 +7,7 @@
 package whatsmeow
 
 import (
+	"context"
 	"fmt"
 
 	waBinary "go.mau.fi/whatsmeow/binary"
@@ -61,7 +62,9 @@ func (cli *Client) handlePresence(node *waBinary.Node) {
 // You should call this at least once after connecting so that the server has your pushname.
 // Otherwise, other users will see "-" as the name.
 func (cli *Client) SendPresence(state types.Presence) error {
-	if len(cli.Store.PushName) == 0 {
+	if cli == nil {
+		return ErrClientIsNil
+	} else if len(cli.Store.PushName) == 0 && cli.MessengerConfig == nil {
 		return ErrNoPushName
 	}
 	if state == types.PresenceAvailable {
@@ -69,12 +72,16 @@ func (cli *Client) SendPresence(state types.Presence) error {
 	} else {
 		cli.sendActiveReceipts.CompareAndSwap(1, 0)
 	}
+	attrs := waBinary.Attrs{
+		"type": string(state),
+	}
+	// PushName not set when using WhatsApp for Messenger E2EE
+	if cli.MessengerConfig == nil {
+		attrs["name"] = cli.Store.PushName
+	}
 	return cli.sendNode(waBinary.Node{
-		Tag: "presence",
-		Attrs: waBinary.Attrs{
-			"name": cli.Store.PushName,
-			"type": string(state),
-		},
+		Tag:   "presence",
+		Attrs: attrs,
 	})
 }
 
@@ -87,7 +94,10 @@ func (cli *Client) SendPresence(state types.Presence) error {
 //
 //	cli.SendPresence(types.PresenceAvailable)
 func (cli *Client) SubscribePresence(jid types.JID) error {
-	privacyToken, err := cli.Store.PrivacyTokens.GetPrivacyToken(jid)
+	if cli == nil {
+		return ErrClientIsNil
+	}
+	privacyToken, err := cli.Store.PrivacyTokens.GetPrivacyToken(context.TODO(), jid)
 	if err != nil {
 		return fmt.Errorf("failed to get privacy token: %w", err)
 	} else if privacyToken == nil {