slidge-whatsapp 0.3.1__cp311-cp311-manylinux_2_36_aarch64.whl → 0.3.4__cp311-cp311-manylinux_2_36_aarch64.whl

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

@@ -14,6 +14,7 @@ import (
 	"encoding/hex"
 	"errors"
 	"fmt"
+	"slices"
 	"sort"
 	"strconv"
 	"strings"
@@ -366,6 +367,8 @@ func (cli *Client) SendMessage(ctx context.Context, to types.JID, message *waE2E
 
 	start := time.Now()
 	// Sending multiple messages at a time can cause weird issues and makes it harder to retry safely
+	// This is also required for the session prefetching that makes group sends faster
+	// (everything will explode if you send a message to the same user twice in parallel)
 	cli.messageSendLock.Lock()
 	resp.DebugTimings.Queue = time.Since(start)
 	defer cli.messageSendLock.Unlock()
@@ -1120,6 +1123,12 @@ func (cli *Client) prepareMessageNode(
 		return nil, nil, fmt.Errorf("failed to get device list: %w", err)
 	}
 
+	if to.Server == types.GroupServer {
+		allDevices = slices.DeleteFunc(allDevices, func(jid types.JID) bool {
+			return jid.Server == types.HostedServer || jid.Server == types.HostedLIDServer
+		})
+	}
+
 	msgType := getTypeFromMessage(message)
 	encAttrs := waBinary.Attrs{}
 	// Only include encMediaType for 1:1 messages (groups don't have a device-sent message plaintext)
@@ -1226,7 +1235,8 @@ func (cli *Client) encryptMessageForDevices(
 	}
 
 	encryptionIdentities := make(map[types.JID]types.JID, len(allDevices))
-	var sessionAddresses []string
+	sessionAddressToJID := make(map[string]types.JID, len(allDevices))
+	sessionAddresses := make([]string, 0, len(allDevices))
 	for _, jid := range allDevices {
 		encryptionIdentity := jid
 		if jid.Server == types.DefaultUserServer {
@@ -1237,15 +1247,23 @@ func (cli *Client) encryptMessageForDevices(
 			}
 		}
 		encryptionIdentities[jid] = encryptionIdentity
-		sessionAddresses = append(sessionAddresses, encryptionIdentity.SignalAddress().String())
+		addr := encryptionIdentity.SignalAddress().String()
+		sessionAddresses = append(sessionAddresses, addr)
+		sessionAddressToJID[addr] = jid
 	}
 
-	existingSessions, err := cli.Store.Sessions.HasManySessions(ctx, sessionAddresses)
+	existingSessions, ctx, err := cli.Store.WithCachedSessions(ctx, sessionAddresses)
 	if err != nil {
-		return nil, false, fmt.Errorf("failed to check which sessions exist: %w", err)
+		return nil, false, fmt.Errorf("failed to prefetch sessions: %w", err)
 	}
+	var retryDevices []types.JID
+	for addr, exists := range existingSessions {
+		if !exists {
+			retryDevices = append(retryDevices, sessionAddressToJID[addr])
+		}
+	}
+	bundles := cli.fetchPreKeysNoError(ctx, retryDevices)
 
-	var retryDevices, retryEncryptionIdentities []types.JID
 	for _, jid := range allDevices {
 		plaintext := msgPlaintext
 		if (jid.User == ownJID.User || jid.User == ownLID.User) && dsmPlaintext != nil {
@@ -1254,16 +1272,10 @@ func (cli *Client) encryptMessageForDevices(
 			}
 			plaintext = dsmPlaintext
 		}
-		encryptionIdentity := encryptionIdentities[jid]
-
 		encrypted, isPreKey, err := cli.encryptMessageForDeviceAndWrap(
-			ctx, plaintext, jid, encryptionIdentity, nil, encAttrs, existingSessions,
+			ctx, plaintext, jid, encryptionIdentities[jid], bundles[jid], encAttrs, existingSessions,
 		)
-		if errors.Is(err, ErrNoSession) {
-			retryDevices = append(retryDevices, jid)
-			retryEncryptionIdentities = append(retryEncryptionIdentities, encryptionIdentity)
-			continue
-		} else if err != nil {
+		if err != nil {
 			// TODO return these errors if it's a fatal one (like context cancellation or database)
 			cli.Log.Warnf("Failed to encrypt %s for %s: %v", id, jid, err)
 			if ctx.Err() != nil {
@@ -1277,35 +1289,9 @@ func (cli *Client) encryptMessageForDevices(
 			includeIdentity = true
 		}
 	}
-	if len(retryDevices) > 0 {
-		bundles, err := cli.fetchPreKeys(ctx, retryDevices)
-		if err != nil {
-			cli.Log.Warnf("Failed to fetch prekeys for %v to retry encryption: %v", retryDevices, err)
-		} else {
-			for i, jid := range retryDevices {
-				resp := bundles[jid]
-				if resp.err != nil {
-					cli.Log.Warnf("Failed to fetch prekey for %s: %v", jid, resp.err)
-					continue
-				}
-				plaintext := msgPlaintext
-				if (jid.User == ownJID.User || jid.User == ownLID.User) && dsmPlaintext != nil {
-					plaintext = dsmPlaintext
-				}
-				encrypted, isPreKey, err := cli.encryptMessageForDeviceAndWrap(
-					ctx, plaintext, jid, retryEncryptionIdentities[i], resp.bundle, encAttrs, nil,
-				)
-				if err != nil {
-					// TODO return these errors if it's a fatal one (like context cancellation or database)
-					cli.Log.Warnf("Failed to encrypt %s for %s (retry): %v", id, jid, err)
-					continue
-				}
-				participantNodes = append(participantNodes, *encrypted)
-				if isPreKey {
-					includeIdentity = true
-				}
-			}
-		}
+	err = cli.Store.PutCachedSessions(ctx)
+	if err != nil {
+		return nil, false, fmt.Errorf("failed to save cached sessions: %w", err)
 	}
 	return participantNodes, includeIdentity, nil
 }

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

@@ -468,7 +468,10 @@ func (cli *Client) prepareMessageNodeV3(
 	}
 
 	start = time.Now()
-	participantNodes := cli.encryptMessageForDevicesV3(ctx, allDevices, ownID, id, payload, skdm, dsm, encAttrs)
+	participantNodes, err := cli.encryptMessageForDevicesV3(ctx, allDevices, ownID, id, payload, skdm, dsm, encAttrs)
+	if err != nil {
+		return nil, nil, err
+	}
 	timings.PeerEncrypt = time.Since(start)
 	content := make([]waBinary.Node, 0, 4)
 	content = append(content, waBinary.Node{
@@ -518,9 +521,28 @@ func (cli *Client) encryptMessageForDevicesV3(
 	skdm *waMsgTransport.MessageTransport_Protocol_Ancillary_SenderKeyDistributionMessage,
 	dsm *waMsgTransport.MessageTransport_Protocol_Integral_DeviceSentMessage,
 	encAttrs waBinary.Attrs,
-) []waBinary.Node {
+) ([]waBinary.Node, error) {
 	participantNodes := make([]waBinary.Node, 0, len(allDevices))
+
+	sessionAddressToJID := make(map[string]types.JID, len(allDevices))
+	sessionAddresses := make([]string, 0, len(allDevices))
+	for _, jid := range allDevices {
+		addr := jid.SignalAddress().String()
+		sessionAddresses = append(sessionAddresses, addr)
+		sessionAddressToJID[addr] = jid
+	}
+	existingSessions, ctx, err := cli.Store.WithCachedSessions(ctx, sessionAddresses)
+	if err != nil {
+		return nil, fmt.Errorf("failed to prefetch sessions: %w", err)
+	}
 	var retryDevices []types.JID
+	for addr, exists := range existingSessions {
+		if !exists {
+			retryDevices = append(retryDevices, sessionAddressToJID[addr])
+		}
+	}
+	bundles := cli.fetchPreKeysNoError(ctx, retryDevices)
+
 	for _, jid := range allDevices {
 		var dsmForDevice *waMsgTransport.MessageTransport_Protocol_Integral_DeviceSentMessage
 		if jid.User == ownID.User {
@@ -529,43 +551,22 @@ func (cli *Client) encryptMessageForDevicesV3(
 			}
 			dsmForDevice = dsm
 		}
-		encrypted, err := cli.encryptMessageForDeviceAndWrapV3(ctx, payload, skdm, dsmForDevice, jid, nil, encAttrs)
-		if errors.Is(err, ErrNoSession) {
-			retryDevices = append(retryDevices, jid)
-			continue
-		} else if err != nil {
+		encrypted, err := cli.encryptMessageForDeviceAndWrapV3(ctx, payload, skdm, dsmForDevice, jid, bundles[jid], encAttrs)
+		if err != nil {
 			// TODO return these errors if it's a fatal one (like context cancellation or database)
 			cli.Log.Warnf("Failed to encrypt %s for %s: %v", id, jid, err)
+			if ctx.Err() != nil {
+				return nil, err
+			}
 			continue
 		}
 		participantNodes = append(participantNodes, *encrypted)
 	}
-	if len(retryDevices) > 0 {
-		bundles, err := cli.fetchPreKeys(ctx, retryDevices)
-		if err != nil {
-			cli.Log.Warnf("Failed to fetch prekeys for %v to retry encryption: %v", retryDevices, err)
-		} else {
-			for _, jid := range retryDevices {
-				resp := bundles[jid]
-				if resp.err != nil {
-					cli.Log.Warnf("Failed to fetch prekey for %s: %v", jid, resp.err)
-					continue
-				}
-				var dsmForDevice *waMsgTransport.MessageTransport_Protocol_Integral_DeviceSentMessage
-				if jid.User == ownID.User {
-					dsmForDevice = dsm
-				}
-				encrypted, err := cli.encryptMessageForDeviceAndWrapV3(ctx, payload, skdm, dsmForDevice, jid, resp.bundle, encAttrs)
-				if err != nil {
-					// TODO return these errors if it's a fatal one (like context cancellation or database)
-					cli.Log.Warnf("Failed to encrypt %s for %s (retry): %v", id, jid, err)
-					continue
-				}
-				participantNodes = append(participantNodes, *encrypted)
-			}
-		}
+	err = cli.Store.PutCachedSessions(ctx)
+	if err != nil {
+		return nil, fmt.Errorf("failed to save cached sessions: %w", err)
 	}
-	return participantNodes
+	return participantNodes, nil
 }
 
 func (cli *Client) encryptMessageForDeviceAndWrapV3(

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/store/clientpayload.go

@@ -76,7 +76,7 @@ func (vc WAVersionContainer) ProtoAppVersion() *waWa6.ClientPayload_UserAgent_Ap
 }
 
 // waVersion is the WhatsApp web client version
-var waVersion = WAVersionContainer{2, 3000, 1027949008}
+var waVersion = WAVersionContainer{2, 3000, 1028259376}
 
 // waVersionHash is the md5 hash of a dot-separated waVersion
 var waVersionHash [16]byte

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/store/noop.go

@@ -68,7 +68,7 @@ func (n *NoopStore) HasSession(ctx context.Context, address string) (bool, error
 	return false, n.Error
 }
 
-func (n *NoopStore) HasManySessions(ctx context.Context, addresses []string) (map[string]bool, error) {
+func (n *NoopStore) GetManySessions(ctx context.Context, addresses []string) (map[string][]byte, error) {
 	return nil, n.Error
 }
 
@@ -76,6 +76,10 @@ func (n *NoopStore) PutSession(ctx context.Context, address string, session []by
 	return n.Error
 }
 
+func (n *NoopStore) PutManySessions(ctx context.Context, sessions map[string][]byte) error {
+	return n.Error
+}
+
 func (n *NoopStore) DeleteAllSessions(ctx context.Context, phone string) error {
 	return n.Error
 }

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/store/sessioncache.go

@@ -0,0 +1,125 @@
+// Copyright (c) 2025 Tulir Asokan
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package store
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/rs/zerolog"
+	"go.mau.fi/libsignal/state/record"
+
+	"go.mau.fi/util/exsync"
+)
+
+type contextKey int
+
+const (
+	contextKeySessionCache contextKey = iota
+)
+
+type sessionCacheEntry struct {
+	Dirty  bool
+	Found  bool
+	Record *record.Session
+}
+
+type sessionCache = exsync.Map[string, sessionCacheEntry]
+
+func getSessionCache(ctx context.Context) *sessionCache {
+	if ctx == nil {
+		return nil
+	}
+	val := ctx.Value(contextKeySessionCache)
+	if val == nil {
+		return nil
+	}
+	if cache, ok := val.(*sessionCache); ok {
+		return cache
+	}
+	return nil
+}
+
+func getCachedSession(ctx context.Context, addr string) *record.Session {
+	cache := getSessionCache(ctx)
+	if cache == nil {
+		return nil
+	}
+	sess, ok := cache.Get(addr)
+	if !ok {
+		return nil
+	}
+	return sess.Record
+}
+
+func putCachedSession(ctx context.Context, addr string, record *record.Session) bool {
+	cache := getSessionCache(ctx)
+	if cache == nil {
+		return false
+	}
+	cache.Set(addr, sessionCacheEntry{
+		Dirty:  true,
+		Found:  true,
+		Record: record,
+	})
+	return true
+}
+
+func (device *Device) WithCachedSessions(ctx context.Context, addresses []string) (map[string]bool, context.Context, error) {
+	if len(addresses) == 0 {
+		return nil, ctx, nil
+	}
+
+	sessions, err := device.Sessions.GetManySessions(ctx, addresses)
+	if err != nil {
+		return nil, ctx, fmt.Errorf("failed to prefetch sessions: %w", err)
+	}
+	wrapped := make(map[string]sessionCacheEntry, len(sessions))
+	existingSessions := make(map[string]bool, len(sessions))
+	for addr, rawSess := range sessions {
+		var sessionRecord *record.Session
+		var found bool
+		if rawSess == nil {
+			sessionRecord = record.NewSession(SignalProtobufSerializer.Session, SignalProtobufSerializer.State)
+		} else {
+			found = true
+			sessionRecord, err = record.NewSessionFromBytes(rawSess, SignalProtobufSerializer.Session, SignalProtobufSerializer.State)
+			if err != nil {
+				zerolog.Ctx(ctx).Err(err).
+					Str("address", addr).
+					Msg("Failed to deserialize session")
+				continue
+			}
+		}
+		existingSessions[addr] = found
+		wrapped[addr] = sessionCacheEntry{Record: sessionRecord, Found: found}
+	}
+
+	ctx = context.WithValue(ctx, contextKeySessionCache, (*sessionCache)(exsync.NewMapWithData(wrapped)))
+	return existingSessions, ctx, nil
+}
+
+func (device *Device) PutCachedSessions(ctx context.Context) error {
+	cache := getSessionCache(ctx)
+	if cache == nil {
+		return nil
+	}
+	dirtySessions := make(map[string][]byte)
+	for addr, item := range cache.Iter() {
+		if item.Dirty {
+			dirtySessions[addr] = item.Record.Serialize()
+		}
+	}
+	if len(dirtySessions) > 0 {
+		err := device.Sessions.PutManySessions(ctx, dirtySessions)
+		if err != nil {
+			return fmt.Errorf("failed to store cached sessions: %w", err)
+		}
+	}
+	cache.Clear()
+	return nil
+}

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/store/signal.go

@@ -84,6 +84,10 @@ func (device *Device) ContainsPreKey(ctx context.Context, preKeyID uint32) (bool
 
 func (device *Device) LoadSession(ctx context.Context, address *protocol.SignalAddress) (*record.Session, error) {
 	addrString := address.String()
+	if sess := getCachedSession(ctx, addrString); sess != nil {
+		return sess, nil
+	}
+
 	rawSess, err := device.Sessions.GetSession(ctx, addrString)
 	if err != nil {
 		return nil, fmt.Errorf("failed to load session with %s: %w", addrString, err)
@@ -104,6 +108,10 @@ func (device *Device) GetSubDeviceSessions(ctx context.Context, name string) ([]
 
 func (device *Device) StoreSession(ctx context.Context, address *protocol.SignalAddress, record *record.Session) error {
 	addrString := address.String()
+	if putCachedSession(ctx, addrString, record) {
+		return nil
+	}
+
 	err := device.Sessions.PutSession(ctx, addrString, record.Serialize())
 	if err != nil {
 		return fmt.Errorf("failed to store session with %s: %w", addrString, err)

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/store/sqlstore/store.go

@@ -111,8 +111,8 @@ func (s *SQLStore) IsTrustedIdentity(ctx context.Context, address string, key [3
 const (
 	getSessionQuery             = `SELECT session FROM whatsmeow_sessions WHERE our_jid=$1 AND their_id=$2`
 	hasSessionQuery             = `SELECT true FROM whatsmeow_sessions WHERE our_jid=$1 AND their_id=$2`
-	hasManySessionQueryPostgres = `SELECT their_id FROM whatsmeow_sessions WHERE our_jid=$1 AND their_id = ANY($2)`
-	hasManySessionQueryGeneric  = `SELECT their_id FROM whatsmeow_sessions WHERE our_jid=$1 AND their_id IN (%s)`
+	getManySessionQueryPostgres = `SELECT their_id, session FROM whatsmeow_sessions WHERE our_jid=$1 AND their_id = ANY($2)`
+	getManySessionQueryGeneric  = `SELECT their_id, session FROM whatsmeow_sessions WHERE our_jid=$1 AND their_id IN (%s)`
 	putSessionQuery             = `
 		INSERT INTO whatsmeow_sessions (our_jid, their_id, session) VALUES ($1, $2, $3)
 		ON CONFLICT (our_jid, their_id) DO UPDATE SET session=excluded.session
@@ -161,9 +161,17 @@ func (s *SQLStore) HasSession(ctx context.Context, address string) (has bool, er
 	return
 }
 
-var stringScanner = dbutil.ConvertRowFn[string](dbutil.ScanSingleColumn[string])
+type addressSessionTuple struct {
+	Address string
+	Session []byte
+}
+
+var sessionScanner = dbutil.ConvertRowFn[addressSessionTuple](func(row dbutil.Scannable) (out addressSessionTuple, err error) {
+	err = row.Scan(&out.Address, &out.Session)
+	return
+})
 
-func (s *SQLStore) HasManySessions(ctx context.Context, addresses []string) (map[string]bool, error) {
+func (s *SQLStore) GetManySessions(ctx context.Context, addresses []string) (map[string][]byte, error) {
 	if len(addresses) == 0 {
 		return nil, nil
 	}
@@ -171,7 +179,7 @@ func (s *SQLStore) HasManySessions(ctx context.Context, addresses []string) (map
 	var rows dbutil.Rows
 	var err error
 	if s.db.Dialect == dbutil.Postgres && PostgresArrayWrapper != nil {
-		rows, err = s.db.Query(ctx, hasManySessionQueryPostgres, s.JID, PostgresArrayWrapper(addresses))
+		rows, err = s.db.Query(ctx, getManySessionQueryPostgres, s.JID, PostgresArrayWrapper(addresses))
 	} else {
 		args := make([]any, len(addresses)+1)
 		placeholders := make([]string, len(addresses))
@@ -180,17 +188,32 @@ func (s *SQLStore) HasManySessions(ctx context.Context, addresses []string) (map
 			args[i+1] = addr
 			placeholders[i] = fmt.Sprintf("$%d", i+2)
 		}
-		rows, err = s.db.Query(ctx, fmt.Sprintf(hasManySessionQueryGeneric, strings.Join(placeholders, ",")), args...)
+		rows, err = s.db.Query(ctx, fmt.Sprintf(getManySessionQueryGeneric, strings.Join(placeholders, ",")), args...)
 	}
-	result := make(map[string]bool, len(addresses))
+	result := make(map[string][]byte, len(addresses))
 	for _, addr := range addresses {
-		result[addr] = false
+		result[addr] = nil
 	}
-	err = stringScanner.NewRowIter(rows, err).Iter(func(s string) (bool, error) {
-		result[s] = true
+	err = sessionScanner.NewRowIter(rows, err).Iter(func(tuple addressSessionTuple) (bool, error) {
+		result[tuple.Address] = tuple.Session
 		return true, nil
 	})
-	return result, err
+	if err != nil {
+		return nil, err
+	}
+	return result, nil
+}
+
+func (s *SQLStore) PutManySessions(ctx context.Context, sessions map[string][]byte) error {
+	return s.db.DoTxn(ctx, nil, func(ctx context.Context) error {
+		for addr, sess := range sessions {
+			err := s.PutSession(ctx, addr, sess)
+			if err != nil {
+				return err
+			}
+		}
+		return nil
+	})
 }
 
 func (s *SQLStore) PutSession(ctx context.Context, address string, session []byte) error {

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

@@ -29,8 +29,9 @@ type IdentityStore interface {
 type SessionStore interface {
 	GetSession(ctx context.Context, address string) ([]byte, error)
 	HasSession(ctx context.Context, address string) (bool, error)
-	HasManySessions(ctx context.Context, addresses []string) (map[string]bool, error)
+	GetManySessions(ctx context.Context, addresses []string) (map[string][]byte, error)
 	PutSession(ctx context.Context, address string, session []byte) error
+	PutManySessions(ctx context.Context, sessions map[string][]byte) error
 	DeleteAllSessions(ctx context.Context, phone string) error
 	DeleteSession(ctx context.Context, address string) error
 	MigratePNToLID(ctx context.Context, pn, lid types.JID) error
@@ -207,8 +208,9 @@ type Device struct {
 	RegistrationID uint32
 	AdvSecretKey   []byte
 
-	ID           *types.JID
-	LID          types.JID
+	ID  *types.JID
+	LID types.JID
+
 	Account      *waAdv.ADVSignedDeviceIdentity
 	Platform     string
 	BusinessName string

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/types/jid.go

@@ -29,6 +29,7 @@ const (
 	InteropServer     = "interop"
 	NewsletterServer  = "newsletter"
 	HostedServer      = "hosted"
+	HostedLIDServer   = "hosted.lid"
 	BotServer         = "bot"
 )
 
@@ -46,6 +47,13 @@ var (
 	NewMetaAIJID        = NewJID("867051314767696", BotServer)
 )
 
+var (
+	WhatsAppDomain  = uint8(0)   // This is the main domain type that whatsapp uses
+	LIDDomain       = uint8(1)   // This is the domain for LID type JIDs
+	HostedDomain    = uint8(128) // This is the domain for Hosted type JIDs
+	HostedLIDDomain = uint8(129) // This is the domain for Hosted LID type JIDs
+)
+
 // MessageID is the internal ID of a WhatsApp message.
 type MessageID = string
 
@@ -68,9 +76,13 @@ type JID struct {
 func (jid JID) ActualAgent() uint8 {
 	switch jid.Server {
 	case DefaultUserServer:
-		return 0
+		return WhatsAppDomain
 	case HiddenUserServer:
-		return 1
+		return LIDDomain
+	case HostedServer:
+		return HostedDomain
+	case HostedLIDServer:
+		return HostedLIDDomain
 	default:
 		return jid.RawAgent
 	}
@@ -119,17 +131,20 @@ func (jid JID) IsBot() bool {
 // NewADJID creates a new AD JID.
 func NewADJID(user string, agent, device uint8) JID {
 	var server string
+	// agent terminology isn't 100% correct here, these are the domainType, but whatsapp usually places them in the same place (if the switch case below doesn't process it, then it is an agent instead)
 	switch agent {
-	case 0:
-		server = DefaultUserServer
-	case 1:
+	case LIDDomain:
 		server = HiddenUserServer
 		agent = 0
-	default:
-		if (agent&0x01) != 0 || (agent&0x80) == 0 { // agent % 2 == 0 || agent < 128?
-			// TODO invalid JID?
-		}
+	case HostedDomain:
 		server = HostedServer
+		agent = 0
+	case HostedLIDDomain:
+		server = HostedLIDServer
+		agent = 0
+	default:
+	case WhatsAppDomain:
+		server = DefaultUserServer // will just default to the normal server
 	}
 	return JID{
 		User:     user,

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

@@ -704,11 +704,22 @@ func parseDeviceList(user types.JID, deviceNode waBinary.Node) []types.JID {
 	devices := make([]types.JID, 0, len(children))
 	for _, device := range children {
 		deviceID, ok := device.AttrGetter().GetInt64("id", true)
+		isHosted := device.AttrGetter().Bool("is_hosted")
 		if device.Tag != "device" || !ok {
 			continue
 		}
 		user.Device = uint16(deviceID)
-		devices = append(devices, user)
+		if isHosted {
+			hostedUser := user
+			if user.Server == types.HiddenUserServer {
+				hostedUser.Server = types.HostedLIDServer
+			} else {
+				hostedUser.Server = types.HostedServer
+			}
+			devices = append(devices, hostedUser)
+		} else {
+			devices = append(devices, user)
+		}
 	}
 	return devices
 }

slidge_whatsapp/vendor/golang.org/x/crypto/curve25519/curve25519.go

@@ -3,11 +3,14 @@
 // license that can be found in the LICENSE file.
 
 // Package curve25519 provides an implementation of the X25519 function, which
-// performs scalar multiplication on the elliptic curve known as Curve25519.
-// See RFC 7748.
+// performs scalar multiplication on the elliptic curve known as Curve25519
+// according to [RFC 7748].
 //
-// This package is a wrapper for the X25519 implementation
-// in the crypto/ecdh package.
+// The curve25519 package is a wrapper for the X25519 implementation in the
+// crypto/ecdh package. It is [frozen] and is not accepting new features.
+//
+// [RFC 7748]: https://datatracker.ietf.org/doc/html/rfc7748
+// [frozen]: https://go.dev/wiki/Frozen
 package curve25519
 
 import "crypto/ecdh"

slidge_whatsapp/vendor/golang.org/x/net/http2/config.go

@@ -27,6 +27,7 @@ import (
 //   - If the resulting value is zero or out of range, use a default.
 type http2Config struct {
 	MaxConcurrentStreams         uint32
+	StrictMaxConcurrentRequests  bool
 	MaxDecoderHeaderTableSize    uint32
 	MaxEncoderHeaderTableSize    uint32
 	MaxReadFrameSize             uint32
@@ -64,12 +65,13 @@ func configFromServer(h1 *http.Server, h2 *Server) http2Config {
 // (the net/http Transport).
 func configFromTransport(h2 *Transport) http2Config {
 	conf := http2Config{
-		MaxEncoderHeaderTableSize: h2.MaxEncoderHeaderTableSize,
-		MaxDecoderHeaderTableSize: h2.MaxDecoderHeaderTableSize,
-		MaxReadFrameSize:          h2.MaxReadFrameSize,
-		SendPingTimeout:           h2.ReadIdleTimeout,
-		PingTimeout:               h2.PingTimeout,
-		WriteByteTimeout:          h2.WriteByteTimeout,
+		StrictMaxConcurrentRequests: h2.StrictMaxConcurrentStreams,
+		MaxEncoderHeaderTableSize:   h2.MaxEncoderHeaderTableSize,
+		MaxDecoderHeaderTableSize:   h2.MaxDecoderHeaderTableSize,
+		MaxReadFrameSize:            h2.MaxReadFrameSize,
+		SendPingTimeout:             h2.ReadIdleTimeout,
+		PingTimeout:                 h2.PingTimeout,
+		WriteByteTimeout:            h2.WriteByteTimeout,
 	}
 
 	// Unlike most config fields, where out-of-range values revert to the default,
@@ -128,6 +130,9 @@ func fillNetHTTPConfig(conf *http2Config, h2 *http.HTTP2Config) {
 	if h2.MaxConcurrentStreams != 0 {
 		conf.MaxConcurrentStreams = uint32(h2.MaxConcurrentStreams)
 	}
+	if http2ConfigStrictMaxConcurrentRequests(h2) {
+		conf.StrictMaxConcurrentRequests = true
+	}
 	if h2.MaxEncoderHeaderTableSize != 0 {
 		conf.MaxEncoderHeaderTableSize = uint32(h2.MaxEncoderHeaderTableSize)
 	}

slidge_whatsapp/vendor/golang.org/x/net/http2/config_go125.go

@@ -0,0 +1,15 @@
+// Copyright 2025 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build !go1.26
+
+package http2
+
+import (
+	"net/http"
+)
+
+func http2ConfigStrictMaxConcurrentRequests(h2 *http.HTTP2Config) bool {
+	return false
+}

slidge_whatsapp/vendor/golang.org/x/net/http2/config_go126.go

@@ -0,0 +1,15 @@
+// Copyright 2025 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build go1.26
+
+package http2
+
+import (
+	"net/http"
+)
+
+func http2ConfigStrictMaxConcurrentRequests(h2 *http.HTTP2Config) bool {
+	return h2.StrictMaxConcurrentRequests
+}