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

slidge_whatsapp/vendor/go.mau.fi/util/exzerolog/writer.go

@@ -0,0 +1,81 @@
+// Copyright (c) 2023 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 exzerolog
+
+import (
+	"bytes"
+	"sync"
+
+	"github.com/rs/zerolog"
+)
+
+// LogWriter wraps a zerolog.Logger and provides an io.Writer with buffering so each written line is logged separately.
+type LogWriter struct {
+	log   zerolog.Logger
+	level zerolog.Level
+	field string
+	mu    sync.Mutex
+	buf   bytes.Buffer
+}
+
+func NewLogWriter(log zerolog.Logger) *LogWriter {
+	zerolog.Nop()
+	return &LogWriter{
+		log:   log,
+		level: zerolog.DebugLevel,
+		field: zerolog.MessageFieldName,
+	}
+}
+
+func (lw *LogWriter) WithLevel(level zerolog.Level) *LogWriter {
+	return &LogWriter{
+		log:   lw.log,
+		level: level,
+		field: lw.field,
+	}
+}
+
+func (lw *LogWriter) WithField(field string) *LogWriter {
+	return &LogWriter{
+		log:   lw.log,
+		level: lw.level,
+		field: field,
+	}
+}
+
+func (lw *LogWriter) writeLine(data []byte) {
+	if len(data) == 0 {
+		return
+	}
+	if data[len(data)-1] == '\n' {
+		data = data[:len(data)-1]
+	}
+	if lw.buf.Len() > 0 {
+		lw.buf.Write(data)
+		data = lw.buf.Bytes()
+		lw.buf.Reset()
+	}
+	lw.log.WithLevel(lw.level).Bytes(lw.field, data).Send()
+}
+
+func (lw *LogWriter) Write(data []byte) (n int, err error) {
+	lw.mu.Lock()
+	defer lw.mu.Unlock()
+	newline := bytes.IndexByte(data, '\n')
+	if newline == len(data)-1 {
+		lw.writeLine(data)
+	} else if newline < 0 {
+		lw.buf.Write(data)
+	} else {
+		lines := bytes.Split(data, []byte{'\n'})
+		for _, line := range lines[:len(lines)-1] {
+			lw.writeLine(line)
+		}
+		lw.buf.Write(lines[len(lines)-1])
+	}
+	return len(data), nil
+}

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/.pre-commit-config.yaml

@@ -1,6 +1,6 @@
 repos:
   - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v5.0.0
+    rev: v6.0.0
     hooks:
       - id: trailing-whitespace
         exclude_types: [markdown]
@@ -11,7 +11,7 @@ repos:
       - id: check-added-large-files
 
   - repo: https://github.com/tekwizely/pre-commit-golang
-    rev: v1.0.0-rc.1
+    rev: v1.0.0-rc.2
     hooks:
       - id: go-imports-repo
         args:
@@ -24,7 +24,7 @@ repos:
       - id: go-mod-tidy
 
   - repo: https://github.com/beeper/pre-commit-go
-    rev: v0.3.1
+    rev: v0.4.2
     hooks:
       # TODO enable this
       #- id: zerolog-ban-msgf

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/hash.go

@@ -80,7 +80,7 @@ func (hs *HashState) generateSnapshotMAC(name WAPatchName, key []byte) []byte {
 
 func generatePatchMAC(patch *waServerSync.SyncdPatch, name WAPatchName, key []byte, version uint64) []byte {
 	dataToHash := make([][]byte, len(patch.GetMutations())+3)
-	dataToHash[0] = patch.GetSnapshotMac()
+	dataToHash[0] = patch.GetSnapshotMAC()
 	for i, mutation := range patch.Mutations {
 		val := mutation.GetRecord().GetValue().GetBlob()
 		dataToHash[i+1] = val[len(val)-32:]

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 {
@@ -134,28 +134,32 @@ func (cli *Client) dispatchAppState(mutation appstate.Mutation, fullSync bool, e
 		eventToDispatch = &events.Mute{JID: jid, Timestamp: ts, Action: act, FromFullSync: fullSync}
 		var mutedUntil time.Time
 		if act.GetMuted() {
-			mutedUntil = time.UnixMilli(act.GetMuteEndTimestamp())
+			if act.GetMuteEndTimestamp() < 0 {
+				mutedUntil = store.MutedForever
+			} else {
+				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 +213,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 +274,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 +287,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 +302,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 +353,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 +372,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 +409,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)
 }