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/util/ptr/ptr.go

@@ -0,0 +1,43 @@
+// Copyright (c) 2024 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 ptr
+
+// Clone creates a shallow copy of the given pointer.
+func Clone[T any](val *T) *T {
+	if val == nil {
+		return nil
+	}
+	valCopy := *val
+	return &valCopy
+}
+
+// Ptr returns a pointer to the given value.
+func Ptr[T any](val T) *T {
+	return &val
+}
+
+// NonZero returns a pointer to the given comparable value, unless the value is the type's zero value.
+func NonZero[T comparable](val T) *T {
+	var zero T
+	return NonDefault(val, zero)
+}
+
+// NonDefault returns a pointer to the first parameter, unless it is equal to the second parameter.
+func NonDefault[T comparable](val, def T) *T {
+	if val == def {
+		return nil
+	}
+	return &val
+}
+
+// Val returns the value of the given pointer, or the zero value of the type if the pointer is nil.
+func Val[T any](ptr *T) (val T) {
+	if ptr != nil {
+		val = *ptr
+	}
+	return
+}

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/appstate/decode.go

@@ -8,6 +8,7 @@ package appstate
 
 import (
 	"bytes"
+	"context"
 	"crypto/sha256"
 	"encoding/json"
 	"fmt"
@@ -30,9 +31,9 @@ type PatchList struct {
 }
 
 // DownloadExternalFunc is a function that can download a blob of external app state patches.
-type DownloadExternalFunc func(*waServerSync.ExternalBlobReference) ([]byte, error)
+type DownloadExternalFunc func(context.Context, *waServerSync.ExternalBlobReference) ([]byte, error)
 
-func parseSnapshotInternal(collection *waBinary.Node, downloadExternal DownloadExternalFunc) (*waServerSync.SyncdSnapshot, error) {
+func parseSnapshotInternal(ctx context.Context, collection *waBinary.Node, downloadExternal DownloadExternalFunc) (*waServerSync.SyncdSnapshot, error) {
 	snapshotNode := collection.GetChildByTag("snapshot")
 	rawSnapshot, ok := snapshotNode.Content.([]byte)
 	if snapshotNode.Tag != "snapshot" || !ok {
@@ -44,7 +45,7 @@ func parseSnapshotInternal(collection *waBinary.Node, downloadExternal DownloadE
 		return nil, fmt.Errorf("failed to unmarshal snapshot: %w", err)
 	}
 	var rawData []byte
-	rawData, err = downloadExternal(&snapshot)
+	rawData, err = downloadExternal(ctx, &snapshot)
 	if err != nil {
 		return nil, fmt.Errorf("failed to download external mutations: %w", err)
 	}
@@ -56,7 +57,7 @@ func parseSnapshotInternal(collection *waBinary.Node, downloadExternal DownloadE
 	return &downloaded, nil
 }
 
-func parsePatchListInternal(collection *waBinary.Node, downloadExternal DownloadExternalFunc) ([]*waServerSync.SyncdPatch, error) {
+func parsePatchListInternal(ctx context.Context, collection *waBinary.Node, downloadExternal DownloadExternalFunc) ([]*waServerSync.SyncdPatch, error) {
 	patchesNode := collection.GetChildByTag("patches")
 	patchNodes := patchesNode.GetChildren()
 	patches := make([]*waServerSync.SyncdPatch, 0, len(patchNodes))
@@ -72,7 +73,7 @@ func parsePatchListInternal(collection *waBinary.Node, downloadExternal Download
 		}
 		if patch.GetExternalMutations() != nil && downloadExternal != nil {
 			var rawData []byte
-			rawData, err = downloadExternal(patch.GetExternalMutations())
+			rawData, err = downloadExternal(ctx, patch.GetExternalMutations())
 			if err != nil {
 				return nil, fmt.Errorf("failed to download external mutations: %w", err)
 			}
@@ -91,14 +92,14 @@ func parsePatchListInternal(collection *waBinary.Node, downloadExternal Download
 }
 
 // ParsePatchList will decode an XML node containing app state patches, including downloading any external blobs.
-func ParsePatchList(node *waBinary.Node, downloadExternal DownloadExternalFunc) (*PatchList, error) {
+func ParsePatchList(ctx context.Context, node *waBinary.Node, downloadExternal DownloadExternalFunc) (*PatchList, error) {
 	collection := node.GetChildByTag("sync", "collection")
 	ag := collection.AttrGetter()
-	snapshot, err := parseSnapshotInternal(&collection, downloadExternal)
+	snapshot, err := parseSnapshotInternal(ctx, &collection, downloadExternal)
 	if err != nil {
 		return nil, err
 	}
-	patches, err := parsePatchListInternal(&collection, downloadExternal)
+	patches, err := parsePatchListInternal(ctx, &collection, downloadExternal)
 	if err != nil {
 		return nil, err
 	}
@@ -117,10 +118,10 @@ type patchOutput struct {
 	Mutations   []Mutation
 }
 
-func (proc *Processor) decodeMutations(mutations []*waServerSync.SyncdMutation, out *patchOutput, validateMACs bool) error {
+func (proc *Processor) decodeMutations(ctx context.Context, mutations []*waServerSync.SyncdMutation, out *patchOutput, validateMACs bool) error {
 	for i, mutation := range mutations {
 		keyID := mutation.GetRecord().GetKeyID().GetID()
-		keys, err := proc.getAppStateKey(keyID)
+		keys, err := proc.getAppStateKey(ctx, keyID)
 		if err != nil {
 			return fmt.Errorf("failed to get key %X to decode mutation: %w", keyID, err)
 		}
@@ -173,23 +174,23 @@ func (proc *Processor) decodeMutations(mutations []*waServerSync.SyncdMutation,
 	return nil
 }
 
-func (proc *Processor) storeMACs(name WAPatchName, currentState HashState, out *patchOutput) {
-	err := proc.Store.AppState.PutAppStateVersion(string(name), currentState.Version, currentState.Hash)
+func (proc *Processor) storeMACs(ctx context.Context, name WAPatchName, currentState HashState, out *patchOutput) {
+	err := proc.Store.AppState.PutAppStateVersion(ctx, string(name), currentState.Version, currentState.Hash)
 	if err != nil {
 		proc.Log.Errorf("Failed to update app state version in the database: %v", err)
 	}
-	err = proc.Store.AppState.DeleteAppStateMutationMACs(string(name), out.RemovedMACs)
+	err = proc.Store.AppState.DeleteAppStateMutationMACs(ctx, string(name), out.RemovedMACs)
 	if err != nil {
 		proc.Log.Errorf("Failed to remove deleted mutation MACs from the database: %v", err)
 	}
-	err = proc.Store.AppState.PutAppStateMutationMACs(string(name), currentState.Version, out.AddedMACs)
+	err = proc.Store.AppState.PutAppStateMutationMACs(ctx, string(name), currentState.Version, out.AddedMACs)
 	if err != nil {
 		proc.Log.Errorf("Failed to insert added mutation MACs to the database: %v", err)
 	}
 }
 
-func (proc *Processor) validateSnapshotMAC(name WAPatchName, currentState HashState, keyID, expectedSnapshotMAC []byte) (keys ExpandedAppStateKeys, err error) {
-	keys, err = proc.getAppStateKey(keyID)
+func (proc *Processor) validateSnapshotMAC(ctx context.Context, name WAPatchName, currentState HashState, keyID, expectedSnapshotMAC []byte) (keys ExpandedAppStateKeys, err error) {
+	keys, err = proc.getAppStateKey(ctx, keyID)
 	if err != nil {
 		err = fmt.Errorf("failed to get key %X to verify patch v%d MACs: %w", keyID, currentState.Version, err)
 		return
@@ -201,7 +202,7 @@ func (proc *Processor) validateSnapshotMAC(name WAPatchName, currentState HashSt
 	return
 }
 
-func (proc *Processor) decodeSnapshot(name WAPatchName, ss *waServerSync.SyncdSnapshot, initialState HashState, validateMACs bool, newMutationsInput []Mutation) (newMutations []Mutation, currentState HashState, err error) {
+func (proc *Processor) decodeSnapshot(ctx context.Context, name WAPatchName, ss *waServerSync.SyncdSnapshot, initialState HashState, validateMACs bool, newMutationsInput []Mutation) (newMutations []Mutation, currentState HashState, err error) {
 	currentState = initialState
 	currentState.Version = ss.GetVersion().GetVersion()
 
@@ -226,7 +227,7 @@ func (proc *Processor) decodeSnapshot(name WAPatchName, ss *waServerSync.SyncdSn
 	}
 
 	if validateMACs {
-		_, err = proc.validateSnapshotMAC(name, currentState, ss.GetKeyID().GetID(), ss.GetMac())
+		_, err = proc.validateSnapshotMAC(ctx, name, currentState, ss.GetKeyID().GetID(), ss.GetMac())
 		if err != nil {
 			return
 		}
@@ -234,18 +235,18 @@ func (proc *Processor) decodeSnapshot(name WAPatchName, ss *waServerSync.SyncdSn
 
 	var out patchOutput
 	out.Mutations = newMutationsInput
-	err = proc.decodeMutations(encryptedMutations, &out, validateMACs)
+	err = proc.decodeMutations(ctx, encryptedMutations, &out, validateMACs)
 	if err != nil {
 		err = fmt.Errorf("failed to decode snapshot of v%d: %w", currentState.Version, err)
 		return
 	}
-	proc.storeMACs(name, currentState, &out)
+	proc.storeMACs(ctx, name, currentState, &out)
 	newMutations = out.Mutations
 	return
 }
 
 // DecodePatches will decode all the patches in a PatchList into a list of app state mutations.
-func (proc *Processor) DecodePatches(list *PatchList, initialState HashState, validateMACs bool) (newMutations []Mutation, currentState HashState, err error) {
+func (proc *Processor) DecodePatches(ctx context.Context, list *PatchList, initialState HashState, validateMACs bool) (newMutations []Mutation, currentState HashState, err error) {
 	currentState = initialState
 	var expectedLength int
 	if list.Snapshot != nil {
@@ -257,7 +258,7 @@ func (proc *Processor) DecodePatches(list *PatchList, initialState HashState, va
 	newMutations = make([]Mutation, 0, expectedLength)
 
 	if list.Snapshot != nil {
-		newMutations, currentState, err = proc.decodeSnapshot(list.Name, list.Snapshot, currentState, validateMACs, newMutations)
+		newMutations, currentState, err = proc.decodeSnapshot(ctx, list.Name, list.Snapshot, currentState, validateMACs, newMutations)
 		if err != nil {
 			return
 		}
@@ -275,7 +276,7 @@ func (proc *Processor) DecodePatches(list *PatchList, initialState HashState, va
 				}
 			}
 			// Previous value not found in current patch, look in the database
-			return proc.Store.AppState.GetAppStateMutationMAC(string(list.Name), indexMAC)
+			return proc.Store.AppState.GetAppStateMutationMAC(ctx, string(list.Name), indexMAC)
 		})
 		if len(warn) > 0 {
 			proc.Log.Warnf("Warnings while updating hash for %s: %+v", list.Name, warn)
@@ -287,7 +288,7 @@ func (proc *Processor) DecodePatches(list *PatchList, initialState HashState, va
 
 		if validateMACs {
 			var keys ExpandedAppStateKeys
-			keys, err = proc.validateSnapshotMAC(list.Name, currentState, patch.GetKeyID().GetID(), patch.GetSnapshotMac())
+			keys, err = proc.validateSnapshotMAC(ctx, list.Name, currentState, patch.GetKeyID().GetID(), patch.GetSnapshotMac())
 			if err != nil {
 				return
 			}
@@ -300,11 +301,11 @@ func (proc *Processor) DecodePatches(list *PatchList, initialState HashState, va
 
 		var out patchOutput
 		out.Mutations = newMutations
-		err = proc.decodeMutations(patch.GetMutations(), &out, validateMACs)
+		err = proc.decodeMutations(ctx, patch.GetMutations(), &out, validateMACs)
 		if err != nil {
 			return
 		}
-		proc.storeMACs(list.Name, currentState, &out)
+		proc.storeMACs(ctx, list.Name, currentState, &out)
 		newMutations = out.Mutations
 	}
 	return

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/appstate/encode.go

@@ -1,6 +1,7 @@
 package appstate
 
 import (
+	"context"
 	"crypto/sha256"
 	"encoding/json"
 	"fmt"
@@ -245,8 +246,8 @@ func BuildStar(target, sender types.JID, messageID types.MessageID, fromMe, star
 	}
 }
 
-func (proc *Processor) EncodePatch(keyID []byte, state HashState, patchInfo PatchInfo) ([]byte, error) {
-	keys, err := proc.getAppStateKey(keyID)
+func (proc *Processor) EncodePatch(ctx context.Context, keyID []byte, state HashState, patchInfo PatchInfo) ([]byte, error) {
+	keys, err := proc.getAppStateKey(ctx, keyID)
 	if err != nil {
 		return nil, fmt.Errorf("failed to get app state key details with key ID %x: %w", keyID, err)
 	}
@@ -295,7 +296,7 @@ func (proc *Processor) EncodePatch(keyID []byte, state HashState, patchInfo Patc
 	}
 
 	warn, err := state.updateHash(mutations, func(indexMAC []byte, _ int) ([]byte, error) {
-		return proc.Store.AppState.GetAppStateMutationMAC(string(patchInfo.Type), indexMAC)
+		return proc.Store.AppState.GetAppStateMutationMAC(ctx, string(patchInfo.Type), indexMAC)
 	})
 	if len(warn) > 0 {
 		proc.Log.Warnf("Warnings while updating hash for %s (sending new app state): %+v", patchInfo.Type, warn)

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/appstate/keys.go

@@ -8,6 +8,7 @@
 package appstate
 
 import (
+	"context"
 	"encoding/base64"
 	"sync"
 
@@ -82,7 +83,7 @@ func expandAppStateKeys(keyData []byte) (keys ExpandedAppStateKeys) {
 	return ExpandedAppStateKeys{appStateKeyExpanded[0:32], appStateKeyExpanded[32:64], appStateKeyExpanded[64:96], appStateKeyExpanded[96:128], appStateKeyExpanded[128:160]}
 }
 
-func (proc *Processor) getAppStateKey(keyID []byte) (keys ExpandedAppStateKeys, err error) {
+func (proc *Processor) getAppStateKey(ctx context.Context, keyID []byte) (keys ExpandedAppStateKeys, err error) {
 	keyCacheID := base64.RawStdEncoding.EncodeToString(keyID)
 	var ok bool
 
@@ -92,7 +93,7 @@ func (proc *Processor) getAppStateKey(keyID []byte) (keys ExpandedAppStateKeys,
 	keys, ok = proc.keyCache[keyCacheID]
 	if !ok {
 		var keyData *store.AppStateSyncKey
-		keyData, err = proc.Store.AppStateKeys.GetAppStateSyncKey(keyID)
+		keyData, err = proc.Store.AppStateKeys.GetAppStateSyncKey(ctx, keyID)
 		if keyData != nil {
 			keys = expandAppStateKeys(keyData.Data)
 			proc.keyCache[keyCacheID] = keys
@@ -103,7 +104,7 @@ func (proc *Processor) getAppStateKey(keyID []byte) (keys ExpandedAppStateKeys,
 	return
 }
 
-func (proc *Processor) GetMissingKeyIDs(pl *PatchList) [][]byte {
+func (proc *Processor) GetMissingKeyIDs(ctx context.Context, pl *PatchList) [][]byte {
 	cache := make(map[string]bool)
 	var missingKeys [][]byte
 	checkMissing := func(keyID []byte) {
@@ -113,7 +114,7 @@ func (proc *Processor) GetMissingKeyIDs(pl *PatchList) [][]byte {
 		stringKeyID := base64.RawStdEncoding.EncodeToString(keyID)
 		_, alreadyAdded := cache[stringKeyID]
 		if !alreadyAdded {
-			keyData, err := proc.Store.AppStateKeys.GetAppStateSyncKey(keyID)
+			keyData, err := proc.Store.AppStateKeys.GetAppStateSyncKey(ctx, keyID)
 			if err != nil {
 				proc.Log.Warnf("Error fetching key %X while checking if it's missing: %v", keyID, err)
 			}

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

@@ -24,19 +24,19 @@ import (
 
 // FetchAppState fetches updates to the given type of app state. If fullSync is true, the current
 // cached state will be removed and all app state patches will be re-fetched from the server.
-func (cli *Client) FetchAppState(name appstate.WAPatchName, fullSync, onlyIfNotSynced bool) error {
+func (cli *Client) FetchAppState(ctx context.Context, name appstate.WAPatchName, fullSync, onlyIfNotSynced bool) error {
 	if cli == nil {
 		return ErrClientIsNil
 	}
 	cli.appStateSyncLock.Lock()
 	defer cli.appStateSyncLock.Unlock()
 	if fullSync {
-		err := cli.Store.AppState.DeleteAppStateVersion(string(name))
+		err := cli.Store.AppState.DeleteAppStateVersion(ctx, string(name))
 		if err != nil {
 			return fmt.Errorf("failed to reset app state %s version: %w", name, err)
 		}
 	}
-	version, hash, err := cli.Store.AppState.GetAppStateVersion(string(name))
+	version, hash, err := cli.Store.AppState.GetAppStateVersion(ctx, string(name))
 	if err != nil {
 		return fmt.Errorf("failed to get app state %s version: %w", name, err)
 	}
@@ -51,17 +51,17 @@ func (cli *Client) FetchAppState(name appstate.WAPatchName, fullSync, onlyIfNotS
 	hasMore := true
 	wantSnapshot := fullSync
 	for hasMore {
-		patches, err := cli.fetchAppStatePatches(name, state.Version, wantSnapshot)
+		patches, err := cli.fetchAppStatePatches(ctx, name, state.Version, wantSnapshot)
 		wantSnapshot = false
 		if err != nil {
 			return fmt.Errorf("failed to fetch app state %s patches: %w", name, err)
 		}
 		hasMore = patches.HasMorePatches
 
-		mutations, newState, err := cli.appStateProc.DecodePatches(patches, state, true)
+		mutations, newState, err := cli.appStateProc.DecodePatches(ctx, patches, state, true)
 		if err != nil {
 			if errors.Is(err, appstate.ErrKeyNotFound) {
-				go cli.requestMissingAppStateKeys(context.TODO(), patches)
+				go cli.requestMissingAppStateKeys(context.WithoutCancel(ctx), patches)
 			}
 			return fmt.Errorf("failed to decode app state %s patches: %w", name, err)
 		}
@@ -71,14 +71,14 @@ func (cli *Client) FetchAppState(name appstate.WAPatchName, fullSync, onlyIfNotS
 			var contacts []store.ContactEntry
 			mutations, contacts = cli.filterContacts(mutations)
 			cli.Log.Debugf("Mass inserting app state snapshot with %d contacts into the store", len(contacts))
-			err = cli.Store.Contacts.PutAllContactNames(contacts)
+			err = cli.Store.Contacts.PutAllContactNames(ctx, contacts)
 			if err != nil {
 				// This is a fairly serious failure, so just abort the whole thing
 				return fmt.Errorf("failed to update contact store with data from snapshot: %v", err)
 			}
 		}
 		for _, mutation := range mutations {
-			cli.dispatchAppState(mutation, fullSync, cli.EmitAppStateEventsOnFullSync)
+			cli.dispatchAppState(ctx, mutation, fullSync, cli.EmitAppStateEventsOnFullSync)
 		}
 	}
 	if fullSync {
@@ -109,7 +109,7 @@ func (cli *Client) filterContacts(mutations []appstate.Mutation) ([]appstate.Mut
 	return filteredMutations, contacts
 }
 
-func (cli *Client) dispatchAppState(mutation appstate.Mutation, fullSync bool, emitOnFullSync bool) {
+func (cli *Client) dispatchAppState(ctx context.Context, mutation appstate.Mutation, fullSync bool, emitOnFullSync bool) {
 	dispatchEvts := !fullSync || emitOnFullSync
 
 	if mutation.Operation != waServerSync.SyncdMutation_SET {
@@ -137,25 +137,25 @@ func (cli *Client) dispatchAppState(mutation appstate.Mutation, fullSync bool, e
 			mutedUntil = time.UnixMilli(act.GetMuteEndTimestamp())
 		}
 		if cli.Store.ChatSettings != nil {
-			storeUpdateError = cli.Store.ChatSettings.PutMutedUntil(jid, mutedUntil)
+			storeUpdateError = cli.Store.ChatSettings.PutMutedUntil(ctx, jid, mutedUntil)
 		}
 	case appstate.IndexPin:
 		act := mutation.Action.GetPinAction()
 		eventToDispatch = &events.Pin{JID: jid, Timestamp: ts, Action: act, FromFullSync: fullSync}
 		if cli.Store.ChatSettings != nil {
-			storeUpdateError = cli.Store.ChatSettings.PutPinned(jid, act.GetPinned())
+			storeUpdateError = cli.Store.ChatSettings.PutPinned(ctx, jid, act.GetPinned())
 		}
 	case appstate.IndexArchive:
 		act := mutation.Action.GetArchiveChatAction()
 		eventToDispatch = &events.Archive{JID: jid, Timestamp: ts, Action: act, FromFullSync: fullSync}
 		if cli.Store.ChatSettings != nil {
-			storeUpdateError = cli.Store.ChatSettings.PutArchived(jid, act.GetArchived())
+			storeUpdateError = cli.Store.ChatSettings.PutArchived(ctx, jid, act.GetArchived())
 		}
 	case appstate.IndexContact:
 		act := mutation.Action.GetContactAction()
 		eventToDispatch = &events.Contact{JID: jid, Timestamp: ts, Action: act, FromFullSync: fullSync}
 		if cli.Store.Contacts != nil {
-			storeUpdateError = cli.Store.Contacts.PutContactName(jid, act.GetFirstName(), act.GetFullName())
+			storeUpdateError = cli.Store.Contacts.PutContactName(ctx, jid, act.GetFirstName(), act.GetFullName())
 		}
 	case appstate.IndexClearChat:
 		act := mutation.Action.GetClearChatAction()
@@ -209,7 +209,7 @@ func (cli *Client) dispatchAppState(mutation appstate.Mutation, fullSync bool, e
 			FromFullSync: fullSync,
 		}
 		cli.Store.PushName = mutation.Action.GetPushNameSetting().GetName()
-		err := cli.Store.Save()
+		err := cli.Store.Save(ctx)
 		if err != nil {
 			cli.Log.Errorf("Failed to save device store after updating push name: %v", err)
 		}
@@ -270,11 +270,11 @@ func (cli *Client) dispatchAppState(mutation appstate.Mutation, fullSync bool, e
 	}
 }
 
-func (cli *Client) downloadExternalAppStateBlob(ref *waServerSync.ExternalBlobReference) ([]byte, error) {
-	return cli.Download(ref)
+func (cli *Client) downloadExternalAppStateBlob(ctx context.Context, ref *waServerSync.ExternalBlobReference) ([]byte, error) {
+	return cli.Download(ctx, ref)
 }
 
-func (cli *Client) fetchAppStatePatches(name appstate.WAPatchName, fromVersion uint64, snapshot bool) (*appstate.PatchList, error) {
+func (cli *Client) fetchAppStatePatches(ctx context.Context, name appstate.WAPatchName, fromVersion uint64, snapshot bool) (*appstate.PatchList, error) {
 	attrs := waBinary.Attrs{
 		"name":            string(name),
 		"return_snapshot": snapshot,
@@ -283,6 +283,7 @@ func (cli *Client) fetchAppStatePatches(name appstate.WAPatchName, fromVersion u
 		attrs["version"] = fromVersion
 	}
 	resp, err := cli.sendIQ(infoQuery{
+		Context:   ctx,
 		Namespace: "w:sync:app:state",
 		Type:      "set",
 		To:        types.ServerJID,
@@ -297,12 +298,12 @@ func (cli *Client) fetchAppStatePatches(name appstate.WAPatchName, fromVersion u
 	if err != nil {
 		return nil, err
 	}
-	return appstate.ParsePatchList(resp, cli.downloadExternalAppStateBlob)
+	return appstate.ParsePatchList(ctx, resp, cli.downloadExternalAppStateBlob)
 }
 
 func (cli *Client) requestMissingAppStateKeys(ctx context.Context, patches *appstate.PatchList) {
 	cli.appStateKeyRequestsLock.Lock()
-	rawKeyIDs := cli.appStateProc.GetMissingKeyIDs(patches)
+	rawKeyIDs := cli.appStateProc.GetMissingKeyIDs(ctx, patches)
 	filteredKeyIDs := make([][]byte, 0, len(rawKeyIDs))
 	now := time.Now()
 	for _, keyID := range rawKeyIDs {
@@ -348,17 +349,17 @@ func (cli *Client) requestAppStateKeys(ctx context.Context, rawKeyIDs [][]byte)
 //
 // You can use the Build methods in the appstate package to build the parameter for this method, e.g.
 //
-//	cli.SendAppState(appstate.BuildMute(targetJID, true, 24 * time.Hour))
-func (cli *Client) SendAppState(patch appstate.PatchInfo) error {
+//	cli.SendAppState(ctx, appstate.BuildMute(targetJID, true, 24 * time.Hour))
+func (cli *Client) SendAppState(ctx context.Context, patch appstate.PatchInfo) error {
 	if cli == nil {
 		return ErrClientIsNil
 	}
-	version, hash, err := cli.Store.AppState.GetAppStateVersion(string(patch.Type))
+	version, hash, err := cli.Store.AppState.GetAppStateVersion(ctx, string(patch.Type))
 	if err != nil {
 		return err
 	}
 	// TODO create new key instead of reusing the primary client's keys
-	latestKeyID, err := cli.Store.AppStateKeys.GetLatestAppStateSyncKeyID()
+	latestKeyID, err := cli.Store.AppStateKeys.GetLatestAppStateSyncKeyID(ctx)
 	if err != nil {
 		return fmt.Errorf("failed to get latest app state key ID: %w", err)
 	} else if latestKeyID == nil {
@@ -367,12 +368,13 @@ func (cli *Client) SendAppState(patch appstate.PatchInfo) error {
 
 	state := appstate.HashState{Version: version, Hash: hash}
 
-	encodedPatch, err := cli.appStateProc.EncodePatch(latestKeyID, state, patch)
+	encodedPatch, err := cli.appStateProc.EncodePatch(ctx, latestKeyID, state, patch)
 	if err != nil {
 		return err
 	}
 
 	resp, err := cli.sendIQ(infoQuery{
+		Context:   ctx,
 		Namespace: "w:sync:app:state",
 		Type:      iqSet,
 		To:        types.ServerJID,
@@ -403,5 +405,5 @@ func (cli *Client) SendAppState(patch appstate.PatchInfo) error {
 		return fmt.Errorf("%w: %s", ErrAppStateUpdate, respCollection.XMLString())
 	}
 
-	return cli.FetchAppState(patch.Type, false, false)
+	return cli.FetchAppState(ctx, patch.Type, false, false)
 }

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

@@ -7,11 +7,14 @@
 package whatsmeow
 
 import (
+	"context"
 	"fmt"
 
 	"google.golang.org/protobuf/proto"
 
 	armadillo "go.mau.fi/whatsmeow/proto"
+	"go.mau.fi/whatsmeow/proto/armadilloutil"
+	"go.mau.fi/whatsmeow/proto/instamadilloTransportPayload"
 	"go.mau.fi/whatsmeow/proto/waCommon"
 	"go.mau.fi/whatsmeow/proto/waMsgApplication"
 	"go.mau.fi/whatsmeow/proto/waMsgTransport"
@@ -19,11 +22,11 @@ import (
 	"go.mau.fi/whatsmeow/types/events"
 )
 
-func (cli *Client) handleDecryptedArmadillo(info *types.MessageInfo, decrypted []byte, retryCount int) bool {
+func (cli *Client) handleDecryptedArmadillo(ctx context.Context, info *types.MessageInfo, decrypted []byte, retryCount int) (handled, handlerFailed bool) {
 	dec, err := decodeArmadillo(decrypted)
 	if err != nil {
 		cli.Log.Warnf("Failed to decode armadillo message from %s: %v", info.SourceString(), err)
-		return false
+		return
 	}
 	dec.Info = *info
 	dec.RetryCount = retryCount
@@ -32,13 +35,14 @@ func (cli *Client) handleDecryptedArmadillo(info *types.MessageInfo, decrypted [
 			cli.Log.Warnf("Got sender key distribution message in non-group chat from %s", info.Sender)
 		} else {
 			skdm := dec.Transport.GetProtocol().GetAncillary().GetSkdm()
-			cli.handleSenderKeyDistributionMessage(info.Chat, info.Sender, skdm.AxolotlSenderKeyDistributionMessage)
+			cli.handleSenderKeyDistributionMessage(ctx, info.Chat, info.Sender, skdm.AxolotlSenderKeyDistributionMessage)
 		}
 	}
 	if dec.Message != nil {
-		cli.dispatchEvent(&dec)
+		handlerFailed = cli.dispatchEvent(&dec)
 	}
-	return true
+	handled = true
+	return
 }
 
 func decodeArmadillo(data []byte) (dec events.FBMessage, err error) {
@@ -51,11 +55,23 @@ func decodeArmadillo(data []byte) (dec events.FBMessage, err error) {
 	if transport.GetPayload() == nil {
 		return
 	}
-	application, err := transport.GetPayload().Decode()
+	appPayloadVer := transport.GetPayload().GetApplicationPayload().GetVersion()
+	switch appPayloadVer {
+	case waMsgTransport.FBMessageApplicationVersion:
+		return decodeFBArmadillo(&transport)
+	case waMsgTransport.IGMessageApplicationVersion:
+		return decodeIGArmadillo(&transport)
+	default:
+		return dec, fmt.Errorf("%w %d in MessageTransport", armadilloutil.ErrUnsupportedVersion, appPayloadVer)
+	}
+}
+
+func decodeFBArmadillo(transport *waMsgTransport.MessageTransport) (dec events.FBMessage, err error) {
+	application, err := transport.GetPayload().DecodeFB()
 	if err != nil {
 		return dec, fmt.Errorf("failed to unmarshal application: %w", err)
 	}
-	dec.Application = application
+	dec.FBApplication = application
 	if application.GetPayload() == nil {
 		return
 	}
@@ -97,3 +113,20 @@ func decodeArmadillo(data []byte) (dec events.FBMessage, err error) {
 	}
 	return
 }
+
+func decodeIGArmadillo(transport *waMsgTransport.MessageTransport) (dec events.FBMessage, err error) {
+	innerTransport, err := transport.GetPayload().DecodeIG()
+	if err != nil {
+		return dec, fmt.Errorf("failed to unmarshal IG transport: %w", err)
+	}
+	dec.IGTransport = innerTransport
+	switch typedContent := innerTransport.GetTransportPayload().(type) {
+	case *instamadilloTransportPayload.TransportPayload_Add:
+		dec.Message = typedContent.Add
+	case *instamadilloTransportPayload.TransportPayload_Supplement:
+		dec.Message = typedContent.Supplement
+	case *instamadilloTransportPayload.TransportPayload_Delete:
+		dec.Message = typedContent.Delete
+	}
+	return
+}

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/binary/encoder.go

@@ -159,7 +159,7 @@ func (w *binaryEncoder) writeStringRaw(value string) {
 }
 
 func (w *binaryEncoder) writeJID(jid types.JID) {
-	if (jid.Server == types.DefaultUserServer && jid.Device > 0) || jid.Server == types.HiddenUserServer || jid.Server == types.HostedServer {
+	if ((jid.Server == types.DefaultUserServer || jid.Server == types.HiddenUserServer) && jid.Device > 0) || jid.Server == types.HostedServer {
 		w.pushByte(token.ADJID)
 		w.pushByte(jid.ActualAgent())
 		w.pushByte(uint8(jid.Device))

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

@@ -7,6 +7,7 @@
 package whatsmeow
 
 import (
+	"context"
 	"errors"
 	"fmt"
 
@@ -14,11 +15,11 @@ import (
 	"go.mau.fi/whatsmeow/types"
 )
 
-func (cli *Client) getBroadcastListParticipants(jid types.JID) ([]types.JID, error) {
+func (cli *Client) getBroadcastListParticipants(ctx context.Context, jid types.JID) ([]types.JID, error) {
 	var list []types.JID
 	var err error
 	if jid == types.StatusBroadcastJID {
-		list, err = cli.getStatusBroadcastRecipients()
+		list, err = cli.getStatusBroadcastRecipients(ctx)
 	} else {
 		return nil, ErrBroadcastListUnsupported
 	}
@@ -43,7 +44,7 @@ func (cli *Client) getBroadcastListParticipants(jid types.JID) ([]types.JID, err
 	return list, nil
 }
 
-func (cli *Client) getStatusBroadcastRecipients() ([]types.JID, error) {
+func (cli *Client) getStatusBroadcastRecipients(ctx context.Context) ([]types.JID, error) {
 	statusPrivacyOptions, err := cli.GetStatusPrivacy()
 	if err != nil {
 		return nil, fmt.Errorf("failed to get status privacy: %w", err)
@@ -55,7 +56,7 @@ func (cli *Client) getStatusBroadcastRecipients() ([]types.JID, error) {
 	}
 
 	// Blacklist or all contacts mode. Find all contacts from database, then filter them appropriately.
-	contacts, err := cli.Store.Contacts.GetAllContacts()
+	contacts, err := cli.Store.Contacts.GetAllContacts(ctx)
 	if err != nil {
 		return nil, fmt.Errorf("failed to get contact list from db: %w", err)
 	}

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

@@ -13,7 +13,7 @@ import (
 )
 
 func (cli *Client) handleCallEvent(node *waBinary.Node) {
-	defer cli.maybeDeferredAck(node)()
+	defer cli.maybeDeferredAck(cli.BackgroundEventCtx, node)()
 
 	if len(node.GetChildren()) != 1 {
 		cli.dispatchEvent(&events.UnknownCallEvent{Node: node})