slidge-whatsapp 0.3.1__cp312-cp312-manylinux_2_36_aarch64.whl → 0.3.4__cp312-cp312-manylinux_2_36_aarch64.whl

slidge_whatsapp/vendor/go.mau.fi/util/jsontime/helpers.go

@@ -10,12 +10,19 @@ import (
 	"time"
 )
 
+func zeroSafeUnixToTime(val int64, fn func(int64) time.Time) time.Time {
+	if val == 0 {
+		return time.Time{}
+	}
+	return fn(val)
+}
+
 func UM(time time.Time) UnixMilli {
 	return UnixMilli{Time: time}
 }
 
 func UMInt(ts int64) UnixMilli {
-	return UM(time.UnixMilli(ts))
+	return UM(zeroSafeUnixToTime(ts, time.UnixMilli))
 }
 
 func UnixMilliNow() UnixMilli {
@@ -26,8 +33,8 @@ func UMicro(time time.Time) UnixMicro {
 	return UnixMicro{Time: time}
 }
 
-func UMicroInto(ts int64) UnixMicro {
-	return UMicro(time.UnixMicro(ts))
+func UMicroInt(ts int64) UnixMicro {
+	return UMicro(zeroSafeUnixToTime(ts, time.UnixMicro))
 }
 
 func UnixMicroNow() UnixMicro {
@@ -39,7 +46,9 @@ func UN(time time.Time) UnixNano {
 }
 
 func UNInt(ts int64) UnixNano {
-	return UN(time.Unix(0, ts))
+	return UN(zeroSafeUnixToTime(ts, func(i int64) time.Time {
+		return time.Unix(0, i)
+	}))
 }
 
 func UnixNanoNow() UnixNano {
@@ -51,7 +60,9 @@ func U(time time.Time) Unix {
 }
 
 func UInt(ts int64) Unix {
-	return U(time.Unix(ts, 0))
+	return U(zeroSafeUnixToTime(ts, func(i int64) time.Time {
+		return time.Unix(i, 0)
+	}))
 }
 
 func UnixNow() Unix {

slidge_whatsapp/vendor/go.mau.fi/util/jsontime/integer.go

@@ -57,6 +57,13 @@ func anyIntegerToTime(src any, unixConv func(int64) time.Time, into *time.Time)
 	return nil
 }
 
+func zeroSafeUnix(t time.Time, method func(time.Time) int64) int64 {
+	if t.IsZero() {
+		return 0
+	}
+	return method(t)
+}
+
 var _ sql.Scanner = &UnixMilli{}
 var _ driver.Valuer = UnixMilli{}
 
@@ -65,9 +72,6 @@ type UnixMilli struct {
 }
 
 func (um UnixMilli) MarshalJSON() ([]byte, error) {
-	if um.IsZero() {
-		return []byte{'0'}, nil
-	}
 	return json.Marshal(um.UnixMilli())
 }
 
@@ -83,6 +87,11 @@ func (um *UnixMilli) Scan(src any) error {
 	return anyIntegerToTime(src, time.UnixMilli, &um.Time)
 }
 
+func (um UnixMilli) Unix() int64      { return zeroSafeUnix(um.Time, time.Time.Unix) }
+func (um UnixMilli) UnixMilli() int64 { return zeroSafeUnix(um.Time, time.Time.UnixMilli) }
+func (um UnixMilli) UnixMicro() int64 { return zeroSafeUnix(um.Time, time.Time.UnixMicro) }
+func (um UnixMilli) UnixNano() int64  { return zeroSafeUnix(um.Time, time.Time.UnixNano) }
+
 var _ sql.Scanner = &UnixMicro{}
 var _ driver.Valuer = UnixMicro{}
 
@@ -91,9 +100,6 @@ type UnixMicro struct {
 }
 
 func (um UnixMicro) MarshalJSON() ([]byte, error) {
-	if um.IsZero() {
-		return []byte{'0'}, nil
-	}
 	return json.Marshal(um.UnixMicro())
 }
 
@@ -109,6 +115,11 @@ func (um *UnixMicro) Scan(src any) error {
 	return anyIntegerToTime(src, time.UnixMicro, &um.Time)
 }
 
+func (um UnixMicro) Unix() int64      { return zeroSafeUnix(um.Time, time.Time.Unix) }
+func (um UnixMicro) UnixMilli() int64 { return zeroSafeUnix(um.Time, time.Time.UnixMilli) }
+func (um UnixMicro) UnixMicro() int64 { return zeroSafeUnix(um.Time, time.Time.UnixMicro) }
+func (um UnixMicro) UnixNano() int64  { return zeroSafeUnix(um.Time, time.Time.UnixNano) }
+
 var _ sql.Scanner = &UnixNano{}
 var _ driver.Valuer = UnixNano{}
 
@@ -117,9 +128,6 @@ type UnixNano struct {
 }
 
 func (un UnixNano) MarshalJSON() ([]byte, error) {
-	if un.IsZero() {
-		return []byte{'0'}, nil
-	}
 	return json.Marshal(un.UnixNano())
 }
 
@@ -139,14 +147,16 @@ func (un *UnixNano) Scan(src any) error {
 	}, &un.Time)
 }
 
+func (un UnixNano) Unix() int64      { return zeroSafeUnix(un.Time, time.Time.Unix) }
+func (un UnixNano) UnixMilli() int64 { return zeroSafeUnix(un.Time, time.Time.UnixMilli) }
+func (un UnixNano) UnixMicro() int64 { return zeroSafeUnix(un.Time, time.Time.UnixMicro) }
+func (un UnixNano) UnixNano() int64  { return zeroSafeUnix(un.Time, time.Time.UnixNano) }
+
 type Unix struct {
 	time.Time
 }
 
 func (u Unix) MarshalJSON() ([]byte, error) {
-	if u.IsZero() {
-		return []byte{'0'}, nil
-	}
 	return json.Marshal(u.Unix())
 }
 
@@ -168,3 +178,8 @@ func (u *Unix) Scan(src any) error {
 		return time.Unix(i, 0)
 	}, &u.Time)
 }
+
+func (u Unix) Unix() int64      { return zeroSafeUnix(u.Time, time.Time.Unix) }
+func (u Unix) UnixMilli() int64 { return zeroSafeUnix(u.Time, time.Time.UnixMilli) }
+func (u Unix) UnixMicro() int64 { return zeroSafeUnix(u.Time, time.Time.UnixMicro) }
+func (u Unix) UnixNano() int64  { return zeroSafeUnix(u.Time, time.Time.UnixNano) }

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

@@ -93,30 +93,18 @@ func BuildPin(target types.JID, pin bool) PatchInfo {
 //
 // 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?
-				},
+				Archived:     &archive,
+				MessageRange: newMessageRange(lastMessageTimestamp, lastMessageKey),
+				// 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))
@@ -132,20 +120,9 @@ func BuildArchive(target types.JID, archive bool, lastMessageTimestamp time.Time
 
 // 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()),
-		}}
+		Read:         proto.Bool(read),
+		MessageRange: newMessageRange(lastMessageTimestamp, lastMessageKey),
 	}
 
 	return PatchInfo{
@@ -355,3 +332,37 @@ func (proc *Processor) EncodePatch(ctx context.Context, keyID []byte, state Hash
 
 	return result, nil
 }
+
+// BuildDeleteChat builds an app state patch for deleting a chat.
+func BuildDeleteChat(target types.JID, lastMessageTimestamp time.Time, lastMessageKey *waCommon.MessageKey) PatchInfo {
+	action := &waSyncAction.DeleteChatAction{
+		MessageRange: newMessageRange(lastMessageTimestamp, lastMessageKey),
+	}
+
+	return PatchInfo{
+		Type: WAPatchRegular,
+		Mutations: []MutationInfo{{
+			Index:   []string{IndexDeleteChat, target.String()},
+			Version: 6,
+			Value: &waSyncAction.SyncActionValue{
+				DeleteChatAction: action,
+			},
+		}},
+	}
+}
+
+func newMessageRange(lastMessageTimestamp time.Time, lastMessageKey *waCommon.MessageKey) *waSyncAction.SyncActionMessageRange {
+	if lastMessageTimestamp.IsZero() {
+		lastMessageTimestamp = time.Now()
+	}
+	messageRange := &waSyncAction.SyncActionMessageRange{
+		LastMessageTimestamp: proto.Int64(lastMessageTimestamp.Unix()),
+	}
+	if lastMessageKey != nil {
+		messageRange.Messages = []*waSyncAction.SyncActionMessage{{
+			Key:       lastMessageKey,
+			Timestamp: proto.Int64(lastMessageTimestamp.Unix()),
+		}}
+	}
+	return messageRange
+}

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

@@ -351,13 +351,17 @@ func (cli *Client) requestAppStateKeys(ctx context.Context, rawKeyIDs [][]byte)
 	}
 }
 
-// SendAppState sends the given app state patch, then resyncs that app state type from the server
+// SendAppState sends the given app state patch, then triggers a background resync of that app state type
 // 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 {
+	return cli.sendAppState(ctx, patch, false)
+}
+
+func (cli *Client) sendAppState(ctx context.Context, patch appstate.PatchInfo, waitForSync bool) error {
 	if cli == nil {
 		return ErrClientIsNil
 	}
@@ -412,5 +416,16 @@ func (cli *Client) SendAppState(ctx context.Context, patch appstate.PatchInfo) e
 		return fmt.Errorf("%w: %s", ErrAppStateUpdate, respCollection.XMLString())
 	}
 
-	return cli.FetchAppState(ctx, patch.Type, false, false)
+	if waitForSync {
+		return cli.FetchAppState(ctx, patch.Type, false, false)
+	}
+
+	go func() {
+		err := cli.FetchAppState(ctx, patch.Type, false, false)
+		if err != nil {
+			cli.Log.Errorf("Failed to resync app state %s after sending update: %v", patch.Type, err)
+		}
+	}()
+
+	return nil
 }

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

@@ -22,10 +22,11 @@ import (
 	"go.mau.fi/whatsmeow/types/events"
 )
 
-func (cli *Client) handleDecryptedArmadillo(ctx context.Context, info *types.MessageInfo, decrypted []byte, retryCount int) (handlerFailed bool) {
+func (cli *Client) handleDecryptedArmadillo(ctx context.Context, info *types.MessageInfo, decrypted []byte, retryCount int) (handlerFailed, protobufFailed bool) {
 	dec, err := decodeArmadillo(decrypted)
 	if err != nil {
 		cli.Log.Warnf("Failed to decode armadillo message from %s: %v", info.SourceString(), err)
+		protobufFailed = true
 		return
 	}
 	dec.Info = *info

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

@@ -67,7 +67,11 @@ func (int *DangerousInternalClient) RequestAppStateKeys(ctx context.Context, raw
 	int.c.requestAppStateKeys(ctx, rawKeyIDs)
 }
 
-func (int *DangerousInternalClient) HandleDecryptedArmadillo(ctx context.Context, info *types.MessageInfo, decrypted []byte, retryCount int) (handlerFailed bool) {
+func (int *DangerousInternalClient) SendAppState(ctx context.Context, patch appstate.PatchInfo, waitForSync bool) error {
+	return int.c.sendAppState(ctx, patch, waitForSync)
+}
+
+func (int *DangerousInternalClient) HandleDecryptedArmadillo(ctx context.Context, info *types.MessageInfo, decrypted []byte, retryCount int) (handlerFailed, protobufFailed bool) {
 	return int.c.handleDecryptedArmadillo(ctx, info, decrypted, retryCount)
 }
 
@@ -479,6 +483,10 @@ func (int *DangerousInternalClient) UploadPreKeys(ctx context.Context) {
 	int.c.uploadPreKeys(ctx)
 }
 
+func (int *DangerousInternalClient) FetchPreKeysNoError(ctx context.Context, retryDevices []types.JID) map[types.JID]*prekey.Bundle {
+	return int.c.fetchPreKeysNoError(ctx, retryDevices)
+}
+
 func (int *DangerousInternalClient) FetchPreKeys(ctx context.Context, users []types.JID) (map[types.JID]preKeyResp, error) {
 	return int.c.fetchPreKeys(ctx, users)
 }
@@ -511,16 +519,20 @@ func (int *DangerousInternalClient) ParseReceipt(node *waBinary.Node) (*events.R
 	return int.c.parseReceipt(node)
 }
 
+func (int *DangerousInternalClient) BackgroundIfAsyncAck(fn func()) {
+	int.c.backgroundIfAsyncAck(fn)
+}
+
 func (int *DangerousInternalClient) MaybeDeferredAck(ctx context.Context, node *waBinary.Node) func(...*bool) {
 	return int.c.maybeDeferredAck(ctx, node)
 }
 
-func (int *DangerousInternalClient) SendAck(node *waBinary.Node) {
-	int.c.sendAck(node)
+func (int *DangerousInternalClient) SendAck(node *waBinary.Node, error int) {
+	int.c.sendAck(node, error)
 }
 
-func (int *DangerousInternalClient) SendMessageReceipt(info *types.MessageInfo) {
-	int.c.sendMessageReceipt(info)
+func (int *DangerousInternalClient) SendMessageReceipt(info *types.MessageInfo, node *waBinary.Node) {
+	int.c.sendMessageReceipt(info, node)
 }
 
 func (int *DangerousInternalClient) GenerateRequestID() string {
@@ -611,7 +623,7 @@ func (int *DangerousInternalClient) PrepareMessageNodeV3(ctx context.Context, to
 	return int.c.prepareMessageNodeV3(ctx, to, ownID, id, payload, skdm, msgAttrs, frankingTag, participants, timings)
 }
 
-func (int *DangerousInternalClient) EncryptMessageForDevicesV3(ctx context.Context, allDevices []types.JID, ownID types.JID, id string, payload *waMsgTransport.MessageTransport_Payload, skdm *waMsgTransport.MessageTransport_Protocol_Ancillary_SenderKeyDistributionMessage, dsm *waMsgTransport.MessageTransport_Protocol_Integral_DeviceSentMessage, encAttrs waBinary.Attrs) []waBinary.Node {
+func (int *DangerousInternalClient) EncryptMessageForDevicesV3(ctx context.Context, allDevices []types.JID, ownID types.JID, id string, payload *waMsgTransport.MessageTransport_Payload, skdm *waMsgTransport.MessageTransport_Protocol_Ancillary_SenderKeyDistributionMessage, dsm *waMsgTransport.MessageTransport_Protocol_Integral_DeviceSentMessage, encAttrs waBinary.Attrs) ([]waBinary.Node, error) {
 	return int.c.encryptMessageForDevicesV3(ctx, allDevices, ownID, id, payload, skdm, dsm, encAttrs)
 }
 

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

@@ -124,6 +124,11 @@ func (cli *Client) parseMessageSource(node *waBinary.Node, requireParticipant bo
 		source.Sender = from
 		// TODO IsFromMe?
 	} else if from.User == clientID.User || from.User == clientLID.User {
+		if from.Server == types.HostedServer {
+			from.Server = types.DefaultUserServer
+		} else if from.Server == types.HostedLIDServer {
+			from.Server = types.HiddenUserServer
+		}
 		source.IsFromMe = true
 		source.Sender = from
 		recipient := ag.OptionalJID("recipient")
@@ -132,7 +137,7 @@ func (cli *Client) parseMessageSource(node *waBinary.Node, requireParticipant bo
 		} else {
 			source.Chat = from.ToNonAD()
 		}
-		if source.Chat.Server == types.HiddenUserServer {
+		if source.Chat.Server == types.HiddenUserServer || source.Chat.Server == types.HostedLIDServer {
 			source.RecipientAlt = ag.OptionalJIDOrEmpty("peer_recipient_pn")
 		} else {
 			source.RecipientAlt = ag.OptionalJIDOrEmpty("peer_recipient_lid")
@@ -148,9 +153,14 @@ func (cli *Client) parseMessageSource(node *waBinary.Node, requireParticipant bo
 			source.Chat = from
 		}
 	} else {
+		if from.Server == types.HostedServer {
+			from.Server = types.DefaultUserServer
+		} else if from.Server == types.HostedLIDServer {
+			from.Server = types.HiddenUserServer
+		}
 		source.Chat = from.ToNonAD()
 		source.Sender = from
-		if source.Sender.Server == types.HiddenUserServer {
+		if source.Sender.Server == types.HiddenUserServer || source.Chat.Server == types.HostedLIDServer {
 			source.SenderAlt = ag.OptionalJIDOrEmpty("sender_pn")
 		} else {
 			source.SenderAlt = ag.OptionalJIDOrEmpty("sender_lid")
@@ -291,13 +301,10 @@ func (cli *Client) decryptMessages(ctx context.Context, info *types.MessageInfo,
 	if ok && len(node.GetChildrenByTag("enc")) == 0 {
 		uType := events.UnavailableType(unavailableNode.AttrGetter().String("type"))
 		cli.Log.Warnf("Unavailable message %s from %s (type: %q)", info.ID, info.SourceString(), uType)
-		if cli.SynchronousAck {
+		cli.backgroundIfAsyncAck(func() {
 			cli.immediateRequestMessageFromPhone(ctx, info)
-			cli.sendAck(node)
-		} else {
-			go cli.delayedRequestMessageFromPhone(info)
-			go cli.sendAck(node)
-		}
+			cli.sendAck(node, 0)
+		})
 		cli.dispatchEvent(&events.UndecryptableMessage{Info: *info, IsUnavailable: true, UnavailableType: uType})
 		return
 	}
@@ -320,10 +327,12 @@ func (cli *Client) decryptMessages(ctx context.Context, info *types.MessageInfo,
 			cli.Log.Warnf("No LID found for %s", info.Sender)
 		}
 	}
+	var recognizedStanza, protobufFailed bool
 	for _, child := range children {
 		if child.Tag != "enc" {
 			continue
 		}
+		recognizedStanza = true
 		ag := child.AttrGetter()
 		encType, ok := ag.GetString("type", false)
 		if !ok {
@@ -371,16 +380,26 @@ func (cli *Client) decryptMessages(ctx context.Context, info *types.MessageInfo,
 		if errors.Is(err, EventAlreadyProcessed) {
 			cli.Log.Debugf("Ignoring message %s from %s: %v", info.ID, info.SourceString(), err)
 			continue
+		} else if errors.Is(err, signalerror.ErrOldCounter) {
+			cli.Log.Warnf("Ignoring message %s from %s: %v", info.ID, info.SourceString(), err)
+			continue
 		} else if err != nil {
 			cli.Log.Warnf("Error decrypting message %s from %s: %v", info.ID, info.SourceString(), err)
 			if ctx.Err() != nil || errors.Is(err, context.Canceled) {
 				return
 			}
 			isUnavailable := encType == "skmsg" && !containsDirectMsg && errors.Is(err, signalerror.ErrNoSenderKeyForUser)
-			if cli.SynchronousAck {
+			if encType == "msmsg" {
+				cli.backgroundIfAsyncAck(func() {
+					cli.sendAck(node, NackMissingMessageSecret)
+				})
+			} else if cli.SynchronousAck {
 				cli.sendRetryReceipt(ctx, node, info, isUnavailable)
+				// TODO this probably isn't supposed to ack
+				cli.sendAck(node, 0)
 			} else {
 				go cli.sendRetryReceipt(context.WithoutCancel(ctx), node, info, isUnavailable)
+				go cli.sendAck(node, 0)
 			}
 			cli.dispatchEvent(&events.UndecryptableMessage{
 				Info:            *info,
@@ -396,15 +415,16 @@ func (cli *Client) decryptMessages(ctx context.Context, info *types.MessageInfo,
 		var handlerFailed bool
 		switch ag.Int("v") {
 		case 2:
-			// TODO send nack instead of receipt for proto unmarshal errors (both this one and armadillo)
 			err = proto.Unmarshal(decrypted, &msg)
 			if err != nil {
 				cli.Log.Warnf("Error unmarshaling decrypted message from %s: %v", info.SourceString(), err)
+				protobufFailed = true
 				continue
 			}
+			protobufFailed = false
 			handlerFailed = cli.handleDecryptedMessage(ctx, info, &msg, retryCount)
 		case 3:
-			handlerFailed = cli.handleDecryptedArmadillo(ctx, info, decrypted, retryCount)
+			handlerFailed, protobufFailed = cli.handleDecryptedArmadillo(ctx, info, decrypted, retryCount)
 		default:
 			cli.Log.Warnf("Unknown version %d in decrypted message from %s", ag.Int("v"), info.SourceString())
 		}
@@ -438,11 +458,15 @@ func (cli *Client) decryptMessages(ctx context.Context, info *types.MessageInfo,
 			}
 		}
 	}
-	if cli.SynchronousAck {
-		cli.sendMessageReceipt(info)
-	} else {
-		go cli.sendMessageReceipt(info)
-	}
+	cli.backgroundIfAsyncAck(func() {
+		if !recognizedStanza {
+			cli.sendAck(node, NackUnrecognizedStanza)
+		} else if protobufFailed {
+			cli.sendAck(node, NackInvalidProtobuf)
+		} else {
+			cli.sendMessageReceipt(info, node)
+		}
+	})
 	return
 }
 

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

@@ -26,10 +26,11 @@ import (
 )
 
 var (
-	AdvPrefixAccountSignature                                = []byte{6, 0}
-	AdvPrefixDeviceSignatureGenerate                         = []byte{6, 1}
-	AdvHostedPrefixDeviceIdentityAccountSignature            = []byte{6, 5}
-	AdvHostedPrefixDeviceIdentityDeviceSignatureVerification = []byte{6, 6}
+	AdvAccountSignaturePrefix = []byte{6, 0}
+	AdvDeviceSignaturePrefix  = []byte{6, 1}
+
+	AdvHostedAccountSignaturePrefix = []byte{6, 5}
+	AdvHostedDeviceSignaturePrefix  = []byte{6, 6}
 )
 
 func (cli *Client) handleIQ(node *waBinary.Node) {
@@ -113,11 +114,11 @@ func (cli *Client) handlePair(ctx context.Context, deviceIdentityBytes []byte, r
 		cli.sendPairError(reqID, 500, "internal-error")
 		return &PairProtoError{"failed to parse device identity container in pair success message", err}
 	}
-	isHostedAccount := deviceIdentityContainer.AccountType != nil && *deviceIdentityContainer.AccountType == waAdv.ADVEncryptionType_HOSTED
 
 	h := hmac.New(sha256.New, cli.Store.AdvSecretKey)
-	if isHostedAccount {
-		h.Write(AdvHostedPrefixDeviceIdentityAccountSignature)
+	if deviceIdentityContainer.GetAccountType() == waAdv.ADVEncryptionType_HOSTED {
+		h.Write(AdvHostedAccountSignaturePrefix)
+		//cli.Store.IsHosted = true
 	}
 	h.Write(deviceIdentityContainer.Details)
 
@@ -134,13 +135,6 @@ func (cli *Client) handlePair(ctx context.Context, deviceIdentityBytes []byte, r
 		return &PairProtoError{"failed to parse signed device identity in pair success message", err}
 	}
 
-	if !verifyDeviceIdentityAccountSignature(&deviceIdentity, cli.Store.IdentityKey) {
-		cli.sendPairError(reqID, 401, "signature-mismatch")
-		return ErrPairInvalidDeviceSignature
-	}
-
-	deviceIdentity.DeviceSignature = generateDeviceSignature(&deviceIdentity, cli.Store.IdentityKey, isHostedAccount)[:]
-
 	var deviceIdentityDetails waAdv.ADVDeviceIdentity
 	err = proto.Unmarshal(deviceIdentity.Details, &deviceIdentityDetails)
 	if err != nil {
@@ -148,6 +142,13 @@ func (cli *Client) handlePair(ctx context.Context, deviceIdentityBytes []byte, r
 		return &PairProtoError{"failed to parse device identity details in pair success message", err}
 	}
 
+	if !verifyAccountSignature(&deviceIdentity, cli.Store.IdentityKey, deviceIdentityDetails.GetDeviceType() == waAdv.ADVEncryptionType_HOSTED) {
+		cli.sendPairError(reqID, 401, "signature-mismatch")
+		return ErrPairInvalidDeviceSignature
+	}
+
+	deviceIdentity.DeviceSignature = generateDeviceSignature(&deviceIdentity, cli.Store.IdentityKey)[:]
+
 	if cli.PrePairCallback != nil && !cli.PrePairCallback(jid, platform, businessName) {
 		cli.sendPairError(reqID, 500, "internal-error")
 		return ErrPairRejectedLocally
@@ -224,7 +225,7 @@ func concatBytes(data ...[]byte) []byte {
 	return output
 }
 
-func verifyDeviceIdentityAccountSignature(deviceIdentity *waAdv.ADVSignedDeviceIdentity, ikp *keys.KeyPair) bool {
+func verifyAccountSignature(deviceIdentity *waAdv.ADVSignedDeviceIdentity, ikp *keys.KeyPair, isHosted bool) bool {
 	if len(deviceIdentity.AccountSignatureKey) != 32 || len(deviceIdentity.AccountSignature) != 64 {
 		return false
 	}
@@ -232,15 +233,17 @@ func verifyDeviceIdentityAccountSignature(deviceIdentity *waAdv.ADVSignedDeviceI
 	signatureKey := ecc.NewDjbECPublicKey(*(*[32]byte)(deviceIdentity.AccountSignatureKey))
 	signature := *(*[64]byte)(deviceIdentity.AccountSignature)
 
-	message := concatBytes(AdvPrefixAccountSignature, deviceIdentity.Details, ikp.Pub[:])
+	prefix := AdvAccountSignaturePrefix
+	if isHosted {
+		prefix = AdvHostedAccountSignaturePrefix
+	}
+	message := concatBytes(prefix, deviceIdentity.Details, ikp.Pub[:])
+
 	return ecc.VerifySignature(signatureKey, message, signature)
 }
 
-func generateDeviceSignature(deviceIdentity *waAdv.ADVSignedDeviceIdentity, ikp *keys.KeyPair, isHostedAccount bool) *[64]byte {
-	prefix := AdvPrefixDeviceSignatureGenerate
-	if isHostedAccount {
-		prefix = AdvHostedPrefixDeviceIdentityDeviceSignatureVerification
-	}
+func generateDeviceSignature(deviceIdentity *waAdv.ADVSignedDeviceIdentity, ikp *keys.KeyPair) *[64]byte {
+	prefix := AdvDeviceSignaturePrefix
 	message := concatBytes(prefix, deviceIdentity.Details, ikp.Pub[:], deviceIdentity.AccountSignatureKey)
 	sig := ecc.CalculateSignature(ecc.NewDjbECPrivateKey(*ikp.Priv), message)
 	return &sig

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

@@ -93,6 +93,27 @@ func (cli *Client) uploadPreKeys(ctx context.Context) {
 	return
 }
 
+func (cli *Client) fetchPreKeysNoError(ctx context.Context, retryDevices []types.JID) map[types.JID]*prekey.Bundle {
+	if len(retryDevices) == 0 {
+		return nil
+	}
+	bundlesResp, err := cli.fetchPreKeys(ctx, retryDevices)
+	if err != nil {
+		cli.Log.Warnf("Failed to fetch prekeys for %v with no existing session: %v", retryDevices, err)
+		return nil
+	}
+	bundles := make(map[types.JID]*prekey.Bundle, len(retryDevices))
+	for _, jid := range retryDevices {
+		resp := bundlesResp[jid]
+		if resp.err != nil {
+			cli.Log.Warnf("Failed to fetch prekey for %s: %v", jid, resp.err)
+			continue
+		}
+		bundles[jid] = resp.bundle
+	}
+	return bundles
+}
+
 type preKeyResp struct {
 	bundle *prekey.Bundle
 	err    error