slidge-whatsapp 0.3.0b0__cp311-cp311-manylinux_2_36_aarch64.whl → 0.3.4__cp311-cp311-manylinux_2_36_aarch64.whl

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/proto/waWeb/WAWebProtobufsWeb.proto

@@ -307,6 +307,9 @@ message WebMessageInfo {
 	repeated string statusMentionSources = 71;
 	repeated Citation supportAiCitations = 72;
 	optional string botTargetID = 73;
+	optional GroupHistoryIndividualMessageInfo groupHistoryIndividualMessageInfo = 74;
+	optional GroupHistoryBundleInfo groupHistoryBundleInfo = 75;
+	optional InteractiveMessageAdditionalMetadata interactiveMessageAdditionalMetadata = 76;
 }
 
 message PaymentInfo {
@@ -468,6 +471,18 @@ message MessageAddOn {
 	optional LegacyMessage legacyMessage = 8;
 }
 
+message GroupHistoryBundleInfo {
+	enum ProcessState {
+		NOT_INJECTED = 0;
+		INJECTED = 1;
+		INJECTED_PARTIAL = 2;
+		INJECTION_FAILED = 3;
+	}
+
+	optional WAWebProtobufsE2E.MessageHistoryBundle deprecatedMessageHistoryBundle = 1;
+	optional ProcessState processState = 2;
+}
+
 message CommentMetadata {
 	optional WACommon.MessageKey commentParentKey = 1;
 	optional uint32 replyCount = 2;
@@ -535,6 +550,10 @@ message PollAdditionalMetadata {
 	optional bool pollInvalidated = 1;
 }
 
+message InteractiveMessageAdditionalMetadata {
+	optional bool isGalaxyFlowCompleted = 1;
+}
+
 message EventAdditionalMetadata {
 	optional bool isStale = 1;
 }
@@ -579,3 +598,8 @@ message Citation {
 	required string cmsID = 3;
 	required string imageURL = 4;
 }
+
+message GroupHistoryIndividualMessageInfo {
+	optional WACommon.MessageKey bundleMessageKey = 1;
+	optional bool editedAfterReceivedAsHistory = 2;
+}

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

@@ -101,6 +101,14 @@ func (cli *Client) parseReceipt(node *waBinary.Node) (*events.Receipt, error) {
 	return &receipt, nil
 }
 
+func (cli *Client) backgroundIfAsyncAck(fn func()) {
+	if cli.SynchronousAck {
+		fn()
+	} else {
+		go fn()
+	}
+}
+
 func (cli *Client) maybeDeferredAck(ctx context.Context, node *waBinary.Node) func(cancelled ...*bool) {
 	if cli.SynchronousAck {
 		return func(cancelled ...*bool) {
@@ -113,15 +121,31 @@ func (cli *Client) maybeDeferredAck(ctx context.Context, node *waBinary.Node) fu
 					Msg("Not sending ack for node")
 				return
 			}
-			cli.sendAck(node)
+			cli.sendAck(node, 0)
 		}
 	} else {
-		go cli.sendAck(node)
+		go cli.sendAck(node, 0)
 		return func(...*bool) {}
 	}
 }
 
-func (cli *Client) sendAck(node *waBinary.Node) {
+const (
+	NackParsingError                 = 487
+	NackUnrecognizedStanza           = 488
+	NackUnrecognizedStanzaClass      = 489
+	NackUnrecognizedStanzaType       = 490
+	NackInvalidProtobuf              = 491
+	NackInvalidHostedCompanionStanza = 493
+	NackMissingMessageSecret         = 495
+	NackSignalErrorOldCounter        = 496
+	NackMessageDeletedOnPeer         = 499
+	NackUnhandledError               = 500
+	NackUnsupportedAdminRevoke       = 550
+	NackUnsupportedLIDGroup          = 551
+	NackDBOperationFailed            = 552
+)
+
+func (cli *Client) sendAck(node *waBinary.Node, error int) {
 	attrs := waBinary.Attrs{
 		"class": node.Tag,
 		"id":    node.Attrs["id"],
@@ -145,6 +169,9 @@ func (cli *Client) sendAck(node *waBinary.Node) {
 	if receiptType, ok := node.Attrs["type"]; node.Tag != "message" && ok {
 		attrs["type"] = receiptType
 	}
+	if error != 0 {
+		attrs["error"] = error
+	}
 	err := cli.sendNode(waBinary.Node{
 		Tag:   "ack",
 		Attrs: attrs,
@@ -233,24 +260,30 @@ func (cli *Client) SetForceActiveDeliveryReceipts(active bool) {
 	}
 }
 
-func (cli *Client) sendMessageReceipt(info *types.MessageInfo) {
+func buildBaseReceipt(id string, node *waBinary.Node) waBinary.Attrs {
 	attrs := waBinary.Attrs{
-		"id": info.ID,
+		"id": id,
+		"to": node.Attrs["from"],
 	}
+	if recipient, ok := node.Attrs["recipient"]; ok {
+		attrs["recipient"] = recipient
+	}
+	if participant, ok := node.Attrs["participant"]; ok {
+		attrs["participant"] = participant
+	}
+	return attrs
+}
+
+func (cli *Client) sendMessageReceipt(info *types.MessageInfo, node *waBinary.Node) {
+	attrs := buildBaseReceipt(info.ID, node)
 	if info.IsFromMe {
 		attrs["type"] = string(types.ReceiptTypeSender)
+		if info.Type == "peer_msg" {
+			attrs["type"] = string(types.ReceiptTypePeerMsg)
+		}
 	} else if cli.sendActiveReceipts.Load() == 0 {
 		attrs["type"] = string(types.ReceiptTypeInactive)
 	}
-	attrs["to"] = info.Chat
-	if info.IsGroup {
-		attrs["participant"] = info.Sender
-	} else if info.IsFromMe {
-		attrs["recipient"] = info.Sender
-	} else {
-		// Override the to attribute with the JID version with a device number
-		attrs["to"] = info.Sender
-	}
 	err := cli.sendNode(waBinary.Node{
 		Tag:   "receipt",
 		Attrs: attrs,

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

@@ -98,6 +98,7 @@ type infoQuery struct {
 	To        types.JID
 	Target    types.JID
 	ID        string
+	SMaxID    string
 	Content   interface{}
 
 	Timeout time.Duration
@@ -118,6 +119,9 @@ func (cli *Client) sendIQAsyncAndGetData(query *infoQuery) (<-chan *waBinary.Nod
 		"xmlns": query.Namespace,
 		"type":  string(query.Type),
 	}
+	if query.SMaxID != "" {
+		attrs["smax_id"] = query.SMaxID
+	}
 	if !query.To.IsEmpty() {
 		attrs["to"] = query.To
 	}

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

@@ -157,8 +157,7 @@ func (cli *Client) handleRetryReceipt(ctx context.Context, receipt *events.Recei
 		signalSKDMessage, err := builder.Create(ctx, senderKeyName)
 		if err != nil {
 			cli.Log.Warnf("Failed to create sender key distribution message to include in retry of %s in %s to %s: %v", messageID, receipt.Chat, receipt.Sender, err)
-		}
-		if msg.wa != nil {
+		} else if msg.wa != nil {
 			msg.wa.SenderKeyDistributionMessage = &waE2E.SenderKeyDistributionMessage{
 				GroupID:                             proto.String(receipt.Chat.String()),
 				AxolotlSenderKeyDistributionMessage: signalSKDMessage.Serialize(),
@@ -252,7 +251,7 @@ func (cli *Client) handleRetryReceipt(ctx context.Context, receipt *events.Recei
 				encryptionIdentity = lidForPN
 			}
 		}
-		encrypted, includeDeviceIdentity, err = cli.encryptMessageForDevice(ctx, plaintext, encryptionIdentity, bundle, encAttrs)
+		encrypted, includeDeviceIdentity, err = cli.encryptMessageForDevice(ctx, plaintext, encryptionIdentity, bundle, encAttrs, nil)
 	} else {
 		encrypted, err = cli.encryptMessageForDeviceV3(ctx, &waMsgTransport.MessageTransport_Payload{
 			ApplicationPayload: &waCommon.SubProtocol{
@@ -408,16 +407,10 @@ func (cli *Client) sendRetryReceipt(ctx context.Context, node *waBinary.Node, in
 
 	var registrationIDBytes [4]byte
 	binary.BigEndian.PutUint32(registrationIDBytes[:], cli.Store.RegistrationID)
-	attrs := waBinary.Attrs{
-		"id":   id,
-		"type": "retry",
-		"to":   node.Attrs["from"],
-	}
-	if recipient, ok := node.Attrs["recipient"]; ok {
-		attrs["recipient"] = recipient
-	}
-	if participant, ok := node.Attrs["participant"]; ok {
-		attrs["participant"] = participant
+	attrs := buildBaseReceipt(info.ID, node)
+	attrs["type"] = "retry"
+	if info.Type == "peer_msg" && info.IsFromMe {
+		attrs["category"] = "peer"
 	}
 	payload := waBinary.Node{
 		Tag:   "receipt",

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

@@ -14,6 +14,7 @@ import (
 	"encoding/hex"
 	"errors"
 	"fmt"
+	"slices"
 	"sort"
 	"strconv"
 	"strings"
@@ -29,7 +30,7 @@ import (
 	"google.golang.org/protobuf/proto"
 
 	waBinary "go.mau.fi/whatsmeow/binary"
-	"go.mau.fi/whatsmeow/proto/waBotMetadata"
+	"go.mau.fi/whatsmeow/proto/waAICommon"
 	"go.mau.fi/whatsmeow/proto/waCommon"
 	"go.mau.fi/whatsmeow/proto/waE2E"
 	"go.mau.fi/whatsmeow/types"
@@ -74,7 +75,8 @@ func GenerateMessageID() types.MessageID {
 }
 
 type MessageDebugTimings struct {
-	Queue time.Duration
+	LIDFetch time.Duration
+	Queue    time.Duration
 
 	Marshal         time.Duration
 	GetParticipants time.Duration
@@ -88,6 +90,9 @@ type MessageDebugTimings struct {
 }
 
 func (mdt MessageDebugTimings) MarshalZerologObject(evt *zerolog.Event) {
+	if mdt.LIDFetch != 0 {
+		evt.Dur("lid_fetch", mdt.LIDFetch)
+	}
 	evt.Dur("queue", mdt.Queue)
 	evt.Dur("marshal", mdt.Marshal)
 	if mdt.GetParticipants != 0 {
@@ -149,6 +154,8 @@ type SendRequestExtra struct {
 	MediaHandle string
 
 	Meta *types.MsgMetaInfo
+	// use this only if you know what you are doing
+	AdditionalNodes *[]waBinary.Node
 }
 
 // SendMessage sends the given message.
@@ -238,7 +245,7 @@ func (cli *Client) SendMessage(ctx context.Context, to types.JID, message *waE2E
 
 	if isBotMode {
 		if message.MessageContextInfo.BotMetadata == nil {
-			message.MessageContextInfo.BotMetadata = &waBotMetadata.BotMetadata{
+			message.MessageContextInfo.BotMetadata = &waAICommon.BotMetadata{
 				PersonaID: proto.String("867051314767696$760019659443059"),
 			}
 		}
@@ -272,7 +279,11 @@ func (cli *Client) SendMessage(ctx context.Context, to types.JID, message *waE2E
 				return
 			}
 
-			participantNodes, _ := cli.encryptMessageForDevices(ctx, []types.JID{req.InlineBotJID}, resp.ID, messagePlaintext, nil, waBinary.Attrs{})
+			var participantNodes []waBinary.Node
+			participantNodes, _, err = cli.encryptMessageForDevices(ctx, []types.JID{req.InlineBotJID}, resp.ID, messagePlaintext, nil, waBinary.Attrs{})
+			if err != nil {
+				return
+			}
 			extraParams.botNode = &waBinary.Node{
 				Tag:     "bot",
 				Attrs:   nil,
@@ -311,6 +322,28 @@ func (cli *Client) SendMessage(ctx context.Context, to types.JID, message *waE2E
 		resp.DebugTimings.GetParticipants = time.Since(start)
 	} else if to.Server == types.HiddenUserServer {
 		ownID = cli.getOwnLID()
+	} else if to.Server == types.DefaultUserServer && cli.Store.LIDMigrationTimestamp > 0 {
+		start := time.Now()
+		var toLID types.JID
+		toLID, err = cli.Store.LIDs.GetLIDForPN(ctx, to)
+		if err != nil {
+			err = fmt.Errorf("failed to get LID for PN %s: %w", to, err)
+			return
+		} else if toLID.IsEmpty() {
+			var info map[types.JID]types.UserInfo
+			info, err = cli.GetUserInfo([]types.JID{to})
+			if err != nil {
+				err = fmt.Errorf("failed to get user info for %s to fill LID cache: %w", to, err)
+				return
+			} else if toLID = info[to].LID; toLID.IsEmpty() {
+				err = fmt.Errorf("no LID found for %s from server", to)
+				return
+			}
+		}
+		resp.DebugTimings.LIDFetch = time.Since(start)
+		cli.Log.Debugf("Replacing SendMessage destination with LID as migration timestamp is set %s -> %s", to, toLID)
+		to = toLID
+		ownID = cli.getOwnLID()
 	}
 	if req.Meta != nil {
 		extraParams.metaNode = &waBinary.Node{
@@ -326,10 +359,16 @@ func (cli *Client) SendMessage(ctx context.Context, to types.JID, message *waE2E
 		}
 	}
 
+	if req.AdditionalNodes != nil {
+		extraParams.additionalNodes = req.AdditionalNodes
+	}
+
 	resp.Sender = ownID
 
 	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()
@@ -582,6 +621,9 @@ func ParseDisappearingTimerString(val string) (time.Duration, bool) {
 func (cli *Client) SetDisappearingTimer(chat types.JID, timer time.Duration, settingTS time.Time) (err error) {
 	switch chat.Server {
 	case types.DefaultUserServer, types.HiddenUserServer:
+		if settingTS.IsZero() {
+			settingTS = time.Now()
+		}
 		_, err = cli.SendMessage(context.TODO(), chat, &waE2E.Message{
 			ProtocolMessage: &waE2E.ProtocolMessage{
 				Type:                      waE2E.ProtocolMessage_EPHEMERAL_SETTING.Enum(),
@@ -673,9 +715,10 @@ func (cli *Client) sendNewsletter(
 }
 
 type nodeExtraParams struct {
-	botNode        *waBinary.Node
-	metaNode       *waBinary.Node
-	addressingMode types.AddressingMode
+	botNode         *waBinary.Node
+	metaNode        *waBinary.Node
+	additionalNodes *[]waBinary.Node
+	addressingMode  types.AddressingMode
 }
 
 func (cli *Client) sendGroup(
@@ -1001,7 +1044,7 @@ func (cli *Client) preparePeerMessageNode(
 		}
 	}
 	start = time.Now()
-	encrypted, isPreKey, err := cli.encryptMessageForDevice(ctx, plaintext, encryptionIdentity, nil, nil)
+	encrypted, isPreKey, err := cli.encryptMessageForDevice(ctx, plaintext, encryptionIdentity, nil, nil, nil)
 	timings.PeerEncrypt = time.Since(start)
 	if err != nil {
 		return nil, fmt.Errorf("failed to encrypt peer message for %s: %v", to, err)
@@ -1047,6 +1090,9 @@ func (cli *Client) getMessageContent(
 	if extraParams.metaNode != nil {
 		content = append(content, *extraParams.metaNode)
 	}
+	if extraParams.additionalNodes != nil {
+		content = append(content, *extraParams.additionalNodes...)
+	}
 
 	if buttonType := getButtonTypeFromMessage(message); buttonType != "" {
 		content = append(content, waBinary.Node{
@@ -1077,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)
@@ -1101,10 +1153,13 @@ func (cli *Client) prepareMessageNode(
 	}
 
 	start = time.Now()
-	participantNodes, includeIdentity := cli.encryptMessageForDevices(
+	participantNodes, includeIdentity, err := cli.encryptMessageForDevices(
 		ctx, allDevices, id, plaintext, dsmPlaintext, encAttrs,
 	)
 	timings.PeerEncrypt = time.Since(start)
+	if err != nil {
+		return nil, nil, err
+	}
 	participantNode := waBinary.Node{
 		Tag:     "participants",
 		Content: participantNodes,
@@ -1162,41 +1217,70 @@ func (cli *Client) encryptMessageForDevices(
 	id string,
 	msgPlaintext, dsmPlaintext []byte,
 	encAttrs waBinary.Attrs,
-) ([]waBinary.Node, bool) {
+) ([]waBinary.Node, bool, error) {
 	ownJID := cli.getOwnID()
 	ownLID := cli.getOwnLID()
 	includeIdentity := false
 	participantNodes := make([]waBinary.Node, 0, len(allDevices))
-	var retryDevices, retryEncryptionIdentities []types.JID
+
+	var pnDevices []types.JID
 	for _, jid := range allDevices {
-		plaintext := msgPlaintext
-		if (jid.User == ownJID.User || jid.User == ownLID.User) && dsmPlaintext != nil {
-			if jid == ownJID || jid == ownLID {
-				continue
-			}
-			plaintext = dsmPlaintext
+		if jid.Server == types.DefaultUserServer {
+			pnDevices = append(pnDevices, jid)
 		}
+	}
+	lidMappings, err := cli.Store.LIDs.GetManyLIDsForPNs(ctx, pnDevices)
+	if err != nil {
+		return nil, false, fmt.Errorf("failed to fetch LID mappings: %w", err)
+	}
+
+	encryptionIdentities := make(map[types.JID]types.JID, len(allDevices))
+	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 {
-			lidForPN, err := cli.Store.LIDs.GetLIDForPN(ctx, jid)
-			if err != nil {
-				cli.Log.Warnf("Failed to get LID for %s: %v", jid, err)
-			} else if !lidForPN.IsEmpty() {
+			// TODO query LID from server for missing entries
+			if lidForPN, ok := lidMappings[jid]; ok && !lidForPN.IsEmpty() {
 				cli.migrateSessionStore(ctx, jid, lidForPN)
 				encryptionIdentity = lidForPN
 			}
 		}
+		encryptionIdentities[jid] = encryptionIdentity
+		addr := encryptionIdentity.SignalAddress().String()
+		sessionAddresses = append(sessionAddresses, addr)
+		sessionAddressToJID[addr] = jid
+	}
+
+	existingSessions, ctx, err := cli.Store.WithCachedSessions(ctx, sessionAddresses)
+	if err != nil {
+		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)
 
+	for _, jid := range allDevices {
+		plaintext := msgPlaintext
+		if (jid.User == ownJID.User || jid.User == ownLID.User) && dsmPlaintext != nil {
+			if jid == ownJID || jid == ownLID {
+				continue
+			}
+			plaintext = dsmPlaintext
+		}
 		encrypted, isPreKey, err := cli.encryptMessageForDeviceAndWrap(
-			ctx, plaintext, jid, encryptionIdentity, nil, encAttrs,
+			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 {
+				return nil, false, err
+			}
 			continue
 		}
 
@@ -1205,37 +1289,11 @@ 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,
-				)
-				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
+	return participantNodes, includeIdentity, nil
 }
 
 func (cli *Client) encryptMessageForDeviceAndWrap(
@@ -1245,9 +1303,10 @@ func (cli *Client) encryptMessageForDeviceAndWrap(
 	encryptionIdentity types.JID,
 	bundle *prekey.Bundle,
 	encAttrs waBinary.Attrs,
+	existingSessions map[string]bool,
 ) (*waBinary.Node, bool, error) {
 	node, includeDeviceIdentity, err := cli.encryptMessageForDevice(
-		ctx, plaintext, encryptionIdentity, bundle, encAttrs,
+		ctx, plaintext, encryptionIdentity, bundle, encAttrs, existingSessions,
 	)
 	if err != nil {
 		return nil, false, err
@@ -1271,6 +1330,7 @@ func (cli *Client) encryptMessageForDevice(
 	to types.JID,
 	bundle *prekey.Bundle,
 	extraAttrs waBinary.Attrs,
+	existingSessions map[string]bool,
 ) (*waBinary.Node, bool, error) {
 	builder := session.NewBuilderFromSignal(cli.Store, to.SignalAddress(), pbSerializer)
 	if bundle != nil {
@@ -1287,10 +1347,18 @@ func (cli *Client) encryptMessageForDevice(
 		if err != nil {
 			return nil, false, fmt.Errorf("failed to process prekey bundle: %w", err)
 		}
-	} else if contains, err := cli.Store.ContainsSession(ctx, to.SignalAddress()); err != nil {
-		return nil, false, err
-	} else if !contains {
-		return nil, false, fmt.Errorf("%w with %s", ErrNoSession, to.SignalAddress().String())
+	} else {
+		sessionExists, checked := existingSessions[to.SignalAddress().String()]
+		if !checked {
+			var err error
+			sessionExists, err = cli.Store.ContainsSession(ctx, to.SignalAddress())
+			if err != nil {
+				return nil, false, err
+			}
+		}
+		if !sessionExists {
+			return nil, false, fmt.Errorf("%w with %s", ErrNoSession, to.SignalAddress().String())
+		}
 	}
 	cipher := session.NewCipher(builder, to.SignalAddress())
 	ciphertext, err := cipher.Encrypt(ctx, padMessage(plaintext))

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, 1026436087}
+var waVersion = WAVersionContainer{2, 3000, 1028259376}
 
 // waVersionHash is the md5 hash of a dot-separated waVersion
 var waVersionHash [16]byte