slidge-whatsapp 0.3.7__cp312-cp312-manylinux_2_41_aarch64.whl → 0.3.8__cp312-cp312-manylinux_2_41_aarch64.whl

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

@@ -27,14 +27,14 @@ var (
 	KeepAliveMaxFailTime = 3 * time.Minute
 )
 
-func (cli *Client) keepAliveLoop(ctx context.Context) {
+func (cli *Client) keepAliveLoop(ctx, connCtx context.Context) {
 	lastSuccess := time.Now()
 	var errorCount int
 	for {
 		interval := rand.Int64N(KeepAliveIntervalMax.Milliseconds()-KeepAliveIntervalMin.Milliseconds()) + KeepAliveIntervalMin.Milliseconds()
 		select {
 		case <-time.After(time.Duration(interval) * time.Millisecond):
-			isSuccess, shouldContinue := cli.sendKeepAlive(ctx)
+			isSuccess, shouldContinue := cli.sendKeepAlive(connCtx)
 			if !shouldContinue {
 				return
 			} else if !isSuccess {
@@ -47,7 +47,7 @@ func (cli *Client) keepAliveLoop(ctx context.Context) {
 					cli.Log.Debugf("Forcing reconnect due to keepalive failure")
 					cli.Disconnect()
 					cli.resetExpectedDisconnect()
-					go cli.autoReconnect()
+					go cli.autoReconnect(ctx)
 				}
 			} else {
 				if errorCount > 0 {
@@ -56,19 +56,21 @@ func (cli *Client) keepAliveLoop(ctx context.Context) {
 				}
 				lastSuccess = time.Now()
 			}
-		case <-ctx.Done():
+		case <-connCtx.Done():
 			return
 		}
 	}
 }
 
 func (cli *Client) sendKeepAlive(ctx context.Context) (isSuccess, shouldContinue bool) {
-	respCh, err := cli.sendIQAsync(infoQuery{
+	respCh, err := cli.sendIQAsync(ctx, infoQuery{
 		Namespace: "w:p",
 		Type:      "get",
 		To:        types.ServerJID,
 	})
-	if err != nil {
+	if ctx.Err() != nil {
+		return false, false
+	} else if err != nil {
 		cli.Log.Warnf("Failed to send keepalive: %v", err)
 		return false, true
 	}

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

@@ -58,8 +58,7 @@ func (cli *Client) refreshMediaConn(ctx context.Context, force bool) (*MediaConn
 }
 
 func (cli *Client) queryMediaConn(ctx context.Context) (*MediaConn, error) {
-	resp, err := cli.sendIQ(infoQuery{
-		Context:   ctx,
+	resp, err := cli.sendIQ(ctx, infoQuery{
 		Namespace: "w:m",
 		Type:      "set",
 		To:        types.ServerJID,

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

@@ -74,7 +74,7 @@ func encryptMediaRetryReceipt(messageID types.MessageID, mediaKey []byte) (ciphe
 //	    // Alternatively, you can use cli.DownloadMediaWithPath and provide the individual fields manually.
 //	  }
 //	}
-func (cli *Client) SendMediaRetryReceipt(message *types.MessageInfo, mediaKey []byte) error {
+func (cli *Client) SendMediaRetryReceipt(ctx context.Context, message *types.MessageInfo, mediaKey []byte) error {
 	if cli == nil {
 		return ErrClientIsNil
 	}
@@ -100,7 +100,7 @@ func (cli *Client) SendMediaRetryReceipt(message *types.MessageInfo, mediaKey []
 		{Tag: "enc_iv", Content: iv},
 	}
 
-	err = cli.sendNode(waBinary.Node{
+	err = cli.sendNode(ctx, waBinary.Node{
 		Tag: "receipt",
 		Attrs: waBinary.Attrs{
 			"id":   message.ID,

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

@@ -40,8 +40,7 @@ import (
 
 var pbSerializer = store.SignalProtobufSerializer
 
-func (cli *Client) handleEncryptedMessage(node *waBinary.Node) {
-	ctx := cli.BackgroundEventCtx
+func (cli *Client) handleEncryptedMessage(ctx context.Context, node *waBinary.Node) {
 	info, err := cli.parseMessageInfo(node)
 	if err != nil {
 		cli.Log.Warnf("Failed to parse message: %v", err)
@@ -52,10 +51,10 @@ func (cli *Client) handleEncryptedMessage(node *waBinary.Node) {
 			cli.StoreLIDPNMapping(ctx, info.RecipientAlt, info.Chat)
 		}
 		if info.VerifiedName != nil && len(info.VerifiedName.Details.GetVerifiedName()) > 0 {
-			go cli.updateBusinessName(cli.BackgroundEventCtx, info.Sender, info, info.VerifiedName.Details.GetVerifiedName())
+			go cli.updateBusinessName(ctx, info.Sender, info.SenderAlt, info, info.VerifiedName.Details.GetVerifiedName())
 		}
 		if len(info.PushName) > 0 && info.PushName != "-" && (cli.MessengerConfig == nil || info.PushName != "username") {
-			go cli.updatePushName(cli.BackgroundEventCtx, info.Sender, info, info.PushName)
+			go cli.updatePushName(ctx, info.Sender, info.SenderAlt, info, info.PushName)
 		}
 		if info.Sender.Server == types.NewsletterServer {
 			var cancelled bool
@@ -303,7 +302,7 @@ func (cli *Client) decryptMessages(ctx context.Context, info *types.MessageInfo,
 		cli.Log.Warnf("Unavailable message %s from %s (type: %q)", info.ID, info.SourceString(), uType)
 		cli.backgroundIfAsyncAck(func() {
 			cli.immediateRequestMessageFromPhone(ctx, info)
-			cli.sendAck(node, 0)
+			cli.sendAck(ctx, node, 0)
 		})
 		cli.dispatchEvent(&events.UndecryptableMessage{Info: *info, IsUnavailable: true, UnavailableType: uType})
 		return
@@ -391,15 +390,15 @@ func (cli *Client) decryptMessages(ctx context.Context, info *types.MessageInfo,
 			isUnavailable := encType == "skmsg" && !containsDirectMsg && errors.Is(err, signalerror.ErrNoSenderKeyForUser)
 			if encType == "msmsg" {
 				cli.backgroundIfAsyncAck(func() {
-					cli.sendAck(node, NackMissingMessageSecret)
+					cli.sendAck(ctx, node, NackMissingMessageSecret)
 				})
 			} else if cli.SynchronousAck {
 				cli.sendRetryReceipt(ctx, node, info, isUnavailable)
 				// TODO this probably isn't supposed to ack
-				cli.sendAck(node, 0)
+				cli.sendAck(ctx, node, 0)
 			} else {
 				go cli.sendRetryReceipt(context.WithoutCancel(ctx), node, info, isUnavailable)
-				go cli.sendAck(node, 0)
+				go cli.sendAck(ctx, node, 0)
 			}
 			cli.dispatchEvent(&events.UndecryptableMessage{
 				Info:            *info,
@@ -460,11 +459,11 @@ func (cli *Client) decryptMessages(ctx context.Context, info *types.MessageInfo,
 	}
 	cli.backgroundIfAsyncAck(func() {
 		if !recognizedStanza {
-			cli.sendAck(node, NackUnrecognizedStanza)
+			cli.sendAck(ctx, node, NackUnrecognizedStanza)
 		} else if protobufFailed {
-			cli.sendAck(node, NackInvalidProtobuf)
+			cli.sendAck(ctx, node, NackInvalidProtobuf)
 		} else {
-			cli.sendMessageReceipt(info, node)
+			cli.sendMessageReceipt(ctx, info, node)
 		}
 	})
 	return
@@ -690,37 +689,41 @@ func (cli *Client) handleHistorySyncNotificationLoop() {
 // You only need to call this manually if you set [Client.ManualHistorySyncDownload] to true.
 // By default, whatsmeow will call this automatically and dispatch an [events.HistorySync] with the parsed data.
 func (cli *Client) DownloadHistorySync(ctx context.Context, notif *waE2E.HistorySyncNotification, synchronousStorage bool) (*waHistorySync.HistorySync, error) {
-	var historySync waHistorySync.HistorySync
-	if data, err := cli.Download(ctx, notif); err != nil {
+	var data []byte
+	var err error
+	if notif.InitialHistBootstrapInlinePayload != nil {
+		data = notif.InitialHistBootstrapInlinePayload
+	} else if data, err = cli.Download(ctx, notif); err != nil {
 		return nil, fmt.Errorf("failed to download: %w", err)
-	} else if reader, err := zlib.NewReader(bytes.NewReader(data)); err != nil {
+	}
+	var historySync waHistorySync.HistorySync
+	if reader, err := zlib.NewReader(bytes.NewReader(data)); err != nil {
 		return nil, fmt.Errorf("failed to prepare to decompress: %w", err)
 	} else if rawData, err := io.ReadAll(reader); err != nil {
 		return nil, fmt.Errorf("failed to decompress: %w", err)
 	} else if err = proto.Unmarshal(rawData, &historySync); err != nil {
 		return nil, fmt.Errorf("failed to unmarshal: %w", err)
-	} else {
-		cli.Log.Debugf("Received history sync (type %s, chunk %d, progress %d)", historySync.GetSyncType(), historySync.GetChunkOrder(), historySync.GetProgress())
-		doStorage := func(ctx context.Context) {
-			if historySync.GetSyncType() == waHistorySync.HistorySync_PUSH_NAME {
-				cli.handleHistoricalPushNames(ctx, historySync.GetPushnames())
-			} else if len(historySync.GetConversations()) > 0 {
-				cli.storeHistoricalMessageSecrets(ctx, historySync.GetConversations())
-			}
-			if len(historySync.GetPhoneNumberToLidMappings()) > 0 {
-				cli.storeHistoricalPNLIDMappings(ctx, historySync.GetPhoneNumberToLidMappings())
-			}
-			if historySync.GlobalSettings != nil {
-				cli.storeGlobalSettings(ctx, historySync.GlobalSettings)
-			}
+	}
+	cli.Log.Debugf("Received history sync (type %s, chunk %d, progress %d)", historySync.GetSyncType(), historySync.GetChunkOrder(), historySync.GetProgress())
+	doStorage := func(ctx context.Context) {
+		if historySync.GetSyncType() == waHistorySync.HistorySync_PUSH_NAME {
+			cli.handleHistoricalPushNames(ctx, historySync.GetPushnames())
+		} else if len(historySync.GetConversations()) > 0 {
+			cli.storeHistoricalMessageSecrets(ctx, historySync.GetConversations())
 		}
-		if synchronousStorage {
-			doStorage(ctx)
-		} else {
-			go doStorage(context.WithoutCancel(ctx))
+		if len(historySync.GetPhoneNumberToLidMappings()) > 0 {
+			cli.storeHistoricalPNLIDMappings(ctx, historySync.GetPhoneNumberToLidMappings())
 		}
-		return &historySync, nil
+		if historySync.GlobalSettings != nil {
+			cli.storeGlobalSettings(ctx, historySync.GlobalSettings)
+		}
+	}
+	if synchronousStorage {
+		doStorage(ctx)
+	} else {
+		go doStorage(context.WithoutCancel(ctx))
 	}
+	return &historySync, nil
 }
 
 func (cli *Client) handleAppStateSyncKeyShare(ctx context.Context, keys *waE2E.AppStateSyncKeyShare) {
@@ -795,7 +798,7 @@ func (cli *Client) handleProtocolMessage(ctx context.Context, info *types.Messag
 				go cli.handleHistorySyncNotificationLoop()
 			}
 		}
-		go cli.sendProtocolMessageReceipt(info.ID, types.ReceiptTypeHistorySync)
+		go cli.sendProtocolMessageReceipt(ctx, info.ID, types.ReceiptTypeHistorySync)
 	}
 
 	if protoMsg.GetLidMigrationMappingSyncMessage() != nil {
@@ -811,7 +814,7 @@ func (cli *Client) handleProtocolMessage(ctx context.Context, info *types.Messag
 	}
 
 	if info.Category == "peer" {
-		go cli.sendProtocolMessageReceipt(info.ID, types.ReceiptTypePeerMsg)
+		go cli.sendProtocolMessageReceipt(ctx, info.ID, types.ReceiptTypePeerMsg)
 	}
 	return
 }
@@ -1024,17 +1027,16 @@ func (cli *Client) handleDecryptedMessage(ctx context.Context, info *types.Messa
 	return cli.dispatchEvent(evt.UnwrapRaw())
 }
 
-func (cli *Client) sendProtocolMessageReceipt(id types.MessageID, msgType types.ReceiptType) {
-	clientID := cli.Store.ID
-	if len(id) == 0 || clientID == nil {
+func (cli *Client) sendProtocolMessageReceipt(ctx context.Context, id types.MessageID, msgType types.ReceiptType) {
+	if len(id) == 0 {
 		return
 	}
-	err := cli.sendNode(waBinary.Node{
+	err := cli.sendNode(ctx, waBinary.Node{
 		Tag: "receipt",
 		Attrs: waBinary.Attrs{
 			"id":   string(id),
 			"type": string(msgType),
-			"to":   types.NewJID(clientID.User, types.LegacyUserServer),
+			"to":   cli.getOwnID().ToNonAD(),
 		},
 		Content: nil,
 	})

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

@@ -20,13 +20,13 @@ import (
 	"go.mau.fi/whatsmeow/argo"
 	waBinary "go.mau.fi/whatsmeow/binary"
 	"go.mau.fi/whatsmeow/proto/waWa6"
+	"go.mau.fi/whatsmeow/store"
 	"go.mau.fi/whatsmeow/types"
 )
 
 // NewsletterSubscribeLiveUpdates subscribes to receive live updates from a WhatsApp channel temporarily (for the duration returned).
 func (cli *Client) NewsletterSubscribeLiveUpdates(ctx context.Context, jid types.JID) (time.Duration, error) {
-	resp, err := cli.sendIQ(infoQuery{
-		Context:   ctx,
+	resp, err := cli.sendIQ(ctx, infoQuery{
 		Namespace: "newsletter",
 		Type:      iqSet,
 		To:        jid,
@@ -45,7 +45,7 @@ func (cli *Client) NewsletterSubscribeLiveUpdates(ctx context.Context, jid types
 // NewsletterMarkViewed marks a channel message as viewed, incrementing the view counter.
 //
 // This is not the same as marking the channel as read on your other devices, use the usual MarkRead function for that.
-func (cli *Client) NewsletterMarkViewed(jid types.JID, serverIDs []types.MessageServerID) error {
+func (cli *Client) NewsletterMarkViewed(ctx context.Context, jid types.JID, serverIDs []types.MessageServerID) error {
 	if cli == nil {
 		return ErrClientIsNil
 	}
@@ -60,7 +60,7 @@ func (cli *Client) NewsletterMarkViewed(jid types.JID, serverIDs []types.Message
 	}
 	reqID := cli.generateRequestID()
 	resp := cli.waitResponse(reqID)
-	err := cli.sendNode(waBinary.Node{
+	err := cli.sendNode(ctx, waBinary.Node{
 		Tag: "receipt",
 		Attrs: waBinary.Attrs{
 			"to":   jid,
@@ -85,7 +85,7 @@ func (cli *Client) NewsletterMarkViewed(jid types.JID, serverIDs []types.Message
 // To remove a reaction sent earlier, set reaction to an empty string.
 //
 // The last parameter is the message ID of the reaction itself. It can be left empty to let whatsmeow generate a random one.
-func (cli *Client) NewsletterSendReaction(jid types.JID, serverID types.MessageServerID, reaction string, messageID types.MessageID) error {
+func (cli *Client) NewsletterSendReaction(ctx context.Context, jid types.JID, serverID types.MessageServerID, reaction string, messageID types.MessageID) error {
 	if messageID == "" {
 		messageID = cli.GenerateMessageID()
 	}
@@ -101,7 +101,7 @@ func (cli *Client) NewsletterSendReaction(jid types.JID, serverID types.MessageS
 	} else {
 		messageAttrs["edit"] = string(types.EditAttributeSenderRevoke)
 	}
-	return cli.sendNode(waBinary.Node{
+	return cli.sendNode(ctx, waBinary.Node{
 		Tag:   "message",
 		Attrs: messageAttrs,
 		Content: []waBinary.Node{{
@@ -170,6 +170,9 @@ func convertQueryID(cli *Client, queryID string) string {
 }
 
 func (cli *Client) sendMexIQ(ctx context.Context, queryID string, variables any) (json.RawMessage, error) {
+	if store.BaseClientPayload.GetUserAgent().GetPlatform() == waWa6.ClientPayload_UserAgent_MACOS {
+		return nil, fmt.Errorf("argo decoding is currently broken")
+	}
 	queryID = convertQueryID(cli, queryID)
 	payload, err := json.Marshal(map[string]any{
 		"variables": variables,
@@ -177,7 +180,7 @@ func (cli *Client) sendMexIQ(ctx context.Context, queryID string, variables any)
 	if err != nil {
 		return nil, err
 	}
-	resp, err := cli.sendIQ(infoQuery{
+	resp, err := cli.sendIQ(ctx, infoQuery{
 		Namespace: "w:mex",
 		Type:      iqGet,
 		To:        types.ServerJID,
@@ -188,7 +191,6 @@ func (cli *Client) sendMexIQ(ctx context.Context, queryID string, variables any)
 			},
 			Content: payload,
 		}},
-		Context: ctx,
 	})
 	if err != nil {
 		return nil, err
@@ -202,6 +204,9 @@ func (cli *Client) sendMexIQ(ctx context.Context, queryID string, variables any)
 		return nil, fmt.Errorf("unexpected content type %T in mex response", result.Content)
 	}
 	if result.AttrGetter().OptionalString("format") == "argo" {
+		if true {
+			return nil, fmt.Errorf("argo decoding is currently broken")
+		}
 		store, err := argo.GetStore()
 		if err != nil {
 			return nil, err
@@ -241,8 +246,8 @@ type respGetNewsletterInfo struct {
 	Newsletter *types.NewsletterMetadata `json:"xwa2_newsletter"`
 }
 
-func (cli *Client) getNewsletterInfo(input map[string]any, fetchViewerMeta bool) (*types.NewsletterMetadata, error) {
-	data, err := cli.sendMexIQ(context.TODO(), queryFetchNewsletter, map[string]any{
+func (cli *Client) getNewsletterInfo(ctx context.Context, input map[string]any, fetchViewerMeta bool) (*types.NewsletterMetadata, error) {
+	data, err := cli.sendMexIQ(ctx, queryFetchNewsletter, map[string]any{
 		"fetch_creation_time":   true,
 		"fetch_full_image":      true,
 		"fetch_viewer_metadata": fetchViewerMeta,
@@ -259,8 +264,8 @@ func (cli *Client) getNewsletterInfo(input map[string]any, fetchViewerMeta bool)
 }
 
 // GetNewsletterInfo gets the info of a newsletter that you're joined to.
-func (cli *Client) GetNewsletterInfo(jid types.JID) (*types.NewsletterMetadata, error) {
-	return cli.getNewsletterInfo(map[string]any{
+func (cli *Client) GetNewsletterInfo(ctx context.Context, jid types.JID) (*types.NewsletterMetadata, error) {
+	return cli.getNewsletterInfo(ctx, map[string]any{
 		"key":  jid.String(),
 		"type": types.NewsletterKeyTypeJID,
 	}, true)
@@ -271,8 +276,8 @@ func (cli *Client) GetNewsletterInfo(jid types.JID) (*types.NewsletterMetadata,
 // You can either pass the full link (https://whatsapp.com/channel/...) or just the `...` part.
 //
 // Note that the ViewerMeta field of the returned NewsletterMetadata will be nil.
-func (cli *Client) GetNewsletterInfoWithInvite(key string) (*types.NewsletterMetadata, error) {
-	return cli.getNewsletterInfo(map[string]any{
+func (cli *Client) GetNewsletterInfoWithInvite(ctx context.Context, key string) (*types.NewsletterMetadata, error) {
+	return cli.getNewsletterInfo(ctx, map[string]any{
 		"key":  strings.TrimPrefix(key, NewsletterLinkPrefix),
 		"type": types.NewsletterKeyTypeInvite,
 	}, false)
@@ -283,8 +288,8 @@ type respGetSubscribedNewsletters struct {
 }
 
 // GetSubscribedNewsletters gets the info of all newsletters that you're joined to.
-func (cli *Client) GetSubscribedNewsletters() ([]*types.NewsletterMetadata, error) {
-	data, err := cli.sendMexIQ(context.TODO(), querySubscribedNewsletters, map[string]any{})
+func (cli *Client) GetSubscribedNewsletters(ctx context.Context) ([]*types.NewsletterMetadata, error) {
+	data, err := cli.sendMexIQ(ctx, querySubscribedNewsletters, map[string]any{})
 	var respData respGetSubscribedNewsletters
 	if data != nil {
 		jsonErr := json.Unmarshal(data, &respData)
@@ -306,8 +311,8 @@ type respCreateNewsletter struct {
 }
 
 // CreateNewsletter creates a new WhatsApp channel.
-func (cli *Client) CreateNewsletter(params CreateNewsletterParams) (*types.NewsletterMetadata, error) {
-	resp, err := cli.sendMexIQ(context.TODO(), mutationCreateNewsletter, map[string]any{
+func (cli *Client) CreateNewsletter(ctx context.Context, params CreateNewsletterParams) (*types.NewsletterMetadata, error) {
+	resp, err := cli.sendMexIQ(ctx, mutationCreateNewsletter, map[string]any{
 		"newsletter_input": &params,
 	})
 	if err != nil {
@@ -326,8 +331,8 @@ func (cli *Client) CreateNewsletter(params CreateNewsletterParams) (*types.Newsl
 // To accept the terms for creating newsletters, use
 //
 //	cli.AcceptTOSNotice("20601218", "5")
-func (cli *Client) AcceptTOSNotice(noticeID, stage string) error {
-	_, err := cli.sendIQ(infoQuery{
+func (cli *Client) AcceptTOSNotice(ctx context.Context, noticeID, stage string) error {
+	_, err := cli.sendIQ(ctx, infoQuery{
 		Namespace: "tos",
 		Type:      iqSet,
 		To:        types.ServerJID,
@@ -343,28 +348,28 @@ func (cli *Client) AcceptTOSNotice(noticeID, stage string) error {
 }
 
 // NewsletterToggleMute changes the mute status of a newsletter.
-func (cli *Client) NewsletterToggleMute(jid types.JID, mute bool) error {
+func (cli *Client) NewsletterToggleMute(ctx context.Context, jid types.JID, mute bool) error {
 	query := mutationUnmuteNewsletter
 	if mute {
 		query = mutationMuteNewsletter
 	}
-	_, err := cli.sendMexIQ(context.TODO(), query, map[string]any{
+	_, err := cli.sendMexIQ(ctx, query, map[string]any{
 		"newsletter_id": jid.String(),
 	})
 	return err
 }
 
 // FollowNewsletter makes the user follow (join) a WhatsApp channel.
-func (cli *Client) FollowNewsletter(jid types.JID) error {
-	_, err := cli.sendMexIQ(context.TODO(), mutationFollowNewsletter, map[string]any{
+func (cli *Client) FollowNewsletter(ctx context.Context, jid types.JID) error {
+	_, err := cli.sendMexIQ(ctx, mutationFollowNewsletter, map[string]any{
 		"newsletter_id": jid.String(),
 	})
 	return err
 }
 
 // UnfollowNewsletter makes the user unfollow (leave) a WhatsApp channel.
-func (cli *Client) UnfollowNewsletter(jid types.JID) error {
-	_, err := cli.sendMexIQ(context.TODO(), mutationUnfollowNewsletter, map[string]any{
+func (cli *Client) UnfollowNewsletter(ctx context.Context, jid types.JID) error {
+	_, err := cli.sendMexIQ(ctx, mutationUnfollowNewsletter, map[string]any{
 		"newsletter_id": jid.String(),
 	})
 	return err
@@ -376,7 +381,7 @@ type GetNewsletterMessagesParams struct {
 }
 
 // GetNewsletterMessages gets messages in a WhatsApp channel.
-func (cli *Client) GetNewsletterMessages(jid types.JID, params *GetNewsletterMessagesParams) ([]*types.NewsletterMessage, error) {
+func (cli *Client) GetNewsletterMessages(ctx context.Context, jid types.JID, params *GetNewsletterMessagesParams) ([]*types.NewsletterMessage, error) {
 	attrs := waBinary.Attrs{
 		"type": "jid",
 		"jid":  jid,
@@ -389,7 +394,7 @@ func (cli *Client) GetNewsletterMessages(jid types.JID, params *GetNewsletterMes
 			attrs["before"] = params.Before
 		}
 	}
-	resp, err := cli.sendIQ(infoQuery{
+	resp, err := cli.sendIQ(ctx, infoQuery{
 		Namespace: "newsletter",
 		Type:      iqGet,
 		To:        types.ServerJID,
@@ -397,7 +402,6 @@ func (cli *Client) GetNewsletterMessages(jid types.JID, params *GetNewsletterMes
 			Tag:   "messages",
 			Attrs: attrs,
 		}},
-		Context: context.TODO(),
 	})
 	if err != nil {
 		return nil, err
@@ -418,7 +422,7 @@ type GetNewsletterUpdatesParams struct {
 // GetNewsletterMessageUpdates gets updates in a WhatsApp channel.
 //
 // These are the same kind of updates that NewsletterSubscribeLiveUpdates triggers (reaction and view counts).
-func (cli *Client) GetNewsletterMessageUpdates(jid types.JID, params *GetNewsletterUpdatesParams) ([]*types.NewsletterMessage, error) {
+func (cli *Client) GetNewsletterMessageUpdates(ctx context.Context, jid types.JID, params *GetNewsletterUpdatesParams) ([]*types.NewsletterMessage, error) {
 	attrs := waBinary.Attrs{}
 	if params != nil {
 		if params.Count != 0 {
@@ -431,7 +435,7 @@ func (cli *Client) GetNewsletterMessageUpdates(jid types.JID, params *GetNewslet
 			attrs["after"] = params.After
 		}
 	}
-	resp, err := cli.sendIQ(infoQuery{
+	resp, err := cli.sendIQ(ctx, infoQuery{
 		Namespace: "newsletter",
 		Type:      iqGet,
 		To:        jid,
@@ -439,7 +443,6 @@ func (cli *Client) GetNewsletterMessageUpdates(jid types.JID, params *GetNewslet
 			Tag:   "message_updates",
 			Attrs: attrs,
 		}},
-		Context: context.TODO(),
 	})
 	if err != nil {
 		return nil, err

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

@@ -34,7 +34,7 @@ func (cli *Client) handleEncryptNotification(ctx context.Context, node *waBinary
 		}
 		cli.Log.Infof("Got prekey count from server: %s", node.XMLString())
 		if otksLeft < MinPreKeyCount {
-			cli.uploadPreKeys(ctx)
+			cli.uploadPreKeys(ctx, false)
 		}
 	} 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())
@@ -409,8 +409,7 @@ func (cli *Client) handleStatusNotification(ctx context.Context, node *waBinary.
 	})
 }
 
-func (cli *Client) handleNotification(node *waBinary.Node) {
-	ctx := cli.BackgroundEventCtx
+func (cli *Client) handleNotification(ctx context.Context, node *waBinary.Node) {
 	ag := node.AttrGetter()
 	notifType := ag.String("type")
 	if !ag.OK() {

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

@@ -99,11 +99,10 @@ func (cli *Client) PairPhone(ctx context.Context, phone string, showPushNotifica
 		return "", ErrPhoneNumberIsNotInternational
 	}
 	jid := types.NewJID(phone, types.DefaultUserServer)
-	resp, err := cli.sendIQ(infoQuery{
+	resp, err := cli.sendIQ(ctx, infoQuery{
 		Namespace: "md",
 		Type:      iqSet,
 		To:        types.ServerJID,
-		Context:   ctx,
 		Content: []waBinary.Node{{
 			Tag: "link_code_companion_reg",
 			Attrs: waBinary.Attrs{
@@ -223,11 +222,10 @@ func (cli *Client) handleCodePairNotification(ctx context.Context, parentNode *w
 	advSecret := hkdfutil.SHA256(advSecretInput, nil, []byte("adv_secret"), 32)
 	cli.Store.AdvSecretKey = advSecret
 
-	_, err = cli.sendIQ(infoQuery{
+	_, err = cli.sendIQ(ctx, infoQuery{
 		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

@@ -33,22 +33,22 @@ var (
 	AdvHostedDeviceSignaturePrefix  = []byte{6, 6}
 )
 
-func (cli *Client) handleIQ(node *waBinary.Node) {
+func (cli *Client) handleIQ(ctx context.Context, node *waBinary.Node) {
 	children := node.GetChildren()
 	if len(children) != 1 || node.Attrs["from"] != types.ServerJID {
 		return
 	}
 	switch children[0].Tag {
 	case "pair-device":
-		cli.handlePairDevice(node)
+		cli.handlePairDevice(ctx, node)
 	case "pair-success":
-		cli.handlePairSuccess(node)
+		cli.handlePairSuccess(ctx, node)
 	}
 }
 
-func (cli *Client) handlePairDevice(node *waBinary.Node) {
+func (cli *Client) handlePairDevice(ctx context.Context, node *waBinary.Node) {
 	pairDevice := node.GetChildByTag("pair-device")
-	err := cli.sendNode(waBinary.Node{
+	err := cli.sendNode(ctx, waBinary.Node{
 		Tag: "iq",
 		Attrs: waBinary.Attrs{
 			"to":   node.Attrs["from"],
@@ -84,7 +84,7 @@ func (cli *Client) makeQRData(ref string) string {
 	return strings.Join([]string{ref, noise, identity, adv}, ",")
 }
 
-func (cli *Client) handlePairSuccess(node *waBinary.Node) {
+func (cli *Client) handlePairSuccess(ctx context.Context, node *waBinary.Node) {
 	id := node.Attrs["id"].(string)
 	pairSuccess := node.GetChildByTag("pair-success")
 
@@ -95,7 +95,7 @@ func (cli *Client) handlePairSuccess(node *waBinary.Node) {
 	platform, _ := pairSuccess.GetChildByTag("platform").Attrs["name"].(string)
 
 	go func() {
-		err := cli.handlePair(context.TODO(), deviceIdentityBytes, id, businessName, platform, jid, lid)
+		err := cli.handlePair(ctx, deviceIdentityBytes, id, businessName, platform, jid, lid)
 		if err != nil {
 			cli.Log.Errorf("Failed to pair device: %v", err)
 			cli.Disconnect()
@@ -111,7 +111,7 @@ func (cli *Client) handlePair(ctx context.Context, deviceIdentityBytes []byte, r
 	var deviceIdentityContainer waAdv.ADVSignedDeviceIdentityHMAC
 	err := proto.Unmarshal(deviceIdentityBytes, &deviceIdentityContainer)
 	if err != nil {
-		cli.sendPairError(reqID, 500, "internal-error")
+		cli.sendPairError(ctx, reqID, 500, "internal-error")
 		return &PairProtoError{"failed to parse device identity container in pair success message", err}
 	}
 
@@ -124,33 +124,33 @@ func (cli *Client) handlePair(ctx context.Context, deviceIdentityBytes []byte, r
 
 	if !bytes.Equal(h.Sum(nil), deviceIdentityContainer.HMAC) {
 		cli.Log.Warnf("Invalid HMAC from pair success message")
-		cli.sendPairError(reqID, 401, "hmac-mismatch")
+		cli.sendPairError(ctx, reqID, 401, "hmac-mismatch")
 		return ErrPairInvalidDeviceIdentityHMAC
 	}
 
 	var deviceIdentity waAdv.ADVSignedDeviceIdentity
 	err = proto.Unmarshal(deviceIdentityContainer.Details, &deviceIdentity)
 	if err != nil {
-		cli.sendPairError(reqID, 500, "internal-error")
+		cli.sendPairError(ctx, reqID, 500, "internal-error")
 		return &PairProtoError{"failed to parse signed device identity in pair success message", err}
 	}
 
 	var deviceIdentityDetails waAdv.ADVDeviceIdentity
 	err = proto.Unmarshal(deviceIdentity.Details, &deviceIdentityDetails)
 	if err != nil {
-		cli.sendPairError(reqID, 500, "internal-error")
+		cli.sendPairError(ctx, reqID, 500, "internal-error")
 		return &PairProtoError{"failed to parse device identity details in pair success message", err}
 	}
 
 	if !verifyAccountSignature(&deviceIdentity, cli.Store.IdentityKey, deviceIdentityDetails.GetDeviceType() == waAdv.ADVEncryptionType_HOSTED) {
-		cli.sendPairError(reqID, 401, "signature-mismatch")
+		cli.sendPairError(ctx, reqID, 401, "signature-mismatch")
 		return ErrPairInvalidDeviceSignature
 	}
 
 	deviceIdentity.DeviceSignature = generateDeviceSignature(&deviceIdentity, cli.Store.IdentityKey)[:]
 
 	if cli.PrePairCallback != nil && !cli.PrePairCallback(jid, platform, businessName) {
-		cli.sendPairError(reqID, 500, "internal-error")
+		cli.sendPairError(ctx, reqID, 500, "internal-error")
 		return ErrPairRejectedLocally
 	}
 
@@ -163,7 +163,7 @@ func (cli *Client) handlePair(ctx context.Context, deviceIdentityBytes []byte, r
 
 	selfSignedDeviceIdentity, err := proto.Marshal(&deviceIdentity)
 	if err != nil {
-		cli.sendPairError(reqID, 500, "internal-error")
+		cli.sendPairError(ctx, reqID, 500, "internal-error")
 		return &PairProtoError{"failed to marshal self-signed device identity", err}
 	}
 
@@ -173,21 +173,21 @@ func (cli *Client) handlePair(ctx context.Context, deviceIdentityBytes []byte, r
 	cli.Store.Platform = platform
 	err = cli.Store.Save(ctx)
 	if err != nil {
-		cli.sendPairError(reqID, 500, "internal-error")
+		cli.sendPairError(ctx, reqID, 500, "internal-error")
 		return &PairDatabaseError{"failed to save device store", err}
 	}
 	cli.StoreLIDPNMapping(ctx, lid, jid)
 	err = cli.Store.Identities.PutIdentity(ctx, mainDeviceLID.SignalAddress().String(), mainDeviceIdentity)
 	if err != nil {
 		_ = cli.Store.Delete(ctx)
-		cli.sendPairError(reqID, 500, "internal-error")
+		cli.sendPairError(ctx, reqID, 500, "internal-error")
 		return &PairDatabaseError{"failed to store main device identity", err}
 	}
 
 	// Expect a disconnect after this and don't dispatch the usual Disconnected event
 	cli.expectDisconnect()
 
-	err = cli.sendNode(waBinary.Node{
+	err = cli.sendNode(ctx, waBinary.Node{
 		Tag: "iq",
 		Attrs: waBinary.Attrs{
 			"to":   types.ServerJID,
@@ -249,8 +249,8 @@ func generateDeviceSignature(deviceIdentity *waAdv.ADVSignedDeviceIdentity, ikp
 	return &sig
 }
 
-func (cli *Client) sendPairError(id string, code int, text string) {
-	err := cli.sendNode(waBinary.Node{
+func (cli *Client) sendPairError(ctx context.Context, id string, code int, text string) {
+	err := cli.sendNode(ctx, waBinary.Node{
 		Tag: "iq",
 		Attrs: waBinary.Attrs{
 			"to":   types.ServerJID,