Introduce Service Id Types

Co-authored-by: Scott Nonnenberg <scott@signal.org>
This commit is contained in:
Fedor Indutny 2023-08-10 18:43:33 +02:00 committed by Jamie Kyle
parent 414c0a58d3
commit 366b875fd2
269 changed files with 5832 additions and 5550 deletions

View file

@ -2,6 +2,7 @@
// SPDX-License-Identifier: AGPL-3.0-only
import { differenceWith, omit, partition } from 'lodash';
import { v4 as generateUuid } from 'uuid';
import {
ErrorCode,
@ -21,10 +22,10 @@ import {
} from '../textsecure/OutgoingMessage';
import { Address } from '../types/Address';
import { QualifiedAddress } from '../types/QualifiedAddress';
import { UUID, UUIDKind } from '../types/UUID';
import * as Errors from '../types/errors';
import { getValue, isEnabled } from '../RemoteConfig';
import type { UUIDStringType } from '../types/UUID';
import type { ServiceIdString } from '../types/ServiceId';
import { ServiceIdKind } from '../types/ServiceId';
import { isRecord } from './isRecord';
import { isOlderThan } from './timestamp';
@ -44,7 +45,7 @@ import type { HTTPError } from '../textsecure/Errors';
import { IdentityKeys, SenderKeys, Sessions } from '../LibSignalStores';
import type { ConversationModel } from '../models/conversations';
import type { DeviceType, CallbackResultType } from '../textsecure/Types.d';
import { getKeysForIdentifier } from '../textsecure/getKeysForIdentifier';
import { getKeysForServiceId } from '../textsecure/getKeysForServiceId';
import type {
ConversationAttributesType,
SenderKeyInfoType,
@ -64,6 +65,8 @@ import { strictAssert } from './assert';
import * as log from '../logging/log';
import { GLOBAL_ZONE } from '../SignalProtocolStore';
import { waitForAll } from './waitForAll';
import { resolveSenderKeyDevice } from './resolveSenderKeyDevice';
import { isNotNil } from './isNotNil';
const UNKNOWN_RECIPIENT = 404;
const INCORRECT_AUTH_KEY = 401;
@ -84,7 +87,7 @@ const ZERO_ACCESS_KEY = Bytes.toBase64(new Uint8Array(ACCESS_KEY_LENGTH));
export type SenderKeyTargetType = {
getGroupId: () => string | undefined;
getMembers: () => Array<ConversationModel>;
hasMember: (uuid: UUIDStringType) => boolean;
hasMember: (serviceId: ServiceIdString) => boolean;
idForLogging: () => string;
isGroupV2: () => boolean;
isValid: () => boolean;
@ -172,7 +175,7 @@ export async function sendContentMessageToGroup({
isPartialSend?: boolean;
messageId: string | undefined;
online?: boolean;
recipients: ReadonlyArray<string>;
recipients: ReadonlyArray<ServiceIdString>;
sendOptions?: SendOptionsType;
sendTarget: SenderKeyTargetType;
sendType: SendTypesType;
@ -183,12 +186,12 @@ export async function sendContentMessageToGroup({
const logId = sendTarget.idForLogging();
const accountManager = window.getAccountManager();
if (accountManager.areKeysOutOfDate(UUIDKind.ACI)) {
if (accountManager.areKeysOutOfDate(ServiceIdKind.ACI)) {
log.warn(
`sendToGroup/${logId}: Keys are out of date; updating before send`
);
await accountManager.maybeUpdateKeys(UUIDKind.ACI);
if (accountManager.areKeysOutOfDate(UUIDKind.ACI)) {
await accountManager.maybeUpdateKeys(ServiceIdKind.ACI);
if (accountManager.areKeysOutOfDate(ServiceIdKind.ACI)) {
throw new Error('Keys still out of date after update');
}
}
@ -266,7 +269,7 @@ export async function sendToGroupViaSenderKey(options: {
isPartialSend?: boolean;
messageId: string | undefined;
online?: boolean;
recipients: ReadonlyArray<string>;
recipients: ReadonlyArray<ServiceIdString>;
recursionCount: number;
sendOptions?: SendOptionsType;
sendTarget: SenderKeyTargetType;
@ -337,7 +340,7 @@ export async function sendToGroupViaSenderKey(options: {
);
await sendTarget.saveSenderKeyInfo({
createdAtDate: Date.now(),
distributionId: UUID.generate().toString(),
distributionId: generateUuid(),
memberDevices: [],
});
@ -362,21 +365,18 @@ export async function sendToGroupViaSenderKey(options: {
}
// 2. Fetch all devices we believe we'll be sending to
const ourUuid = window.textsecure.storage.user.getCheckedUuid();
const { devices: currentDevices, emptyIdentifiers } =
await window.textsecure.storage.protocol.getOpenDevices(
ourUuid,
recipients
);
const ourAci = window.textsecure.storage.user.getCheckedAci();
const { devices: currentDevices, emptyServiceIds } =
await window.textsecure.storage.protocol.getOpenDevices(ourAci, recipients);
// 3. If we have no open sessions with people we believe we are sending to, and we
// believe that any have signal accounts, fetch their prekey bundle and start
// sessions with them.
if (
emptyIdentifiers.length > 0 &&
emptyIdentifiers.some(isIdentifierRegistered)
emptyServiceIds.length > 0 &&
emptyServiceIds.some(isIdentifierRegistered)
) {
await fetchKeysForIdentifiers(emptyIdentifiers);
await fetchKeysForServiceIds(emptyServiceIds);
// Restart here to capture devices for accounts we just started sessions with
return sendToGroupViaSenderKey({
@ -385,17 +385,25 @@ export async function sendToGroupViaSenderKey(options: {
});
}
const { memberDevices, distributionId, createdAtDate } = senderKeyInfo;
const {
memberDevices: rawMemberDevices,
distributionId,
createdAtDate,
} = senderKeyInfo;
const memberSet = new Set(sendTarget.getMembers());
const memberDevices = rawMemberDevices
.map(resolveSenderKeyDevice)
.filter(isNotNil);
// 4. Partition devices into sender key and non-sender key groups
const [devicesForSenderKey, devicesForNormalSend] = partition(
currentDevices,
device => isValidSenderKeyRecipient(memberSet, device.identifier, { story })
device => isValidSenderKeyRecipient(memberSet, device.serviceId, { story })
);
const senderKeyRecipients = getUuidsFromDevices(devicesForSenderKey);
const normalSendRecipients = getUuidsFromDevices(devicesForNormalSend);
const senderKeyRecipients = getServiceIdsFromDevices(devicesForSenderKey);
const normalSendRecipients = getServiceIdsFromDevices(devicesForNormalSend);
log.info(
`sendToGroupViaSenderKey/${logId}:` +
` ${senderKeyRecipients.length} accounts for sender key (${devicesForSenderKey.length} devices),` +
@ -412,9 +420,9 @@ export async function sendToGroupViaSenderKey(options: {
// 6. Analyze target devices for sender key, determine which have been added or removed
const {
newToMemberDevices,
newToMemberUuids,
newToMemberServiceIds,
removedFromMemberDevices,
removedFromMemberUuids,
removedFromMemberServiceIds,
} = _analyzeSenderKeyDevices(
memberDevices,
devicesForSenderKey,
@ -423,8 +431,8 @@ export async function sendToGroupViaSenderKey(options: {
// 7. If members have been removed from the group, we need to reset our sender key, then
// start over to get a fresh set of target devices.
const keyNeedsReset = Array.from(removedFromMemberUuids).some(
uuid => !sendTarget.hasMember(uuid)
const keyNeedsReset = Array.from(removedFromMemberServiceIds).some(
serviceId => !sendTarget.hasMember(serviceId)
);
if (keyNeedsReset) {
await resetSenderKey(sendTarget);
@ -439,11 +447,11 @@ export async function sendToGroupViaSenderKey(options: {
// 8. If there are new members or new devices in the group, we need to ensure that they
// have our sender key before we send sender key messages to them.
if (newToMemberUuids.length > 0) {
if (newToMemberServiceIds.length > 0) {
log.info(
`sendToGroupViaSenderKey/${logId}: Sending sender key to ${
newToMemberUuids.length
} members: ${JSON.stringify(newToMemberUuids)}`
newToMemberServiceIds.length
} members: ${JSON.stringify(newToMemberServiceIds)}`
);
try {
await handleMessageSend(
@ -452,7 +460,7 @@ export async function sendToGroupViaSenderKey(options: {
contentHint,
distributionId,
groupId,
identifiers: newToMemberUuids,
serviceIds: newToMemberServiceIds,
// SKDMs should only have story=true if we're sending to a distribution list
story: sendTarget.getGroupId() ? false : story,
urgent,
@ -480,7 +488,9 @@ export async function sendToGroupViaSenderKey(options: {
await sendTarget.saveSenderKeyInfo({
createdAtDate,
distributionId,
memberDevices: updatedMemberDevices,
memberDevices: updatedMemberDevices.map(({ serviceId, ...rest }) => {
return { ...rest, identifier: serviceId };
}),
});
// Restart here because we might have discovered new or dropped devices as part of
@ -504,7 +514,9 @@ export async function sendToGroupViaSenderKey(options: {
await sendTarget.saveSenderKeyInfo({
createdAtDate,
distributionId,
memberDevices: updatedMemberDevices,
memberDevices: updatedMemberDevices.map(({ serviceId, ...rest }) => {
return { ...rest, identifier: serviceId };
}),
});
// Note, we do not need to restart here because we don't refer back to senderKeyInfo
@ -513,11 +525,14 @@ export async function sendToGroupViaSenderKey(options: {
// 10. Send the Sender Key message!
let sendLogId: number;
let senderKeyRecipientsWithDevices: Record<string, Array<number>> = {};
let senderKeyRecipientsWithDevices: Record<
ServiceIdString,
Array<number>
> = {};
devicesForSenderKey.forEach(item => {
const { id, identifier } = item;
senderKeyRecipientsWithDevices[identifier] ||= [];
senderKeyRecipientsWithDevices[identifier].push(id);
const { id, serviceId } = item;
senderKeyRecipientsWithDevices[serviceId] ||= [];
senderKeyRecipientsWithDevices[serviceId].push(id);
});
try {
@ -543,7 +558,7 @@ export async function sendToGroupViaSenderKey(options: {
if (uuids404 && uuids404.length > 0) {
await waitForAll({
tasks: uuids404.map(
uuid => async () => markIdentifierUnregistered(uuid)
serviceId => async () => markServiceIdUnregistered(serviceId)
),
});
}
@ -643,7 +658,7 @@ export async function sendToGroupViaSenderKey(options: {
editMessage: contentMessage.editMessage
? Proto.EditMessage.encode(contentMessage.editMessage).finish()
: undefined,
successfulIdentifiers: senderKeyRecipients,
successfulServiceIds: senderKeyRecipients,
unidentifiedDeliveries: senderKeyRecipients,
contentHint,
@ -660,25 +675,25 @@ export async function sendToGroupViaSenderKey(options: {
// We don't want to use a normal send log callback here, because the proto has already
// been saved as part of the Sender Key send. We're just adding recipients here.
const sendLogCallback: SendLogCallbackType = async ({
identifier,
serviceId,
deviceIds,
}: {
identifier: string;
serviceId: ServiceIdString;
deviceIds: Array<number>;
}) => {
if (!shouldSaveProto(sendType)) {
return;
}
const sentToConversation = window.ConversationController.get(identifier);
const sentToConversation = window.ConversationController.get(serviceId);
if (!sentToConversation) {
log.warn(
`sendToGroupViaSenderKey/callback: Unable to find conversation for identifier ${identifier}`
`sendToGroupViaSenderKey/callback: Unable to find conversation for serviceId ${serviceId}`
);
return;
}
const recipientUuid = sentToConversation.get('uuid');
if (!recipientUuid) {
const recipientServiceId = sentToConversation.get('uuid');
if (!recipientServiceId) {
log.warn(
`sendToGroupViaSenderKey/callback: Conversation ${sentToConversation.idForLogging()} had no UUID`
);
@ -687,7 +702,7 @@ export async function sendToGroupViaSenderKey(options: {
await window.Signal.Data.insertProtoRecipients({
id: sendLogId,
recipientUuid,
recipientServiceId,
deviceIds,
});
};
@ -731,13 +746,13 @@ function mergeSendResult({
senderKeyRecipientsWithDevices,
}: {
result: CallbackResultType | SendMessageProtoError;
senderKeyRecipients: Array<string>;
senderKeyRecipientsWithDevices: Record<string, Array<number>>;
senderKeyRecipients: Array<ServiceIdString>;
senderKeyRecipientsWithDevices: Record<ServiceIdString, Array<number>>;
}): CallbackResultType {
return {
...result,
successfulIdentifiers: [
...(result.successfulIdentifiers || []),
successfulServiceIds: [
...(result.successfulServiceIds || []),
...senderKeyRecipients,
],
unidentifiedDeliveries: [
@ -855,7 +870,7 @@ export function _shouldFailSend(error: unknown, logId: string): boolean {
return true;
}
if (error.successfulIdentifiers && error.successfulIdentifiers.length > 0) {
if (error.successfulServiceIds && error.successfulServiceIds.length > 0) {
logError(
'SendMessageProtoError had successful sends; no further sends needed. Failing.'
);
@ -873,7 +888,9 @@ export function _shouldFailSend(error: unknown, logId: string): boolean {
return false;
}
function getRecipients(options: GroupSendOptionsType): ReadonlyArray<string> {
function getRecipients(
options: GroupSendOptionsType
): ReadonlyArray<ServiceIdString> {
if (options.groupV2) {
return options.groupV2.members;
}
@ -881,22 +898,16 @@ function getRecipients(options: GroupSendOptionsType): ReadonlyArray<string> {
throw new Error('getRecipients: Unable to extract recipients!');
}
async function markIdentifierUnregistered(identifier: string) {
async function markServiceIdUnregistered(serviceId: ServiceIdString) {
const conversation = window.ConversationController.getOrCreate(
identifier,
serviceId,
'private'
);
conversation.setUnregistered();
window.Signal.Data.updateConversation(conversation.attributes);
const uuid = UUID.lookup(identifier);
if (!uuid) {
log.warn(`No uuid found for ${identifier}`);
return;
}
await window.textsecure.storage.protocol.archiveAllSessions(uuid);
await window.textsecure.storage.protocol.archiveAllSessions(serviceId);
}
function isIdentifierRegistered(identifier: string) {
@ -917,17 +928,17 @@ async function handle409Response(logId: string, error: HTTPError) {
const { uuid, devices } = item;
// Start new sessions with devices we didn't know about before
if (devices.missingDevices && devices.missingDevices.length > 0) {
await fetchKeysForIdentifier(uuid, devices.missingDevices);
await fetchKeysForServiceId(uuid, devices.missingDevices);
}
// Archive sessions with devices that have been removed
if (devices.extraDevices && devices.extraDevices.length > 0) {
const ourUuid = window.textsecure.storage.user.getCheckedUuid();
const ourAci = window.textsecure.storage.user.getCheckedAci();
await waitForAll({
tasks: devices.extraDevices.map(deviceId => async () => {
await window.textsecure.storage.protocol.archiveSession(
new QualifiedAddress(ourUuid, Address.create(uuid, deviceId))
new QualifiedAddress(ourAci, Address.create(uuid, deviceId))
);
}),
});
@ -957,33 +968,37 @@ async function handle410Response(
tasks: parsed.data.map(item => async () => {
const { uuid, devices } = item;
if (devices.staleDevices && devices.staleDevices.length > 0) {
const ourUuid = window.textsecure.storage.user.getCheckedUuid();
const ourAci = window.textsecure.storage.user.getCheckedAci();
// First, archive our existing sessions with these devices
await waitForAll({
tasks: devices.staleDevices.map(deviceId => async () => {
await window.textsecure.storage.protocol.archiveSession(
new QualifiedAddress(ourUuid, Address.create(uuid, deviceId))
new QualifiedAddress(ourAci, Address.create(uuid, deviceId))
);
}),
});
// Start new sessions with these devices
await fetchKeysForIdentifier(uuid, devices.staleDevices);
await fetchKeysForServiceId(uuid, devices.staleDevices);
// Forget that we've sent our sender key to these devices, since they've
// been re-registered or re-linked.
const senderKeyInfo = sendTarget.getSenderKeyInfo();
if (senderKeyInfo) {
const devicesToRemove: Array<PartialDeviceType> =
devices.staleDevices.map(id => ({ id, identifier: uuid }));
devices.staleDevices.map(id => ({ id, serviceId: uuid }));
await sendTarget.saveSenderKeyInfo({
...senderKeyInfo,
memberDevices: differenceWith(
senderKeyInfo.memberDevices,
senderKeyInfo.memberDevices
.map(resolveSenderKeyDevice)
.filter(isNotNil),
devicesToRemove,
partialDeviceComparator
),
).map(({ serviceId, ...rest }) => {
return { ...rest, identifier: serviceId };
}),
});
}
}
@ -1004,7 +1019,7 @@ function getXorOfAccessKeys(
devices: Array<DeviceType>,
{ story }: { story?: boolean } = {}
): Buffer {
const uuids = getUuidsFromDevices(devices);
const uuids = getServiceIdsFromDevices(devices);
const result = Buffer.alloc(ACCESS_KEY_LENGTH);
strictAssert(
@ -1054,7 +1069,7 @@ async function encryptForSenderKey({
distributionId: string;
groupId?: string;
}): Promise<Buffer> {
const ourUuid = window.textsecure.storage.user.getCheckedUuid();
const ourAci = window.textsecure.storage.user.getCheckedAci();
const ourDeviceId = window.textsecure.storage.user.getDeviceId();
if (!ourDeviceId) {
throw new Error(
@ -1063,16 +1078,19 @@ async function encryptForSenderKey({
}
const sender = ProtocolAddress.new(
ourUuid.toString(),
ourAci,
parseIntOrThrow(ourDeviceId, 'encryptForSenderKey, ourDeviceId')
);
const ourAddress = getOurAddress();
const senderKeyStore = new SenderKeys({ ourUuid, zone: GLOBAL_ZONE });
const senderKeyStore = new SenderKeys({
ourServiceId: ourAci,
zone: GLOBAL_ZONE,
});
const message = Buffer.from(padMessage(contentMessage));
const ciphertextMessage =
await window.textsecure.storage.protocol.enqueueSenderKeyJob(
new QualifiedAddress(ourUuid, ourAddress),
new QualifiedAddress(ourAci, ourAddress),
() => groupEncrypt(sender, distributionId, senderKeyStore, message)
);
@ -1097,24 +1115,21 @@ async function encryptForSenderKey({
const recipients = devices
.slice()
.sort((a, b): number => {
if (a.identifier === b.identifier) {
if (a.serviceId === b.serviceId) {
return 0;
}
if (a.identifier < b.identifier) {
if (a.serviceId < b.serviceId) {
return -1;
}
return 1;
})
.map(device => {
return ProtocolAddress.new(
UUID.checkedLookup(device.identifier).toString(),
device.id
);
return ProtocolAddress.new(device.serviceId, device.id);
});
const identityKeyStore = new IdentityKeys({ ourUuid });
const sessionStore = new Sessions({ ourUuid });
const identityKeyStore = new IdentityKeys({ ourServiceId: ourAci });
const sessionStore = new Sessions({ ourServiceId: ourAci });
return sealedSenderMultiRecipientEncrypt(
content,
recipients,
@ -1160,7 +1175,7 @@ function deviceComparator(left?: DeviceType, right?: DeviceType): boolean {
left &&
right &&
left.id === right.id &&
left.identifier === right.identifier &&
left.serviceId === right.serviceId &&
left.registrationId === right.registrationId
);
}
@ -1172,22 +1187,14 @@ function partialDeviceComparator(
right?: PartialDeviceType
): boolean {
return Boolean(
left &&
right &&
left.id === right.id &&
left.identifier === right.identifier
left && right && left.id === right.id && left.serviceId === right.serviceId
);
}
function getUuidsFromDevices(
function getServiceIdsFromDevices(
devices: Array<DeviceType>
): Array<UUIDStringType> {
const uuids = new Set<UUIDStringType>();
devices.forEach(device => {
uuids.add(UUID.checkedLookup(device.identifier).toString());
});
return Array.from(uuids);
): Array<ServiceIdString> {
return [...new Set(devices.map(({ serviceId }) => serviceId))];
}
export function _analyzeSenderKeyDevices(
@ -1196,24 +1203,24 @@ export function _analyzeSenderKeyDevices(
isPartialSend?: boolean
): {
newToMemberDevices: Array<DeviceType>;
newToMemberUuids: Array<UUIDStringType>;
newToMemberServiceIds: Array<ServiceIdString>;
removedFromMemberDevices: Array<DeviceType>;
removedFromMemberUuids: Array<UUIDStringType>;
removedFromMemberServiceIds: Array<ServiceIdString>;
} {
const newToMemberDevices = differenceWith<DeviceType, DeviceType>(
devicesForSend,
memberDevices,
deviceComparator
);
const newToMemberUuids = getUuidsFromDevices(newToMemberDevices);
const newToMemberServiceIds = getServiceIdsFromDevices(newToMemberDevices);
// If this is a partial send, we won't do anything with device removals
if (isPartialSend) {
return {
newToMemberDevices,
newToMemberUuids,
newToMemberServiceIds,
removedFromMemberDevices: [],
removedFromMemberUuids: [],
removedFromMemberServiceIds: [],
};
}
@ -1222,23 +1229,25 @@ export function _analyzeSenderKeyDevices(
devicesForSend,
deviceComparator
);
const removedFromMemberUuids = getUuidsFromDevices(removedFromMemberDevices);
const removedFromMemberServiceIds = getServiceIdsFromDevices(
removedFromMemberDevices
);
return {
newToMemberDevices,
newToMemberUuids,
newToMemberServiceIds,
removedFromMemberDevices,
removedFromMemberUuids,
removedFromMemberServiceIds,
};
}
function getOurAddress(): Address {
const ourUuid = window.textsecure.storage.user.getCheckedUuid();
const ourAci = window.textsecure.storage.user.getCheckedAci();
const ourDeviceId = window.textsecure.storage.user.getDeviceId();
if (!ourDeviceId) {
throw new Error('getOurAddress: Unable to fetch our deviceId');
}
return new Address(ourUuid, ourDeviceId);
return new Address(ourAci, ourDeviceId);
}
async function resetSenderKey(sendTarget: SenderKeyTargetType): Promise<void> {
@ -1261,9 +1270,9 @@ async function resetSenderKey(sendTarget: SenderKeyTargetType): Promise<void> {
memberDevices: [],
});
const ourUuid = window.storage.user.getCheckedUuid();
const ourAci = window.storage.user.getCheckedAci();
await window.textsecure.storage.protocol.removeSenderKey(
new QualifiedAddress(ourUuid, ourAddress),
new QualifiedAddress(ourAci, ourAddress),
distributionId
);
}
@ -1292,59 +1301,59 @@ function getAccessKey(
return undefined;
}
async function fetchKeysForIdentifiers(
identifiers: Array<string>
async function fetchKeysForServiceIds(
serviceIds: Array<ServiceIdString>
): Promise<void> {
log.info(
`fetchKeysForIdentifiers: Fetching keys for ${identifiers.length} identifiers`
`fetchKeysForServiceIds: Fetching keys for ${serviceIds.length} serviceIds`
);
try {
await waitForAll({
tasks: identifiers.map(
identifier => async () => fetchKeysForIdentifier(identifier)
tasks: serviceIds.map(
serviceId => async () => fetchKeysForServiceId(serviceId)
),
});
} catch (error) {
log.error(
'fetchKeysForIdentifiers: Failed to fetch keys:',
'fetchKeysForServiceIds: Failed to fetch keys:',
Errors.toLogFormat(error)
);
throw error;
}
}
async function fetchKeysForIdentifier(
identifier: string,
async function fetchKeysForServiceId(
serviceId: ServiceIdString,
devices?: Array<number>
): Promise<void> {
log.info(
`fetchKeysForIdentifier: Fetching ${
`fetchKeysForServiceId: Fetching ${
devices || 'all'
} devices for ${identifier}`
} devices for ${serviceId}`
);
if (!window.textsecure?.messaging?.server) {
throw new Error('fetchKeysForIdentifier: No server available!');
throw new Error('fetchKeysForServiceId: No server available!');
}
const emptyConversation = window.ConversationController.getOrCreate(
identifier,
serviceId,
'private'
);
try {
// Note: we have no way to make an unrestricted unauthenticated key fetch as part of a
// story send, so we hardcode story=false.
const { accessKeyFailed } = await getKeysForIdentifier(
identifier,
const { accessKeyFailed } = await getKeysForServiceId(
serviceId,
window.textsecure?.messaging?.server,
devices,
getAccessKey(emptyConversation.attributes, { story: false })
);
if (accessKeyFailed) {
log.info(
`fetchKeysForIdentifiers: Setting sealedSender to DISABLED for conversation ${emptyConversation.idForLogging()}`
`fetchKeysForServiceIds: Setting sealedSender to DISABLED for conversation ${emptyConversation.idForLogging()}`
);
emptyConversation.set({
sealedSender: SEALED_SENDER.DISABLED,
@ -1353,13 +1362,13 @@ async function fetchKeysForIdentifier(
}
} catch (error: unknown) {
if (error instanceof UnregisteredUserError) {
await markIdentifierUnregistered(identifier);
await markServiceIdUnregistered(serviceId);
return;
}
log.error(
`fetchKeysForIdentifier: Error fetching ${
`fetchKeysForServiceId: Error fetching ${
devices || 'all'
} devices for ${identifier}`,
} devices for ${serviceId}`,
Errors.toLogFormat(error)
);
throw error;