Paths

Table of Contentst

-
native/
-
backup/
1/2
restore-siwe-backup.react.js
1/2
use-client-backup.js
-
profile/
1/2
backup-menu.react.js

[native] make it possible to test signing using Olm Account from User Keys
ClosedPublic
Actions

Authored by kamil on Nov 26 2024, 6:08 AM.

Details

Reviewers

bartek
tomek

Commits

rCOMMc93bd7a55df0: [native] make it possible to test signing using Olm Account from User Keys

Summary

ENG-9603.

This is a test case and an example of how to use it, probably this code can be updated, exported, and used in Restore Flow later (cc. @tomek).

This is a real-life use case because we take the previous Primary Device deviceID from the device list history, then sign the message using Olm Account from Backup without extracting deviceID, and use deviceID from the device list to verify — so if this passes verification, both device list history and User Keys upload/download/crypto operations work together.

Depends on D14046

Test Plan

Perform what is explained in test case

Diff Detail

Repository

rCOMM Comm

Branch

land

Lint

No Lint Coverage

Unit

No Test Coverage

Event Timeline

kamil created this revision.Nov 26 2024, 6:08 AM

kamil held this revision as a draft.

Herald added a subscriber: ashoat. · View Herald TranscriptNov 26 2024, 6:08 AM

kamil edited the summary of this revision. (Show Details)Nov 26 2024, 6:10 AM

kamil added inline comments.Nov 26 2024, 6:13 AM

native/backup/restore-siwe-backup.react.js
52–60 ↗	(On Diff #46080)	The old code is wrong - I mentioned this here
native/profile/backup-menu.react.js
197–211 ↗	(On Diff #46080)

kamil retitled this revision from [native] make it possible to test singing using Olm Account from User Keys to [native] make it possible to test signing using Olm Account from User Keys.Nov 26 2024, 6:17 AM

Harbormaster failed remote builds in B32865: Diff 46080!Nov 26 2024, 6:20 AM

eslint

kamil added a child revision: D14048: [CommCoreModule] deprecate `computeBackupKey`.Nov 26 2024, 6:27 AM

kamil published this revision for review.Nov 26 2024, 6:45 AM

Harbormaster completed remote builds in B32866: Diff 46081.Nov 26 2024, 8:48 AM

bartek accepted this revision.Nov 29 2024, 2:20 AM

bartek added inline comments.

native/profile/backup-menu.react.js
335–337 ↗	(On Diff #46081)	I was thinking about a note e.g. "see code comments" but not sure if it's worth it. Only us will be using it and this test button i going to be removed when the feature is released

This revision is now accepted and ready to land.Nov 29 2024, 2:20 AM

rebase

Harbormaster completed remote builds in B32906: Diff 46165.Dec 2 2024, 7:36 AM

Closed by commit rCOMMc93bd7a55df0: [native] make it possible to test signing using Olm Account from User Keys (authored by kamil). · Explain WhyDec 3 2024, 6:28 AM

This revision was automatically updated to reflect the committed changes.

kamil added a commit: rCOMMc93bd7a55df0: [native] make it possible to test signing using Olm Account from User Keys.

Revision Contents
Changeset List

Path

Size

native/

backup/

restore-siwe-backup.react.js

17 lines

use-client-backup.js

26 lines

profile/

backup-menu.react.js

139 lines

Diff 46165

View Options

native/backup/restore-siwe-backup.react.js

// @flow // @flow

import * as React from 'react'; import * as React from 'react';

import { setAuxUserFIDsActionType } from '../actions/aux-user-actions.js';

import { import {

updateRelationships as serverUpdateRelationships, updateRelationships as serverUpdateRelationships,

updateRelationshipsActionTypes, updateRelationshipsActionTypes,

} from '../actions/relationship-actions.js'; } from '../actions/relationship-actions.js';

import { NeynarClientContext } from '../components/neynar-client-provider.react.js'; import { NeynarClientContext } from '../components/neynar-client-provider.react.js';

import { useLegacyAshoatKeyserverCall } from '../keyserver-conn/legacy-keyserver-call.js'; import { useLegacyAshoatKeyserverCall } from '../keyserver-conn/legacy-keyserver-call.js';

import { cookieSelector } from '../selectors/keyserver-selectors.js'; import { cookieSelector } from '../selectors/keyserver-selectors.js';

import { IdentityClientContext } from '../shared/identity-client-context.js'; import { IdentityClientContext } from '../shared/identity-client-context.js';

import { relationshipActions } from '../types/relationship-types.js'; import { relationshipActions } from '../types/relationship-types.js';

import { authoritativeKeyserverID } from '../utils/authoritative-keyserver.js'; import { authoritativeKeyserverID } from '../utils/authoritative-keyserver.js';

import { useCurrentUserFID } from '../utils/farcaster-utils.js'; import { useCurrentUserFID } from '../utils/farcaster-utils.js';

import { useDispatchActionPromise } from '../utils/redux-promise-utils.js'; import { useDispatchActionPromise } from '../utils/redux-promise-utils.js';

import { useSelector } from '../utils/redux-utils.js'; import { useSelector, useDispatch } from '../utils/redux-utils.js';

import { usingCommServicesAccessToken } from '../utils/services-utils.js'; import { usingCommServicesAccessToken } from '../utils/services-utils.js';

function FarcasterDataHandler(): React.Node { function FarcasterDataHandler(): React.Node {

const isActive = useSelector(state => state.lifecycleState !== 'background'); const isActive = useSelector(state => state.lifecycleState !== 'background');

const cookie = useSelector(cookieSelector(authoritativeKeyserverID())); const cookie = useSelector(cookieSelector(authoritativeKeyserverID()));

const hasUserCookie = !!(cookie && cookie.startsWith('user=')); const hasUserCookie = !!(cookie && cookie.startsWith('user='));

const currentUserID = useSelector(state => state.currentUserInfo?.id); const currentUserID = useSelector(state => state.currentUserInfo?.id);

const loggedIn = !!currentUserID && hasUserCookie; const loggedIn = !!currentUserID && hasUserCookie;

const neynarClient = React.useContext(NeynarClientContext)?.client; const neynarClient = React.useContext(NeynarClientContext)?.client;

const identityServiceClient = React.useContext(IdentityClientContext); const identityServiceClient = React.useContext(IdentityClientContext);

const getFarcasterUsers = const getFarcasterUsers =

identityServiceClient?.identityClient.getFarcasterUsers; identityServiceClient?.identityClient.getFarcasterUsers;

const findUserIdentities =

identityServiceClient?.identityClient.findUserIdentities;

const dispatch = useDispatch();

const dispatchActionPromise = useDispatchActionPromise(); const dispatchActionPromise = useDispatchActionPromise();

const updateRelationships = useLegacyAshoatKeyserverCall( const updateRelationships = useLegacyAshoatKeyserverCall(

serverUpdateRelationships, serverUpdateRelationships,

); );

const createThreadsAndRobotextForFarcasterMutuals = React.useCallback( const createThreadsAndRobotextForFarcasterMutuals = React.useCallback(

(userIDsToFID: { +[userID: string]: string }) => (userIDsToFID: { +[userID: string]: string }) =>

updateRelationships({ updateRelationships({

action: relationshipActions.FARCASTER_MUTUAL, action: relationshipActions.FARCASTER_MUTUAL,

userIDsToFID, userIDsToFID,

}), }),

[updateRelationships], [updateRelationships],

); );

const userInfos = useSelector(state => state.userStore.userInfos); const userInfos = useSelector(state => state.userStore.userInfos);

const fid = useCurrentUserFID(); const fid = useCurrentUserFID();

const prevCanQueryRef = React.useRef<?boolean>(); const prevCanQueryRef = React.useRef<?boolean>();

React.useEffect(() => {

if (!usingCommServicesAccessToken) {

return;

}

const handleFarcasterMutuals = React.useCallback(async () => {

const canQuery = isActive && !!fid && loggedIn; const canQuery = isActive && !!fid && loggedIn;

if (canQuery === prevCanQueryRef.current) { if (canQuery === prevCanQueryRef.current) {

return; return;

} }

prevCanQueryRef.current = canQuery; prevCanQueryRef.current = canQuery;

if ( if (

!loggedIn || !loggedIn ||

!isActive || !isActive ||

!fid || !fid ||

!neynarClient || !neynarClient ||

!getFarcasterUsers || !getFarcasterUsers ||

!currentUserID !currentUserID

) { ) {

return; return;

} }

void (async () => {

const followerFIDs = await neynarClient.fetchFriendFIDs(fid); const followerFIDs = await neynarClient.fetchFriendFIDs(fid);

const commFCUsers = await getFarcasterUsers(followerFIDs); const commFCUsers = await getFarcasterUsers(followerFIDs);

const newCommUsers = commFCUsers.filter( const newCommUsers = commFCUsers.filter(({ userID }) => !userInfos[userID]);

({ userID }) => !userInfos[userID],

);

if (newCommUsers.length === 0) { if (newCommUsers.length === 0) {

return; return;

} }

const userIDsToFID: { +[userID: string]: string } = Object.fromEntries( const userIDsToFID: { +[userID: string]: string } = Object.fromEntries(

newCommUsers.map(({ userID, farcasterID }) => [userID, farcasterID]), newCommUsers.map(({ userID, farcasterID }) => [userID, farcasterID]),

); );

const userIDsToFIDIncludingCurrentUser: { +[userID: string]: string } = { const userIDsToFIDIncludingCurrentUser: { +[userID: string]: string } = {

...userIDsToFID, ...userIDsToFID,

[(currentUserID: string)]: fid, [(currentUserID: string)]: fid,

}; };

void dispatchActionPromise( void dispatchActionPromise(

updateRelationshipsActionTypes, updateRelationshipsActionTypes,

createThreadsAndRobotextForFarcasterMutuals( createThreadsAndRobotextForFarcasterMutuals(

userIDsToFIDIncludingCurrentUser, userIDsToFIDIncludingCurrentUser,

), ),

); );

})();

}, [ }, [

isActive, isActive,

fid, fid,

loggedIn, loggedIn,

neynarClient, neynarClient,

getFarcasterUsers, getFarcasterUsers,

userInfos, userInfos,

dispatchActionPromise, dispatchActionPromise,

createThreadsAndRobotextForFarcasterMutuals, createThreadsAndRobotextForFarcasterMutuals,

currentUserID, currentUserID,

]); ]);

const handleUserStoreFIDs = React.useCallback(async () => {

if (!loggedIn || !isActive || !findUserIdentities) {

return;

}

const userStoreIDs = Object.keys(userInfos);

const userIdentities = await findUserIdentities(userStoreIDs);

const userStoreFarcasterUsers = Object.entries(userIdentities)

.filter(([, identity]) => identity.farcasterID !== null)

.map(([userID, identity]) => ({

userID,

username: identity.username,

farcasterID: identity.farcasterID,

}));

dispatch({

type: setAuxUserFIDsActionType,

payload: {

farcasterUsers: userStoreFarcasterUsers,

});

willAuthorUnsubmitted

Done

I introduced a previous diff where setAuxUserFIDs now clears fids prior to updating with new fids from the payload. The previous functionality of setAuxUserFIDs of just adding without clearing is now a new action type addAuxUserFIDs

There are now two callbacks which are called by a single useEffect. The two callbacks are called handleFarcasterMutuals and handleUserStoreFIDs

will: I introduced a previous diff where `setAuxUserFIDs` now clears fids prior to updating with new…

}, [loggedIn, isActive, findUserIdentities, userInfos, dispatch]);

React.useEffect(() => {

if (!usingCommServicesAccessToken) {

return;

}

void (async () => {

await Promise.all([handleFarcasterMutuals(), handleUserStoreFIDs()]);

[]);

ashoatUnsubmitted

Not Done

return;

}

- void (async () => {

- await Promise.all([handleFarcasterMutuals(), handleUserStoreFIDs()]);

- },

- []);

+ void handleFarcasterMutuals();

+ void handleUserStoreFIDs();

}, [handleFarcasterMutuals, handleUserStoreFIDs]);

Line 145 isn't doing anything
Since we aren't waiting on these anyways, we can simplify this a little bit

ashoat: 1. Line 145 isn't doing anything 2. Since we aren't waiting on these anyways, we can simplify…

}, [handleFarcasterMutuals, handleUserStoreFIDs]);

return null; return null;

} }

export { FarcasterDataHandler }; export { FarcasterDataHandler };

View Options

native/backup/use-client-backup.js