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

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

@@ -7,29 +7,33 @@
 package whatsmeow
 
 import (
+	"context"
 	"fmt"
 	"time"
 
+	"go.mau.fi/util/ptr"
+
 	waBinary "go.mau.fi/whatsmeow/binary"
 	"go.mau.fi/whatsmeow/types"
 	"go.mau.fi/whatsmeow/types/events"
 )
 
 func (cli *Client) handleReceipt(node *waBinary.Node) {
-	defer cli.maybeDeferredAck(node)()
+	var cancelled bool
+	defer cli.maybeDeferredAck(cli.BackgroundEventCtx, node)(&cancelled)
 	receipt, err := cli.parseReceipt(node)
 	if err != nil {
 		cli.Log.Warnf("Failed to parse receipt: %v", err)
 	} else if receipt != nil {
 		if receipt.Type == types.ReceiptTypeRetry {
 			go func() {
-				err := cli.handleRetryReceipt(receipt, node)
+				err := cli.handleRetryReceipt(cli.BackgroundEventCtx, receipt, node)
 				if err != nil {
 					cli.Log.Errorf("Failed to handle retry receipt for %s/%s from %s: %v", receipt.Chat, receipt.MessageIDs[0], receipt.Sender, err)
 				}
 			}()
 		}
-		cli.dispatchEvent(receipt)
+		cancelled = cli.dispatchEvent(receipt)
 	}
 }
 
@@ -49,7 +53,7 @@ func (cli *Client) handleGroupedReceipt(partialReceipt events.Receipt, participa
 			cli.Log.Warnf("Failed to parse user node %s in grouped receipt: %v", child.XMLString(), ag.Error())
 			continue
 		}
-		go cli.dispatchEvent(&receipt)
+		cli.dispatchEvent(&receipt)
 	}
 }
 
@@ -96,14 +100,17 @@ func (cli *Client) parseReceipt(node *waBinary.Node) (*events.Receipt, error) {
 	return &receipt, nil
 }
 
-func (cli *Client) maybeDeferredAck(node *waBinary.Node) func() {
+func (cli *Client) maybeDeferredAck(ctx context.Context, node *waBinary.Node) func(cancelled ...*bool) {
 	if cli.SynchronousAck {
-		return func() {
+		return func(cancelled ...*bool) {
+			if ctx.Err() != nil || (len(cancelled) > 0 && ptr.Val(cancelled[0])) {
+				return
+			}
 			cli.sendAck(node)
 		}
 	} else {
 		go cli.sendAck(node)
-		return func() {}
+		return func(...*bool) {}
 	}
 }
 
@@ -118,6 +125,15 @@ func (cli *Client) sendAck(node *waBinary.Node) {
 	}
 	if recipient, ok := node.Attrs["recipient"]; ok {
 		attrs["recipient"] = recipient
+
+		// TODO this hack probably needs to be removed at some point
+		recipientJID, ok := recipient.(types.JID)
+		if ok && recipientJID.Server == types.BotServer && node.Tag == "message" {
+			altRecipient, ok := types.BotJIDMap[recipientJID]
+			if ok {
+				attrs["recipient"] = altRecipient
+			}
+		}
 	}
 	if receiptType, ok := node.Attrs["type"]; node.Tag != "message" && ok {
 		attrs["type"] = receiptType
@@ -160,14 +176,14 @@ func (cli *Client) MarkRead(ids []types.MessageID, timestamp time.Time, chat, se
 			"t":    timestamp.Unix(),
 		},
 	}
-	if chat.Server == types.NewsletterServer || cli.GetPrivacySettings().ReadReceipts == types.PrivacySettingNone {
+	if chat.Server == types.NewsletterServer || cli.GetPrivacySettings(context.TODO()).ReadReceipts == types.PrivacySettingNone {
 		switch receiptType {
 		case types.ReceiptTypeRead:
 			node.Attrs["type"] = string(types.ReceiptTypeReadSelf)
 			// TODO change played to played-self?
 		}
 	}
-	if !sender.IsEmpty() && chat.Server != types.DefaultUserServer && chat.Server != types.MessengerServer {
+	if !sender.IsEmpty() && chat.Server != types.DefaultUserServer && chat.Server != types.HiddenUserServer && chat.Server != types.MessengerServer {
 		node.Attrs["participant"] = sender.ToNonAD()
 	}
 	if len(ids) > 1 {

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/reportingfields.json

@@ -0,0 +1 @@
+[{"f":1},{"f":3,"s":[{"f":2},{"f":3},{"f":8},{"f":11},{"f":17,"s":[{"f":21},{"f":22}]},{"f":25}]},{"f":4,"s":[{"f":1},{"f":16},{"f":17,"s":[{"f":21},{"f":22}]}]},{"f":5,"s":[{"f":3},{"f":4},{"f":5},{"f":16},{"f":17,"s":[{"f":21},{"f":22}]}]},{"f":6,"s":[{"f":1},{"f":17,"s":[{"f":21},{"f":22}]},{"f":30}]},{"f":7,"s":[{"f":2},{"f":7},{"f":10},{"f":17,"s":[{"f":21},{"f":22}]},{"f":20}]},{"f":8,"s":[{"f":2},{"f":7},{"f":9},{"f":17,"s":[{"f":21},{"f":22}]},{"f":21}]},{"f":9,"s":[{"f":2},{"f":6},{"f":7},{"f":13},{"f":17,"s":[{"f":21},{"f":22}]},{"f":20}]},{"f":12,"s":[{"f":1},{"f":2},{"f":14,"m":true},{"f":15}]},{"f":18,"s":[{"f":6},{"f":16},{"f":17,"s":[{"f":21},{"f":22}]}]},{"f":26,"s":[{"f":4},{"f":5},{"f":8},{"f":13},{"f":17,"s":[{"f":21},{"f":22}]}]},{"f":28,"s":[{"f":1},{"f":2},{"f":4},{"f":5},{"f":6},{"f":7,"s":[{"f":21},{"f":22}]}]},{"f":37,"s":[{"f":1,"m":true}]},{"f":49,"s":[{"f":2},{"f":3,"s":[{"f":1},{"f":2}]},{"f":5,"s":[{"f":21},{"f":22}]},{"f":8,"s":[{"f":1},{"f":2}]}]},{"f":53,"s":[{"f":1,"m":true}]},{"f":55,"s":[{"f":1,"m":true}]},{"f":58,"s":[{"f":1,"m":true}]},{"f":59,"s":[{"f":1,"m":true}]},{"f":60,"s":[{"f":2},{"f":3,"s":[{"f":1},{"f":2}]},{"f":5,"s":[{"f":21},{"f":22}]},{"f":8,"s":[{"f":1},{"f":2}]}]},{"f":64,"s":[{"f":2},{"f":3,"s":[{"f":1},{"f":2}]},{"f":5,"s":[{"f":21},{"f":22}]},{"f":8,"s":[{"f":1},{"f":2}]}]},{"f":66,"s":[{"f":2},{"f":6},{"f":7},{"f":13},{"f":17,"s":[{"f":21},{"f":22}]},{"f":20}]},{"f":74,"s":[{"f":1,"m":true}]},{"f":87,"s":[{"f":1,"m":true}]},{"f":88,"s":[{"f":1},{"f":2,"s":[{"f":1}]},{"f":3,"s":[{"f":21},{"f":22}]}]},{"f":92,"s":[{"f":1,"m":true}]},{"f":93,"s":[{"f":1,"m":true}]},{"f":94,"s":[{"f":1,"m":true}]}]

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

@@ -0,0 +1,176 @@
+// 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 whatsmeow
+
+import (
+	"crypto/hmac"
+	"crypto/sha256"
+	_ "embed"
+	"encoding/binary"
+	"encoding/json"
+	"sort"
+	"sync"
+
+	"go.mau.fi/util/exerrors"
+	"go.mau.fi/util/exstrings"
+
+	waBinary "go.mau.fi/whatsmeow/binary"
+	"go.mau.fi/whatsmeow/proto/waE2E"
+	"go.mau.fi/whatsmeow/types"
+)
+
+//go:embed reportingfields.json
+var reportingFieldsJSON string
+var getReportingFields = sync.OnceValue(func() (output []reportingField) {
+	exerrors.PanicIfNotNil(json.Unmarshal(exstrings.UnsafeBytes(reportingFieldsJSON), &output))
+	return
+})
+
+type reportingField struct {
+	FieldNumber int              `json:"f"`
+	IsMessage   bool             `json:"m,omitempty"`
+	Subfields   []reportingField `json:"s,omitempty"`
+}
+
+func (cli *Client) shouldIncludeReportingToken(message *waE2E.Message) bool {
+	if !cli.SendReportingTokens {
+		return false
+	}
+	return message.ReactionMessage == nil &&
+		message.EncReactionMessage == nil &&
+		message.EncEventResponseMessage == nil &&
+		message.PollUpdateMessage == nil
+}
+
+func (cli *Client) getMessageReportingToken(
+	msgProtobuf []byte,
+	msg *waE2E.Message,
+	senderJID, remoteJID types.JID,
+	messageID types.MessageID,
+) waBinary.Node {
+	reportingSecret, _ := generateMsgSecretKey(
+		EncSecretReportToken, senderJID, messageID, remoteJID,
+		msg.GetMessageContextInfo().GetMessageSecret(),
+	)
+	hasher := hmac.New(sha256.New, reportingSecret)
+	hasher.Write(getReportingToken(msgProtobuf))
+	return waBinary.Node{
+		Tag: "reporting",
+		Content: []waBinary.Node{{
+			Tag:     "reporting_token",
+			Attrs:   waBinary.Attrs{"v": "2"},
+			Content: hasher.Sum(nil)[:16],
+		}},
+	}
+}
+
+func getReportingToken(messageProtobuf []byte) []byte {
+	return extractReportingTokenContent(messageProtobuf, getReportingFields())
+}
+
+// Helper to find config for a field number
+func getConfigForField(fields []reportingField, fieldNum int) *reportingField {
+	for i := range fields {
+		if fields[i].FieldNumber == fieldNum {
+			return &fields[i]
+		}
+	}
+	return nil
+}
+
+// Protobuf wire types
+const (
+	wireVarint = 0
+	wire64bit  = 1
+	wireBytes  = 2
+	wire32bit  = 5
+)
+
+// Extracts the reporting token content recursively
+func extractReportingTokenContent(data []byte, config []reportingField) []byte {
+	type field struct {
+		Num   int
+		Bytes []byte
+	}
+	var fields []field
+	i := 0
+	for i < len(data) {
+		// Read tag (varint)
+		tag, tagLen := binary.Uvarint(data[i:])
+		if tagLen <= 0 {
+			break // malformed
+		}
+		fieldNum := int(tag >> 3)
+		wireType := int(tag & 0x7)
+		fieldCfg := getConfigForField(config, fieldNum)
+		fieldStart := i
+		i += tagLen
+		if fieldCfg == nil {
+			// Skip field
+			switch wireType {
+			case wireVarint:
+				_, n := binary.Uvarint(data[i:])
+				i += n
+			case wire64bit:
+				i += 8
+			case wireBytes:
+				l, n := binary.Uvarint(data[i:])
+				i += n + int(l)
+			case wire32bit:
+				i += 4
+			default:
+				return nil
+			}
+			continue
+		}
+		switch wireType {
+		case wireVarint:
+			_, n := binary.Uvarint(data[i:])
+			i += n
+			fields = append(fields, field{Num: fieldNum, Bytes: data[fieldStart:i]})
+		case wire64bit:
+			i += 8
+			fields = append(fields, field{Num: fieldNum, Bytes: data[fieldStart:i]})
+		case wireBytes:
+			l, n := binary.Uvarint(data[i:])
+			valStart := i + n
+			valEnd := valStart + int(l)
+			if fieldCfg.IsMessage || len(fieldCfg.Subfields) > 0 {
+				// Recursively extract subfields
+				sub := extractReportingTokenContent(data[valStart:valEnd], fieldCfg.Subfields)
+				if len(sub) > 0 {
+					// Re-encode tag and length
+					buf := make([]byte, 0, tagLen+n+len(sub))
+					tagBuf := make([]byte, binary.MaxVarintLen64)
+					tagN := binary.PutUvarint(tagBuf, tag)
+					lenBuf := make([]byte, binary.MaxVarintLen64)
+					lenN := binary.PutUvarint(lenBuf, uint64(len(sub)))
+					buf = append(buf, tagBuf[:tagN]...)
+					buf = append(buf, lenBuf[:lenN]...)
+					buf = append(buf, sub...)
+					fields = append(fields, field{Num: fieldNum, Bytes: buf})
+				}
+			} else {
+				fields = append(fields, field{Num: fieldNum, Bytes: data[fieldStart:valEnd]})
+			}
+			i = valEnd
+		case wire32bit:
+			i += 4
+			fields = append(fields, field{Num: fieldNum, Bytes: data[fieldStart:i]})
+		default:
+			return nil
+		}
+	}
+	// Sort by field number
+	sort.Slice(fields, func(i, j int) bool { return fields[i].Num < fields[j].Num })
+	// Concatenate
+	var out []byte
+	for _, f := range fields {
+		out = append(out, f.Bytes...)
+	}
+	return out
+}

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

@@ -69,7 +69,7 @@ func (cli *Client) getRecentMessage(to types.JID, id types.MessageID) RecentMess
 	return msg
 }
 
-func (cli *Client) getMessageForRetry(receipt *events.Receipt, messageID types.MessageID) (RecentMessage, error) {
+func (cli *Client) getMessageForRetry(ctx context.Context, receipt *events.Receipt, messageID types.MessageID) (RecentMessage, error) {
 	msg := cli.getRecentMessage(receipt.Chat, messageID)
 	if msg.IsEmpty() {
 		waMsg := cli.GetMessageForRetry(receipt.Sender, receipt.Chat, messageID)
@@ -87,10 +87,12 @@ func (cli *Client) getMessageForRetry(receipt *events.Receipt, messageID types.M
 
 const recreateSessionTimeout = 1 * time.Hour
 
-func (cli *Client) shouldRecreateSession(retryCount int, jid types.JID) (reason string, recreate bool) {
+func (cli *Client) shouldRecreateSession(ctx context.Context, retryCount int, jid types.JID) (reason string, recreate bool) {
 	cli.sessionRecreateHistoryLock.Lock()
 	defer cli.sessionRecreateHistoryLock.Unlock()
-	if !cli.Store.ContainsSession(jid.SignalAddress()) {
+	if contains, err := cli.Store.ContainsSession(ctx, jid.SignalAddress()); err != nil {
+		return "", false
+	} else if !contains {
 		cli.sessionRecreateHistory[jid] = time.Now()
 		return "we don't have a Signal session with them", true
 	} else if retryCount < 2 {
@@ -110,7 +112,7 @@ type incomingRetryKey struct {
 }
 
 // handleRetryReceipt handles an incoming retry receipt for an outgoing message.
-func (cli *Client) handleRetryReceipt(receipt *events.Receipt, node *waBinary.Node) error {
+func (cli *Client) handleRetryReceipt(ctx context.Context, receipt *events.Receipt, node *waBinary.Node) error {
 	retryChild, ok := node.GetOptionalChildByTag("retry")
 	if !ok {
 		return &ElementMissingError{Tag: "retry", In: "retry receipt"}
@@ -122,7 +124,7 @@ func (cli *Client) handleRetryReceipt(receipt *events.Receipt, node *waBinary.No
 	if !ag.OK() {
 		return ag.Error()
 	}
-	msg, err := cli.getMessageForRetry(receipt, messageID)
+	msg, err := cli.getMessageForRetry(ctx, receipt, messageID)
 	if err != nil {
 		return err
 	}
@@ -147,17 +149,12 @@ func (cli *Client) handleRetryReceipt(receipt *events.Receipt, node *waBinary.No
 		return nil
 	}
 
-	ownID := cli.getOwnID()
-	if ownID.IsEmpty() {
-		return ErrNotLoggedIn
-	}
-
 	var fbSKDM *waMsgTransport.MessageTransport_Protocol_Ancillary_SenderKeyDistributionMessage
 	var fbDSM *waMsgTransport.MessageTransport_Protocol_Integral_DeviceSentMessage
 	if receipt.IsGroup {
 		builder := groups.NewGroupSessionBuilder(cli.Store, pbSerializer)
-		senderKeyName := protocol.NewSenderKeyName(receipt.Chat.String(), ownID.SignalAddress())
-		signalSKDMessage, err := builder.Create(senderKeyName)
+		senderKeyName := protocol.NewSenderKeyName(receipt.Chat.String(), cli.getOwnLID().SignalAddress())
+		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)
 		}
@@ -215,10 +212,10 @@ func (cli *Client) handleRetryReceipt(receipt *events.Receipt, node *waBinary.No
 		if err != nil {
 			return fmt.Errorf("failed to read prekey bundle in retry receipt: %w", err)
 		}
-	} else if reason, recreate := cli.shouldRecreateSession(retryCount, receipt.Sender); recreate {
+	} else if reason, recreate := cli.shouldRecreateSession(ctx, retryCount, receipt.Sender); recreate {
 		cli.Log.Debugf("Fetching prekeys for %s for handling retry receipt with no prekey bundle because %s", receipt.Sender, reason)
 		var keys map[types.JID]preKeyResp
-		keys, err = cli.fetchPreKeys(context.TODO(), []types.JID{receipt.Sender})
+		keys, err = cli.fetchPreKeys(ctx, []types.JID{receipt.Sender})
 		if err != nil {
 			return err
 		}
@@ -245,9 +242,19 @@ func (cli *Client) handleRetryReceipt(receipt *events.Receipt, node *waBinary.No
 	var encrypted *waBinary.Node
 	var includeDeviceIdentity bool
 	if msg.wa != nil {
-		encrypted, includeDeviceIdentity, err = cli.encryptMessageForDevice(plaintext, receipt.Sender, bundle, encAttrs)
+		encryptionIdentity := receipt.Sender
+		if receipt.Sender.Server == types.DefaultUserServer {
+			lidForPN, err := cli.Store.LIDs.GetLIDForPN(ctx, receipt.Sender)
+			if err != nil {
+				cli.Log.Warnf("Failed to get LID for %s: %v", receipt.Sender, err)
+			} else if !lidForPN.IsEmpty() {
+				cli.migrateSessionStore(ctx, receipt.Sender, lidForPN)
+				encryptionIdentity = lidForPN
+			}
+		}
+		encrypted, includeDeviceIdentity, err = cli.encryptMessageForDevice(ctx, plaintext, encryptionIdentity, bundle, encAttrs)
 	} else {
-		encrypted, err = cli.encryptMessageForDeviceV3(&waMsgTransport.MessageTransport_Payload{
+		encrypted, err = cli.encryptMessageForDeviceV3(ctx, &waMsgTransport.MessageTransport_Payload{
 			ApplicationPayload: &waCommon.SubProtocol{
 				Payload: plaintext,
 				Version: proto.Int32(FBMessageApplicationVersion),
@@ -280,7 +287,9 @@ func (cli *Client) handleRetryReceipt(receipt *events.Receipt, node *waBinary.No
 	}
 	var content []waBinary.Node
 	if msg.wa != nil {
-		content = cli.getMessageContent(*encrypted, msg.wa, attrs, includeDeviceIdentity, nil)
+		content = cli.getMessageContent(
+			*encrypted, msg.wa, attrs, includeDeviceIdentity, nodeExtraParams{},
+		)
 	} else {
 		content = []waBinary.Node{
 			*encrypted,
@@ -325,7 +334,7 @@ func (cli *Client) delayedRequestMessageFromPhone(info *types.MessageInfo) {
 		cli.pendingPhoneRerequestsLock.Unlock()
 		return
 	}
-	ctx, cancel := context.WithCancel(context.Background())
+	ctx, cancel := context.WithCancel(cli.BackgroundEventCtx)
 	defer cancel()
 	cli.pendingPhoneRerequests[info.ID] = cancel
 	cli.pendingPhoneRerequestsLock.Unlock()
@@ -341,6 +350,10 @@ func (cli *Client) delayedRequestMessageFromPhone(info *types.MessageInfo) {
 		cli.Log.Debugf("Cancelled delayed request for message %s from phone", info.ID)
 		return
 	}
+	cli.immediateRequestMessageFromPhone(ctx, info)
+}
+
+func (cli *Client) immediateRequestMessageFromPhone(ctx context.Context, info *types.MessageInfo) {
 	_, err := cli.SendMessage(
 		ctx,
 		cli.getOwnID().ToNonAD(),
@@ -352,6 +365,7 @@ func (cli *Client) delayedRequestMessageFromPhone(info *types.MessageInfo) {
 	} else {
 		cli.Log.Debugf("Requested message %s from phone", info.ID)
 	}
+	return
 }
 
 func (cli *Client) clearDelayedMessageRequests() {
@@ -363,7 +377,7 @@ func (cli *Client) clearDelayedMessageRequests() {
 }
 
 // sendRetryReceipt sends a retry receipt for an incoming message.
-func (cli *Client) sendRetryReceipt(node *waBinary.Node, info *types.MessageInfo, forceIncludeIdentity bool) {
+func (cli *Client) sendRetryReceipt(ctx context.Context, node *waBinary.Node, info *types.MessageInfo, forceIncludeIdentity bool) {
 	id, _ := node.Attrs["id"].(string)
 	children := node.GetChildren()
 	var retryCountInMsg int
@@ -385,7 +399,11 @@ func (cli *Client) sendRetryReceipt(node *waBinary.Node, info *types.MessageInfo
 		return
 	}
 	if retryCount == 1 {
-		go cli.delayedRequestMessageFromPhone(info)
+		if cli.SynchronousAck {
+			cli.immediateRequestMessageFromPhone(ctx, info)
+		} else {
+			go cli.delayedRequestMessageFromPhone(info)
+		}
 	}
 
 	var registrationIDBytes [4]byte
@@ -415,7 +433,7 @@ func (cli *Client) sendRetryReceipt(node *waBinary.Node, info *types.MessageInfo
 		},
 	}
 	if retryCount > 1 || forceIncludeIdentity {
-		if key, err := cli.Store.PreKeys.GenOnePreKey(); err != nil {
+		if key, err := cli.Store.PreKeys.GenOnePreKey(ctx); err != nil {
 			cli.Log.Errorf("Failed to get prekey for retry receipt: %v", err)
 		} else if deviceIdentity, err := proto.Marshal(cli.Store.Account); err != nil {
 			cli.Log.Errorf("Failed to marshal account info: %v", err)