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

slidge_whatsapp/vendor/go.mau.fi/util/dbutil/log.go

@@ -115,6 +115,7 @@ func (z zeroLogger) QueryTiming(ctx context.Context, method, query string, args
 	if duration >= 1*time.Second {
 		evt := log.Warn().
 			Float64("duration_seconds", duration.Seconds()).
+			AnErr("result_error", err).
 			Str("method", method).
 			Str("query", query)
 		if z.Caller {

slidge_whatsapp/vendor/go.mau.fi/util/dbutil/module.go

@@ -0,0 +1,118 @@
+// Package dbutil provides a simple framework for in-process database
+// migrations. You provide the SQL files and they are run to upgrade
+// the database. A versions table is automatically created in the
+// database to track which migrations have been applied. There is
+// support for multiple migration pathways, for example v0->v2 versus
+// v0->v1->v2, and the shorter one is prioritized if both are
+// provided.
+//
+// Example usage from Go:
+//
+//	package main
+//
+//	import (
+//		"context"
+//		"database/sql"
+//		"embed"
+//
+//		"go.mau.fi/util/dbutil"
+//	)
+//
+//	//go:embed *.sql
+//	var upgrades embed.FS
+//
+//	func mainE() error {
+//		ctx := context.Background()
+//		rawDB, err := sql.Open("sqlite3", "./hotdogs.db")
+//		if err != nil {
+//			return err
+//		}
+//		db, err := dbutil.NewWithDB(rawDB, "sqlite3")
+//		if err != nil {
+//			return err
+//		}
+//		table := dbutil.UpgradeTable{}
+//		table.RegisterFS(upgrades)
+//		err = db.Upgrade(ctx)
+//		if err != nil {
+//			return err
+//		}
+//		// db has been upgraded to latest version
+//		return nil
+//	}
+//
+// In dbutil, the database is understood to have a monotonic integer
+// sequence of versions starting at v0, v1, v2, etc. By providing
+// migrations you define a directed acyclic graph (DAG) that allows
+// dbutil to find a path from the current recorded database version to
+// the latest version available.
+//
+// Each SQL migration file has a mandatory comment header that
+// identifies which database versions it upgrades between. For example
+// this is a migration that upgrades from v0 to v2:
+//
+//	-- v0 -> v2: Do some things
+//
+// You can omit the first version for the common case of upgrading to
+// a version from the previous version. For example this is a
+// migration that upgrades from v1 to v2:
+//
+//	-- v2: Do fewer things
+//
+// By providing "v1" and "v2" migrations, a v0 database would be
+// upgraded to v1 and then v2, while by providing an additional "v0 ->
+// v2" migration a v0 database would be upgraded directly to v2 as it
+// is a more direct path. With that migration provided the "v1"
+// migration is no longer needed.
+//
+// By default, when running migrations, if a more recent database
+// version is live than the current code knows about (for example,
+// from running a previous version of the application), dbutil will
+// error out. However, many database migrations are backwards
+// compatible. You can therefore indicate this when writing a
+// migration, and previous versions of the application will accept a
+// database with that migration applied, even if they are unaware of
+// its contents. For example, if the migration from v1 to v2 was
+// backwards compatible, you could provide this migration:
+//
+//	-- v2 (compatible with v1+): Do fewer things
+//
+// When applying the migration, the compatibility level (v1) is saved
+// to the versions table in the database, so that older versions of
+// the application which only know about v1 will see that v2 of the
+// database is still OK to use. If the compatibility level is not set,
+// then it defaults to the same as the target version for the
+// migration, which achieves the default behavior described in the
+// previous paragraph.
+//
+// You can provide additional flags immediately following the header
+// line. To disable wrapping the upgrade in a single transaction, put
+// "transaction: off" on the second line.
+//
+//	-- v5: Upgrade without transaction
+//	-- transaction: off
+//	// do dangerous stuff
+//
+// Within migrations, there is special syntax that can be used to
+// filter parts of the SQL to apply only with specific dialects. To
+// limit the next line to one dialect:
+//
+//	-- only: postgres
+//
+// To limit the next N lines:
+//
+//	-- only: sqlite for next 123 lines
+//
+// To limit a block of code, fenced by another directive:
+//
+//	-- only: sqlite until "end only"
+//	QUERY;
+//	ANOTHER QUERY;
+//	-- end only sqlite
+//
+// If the single-line limit is on the second line of the file, the
+// whole file is limited to that dialect.
+//
+// If the filter ends with `(lines commented)`, then ALL lines chosen
+// by the filter will be uncommented.
+package dbutil

slidge_whatsapp/vendor/go.mau.fi/util/dbutil/upgradetable.go

@@ -60,24 +60,8 @@ func (ut *UpgradeTable) Register(from, to, compat int, message string, txn TxnMo
 	(*ut)[from] = upg
 }
 
-// Syntax is either
-//
-//	-- v0 -> v1: Message
-//
-// or
-//
-//	-- v1: Message
-//
-// Both syntaxes may also have a compatibility notice before the colon:
-//
-//	-- v5 (compatible with v3+): Upgrade with backwards compatibility
 var upgradeHeaderRegex = regexp.MustCompile(`^-- (?:v(\d+) -> )?v(\d+)(?: \(compatible with v(\d+)\+\))?: (.+)$`)
 
-// To disable wrapping the upgrade in a single transaction, put `--transaction: off` on the second line.
-//
-//	-- v5: Upgrade without transaction
-//	-- transaction: off
-//	// do dangerous stuff
 var transactionDisableRegex = regexp.MustCompile(`^-- transaction: ([a-z-]*)`)
 
 func parseFileHeader(file []byte) (from, to, compat int, message string, txn TxnMode, lines [][]byte, err error) {
@@ -123,24 +107,6 @@ func parseFileHeader(file []byte) (from, to, compat int, message string, txn Txn
 	return
 }
 
-// To limit the next line to one dialect:
-//
-//	-- only: postgres
-//
-// To limit the next N lines:
-//
-//	-- only: sqlite for next 123 lines
-//
-// To limit a block of code, fenced by another directive:
-//
-//	-- only: sqlite until "end only"
-//	QUERY;
-//	ANOTHER QUERY;
-//	-- end only sqlite
-//
-// If the single-line limit is on the second line of the file, the whole file is limited to that dialect.
-//
-// If the filter ends with `(lines commented)`, then ALL lines chosen by the filter will be uncommented.
 var dialectLineFilter = regexp.MustCompile(`^\s*-- only: (postgres|sqlite)(?: for next (\d+) lines| until "(end) only")?(?: \(lines? (commented)\))?`)
 
 // Constants used to make parseDialectFilter clearer

slidge_whatsapp/vendor/go.mau.fi/util/exbytes/string.go

@@ -0,0 +1,20 @@
+// Copyright (c) 2025 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 exbytes
+
+import (
+	"unsafe"
+)
+
+// UnsafeString returns a string that points to the same memory as the input byte slice.
+//
+// The input byte slice must not be modified after this function is called.
+//
+// See [go.mau.fi/util/exstrings.UnsafeBytes] for the reverse operation.
+func UnsafeString(b []byte) string {
+	return unsafe.String(unsafe.SliceData(b), len(b))
+}

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

@@ -0,0 +1,78 @@
+// 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 exbytes
+
+import (
+	"errors"
+	"fmt"
+	"io"
+)
+
+// Writer is a simple byte writer that does not allow extending the buffer.
+//
+// Writes always go after the current len() and will fail if the slice capacity is too low.
+//
+// The correct way to use this is to create a slice with sufficient capacity and zero length:
+//
+//	x := make([]byte, 0, 11)
+//	w := (*Writer)(&x)
+//	w.Write([]byte("hello"))
+//	w.WriteByte(' ')
+//	w.WriteString("world")
+//	fmt.Println(string(x)) // "hello world"
+type Writer []byte
+
+var ErrWriterBufferFull = errors.New("exbytes.Writer: buffer full")
+
+var (
+	_ io.Writer       = (*Writer)(nil)
+	_ io.StringWriter = (*Writer)(nil)
+	_ io.ByteWriter   = (*Writer)(nil)
+)
+
+func (w *Writer) extendLen(n int) (int, error) {
+	ptr := len(*w)
+	if ptr+n > cap(*w) {
+		return 0, fmt.Errorf("%w (%d + %d > %d)", ErrWriterBufferFull, ptr, n, cap(*w))
+	}
+	*w = (*w)[:ptr+n]
+	return ptr, nil
+}
+
+func (w *Writer) Write(b []byte) (n int, err error) {
+	ptr, err := w.extendLen(len(b))
+	if err != nil {
+		return 0, err
+	}
+	copy((*w)[ptr:], b)
+	return len(b), nil
+}
+
+func (w *Writer) WriteString(s string) (n int, err error) {
+	ptr, err := w.extendLen(len(s))
+	if err != nil {
+		return 0, err
+	}
+	copy((*w)[ptr:], s)
+	return len(s), nil
+}
+
+func (w *Writer) WriteByte(r byte) error {
+	ptr, err := w.extendLen(1)
+	if err != nil {
+		return err
+	}
+	(*w)[ptr] = r
+	return nil
+}
+
+func (w *Writer) String() string {
+	if w == nil {
+		return "<nil>"
+	}
+	return string(*w)
+}

slidge_whatsapp/vendor/go.mau.fi/util/exslices/cast.go

@@ -0,0 +1,42 @@
+// 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 exslices
+
+func CastFunc[To, From any](source []From, conv func(From) To) []To {
+	result := make([]To, len(source))
+	for i, v := range source {
+		result[i] = conv(v)
+	}
+	return result
+}
+
+func CastFuncFilter[To, From any](source []From, conv func(From) (To, bool)) []To {
+	result := make([]To, 0, len(source))
+	for _, v := range source {
+		res, ok := conv(v)
+		if ok {
+			result = append(result, res)
+		}
+	}
+	return result
+}
+
+func CastToString[To, From ~string](source []From) []To {
+	result := make([]To, len(source))
+	for i, v := range source {
+		result[i] = To(v)
+	}
+	return result
+}
+
+func CastToAny[From any](source []From) []any {
+	result := make([]any, len(source))
+	for i, v := range source {
+		result[i] = v
+	}
+	return result
+}

slidge_whatsapp/vendor/go.mau.fi/util/exslices/chunk.go

@@ -0,0 +1,28 @@
+// 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 exslices
+
+// Chunk splits a slice into chunks of the given size.
+//
+// From https://github.com/golang/go/issues/53987#issuecomment-1224367139
+//
+// TODO remove this after slices.Chunk can be used (it'll probably be added in Go 1.23, so it can be used after 1.22 is EOL)
+func Chunk[T any](slice []T, size int) (chunks [][]T) {
+	if size < 1 {
+		panic("chunk size cannot be less than 1")
+	}
+	for i := 0; ; i++ {
+		next := i * size
+		if len(slice[next:]) > size {
+			end := next + size
+			chunks = append(chunks, slice[next:end:end])
+		} else {
+			chunks = append(chunks, slice[i*size:])
+			return
+		}
+	}
+}

slidge_whatsapp/vendor/go.mau.fi/util/exslices/deduplicate.go

@@ -0,0 +1,67 @@
+// 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 exslices
+
+// DeduplicateUnsorted removes duplicates from the given slice without requiring that the input slice is sorted.
+// The order of the output will be the same as the input. The input slice will not be modified.
+//
+// If you don't care about the order of the output, it's recommended to sort the list and then use [slices.Compact].
+func DeduplicateUnsorted[T comparable](s []T) []T {
+	return deduplicateUnsortedInto(s, make([]T, 0, len(s)))
+}
+
+// DeduplicateUnsortedOverwrite removes duplicates from the given slice without requiring that the input slice is sorted.
+// The input slice will be modified and used as the output slice to avoid extra allocations.
+//
+// If you don't care about the order of the output, it's recommended to sort the list and then use [slices.Compact].
+func DeduplicateUnsortedOverwrite[T comparable](s []T) []T {
+	out := deduplicateUnsortedInto(s, s[:0])
+	clear(s[len(out):])
+	return out
+}
+
+func deduplicateUnsortedInto[T comparable](s, result []T) []T {
+	seen := make(map[T]struct{}, len(s))
+	for _, item := range s {
+		if _, ok := seen[item]; !ok {
+			seen[item] = struct{}{}
+			result = append(result, item)
+		}
+	}
+	return result
+}
+
+// DeduplicateUnsortedFunc removes duplicates from the given slice using the given key function without requiring
+// that the input slice is sorted. The order of the output will be the same as the input.
+//
+// If you don't care about the order of the output, it's recommended to sort the list and then use [slices.CompactFunc].
+func DeduplicateUnsortedFunc[T any, K comparable](s []T, getKey func(T) K) []T {
+	return deduplicateUnsortedFuncInto(s, make([]T, 0, len(s)), getKey)
+}
+
+// DeduplicateUnsortedOverwriteFunc removes duplicates from the given slice using the given key function
+// without requiring that the input slice is sorted. The order of the output will be the same as the input.
+// The input slice will be modified and used as the output slice to avoid extra allocations.
+//
+// If you don't care about the order of the output, it's recommended to sort the list and then use [slices.CompactFunc].
+func DeduplicateUnsortedOverwriteFunc[T any, K comparable](s []T, getKey func(T) K) []T {
+	out := deduplicateUnsortedFuncInto(s, s[:0], getKey)
+	clear(s[len(out):])
+	return out
+}
+
+func deduplicateUnsortedFuncInto[T any, K comparable](s, result []T, getKey func(T) K) []T {
+	seen := make(map[K]struct{}, len(s))
+	for _, item := range s {
+		key := getKey(item)
+		if _, ok := seen[key]; !ok {
+			seen[key] = struct{}{}
+			result = append(result, item)
+		}
+	}
+	return result
+}

slidge_whatsapp/vendor/go.mau.fi/util/exslices/diff.go

@@ -0,0 +1,63 @@
+// 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 exslices
+
+// SortedDiff returns the difference between two already-sorted slices, with the help of the given comparison function.
+// The output will be in the same order as the input, which means it'll be sorted.
+func SortedDiff[T any](a, b []T, compare func(a, b T) int) (uniqueToA, uniqueToB []T) {
+	uniqueToA = make([]T, 0, len(a))
+	uniqueToB = make([]T, 0, len(b))
+
+	var i, j int
+	for {
+		if j >= len(b) {
+			uniqueToA = append(uniqueToA, a[i:]...)
+			break
+		} else if i >= len(a) {
+			uniqueToB = append(uniqueToB, b[j:]...)
+			break
+		}
+		c := compare(a[i], b[j])
+		if c < 0 {
+			uniqueToA = append(uniqueToA, a[i])
+			i++
+		} else if c > 0 {
+			uniqueToB = append(uniqueToB, b[j])
+			j++
+		} else {
+			i++
+			j++
+		}
+	}
+	return
+}
+
+// Diff returns the difference between two slices. The slices may contain duplicates and don't need to be sorted.
+// The output will not be sorted, but is guaranteed to not contain any duplicates.
+func Diff[T comparable](a, b []T) (uniqueToA, uniqueToB []T) {
+	maxLen := len(a)
+	if len(b) > maxLen {
+		maxLen = len(b)
+	}
+	collector := make(map[T]uint8, maxLen)
+	for _, item := range a {
+		collector[item] |= 0b01
+	}
+	for _, item := range b {
+		collector[item] |= 0b10
+	}
+	uniqueToA = make([]T, 0, maxLen)
+	uniqueToB = make([]T, 0, maxLen)
+	for item, mask := range collector {
+		if mask == 0b01 {
+			uniqueToA = append(uniqueToA, item)
+		} else if mask == 0b10 {
+			uniqueToB = append(uniqueToB, item)
+		}
+	}
+	return
+}

slidge_whatsapp/vendor/go.mau.fi/util/exsync/event.go

@@ -8,6 +8,7 @@ package exsync
 
 import (
 	"context"
+	"fmt"
 	"sync"
 	"time"
 )
@@ -50,7 +51,7 @@ func (e *Event) Wait(ctx context.Context) error {
 	}
 }
 
-// WaitTimeout waits for either the event to happen within the given timeout.
+// WaitTimeout waits for the event to happen within the given timeout.
 // If the timeout expires first, the return value is false, otherwise it's true.
 func (e *Event) WaitTimeout(timeout time.Duration) bool {
 	select {
@@ -61,6 +62,19 @@ func (e *Event) WaitTimeout(timeout time.Duration) bool {
 	}
 }
 
+// WaitTimeoutCtx waits for the event to happen, the timeout to expire, or the given context to be done.
+// If the context or timeout is done first, an error is returned, otherwise the return value is nil.
+func (e *Event) WaitTimeoutCtx(ctx context.Context, timeout time.Duration) error {
+	select {
+	case <-e.GetChan():
+		return nil
+	case <-ctx.Done():
+		return ctx.Err()
+	case <-time.After(timeout):
+		return fmt.Errorf("exsync.Event: wait timeout")
+	}
+}
+
 // IsSet returns true if the event has been set.
 func (e *Event) IsSet() bool {
 	e.l.RLock()

slidge_whatsapp/vendor/go.mau.fi/util/random/string.go

@@ -1,4 +1,4 @@
-// Copyright (c) 2023 Tulir Asokan
+// Copyright (c) 2025 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
@@ -10,20 +10,52 @@ import (
 	"encoding/binary"
 	"hash/crc32"
 	"strings"
-	"unsafe"
+
+	"go.mau.fi/util/exbytes"
 )
 
 const letters = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
 
 // StringBytes generates a random string of the given length and returns it as a byte array.
 func StringBytes(n int) []byte {
+	return StringBytesCharset(n, letters)
+}
+
+// AppendSequence generates a random sequence of the given length using the given character set
+// and appends it to the given output slice.
+func AppendSequence[T any](n int, charset, output []T) []T {
+	if n <= 0 {
+		return output
+	}
+	if output == nil {
+		output = make([]T, 0, n)
+	}
+	// If risk of modulo bias is too high, use 32-bit integers as source instead of 16-bit.
+	if 65536%len(charset) < 200 {
+		input := Bytes(n * 2)
+		for i := 0; i < n; i++ {
+			output = append(output, charset[binary.BigEndian.Uint16(input[i*2:])%uint16(len(charset))])
+		}
+	} else {
+		input := Bytes(n * 4)
+		for i := 0; i < n; i++ {
+			output = append(output, charset[binary.BigEndian.Uint32(input[i*4:])%uint32(len(charset))])
+		}
+	}
+	return output
+}
+
+// StringBytesCharset generates a random string of the given length using the given character set and returns it as a byte array.
+// Note that the character set must be ASCII. For arbitrary Unicode, use [AppendSequence] with a `[]rune`.
+func StringBytesCharset(n int, charset string) []byte {
 	if n <= 0 {
 		return []byte{}
 	}
 	input := Bytes(n * 2)
 	for i := 0; i < n; i++ {
-		// Risk of modulo bias is only 2 in 65535, values between 0 and 65533 are uniformly distributed
-		input[i] = letters[binary.BigEndian.Uint16(input[i*2:])%uint16(len(letters))]
+		// The risk of modulo bias is (65536 % len(charset)) / 65536.
+		// For the default charset, that's 2 in 65536 or 0.003 %.
+		input[i] = charset[binary.BigEndian.Uint16(input[i*2:])%uint16(len(charset))]
 	}
 	input = input[:n]
 	return input
@@ -34,8 +66,16 @@ func String(n int) string {
 	if n <= 0 {
 		return ""
 	}
-	str := StringBytes(n)
-	return *(*string)(unsafe.Pointer(&str))
+	return exbytes.UnsafeString(StringBytes(n))
+}
+
+// StringCharset generates a random string of the given length using the given character set.
+// Note that the character set must be ASCII. For arbitrary Unicode, use [AppendSequence] with a `[]rune`.
+func StringCharset(n int, charset string) string {
+	if n <= 0 {
+		return ""
+	}
+	return exbytes.UnsafeString(StringBytesCharset(n, charset))
 }
 
 func base62Encode(val uint32, minWidth int) []byte {
@@ -65,7 +105,7 @@ func Token(namespace string, randomLength int) string {
 	token[len(namespace)+randomLength+1] = '_'
 	checksum := base62Encode(crc32.ChecksumIEEE(token[:len(token)-7]), 6)
 	copy(token[len(token)-6:], checksum)
-	return *(*string)(unsafe.Pointer(&token))
+	return exbytes.UnsafeString(token)
 }
 
 // GetTokenPrefix parses the given token generated with Token, validates the checksum and returns the prefix namespace.

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

@@ -166,6 +166,7 @@ func (proc *Processor) decodeMutations(ctx context.Context, mutations []*waServe
 		out.Mutations = append(out.Mutations, Mutation{
 			Operation: mutation.GetOperation(),
 			Action:    syncAction.GetValue(),
+			Version:   syncAction.GetVersion(),
 			Index:     index,
 			IndexMAC:  indexMAC,
 			ValueMAC:  valueMAC,

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

@@ -45,7 +45,11 @@ func BuildMute(target types.JID, mute bool, muteDuration time.Duration) PatchInf
 	if muteDuration > 0 {
 		muteEndTimestamp = proto.Int64(time.Now().Add(muteDuration).UnixMilli())
 	}
+	return BuildMuteAbs(target, mute, muteEndTimestamp)
+}
 
+// BuildMuteAbs builds an app state patch for muting or unmuting a chat with an absolute timestamp.
+func BuildMuteAbs(target types.JID, mute bool, muteEndTimestamp *int64) PatchInfo {
 	return PatchInfo{
 		Type: WAPatchRegularHigh,
 		Mutations: []MutationInfo{{
@@ -126,6 +130,36 @@ func BuildArchive(target types.JID, archive bool, lastMessageTimestamp time.Time
 	return result
 }
 
+// BuildMarkChatAsRead builds an app state patch for marking a chat as read or unread.
+func BuildMarkChatAsRead(target types.JID, read bool, lastMessageTimestamp time.Time, lastMessageKey *waCommon.MessageKey) PatchInfo {
+	if lastMessageTimestamp.IsZero() {
+		lastMessageTimestamp = time.Now()
+	}
+	action := &waSyncAction.MarkChatAsReadAction{
+		Read: proto.Bool(read),
+		MessageRange: &waSyncAction.SyncActionMessageRange{
+			LastMessageTimestamp: proto.Int64(lastMessageTimestamp.Unix()),
+		},
+	}
+	if lastMessageKey != nil {
+		action.MessageRange.Messages = []*waSyncAction.SyncActionMessage{{
+			Key:       lastMessageKey,
+			Timestamp: proto.Int64(lastMessageTimestamp.Unix()),
+		}}
+	}
+
+	return PatchInfo{
+		Type: WAPatchRegularLow,
+		Mutations: []MutationInfo{{
+			Index:   []string{IndexMarkChatAsRead, target.String()},
+			Version: 3,
+			Value: &waSyncAction.SyncActionValue{
+				MarkChatAsReadAction: action,
+			},
+		}},
+	}
+}
+
 func newLabelChatMutation(target types.JID, labelID string, labeled bool) MutationInfo {
 	return MutationInfo{
 		Index:   []string{IndexLabelAssociationChat, labelID, target.String()},

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

@@ -22,6 +22,7 @@ import (
 type Mutation struct {
 	Operation waServerSync.SyncdMutation_SyncdOperation
 	Action    *waSyncAction.SyncActionValue
+	Version   int32
 	Index     []string
 	IndexMAC  []byte
 	ValueMAC  []byte