Page MenuHomePhabricator
Differential D11346

[lib][native] Call backup restore protocol after QR auth
ClosedPublic
Actions

Authored by bartek on Mar 18 2024, 4:31 AM.
Tags
None
Referenced Files
Unknown Object (File)
Thu, Apr 24, 9:44 AM
Unknown Object (File)
Thu, Apr 24, 2:05 AM
Unknown Object (File)
Wed, Apr 23, 11:11 PM
Unknown Object (File)
Wed, Apr 23, 11:07 PM
Unknown Object (File)
Wed, Apr 23, 9:31 PM
Unknown Object (File)
Wed, Apr 23, 8:27 AM
Unknown Object (File)
Sun, Apr 6, 9:08 AM
Unknown Object (File)
Wed, Apr 2, 3:07 AM
View All Files
Subscribers
ashoat
tomek

Details

Reviewers
michal
kamil
Commits
rCOMMc0e96428f4c2: [lib][native] Call backup restore protocol after QR auth
Summary
  • On primary device, replaced stub values with actual backup keys
  • On secondary device, added a function to call backup restore protocol when received backup keys from primary device

Depends on D11345

Test Plan
  • Verified that backup keys are retrieved and sent to the secondary device
  • Verified that backup data is downloaded on the secondary device

Diff Detail

Repository
rCOMM Comm
Lint
No Lint Coverage
Unit
No Test Coverage

Revision Contents
Changeset List

PathSize
lib/
components/
15 lines
types/
17 lines
native/
backup/
2 lines
profile/
19 lines
qr-code/
11 lines

Diff 38122

View Options

lib/components/qr-auth-handler.react.js

// @flow // @flow
import invariant from 'invariant';
import * as React from 'react';
import uuid from 'uuid'; import uuid from 'uuid';
import { dmOpSpecs } from './dm-op-specs.js'; import { dmOpSpecs } from './dm-op-specs.js';
import type { DMOperation } from '../../types/dm-ops.js'; import { useProcessAndSendDMOperation } from './process-dm-ops.js';
import type {
CreateThickRawThreadInfoInput,
DMAddMembersOperation,
DMAddViewerToThreadMembersOperation,
DMOperation,
} from '../../types/dm-ops.js';
import type { ThreadInfo } from '../../types/minimally-encoded-thread-permissions-types.js';
import type { InboundActionMetadata } from '../../types/redux-types.js'; import type { InboundActionMetadata } from '../../types/redux-types.js';
import { import {
outboundP2PMessageStatuses, outboundP2PMessageStatuses,
type OutboundP2PMessage, type OutboundP2PMessage,
} from '../../types/sqlite-types.js'; } from '../../types/sqlite-types.js';
import {
assertThickThreadType,
thickThreadTypes,
} from '../../types/thread-types-enum.js';
import type { RawThreadInfos } from '../../types/thread-types.js'; import type { RawThreadInfos } from '../../types/thread-types.js';
import { import {
type DMOperationP2PMessage, type DMOperationP2PMessage,
userActionsP2PMessageTypes, userActionsP2PMessageTypes,
} from '../../types/tunnelbroker/user-actions-peer-to-peer-message-types.js'; } from '../../types/tunnelbroker/user-actions-peer-to-peer-message-types.js';
import type { CurrentUserInfo } from '../../types/user-types.js'; import type { CurrentUserInfo } from '../../types/user-types.js';
import { getContentSigningKey } from '../../utils/crypto-utils.js'; import { getContentSigningKey } from '../../utils/crypto-utils.js';
import { useSelector } from '../../utils/redux-utils.js';
function generateMessagesToPeers( function generateMessagesToPeers(
message: DMOperation, message: DMOperation,
peers: $ReadOnlyArray<{ peers: $ReadOnlyArray<{
+userID: string, +userID: string,
+deviceID: string, +deviceID: string,
}>, }>,
): $ReadOnlyArray<OutboundP2PMessage> { ): $ReadOnlyArray<OutboundP2PMessage> {
▲ Show 20 Lines • Show All 83 Lines • ▼ Show 20 Lines): Promise<$ReadOnlyArray<OutboundP2PMessage>> {
const thisDeviceID = await getContentSigningKey(); const thisDeviceID = await getContentSigningKey();
const targetPeers = peerUserIDAndDeviceIDs.filter( const targetPeers = peerUserIDAndDeviceIDs.filter(
peer => peer.deviceID !== thisDeviceID, peer => peer.deviceID !== thisDeviceID,
); );
return generateMessagesToPeers(operation.op, targetPeers); return generateMessagesToPeers(operation.op, targetPeers);
} }
export { createMessagesToPeersFromDMOp }; function getCreateThickRawThreadInfoInputFromThreadInfo(
threadInfo: ThreadInfo,
): CreateThickRawThreadInfoInput {
const roleID = Object.keys(threadInfo.roles).pop();
const thickThreadType = assertThickThreadType(threadInfo.type);
return {
threadID: threadInfo.id,
threadType: thickThreadType,
creationTime: threadInfo.creationTime,
parentThreadID: threadInfo.parentThreadID,
allMemberIDs: threadInfo.members.map(member => member.id),
roleID,
unread: !!threadInfo.currentUser.unread,
name: threadInfo.name,
avatar: threadInfo.avatar,
description: threadInfo.description,
color: threadInfo.color,
containingThreadID: threadInfo.containingThreadID,
sourceMessageID: threadInfo.sourceMessageID,
repliesCount: threadInfo.repliesCount,
pinnedCount: threadInfo.pinnedCount,
};
}
function useAddDMThreadMembers(): (
newMemberIDs: $ReadOnlyArray<string>,
threadInfo: ThreadInfo,
) => Promise<void> {
const viewerID = useSelector(
state => state.currentUserInfo && state.currentUserInfo.id,
);
const processAndSendDMOperation = useProcessAndSendDMOperation();
return React.useCallback(
async (newMemberIDs: $ReadOnlyArray<string>, threadInfo: ThreadInfo) => {
const existingThreadDetails =
getCreateThickRawThreadInfoInputFromThreadInfo(threadInfo);
invariant(viewerID, 'viewerID should be set');
const viewerToThreadMembersOperation: DMAddViewerToThreadMembersOperation =
{
type: 'add_viewer_to_thread_members',
existingThreadDetails,
editorID: viewerID,
time: Date.now(),
messageID: uuid.v4(),
addedUserIDs: newMemberIDs,
};
const viewerOperationSpecification: OutboundDMOperationSpecification = {
type: dmOperationSpecificationTypes.OUTBOUND,
op: viewerToThreadMembersOperation,
recipients: {
type: 'all_thread_members',
threadID:
threadInfo.type === thickThreadTypes.THICK_SIDEBAR &&
threadInfo.parentThreadID
? threadInfo.parentThreadID
: threadInfo.id,
},
sendOnly: true,
};
invariant(viewerID, 'viewerID should be set');
const addMembersOperation: DMAddMembersOperation = {
type: 'add_members',
threadID: threadInfo.id,
editorID: viewerID,
time: Date.now(),
messageID: uuid.v4(),
addedUserIDs: newMemberIDs,
};
const newMemberIDsSet = new Set<string>(newMemberIDs);
const addMembersOperationSpecification: OutboundDMOperationSpecification =
{
type: dmOperationSpecificationTypes.OUTBOUND,
op: addMembersOperation,
recipients: {
type: 'some_users',
userIDs: threadInfo.members
.map(member => member.id)
.filter(memberID => !newMemberIDsSet.has(memberID)),
},
};
void Promise.all([
processAndSendDMOperation(viewerOperationSpecification),
processAndSendDMOperation(addMembersOperationSpecification),
]);
},
[processAndSendDMOperation, viewerID],
);
}
export { createMessagesToPeersFromDMOp, useAddDMThreadMembers };
View Options

lib/types/backup-types.js

// @flow // @flow
import invariant from 'invariant';
import * as React from 'react';
import uuid from 'uuid'; import uuid from 'uuid';
import { dmOpSpecs } from './dm-op-specs.js'; import { dmOpSpecs } from './dm-op-specs.js';
import type { DMOperation } from '../../types/dm-ops.js'; import { useProcessAndSendDMOperation } from './process-dm-ops.js';
import type {
CreateThickRawThreadInfoInput,
DMAddMembersOperation,
DMAddViewerToThreadMembersOperation,
DMOperation,
} from '../../types/dm-ops.js';
import type { ThreadInfo } from '../../types/minimally-encoded-thread-permissions-types.js';
import type { InboundActionMetadata } from '../../types/redux-types.js'; import type { InboundActionMetadata } from '../../types/redux-types.js';
import { import {
outboundP2PMessageStatuses, outboundP2PMessageStatuses,
type OutboundP2PMessage, type OutboundP2PMessage,
} from '../../types/sqlite-types.js'; } from '../../types/sqlite-types.js';
import {
assertThickThreadType,
thickThreadTypes,
} from '../../types/thread-types-enum.js';
import type { RawThreadInfos } from '../../types/thread-types.js'; import type { RawThreadInfos } from '../../types/thread-types.js';
import { import {
type DMOperationP2PMessage, type DMOperationP2PMessage,
userActionsP2PMessageTypes, userActionsP2PMessageTypes,
} from '../../types/tunnelbroker/user-actions-peer-to-peer-message-types.js'; } from '../../types/tunnelbroker/user-actions-peer-to-peer-message-types.js';
import type { CurrentUserInfo } from '../../types/user-types.js'; import type { CurrentUserInfo } from '../../types/user-types.js';
import { getContentSigningKey } from '../../utils/crypto-utils.js'; import { getContentSigningKey } from '../../utils/crypto-utils.js';
import { useSelector } from '../../utils/redux-utils.js';
function generateMessagesToPeers( function generateMessagesToPeers(
message: DMOperation, message: DMOperation,
peers: $ReadOnlyArray<{ peers: $ReadOnlyArray<{
+userID: string, +userID: string,
+deviceID: string, +deviceID: string,
}>, }>,
): $ReadOnlyArray<OutboundP2PMessage> { ): $ReadOnlyArray<OutboundP2PMessage> {
▲ Show 20 Lines • Show All 83 Lines • ▼ Show 20 Lines): Promise<$ReadOnlyArray<OutboundP2PMessage>> {
const thisDeviceID = await getContentSigningKey(); const thisDeviceID = await getContentSigningKey();
const targetPeers = peerUserIDAndDeviceIDs.filter( const targetPeers = peerUserIDAndDeviceIDs.filter(
peer => peer.deviceID !== thisDeviceID, peer => peer.deviceID !== thisDeviceID,
); );
return generateMessagesToPeers(operation.op, targetPeers); return generateMessagesToPeers(operation.op, targetPeers);
} }
export { createMessagesToPeersFromDMOp }; function getCreateThickRawThreadInfoInputFromThreadInfo(
threadInfo: ThreadInfo,
): CreateThickRawThreadInfoInput {
const roleID = Object.keys(threadInfo.roles).pop();
const thickThreadType = assertThickThreadType(threadInfo.type);
return {
threadID: threadInfo.id,
threadType: thickThreadType,
creationTime: threadInfo.creationTime,
parentThreadID: threadInfo.parentThreadID,
allMemberIDs: threadInfo.members.map(member => member.id),
roleID,
unread: !!threadInfo.currentUser.unread,
name: threadInfo.name,
avatar: threadInfo.avatar,
description: threadInfo.description,
color: threadInfo.color,
containingThreadID: threadInfo.containingThreadID,
sourceMessageID: threadInfo.sourceMessageID,
repliesCount: threadInfo.repliesCount,
pinnedCount: threadInfo.pinnedCount,
};
}
function useAddDMThreadMembers(): (
newMemberIDs: $ReadOnlyArray<string>,
threadInfo: ThreadInfo,
) => Promise<void> {
const viewerID = useSelector(
state => state.currentUserInfo && state.currentUserInfo.id,
);
const processAndSendDMOperation = useProcessAndSendDMOperation();
return React.useCallback(
async (newMemberIDs: $ReadOnlyArray<string>, threadInfo: ThreadInfo) => {
const existingThreadDetails =
getCreateThickRawThreadInfoInputFromThreadInfo(threadInfo);
invariant(viewerID, 'viewerID should be set');
const viewerToThreadMembersOperation: DMAddViewerToThreadMembersOperation =
{
type: 'add_viewer_to_thread_members',
existingThreadDetails,
editorID: viewerID,
time: Date.now(),
messageID: uuid.v4(),
addedUserIDs: newMemberIDs,
};
const viewerOperationSpecification: OutboundDMOperationSpecification = {
type: dmOperationSpecificationTypes.OUTBOUND,
op: viewerToThreadMembersOperation,
recipients: {
type: 'all_thread_members',
threadID:
threadInfo.type === thickThreadTypes.THICK_SIDEBAR &&
threadInfo.parentThreadID
? threadInfo.parentThreadID
: threadInfo.id,
},
sendOnly: true,
};
invariant(viewerID, 'viewerID should be set');
const addMembersOperation: DMAddMembersOperation = {
type: 'add_members',
threadID: threadInfo.id,
editorID: viewerID,
time: Date.now(),
messageID: uuid.v4(),
addedUserIDs: newMemberIDs,
};
const newMemberIDsSet = new Set<string>(newMemberIDs);
const addMembersOperationSpecification: OutboundDMOperationSpecification =
{
type: dmOperationSpecificationTypes.OUTBOUND,
op: addMembersOperation,
recipients: {
type: 'some_users',
userIDs: threadInfo.members
.map(member => member.id)
.filter(memberID => !newMemberIDsSet.has(memberID)),
},
};
void Promise.all([
processAndSendDMOperation(viewerOperationSpecification),
processAndSendDMOperation(addMembersOperationSpecification),
]);
},
[processAndSendDMOperation, viewerID],
);
}
export { createMessagesToPeersFromDMOp, useAddDMThreadMembers };
View Options

native/backup/use-client-backup.js

// @flow // @flow
import invariant from 'invariant';
import * as React from 'react';
import uuid from 'uuid'; import uuid from 'uuid';
import { dmOpSpecs } from './dm-op-specs.js'; import { dmOpSpecs } from './dm-op-specs.js';
import type { DMOperation } from '../../types/dm-ops.js'; import { useProcessAndSendDMOperation } from './process-dm-ops.js';
import type {
CreateThickRawThreadInfoInput,
DMAddMembersOperation,
DMAddViewerToThreadMembersOperation,
DMOperation,
} from '../../types/dm-ops.js';
import type { ThreadInfo } from '../../types/minimally-encoded-thread-permissions-types.js';
import type { InboundActionMetadata } from '../../types/redux-types.js'; import type { InboundActionMetadata } from '../../types/redux-types.js';
import { import {
outboundP2PMessageStatuses, outboundP2PMessageStatuses,
type OutboundP2PMessage, type OutboundP2PMessage,
} from '../../types/sqlite-types.js'; } from '../../types/sqlite-types.js';
import {
assertThickThreadType,
thickThreadTypes,
} from '../../types/thread-types-enum.js';
import type { RawThreadInfos } from '../../types/thread-types.js'; import type { RawThreadInfos } from '../../types/thread-types.js';
import { import {
type DMOperationP2PMessage, type DMOperationP2PMessage,
userActionsP2PMessageTypes, userActionsP2PMessageTypes,
} from '../../types/tunnelbroker/user-actions-peer-to-peer-message-types.js'; } from '../../types/tunnelbroker/user-actions-peer-to-peer-message-types.js';
import type { CurrentUserInfo } from '../../types/user-types.js'; import type { CurrentUserInfo } from '../../types/user-types.js';
import { getContentSigningKey } from '../../utils/crypto-utils.js'; import { getContentSigningKey } from '../../utils/crypto-utils.js';
import { useSelector } from '../../utils/redux-utils.js';
function generateMessagesToPeers( function generateMessagesToPeers(
message: DMOperation, message: DMOperation,
peers: $ReadOnlyArray<{ peers: $ReadOnlyArray<{
+userID: string, +userID: string,
+deviceID: string, +deviceID: string,
}>, }>,
): $ReadOnlyArray<OutboundP2PMessage> { ): $ReadOnlyArray<OutboundP2PMessage> {
▲ Show 20 Lines • Show All 83 Lines • ▼ Show 20 Lines): Promise<$ReadOnlyArray<OutboundP2PMessage>> {
const thisDeviceID = await getContentSigningKey(); const thisDeviceID = await getContentSigningKey();
const targetPeers = peerUserIDAndDeviceIDs.filter( const targetPeers = peerUserIDAndDeviceIDs.filter(
peer => peer.deviceID !== thisDeviceID, peer => peer.deviceID !== thisDeviceID,
); );
return generateMessagesToPeers(operation.op, targetPeers); return generateMessagesToPeers(operation.op, targetPeers);
} }
export { createMessagesToPeersFromDMOp }; function getCreateThickRawThreadInfoInputFromThreadInfo(
threadInfo: ThreadInfo,
): CreateThickRawThreadInfoInput {
const roleID = Object.keys(threadInfo.roles).pop();
const thickThreadType = assertThickThreadType(threadInfo.type);
return {
threadID: threadInfo.id,
threadType: thickThreadType,
creationTime: threadInfo.creationTime,
parentThreadID: threadInfo.parentThreadID,
allMemberIDs: threadInfo.members.map(member => member.id),
roleID,
unread: !!threadInfo.currentUser.unread,
name: threadInfo.name,
avatar: threadInfo.avatar,
description: threadInfo.description,
color: threadInfo.color,
containingThreadID: threadInfo.containingThreadID,
sourceMessageID: threadInfo.sourceMessageID,
repliesCount: threadInfo.repliesCount,
pinnedCount: threadInfo.pinnedCount,
};
}
function useAddDMThreadMembers(): (
newMemberIDs: $ReadOnlyArray<string>,
threadInfo: ThreadInfo,
) => Promise<void> {
const viewerID = useSelector(
state => state.currentUserInfo && state.currentUserInfo.id,
);
const processAndSendDMOperation = useProcessAndSendDMOperation();
return React.useCallback(
async (newMemberIDs: $ReadOnlyArray<string>, threadInfo: ThreadInfo) => {
const existingThreadDetails =
getCreateThickRawThreadInfoInputFromThreadInfo(threadInfo);
invariant(viewerID, 'viewerID should be set');
const viewerToThreadMembersOperation: DMAddViewerToThreadMembersOperation =
{
type: 'add_viewer_to_thread_members',
existingThreadDetails,
editorID: viewerID,
time: Date.now(),
messageID: uuid.v4(),
addedUserIDs: newMemberIDs,
};
const viewerOperationSpecification: OutboundDMOperationSpecification = {
type: dmOperationSpecificationTypes.OUTBOUND,
op: viewerToThreadMembersOperation,
recipients: {
type: 'all_thread_members',
threadID:
threadInfo.type === thickThreadTypes.THICK_SIDEBAR &&
threadInfo.parentThreadID
? threadInfo.parentThreadID
: threadInfo.id,
},
sendOnly: true,
};
invariant(viewerID, 'viewerID should be set');
const addMembersOperation: DMAddMembersOperation = {
type: 'add_members',
threadID: threadInfo.id,
editorID: viewerID,
time: Date.now(),
messageID: uuid.v4(),
addedUserIDs: newMemberIDs,
};
const newMemberIDsSet = new Set<string>(newMemberIDs);
const addMembersOperationSpecification: OutboundDMOperationSpecification =
{
type: dmOperationSpecificationTypes.OUTBOUND,
op: addMembersOperation,
recipients: {
type: 'some_users',
userIDs: threadInfo.members
.map(member => member.id)
.filter(memberID => !newMemberIDsSet.has(memberID)),
},
};
void Promise.all([
processAndSendDMOperation(viewerOperationSpecification),
processAndSendDMOperation(addMembersOperationSpecification),
]);
},
[processAndSendDMOperation, viewerID],
);
}
export { createMessagesToPeersFromDMOp, useAddDMThreadMembers };
View Options

native/profile/secondary-device-qr-code-scanner.react.js

// @flow // @flow
import invariant from 'invariant';
import * as React from 'react';
import uuid from 'uuid'; import uuid from 'uuid';
import { dmOpSpecs } from './dm-op-specs.js'; import { dmOpSpecs } from './dm-op-specs.js';
import type { DMOperation } from '../../types/dm-ops.js'; import { useProcessAndSendDMOperation } from './process-dm-ops.js';
import type {
CreateThickRawThreadInfoInput,
DMAddMembersOperation,
DMAddViewerToThreadMembersOperation,
DMOperation,
} from '../../types/dm-ops.js';
import type { ThreadInfo } from '../../types/minimally-encoded-thread-permissions-types.js';
import type { InboundActionMetadata } from '../../types/redux-types.js'; import type { InboundActionMetadata } from '../../types/redux-types.js';
import { import {
outboundP2PMessageStatuses, outboundP2PMessageStatuses,
type OutboundP2PMessage, type OutboundP2PMessage,
} from '../../types/sqlite-types.js'; } from '../../types/sqlite-types.js';
import {
assertThickThreadType,
thickThreadTypes,
} from '../../types/thread-types-enum.js';
import type { RawThreadInfos } from '../../types/thread-types.js'; import type { RawThreadInfos } from '../../types/thread-types.js';
import { import {
type DMOperationP2PMessage, type DMOperationP2PMessage,
userActionsP2PMessageTypes, userActionsP2PMessageTypes,
} from '../../types/tunnelbroker/user-actions-peer-to-peer-message-types.js'; } from '../../types/tunnelbroker/user-actions-peer-to-peer-message-types.js';
import type { CurrentUserInfo } from '../../types/user-types.js'; import type { CurrentUserInfo } from '../../types/user-types.js';
import { getContentSigningKey } from '../../utils/crypto-utils.js'; import { getContentSigningKey } from '../../utils/crypto-utils.js';
import { useSelector } from '../../utils/redux-utils.js';
function generateMessagesToPeers( function generateMessagesToPeers(
message: DMOperation, message: DMOperation,
peers: $ReadOnlyArray<{ peers: $ReadOnlyArray<{
+userID: string, +userID: string,
+deviceID: string, +deviceID: string,
}>, }>,
): $ReadOnlyArray<OutboundP2PMessage> { ): $ReadOnlyArray<OutboundP2PMessage> {
▲ Show 20 Lines • Show All 83 Lines • ▼ Show 20 Lines): Promise<$ReadOnlyArray<OutboundP2PMessage>> {
const thisDeviceID = await getContentSigningKey(); const thisDeviceID = await getContentSigningKey();
const targetPeers = peerUserIDAndDeviceIDs.filter( const targetPeers = peerUserIDAndDeviceIDs.filter(
peer => peer.deviceID !== thisDeviceID, peer => peer.deviceID !== thisDeviceID,
); );
return generateMessagesToPeers(operation.op, targetPeers); return generateMessagesToPeers(operation.op, targetPeers);
} }
export { createMessagesToPeersFromDMOp }; function getCreateThickRawThreadInfoInputFromThreadInfo(
threadInfo: ThreadInfo,
): CreateThickRawThreadInfoInput {
const roleID = Object.keys(threadInfo.roles).pop();
const thickThreadType = assertThickThreadType(threadInfo.type);
return {
threadID: threadInfo.id,
threadType: thickThreadType,
creationTime: threadInfo.creationTime,
parentThreadID: threadInfo.parentThreadID,
allMemberIDs: threadInfo.members.map(member => member.id),
roleID,
unread: !!threadInfo.currentUser.unread,
name: threadInfo.name,
avatar: threadInfo.avatar,
description: threadInfo.description,
color: threadInfo.color,
containingThreadID: threadInfo.containingThreadID,
sourceMessageID: threadInfo.sourceMessageID,
repliesCount: threadInfo.repliesCount,
pinnedCount: threadInfo.pinnedCount,
};
}
function useAddDMThreadMembers(): (
newMemberIDs: $ReadOnlyArray<string>,
threadInfo: ThreadInfo,
) => Promise<void> {
const viewerID = useSelector(
state => state.currentUserInfo && state.currentUserInfo.id,
);
const processAndSendDMOperation = useProcessAndSendDMOperation();
return React.useCallback(
async (newMemberIDs: $ReadOnlyArray<string>, threadInfo: ThreadInfo) => {
const existingThreadDetails =
getCreateThickRawThreadInfoInputFromThreadInfo(threadInfo);
invariant(viewerID, 'viewerID should be set');
const viewerToThreadMembersOperation: DMAddViewerToThreadMembersOperation =
{
type: 'add_viewer_to_thread_members',
existingThreadDetails,
editorID: viewerID,
time: Date.now(),
messageID: uuid.v4(),
addedUserIDs: newMemberIDs,
};
const viewerOperationSpecification: OutboundDMOperationSpecification = {
type: dmOperationSpecificationTypes.OUTBOUND,
op: viewerToThreadMembersOperation,
recipients: {
type: 'all_thread_members',
threadID:
threadInfo.type === thickThreadTypes.THICK_SIDEBAR &&
threadInfo.parentThreadID
? threadInfo.parentThreadID
: threadInfo.id,
},
sendOnly: true,
};
invariant(viewerID, 'viewerID should be set');
const addMembersOperation: DMAddMembersOperation = {
type: 'add_members',
threadID: threadInfo.id,
editorID: viewerID,
time: Date.now(),
messageID: uuid.v4(),
addedUserIDs: newMemberIDs,
};
const newMemberIDsSet = new Set<string>(newMemberIDs);
const addMembersOperationSpecification: OutboundDMOperationSpecification =
{
type: dmOperationSpecificationTypes.OUTBOUND,
op: addMembersOperation,
recipients: {
type: 'some_users',
userIDs: threadInfo.members
.map(member => member.id)
.filter(memberID => !newMemberIDsSet.has(memberID)),
},
};
void Promise.all([
processAndSendDMOperation(viewerOperationSpecification),
processAndSendDMOperation(addMembersOperationSpecification),
]);
},
[processAndSendDMOperation, viewerID],
);
}
export { createMessagesToPeersFromDMOp, useAddDMThreadMembers };
View Options

native/qr-code/qr-code-screen.react.js

Loading...