Paths

Table of Contentst

-
keyserver/src/
-
src/
-
keyserver.js
-
lib/facts/
-
facts/
2/2
links.js
-
native/qr-code/
-
qr-code/
2/2
qr-code-screen.react.js
-
web/account/
-
account/
2/2
qr-code-login.react.js

native] Covert AES-256 key from Uint8Array representation to hex string representation
ClosedPublic
Actions

Authored by rohan on Sep 14 2023, 7:58 AM.

Details

Reviewers

atul
varun
bartek
ginsu

Commits

rCOMM9a08fd6f2883: [keyserver/web/native] Covert AES-256 key from Uint8Array representation to hex…

Summary

I think it makes the most sense to handle this conversion from Uint8Array to string before encoding the data in the QR codes, so clients reading the QR code don't need to handle it. I used @bartek's helper functions in lib/media/data-utils.js to achieve this.

Addresses ENG-4934

Depends on D9181

Test Plan

Logged the URL being encoded into the QR code, and parsed out the keys to make sure they were correct

const url = 'comm://qr-code/%7B%22aes256%22%3A%22b7990e4614f46bd8958df23c5c799110fdef8bc29a9a8821de60aad9e9e72c7f%22%2C%22ed25519%22%3A%22dbe%2FGygnpkyvW0GVMqwLuaiWAL6F9yoAwS3FO2BMhls%22%7D';

const qrCodeKeysRegex = /qr-code\/(\S+)$/;
const qrCodeKeysMatch = qrCodeKeysRegex.exec(url)[1];

const keys = JSON.parse(decodeURIComponent(qrCodeKeysMatch));

console.log(keys);

Output:

{
  aes256: 'b7990e4614f46bd8958df23c5c799110fdef8bc29a9a8821de60aad9e9e72c7f',
  ed25519: 'dbe/GygnpkyvW0GVMqwLuaiWAL6F9yoAwS3FO2BMhls'
}

Diff Detail

Repository

rCOMM Comm

Branch

terminal_qr

Lint

No Lint Coverage

Unit

No Test Coverage

Event Timeline

rohan created this revision.Sep 14 2023, 7:58 AM

Herald added subscribers: tomek, ashoat. · View Herald TranscriptSep 14 2023, 7:58 AM

rohan edited the summary of this revision. (Show Details)Sep 14 2023, 7:58 AM

rohan added reviewers: atul, varun, bartek.

rohan added a reviewer: ginsu.

rohan removed a parent revision: D9180: [keyserver] Print out a QR code to the terminal.Sep 14 2023, 8:03 AM

rohan edited the summary of this revision. (Show Details)

rohan added a parent revision: D9181: [keyserver] Generate an AES256 key (ephemeral) to encode.

Harbormaster completed remote builds in B22632: Diff 31136.Sep 14 2023, 8:16 AM

rohan requested review of this revision.Sep 14 2023, 8:16 AM

Code looks good to me, but resigning to give others a chance to review

rohan added a child revision: D9220: [keyserver] Encode the device id into the QR code.Sep 18 2023, 10:01 AM

accepting with nit inline

web/account/qr-code-login.react.js
25–26	i think we can name these better. maybe `rawAESKey` and `aesKeyAsHexString`. open to alternatives, just don't love calling the `Uint8Array` version of the key `aes256` same in native

This revision is now accepted and ready to land.Sep 20 2023, 10:01 PM

Use rawAESKey and aesKeyAsHexString

Harbormaster completed remote builds in B22777: Diff 31336.Sep 21 2023, 6:48 AM

Closed by commit rCOMM9a08fd6f2883: [keyserver/web/native] Covert AES-256 key from Uint8Array representation to hex… (authored by rohan). · Explain WhySep 22 2023, 7:40 AM

This revision was automatically updated to reflect the committed changes.

rohan added a commit: rCOMM9a08fd6f2883: [keyserver/web/native] Covert AES-256 key from Uint8Array representation to hex….

rohan mentioned this in D9093: [lib/web/native] Generate and encode an ephemeral AES-256 key in the QR code.Oct 24 2023, 9:19 AM

Revision Contents
Changeset List

Path

Size

keyserver/

src/

keyserver.js

2 lines

lib/

facts/

links.js

2 lines

native/

qr-code/

qr-code-screen.react.js

5 lines

web/

account/

qr-code-login.react.js

5 lines

Diff 31136

View Options

keyserver/src/keyserver.js

// @flow		// @flow

		import invariant from 'invariant';

import {		import {
setThreadUnreadStatusActionTypes,		setThreadUnreadStatusActionTypes,
updateActivityActionTypes,		updateActivityActionTypes,
} from '../actions/activity-actions.js';		} from '../actions/activity-actions.js';
import { setClientDBStoreActionType } from '../actions/client-db-store-actions.js';		import { setClientDBStoreActionType } from '../actions/client-db-store-actions.js';
import { saveMessagesActionType } from '../actions/message-actions.js';		import { saveMessagesActionType } from '../actions/message-actions.js';
import { siweAuthActionTypes } from '../actions/siwe-actions.js';		import { siweAuthActionTypes } from '../actions/siwe-actions.js';
import {		import {
Show All 15 Lines	import {
updateSubscriptionActionTypes,		updateSubscriptionActionTypes,
} from '../actions/user-actions.js';		} from '../actions/user-actions.js';
import {		import {
type ThreadStoreOperation,		type ThreadStoreOperation,
threadStoreOpsHandlers,		threadStoreOpsHandlers,
} from '../ops/thread-store-ops.js';		} from '../ops/thread-store-ops.js';
import { stateSyncSpecs } from '../shared/state-sync/state-sync-specs.js';		import { stateSyncSpecs } from '../shared/state-sync/state-sync-specs.js';
import { updateSpecs } from '../shared/updates/update-specs.js';		import { updateSpecs } from '../shared/updates/update-specs.js';
		import type { MinimallyEncodedRawThreadInfo } from '../types/minimally-encoded-thread-permissions-types.js';
import type { BaseAction } from '../types/redux-types.js';		import type { BaseAction } from '../types/redux-types.js';
import { type ClientThreadInconsistencyReportCreationRequest } from '../types/report-types.js';		import { type ClientThreadInconsistencyReportCreationRequest } from '../types/report-types.js';
import {		import {
serverRequestTypes,		serverRequestTypes,
processServerRequestsActionType,		processServerRequestsActionType,
} from '../types/request-types.js';		} from '../types/request-types.js';
import {		import {
fullStateSyncActionType,		fullStateSyncActionType,
incrementalStateSyncActionType,		incrementalStateSyncActionType,
} from '../types/socket-types.js';		} from '../types/socket-types.js';
import type {		import type {
RawThreadInfo,		MinimallyEncodedRawThreadInfos,
RawThreadInfos,
ThreadStore,		ThreadStore,
} from '../types/thread-types.js';		} from '../types/thread-types.js';
import {		import {
type ClientUpdateInfo,		type ClientUpdateInfo,
processUpdatesActionType,		processUpdatesActionType,
} from '../types/update-types.js';		} from '../types/update-types.js';
import { setNewSessionActionType } from '../utils/action-utils.js';		import { setNewSessionActionType } from '../utils/action-utils.js';

const { processStoreOperations: processThreadStoreOperations } =		const { processStoreOperations: processThreadStoreOperations } =
threadStoreOpsHandlers;		threadStoreOpsHandlers;

function generateOpsForThreadUpdates(		function generateOpsForThreadUpdates(
threadInfos: RawThreadInfos,		threadInfos: MinimallyEncodedRawThreadInfos,
payload: {		payload: {
+updatesResult: { +newUpdates: $ReadOnlyArray<ClientUpdateInfo>, ... },		+updatesResult: { +newUpdates: $ReadOnlyArray<ClientUpdateInfo>, ... },
...		...
},		},
): $ReadOnlyArray<ThreadStoreOperation> {		): $ReadOnlyArray<ThreadStoreOperation> {
return payload.updatesResult.newUpdates		return payload.updatesResult.newUpdates
.map(update =>		.map(update =>
updateSpecs[update.type].generateOpsForThreadUpdates?.(		updateSpecs[update.type].generateOpsForThreadUpdates?.(
Show All 19 Lines	if (
action.type === registerActionTypes.success \|\|		action.type === registerActionTypes.success \|\|
action.type === fullStateSyncActionType		action.type === fullStateSyncActionType
) {		) {
const newThreadInfos = action.payload.threadInfos;		const newThreadInfos = action.payload.threadInfos;
const threadStoreOperations = [		const threadStoreOperations = [
{		{
type: 'remove_all',		type: 'remove_all',
},		},
...Object.keys(newThreadInfos).map((id: string) => ({		...Object.keys(newThreadInfos).map((id: string) => {
		invariant(
		newThreadInfos[id].minimallyEncoded,
		'newThreadInfos must be minimallyEncoded for current clients',
		);
		atulAuthorUnsubmitted Done Inline Actions I thought putting an `invariant` here was a reasonable trade-off vs. refactoring the types in the `fullStateSyncActionType` payload (specifically `StateSyncFullActionPayload` which is derived from `ClientFullStateSync` which is derived from `BaseFullStateSync`) which are used across clients and keyserver. Open to re-exploring if that would be preferred. atul: I thought putting an `invariant` here was a reasonable trade-off vs. refactoring the types in…
		return {
type: 'replace',		type: 'replace',
payload: { id, threadInfo: newThreadInfos[id] },		payload: { id, threadInfo: newThreadInfos[id] },
})),		};
		}),
];		];
const updatedThreadStore = processThreadStoreOperations(		const updatedThreadStore = processThreadStoreOperations(
state,		state,
threadStoreOperations,		threadStoreOperations,
);		);
return {		return {
threadStore: updatedThreadStore,		threadStore: updatedThreadStore,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
▲ Show 20 Lines • Show All 58 Lines • ▼ Show 20 Lines	) {
return {		return {
threadStore: updatedThreadStore,		threadStore: updatedThreadStore,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations,		threadStoreOperations,
};		};
} else if (action.type === updateSubscriptionActionTypes.success) {		} else if (action.type === updateSubscriptionActionTypes.success) {
const { threadID, subscription } = action.payload;		const { threadID, subscription } = action.payload;
const threadInfo = state.threadInfos[threadID];		const threadInfo = state.threadInfos[threadID];
// TODO (atul): Try to get rid of this ridiculous branching.
if (threadInfo.minimallyEncoded) {
const newThreadInfo = {
...threadInfo,
currentUser: {
...threadInfo.currentUser,
subscription,
},
};
const threadStoreOperations = [
{
type: 'replace',
payload: {
id: threadID,
threadInfo: newThreadInfo,
},
},
];
const updatedThreadStore = processThreadStoreOperations(
state,
threadStoreOperations,
);
return {
threadStore: updatedThreadStore,
newThreadInconsistencies: [],
threadStoreOperations,
};
} else {
const newThreadInfo = {		const newThreadInfo = {
...threadInfo,		...threadInfo,
currentUser: {		currentUser: {
...threadInfo.currentUser,		...threadInfo.currentUser,
subscription,		subscription,
},		},
};		};
const threadStoreOperations = [		const threadStoreOperations = [
{		{
type: 'replace',		type: 'replace',
payload: {		payload: {
id: threadID,		id: threadID,
threadInfo: newThreadInfo,		threadInfo: newThreadInfo,
},		},
},		},
];		];
const updatedThreadStore = processThreadStoreOperations(		const updatedThreadStore = processThreadStoreOperations(
state,		state,
threadStoreOperations,		threadStoreOperations,
);		);
return {		return {
threadStore: updatedThreadStore,		threadStore: updatedThreadStore,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations,		threadStoreOperations,
};		};
}
} else if (action.type === saveMessagesActionType) {		} else if (action.type === saveMessagesActionType) {
const threadIDToMostRecentTime = new Map<string, number>();		const threadIDToMostRecentTime = new Map<string, number>();
for (const messageInfo of action.payload.rawMessageInfos) {		for (const messageInfo of action.payload.rawMessageInfos) {
const current = threadIDToMostRecentTime.get(messageInfo.threadID);		const current = threadIDToMostRecentTime.get(messageInfo.threadID);
if (!current \|\| current < messageInfo.time) {		if (!current \|\| current < messageInfo.time) {
threadIDToMostRecentTime.set(messageInfo.threadID, messageInfo.time);		threadIDToMostRecentTime.set(messageInfo.threadID, messageInfo.time);
}		}
}		}
const changedThreadInfos: { [string]: RawThreadInfo } = {};		const changedThreadInfos: { [string]: MinimallyEncodedRawThreadInfo } = {};
for (const [threadID, mostRecentTime] of threadIDToMostRecentTime) {		for (const [threadID, mostRecentTime] of threadIDToMostRecentTime) {
const threadInfo = state.threadInfos[threadID];		const threadInfo = state.threadInfos[threadID];
if (		if (
!threadInfo \|\|		!threadInfo \|\|
threadInfo.currentUser.unread \|\|		threadInfo.currentUser.unread \|\|
action.payload.updatesCurrentAsOf > mostRecentTime		action.payload.updatesCurrentAsOf > mostRecentTime
) {		) {
continue;		continue;
}		}
const changedThreadInfo = state.threadInfos[threadID];		const changedThreadInfo = state.threadInfos[threadID];
// TODO (atul): Try to get rid of this ridiculous branching.
if (changedThreadInfo.minimallyEncoded) {
changedThreadInfos[threadID] = {
...changedThreadInfo,
currentUser: {
...changedThreadInfo.currentUser,
unread: true,
},
};
} else {
changedThreadInfos[threadID] = {		changedThreadInfos[threadID] = {
...changedThreadInfo,		...changedThreadInfo,
currentUser: {		currentUser: {
...changedThreadInfo.currentUser,		...changedThreadInfo.currentUser,
unread: true,		unread: true,
},		},
};		};
}		}
}
if (Object.keys(changedThreadInfos).length !== 0) {		if (Object.keys(changedThreadInfos).length !== 0) {
const threadStoreOperations = Object.keys(changedThreadInfos).map(id => ({		const threadStoreOperations = Object.keys(changedThreadInfos).map(id => ({
type: 'replace',		type: 'replace',
payload: {		payload: {
id,		id,
threadInfo: changedThreadInfos[id],		threadInfo: changedThreadInfos[id],
},		},
}));		}));
Show All 25 Lines	if (!rawThreadInfos && !deleteThreadIDs) {
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations: [],		threadStoreOperations: [],
};		};
}		}

const threadStoreOperations: ThreadStoreOperation[] = [];		const threadStoreOperations: ThreadStoreOperation[] = [];
if (rawThreadInfos) {		if (rawThreadInfos) {
for (const rawThreadInfo of rawThreadInfos) {		for (const rawThreadInfo of rawThreadInfos) {
		invariant(
		rawThreadInfo.minimallyEncoded,
		'rawThreadInfo must be minimallyEncoded on new clients',
		);
		atulAuthorUnsubmitted Done Inline Actions Similarly thought this was a reasonable trade-off to avoid having to refactor types related to state check mechanism. Open to re-exploring if that would be preferred. atul: Similarly thought this was a reasonable trade-off to avoid having to refactor types related to…
threadStoreOperations.push({		threadStoreOperations.push({
type: 'replace',		type: 'replace',
payload: {		payload: {
id: rawThreadInfo.id,		id: rawThreadInfo.id,
threadInfo: rawThreadInfo,		threadInfo: rawThreadInfo,
},		},
});		});
}		}
Show All 20 Lines	const newThreadInconsistencies =
);		);

return {		return {
threadStore: updatedThreadStore,		threadStore: updatedThreadStore,
newThreadInconsistencies,		newThreadInconsistencies,
threadStoreOperations,		threadStoreOperations,
};		};
} else if (action.type === updateActivityActionTypes.success) {		} else if (action.type === updateActivityActionTypes.success) {
const updatedThreadInfos: { [string]: RawThreadInfo } = {};		const updatedThreadInfos: { [string]: MinimallyEncodedRawThreadInfo } = {};
for (const setToUnread of action.payload.result.unfocusedToUnread) {		for (const setToUnread of action.payload.result.unfocusedToUnread) {
const threadInfo = state.threadInfos[setToUnread];		const threadInfo = state.threadInfos[setToUnread];
// TODO (atul): Try to get rid of this ridiculous branching.
if (threadInfo.minimallyEncoded) {
if (threadInfo && !threadInfo.currentUser.unread) {
updatedThreadInfos[setToUnread] = {
...threadInfo,
currentUser: {
...threadInfo.currentUser,
unread: true,
},
};
}
} else {
if (threadInfo && !threadInfo.currentUser.unread) {		if (threadInfo && !threadInfo.currentUser.unread) {
updatedThreadInfos[setToUnread] = {		updatedThreadInfos[setToUnread] = {
...threadInfo,		...threadInfo,
currentUser: {		currentUser: {
...threadInfo.currentUser,		...threadInfo.currentUser,
unread: true,		unread: true,
},		},
};		};
}		}
}		}
}

if (Object.keys(updatedThreadInfos).length === 0) {		if (Object.keys(updatedThreadInfos).length === 0) {
return {		return {
threadStore: state,		threadStore: state,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations: [],		threadStoreOperations: [],
};		};
}		}
const threadStoreOperations = Object.keys(updatedThreadInfos).map(id => ({		const threadStoreOperations = Object.keys(updatedThreadInfos).map(id => ({
Show All 10 Lines	) {
return {		return {
threadStore: updatedThreadStore,		threadStore: updatedThreadStore,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations,		threadStoreOperations,
};		};
} else if (action.type === setThreadUnreadStatusActionTypes.started) {		} else if (action.type === setThreadUnreadStatusActionTypes.started) {
const { threadID, unread } = action.payload;		const { threadID, unread } = action.payload;
const threadInfo = state.threadInfos[threadID];		const threadInfo = state.threadInfos[threadID];
// TODO (atul): Try to get rid of this ridiculous branching.
if (threadInfo.minimallyEncoded) {
const updatedThreadInfo = {
...threadInfo,
currentUser: {
...threadInfo.currentUser,
unread,
},
};
const threadStoreOperations = [
{
type: 'replace',
payload: {
id: threadID,
threadInfo: updatedThreadInfo,
},
},
];
const updatedThreadStore = processThreadStoreOperations(
state,
threadStoreOperations,
);
return {
threadStore: updatedThreadStore,
newThreadInconsistencies: [],
threadStoreOperations,
};
} else {
const updatedThreadInfo = {		const updatedThreadInfo = {
...threadInfo,		...threadInfo,
currentUser: {		currentUser: {
...threadInfo.currentUser,		...threadInfo.currentUser,
unread,		unread,
},		},
};		};
const threadStoreOperations = [		const threadStoreOperations = [
{		{
type: 'replace',		type: 'replace',
payload: {		payload: {
id: threadID,		id: threadID,
threadInfo: updatedThreadInfo,		threadInfo: updatedThreadInfo,
},		},
},		},
];		];
const updatedThreadStore = processThreadStoreOperations(		const updatedThreadStore = processThreadStoreOperations(
state,		state,
threadStoreOperations,		threadStoreOperations,
);		);
return {		return {
threadStore: updatedThreadStore,		threadStore: updatedThreadStore,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations,		threadStoreOperations,
};		};
}
} else if (action.type === setThreadUnreadStatusActionTypes.success) {		} else if (action.type === setThreadUnreadStatusActionTypes.success) {
const { threadID, resetToUnread } = action.payload;		const { threadID, resetToUnread } = action.payload;
const currentUser = state.threadInfos[threadID].currentUser;		const currentUser = state.threadInfos[threadID].currentUser;

if (!resetToUnread \|\| currentUser.unread) {		if (!resetToUnread \|\| currentUser.unread) {
return {		return {
threadStore: state,		threadStore: state,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations: [],		threadStoreOperations: [],
};		};
}		}

const threadInfo = state.threadInfos[threadID];		const threadInfo = state.threadInfos[threadID];
// TODO (atul): Try to get rid of this ridiculous branching.
if (threadInfo.minimallyEncoded) {
const updatedThread = {		const updatedThread = {
...threadInfo,		...threadInfo,
currentUser: { ...threadInfo.currentUser, unread: true },		currentUser: { ...threadInfo.currentUser, unread: true },
};		};
const threadStoreOperations = [		const threadStoreOperations = [
{		{
type: 'replace',		type: 'replace',
payload: {		payload: {
id: threadID,		id: threadID,
threadInfo: updatedThread,		threadInfo: updatedThread,
},		},
},		},
];		];
const updatedThreadStore = processThreadStoreOperations(		const updatedThreadStore = processThreadStoreOperations(
state,		state,
threadStoreOperations,		threadStoreOperations,
);		);
return {		return {
threadStore: updatedThreadStore,		threadStore: updatedThreadStore,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations,		threadStoreOperations,
};		};
} else {
const updatedThread = {
...threadInfo,
currentUser: { ...threadInfo.currentUser, unread: true },
};
const threadStoreOperations = [
{
type: 'replace',
payload: {
id: threadID,
threadInfo: updatedThread,
},
},
];
const updatedThreadStore = processThreadStoreOperations(
state,
threadStoreOperations,
);
return {
threadStore: updatedThreadStore,
newThreadInconsistencies: [],
threadStoreOperations,
};
}
} else if (action.type === setClientDBStoreActionType) {		} else if (action.type === setClientDBStoreActionType) {
return {		return {
threadStore: action.payload.threadStore ?? state,		threadStore: action.payload.threadStore ?? state,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations: [],		threadStoreOperations: [],
};		};
}		}
return {		return {
threadStore: state,		threadStore: state,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations: [],		threadStoreOperations: [],
};		};
}		}

export { reduceThreadInfos };		export { reduceThreadInfos };

View Options

lib/facts/links.js

// @flow		// @flow

		import invariant from 'invariant';

import {		import {
setThreadUnreadStatusActionTypes,		setThreadUnreadStatusActionTypes,
updateActivityActionTypes,		updateActivityActionTypes,
} from '../actions/activity-actions.js';		} from '../actions/activity-actions.js';
import { setClientDBStoreActionType } from '../actions/client-db-store-actions.js';		import { setClientDBStoreActionType } from '../actions/client-db-store-actions.js';
import { saveMessagesActionType } from '../actions/message-actions.js';		import { saveMessagesActionType } from '../actions/message-actions.js';
import { siweAuthActionTypes } from '../actions/siwe-actions.js';		import { siweAuthActionTypes } from '../actions/siwe-actions.js';
import {		import {
Show All 15 Lines	import {
updateSubscriptionActionTypes,		updateSubscriptionActionTypes,
} from '../actions/user-actions.js';		} from '../actions/user-actions.js';
import {		import {
type ThreadStoreOperation,		type ThreadStoreOperation,
threadStoreOpsHandlers,		threadStoreOpsHandlers,
} from '../ops/thread-store-ops.js';		} from '../ops/thread-store-ops.js';
import { stateSyncSpecs } from '../shared/state-sync/state-sync-specs.js';		import { stateSyncSpecs } from '../shared/state-sync/state-sync-specs.js';
import { updateSpecs } from '../shared/updates/update-specs.js';		import { updateSpecs } from '../shared/updates/update-specs.js';
		import type { MinimallyEncodedRawThreadInfo } from '../types/minimally-encoded-thread-permissions-types.js';
import type { BaseAction } from '../types/redux-types.js';		import type { BaseAction } from '../types/redux-types.js';
import { type ClientThreadInconsistencyReportCreationRequest } from '../types/report-types.js';		import { type ClientThreadInconsistencyReportCreationRequest } from '../types/report-types.js';
import {		import {
serverRequestTypes,		serverRequestTypes,
processServerRequestsActionType,		processServerRequestsActionType,
} from '../types/request-types.js';		} from '../types/request-types.js';
import {		import {
fullStateSyncActionType,		fullStateSyncActionType,
incrementalStateSyncActionType,		incrementalStateSyncActionType,
} from '../types/socket-types.js';		} from '../types/socket-types.js';
import type {		import type {
RawThreadInfo,		MinimallyEncodedRawThreadInfos,
RawThreadInfos,
ThreadStore,		ThreadStore,
} from '../types/thread-types.js';		} from '../types/thread-types.js';
import {		import {
type ClientUpdateInfo,		type ClientUpdateInfo,
processUpdatesActionType,		processUpdatesActionType,
} from '../types/update-types.js';		} from '../types/update-types.js';
import { setNewSessionActionType } from '../utils/action-utils.js';		import { setNewSessionActionType } from '../utils/action-utils.js';

const { processStoreOperations: processThreadStoreOperations } =		const { processStoreOperations: processThreadStoreOperations } =
threadStoreOpsHandlers;		threadStoreOpsHandlers;

function generateOpsForThreadUpdates(		function generateOpsForThreadUpdates(
threadInfos: RawThreadInfos,		threadInfos: MinimallyEncodedRawThreadInfos,
payload: {		payload: {
+updatesResult: { +newUpdates: $ReadOnlyArray<ClientUpdateInfo>, ... },		+updatesResult: { +newUpdates: $ReadOnlyArray<ClientUpdateInfo>, ... },
...		...
},		},
): $ReadOnlyArray<ThreadStoreOperation> {		): $ReadOnlyArray<ThreadStoreOperation> {
return payload.updatesResult.newUpdates		return payload.updatesResult.newUpdates
.map(update =>		.map(update =>
updateSpecs[update.type].generateOpsForThreadUpdates?.(		updateSpecs[update.type].generateOpsForThreadUpdates?.(
Show All 19 Lines	if (
action.type === registerActionTypes.success \|\|		action.type === registerActionTypes.success \|\|
action.type === fullStateSyncActionType		action.type === fullStateSyncActionType
) {		) {
const newThreadInfos = action.payload.threadInfos;		const newThreadInfos = action.payload.threadInfos;
const threadStoreOperations = [		const threadStoreOperations = [
{		{
type: 'remove_all',		type: 'remove_all',
},		},
...Object.keys(newThreadInfos).map((id: string) => ({		...Object.keys(newThreadInfos).map((id: string) => {
		invariant(
		newThreadInfos[id].minimallyEncoded,
		'newThreadInfos must be minimallyEncoded for current clients',
		);
		atulAuthorUnsubmitted Done Inline Actions I thought putting an `invariant` here was a reasonable trade-off vs. refactoring the types in the `fullStateSyncActionType` payload (specifically `StateSyncFullActionPayload` which is derived from `ClientFullStateSync` which is derived from `BaseFullStateSync`) which are used across clients and keyserver. Open to re-exploring if that would be preferred. atul: I thought putting an `invariant` here was a reasonable trade-off vs. refactoring the types in…
		return {
type: 'replace',		type: 'replace',
payload: { id, threadInfo: newThreadInfos[id] },		payload: { id, threadInfo: newThreadInfos[id] },
})),		};
		}),
];		];
const updatedThreadStore = processThreadStoreOperations(		const updatedThreadStore = processThreadStoreOperations(
state,		state,
threadStoreOperations,		threadStoreOperations,
);		);
return {		return {
threadStore: updatedThreadStore,		threadStore: updatedThreadStore,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
▲ Show 20 Lines • Show All 58 Lines • ▼ Show 20 Lines	) {
return {		return {
threadStore: updatedThreadStore,		threadStore: updatedThreadStore,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations,		threadStoreOperations,
};		};
} else if (action.type === updateSubscriptionActionTypes.success) {		} else if (action.type === updateSubscriptionActionTypes.success) {
const { threadID, subscription } = action.payload;		const { threadID, subscription } = action.payload;
const threadInfo = state.threadInfos[threadID];		const threadInfo = state.threadInfos[threadID];
// TODO (atul): Try to get rid of this ridiculous branching.
if (threadInfo.minimallyEncoded) {
const newThreadInfo = {
...threadInfo,
currentUser: {
...threadInfo.currentUser,
subscription,
},
};
const threadStoreOperations = [
{
type: 'replace',
payload: {
id: threadID,
threadInfo: newThreadInfo,
},
},
];
const updatedThreadStore = processThreadStoreOperations(
state,
threadStoreOperations,
);
return {
threadStore: updatedThreadStore,
newThreadInconsistencies: [],
threadStoreOperations,
};
} else {
const newThreadInfo = {		const newThreadInfo = {
...threadInfo,		...threadInfo,
currentUser: {		currentUser: {
...threadInfo.currentUser,		...threadInfo.currentUser,
subscription,		subscription,
},		},
};		};
const threadStoreOperations = [		const threadStoreOperations = [
{		{
type: 'replace',		type: 'replace',
payload: {		payload: {
id: threadID,		id: threadID,
threadInfo: newThreadInfo,		threadInfo: newThreadInfo,
},		},
},		},
];		];
const updatedThreadStore = processThreadStoreOperations(		const updatedThreadStore = processThreadStoreOperations(
state,		state,
threadStoreOperations,		threadStoreOperations,
);		);
return {		return {
threadStore: updatedThreadStore,		threadStore: updatedThreadStore,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations,		threadStoreOperations,
};		};
}
} else if (action.type === saveMessagesActionType) {		} else if (action.type === saveMessagesActionType) {
const threadIDToMostRecentTime = new Map<string, number>();		const threadIDToMostRecentTime = new Map<string, number>();
for (const messageInfo of action.payload.rawMessageInfos) {		for (const messageInfo of action.payload.rawMessageInfos) {
const current = threadIDToMostRecentTime.get(messageInfo.threadID);		const current = threadIDToMostRecentTime.get(messageInfo.threadID);
if (!current \|\| current < messageInfo.time) {		if (!current \|\| current < messageInfo.time) {
threadIDToMostRecentTime.set(messageInfo.threadID, messageInfo.time);		threadIDToMostRecentTime.set(messageInfo.threadID, messageInfo.time);
}		}
}		}
const changedThreadInfos: { [string]: RawThreadInfo } = {};		const changedThreadInfos: { [string]: MinimallyEncodedRawThreadInfo } = {};
for (const [threadID, mostRecentTime] of threadIDToMostRecentTime) {		for (const [threadID, mostRecentTime] of threadIDToMostRecentTime) {
const threadInfo = state.threadInfos[threadID];		const threadInfo = state.threadInfos[threadID];
if (		if (
!threadInfo \|\|		!threadInfo \|\|
threadInfo.currentUser.unread \|\|		threadInfo.currentUser.unread \|\|
action.payload.updatesCurrentAsOf > mostRecentTime		action.payload.updatesCurrentAsOf > mostRecentTime
) {		) {
continue;		continue;
}		}
const changedThreadInfo = state.threadInfos[threadID];		const changedThreadInfo = state.threadInfos[threadID];
// TODO (atul): Try to get rid of this ridiculous branching.
if (changedThreadInfo.minimallyEncoded) {
changedThreadInfos[threadID] = {
...changedThreadInfo,
currentUser: {
...changedThreadInfo.currentUser,
unread: true,
},
};
} else {
changedThreadInfos[threadID] = {		changedThreadInfos[threadID] = {
...changedThreadInfo,		...changedThreadInfo,
currentUser: {		currentUser: {
...changedThreadInfo.currentUser,		...changedThreadInfo.currentUser,
unread: true,		unread: true,
},		},
};		};
}		}
}
if (Object.keys(changedThreadInfos).length !== 0) {		if (Object.keys(changedThreadInfos).length !== 0) {
const threadStoreOperations = Object.keys(changedThreadInfos).map(id => ({		const threadStoreOperations = Object.keys(changedThreadInfos).map(id => ({
type: 'replace',		type: 'replace',
payload: {		payload: {
id,		id,
threadInfo: changedThreadInfos[id],		threadInfo: changedThreadInfos[id],
},		},
}));		}));
Show All 25 Lines	if (!rawThreadInfos && !deleteThreadIDs) {
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations: [],		threadStoreOperations: [],
};		};
}		}

const threadStoreOperations: ThreadStoreOperation[] = [];		const threadStoreOperations: ThreadStoreOperation[] = [];
if (rawThreadInfos) {		if (rawThreadInfos) {
for (const rawThreadInfo of rawThreadInfos) {		for (const rawThreadInfo of rawThreadInfos) {
		invariant(
		rawThreadInfo.minimallyEncoded,
		'rawThreadInfo must be minimallyEncoded on new clients',
		);
		atulAuthorUnsubmitted Done Inline Actions Similarly thought this was a reasonable trade-off to avoid having to refactor types related to state check mechanism. Open to re-exploring if that would be preferred. atul: Similarly thought this was a reasonable trade-off to avoid having to refactor types related to…
threadStoreOperations.push({		threadStoreOperations.push({
type: 'replace',		type: 'replace',
payload: {		payload: {
id: rawThreadInfo.id,		id: rawThreadInfo.id,
threadInfo: rawThreadInfo,		threadInfo: rawThreadInfo,
},		},
});		});
}		}
Show All 20 Lines	const newThreadInconsistencies =
);		);

return {		return {
threadStore: updatedThreadStore,		threadStore: updatedThreadStore,
newThreadInconsistencies,		newThreadInconsistencies,
threadStoreOperations,		threadStoreOperations,
};		};
} else if (action.type === updateActivityActionTypes.success) {		} else if (action.type === updateActivityActionTypes.success) {
const updatedThreadInfos: { [string]: RawThreadInfo } = {};		const updatedThreadInfos: { [string]: MinimallyEncodedRawThreadInfo } = {};
for (const setToUnread of action.payload.result.unfocusedToUnread) {		for (const setToUnread of action.payload.result.unfocusedToUnread) {
const threadInfo = state.threadInfos[setToUnread];		const threadInfo = state.threadInfos[setToUnread];
// TODO (atul): Try to get rid of this ridiculous branching.
if (threadInfo.minimallyEncoded) {
if (threadInfo && !threadInfo.currentUser.unread) {
updatedThreadInfos[setToUnread] = {
...threadInfo,
currentUser: {
...threadInfo.currentUser,
unread: true,
},
};
}
} else {
if (threadInfo && !threadInfo.currentUser.unread) {		if (threadInfo && !threadInfo.currentUser.unread) {
updatedThreadInfos[setToUnread] = {		updatedThreadInfos[setToUnread] = {
...threadInfo,		...threadInfo,
currentUser: {		currentUser: {
...threadInfo.currentUser,		...threadInfo.currentUser,
unread: true,		unread: true,
},		},
};		};
}		}
}		}
}

if (Object.keys(updatedThreadInfos).length === 0) {		if (Object.keys(updatedThreadInfos).length === 0) {
return {		return {
threadStore: state,		threadStore: state,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations: [],		threadStoreOperations: [],
};		};
}		}
const threadStoreOperations = Object.keys(updatedThreadInfos).map(id => ({		const threadStoreOperations = Object.keys(updatedThreadInfos).map(id => ({
Show All 10 Lines	) {
return {		return {
threadStore: updatedThreadStore,		threadStore: updatedThreadStore,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations,		threadStoreOperations,
};		};
} else if (action.type === setThreadUnreadStatusActionTypes.started) {		} else if (action.type === setThreadUnreadStatusActionTypes.started) {
const { threadID, unread } = action.payload;		const { threadID, unread } = action.payload;
const threadInfo = state.threadInfos[threadID];		const threadInfo = state.threadInfos[threadID];
// TODO (atul): Try to get rid of this ridiculous branching.
if (threadInfo.minimallyEncoded) {
const updatedThreadInfo = {
...threadInfo,
currentUser: {
...threadInfo.currentUser,
unread,
},
};
const threadStoreOperations = [
{
type: 'replace',
payload: {
id: threadID,
threadInfo: updatedThreadInfo,
},
},
];
const updatedThreadStore = processThreadStoreOperations(
state,
threadStoreOperations,
);
return {
threadStore: updatedThreadStore,
newThreadInconsistencies: [],
threadStoreOperations,
};
} else {
const updatedThreadInfo = {		const updatedThreadInfo = {
...threadInfo,		...threadInfo,
currentUser: {		currentUser: {
...threadInfo.currentUser,		...threadInfo.currentUser,
unread,		unread,
},		},
};		};
const threadStoreOperations = [		const threadStoreOperations = [
{		{
type: 'replace',		type: 'replace',
payload: {		payload: {
id: threadID,		id: threadID,
threadInfo: updatedThreadInfo,		threadInfo: updatedThreadInfo,
},		},
},		},
];		];
const updatedThreadStore = processThreadStoreOperations(		const updatedThreadStore = processThreadStoreOperations(
state,		state,
threadStoreOperations,		threadStoreOperations,
);		);
return {		return {
threadStore: updatedThreadStore,		threadStore: updatedThreadStore,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations,		threadStoreOperations,
};		};
}
} else if (action.type === setThreadUnreadStatusActionTypes.success) {		} else if (action.type === setThreadUnreadStatusActionTypes.success) {
const { threadID, resetToUnread } = action.payload;		const { threadID, resetToUnread } = action.payload;
const currentUser = state.threadInfos[threadID].currentUser;		const currentUser = state.threadInfos[threadID].currentUser;

if (!resetToUnread \|\| currentUser.unread) {		if (!resetToUnread \|\| currentUser.unread) {
return {		return {
threadStore: state,		threadStore: state,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations: [],		threadStoreOperations: [],
};		};
}		}

const threadInfo = state.threadInfos[threadID];		const threadInfo = state.threadInfos[threadID];
// TODO (atul): Try to get rid of this ridiculous branching.
if (threadInfo.minimallyEncoded) {
const updatedThread = {		const updatedThread = {
...threadInfo,		...threadInfo,
currentUser: { ...threadInfo.currentUser, unread: true },		currentUser: { ...threadInfo.currentUser, unread: true },
};		};
const threadStoreOperations = [		const threadStoreOperations = [
{		{
type: 'replace',		type: 'replace',
payload: {		payload: {
id: threadID,		id: threadID,
threadInfo: updatedThread,		threadInfo: updatedThread,
},		},
},		},
];		];
const updatedThreadStore = processThreadStoreOperations(		const updatedThreadStore = processThreadStoreOperations(
state,		state,
threadStoreOperations,		threadStoreOperations,
);		);
return {		return {
threadStore: updatedThreadStore,		threadStore: updatedThreadStore,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations,		threadStoreOperations,
};		};
} else {
const updatedThread = {
...threadInfo,
currentUser: { ...threadInfo.currentUser, unread: true },
};
const threadStoreOperations = [
{
type: 'replace',
payload: {
id: threadID,
threadInfo: updatedThread,
},
},
];
const updatedThreadStore = processThreadStoreOperations(
state,
threadStoreOperations,
);
return {
threadStore: updatedThreadStore,
newThreadInconsistencies: [],
threadStoreOperations,
};
}
} else if (action.type === setClientDBStoreActionType) {		} else if (action.type === setClientDBStoreActionType) {
return {		return {
threadStore: action.payload.threadStore ?? state,		threadStore: action.payload.threadStore ?? state,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations: [],		threadStoreOperations: [],
};		};
}		}
return {		return {
threadStore: state,		threadStore: state,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations: [],		threadStoreOperations: [],
};		};
}		}

export { reduceThreadInfos };		export { reduceThreadInfos };

View Options

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

// @flow		// @flow

		import invariant from 'invariant';

import {		import {
setThreadUnreadStatusActionTypes,		setThreadUnreadStatusActionTypes,
updateActivityActionTypes,		updateActivityActionTypes,
} from '../actions/activity-actions.js';		} from '../actions/activity-actions.js';
import { setClientDBStoreActionType } from '../actions/client-db-store-actions.js';		import { setClientDBStoreActionType } from '../actions/client-db-store-actions.js';
import { saveMessagesActionType } from '../actions/message-actions.js';		import { saveMessagesActionType } from '../actions/message-actions.js';
import { siweAuthActionTypes } from '../actions/siwe-actions.js';		import { siweAuthActionTypes } from '../actions/siwe-actions.js';
import {		import {
Show All 15 Lines	import {
updateSubscriptionActionTypes,		updateSubscriptionActionTypes,
} from '../actions/user-actions.js';		} from '../actions/user-actions.js';
import {		import {
type ThreadStoreOperation,		type ThreadStoreOperation,
threadStoreOpsHandlers,		threadStoreOpsHandlers,
} from '../ops/thread-store-ops.js';		} from '../ops/thread-store-ops.js';
import { stateSyncSpecs } from '../shared/state-sync/state-sync-specs.js';		import { stateSyncSpecs } from '../shared/state-sync/state-sync-specs.js';
import { updateSpecs } from '../shared/updates/update-specs.js';		import { updateSpecs } from '../shared/updates/update-specs.js';
		import type { MinimallyEncodedRawThreadInfo } from '../types/minimally-encoded-thread-permissions-types.js';
import type { BaseAction } from '../types/redux-types.js';		import type { BaseAction } from '../types/redux-types.js';
import { type ClientThreadInconsistencyReportCreationRequest } from '../types/report-types.js';		import { type ClientThreadInconsistencyReportCreationRequest } from '../types/report-types.js';
import {		import {
serverRequestTypes,		serverRequestTypes,
processServerRequestsActionType,		processServerRequestsActionType,
} from '../types/request-types.js';		} from '../types/request-types.js';
import {		import {
fullStateSyncActionType,		fullStateSyncActionType,
incrementalStateSyncActionType,		incrementalStateSyncActionType,
} from '../types/socket-types.js';		} from '../types/socket-types.js';
import type {		import type {
RawThreadInfo,		MinimallyEncodedRawThreadInfos,
RawThreadInfos,
ThreadStore,		ThreadStore,
} from '../types/thread-types.js';		} from '../types/thread-types.js';
import {		import {
type ClientUpdateInfo,		type ClientUpdateInfo,
processUpdatesActionType,		processUpdatesActionType,
} from '../types/update-types.js';		} from '../types/update-types.js';
import { setNewSessionActionType } from '../utils/action-utils.js';		import { setNewSessionActionType } from '../utils/action-utils.js';

const { processStoreOperations: processThreadStoreOperations } =		const { processStoreOperations: processThreadStoreOperations } =
threadStoreOpsHandlers;		threadStoreOpsHandlers;

function generateOpsForThreadUpdates(		function generateOpsForThreadUpdates(
threadInfos: RawThreadInfos,		threadInfos: MinimallyEncodedRawThreadInfos,
payload: {		payload: {
+updatesResult: { +newUpdates: $ReadOnlyArray<ClientUpdateInfo>, ... },		+updatesResult: { +newUpdates: $ReadOnlyArray<ClientUpdateInfo>, ... },
...		...
},		},
): $ReadOnlyArray<ThreadStoreOperation> {		): $ReadOnlyArray<ThreadStoreOperation> {
return payload.updatesResult.newUpdates		return payload.updatesResult.newUpdates
.map(update =>		.map(update =>
updateSpecs[update.type].generateOpsForThreadUpdates?.(		updateSpecs[update.type].generateOpsForThreadUpdates?.(
Show All 19 Lines	if (
action.type === registerActionTypes.success \|\|		action.type === registerActionTypes.success \|\|
action.type === fullStateSyncActionType		action.type === fullStateSyncActionType
) {		) {
const newThreadInfos = action.payload.threadInfos;		const newThreadInfos = action.payload.threadInfos;
const threadStoreOperations = [		const threadStoreOperations = [
{		{
type: 'remove_all',		type: 'remove_all',
},		},
...Object.keys(newThreadInfos).map((id: string) => ({		...Object.keys(newThreadInfos).map((id: string) => {
		invariant(
		newThreadInfos[id].minimallyEncoded,
		'newThreadInfos must be minimallyEncoded for current clients',
		);
		atulAuthorUnsubmitted Done Inline Actions I thought putting an `invariant` here was a reasonable trade-off vs. refactoring the types in the `fullStateSyncActionType` payload (specifically `StateSyncFullActionPayload` which is derived from `ClientFullStateSync` which is derived from `BaseFullStateSync`) which are used across clients and keyserver. Open to re-exploring if that would be preferred. atul: I thought putting an `invariant` here was a reasonable trade-off vs. refactoring the types in…
		return {
type: 'replace',		type: 'replace',
payload: { id, threadInfo: newThreadInfos[id] },		payload: { id, threadInfo: newThreadInfos[id] },
})),		};
		}),
];		];
const updatedThreadStore = processThreadStoreOperations(		const updatedThreadStore = processThreadStoreOperations(
state,		state,
threadStoreOperations,		threadStoreOperations,
);		);
return {		return {
threadStore: updatedThreadStore,		threadStore: updatedThreadStore,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
▲ Show 20 Lines • Show All 58 Lines • ▼ Show 20 Lines	) {
return {		return {
threadStore: updatedThreadStore,		threadStore: updatedThreadStore,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations,		threadStoreOperations,
};		};
} else if (action.type === updateSubscriptionActionTypes.success) {		} else if (action.type === updateSubscriptionActionTypes.success) {
const { threadID, subscription } = action.payload;		const { threadID, subscription } = action.payload;
const threadInfo = state.threadInfos[threadID];		const threadInfo = state.threadInfos[threadID];
// TODO (atul): Try to get rid of this ridiculous branching.
if (threadInfo.minimallyEncoded) {
const newThreadInfo = {
...threadInfo,
currentUser: {
...threadInfo.currentUser,
subscription,
},
};
const threadStoreOperations = [
{
type: 'replace',
payload: {
id: threadID,
threadInfo: newThreadInfo,
},
},
];
const updatedThreadStore = processThreadStoreOperations(
state,
threadStoreOperations,
);
return {
threadStore: updatedThreadStore,
newThreadInconsistencies: [],
threadStoreOperations,
};
} else {
const newThreadInfo = {		const newThreadInfo = {
...threadInfo,		...threadInfo,
currentUser: {		currentUser: {
...threadInfo.currentUser,		...threadInfo.currentUser,
subscription,		subscription,
},		},
};		};
const threadStoreOperations = [		const threadStoreOperations = [
{		{
type: 'replace',		type: 'replace',
payload: {		payload: {
id: threadID,		id: threadID,
threadInfo: newThreadInfo,		threadInfo: newThreadInfo,
},		},
},		},
];		];
const updatedThreadStore = processThreadStoreOperations(		const updatedThreadStore = processThreadStoreOperations(
state,		state,
threadStoreOperations,		threadStoreOperations,
);		);
return {		return {
threadStore: updatedThreadStore,		threadStore: updatedThreadStore,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations,		threadStoreOperations,
};		};
}
} else if (action.type === saveMessagesActionType) {		} else if (action.type === saveMessagesActionType) {
const threadIDToMostRecentTime = new Map<string, number>();		const threadIDToMostRecentTime = new Map<string, number>();
for (const messageInfo of action.payload.rawMessageInfos) {		for (const messageInfo of action.payload.rawMessageInfos) {
const current = threadIDToMostRecentTime.get(messageInfo.threadID);		const current = threadIDToMostRecentTime.get(messageInfo.threadID);
if (!current \|\| current < messageInfo.time) {		if (!current \|\| current < messageInfo.time) {
threadIDToMostRecentTime.set(messageInfo.threadID, messageInfo.time);		threadIDToMostRecentTime.set(messageInfo.threadID, messageInfo.time);
}		}
}		}
const changedThreadInfos: { [string]: RawThreadInfo } = {};		const changedThreadInfos: { [string]: MinimallyEncodedRawThreadInfo } = {};
for (const [threadID, mostRecentTime] of threadIDToMostRecentTime) {		for (const [threadID, mostRecentTime] of threadIDToMostRecentTime) {
const threadInfo = state.threadInfos[threadID];		const threadInfo = state.threadInfos[threadID];
if (		if (
!threadInfo \|\|		!threadInfo \|\|
threadInfo.currentUser.unread \|\|		threadInfo.currentUser.unread \|\|
action.payload.updatesCurrentAsOf > mostRecentTime		action.payload.updatesCurrentAsOf > mostRecentTime
) {		) {
continue;		continue;
}		}
const changedThreadInfo = state.threadInfos[threadID];		const changedThreadInfo = state.threadInfos[threadID];
// TODO (atul): Try to get rid of this ridiculous branching.
if (changedThreadInfo.minimallyEncoded) {
changedThreadInfos[threadID] = {
...changedThreadInfo,
currentUser: {
...changedThreadInfo.currentUser,
unread: true,
},
};
} else {
changedThreadInfos[threadID] = {		changedThreadInfos[threadID] = {
...changedThreadInfo,		...changedThreadInfo,
currentUser: {		currentUser: {
...changedThreadInfo.currentUser,		...changedThreadInfo.currentUser,
unread: true,		unread: true,
},		},
};		};
}		}
}
if (Object.keys(changedThreadInfos).length !== 0) {		if (Object.keys(changedThreadInfos).length !== 0) {
const threadStoreOperations = Object.keys(changedThreadInfos).map(id => ({		const threadStoreOperations = Object.keys(changedThreadInfos).map(id => ({
type: 'replace',		type: 'replace',
payload: {		payload: {
id,		id,
threadInfo: changedThreadInfos[id],		threadInfo: changedThreadInfos[id],
},		},
}));		}));
Show All 25 Lines	if (!rawThreadInfos && !deleteThreadIDs) {
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations: [],		threadStoreOperations: [],
};		};
}		}

const threadStoreOperations: ThreadStoreOperation[] = [];		const threadStoreOperations: ThreadStoreOperation[] = [];
if (rawThreadInfos) {		if (rawThreadInfos) {
for (const rawThreadInfo of rawThreadInfos) {		for (const rawThreadInfo of rawThreadInfos) {
		invariant(
		rawThreadInfo.minimallyEncoded,
		'rawThreadInfo must be minimallyEncoded on new clients',
		);
		atulAuthorUnsubmitted Done Inline Actions Similarly thought this was a reasonable trade-off to avoid having to refactor types related to state check mechanism. Open to re-exploring if that would be preferred. atul: Similarly thought this was a reasonable trade-off to avoid having to refactor types related to…
threadStoreOperations.push({		threadStoreOperations.push({
type: 'replace',		type: 'replace',
payload: {		payload: {
id: rawThreadInfo.id,		id: rawThreadInfo.id,
threadInfo: rawThreadInfo,		threadInfo: rawThreadInfo,
},		},
});		});
}		}
Show All 20 Lines	const newThreadInconsistencies =
);		);

return {		return {
threadStore: updatedThreadStore,		threadStore: updatedThreadStore,
newThreadInconsistencies,		newThreadInconsistencies,
threadStoreOperations,		threadStoreOperations,
};		};
} else if (action.type === updateActivityActionTypes.success) {		} else if (action.type === updateActivityActionTypes.success) {
const updatedThreadInfos: { [string]: RawThreadInfo } = {};		const updatedThreadInfos: { [string]: MinimallyEncodedRawThreadInfo } = {};
for (const setToUnread of action.payload.result.unfocusedToUnread) {		for (const setToUnread of action.payload.result.unfocusedToUnread) {
const threadInfo = state.threadInfos[setToUnread];		const threadInfo = state.threadInfos[setToUnread];
// TODO (atul): Try to get rid of this ridiculous branching.
if (threadInfo.minimallyEncoded) {
if (threadInfo && !threadInfo.currentUser.unread) {
updatedThreadInfos[setToUnread] = {
...threadInfo,
currentUser: {
...threadInfo.currentUser,
unread: true,
},
};
}
} else {
if (threadInfo && !threadInfo.currentUser.unread) {		if (threadInfo && !threadInfo.currentUser.unread) {
updatedThreadInfos[setToUnread] = {		updatedThreadInfos[setToUnread] = {
...threadInfo,		...threadInfo,
currentUser: {		currentUser: {
...threadInfo.currentUser,		...threadInfo.currentUser,
unread: true,		unread: true,
},		},
};		};
}		}
}		}
}

if (Object.keys(updatedThreadInfos).length === 0) {		if (Object.keys(updatedThreadInfos).length === 0) {
return {		return {
threadStore: state,		threadStore: state,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations: [],		threadStoreOperations: [],
};		};
}		}
const threadStoreOperations = Object.keys(updatedThreadInfos).map(id => ({		const threadStoreOperations = Object.keys(updatedThreadInfos).map(id => ({
Show All 10 Lines	) {
return {		return {
threadStore: updatedThreadStore,		threadStore: updatedThreadStore,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations,		threadStoreOperations,
};		};
} else if (action.type === setThreadUnreadStatusActionTypes.started) {		} else if (action.type === setThreadUnreadStatusActionTypes.started) {
const { threadID, unread } = action.payload;		const { threadID, unread } = action.payload;
const threadInfo = state.threadInfos[threadID];		const threadInfo = state.threadInfos[threadID];
// TODO (atul): Try to get rid of this ridiculous branching.
if (threadInfo.minimallyEncoded) {
const updatedThreadInfo = {
...threadInfo,
currentUser: {
...threadInfo.currentUser,
unread,
},
};
const threadStoreOperations = [
{
type: 'replace',
payload: {
id: threadID,
threadInfo: updatedThreadInfo,
},
},
];
const updatedThreadStore = processThreadStoreOperations(
state,
threadStoreOperations,
);
return {
threadStore: updatedThreadStore,
newThreadInconsistencies: [],
threadStoreOperations,
};
} else {
const updatedThreadInfo = {		const updatedThreadInfo = {
...threadInfo,		...threadInfo,
currentUser: {		currentUser: {
...threadInfo.currentUser,		...threadInfo.currentUser,
unread,		unread,
},		},
};		};
const threadStoreOperations = [		const threadStoreOperations = [
{		{
type: 'replace',		type: 'replace',
payload: {		payload: {
id: threadID,		id: threadID,
threadInfo: updatedThreadInfo,		threadInfo: updatedThreadInfo,
},		},
},		},
];		];
const updatedThreadStore = processThreadStoreOperations(		const updatedThreadStore = processThreadStoreOperations(
state,		state,
threadStoreOperations,		threadStoreOperations,
);		);
return {		return {
threadStore: updatedThreadStore,		threadStore: updatedThreadStore,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations,		threadStoreOperations,
};		};
}
} else if (action.type === setThreadUnreadStatusActionTypes.success) {		} else if (action.type === setThreadUnreadStatusActionTypes.success) {
const { threadID, resetToUnread } = action.payload;		const { threadID, resetToUnread } = action.payload;
const currentUser = state.threadInfos[threadID].currentUser;		const currentUser = state.threadInfos[threadID].currentUser;

if (!resetToUnread \|\| currentUser.unread) {		if (!resetToUnread \|\| currentUser.unread) {
return {		return {
threadStore: state,		threadStore: state,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations: [],		threadStoreOperations: [],
};		};
}		}

const threadInfo = state.threadInfos[threadID];		const threadInfo = state.threadInfos[threadID];
// TODO (atul): Try to get rid of this ridiculous branching.
if (threadInfo.minimallyEncoded) {
const updatedThread = {		const updatedThread = {
...threadInfo,		...threadInfo,
currentUser: { ...threadInfo.currentUser, unread: true },		currentUser: { ...threadInfo.currentUser, unread: true },
};		};
const threadStoreOperations = [		const threadStoreOperations = [
{		{
type: 'replace',		type: 'replace',
payload: {		payload: {
id: threadID,		id: threadID,
threadInfo: updatedThread,		threadInfo: updatedThread,
},		},
},		},
];		];
const updatedThreadStore = processThreadStoreOperations(		const updatedThreadStore = processThreadStoreOperations(
state,		state,
threadStoreOperations,		threadStoreOperations,
);		);
return {		return {
threadStore: updatedThreadStore,		threadStore: updatedThreadStore,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations,		threadStoreOperations,
};		};
} else {
const updatedThread = {
...threadInfo,
currentUser: { ...threadInfo.currentUser, unread: true },
};
const threadStoreOperations = [
{
type: 'replace',
payload: {
id: threadID,
threadInfo: updatedThread,
},
},
];
const updatedThreadStore = processThreadStoreOperations(
state,
threadStoreOperations,
);
return {
threadStore: updatedThreadStore,
newThreadInconsistencies: [],
threadStoreOperations,
};
}
} else if (action.type === setClientDBStoreActionType) {		} else if (action.type === setClientDBStoreActionType) {
return {		return {
threadStore: action.payload.threadStore ?? state,		threadStore: action.payload.threadStore ?? state,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations: [],		threadStoreOperations: [],
};		};
}		}
return {		return {
threadStore: state,		threadStore: state,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations: [],		threadStoreOperations: [],
};		};
}		}

export { reduceThreadInfos };		export { reduceThreadInfos };

View Options

web/account/qr-code-login.react.js

// @flow		// @flow

		import invariant from 'invariant';

import {		import {
setThreadUnreadStatusActionTypes,		setThreadUnreadStatusActionTypes,
updateActivityActionTypes,		updateActivityActionTypes,
} from '../actions/activity-actions.js';		} from '../actions/activity-actions.js';
import { setClientDBStoreActionType } from '../actions/client-db-store-actions.js';		import { setClientDBStoreActionType } from '../actions/client-db-store-actions.js';
import { saveMessagesActionType } from '../actions/message-actions.js';		import { saveMessagesActionType } from '../actions/message-actions.js';
import { siweAuthActionTypes } from '../actions/siwe-actions.js';		import { siweAuthActionTypes } from '../actions/siwe-actions.js';
import {		import {
Show All 15 Lines	import {
updateSubscriptionActionTypes,		updateSubscriptionActionTypes,
} from '../actions/user-actions.js';		} from '../actions/user-actions.js';
import {		import {
type ThreadStoreOperation,		type ThreadStoreOperation,
threadStoreOpsHandlers,		threadStoreOpsHandlers,
} from '../ops/thread-store-ops.js';		} from '../ops/thread-store-ops.js';
import { stateSyncSpecs } from '../shared/state-sync/state-sync-specs.js';		import { stateSyncSpecs } from '../shared/state-sync/state-sync-specs.js';
import { updateSpecs } from '../shared/updates/update-specs.js';		import { updateSpecs } from '../shared/updates/update-specs.js';
		import type { MinimallyEncodedRawThreadInfo } from '../types/minimally-encoded-thread-permissions-types.js';
import type { BaseAction } from '../types/redux-types.js';		import type { BaseAction } from '../types/redux-types.js';
import { type ClientThreadInconsistencyReportCreationRequest } from '../types/report-types.js';		import { type ClientThreadInconsistencyReportCreationRequest } from '../types/report-types.js';
import {		import {
serverRequestTypes,		serverRequestTypes,
processServerRequestsActionType,		processServerRequestsActionType,
} from '../types/request-types.js';		} from '../types/request-types.js';
import {		import {
fullStateSyncActionType,		fullStateSyncActionType,
incrementalStateSyncActionType,		incrementalStateSyncActionType,
} from '../types/socket-types.js';		} from '../types/socket-types.js';
import type {		import type {
RawThreadInfo,		MinimallyEncodedRawThreadInfos,
RawThreadInfos,
ThreadStore,		ThreadStore,
} from '../types/thread-types.js';		} from '../types/thread-types.js';
import {		import {
type ClientUpdateInfo,		type ClientUpdateInfo,
processUpdatesActionType,		processUpdatesActionType,
} from '../types/update-types.js';		} from '../types/update-types.js';
import { setNewSessionActionType } from '../utils/action-utils.js';		import { setNewSessionActionType } from '../utils/action-utils.js';

const { processStoreOperations: processThreadStoreOperations } =		const { processStoreOperations: processThreadStoreOperations } =
threadStoreOpsHandlers;		threadStoreOpsHandlers;

function generateOpsForThreadUpdates(		function generateOpsForThreadUpdates(
threadInfos: RawThreadInfos,		threadInfos: MinimallyEncodedRawThreadInfos,
payload: {		payload: {
+updatesResult: { +newUpdates: $ReadOnlyArray<ClientUpdateInfo>, ... },		+updatesResult: { +newUpdates: $ReadOnlyArray<ClientUpdateInfo>, ... },
...		...
},		},
): $ReadOnlyArray<ThreadStoreOperation> {		): $ReadOnlyArray<ThreadStoreOperation> {
return payload.updatesResult.newUpdates		return payload.updatesResult.newUpdates
.map(update =>		.map(update =>
updateSpecs[update.type].generateOpsForThreadUpdates?.(		updateSpecs[update.type].generateOpsForThreadUpdates?.(
Show All 19 Lines	if (
action.type === registerActionTypes.success \|\|		action.type === registerActionTypes.success \|\|
action.type === fullStateSyncActionType		action.type === fullStateSyncActionType
) {		) {
const newThreadInfos = action.payload.threadInfos;		const newThreadInfos = action.payload.threadInfos;
const threadStoreOperations = [		const threadStoreOperations = [
{		{
type: 'remove_all',		type: 'remove_all',
},		},
...Object.keys(newThreadInfos).map((id: string) => ({		...Object.keys(newThreadInfos).map((id: string) => {
		invariant(
		newThreadInfos[id].minimallyEncoded,
		'newThreadInfos must be minimallyEncoded for current clients',
		);
		atulAuthorUnsubmitted Done Inline Actions I thought putting an `invariant` here was a reasonable trade-off vs. refactoring the types in the `fullStateSyncActionType` payload (specifically `StateSyncFullActionPayload` which is derived from `ClientFullStateSync` which is derived from `BaseFullStateSync`) which are used across clients and keyserver. Open to re-exploring if that would be preferred. atul: I thought putting an `invariant` here was a reasonable trade-off vs. refactoring the types in…
		return {
type: 'replace',		type: 'replace',
payload: { id, threadInfo: newThreadInfos[id] },		payload: { id, threadInfo: newThreadInfos[id] },
})),		};
		}),
];		];
const updatedThreadStore = processThreadStoreOperations(		const updatedThreadStore = processThreadStoreOperations(
state,		state,
threadStoreOperations,		threadStoreOperations,
);		);
return {		return {
threadStore: updatedThreadStore,		threadStore: updatedThreadStore,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
▲ Show 20 Lines • Show All 58 Lines • ▼ Show 20 Lines	) {
return {		return {
threadStore: updatedThreadStore,		threadStore: updatedThreadStore,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations,		threadStoreOperations,
};		};
} else if (action.type === updateSubscriptionActionTypes.success) {		} else if (action.type === updateSubscriptionActionTypes.success) {
const { threadID, subscription } = action.payload;		const { threadID, subscription } = action.payload;
const threadInfo = state.threadInfos[threadID];		const threadInfo = state.threadInfos[threadID];
// TODO (atul): Try to get rid of this ridiculous branching.
if (threadInfo.minimallyEncoded) {
const newThreadInfo = {
...threadInfo,
currentUser: {
...threadInfo.currentUser,
subscription,
},
};
const threadStoreOperations = [
{
type: 'replace',
payload: {
id: threadID,
threadInfo: newThreadInfo,
},
},
];
const updatedThreadStore = processThreadStoreOperations(
state,
threadStoreOperations,
);
return {
threadStore: updatedThreadStore,
newThreadInconsistencies: [],
threadStoreOperations,
};
} else {
const newThreadInfo = {		const newThreadInfo = {
...threadInfo,		...threadInfo,
currentUser: {		currentUser: {
...threadInfo.currentUser,		...threadInfo.currentUser,
subscription,		subscription,
},		},
};		};
const threadStoreOperations = [		const threadStoreOperations = [
{		{
type: 'replace',		type: 'replace',
payload: {		payload: {
id: threadID,		id: threadID,
threadInfo: newThreadInfo,		threadInfo: newThreadInfo,
},		},
},		},
];		];
const updatedThreadStore = processThreadStoreOperations(		const updatedThreadStore = processThreadStoreOperations(
state,		state,
threadStoreOperations,		threadStoreOperations,
);		);
return {		return {
threadStore: updatedThreadStore,		threadStore: updatedThreadStore,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations,		threadStoreOperations,
};		};
}
} else if (action.type === saveMessagesActionType) {		} else if (action.type === saveMessagesActionType) {
const threadIDToMostRecentTime = new Map<string, number>();		const threadIDToMostRecentTime = new Map<string, number>();
for (const messageInfo of action.payload.rawMessageInfos) {		for (const messageInfo of action.payload.rawMessageInfos) {
const current = threadIDToMostRecentTime.get(messageInfo.threadID);		const current = threadIDToMostRecentTime.get(messageInfo.threadID);
if (!current \|\| current < messageInfo.time) {		if (!current \|\| current < messageInfo.time) {
threadIDToMostRecentTime.set(messageInfo.threadID, messageInfo.time);		threadIDToMostRecentTime.set(messageInfo.threadID, messageInfo.time);
}		}
}		}
const changedThreadInfos: { [string]: RawThreadInfo } = {};		const changedThreadInfos: { [string]: MinimallyEncodedRawThreadInfo } = {};
for (const [threadID, mostRecentTime] of threadIDToMostRecentTime) {		for (const [threadID, mostRecentTime] of threadIDToMostRecentTime) {
const threadInfo = state.threadInfos[threadID];		const threadInfo = state.threadInfos[threadID];
if (		if (
!threadInfo \|\|		!threadInfo \|\|
threadInfo.currentUser.unread \|\|		threadInfo.currentUser.unread \|\|
action.payload.updatesCurrentAsOf > mostRecentTime		action.payload.updatesCurrentAsOf > mostRecentTime
) {		) {
continue;		continue;
}		}
const changedThreadInfo = state.threadInfos[threadID];		const changedThreadInfo = state.threadInfos[threadID];
// TODO (atul): Try to get rid of this ridiculous branching.
if (changedThreadInfo.minimallyEncoded) {
changedThreadInfos[threadID] = {
...changedThreadInfo,
currentUser: {
...changedThreadInfo.currentUser,
unread: true,
},
};
} else {
changedThreadInfos[threadID] = {		changedThreadInfos[threadID] = {
...changedThreadInfo,		...changedThreadInfo,
currentUser: {		currentUser: {
...changedThreadInfo.currentUser,		...changedThreadInfo.currentUser,
unread: true,		unread: true,
},		},
};		};
}		}
}
if (Object.keys(changedThreadInfos).length !== 0) {		if (Object.keys(changedThreadInfos).length !== 0) {
const threadStoreOperations = Object.keys(changedThreadInfos).map(id => ({		const threadStoreOperations = Object.keys(changedThreadInfos).map(id => ({
type: 'replace',		type: 'replace',
payload: {		payload: {
id,		id,
threadInfo: changedThreadInfos[id],		threadInfo: changedThreadInfos[id],
},		},
}));		}));
Show All 25 Lines	if (!rawThreadInfos && !deleteThreadIDs) {
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations: [],		threadStoreOperations: [],
};		};
}		}

const threadStoreOperations: ThreadStoreOperation[] = [];		const threadStoreOperations: ThreadStoreOperation[] = [];
if (rawThreadInfos) {		if (rawThreadInfos) {
for (const rawThreadInfo of rawThreadInfos) {		for (const rawThreadInfo of rawThreadInfos) {
		invariant(
		rawThreadInfo.minimallyEncoded,
		'rawThreadInfo must be minimallyEncoded on new clients',
		);
		atulAuthorUnsubmitted Done Inline Actions Similarly thought this was a reasonable trade-off to avoid having to refactor types related to state check mechanism. Open to re-exploring if that would be preferred. atul: Similarly thought this was a reasonable trade-off to avoid having to refactor types related to…
threadStoreOperations.push({		threadStoreOperations.push({
type: 'replace',		type: 'replace',
payload: {		payload: {
id: rawThreadInfo.id,		id: rawThreadInfo.id,
threadInfo: rawThreadInfo,		threadInfo: rawThreadInfo,
},		},
});		});
}		}
Show All 20 Lines	const newThreadInconsistencies =
);		);

return {		return {
threadStore: updatedThreadStore,		threadStore: updatedThreadStore,
newThreadInconsistencies,		newThreadInconsistencies,
threadStoreOperations,		threadStoreOperations,
};		};
} else if (action.type === updateActivityActionTypes.success) {		} else if (action.type === updateActivityActionTypes.success) {
const updatedThreadInfos: { [string]: RawThreadInfo } = {};		const updatedThreadInfos: { [string]: MinimallyEncodedRawThreadInfo } = {};
for (const setToUnread of action.payload.result.unfocusedToUnread) {		for (const setToUnread of action.payload.result.unfocusedToUnread) {
const threadInfo = state.threadInfos[setToUnread];		const threadInfo = state.threadInfos[setToUnread];
// TODO (atul): Try to get rid of this ridiculous branching.
if (threadInfo.minimallyEncoded) {
if (threadInfo && !threadInfo.currentUser.unread) {
updatedThreadInfos[setToUnread] = {
...threadInfo,
currentUser: {
...threadInfo.currentUser,
unread: true,
},
};
}
} else {
if (threadInfo && !threadInfo.currentUser.unread) {		if (threadInfo && !threadInfo.currentUser.unread) {
updatedThreadInfos[setToUnread] = {		updatedThreadInfos[setToUnread] = {
...threadInfo,		...threadInfo,
currentUser: {		currentUser: {
...threadInfo.currentUser,		...threadInfo.currentUser,
unread: true,		unread: true,
},		},
};		};
}		}
}		}
}

if (Object.keys(updatedThreadInfos).length === 0) {		if (Object.keys(updatedThreadInfos).length === 0) {
return {		return {
threadStore: state,		threadStore: state,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations: [],		threadStoreOperations: [],
};		};
}		}
const threadStoreOperations = Object.keys(updatedThreadInfos).map(id => ({		const threadStoreOperations = Object.keys(updatedThreadInfos).map(id => ({
Show All 10 Lines	) {
return {		return {
threadStore: updatedThreadStore,		threadStore: updatedThreadStore,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations,		threadStoreOperations,
};		};
} else if (action.type === setThreadUnreadStatusActionTypes.started) {		} else if (action.type === setThreadUnreadStatusActionTypes.started) {
const { threadID, unread } = action.payload;		const { threadID, unread } = action.payload;
const threadInfo = state.threadInfos[threadID];		const threadInfo = state.threadInfos[threadID];
// TODO (atul): Try to get rid of this ridiculous branching.
if (threadInfo.minimallyEncoded) {
const updatedThreadInfo = {
...threadInfo,
currentUser: {
...threadInfo.currentUser,
unread,
},
};
const threadStoreOperations = [
{
type: 'replace',
payload: {
id: threadID,
threadInfo: updatedThreadInfo,
},
},
];
const updatedThreadStore = processThreadStoreOperations(
state,
threadStoreOperations,
);
return {
threadStore: updatedThreadStore,
newThreadInconsistencies: [],
threadStoreOperations,
};
} else {
const updatedThreadInfo = {		const updatedThreadInfo = {
...threadInfo,		...threadInfo,
currentUser: {		currentUser: {
...threadInfo.currentUser,		...threadInfo.currentUser,
unread,		unread,
},		},
};		};
const threadStoreOperations = [		const threadStoreOperations = [
{		{
type: 'replace',		type: 'replace',
payload: {		payload: {
id: threadID,		id: threadID,
threadInfo: updatedThreadInfo,		threadInfo: updatedThreadInfo,
},		},
},		},
];		];
const updatedThreadStore = processThreadStoreOperations(		const updatedThreadStore = processThreadStoreOperations(
state,		state,
threadStoreOperations,		threadStoreOperations,
);		);
return {		return {
threadStore: updatedThreadStore,		threadStore: updatedThreadStore,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations,		threadStoreOperations,
};		};
}
} else if (action.type === setThreadUnreadStatusActionTypes.success) {		} else if (action.type === setThreadUnreadStatusActionTypes.success) {
const { threadID, resetToUnread } = action.payload;		const { threadID, resetToUnread } = action.payload;
const currentUser = state.threadInfos[threadID].currentUser;		const currentUser = state.threadInfos[threadID].currentUser;

if (!resetToUnread \|\| currentUser.unread) {		if (!resetToUnread \|\| currentUser.unread) {
return {		return {
threadStore: state,		threadStore: state,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations: [],		threadStoreOperations: [],
};		};
}		}

const threadInfo = state.threadInfos[threadID];		const threadInfo = state.threadInfos[threadID];
// TODO (atul): Try to get rid of this ridiculous branching.
if (threadInfo.minimallyEncoded) {
const updatedThread = {		const updatedThread = {
...threadInfo,		...threadInfo,
currentUser: { ...threadInfo.currentUser, unread: true },		currentUser: { ...threadInfo.currentUser, unread: true },
};		};
const threadStoreOperations = [		const threadStoreOperations = [
{		{
type: 'replace',		type: 'replace',
payload: {		payload: {
id: threadID,		id: threadID,
threadInfo: updatedThread,		threadInfo: updatedThread,
},		},
},		},
];		];
const updatedThreadStore = processThreadStoreOperations(		const updatedThreadStore = processThreadStoreOperations(
state,		state,
threadStoreOperations,		threadStoreOperations,
);		);
return {		return {
threadStore: updatedThreadStore,		threadStore: updatedThreadStore,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations,		threadStoreOperations,
};		};
} else {
const updatedThread = {
...threadInfo,
currentUser: { ...threadInfo.currentUser, unread: true },
};
const threadStoreOperations = [
{
type: 'replace',
payload: {
id: threadID,
threadInfo: updatedThread,
},
},
];
const updatedThreadStore = processThreadStoreOperations(
state,
threadStoreOperations,
);
return {
threadStore: updatedThreadStore,
newThreadInconsistencies: [],
threadStoreOperations,
};
}
} else if (action.type === setClientDBStoreActionType) {		} else if (action.type === setClientDBStoreActionType) {
return {		return {
threadStore: action.payload.threadStore ?? state,		threadStore: action.payload.threadStore ?? state,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations: [],		threadStoreOperations: [],
};		};
}		}
return {		return {
threadStore: state,		threadStore: state,
newThreadInconsistencies: [],		newThreadInconsistencies: [],
threadStoreOperations: [],		threadStoreOperations: [],
};		};
}		}

export { reduceThreadInfos };		export { reduceThreadInfos };

[keyserver/web/native] Covert AES-256 key from Uint8Array representation to hex string representationClosedPublicActions

Details

Diff Detail

Event Timeline

Revision ContentsChangeset List

Diff 31136

keyserver/src/keyserver.js

lib/facts/links.js

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

web/account/qr-code-login.react.js

[keyserver/web/native] Covert AES-256 key from Uint8Array representation to hex string representation
ClosedPublic
Actions

Revision Contents
Changeset List