slidge-whatsapp 0.3.0b0__cp312-cp312-manylinux_2_36_aarch64.whl → 0.3.4__cp312-cp312-manylinux_2_36_aarch64.whl

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/store/noop.go

@@ -68,10 +68,18 @@ func (n *NoopStore) HasSession(ctx context.Context, address string) (bool, error
 	return false, n.Error
 }
 
+func (n *NoopStore) GetManySessions(ctx context.Context, addresses []string) (map[string][]byte, error) {
+	return nil, n.Error
+}
+
 func (n *NoopStore) PutSession(ctx context.Context, address string, session []byte) error {
 	return n.Error
 }
 
+func (n *NoopStore) PutManySessions(ctx context.Context, sessions map[string][]byte) error {
+	return n.Error
+}
+
 func (n *NoopStore) DeleteAllSessions(ctx context.Context, phone string) error {
 	return n.Error
 }
@@ -168,6 +176,10 @@ func (n *NoopStore) PutAllContactNames(ctx context.Context, contacts []ContactEn
 	return n.Error
 }
 
+func (n *NoopStore) PutManyRedactedPhones(ctx context.Context, entries []RedactedPhoneEntry) error {
+	return n.Error
+}
+
 func (n *NoopStore) GetContact(ctx context.Context, user types.JID) (types.ContactInfo, error) {
 	return types.ContactInfo{}, n.Error
 }
@@ -244,6 +256,10 @@ func (n *NoopStore) GetLIDForPN(ctx context.Context, pn types.JID) (types.JID, e
 	return types.JID{}, n.Error
 }
 
+func (n *NoopStore) GetManyLIDsForPNs(ctx context.Context, pns []types.JID) (map[types.JID]types.JID, error) {
+	return nil, n.Error
+}
+
 func (n *NoopStore) GetPNForLID(ctx context.Context, lid types.JID) (types.JID, error) {
 	return types.JID{}, n.Error
 }

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/store/sessioncache.go

@@ -0,0 +1,125 @@
+// 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 store
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/rs/zerolog"
+	"go.mau.fi/libsignal/state/record"
+
+	"go.mau.fi/util/exsync"
+)
+
+type contextKey int
+
+const (
+	contextKeySessionCache contextKey = iota
+)
+
+type sessionCacheEntry struct {
+	Dirty  bool
+	Found  bool
+	Record *record.Session
+}
+
+type sessionCache = exsync.Map[string, sessionCacheEntry]
+
+func getSessionCache(ctx context.Context) *sessionCache {
+	if ctx == nil {
+		return nil
+	}
+	val := ctx.Value(contextKeySessionCache)
+	if val == nil {
+		return nil
+	}
+	if cache, ok := val.(*sessionCache); ok {
+		return cache
+	}
+	return nil
+}
+
+func getCachedSession(ctx context.Context, addr string) *record.Session {
+	cache := getSessionCache(ctx)
+	if cache == nil {
+		return nil
+	}
+	sess, ok := cache.Get(addr)
+	if !ok {
+		return nil
+	}
+	return sess.Record
+}
+
+func putCachedSession(ctx context.Context, addr string, record *record.Session) bool {
+	cache := getSessionCache(ctx)
+	if cache == nil {
+		return false
+	}
+	cache.Set(addr, sessionCacheEntry{
+		Dirty:  true,
+		Found:  true,
+		Record: record,
+	})
+	return true
+}
+
+func (device *Device) WithCachedSessions(ctx context.Context, addresses []string) (map[string]bool, context.Context, error) {
+	if len(addresses) == 0 {
+		return nil, ctx, nil
+	}
+
+	sessions, err := device.Sessions.GetManySessions(ctx, addresses)
+	if err != nil {
+		return nil, ctx, fmt.Errorf("failed to prefetch sessions: %w", err)
+	}
+	wrapped := make(map[string]sessionCacheEntry, len(sessions))
+	existingSessions := make(map[string]bool, len(sessions))
+	for addr, rawSess := range sessions {
+		var sessionRecord *record.Session
+		var found bool
+		if rawSess == nil {
+			sessionRecord = record.NewSession(SignalProtobufSerializer.Session, SignalProtobufSerializer.State)
+		} else {
+			found = true
+			sessionRecord, err = record.NewSessionFromBytes(rawSess, SignalProtobufSerializer.Session, SignalProtobufSerializer.State)
+			if err != nil {
+				zerolog.Ctx(ctx).Err(err).
+					Str("address", addr).
+					Msg("Failed to deserialize session")
+				continue
+			}
+		}
+		existingSessions[addr] = found
+		wrapped[addr] = sessionCacheEntry{Record: sessionRecord, Found: found}
+	}
+
+	ctx = context.WithValue(ctx, contextKeySessionCache, (*sessionCache)(exsync.NewMapWithData(wrapped)))
+	return existingSessions, ctx, nil
+}
+
+func (device *Device) PutCachedSessions(ctx context.Context) error {
+	cache := getSessionCache(ctx)
+	if cache == nil {
+		return nil
+	}
+	dirtySessions := make(map[string][]byte)
+	for addr, item := range cache.Iter() {
+		if item.Dirty {
+			dirtySessions[addr] = item.Record.Serialize()
+		}
+	}
+	if len(dirtySessions) > 0 {
+		err := device.Sessions.PutManySessions(ctx, dirtySessions)
+		if err != nil {
+			return fmt.Errorf("failed to store cached sessions: %w", err)
+		}
+	}
+	cache.Clear()
+	return nil
+}

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/store/signal.go

@@ -84,6 +84,10 @@ func (device *Device) ContainsPreKey(ctx context.Context, preKeyID uint32) (bool
 
 func (device *Device) LoadSession(ctx context.Context, address *protocol.SignalAddress) (*record.Session, error) {
 	addrString := address.String()
+	if sess := getCachedSession(ctx, addrString); sess != nil {
+		return sess, nil
+	}
+
 	rawSess, err := device.Sessions.GetSession(ctx, addrString)
 	if err != nil {
 		return nil, fmt.Errorf("failed to load session with %s: %w", addrString, err)
@@ -104,6 +108,10 @@ func (device *Device) GetSubDeviceSessions(ctx context.Context, name string) ([]
 
 func (device *Device) StoreSession(ctx context.Context, address *protocol.SignalAddress, record *record.Session) error {
 	addrString := address.String()
+	if putCachedSession(ctx, addrString, record) {
+		return nil
+	}
+
 	err := device.Sessions.PutSession(ctx, addrString, record.Serialize())
 	if err != nil {
 		return fmt.Errorf("failed to store session with %s: %w", addrString, err)

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/store/sqlstore/lidmap.go

@@ -13,10 +13,12 @@ import (
 	"errors"
 	"fmt"
 	"slices"
+	"strings"
 	"sync"
 
 	"github.com/rs/zerolog"
 	"go.mau.fi/util/dbutil"
+	"go.mau.fi/util/exslices"
 
 	"go.mau.fi/whatsmeow/store"
 	"go.mau.fi/whatsmeow/types"
@@ -61,18 +63,30 @@ func (s *CachedLIDMap) FillCache(ctx context.Context) error {
 	if err != nil {
 		return err
 	}
-	defer rows.Close()
+	err = s.scanManyLids(rows, nil)
+	s.cacheFilled = err == nil
+	return err
+}
+
+func (s *CachedLIDMap) scanManyLids(rows dbutil.Rows, fn func(lid, pn string)) error {
+	if fn == nil {
+		fn = func(lid, pn string) {}
+	}
 	for rows.Next() {
 		var lid, pn string
-		err = rows.Scan(&lid, &pn)
+		err := rows.Scan(&lid, &pn)
 		if err != nil {
 			return err
 		}
 		s.pnToLIDCache[pn] = lid
 		s.lidToPNCache[lid] = pn
+		fn(lid, pn)
 	}
-	s.cacheFilled = true
-	return nil
+	err := rows.Close()
+	if err != nil {
+		return err
+	}
+	return rows.Err()
 }
 
 func (s *CachedLIDMap) getLIDMapping(ctx context.Context, source types.JID, targetServer, query string, sourceToTarget, targetToSource map[string]string) (types.JID, error) {
@@ -122,6 +136,69 @@ func (s *CachedLIDMap) GetPNForLID(ctx context.Context, lid types.JID) (types.JI
 	)
 }
 
+func (s *CachedLIDMap) GetManyLIDsForPNs(ctx context.Context, pns []types.JID) (map[types.JID]types.JID, error) {
+	if len(pns) == 0 {
+		return nil, nil
+	}
+
+	result := make(map[types.JID]types.JID, len(pns))
+
+	s.lidCacheLock.RLock()
+	missingPNs := make([]string, 0, len(pns))
+	missingPNDevices := make(map[string][]types.JID)
+	for _, pn := range pns {
+		if pn.Server != types.DefaultUserServer {
+			continue
+		}
+		if lidUser, ok := s.pnToLIDCache[pn.User]; ok && lidUser != "" {
+			result[pn] = types.JID{User: lidUser, Device: pn.Device, Server: types.HiddenUserServer}
+		} else if !s.cacheFilled {
+			missingPNs = append(missingPNs, pn.User)
+			missingPNDevices[pn.User] = append(missingPNDevices[pn.User], pn)
+		}
+	}
+	s.lidCacheLock.RUnlock()
+
+	if len(missingPNs) == 0 {
+		return result, nil
+	}
+
+	s.lidCacheLock.Lock()
+	defer s.lidCacheLock.Unlock()
+
+	var rows dbutil.Rows
+	var err error
+	if s.db.Dialect == dbutil.Postgres && PostgresArrayWrapper != nil {
+		rows, err = s.db.Query(
+			ctx,
+			`SELECT lid, pn FROM whatsmeow_lid_map WHERE pn = ANY($1)`,
+			PostgresArrayWrapper(missingPNs),
+		)
+	} else {
+		placeholders := make([]string, len(missingPNs))
+		for i := range missingPNs {
+			placeholders[i] = fmt.Sprintf("$%d", i+1)
+		}
+		rows, err = s.db.Query(
+			ctx,
+			fmt.Sprintf(`SELECT lid, pn FROM whatsmeow_lid_map WHERE pn IN (%s)`, strings.Join(placeholders, ",")),
+			exslices.CastToAny(missingPNs)...,
+		)
+	}
+	if err != nil {
+		return nil, err
+	}
+	err = s.scanManyLids(rows, func(lid, pn string) {
+		for _, dev := range missingPNDevices[pn] {
+			lidDev := dev
+			lidDev.Server = types.HiddenUserServer
+			lidDev.User = lid
+			result[dev] = lidDev.ToNonAD()
+		}
+	})
+	return result, err
+}
+
 func (s *CachedLIDMap) PutLIDMapping(ctx context.Context, lid, pn types.JID) error {
 	if lid.Server != types.HiddenUserServer || pn.Server != types.DefaultUserServer {
 		return fmt.Errorf("invalid PutLIDMapping call %s/%s", lid, pn)
@@ -154,6 +231,7 @@ func (s *CachedLIDMap) PutManyLIDMappings(ctx context.Context, mappings []store.
 		}
 		return false
 	})
+	mappings = exslices.DeduplicateUnsortedOverwrite(mappings)
 	if len(mappings) == 0 {
 		return nil
 	}

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/store/sqlstore/store.go

@@ -19,6 +19,7 @@ import (
 	"time"
 
 	"go.mau.fi/util/dbutil"
+	"go.mau.fi/util/exslices"
 	"go.mau.fi/util/exsync"
 
 	"go.mau.fi/whatsmeow/store"
@@ -108,9 +109,11 @@ func (s *SQLStore) IsTrustedIdentity(ctx context.Context, address string, key [3
 }
 
 const (
-	getSessionQuery = `SELECT session FROM whatsmeow_sessions WHERE our_jid=$1 AND their_id=$2`
-	hasSessionQuery = `SELECT true FROM whatsmeow_sessions WHERE our_jid=$1 AND their_id=$2`
-	putSessionQuery = `
+	getSessionQuery             = `SELECT session FROM whatsmeow_sessions WHERE our_jid=$1 AND their_id=$2`
+	hasSessionQuery             = `SELECT true FROM whatsmeow_sessions WHERE our_jid=$1 AND their_id=$2`
+	getManySessionQueryPostgres = `SELECT their_id, session FROM whatsmeow_sessions WHERE our_jid=$1 AND their_id = ANY($2)`
+	getManySessionQueryGeneric  = `SELECT their_id, session FROM whatsmeow_sessions WHERE our_jid=$1 AND their_id IN (%s)`
+	putSessionQuery             = `
 		INSERT INTO whatsmeow_sessions (our_jid, their_id, session) VALUES ($1, $2, $3)
 		ON CONFLICT (our_jid, their_id) DO UPDATE SET session=excluded.session
 	`
@@ -158,6 +161,61 @@ func (s *SQLStore) HasSession(ctx context.Context, address string) (has bool, er
 	return
 }
 
+type addressSessionTuple struct {
+	Address string
+	Session []byte
+}
+
+var sessionScanner = dbutil.ConvertRowFn[addressSessionTuple](func(row dbutil.Scannable) (out addressSessionTuple, err error) {
+	err = row.Scan(&out.Address, &out.Session)
+	return
+})
+
+func (s *SQLStore) GetManySessions(ctx context.Context, addresses []string) (map[string][]byte, error) {
+	if len(addresses) == 0 {
+		return nil, nil
+	}
+
+	var rows dbutil.Rows
+	var err error
+	if s.db.Dialect == dbutil.Postgres && PostgresArrayWrapper != nil {
+		rows, err = s.db.Query(ctx, getManySessionQueryPostgres, s.JID, PostgresArrayWrapper(addresses))
+	} else {
+		args := make([]any, len(addresses)+1)
+		placeholders := make([]string, len(addresses))
+		args[0] = s.JID
+		for i, addr := range addresses {
+			args[i+1] = addr
+			placeholders[i] = fmt.Sprintf("$%d", i+2)
+		}
+		rows, err = s.db.Query(ctx, fmt.Sprintf(getManySessionQueryGeneric, strings.Join(placeholders, ",")), args...)
+	}
+	result := make(map[string][]byte, len(addresses))
+	for _, addr := range addresses {
+		result[addr] = nil
+	}
+	err = sessionScanner.NewRowIter(rows, err).Iter(func(tuple addressSessionTuple) (bool, error) {
+		result[tuple.Address] = tuple.Session
+		return true, nil
+	})
+	if err != nil {
+		return nil, err
+	}
+	return result, nil
+}
+
+func (s *SQLStore) PutManySessions(ctx context.Context, sessions map[string][]byte) error {
+	return s.db.DoTxn(ctx, nil, func(ctx context.Context) error {
+		for addr, sess := range sessions {
+			err := s.PutSession(ctx, addr, sess)
+			if err != nil {
+				return err
+			}
+		}
+		return nil
+	})
+}
+
 func (s *SQLStore) PutSession(ctx context.Context, address string, session []byte) error {
 	_, err := s.db.Exec(ctx, putSessionQuery, s.JID, address, session)
 	return err
@@ -522,10 +580,10 @@ const (
 		INSERT INTO whatsmeow_contacts (our_jid, their_jid, first_name, full_name) VALUES ($1, $2, $3, $4)
 		ON CONFLICT (our_jid, their_jid) DO UPDATE SET first_name=excluded.first_name, full_name=excluded.full_name
 	`
-	putManyContactNamesQuery = `
-		INSERT INTO whatsmeow_contacts (our_jid, their_jid, first_name, full_name)
-		VALUES %s
-		ON CONFLICT (our_jid, their_jid) DO UPDATE SET first_name=excluded.first_name, full_name=excluded.full_name
+	putRedactedPhoneQuery = `
+		INSERT INTO whatsmeow_contacts (our_jid, their_jid, redacted_phone)
+		VALUES ($1, $2, $3)
+		ON CONFLICT (our_jid, their_jid) DO UPDATE SET redacted_phone=excluded.redacted_phone
 	`
 	putPushNameQuery = `
 		INSERT INTO whatsmeow_contacts (our_jid, their_jid, push_name) VALUES ($1, $2, $3)
@@ -536,13 +594,21 @@ const (
 		ON CONFLICT (our_jid, their_jid) DO UPDATE SET business_name=excluded.business_name
 	`
 	getContactQuery = `
-		SELECT first_name, full_name, push_name, business_name FROM whatsmeow_contacts WHERE our_jid=$1 AND their_jid=$2
+		SELECT first_name, full_name, push_name, business_name, redacted_phone FROM whatsmeow_contacts WHERE our_jid=$1 AND their_jid=$2
 	`
 	getAllContactsQuery = `
-		SELECT their_jid, first_name, full_name, push_name, business_name FROM whatsmeow_contacts WHERE our_jid=$1
+		SELECT their_jid, first_name, full_name, push_name, business_name, redacted_phone FROM whatsmeow_contacts WHERE our_jid=$1
 	`
 )
 
+var putContactNamesMassInsertBuilder = dbutil.NewMassInsertBuilder[store.ContactEntry, [1]any](
+	putContactNameQuery, "($1, $%d, $%d, $%d)",
+)
+
+var putRedactedPhonesMassInsertBuilder = dbutil.NewMassInsertBuilder[store.RedactedPhoneEntry, [1]any](
+	putRedactedPhoneQuery, "($1, $%d, $%d)",
+)
+
 func (s *SQLStore) PutPushName(ctx context.Context, user types.JID, pushName string) (bool, string, error) {
 	s.contactCacheLock.Lock()
 	defer s.contactCacheLock.Unlock()
@@ -607,44 +673,21 @@ func (s *SQLStore) PutContactName(ctx context.Context, user types.JID, firstName
 
 const contactBatchSize = 300
 
-func (s *SQLStore) putContactNamesBatch(ctx context.Context, contacts []store.ContactEntry) error {
-	values := make([]any, 1, 1+len(contacts)*3)
-	queryParts := make([]string, 0, len(contacts))
-	values[0] = s.JID
-	placeholderSyntax := "($1, $%d, $%d, $%d)"
-	if s.db.Dialect == dbutil.SQLite {
-		placeholderSyntax = "(?1, ?%d, ?%d, ?%d)"
-	}
-	i := 0
-	handledContacts := make(map[types.JID]struct{}, len(contacts))
-	for _, contact := range contacts {
-		if contact.JID.IsEmpty() {
-			s.log.Warnf("Empty contact info in mass insert: %+v", contact)
-			continue
-		}
-		// The whole query will break if there are duplicates, so make sure there aren't any duplicates
-		_, alreadyHandled := handledContacts[contact.JID]
-		if alreadyHandled {
-			s.log.Warnf("Duplicate contact info for %s in mass insert", contact.JID)
-			continue
-		}
-		handledContacts[contact.JID] = struct{}{}
-		baseIndex := i*3 + 1
-		values = append(values, contact.JID.String(), contact.FirstName, contact.FullName)
-		queryParts = append(queryParts, fmt.Sprintf(placeholderSyntax, baseIndex+1, baseIndex+2, baseIndex+3))
-		i++
-	}
-	_, err := s.db.Exec(ctx, fmt.Sprintf(putManyContactNamesQuery, strings.Join(queryParts, ",")), values...)
-	return err
-}
-
 func (s *SQLStore) PutAllContactNames(ctx context.Context, contacts []store.ContactEntry) error {
 	if len(contacts) == 0 {
 		return nil
 	}
+	origLen := len(contacts)
+	contacts = exslices.DeduplicateUnsortedOverwriteFunc(contacts, func(t store.ContactEntry) types.JID {
+		return t.JID
+	})
+	if origLen != len(contacts) {
+		s.log.Warnf("%d duplicate contacts found in PutAllContactNames", origLen-len(contacts))
+	}
 	err := s.db.DoTxn(ctx, nil, func(ctx context.Context) error {
 		for slice := range slices.Chunk(contacts, contactBatchSize) {
-			err := s.putContactNamesBatch(ctx, slice)
+			query, vars := putContactNamesMassInsertBuilder.Build([1]any{s.JID}, slice)
+			_, err := s.db.Exec(ctx, query, vars...)
 			if err != nil {
 				return err
 			}
@@ -661,23 +704,59 @@ func (s *SQLStore) PutAllContactNames(ctx context.Context, contacts []store.Cont
 	return nil
 }
 
+func (s *SQLStore) PutManyRedactedPhones(ctx context.Context, entries []store.RedactedPhoneEntry) error {
+	if len(entries) == 0 {
+		return nil
+	}
+	origLen := len(entries)
+	entries = exslices.DeduplicateUnsortedOverwriteFunc(entries, func(t store.RedactedPhoneEntry) types.JID {
+		return t.JID
+	})
+	if origLen != len(entries) {
+		s.log.Warnf("%d duplicate contacts found in PutManyRedactedPhones", origLen-len(entries))
+	}
+	err := s.db.DoTxn(ctx, nil, func(ctx context.Context) error {
+		for slice := range slices.Chunk(entries, contactBatchSize) {
+			query, vars := putRedactedPhonesMassInsertBuilder.Build([1]any{s.JID}, slice)
+			_, err := s.db.Exec(ctx, query, vars...)
+			if err != nil {
+				return err
+			}
+		}
+		return nil
+	})
+	if err != nil {
+		return err
+	}
+	s.contactCacheLock.Lock()
+	for _, entry := range entries {
+		if cached, ok := s.contactCache[entry.JID]; ok && cached.RedactedPhone == entry.RedactedPhone {
+			continue
+		}
+		delete(s.contactCache, entry.JID)
+	}
+	s.contactCacheLock.Unlock()
+	return nil
+}
+
 func (s *SQLStore) getContact(ctx context.Context, user types.JID) (*types.ContactInfo, error) {
 	cached, ok := s.contactCache[user]
 	if ok {
 		return cached, nil
 	}
 
-	var first, full, push, business sql.NullString
-	err := s.db.QueryRow(ctx, getContactQuery, s.JID, user).Scan(&first, &full, &push, &business)
+	var first, full, push, business, redactedPhone sql.NullString
+	err := s.db.QueryRow(ctx, getContactQuery, s.JID, user).Scan(&first, &full, &push, &business, &redactedPhone)
 	if err != nil && !errors.Is(err, sql.ErrNoRows) {
 		return nil, err
 	}
 	info := &types.ContactInfo{
-		Found:        err == nil,
-		FirstName:    first.String,
-		FullName:     full.String,
-		PushName:     push.String,
-		BusinessName: business.String,
+		Found:         err == nil,
+		FirstName:     first.String,
+		FullName:      full.String,
+		PushName:      push.String,
+		BusinessName:  business.String,
+		RedactedPhone: redactedPhone.String,
 	}
 	s.contactCache[user] = info
 	return info, nil
@@ -703,17 +782,18 @@ func (s *SQLStore) GetAllContacts(ctx context.Context) (map[types.JID]types.Cont
 	output := make(map[types.JID]types.ContactInfo, len(s.contactCache))
 	for rows.Next() {
 		var jid types.JID
-		var first, full, push, business sql.NullString
-		err = rows.Scan(&jid, &first, &full, &push, &business)
+		var first, full, push, business, redactedPhone sql.NullString
+		err = rows.Scan(&jid, &first, &full, &push, &business, &redactedPhone)
 		if err != nil {
 			return nil, fmt.Errorf("error scanning row: %w", err)
 		}
 		info := types.ContactInfo{
-			Found:        true,
-			FirstName:    first.String,
-			FullName:     full.String,
-			PushName:     push.String,
-			BusinessName: business.String,
+			Found:         true,
+			FirstName:     first.String,
+			FullName:      full.String,
+			PushName:      push.String,
+			BusinessName:  business.String,
+			RedactedPhone: redactedPhone.String,
 		}
 		output[jid] = info
 		s.contactCache[jid] = &info

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/store/sqlstore/upgrades/00-latest-schema.sql

@@ -1,4 +1,4 @@
--- v0 -> v10 (compatible with v8+): Latest schema
+-- v0 -> v11 (compatible with v8+): Latest schema
 CREATE TABLE whatsmeow_device (
 	jid TEXT PRIMARY KEY,
 	lid TEXT,
@@ -98,12 +98,13 @@ CREATE TABLE whatsmeow_app_state_mutation_macs (
 );
 
 CREATE TABLE whatsmeow_contacts (
-	our_jid       TEXT,
-	their_jid     TEXT,
-	first_name    TEXT,
-	full_name     TEXT,
-	push_name     TEXT,
-	business_name TEXT,
+	our_jid        TEXT,
+	their_jid      TEXT,
+	first_name     TEXT,
+	full_name      TEXT,
+	push_name      TEXT,
+	business_name  TEXT,
+	redacted_phone TEXT,
 
 	PRIMARY KEY (our_jid, their_jid),
 	FOREIGN KEY (our_jid) REFERENCES whatsmeow_device(jid) ON DELETE CASCADE ON UPDATE CASCADE

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/store/sqlstore/upgrades/11-redacted-phone-contacts.sql

@@ -0,0 +1,2 @@
+-- v11 (compatible with v8+): Store redacted phone number for LID members in groups
+ALTER TABLE whatsmeow_contacts ADD COLUMN redacted_phone TEXT;

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

@@ -29,7 +29,9 @@ type IdentityStore interface {
 type SessionStore interface {
 	GetSession(ctx context.Context, address string) ([]byte, error)
 	HasSession(ctx context.Context, address string) (bool, error)
+	GetManySessions(ctx context.Context, addresses []string) (map[string][]byte, error)
 	PutSession(ctx context.Context, address string, session []byte) error
+	PutManySessions(ctx context.Context, sessions map[string][]byte) error
 	DeleteAllSessions(ctx context.Context, phone string) error
 	DeleteSession(ctx context.Context, address string) error
 	MigratePNToLID(ctx context.Context, pn, lid types.JID) error
@@ -82,11 +84,25 @@ type ContactEntry struct {
 	FullName  string
 }
 
+func (ce ContactEntry) GetMassInsertValues() [3]any {
+	return [...]any{ce.JID.String(), ce.FirstName, ce.FullName}
+}
+
+type RedactedPhoneEntry struct {
+	JID           types.JID
+	RedactedPhone string
+}
+
+func (rpe RedactedPhoneEntry) GetMassInsertValues() [2]any {
+	return [...]any{rpe.JID.String(), rpe.RedactedPhone}
+}
+
 type ContactStore interface {
 	PutPushName(ctx context.Context, user types.JID, pushName string) (bool, string, error)
 	PutBusinessName(ctx context.Context, user types.JID, businessName string) (bool, string, error)
 	PutContactName(ctx context.Context, user types.JID, fullName, firstName string) error
 	PutAllContactNames(ctx context.Context, contacts []ContactEntry) error
+	PutManyRedactedPhones(ctx context.Context, entries []RedactedPhoneEntry) error
 	GetContact(ctx context.Context, user types.JID) (types.ContactInfo, error)
 	GetAllContacts(ctx context.Context) (map[types.JID]types.ContactInfo, error)
 }
@@ -148,11 +164,16 @@ type LIDMapping struct {
 	PN  types.JID
 }
 
+func (lm LIDMapping) GetMassInsertValues() [2]any {
+	return [...]any{lm.LID.User, lm.PN.User}
+}
+
 type LIDStore interface {
 	PutManyLIDMappings(ctx context.Context, mappings []LIDMapping) error
 	PutLIDMapping(ctx context.Context, lid, jid types.JID) error
 	GetPNForLID(ctx context.Context, lid types.JID) (types.JID, error)
 	GetLIDForPN(ctx context.Context, pn types.JID) (types.JID, error)
+	GetManyLIDsForPNs(ctx context.Context, pns []types.JID) (map[types.JID]types.JID, error)
 }
 
 type AllSessionSpecificStores interface {
@@ -187,8 +208,9 @@ type Device struct {
 	RegistrationID uint32
 	AdvSecretKey   []byte
 
-	ID           *types.JID
-	LID          types.JID
+	ID  *types.JID
+	LID types.JID
+
 	Account      *waAdv.ADVSignedDeviceIdentity
 	Platform     string
 	BusinessName string

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

@@ -9,11 +9,12 @@ package types
 import "time"
 
 type BasicCallMeta struct {
-	From        JID
-	Timestamp   time.Time
-	CallCreator JID
-	CallID      string
-	GroupJID    JID
+	From           JID
+	Timestamp      time.Time
+	CallCreator    JID
+	CallCreatorAlt JID
+	CallID         string
+	GroupJID       JID
 }
 
 type CallRemoteMeta struct {