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

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

@@ -0,0 +1,97 @@
+// Copyright (c) 2021 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 appstate
+
+import (
+	"crypto/hmac"
+	"crypto/sha256"
+	"crypto/sha512"
+	"encoding/binary"
+	"fmt"
+	"hash"
+
+	"go.mau.fi/whatsmeow/appstate/lthash"
+	"go.mau.fi/whatsmeow/proto/waServerSync"
+	"go.mau.fi/whatsmeow/proto/waSyncAction"
+)
+
+type Mutation struct {
+	Operation waServerSync.SyncdMutation_SyncdOperation
+	Action    *waSyncAction.SyncActionValue
+	Index     []string
+	IndexMAC  []byte
+	ValueMAC  []byte
+}
+
+type HashState struct {
+	Version uint64
+	Hash    [128]byte
+}
+
+func (hs *HashState) updateHash(mutations []*waServerSync.SyncdMutation, getPrevSetValueMAC func(indexMAC []byte, maxIndex int) ([]byte, error)) ([]error, error) {
+	var added, removed [][]byte
+	var warnings []error
+
+	for i, mutation := range mutations {
+		if mutation.GetOperation() == waServerSync.SyncdMutation_SET {
+			value := mutation.GetRecord().GetValue().GetBlob()
+			added = append(added, value[len(value)-32:])
+		}
+		indexMAC := mutation.GetRecord().GetIndex().GetBlob()
+		removal, err := getPrevSetValueMAC(indexMAC, i)
+		if err != nil {
+			return warnings, fmt.Errorf("failed to get value MAC of previous SET operation: %w", err)
+		} else if removal != nil {
+			removed = append(removed, removal)
+		} else if mutation.GetOperation() == waServerSync.SyncdMutation_REMOVE {
+			// TODO figure out if there are certain cases that are safe to ignore and others that aren't
+			// At least removing contact access from WhatsApp seems to create a REMOVE op for your own JID
+			// that points to a non-existent index and is safe to ignore here. Other keys might not be safe to ignore.
+			warnings = append(warnings, fmt.Errorf("%w for %X", ErrMissingPreviousSetValueOperation, indexMAC))
+			//return ErrMissingPreviousSetValueOperation
+		}
+	}
+
+	lthash.WAPatchIntegrity.SubtractThenAddInPlace(hs.Hash[:], removed, added)
+	return warnings, nil
+}
+
+func uint64ToBytes(val uint64) []byte {
+	data := make([]byte, 8)
+	binary.BigEndian.PutUint64(data, val)
+	return data
+}
+
+func concatAndHMAC(alg func() hash.Hash, key []byte, data ...[]byte) []byte {
+	h := hmac.New(alg, key)
+	for _, item := range data {
+		h.Write(item)
+	}
+	return h.Sum(nil)
+}
+
+func (hs *HashState) generateSnapshotMAC(name WAPatchName, key []byte) []byte {
+	return concatAndHMAC(sha256.New, key, hs.Hash[:], uint64ToBytes(hs.Version), []byte(name))
+}
+
+func generatePatchMAC(patch *waServerSync.SyncdPatch, name WAPatchName, key []byte, version uint64) []byte {
+	dataToHash := make([][]byte, len(patch.GetMutations())+3)
+	dataToHash[0] = patch.GetSnapshotMac()
+	for i, mutation := range patch.Mutations {
+		val := mutation.GetRecord().GetValue().GetBlob()
+		dataToHash[i+1] = val[len(val)-32:]
+	}
+	dataToHash[len(dataToHash)-2] = uint64ToBytes(version)
+	dataToHash[len(dataToHash)-1] = []byte(name)
+	return concatAndHMAC(sha256.New, key, dataToHash...)
+}
+
+func generateContentMAC(operation waServerSync.SyncdMutation_SyncdOperation, data, keyID, key []byte) []byte {
+	operationBytes := []byte{byte(operation) + 1}
+	keyDataLength := uint64ToBytes(uint64(len(keyID) + 1))
+	return concatAndHMAC(sha512.New, key, operationBytes, keyID, data, keyDataLength)[:32]
+}

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

@@ -0,0 +1,138 @@
+// Copyright (c) 2021 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 appstate implements encoding and decoding WhatsApp's app state patches.
+package appstate
+
+import (
+	"context"
+	"encoding/base64"
+	"sync"
+
+	"go.mau.fi/whatsmeow/store"
+	"go.mau.fi/whatsmeow/util/hkdfutil"
+	waLog "go.mau.fi/whatsmeow/util/log"
+)
+
+// WAPatchName represents a type of app state patch.
+type WAPatchName string
+
+const (
+	// WAPatchCriticalBlock contains the user's settings like push name and locale.
+	WAPatchCriticalBlock WAPatchName = "critical_block"
+	// WAPatchCriticalUnblockLow contains the user's contact list.
+	WAPatchCriticalUnblockLow WAPatchName = "critical_unblock_low"
+	// WAPatchRegularLow contains some local chat settings like pin, archive status, and the setting of whether to unarchive chats when messages come in.
+	WAPatchRegularLow WAPatchName = "regular_low"
+	// WAPatchRegularHigh contains more local chat settings like mute status and starred messages.
+	WAPatchRegularHigh WAPatchName = "regular_high"
+	// WAPatchRegular contains protocol info about app state patches like key expiration.
+	WAPatchRegular WAPatchName = "regular"
+)
+
+// AllPatchNames contains all currently known patch state names.
+var AllPatchNames = [...]WAPatchName{WAPatchCriticalBlock, WAPatchCriticalUnblockLow, WAPatchRegularHigh, WAPatchRegular, WAPatchRegularLow}
+
+// Constants for the first part of app state indexes.
+const (
+	IndexMute                    = "mute"
+	IndexPin                     = "pin_v1"
+	IndexArchive                 = "archive"
+	IndexContact                 = "contact"
+	IndexClearChat               = "clearChat"
+	IndexDeleteChat              = "deleteChat"
+	IndexStar                    = "star"
+	IndexDeleteMessageForMe      = "deleteMessageForMe"
+	IndexMarkChatAsRead          = "markChatAsRead"
+	IndexSettingPushName         = "setting_pushName"
+	IndexSettingUnarchiveChats   = "setting_unarchiveChats"
+	IndexUserStatusMute          = "userStatusMute"
+	IndexLabelEdit               = "label_edit"
+	IndexLabelAssociationChat    = "label_jid"
+	IndexLabelAssociationMessage = "label_message"
+)
+
+type Processor struct {
+	keyCache     map[string]ExpandedAppStateKeys
+	keyCacheLock sync.Mutex
+	Store        *store.Device
+	Log          waLog.Logger
+}
+
+func NewProcessor(store *store.Device, log waLog.Logger) *Processor {
+	return &Processor{
+		keyCache: make(map[string]ExpandedAppStateKeys),
+		Store:    store,
+		Log:      log,
+	}
+}
+
+type ExpandedAppStateKeys struct {
+	Index           []byte
+	ValueEncryption []byte
+	ValueMAC        []byte
+	SnapshotMAC     []byte
+	PatchMAC        []byte
+}
+
+func expandAppStateKeys(keyData []byte) (keys ExpandedAppStateKeys) {
+	appStateKeyExpanded := hkdfutil.SHA256(keyData, nil, []byte("WhatsApp Mutation Keys"), 160)
+	return ExpandedAppStateKeys{appStateKeyExpanded[0:32], appStateKeyExpanded[32:64], appStateKeyExpanded[64:96], appStateKeyExpanded[96:128], appStateKeyExpanded[128:160]}
+}
+
+func (proc *Processor) getAppStateKey(ctx context.Context, keyID []byte) (keys ExpandedAppStateKeys, err error) {
+	keyCacheID := base64.RawStdEncoding.EncodeToString(keyID)
+	var ok bool
+
+	proc.keyCacheLock.Lock()
+	defer proc.keyCacheLock.Unlock()
+
+	keys, ok = proc.keyCache[keyCacheID]
+	if !ok {
+		var keyData *store.AppStateSyncKey
+		keyData, err = proc.Store.AppStateKeys.GetAppStateSyncKey(ctx, keyID)
+		if keyData != nil {
+			keys = expandAppStateKeys(keyData.Data)
+			proc.keyCache[keyCacheID] = keys
+		} else if err == nil {
+			err = ErrKeyNotFound
+		}
+	}
+	return
+}
+
+func (proc *Processor) GetMissingKeyIDs(ctx context.Context, pl *PatchList) [][]byte {
+	cache := make(map[string]bool)
+	var missingKeys [][]byte
+	checkMissing := func(keyID []byte) {
+		if keyID == nil {
+			return
+		}
+		stringKeyID := base64.RawStdEncoding.EncodeToString(keyID)
+		_, alreadyAdded := cache[stringKeyID]
+		if !alreadyAdded {
+			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)
+			}
+			missing := keyData == nil && err == nil
+			cache[stringKeyID] = missing
+			if missing {
+				missingKeys = append(missingKeys, keyID)
+			}
+		}
+	}
+	if pl.Snapshot != nil {
+		checkMissing(pl.Snapshot.GetKeyId().GetId())
+		for _, record := range pl.Snapshot.GetRecords() {
+			checkMissing(record.GetKeyId().GetId())
+		}
+	}
+	for _, patch := range pl.Patches {
+		checkMissing(patch.GetKeyId().GetId())
+	}
+	return missingKeys
+}

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

@@ -0,0 +1,58 @@
+// Copyright (c) 2021 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 lthash implements a summation based hash algorithm that maintains the
+// integrity of a piece of data over a series of mutations. You can add/remove
+// mutations, and it'll return a hash equal to if the same series of mutations
+// was made sequentially.
+package lthash
+
+import (
+	"encoding/binary"
+
+	"go.mau.fi/whatsmeow/util/hkdfutil"
+)
+
+type LTHash struct {
+	HKDFInfo []byte
+	HKDFSize uint8
+}
+
+// WAPatchIntegrity is a LTHash instance initialized with the details used for verifying integrity of WhatsApp app state sync patches.
+var WAPatchIntegrity = LTHash{[]byte("WhatsApp Patch Integrity"), 128}
+
+func (lth LTHash) SubtractThenAdd(base []byte, subtract, add [][]byte) []byte {
+	output := make([]byte, len(base))
+	copy(output, base)
+	lth.SubtractThenAddInPlace(output, subtract, add)
+	return output
+}
+
+func (lth LTHash) SubtractThenAddInPlace(base []byte, subtract, add [][]byte) {
+	lth.multipleOp(base, subtract, true)
+	lth.multipleOp(base, add, false)
+}
+
+func (lth LTHash) multipleOp(base []byte, input [][]byte, subtract bool) {
+	for _, item := range input {
+		performPointwiseWithOverflow(base, hkdfutil.SHA256(item, nil, lth.HKDFInfo, lth.HKDFSize), subtract)
+	}
+}
+
+func performPointwiseWithOverflow(base, input []byte, subtract bool) []byte {
+	for i := 0; i < len(base); i += 2 {
+		x := binary.LittleEndian.Uint16(base[i : i+2])
+		y := binary.LittleEndian.Uint16(input[i : i+2])
+		var result uint16
+		if subtract {
+			result = x - y
+		} else {
+			result = x + y
+		}
+		binary.LittleEndian.PutUint16(base[i:i+2], result)
+	}
+	return base
+}

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

@@ -0,0 +1,409 @@
+// Copyright (c) 2022 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 (
+	"context"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"time"
+
+	"go.mau.fi/whatsmeow/appstate"
+	waBinary "go.mau.fi/whatsmeow/binary"
+	"go.mau.fi/whatsmeow/proto/waE2E"
+	"go.mau.fi/whatsmeow/proto/waServerSync"
+	"go.mau.fi/whatsmeow/store"
+	"go.mau.fi/whatsmeow/types"
+	"go.mau.fi/whatsmeow/types/events"
+)
+
+// 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(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(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(ctx, string(name))
+	if err != nil {
+		return fmt.Errorf("failed to get app state %s version: %w", name, err)
+	}
+	if version == 0 {
+		fullSync = true
+	} else if onlyIfNotSynced {
+		return nil
+	}
+
+	state := appstate.HashState{Version: version, Hash: hash}
+
+	hasMore := true
+	wantSnapshot := fullSync
+	for hasMore {
+		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(ctx, patches, state, true)
+		if err != nil {
+			if errors.Is(err, appstate.ErrKeyNotFound) {
+				go cli.requestMissingAppStateKeys(context.WithoutCancel(ctx), patches)
+			}
+			return fmt.Errorf("failed to decode app state %s patches: %w", name, err)
+		}
+		wasFullSync := state.Version == 0 && patches.Snapshot != nil
+		state = newState
+		if name == appstate.WAPatchCriticalUnblockLow && wasFullSync && !cli.EmitAppStateEventsOnFullSync {
+			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(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(ctx, mutation, fullSync, cli.EmitAppStateEventsOnFullSync)
+		}
+	}
+	if fullSync {
+		cli.Log.Debugf("Full sync of app state %s completed. Current version: %d", name, state.Version)
+		cli.dispatchEvent(&events.AppStateSyncComplete{Name: name})
+	} else {
+		cli.Log.Debugf("Synced app state %s from version %d to %d", name, version, state.Version)
+	}
+	return nil
+}
+
+func (cli *Client) filterContacts(mutations []appstate.Mutation) ([]appstate.Mutation, []store.ContactEntry) {
+	filteredMutations := mutations[:0]
+	contacts := make([]store.ContactEntry, 0, len(mutations))
+	for _, mutation := range mutations {
+		if mutation.Index[0] == "contact" && len(mutation.Index) > 1 {
+			jid, _ := types.ParseJID(mutation.Index[1])
+			act := mutation.Action.GetContactAction()
+			contacts = append(contacts, store.ContactEntry{
+				JID:       jid,
+				FirstName: act.GetFirstName(),
+				FullName:  act.GetFullName(),
+			})
+		} else {
+			filteredMutations = append(filteredMutations, mutation)
+		}
+	}
+	return filteredMutations, contacts
+}
+
+func (cli *Client) dispatchAppState(ctx context.Context, mutation appstate.Mutation, fullSync bool, emitOnFullSync bool) {
+	dispatchEvts := !fullSync || emitOnFullSync
+
+	if mutation.Operation != waServerSync.SyncdMutation_SET {
+		return
+	}
+
+	if dispatchEvts {
+		cli.dispatchEvent(&events.AppState{Index: mutation.Index, SyncActionValue: mutation.Action})
+	}
+
+	var jid types.JID
+	if len(mutation.Index) > 1 {
+		jid, _ = types.ParseJID(mutation.Index[1])
+	}
+	ts := time.UnixMilli(mutation.Action.GetTimestamp())
+
+	var storeUpdateError error
+	var eventToDispatch interface{}
+	switch mutation.Index[0] {
+	case appstate.IndexMute:
+		act := mutation.Action.GetMuteAction()
+		eventToDispatch = &events.Mute{JID: jid, Timestamp: ts, Action: act, FromFullSync: fullSync}
+		var mutedUntil time.Time
+		if act.GetMuted() {
+			mutedUntil = time.UnixMilli(act.GetMuteEndTimestamp())
+		}
+		if cli.Store.ChatSettings != nil {
+			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(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(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(ctx, jid, act.GetFirstName(), act.GetFullName())
+		}
+	case appstate.IndexClearChat:
+		act := mutation.Action.GetClearChatAction()
+		eventToDispatch = &events.ClearChat{JID: jid, Timestamp: ts, Action: act, FromFullSync: fullSync}
+	case appstate.IndexDeleteChat:
+		act := mutation.Action.GetDeleteChatAction()
+		eventToDispatch = &events.DeleteChat{JID: jid, Timestamp: ts, Action: act, FromFullSync: fullSync}
+	case appstate.IndexStar:
+		if len(mutation.Index) < 5 {
+			return
+		}
+		evt := events.Star{
+			ChatJID:      jid,
+			MessageID:    mutation.Index[2],
+			Timestamp:    ts,
+			Action:       mutation.Action.GetStarAction(),
+			IsFromMe:     mutation.Index[3] == "1",
+			FromFullSync: fullSync,
+		}
+		if mutation.Index[4] != "0" {
+			evt.SenderJID, _ = types.ParseJID(mutation.Index[4])
+		}
+		eventToDispatch = &evt
+	case appstate.IndexDeleteMessageForMe:
+		if len(mutation.Index) < 5 {
+			return
+		}
+		evt := events.DeleteForMe{
+			ChatJID:      jid,
+			MessageID:    mutation.Index[2],
+			Timestamp:    ts,
+			Action:       mutation.Action.GetDeleteMessageForMeAction(),
+			IsFromMe:     mutation.Index[3] == "1",
+			FromFullSync: fullSync,
+		}
+		if mutation.Index[4] != "0" {
+			evt.SenderJID, _ = types.ParseJID(mutation.Index[4])
+		}
+		eventToDispatch = &evt
+	case appstate.IndexMarkChatAsRead:
+		eventToDispatch = &events.MarkChatAsRead{
+			JID:          jid,
+			Timestamp:    ts,
+			Action:       mutation.Action.GetMarkChatAsReadAction(),
+			FromFullSync: fullSync,
+		}
+	case appstate.IndexSettingPushName:
+		eventToDispatch = &events.PushNameSetting{
+			Timestamp:    ts,
+			Action:       mutation.Action.GetPushNameSetting(),
+			FromFullSync: fullSync,
+		}
+		cli.Store.PushName = mutation.Action.GetPushNameSetting().GetName()
+		err := cli.Store.Save(ctx)
+		if err != nil {
+			cli.Log.Errorf("Failed to save device store after updating push name: %v", err)
+		}
+	case appstate.IndexSettingUnarchiveChats:
+		eventToDispatch = &events.UnarchiveChatsSetting{
+			Timestamp:    ts,
+			Action:       mutation.Action.GetUnarchiveChatsSetting(),
+			FromFullSync: fullSync,
+		}
+	case appstate.IndexUserStatusMute:
+		eventToDispatch = &events.UserStatusMute{
+			JID:          jid,
+			Timestamp:    ts,
+			Action:       mutation.Action.GetUserStatusMuteAction(),
+			FromFullSync: fullSync,
+		}
+	case appstate.IndexLabelEdit:
+		act := mutation.Action.GetLabelEditAction()
+		eventToDispatch = &events.LabelEdit{
+			Timestamp:    ts,
+			LabelID:      mutation.Index[1],
+			Action:       act,
+			FromFullSync: fullSync,
+		}
+	case appstate.IndexLabelAssociationChat:
+		if len(mutation.Index) < 3 {
+			return
+		}
+		jid, _ = types.ParseJID(mutation.Index[2])
+		act := mutation.Action.GetLabelAssociationAction()
+		eventToDispatch = &events.LabelAssociationChat{
+			JID:          jid,
+			Timestamp:    ts,
+			LabelID:      mutation.Index[1],
+			Action:       act,
+			FromFullSync: fullSync,
+		}
+	case appstate.IndexLabelAssociationMessage:
+		if len(mutation.Index) < 6 {
+			return
+		}
+		jid, _ = types.ParseJID(mutation.Index[2])
+		act := mutation.Action.GetLabelAssociationAction()
+		eventToDispatch = &events.LabelAssociationMessage{
+			JID:          jid,
+			Timestamp:    ts,
+			LabelID:      mutation.Index[1],
+			MessageID:    mutation.Index[3],
+			Action:       act,
+			FromFullSync: fullSync,
+		}
+	}
+	if storeUpdateError != nil {
+		cli.Log.Errorf("Failed to update device store after app state mutation: %v", storeUpdateError)
+	}
+	if dispatchEvts && eventToDispatch != nil {
+		cli.dispatchEvent(eventToDispatch)
+	}
+}
+
+func (cli *Client) downloadExternalAppStateBlob(ctx context.Context, ref *waServerSync.ExternalBlobReference) ([]byte, error) {
+	return cli.Download(ctx, ref)
+}
+
+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,
+	}
+	if !snapshot {
+		attrs["version"] = fromVersion
+	}
+	resp, err := cli.sendIQ(infoQuery{
+		Context:   ctx,
+		Namespace: "w:sync:app:state",
+		Type:      "set",
+		To:        types.ServerJID,
+		Content: []waBinary.Node{{
+			Tag: "sync",
+			Content: []waBinary.Node{{
+				Tag:   "collection",
+				Attrs: attrs,
+			}},
+		}},
+	})
+	if err != nil {
+		return nil, err
+	}
+	return appstate.ParsePatchList(ctx, resp, cli.downloadExternalAppStateBlob)
+}
+
+func (cli *Client) requestMissingAppStateKeys(ctx context.Context, patches *appstate.PatchList) {
+	cli.appStateKeyRequestsLock.Lock()
+	rawKeyIDs := cli.appStateProc.GetMissingKeyIDs(ctx, patches)
+	filteredKeyIDs := make([][]byte, 0, len(rawKeyIDs))
+	now := time.Now()
+	for _, keyID := range rawKeyIDs {
+		stringKeyID := hex.EncodeToString(keyID)
+		lastRequestTime := cli.appStateKeyRequests[stringKeyID]
+		if lastRequestTime.IsZero() || lastRequestTime.Add(24*time.Hour).Before(now) {
+			cli.appStateKeyRequests[stringKeyID] = now
+			filteredKeyIDs = append(filteredKeyIDs, keyID)
+		}
+	}
+	cli.appStateKeyRequestsLock.Unlock()
+	cli.requestAppStateKeys(ctx, filteredKeyIDs)
+}
+
+func (cli *Client) requestAppStateKeys(ctx context.Context, rawKeyIDs [][]byte) {
+	keyIDs := make([]*waE2E.AppStateSyncKeyId, len(rawKeyIDs))
+	debugKeyIDs := make([]string, len(rawKeyIDs))
+	for i, keyID := range rawKeyIDs {
+		keyIDs[i] = &waE2E.AppStateSyncKeyId{KeyID: keyID}
+		debugKeyIDs[i] = hex.EncodeToString(keyID)
+	}
+	msg := &waE2E.Message{
+		ProtocolMessage: &waE2E.ProtocolMessage{
+			Type: waE2E.ProtocolMessage_APP_STATE_SYNC_KEY_REQUEST.Enum(),
+			AppStateSyncKeyRequest: &waE2E.AppStateSyncKeyRequest{
+				KeyIDs: keyIDs,
+			},
+		},
+	}
+	ownID := cli.getOwnID().ToNonAD()
+	if ownID.IsEmpty() || len(debugKeyIDs) == 0 {
+		return
+	}
+	cli.Log.Infof("Sending key request for app state keys %+v", debugKeyIDs)
+	_, err := cli.SendMessage(ctx, ownID, msg, SendRequestExtra{Peer: true})
+	if err != nil {
+		cli.Log.Warnf("Failed to send app state key request: %v", err)
+	}
+}
+
+// SendAppState sends the given app state patch, then resyncs that app state type from the server
+// to update local caches and send events for the updates.
+//
+// You can use the Build methods in the appstate package to build the parameter for this method, e.g.
+//
+//	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(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(ctx)
+	if err != nil {
+		return fmt.Errorf("failed to get latest app state key ID: %w", err)
+	} else if latestKeyID == nil {
+		return fmt.Errorf("no app state keys found, creating app state keys is not yet supported")
+	}
+
+	state := appstate.HashState{Version: version, Hash: hash}
+
+	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,
+		Content: []waBinary.Node{{
+			Tag: "sync",
+			Content: []waBinary.Node{{
+				Tag: "collection",
+				Attrs: waBinary.Attrs{
+					"name":            string(patch.Type),
+					"version":         version,
+					"return_snapshot": false,
+				},
+				Content: []waBinary.Node{{
+					Tag:     "patch",
+					Content: encodedPatch,
+				}},
+			}},
+		}},
+	})
+	if err != nil {
+		return err
+	}
+
+	respCollection := resp.GetChildByTag("sync", "collection")
+	respCollectionAttr := respCollection.AttrGetter()
+	if respCollectionAttr.OptionalString("type") == "error" {
+		// TODO parse error properly
+		return fmt.Errorf("%w: %s", ErrAppStateUpdate, respCollection.XMLString())
+	}
+
+	return cli.FetchAppState(ctx, patch.Type, false, false)
+}