Page MenuHomePhabricator
Differential D13310

[native] Launch SIWE backup secret creation
ClosedPublic
Actions

Authored by ashoat on Sep 12 2024, 11:07 AM.
Tags
None
Referenced Files
Unknown Object (File)
Tue, Mar 4, 9:55 AM
Unknown Object (File)
Wed, Feb 26, 11:37 AM
Unknown Object (File)
Wed, Feb 26, 10:49 AM
Unknown Object (File)
Feb 9 2025, 12:44 PM
Unknown Object (File)
Jan 31 2025, 7:48 PM
Unknown Object (File)
Jan 31 2025, 7:48 PM
Unknown Object (File)
Jan 31 2025, 7:46 PM
Unknown Object (File)
Jan 23 2025, 12:31 AM
View All 46 Files
Subscribers
tomek

Details

Reviewers
marcin
varun
Commits
rCOMM72cc1de5f953: [native] Launch SIWE backup secret creation
Summary

While the backup itself isn't ready, we're ready to generate the secret for SIWE backup. It would be good to get this info from users as part of the new registration flow.

Depends on D13309

Test Plan

Make sure SIWE backup screen shows up in registration flow when using an ETH wallet

Diff Detail

Repository
rCOMM Comm
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Revision Contents
Changeset List

PathSize
native/
account/
registration/
6 lines
missing-registration-data/
2 lines
2 lines

Diff 44178

View Options

native/account/registration/avatar-selection.react.js

// @flow // @flow
import invariant from 'invariant'; import invariant from 'invariant';
import * as React from 'react'; import * as React from 'react';
import { useDispatch } from 'react-redux'; import { useDispatch } from 'react-redux';
import { createSelector } from 'reselect';
import { ENSCacheContext } from 'lib/components/ens-cache-provider.react'; import { ENSCacheContext } from 'lib/components/ens-cache-provider.react';
import { threadInfoSelector } from 'lib/selectors/thread-selectors';
import { createPendingSidebar } from 'lib/shared/thread-utils'; import { createPendingSidebar } from 'lib/shared/thread-utils';
import type { import type {
ComposableMessageInfo, ComposableMessageInfo,
RobotextMessageInfo, RobotextMessageInfo,
} from 'lib/types/message-types'; } from 'lib/types/message-types';
import type { ThreadInfo } from 'lib/types/thread-types'; import type { ThreadInfo, RawThreadInfo } from 'lib/types/thread-types';
import { values } from 'lib/utils/objects';
import { getDefaultTextMessageRules } from '../markdown/rules.react'; import { getDefaultTextMessageRules } from '../markdown/rules.react';
import { updateNavInfoActionType } from '../redux/action-types'; import { updateNavInfoActionType } from '../redux/action-types';
import type { AppState } from '../redux/redux-setup';
import { useSelector } from '../redux/redux-utils'; import { useSelector } from '../redux/redux-utils';
function useOnClickThread( function useOnClickThread(
thread: ?ThreadInfo, thread: ?ThreadInfo,
): (event: SyntheticEvent<HTMLElement>) => void { ): (event: SyntheticEvent<HTMLElement>) => void {
const dispatch = useDispatch(); const dispatch = useDispatch();
return React.useCallback( return React.useCallback(
(event: SyntheticEvent<HTMLElement>) => { (event: SyntheticEvent<HTMLElement>) => {
▲ Show 20 Lines • Show All 77 Lines • ▼ Show 20 Lines (event: SyntheticEvent<HTMLElement>) => {
selectedUserList: [], selectedUserList: [],
}, },
}); });
}, },
[dispatch], [dispatch],
); );
} }
function filteredCommunityThreadIDs(
communityID: string,
threadInfosObj: { +[id: string]: ThreadInfo | RawThreadInfo },
): $ReadOnlySet<string> {
const threadInfos = values(threadInfosObj);
const threadIDs = threadInfos
.filter(
thread => thread.community === communityID || thread.id === communityID,
)
.map(item => item.id);
return new Set(threadIDs);
}
const filteredCommunityThreadIDsSelector: (
state: AppState,
) => ?$ReadOnlySet<string> = createSelector(
(state: AppState) => state.communityIDFilter,
threadInfoSelector,
(
communityIDFilter: ?string,
threadInfos: { +[id: string]: ThreadInfo },
): ?$ReadOnlySet<string> => {
kamilUnsubmitted
Not Done
Inline Actions

This type could be skipped since it's obvious this will be the same as the return type of the entire selector but I saw in codebase versions with/without type in last callback so deffering to you

kamil: This type could be skipped since it's obvious this will be the same as the return type of the…
if (!communityIDFilter) {
return null;
}
return filteredCommunityThreadIDs(communityIDFilter, threadInfos);
},
);
export { export {
useOnClickThread, useOnClickThread,
useThreadIsActive, useThreadIsActive,
useOnClickPendingSidebar, useOnClickPendingSidebar,
useOnClickNewThread, useOnClickNewThread,
filteredCommunityThreadIDsSelector,
filteredCommunityThreadIDs,
}; };
View Options

native/account/registration/missing-registration-data/missing-registration-data-handler.react.js

// @flow // @flow
import invariant from 'invariant'; import invariant from 'invariant';
import * as React from 'react'; import * as React from 'react';
import { useDispatch } from 'react-redux'; import { useDispatch } from 'react-redux';
import { createSelector } from 'reselect';
import { ENSCacheContext } from 'lib/components/ens-cache-provider.react'; import { ENSCacheContext } from 'lib/components/ens-cache-provider.react';
import { threadInfoSelector } from 'lib/selectors/thread-selectors';
import { createPendingSidebar } from 'lib/shared/thread-utils'; import { createPendingSidebar } from 'lib/shared/thread-utils';
import type { import type {
ComposableMessageInfo, ComposableMessageInfo,
RobotextMessageInfo, RobotextMessageInfo,
} from 'lib/types/message-types'; } from 'lib/types/message-types';
import type { ThreadInfo } from 'lib/types/thread-types'; import type { ThreadInfo, RawThreadInfo } from 'lib/types/thread-types';
import { values } from 'lib/utils/objects';
import { getDefaultTextMessageRules } from '../markdown/rules.react'; import { getDefaultTextMessageRules } from '../markdown/rules.react';
import { updateNavInfoActionType } from '../redux/action-types'; import { updateNavInfoActionType } from '../redux/action-types';
import type { AppState } from '../redux/redux-setup';
import { useSelector } from '../redux/redux-utils'; import { useSelector } from '../redux/redux-utils';
function useOnClickThread( function useOnClickThread(
thread: ?ThreadInfo, thread: ?ThreadInfo,
): (event: SyntheticEvent<HTMLElement>) => void { ): (event: SyntheticEvent<HTMLElement>) => void {
const dispatch = useDispatch(); const dispatch = useDispatch();
return React.useCallback( return React.useCallback(
(event: SyntheticEvent<HTMLElement>) => { (event: SyntheticEvent<HTMLElement>) => {
▲ Show 20 Lines • Show All 77 Lines • ▼ Show 20 Lines (event: SyntheticEvent<HTMLElement>) => {
selectedUserList: [], selectedUserList: [],
}, },
}); });
}, },
[dispatch], [dispatch],
); );
} }
function filteredCommunityThreadIDs(
communityID: string,
threadInfosObj: { +[id: string]: ThreadInfo | RawThreadInfo },
): $ReadOnlySet<string> {
const threadInfos = values(threadInfosObj);
const threadIDs = threadInfos
.filter(
thread => thread.community === communityID || thread.id === communityID,
)
.map(item => item.id);
return new Set(threadIDs);
}
const filteredCommunityThreadIDsSelector: (
state: AppState,
) => ?$ReadOnlySet<string> = createSelector(
(state: AppState) => state.communityIDFilter,
threadInfoSelector,
(
communityIDFilter: ?string,
threadInfos: { +[id: string]: ThreadInfo },
): ?$ReadOnlySet<string> => {
kamilUnsubmitted
Not Done
Inline Actions

This type could be skipped since it's obvious this will be the same as the return type of the entire selector but I saw in codebase versions with/without type in last callback so deffering to you

kamil: This type could be skipped since it's obvious this will be the same as the return type of the…
if (!communityIDFilter) {
return null;
}
return filteredCommunityThreadIDs(communityIDFilter, threadInfos);
},
);
export { export {
useOnClickThread, useOnClickThread,
useThreadIsActive, useThreadIsActive,
useOnClickPendingSidebar, useOnClickPendingSidebar,
useOnClickNewThread, useOnClickNewThread,
filteredCommunityThreadIDsSelector,
filteredCommunityThreadIDs,
}; };
View Options

native/account/registration/registration-types.js

// @flow // @flow
import invariant from 'invariant'; import invariant from 'invariant';
import * as React from 'react'; import * as React from 'react';
import { useDispatch } from 'react-redux'; import { useDispatch } from 'react-redux';
import { createSelector } from 'reselect';
import { ENSCacheContext } from 'lib/components/ens-cache-provider.react'; import { ENSCacheContext } from 'lib/components/ens-cache-provider.react';
import { threadInfoSelector } from 'lib/selectors/thread-selectors';
import { createPendingSidebar } from 'lib/shared/thread-utils'; import { createPendingSidebar } from 'lib/shared/thread-utils';
import type { import type {
ComposableMessageInfo, ComposableMessageInfo,
RobotextMessageInfo, RobotextMessageInfo,
} from 'lib/types/message-types'; } from 'lib/types/message-types';
import type { ThreadInfo } from 'lib/types/thread-types'; import type { ThreadInfo, RawThreadInfo } from 'lib/types/thread-types';
import { values } from 'lib/utils/objects';
import { getDefaultTextMessageRules } from '../markdown/rules.react'; import { getDefaultTextMessageRules } from '../markdown/rules.react';
import { updateNavInfoActionType } from '../redux/action-types'; import { updateNavInfoActionType } from '../redux/action-types';
import type { AppState } from '../redux/redux-setup';
import { useSelector } from '../redux/redux-utils'; import { useSelector } from '../redux/redux-utils';
function useOnClickThread( function useOnClickThread(
thread: ?ThreadInfo, thread: ?ThreadInfo,
): (event: SyntheticEvent<HTMLElement>) => void { ): (event: SyntheticEvent<HTMLElement>) => void {
const dispatch = useDispatch(); const dispatch = useDispatch();
return React.useCallback( return React.useCallback(
(event: SyntheticEvent<HTMLElement>) => { (event: SyntheticEvent<HTMLElement>) => {
▲ Show 20 Lines • Show All 77 Lines • ▼ Show 20 Lines (event: SyntheticEvent<HTMLElement>) => {
selectedUserList: [], selectedUserList: [],
}, },
}); });
}, },
[dispatch], [dispatch],
); );
} }
function filteredCommunityThreadIDs(
communityID: string,
threadInfosObj: { +[id: string]: ThreadInfo | RawThreadInfo },
): $ReadOnlySet<string> {
const threadInfos = values(threadInfosObj);
const threadIDs = threadInfos
.filter(
thread => thread.community === communityID || thread.id === communityID,
)
.map(item => item.id);
return new Set(threadIDs);
}
const filteredCommunityThreadIDsSelector: (
state: AppState,
) => ?$ReadOnlySet<string> = createSelector(
(state: AppState) => state.communityIDFilter,
threadInfoSelector,
(
communityIDFilter: ?string,
threadInfos: { +[id: string]: ThreadInfo },
): ?$ReadOnlySet<string> => {
kamilUnsubmitted
Not Done
Inline Actions

This type could be skipped since it's obvious this will be the same as the return type of the entire selector but I saw in codebase versions with/without type in last callback so deffering to you

kamil: This type could be skipped since it's obvious this will be the same as the return type of the…
if (!communityIDFilter) {
return null;
}
return filteredCommunityThreadIDs(communityIDFilter, threadInfos);
},
);
export { export {
useOnClickThread, useOnClickThread,
useThreadIsActive, useThreadIsActive,
useOnClickPendingSidebar, useOnClickPendingSidebar,
useOnClickNewThread, useOnClickNewThread,
filteredCommunityThreadIDsSelector,
filteredCommunityThreadIDs,
}; };