refactor: store token in profile record

Author: Jack-Works

packages/mask/background/database/persona/helper.ts

@@ -180,31 +180,32 @@ export async function createPersonaByJsonWebKey(options: {
 
 export async function createProfileWithPersona(
     profileID: ProfileIdentifier,
-    data: LinkedProfileDetails,
-    keys: {
+    linkMeta: LinkedProfileDetails,
+    persona: {
         nickname?: string
         publicKey: EC_Public_JsonWebKey
         privateKey?: EC_Private_JsonWebKey
         localKey?: AESJsonWebKey
         mnemonic?: PersonaRecord['mnemonic']
     },
+    token?: string | null,
 ): Promise<void> {
-    const ec_id = (await ECKeyIdentifier.fromJsonWebKey(keys.publicKey)).unwrap()
+    const ec_id = (await ECKeyIdentifier.fromJsonWebKey(persona.publicKey)).unwrap()
     const rec: PersonaRecord = {
         createdAt: new Date(),
         updatedAt: new Date(),
         identifier: ec_id,
         linkedProfiles: new Map(),
-        nickname: keys.nickname,
-        publicKey: keys.publicKey,
-        privateKey: keys.privateKey,
-        localKey: keys.localKey,
-        mnemonic: keys.mnemonic,
+        nickname: persona.nickname,
+        publicKey: persona.publicKey,
+        privateKey: persona.privateKey,
+        localKey: persona.localKey,
+        mnemonic: persona.mnemonic,
         hasLogout: false,
     }
     await consistentPersonaDBWriteAccess(async (t) => {
         await createOrUpdatePersonaDB(rec, { explicitUndefinedField: 'ignore', linkedProfiles: 'merge' }, t)
-        await attachProfileDB(profileID, ec_id, data, t)
+        await attachProfileDB(profileID, ec_id, linkMeta, { token }, t)
     })
 }
 // #endregion

packages/mask/background/database/persona/type.ts

@@ -112,6 +112,7 @@ export interface ProfileRecord {
     nickname?: string
     localKey?: AESJsonWebKey
     linkedPersona?: PersonaIdentifier
+    token?: string
     createdAt: Date
     updatedAt: Date
 }

packages/mask/background/database/persona/web.ts

@@ -522,6 +522,7 @@ export async function attachProfileDB(
     identifier: ProfileIdentifier,
     attachTo: PersonaIdentifier,
     data: LinkedProfileDetails,
+    profileExtra?: { token?: string | null },
     t?: FullPersonaDBTransaction<'readwrite'>,
 ): Promise<void> {
     t = t || createTransaction(await db(), 'readwrite')('personas', 'profiles', 'relations')
@@ -536,6 +537,12 @@ export async function attachProfileDB(
         await detachProfileDB(identifier, t)
     }
 
+    if (profileExtra?.token) {
+        profile.token = profileExtra.token
+    } else if (profileExtra && 'token' in profileExtra && !profileExtra.token) {
+        delete profile.token
+    }
+
     profile.linkedPersona = attachTo
     persona.linkedProfiles.set(identifier, data)
 

packages/mask/background/services/identity/profile/update.ts

@@ -86,22 +86,23 @@ export async function resolveUnknownLegacyIdentity(identifier: ProfileIdentifier
 export async function attachProfile(
     source: ProfileIdentifier,
     target: ProfileIdentifier | PersonaIdentifier,
-    data: LinkedProfileDetails,
+    linkMeta: LinkedProfileDetails,
+    profileExtra?: { token?: string | null },
 ): Promise<void> {
     if (target instanceof ProfileIdentifier) {
         const profile = await queryProfileDB(target)
         if (!profile?.linkedPersona) throw new Error('target not found')
         target = profile.linkedPersona
     }
-    return attachProfileDB(source, target, data)
+    return attachProfileDB(source, target, linkMeta, profileExtra)
 }
 export function detachProfile(identifier: ProfileIdentifier): Promise<void> {
     return detachProfileDB(identifier)
 }
 
 /**
  * Set NextID profile to profileDB
- * */
+ */
 
 export async function attachNextIDPersonaToProfile(item: ProfileInformationFromNextID, whoAmI: ECKeyIdentifier) {
     if (!item.linkedPersona) throw new Error('LinkedPersona Not Found')
@@ -137,6 +138,7 @@ export async function attachNextIDPersonaToProfile(item: ProfileInformationFromN
                 profileRecord.identifier,
                 item.linkedPersona!,
                 { connectionConfirmState: 'confirmed' },
+                undefined,
                 t,
             )
             await createOrUpdateRelationDB(

packages/mask/popups/pages/Personas/ConnectFirefly/index.tsx

@@ -1,5 +1,4 @@
 import { Trans, useLingui } from '@lingui/react/macro'
-import { attachProfile } from '@masknet/plugin-infra/dom/context'
 import { PersonaContext, PopupHomeTabType } from '@masknet/shared'
 import {
     AbortError,
@@ -22,6 +21,7 @@ import { useMount } from 'react-use'
 import urlcat from 'urlcat'
 import { useTitle } from '../../../hooks/index.js'
 import { createAccountByRelayService } from './createAccountByRelayService.js'
+import Services from '#services'
 
 const useStyles = makeStyles()({
     container: {
@@ -98,11 +98,12 @@ export const Component = memo(function ConnectFireflyPage() {
                     setUrl(url)
                 })
                 console.log('account', account)
-                if (attachProfile && currentPersona) {
-                    await attachProfile(
+                if (currentPersona) {
+                    await Services.Identity.attachProfile(
                         ProfileIdentifier.of(EnhanceableSite.Farcaster, account.session.profileId).unwrap(),
                         currentPersona.identifier,
-                        { connectionConfirmState: 'pending', token: account.session.token },
+                        { connectionConfirmState: 'pending' },
+                        { token: account.session.token },
                     )
                 }
                 console.log('account', account)

packages/public-api/src/types/index.ts

@@ -14,7 +14,6 @@ export interface JsonRpcResponse {
 
 export interface LinkedProfileDetails {
     connectionConfirmState: 'confirmed' | 'pending'
-    token?: string
 }
 
 // These type MUST be sync with packages/shared-base/src/crypto/JWKType