slidge-whatsapp 0.2.2__cp312-cp312-manylinux_2_36_aarch64.whl → 0.2.5__cp312-cp312-manylinux_2_36_aarch64.whl

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

@@ -0,0 +1,311 @@
+// 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 (
+	"bytes"
+	"crypto/sha256"
+	"encoding/json"
+	"fmt"
+
+	"google.golang.org/protobuf/proto"
+
+	waBinary "go.mau.fi/whatsmeow/binary"
+	"go.mau.fi/whatsmeow/proto/waServerSync"
+	"go.mau.fi/whatsmeow/proto/waSyncAction"
+	"go.mau.fi/whatsmeow/store"
+	"go.mau.fi/whatsmeow/util/cbcutil"
+)
+
+// PatchList represents a decoded response to getting app state patches from the WhatsApp servers.
+type PatchList struct {
+	Name           WAPatchName
+	HasMorePatches bool
+	Patches        []*waServerSync.SyncdPatch
+	Snapshot       *waServerSync.SyncdSnapshot
+}
+
+// DownloadExternalFunc is a function that can download a blob of external app state patches.
+type DownloadExternalFunc func(*waServerSync.ExternalBlobReference) ([]byte, error)
+
+func parseSnapshotInternal(collection *waBinary.Node, downloadExternal DownloadExternalFunc) (*waServerSync.SyncdSnapshot, error) {
+	snapshotNode := collection.GetChildByTag("snapshot")
+	rawSnapshot, ok := snapshotNode.Content.([]byte)
+	if snapshotNode.Tag != "snapshot" || !ok {
+		return nil, nil
+	}
+	var snapshot waServerSync.ExternalBlobReference
+	err := proto.Unmarshal(rawSnapshot, &snapshot)
+	if err != nil {
+		return nil, fmt.Errorf("failed to unmarshal snapshot: %w", err)
+	}
+	var rawData []byte
+	rawData, err = downloadExternal(&snapshot)
+	if err != nil {
+		return nil, fmt.Errorf("failed to download external mutations: %w", err)
+	}
+	var downloaded waServerSync.SyncdSnapshot
+	err = proto.Unmarshal(rawData, &downloaded)
+	if err != nil {
+		return nil, fmt.Errorf("failed to unmarshal mutation list: %w", err)
+	}
+	return &downloaded, nil
+}
+
+func parsePatchListInternal(collection *waBinary.Node, downloadExternal DownloadExternalFunc) ([]*waServerSync.SyncdPatch, error) {
+	patchesNode := collection.GetChildByTag("patches")
+	patchNodes := patchesNode.GetChildren()
+	patches := make([]*waServerSync.SyncdPatch, 0, len(patchNodes))
+	for i, patchNode := range patchNodes {
+		rawPatch, ok := patchNode.Content.([]byte)
+		if patchNode.Tag != "patch" || !ok {
+			continue
+		}
+		var patch waServerSync.SyncdPatch
+		err := proto.Unmarshal(rawPatch, &patch)
+		if err != nil {
+			return nil, fmt.Errorf("failed to unmarshal patch #%d: %w", i+1, err)
+		}
+		if patch.GetExternalMutations() != nil && downloadExternal != nil {
+			var rawData []byte
+			rawData, err = downloadExternal(patch.GetExternalMutations())
+			if err != nil {
+				return nil, fmt.Errorf("failed to download external mutations: %w", err)
+			}
+			var downloaded waServerSync.SyncdMutations
+			err = proto.Unmarshal(rawData, &downloaded)
+			if err != nil {
+				return nil, fmt.Errorf("failed to unmarshal mutation list: %w", err)
+			} else if len(downloaded.GetMutations()) == 0 {
+				return nil, fmt.Errorf("didn't get any mutations from download")
+			}
+			patch.Mutations = downloaded.Mutations
+		}
+		patches = append(patches, &patch)
+	}
+	return patches, nil
+}
+
+// ParsePatchList will decode an XML node containing app state patches, including downloading any external blobs.
+func ParsePatchList(node *waBinary.Node, downloadExternal DownloadExternalFunc) (*PatchList, error) {
+	collection := node.GetChildByTag("sync", "collection")
+	ag := collection.AttrGetter()
+	snapshot, err := parseSnapshotInternal(&collection, downloadExternal)
+	if err != nil {
+		return nil, err
+	}
+	patches, err := parsePatchListInternal(&collection, downloadExternal)
+	if err != nil {
+		return nil, err
+	}
+	list := &PatchList{
+		Name:           WAPatchName(ag.String("name")),
+		HasMorePatches: ag.OptionalBool("has_more_patches"),
+		Patches:        patches,
+		Snapshot:       snapshot,
+	}
+	return list, ag.Error()
+}
+
+type patchOutput struct {
+	RemovedMACs [][]byte
+	AddedMACs   []store.AppStateMutationMAC
+	Mutations   []Mutation
+}
+
+func (proc *Processor) decodeMutations(mutations []*waServerSync.SyncdMutation, out *patchOutput, validateMACs bool) error {
+	for i, mutation := range mutations {
+		keyID := mutation.GetRecord().GetKeyID().GetID()
+		keys, err := proc.getAppStateKey(keyID)
+		if err != nil {
+			return fmt.Errorf("failed to get key %X to decode mutation: %w", keyID, err)
+		}
+		content := mutation.GetRecord().GetValue().GetBlob()
+		content, valueMAC := content[:len(content)-32], content[len(content)-32:]
+		if validateMACs {
+			expectedValueMAC := generateContentMAC(mutation.GetOperation(), content, keyID, keys.ValueMAC)
+			if !bytes.Equal(expectedValueMAC, valueMAC) {
+				return fmt.Errorf("failed to verify mutation #%d: %w", i+1, ErrMismatchingContentMAC)
+			}
+		}
+		iv, content := content[:16], content[16:]
+		plaintext, err := cbcutil.Decrypt(keys.ValueEncryption, iv, content)
+		if err != nil {
+			return fmt.Errorf("failed to decrypt mutation #%d: %w", i+1, err)
+		}
+		var syncAction waSyncAction.SyncActionData
+		err = proto.Unmarshal(plaintext, &syncAction)
+		if err != nil {
+			return fmt.Errorf("failed to unmarshal mutation #%d: %w", i+1, err)
+		}
+		indexMAC := mutation.GetRecord().GetIndex().GetBlob()
+		if validateMACs {
+			expectedIndexMAC := concatAndHMAC(sha256.New, keys.Index, syncAction.Index)
+			if !bytes.Equal(expectedIndexMAC, indexMAC) {
+				return fmt.Errorf("failed to verify mutation #%d: %w", i+1, ErrMismatchingIndexMAC)
+			}
+		}
+		var index []string
+		err = json.Unmarshal(syncAction.GetIndex(), &index)
+		if err != nil {
+			return fmt.Errorf("failed to unmarshal index of mutation #%d: %w", i+1, err)
+		}
+		if mutation.GetOperation() == waServerSync.SyncdMutation_REMOVE {
+			out.RemovedMACs = append(out.RemovedMACs, indexMAC)
+		} else if mutation.GetOperation() == waServerSync.SyncdMutation_SET {
+			out.AddedMACs = append(out.AddedMACs, store.AppStateMutationMAC{
+				IndexMAC: indexMAC,
+				ValueMAC: valueMAC,
+			})
+		}
+		out.Mutations = append(out.Mutations, Mutation{
+			Operation: mutation.GetOperation(),
+			Action:    syncAction.GetValue(),
+			Index:     index,
+			IndexMAC:  indexMAC,
+			ValueMAC:  valueMAC,
+		})
+	}
+	return nil
+}
+
+func (proc *Processor) storeMACs(name WAPatchName, currentState HashState, out *patchOutput) {
+	err := proc.Store.AppState.PutAppStateVersion(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)
+	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)
+	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)
+	if err != nil {
+		err = fmt.Errorf("failed to get key %X to verify patch v%d MACs: %w", keyID, currentState.Version, err)
+		return
+	}
+	snapshotMAC := currentState.generateSnapshotMAC(name, keys.SnapshotMAC)
+	if !bytes.Equal(snapshotMAC, expectedSnapshotMAC) {
+		err = fmt.Errorf("failed to verify patch v%d: %w", currentState.Version, ErrMismatchingLTHash)
+	}
+	return
+}
+
+func (proc *Processor) decodeSnapshot(name WAPatchName, ss *waServerSync.SyncdSnapshot, initialState HashState, validateMACs bool, newMutationsInput []Mutation) (newMutations []Mutation, currentState HashState, err error) {
+	currentState = initialState
+	currentState.Version = ss.GetVersion().GetVersion()
+
+	encryptedMutations := make([]*waServerSync.SyncdMutation, len(ss.GetRecords()))
+	for i, record := range ss.GetRecords() {
+		encryptedMutations[i] = &waServerSync.SyncdMutation{
+			Operation: waServerSync.SyncdMutation_SET.Enum(),
+			Record:    record,
+		}
+	}
+
+	var warn []error
+	warn, err = currentState.updateHash(encryptedMutations, func(indexMAC []byte, maxIndex int) ([]byte, error) {
+		return nil, nil
+	})
+	if len(warn) > 0 {
+		proc.Log.Warnf("Warnings while updating hash for %s: %+v", name, warn)
+	}
+	if err != nil {
+		err = fmt.Errorf("failed to update state hash: %w", err)
+		return
+	}
+
+	if validateMACs {
+		_, err = proc.validateSnapshotMAC(name, currentState, ss.GetKeyID().GetID(), ss.GetMac())
+		if err != nil {
+			return
+		}
+	}
+
+	var out patchOutput
+	out.Mutations = newMutationsInput
+	err = proc.decodeMutations(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)
+	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) {
+	currentState = initialState
+	var expectedLength int
+	if list.Snapshot != nil {
+		expectedLength = len(list.Snapshot.GetRecords())
+	}
+	for _, patch := range list.Patches {
+		expectedLength += len(patch.GetMutations())
+	}
+	newMutations = make([]Mutation, 0, expectedLength)
+
+	if list.Snapshot != nil {
+		newMutations, currentState, err = proc.decodeSnapshot(list.Name, list.Snapshot, currentState, validateMACs, newMutations)
+		if err != nil {
+			return
+		}
+	}
+
+	for _, patch := range list.Patches {
+		version := patch.GetVersion().GetVersion()
+		currentState.Version = version
+		var warn []error
+		warn, err = currentState.updateHash(patch.GetMutations(), func(indexMAC []byte, maxIndex int) ([]byte, error) {
+			for i := maxIndex - 1; i >= 0; i-- {
+				if bytes.Equal(patch.Mutations[i].GetRecord().GetIndex().GetBlob(), indexMAC) {
+					value := patch.Mutations[i].GetRecord().GetValue().GetBlob()
+					return value[len(value)-32:], nil
+				}
+			}
+			// Previous value not found in current patch, look in the database
+			return proc.Store.AppState.GetAppStateMutationMAC(string(list.Name), indexMAC)
+		})
+		if len(warn) > 0 {
+			proc.Log.Warnf("Warnings while updating hash for %s: %+v", list.Name, warn)
+		}
+		if err != nil {
+			err = fmt.Errorf("failed to update state hash: %w", err)
+			return
+		}
+
+		if validateMACs {
+			var keys ExpandedAppStateKeys
+			keys, err = proc.validateSnapshotMAC(list.Name, currentState, patch.GetKeyID().GetID(), patch.GetSnapshotMac())
+			if err != nil {
+				return
+			}
+			patchMAC := generatePatchMAC(patch, list.Name, keys.PatchMAC, patch.GetVersion().GetVersion())
+			if !bytes.Equal(patchMAC, patch.GetPatchMAC()) {
+				err = fmt.Errorf("failed to verify patch v%d: %w", version, ErrMismatchingPatchMAC)
+				return
+			}
+		}
+
+		var out patchOutput
+		out.Mutations = newMutations
+		err = proc.decodeMutations(patch.GetMutations(), &out, validateMACs)
+		if err != nil {
+			return
+		}
+		proc.storeMACs(list.Name, currentState, &out)
+		newMutations = out.Mutations
+	}
+	return
+}

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

@@ -0,0 +1,322 @@
+package appstate
+
+import (
+	"crypto/sha256"
+	"encoding/json"
+	"fmt"
+	"time"
+
+	"google.golang.org/protobuf/proto"
+
+	"go.mau.fi/whatsmeow/proto/waCommon"
+	"go.mau.fi/whatsmeow/proto/waServerSync"
+	"go.mau.fi/whatsmeow/proto/waSyncAction"
+	"go.mau.fi/whatsmeow/types"
+	"go.mau.fi/whatsmeow/util/cbcutil"
+)
+
+// MutationInfo contains information about a single mutation to the app state.
+type MutationInfo struct {
+	// Index contains the thing being mutated (like `mute` or `pin_v1`), followed by parameters like the target JID.
+	Index []string
+	// Version is a static number that depends on the thing being mutated.
+	Version int32
+	// Value contains the data for the mutation.
+	Value *waSyncAction.SyncActionValue
+}
+
+// PatchInfo contains information about a patch to the app state.
+// A patch can contain multiple mutations, as long as all mutations are in the same app state type.
+type PatchInfo struct {
+	// Timestamp is the time when the patch was created. This will be filled automatically in EncodePatch if it's zero.
+	Timestamp time.Time
+	// Type is the app state type being mutated.
+	Type WAPatchName
+	// Mutations contains the individual mutations to apply to the app state in this patch.
+	Mutations []MutationInfo
+}
+
+// BuildMute builds an app state patch for muting or unmuting a chat.
+//
+// If mute is true and the mute duration is zero, the chat is muted forever.
+func BuildMute(target types.JID, mute bool, muteDuration time.Duration) PatchInfo {
+	var muteEndTimestamp *int64
+	if muteDuration > 0 {
+		muteEndTimestamp = proto.Int64(time.Now().Add(muteDuration).UnixMilli())
+	}
+
+	return PatchInfo{
+		Type: WAPatchRegularHigh,
+		Mutations: []MutationInfo{{
+			Index:   []string{IndexMute, target.String()},
+			Version: 2,
+			Value: &waSyncAction.SyncActionValue{
+				MuteAction: &waSyncAction.MuteAction{
+					Muted:            proto.Bool(mute),
+					MuteEndTimestamp: muteEndTimestamp,
+				},
+			},
+		}},
+	}
+}
+
+func newPinMutationInfo(target types.JID, pin bool) MutationInfo {
+	return MutationInfo{
+		Index:   []string{IndexPin, target.String()},
+		Version: 5,
+		Value: &waSyncAction.SyncActionValue{
+			PinAction: &waSyncAction.PinAction{
+				Pinned: &pin,
+			},
+		},
+	}
+}
+
+// BuildPin builds an app state patch for pinning or unpinning a chat.
+func BuildPin(target types.JID, pin bool) PatchInfo {
+	return PatchInfo{
+		Type: WAPatchRegularLow,
+		Mutations: []MutationInfo{
+			newPinMutationInfo(target, pin),
+		},
+	}
+}
+
+// BuildArchive builds an app state patch for archiving or unarchiving a chat.
+//
+// The last message timestamp and last message key are optional and can be set to zero values (`time.Time{}` and `nil`).
+//
+// Archiving a chat will also unpin it automatically.
+func BuildArchive(target types.JID, archive bool, lastMessageTimestamp time.Time, lastMessageKey *waCommon.MessageKey) PatchInfo {
+	if lastMessageTimestamp.IsZero() {
+		lastMessageTimestamp = time.Now()
+	}
+	archiveMutationInfo := MutationInfo{
+		Index:   []string{IndexArchive, target.String()},
+		Version: 3,
+		Value: &waSyncAction.SyncActionValue{
+			ArchiveChatAction: &waSyncAction.ArchiveChatAction{
+				Archived: &archive,
+				MessageRange: &waSyncAction.SyncActionMessageRange{
+					LastMessageTimestamp: proto.Int64(lastMessageTimestamp.Unix()),
+					// TODO set LastSystemMessageTimestamp?
+				},
+			},
+		},
+	}
+
+	if lastMessageKey != nil {
+		archiveMutationInfo.Value.ArchiveChatAction.MessageRange.Messages = []*waSyncAction.SyncActionMessage{{
+			Key:       lastMessageKey,
+			Timestamp: proto.Int64(lastMessageTimestamp.Unix()),
+		}}
+	}
+
+	mutations := []MutationInfo{archiveMutationInfo}
+	if archive {
+		mutations = append(mutations, newPinMutationInfo(target, false))
+	}
+
+	result := PatchInfo{
+		Type:      WAPatchRegularLow,
+		Mutations: mutations,
+	}
+
+	return result
+}
+
+func newLabelChatMutation(target types.JID, labelID string, labeled bool) MutationInfo {
+	return MutationInfo{
+		Index:   []string{IndexLabelAssociationChat, labelID, target.String()},
+		Version: 3,
+		Value: &waSyncAction.SyncActionValue{
+			LabelAssociationAction: &waSyncAction.LabelAssociationAction{
+				Labeled: &labeled,
+			},
+		},
+	}
+}
+
+// BuildLabelChat builds an app state patch for labeling or un(labeling) a chat.
+func BuildLabelChat(target types.JID, labelID string, labeled bool) PatchInfo {
+	return PatchInfo{
+		Type: WAPatchRegular,
+		Mutations: []MutationInfo{
+			newLabelChatMutation(target, labelID, labeled),
+		},
+	}
+}
+
+func newLabelMessageMutation(target types.JID, labelID, messageID string, labeled bool) MutationInfo {
+	return MutationInfo{
+		Index:   []string{IndexLabelAssociationMessage, labelID, target.String(), messageID, "0", "0"},
+		Version: 3,
+		Value: &waSyncAction.SyncActionValue{
+			LabelAssociationAction: &waSyncAction.LabelAssociationAction{
+				Labeled: &labeled,
+			},
+		},
+	}
+}
+
+// BuildLabelMessage builds an app state patch for labeling or un(labeling) a message.
+func BuildLabelMessage(target types.JID, labelID, messageID string, labeled bool) PatchInfo {
+	return PatchInfo{
+		Type: WAPatchRegular,
+		Mutations: []MutationInfo{
+			newLabelMessageMutation(target, labelID, messageID, labeled),
+		},
+	}
+}
+
+func newLabelEditMutation(labelID string, labelName string, labelColor int32, deleted bool) MutationInfo {
+	return MutationInfo{
+		Index:   []string{IndexLabelEdit, labelID},
+		Version: 3,
+		Value: &waSyncAction.SyncActionValue{
+			LabelEditAction: &waSyncAction.LabelEditAction{
+				Name:    &labelName,
+				Color:   &labelColor,
+				Deleted: &deleted,
+			},
+		},
+	}
+}
+
+// BuildLabelEdit builds an app state patch for editing a label.
+func BuildLabelEdit(labelID string, labelName string, labelColor int32, deleted bool) PatchInfo {
+	return PatchInfo{
+		Type: WAPatchRegular,
+		Mutations: []MutationInfo{
+			newLabelEditMutation(labelID, labelName, labelColor, deleted),
+		},
+	}
+}
+
+func newSettingPushNameMutation(pushName string) MutationInfo {
+	return MutationInfo{
+		Index:   []string{IndexSettingPushName},
+		Version: 1,
+		Value: &waSyncAction.SyncActionValue{
+			PushNameSetting: &waSyncAction.PushNameSetting{
+				Name: &pushName,
+			},
+		},
+	}
+}
+
+// BuildSettingPushName builds an app state patch for setting the push name.
+func BuildSettingPushName(pushName string) PatchInfo {
+	return PatchInfo{
+		Type: WAPatchCriticalBlock,
+		Mutations: []MutationInfo{
+			newSettingPushNameMutation(pushName),
+		},
+	}
+}
+
+func newStarMutation(targetJID, senderJID string, messageID types.MessageID, fromMe string, starred bool) MutationInfo {
+	return MutationInfo{
+		Index:   []string{IndexStar, targetJID, messageID, fromMe, senderJID},
+		Version: 2,
+		Value: &waSyncAction.SyncActionValue{
+			StarAction: &waSyncAction.StarAction{
+				Starred: &starred,
+			},
+		},
+	}
+}
+
+// BuildStar builds an app state patch for starring or unstarring a message.
+func BuildStar(target, sender types.JID, messageID types.MessageID, fromMe, starred bool) PatchInfo {
+	isFromMe := "0"
+	if fromMe {
+		isFromMe = "1"
+	}
+	targetJID, senderJID := target.String(), sender.String()
+	if target.User == sender.User {
+		senderJID = "0"
+	}
+	return PatchInfo{
+		Type: WAPatchRegularHigh,
+		Mutations: []MutationInfo{
+			newStarMutation(targetJID, senderJID, messageID, isFromMe, starred),
+		},
+	}
+}
+
+func (proc *Processor) EncodePatch(keyID []byte, state HashState, patchInfo PatchInfo) ([]byte, error) {
+	keys, err := proc.getAppStateKey(keyID)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get app state key details with key ID %x: %w", keyID, err)
+	}
+
+	if patchInfo.Timestamp.IsZero() {
+		patchInfo.Timestamp = time.Now()
+	}
+
+	mutations := make([]*waServerSync.SyncdMutation, 0, len(patchInfo.Mutations))
+	for _, mutationInfo := range patchInfo.Mutations {
+		mutationInfo.Value.Timestamp = proto.Int64(patchInfo.Timestamp.UnixMilli())
+
+		indexBytes, err := json.Marshal(mutationInfo.Index)
+		if err != nil {
+			return nil, fmt.Errorf("failed to marshal mutation index: %w", err)
+		}
+
+		pbObj := &waSyncAction.SyncActionData{
+			Index:   indexBytes,
+			Value:   mutationInfo.Value,
+			Padding: []byte{},
+			Version: &mutationInfo.Version,
+		}
+
+		content, err := proto.Marshal(pbObj)
+		if err != nil {
+			return nil, fmt.Errorf("failed to marshal mutation: %w", err)
+		}
+
+		encryptedContent, err := cbcutil.Encrypt(keys.ValueEncryption, nil, content)
+		if err != nil {
+			return nil, fmt.Errorf("failed to encrypt mutation: %w", err)
+		}
+
+		valueMac := generateContentMAC(waServerSync.SyncdMutation_SET, encryptedContent, keyID, keys.ValueMAC)
+		indexMac := concatAndHMAC(sha256.New, keys.Index, indexBytes)
+
+		mutations = append(mutations, &waServerSync.SyncdMutation{
+			Operation: waServerSync.SyncdMutation_SET.Enum(),
+			Record: &waServerSync.SyncdRecord{
+				Index: &waServerSync.SyncdIndex{Blob: indexMac},
+				Value: &waServerSync.SyncdValue{Blob: append(encryptedContent, valueMac...)},
+				KeyID: &waServerSync.KeyId{ID: keyID},
+			},
+		})
+	}
+
+	warn, err := state.updateHash(mutations, func(indexMAC []byte, _ int) ([]byte, error) {
+		return proc.Store.AppState.GetAppStateMutationMAC(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)
+	}
+	if err != nil {
+		return nil, fmt.Errorf("failed to update state hash: %w", err)
+	}
+
+	state.Version += 1
+
+	syncdPatch := &waServerSync.SyncdPatch{
+		SnapshotMAC: state.generateSnapshotMAC(patchInfo.Type, keys.SnapshotMAC),
+		KeyID:       &waServerSync.KeyId{ID: keyID},
+		Mutations:   mutations,
+	}
+	syncdPatch.PatchMAC = generatePatchMAC(syncdPatch, patchInfo.Type, keys.PatchMAC, state.Version)
+
+	result, err := proto.Marshal(syncdPatch)
+	if err != nil {
+		return nil, fmt.Errorf("failed to marshal compiled patch: %w", err)
+	}
+
+	return result, nil
+}

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

@@ -0,0 +1,19 @@
+// 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 "errors"
+
+// Errors that this package can return.
+var (
+	ErrMissingPreviousSetValueOperation = errors.New("missing value MAC of previous SET operation")
+	ErrMismatchingLTHash                = errors.New("mismatching LTHash")
+	ErrMismatchingPatchMAC              = errors.New("mismatching patch MAC")
+	ErrMismatchingContentMAC            = errors.New("mismatching content MAC")
+	ErrMismatchingIndexMAC              = errors.New("mismatching index MAC")
+	ErrKeyNotFound                      = errors.New("didn't find app state key")
+)