Handle multiple invitation addresses

packages/backend/src/nest/common/utils.ts

@@ -12,6 +12,8 @@ import { TestConfig } from '../const'
 import logger from './logger'
 import { createCertificatesTestHelper } from './client-server'
 import { Libp2pNodeParams } from '../libp2p/libp2p.types'
+import { ONION_ADDRESS_REGEX, Site, createLibp2pAddress, createLibp2pListenAddress } from '@quiet/common'
+import { multiaddr } from '@multiformats/multiaddr'
 const log = logger('test')
 
 export interface Ports {
@@ -143,14 +145,6 @@ export const torDirForPlatform = (basePath?: string): string => {
   return torPath
 }
 
-export const createLibp2pAddress = (address: string, peerId: string) => {
-  return `/dns4/${address}/tcp/80/ws/p2p/${peerId}`
-}
-
-export const createLibp2pListenAddress = (address: string) => {
-  return `/dns4/${address}/tcp/80/ws`
-}
-
 export const getUsersAddresses = async (users: User[]): Promise<string[]> => {
   const peers = users.map(async (userData: User) => {
     return createLibp2pAddress(userData.onionAddress, userData.peerId)

packages/backend/src/nest/connections-manager/connections-manager.service.tor.spec.ts

@@ -4,14 +4,7 @@ import crypto from 'crypto'
 import { CustomEvent } from '@libp2p/interfaces/events'
 import { jest, beforeEach, describe, it, expect, afterEach } from '@jest/globals'
 import { communities, getFactory, identity, prepareStore, Store } from '@quiet/state-manager'
-import {
-  createLibp2pAddress,
-  createPeerId,
-  createTmpDir,
-  libp2pInstanceParams,
-  removeFilesFromDir,
-  tmpQuietDirPath,
-} from '../common/utils'
+import { createPeerId, createTmpDir, libp2pInstanceParams, removeFilesFromDir, tmpQuietDirPath } from '../common/utils'
 
 import { NetworkStats, type Community, type Identity, type InitCommunityPayload } from '@quiet/types'
 import { LazyModuleLoader } from '@nestjs/core'
@@ -37,6 +30,7 @@ import { DateTime } from 'luxon'
 import waitForExpect from 'wait-for-expect'
 import { Libp2pEvents } from '../libp2p/libp2p.types'
 import { sleep } from '../common/sleep'
+import { createLibp2pAddress } from '@quiet/common'
 
 jest.setTimeout(100_000)
 

packages/backend/src/nest/connections-manager/connections-manager.service.ts

@@ -42,6 +42,10 @@ import {
   StorePeerListPayload,
   UploadFilePayload,
   PeerId as PeerIdType,
+  SaveCSRPayload,
+  SendUserCertificatePayload,
+  CommunityMetadata,
+  CommunityMetadataPayload,
 } from '@quiet/types'
 import { CONFIG_OPTIONS, QUIET_DIR, SERVER_IO_PROVIDER, SOCKS_PROXY_AGENT } from '../const'
 import { ConfigOptions, GetPorts, ServerIoProviderTypes } from '../types'
@@ -165,17 +169,9 @@ export class ConnectionsManagerService extends EventEmitter implements OnModuleI
       if ([ServiceState.LAUNCHING, ServiceState.LAUNCHED].includes(this.communityState)) return
       this.communityState = ServiceState.LAUNCHING
     }
-    const registrarData: LaunchRegistrarPayload = await this.localDbService.get(LocalDBKeys.REGISTRAR)
-    if (registrarData) {
-      if ([ServiceState.LAUNCHING, ServiceState.LAUNCHED].includes(this.registrarState)) return
-      this.registrarState = ServiceState.LAUNCHING
-    }
     if (community) {
       await this.launchCommunity(community)
     }
-    if (registrarData) {
-      await this.registrationService.launchRegistrar(registrarData)
-    }
   }
 
   public async closeAllServices(options: { saveTor: boolean } = { saveTor: false }) {
@@ -273,20 +269,22 @@ export class ConnectionsManagerService extends EventEmitter implements OnModuleI
       community: {
         ...community,
         privateKey: network2.hiddenService.privateKey,
-        registrarUrl: community.registrarUrl || network2.hiddenService.onionAddress.split('.')[0],
+        registrarUrl: community.registrarUrl || network2.hiddenService.onionAddress.split('.')[0], // TODO: remove
       },
       network,
     }
     this.serverIoProvider.io.emit(SocketActionTypes.NETWORK, payload)
   }
 
   public async createCommunity(payload: InitCommunityPayload) {
+    console.log('ConnectionsManager.createCommunity peers:', payload.peers)
     await this.launchCommunity(payload)
     this.logger(`Created and launched community ${payload.id}`)
     this.serverIoProvider.io.emit(SocketActionTypes.NEW_COMMUNITY, { id: payload.id })
   }
 
   public async launchCommunity(payload: InitCommunityPayload) {
+    console.log('ConnectionsManager.launchCommunity peers:', payload.peers)
     this.communityState = ServiceState.LAUNCHING
     const communityData: InitCommunityPayload = await this.localDbService.get(LocalDBKeys.COMMUNITY)
     if (!communityData) {
@@ -327,7 +325,6 @@ export class ConnectionsManagerService extends EventEmitter implements OnModuleI
 
     const { Libp2pModule } = await import('../libp2p/libp2p.module')
     const moduleRef = await this.lazyModuleLoader.load(() => Libp2pModule)
-    this.logger('launchCommunityFromStorage')
     const { Libp2pService } = await import('../libp2p/libp2p.service')
     const lazyService = moduleRef.get(Libp2pService)
     this.libp2pService = lazyService
@@ -336,6 +333,7 @@ export class ConnectionsManagerService extends EventEmitter implements OnModuleI
     const _peerId = await peerIdFromKeys(restoredRsa.marshalPubKey(), restoredRsa.marshalPrivKey())
 
     let peers = payload.peers
+    console.log(`Launching community ${payload.id}, payload peers: ${peers}`)
     if (!peers || peers.length === 0) {
       peers = [this.libp2pService.createLibp2pAddress(onionAddress, _peerId.toString())]
     }
@@ -344,9 +342,6 @@ export class ConnectionsManagerService extends EventEmitter implements OnModuleI
       peerId: _peerId,
       listenAddresses: [this.libp2pService.createLibp2pListenAddress(onionAddress)],
       agent: this.socksProxyAgent,
-      cert: payload.certs.certificate,
-      key: payload.certs.key,
-      ca: payload.certs.CA,
       localAddress: this.libp2pService.createLibp2pAddress(onionAddress, _peerId.toString()),
       targetPort: this.ports.libp2pHiddenService,
       peers,
@@ -397,19 +392,9 @@ export class ConnectionsManagerService extends EventEmitter implements OnModuleI
     this.registrationService.on(SocketActionTypes.SAVED_OWNER_CERTIFICATE, payload => {
       this.serverIoProvider.io.emit(SocketActionTypes.SAVED_OWNER_CERTIFICATE, payload)
     })
-    this.registrationService.on(RegistrationEvents.SPAWN_HS_FOR_REGISTRAR, async payload => {
-      await this.tor.spawnHiddenService({
-        targetPort: payload.port,
-        privKey: payload.privateKey,
-        virtPort: payload.targetPort,
-      })
-    })
     this.registrationService.on(RegistrationEvents.ERROR, payload => {
       emitError(this.serverIoProvider.io, payload)
     })
-    this.registrationService.on(SocketActionTypes.SEND_USER_CERTIFICATE, payload => {
-      this.serverIoProvider.io.emit(SocketActionTypes.SEND_USER_CERTIFICATE, payload)
-    })
     this.registrationService.on(RegistrationEvents.NEW_USER, async payload => {
       await this.storageService?.saveCertificate(payload)
     })
@@ -446,18 +431,16 @@ export class ConnectionsManagerService extends EventEmitter implements OnModuleI
       this.communityState = ServiceState.LAUNCHING
       await this.launchCommunity(args)
     })
-    // Registration
     this.socketService.on(SocketActionTypes.LAUNCH_REGISTRAR, async (args: LaunchRegistrarPayload) => {
+      // Event left for setting permsData purposes
       this.logger(`socketService - ${SocketActionTypes.LAUNCH_REGISTRAR}`)
-
-      const communityData = await this.localDbService.get(LocalDBKeys.REGISTRAR)
-      if (!communityData) {
-        await this.localDbService.put(LocalDBKeys.REGISTRAR, args)
+      this.registrationService.permsData = {
+        certificate: args.rootCertString,
+        privKey: args.rootKeyString,
       }
-      console.log('this.registrarState', this.registrarState)
-      if ([ServiceState.LAUNCHING, ServiceState.LAUNCHED].includes(this.registrarState)) return
-      this.registrarState = ServiceState.LAUNCHING
-      await this.registrationService.launchRegistrar(args)
+    })
+    this.socketService.on(SocketActionTypes.SEND_COMMUNITY_METADATA, async (payload: CommunityMetadata) => {
+      await this.storageService?.updateCommunityMetadata(payload)
     })
     this.socketService.on(SocketActionTypes.SAVED_OWNER_CERTIFICATE, async (args: SaveOwnerCertificatePayload) => {
       const saveCertificatePayload: SaveCertificatePayload = {
@@ -466,18 +449,10 @@ export class ConnectionsManagerService extends EventEmitter implements OnModuleI
       }
       await this.storageService?.saveCertificate(saveCertificatePayload)
     })
-    this.socketService.on(SocketActionTypes.REGISTER_USER_CERTIFICATE, async (args: RegisterUserCertificatePayload) => {
-      // if (!this.socksProxyAgent) {
-      //   this.createAgent()
-      // }
-
-      await this.registrationService.sendCertificateRegistrationRequest(
-        args.serviceAddress,
-        args.userCsr,
-        args.communityId,
-        120_000,
-        this.socksProxyAgent
-      )
+    this.socketService.on(SocketActionTypes.SAVE_USER_CSR, async (payload: SaveCSRPayload) => {
+      console.log(`On ${SocketActionTypes.SAVE_USER_CSR}: ${payload.csr}`)
+      await this.storageService?.saveCSR(payload)
+      this.serverIoProvider.io.emit(SocketActionTypes.SAVED_USER_CSR, payload)
     })
     this.socketService.on(
       SocketActionTypes.REGISTER_OWNER_CERTIFICATE,
@@ -592,5 +567,17 @@ export class ConnectionsManagerService extends EventEmitter implements OnModuleI
       console.log('emitting deleted channel event back to state manager')
       this.serverIoProvider.io.emit(SocketActionTypes.CHANNEL_DELETION_RESPONSE, payload)
     })
+    this.storageService.on(StorageEvents.REPLICATED_CSR, async (payload: { csr: string }) => {
+      console.log(`On ${StorageEvents.REPLICATED_CSR}`)
+      this.registrationService.emit(RegistrationEvents.REGISTER_USER_CERTIFICATE, payload.csr)
+    })
+    this.storageService.on(StorageEvents.REPLICATED_COMMUNITY_METADATA, (payload: CommunityMetadata) => {
+      console.log(`On ${StorageEvents.REPLICATED_COMMUNITY_METADATA}: ${payload}`)
+      const communityMetadataPayload: CommunityMetadataPayload = {
+        rootCa: payload.rootCa,
+        ownerCertificate: payload.ownerCertificate,
+      }
+      this.serverIoProvider.io.emit(SocketActionTypes.SAVE_COMMUNITY_METADATA, communityMetadataPayload)
+    })
   }
 }

packages/backend/src/nest/libp2p/libp2p.service.spec.ts

@@ -38,11 +38,11 @@ describe('Libp2pService', () => {
 
   it('creates libp2p address with proper ws type (%s)', async () => {
     const libp2pAddress = libp2pService.createLibp2pAddress(params.localAddress, params.peerId.toString())
-    expect(libp2pAddress).toStrictEqual(`/dns4/${params.localAddress}.onion/tcp/80/wss/p2p/${params.peerId.toString()}`)
+    expect(libp2pAddress).toStrictEqual(`/dns4/${params.localAddress}.onion/tcp/80/ws/p2p/${params.peerId.toString()}`)
   })
 
   it('creates libp2p listen address', async () => {
     const libp2pListenAddress = libp2pService.createLibp2pListenAddress('onionAddress')
-    expect(libp2pListenAddress).toStrictEqual(`/dns4/onionAddress.onion/tcp/80/wss`)
+    expect(libp2pListenAddress).toStrictEqual(`/dns4/onionAddress.onion/tcp/80/ws`)
   })
 })

packages/backend/src/nest/libp2p/libp2p.service.ts

@@ -15,10 +15,10 @@ import { multiaddr } from '@multiformats/multiaddr'
 import { ConnectionProcessInfo, PeerId, SocketActionTypes } from '@quiet/types'
 import { SERVER_IO_PROVIDER, SOCKS_PROXY_AGENT } from '../const'
 import { ServerIoProviderTypes } from '../types'
-import { createLibp2pListenAddress, createLibp2pAddress } from './libp2p.utils'
 import Logger from '../common/logger'
 import { webSockets } from '../websocketOverTor'
 import { all } from '../websocketOverTor/filters'
+import { createLibp2pAddress, createLibp2pListenAddress } from '@quiet/common'
 
 @Injectable()
 export class Libp2pService extends EventEmitter {
@@ -44,7 +44,8 @@ export class Libp2pService extends EventEmitter {
     return createLibp2pListenAddress(address)
   }
 
-  public async createInstance(params: Libp2pNodeParams): Promise<any> {
+  public async createInstance(params: Libp2pNodeParams): Promise<Libp2p> {
+    console.log('Libp2p.createInstance::: peers:::', params.peers)
     if (this.libp2pInstance) {
       return this.libp2pInstance
     }
@@ -112,6 +113,7 @@ export class Libp2pService extends EventEmitter {
 
     this.libp2pInstance.addEventListener('peer:connect', async peer => {
       const remotePeerId = peer.detail.remotePeer.toString()
+      console.log('ADDRESS', peer.detail.remoteAddr)
       this.logger(`${peerId.toString()} connected to ${remotePeerId}`)
 
       // Stop dialing as soon as we connect to a peer

packages/backend/src/nest/libp2p/libp2p.types.ts

@@ -11,9 +11,9 @@ export interface Libp2pNodeParams {
   peerId: any
   listenAddresses: string[]
   agent: Agent
-  cert: string
-  key: string
-  ca: string[]
+  cert?: string
+  key?: string
+  ca?: string[]
   localAddress: string
   targetPort: number
   peers: string[]

packages/backend/src/nest/registration/registration.functions.ts

@@ -205,6 +205,7 @@ export const registerUser = async (
   let cert: string
   const userData = new UserCsrData()
   userData.csr = csr
+  console.log('USER DATA', userData)
   const validationErrors = await validate(userData)
   if (validationErrors.length > 0) {
     logger.error(`Received data is not valid: ${validationErrors.toString()}`)

packages/backend/src/nest/registration/registration.service.ts

@@ -30,7 +30,7 @@ export class RegistrationService extends EventEmitter implements OnModuleInit {
   private _server: Server
   private _port: number
   public registrationService: any
-  public certificates: string[]
+  public certificates: string[] = []
   private _permsData: PermsData
   private _ownerCertificate: string
 
@@ -40,8 +40,17 @@ export class RegistrationService extends EventEmitter implements OnModuleInit {
 
   onModuleInit() {
     this.on(RegistrationEvents.SET_CERTIFICATES, certs => {
+      console.log('SET CERTIFICATES', certs)
       this.setCertificates(certs)
     })
+    this.on(RegistrationEvents.REGISTER_USER_CERTIFICATE, async (csr: string) => {
+      if (!this._permsData) {
+        console.log('NO PERMS DATA')
+        return
+      }
+      console.log('CSR in registration service', csr)
+      const response = await this.registerUser(csr)
+    })
     this.setRouting()
   }
 
@@ -84,6 +93,14 @@ export class RegistrationService extends EventEmitter implements OnModuleInit {
     })
   }
 
+  public set permsData(perms: PermsData) {
+    console.log('Setting owner perms data')
+    this._permsData = {
+      certificate: perms.certificate,
+      privKey: perms.privKey,
+    }
+  }
+
   public async registerOwnerCertificate(payload: RegisterOwnerCertificatePayload): Promise<void> {
     let cert: string
     try {
@@ -123,7 +140,7 @@ export class RegistrationService extends EventEmitter implements OnModuleInit {
     this.emit(response.eventType, response.data)
   }
 
-  private async registerUser(csr: string): Promise<{ status: number; body: any }> {
+  public async registerUser(csr: string): Promise<{ status: number; body: any }> {
     const result = await registerUser(csr, this._permsData, this.certificates, this._ownerCertificate)
     if (result?.status === 200) {
       this.emit(RegistrationEvents.NEW_USER, { certificate: result.body.certificate, rootPermsData: this._permsData })

packages/backend/src/nest/registration/registration.types.ts

@@ -4,4 +4,5 @@ export enum RegistrationEvents {
   NEW_USER = 'newUser',
   SET_CERTIFICATES = 'setCertificates',
   REGISTRAR_STATE = 'registrarState',
+  REGISTER_USER_CERTIFICATE = 'registerUserCertificate',
 }

packages/backend/src/nest/socket/socket.service.ts

@@ -15,6 +15,8 @@ import {
   LaunchRegistrarPayload,
   Community,
   DeleteFilesFromChannelSocketPayload,
+  SaveCSRPayload,
+  CommunityMetadata,
 } from '@quiet/types'
 import cors, { CorsOptions } from 'cors'
 import EventEmitter from 'events'
@@ -100,11 +102,11 @@ export class SocketService extends EventEmitter implements OnModuleInit {
         this.emit(SocketActionTypes.ASK_FOR_MESSAGES, payload)
       })
 
-      socket.on(SocketActionTypes.REGISTER_USER_CERTIFICATE, async (payload: RegisterUserCertificatePayload) => {
-        this.logger(`Registering user certificate (${payload.communityId}) on ${payload.serviceAddress}`)
-        this.emit(SocketActionTypes.REGISTER_USER_CERTIFICATE, payload)
+      socket.on(SocketActionTypes.SAVE_USER_CSR, async (payload: SaveCSRPayload) => {
+        this.logger(`SAVING user CSR ${payload.csr}`)
+        this.emit(SocketActionTypes.SAVE_USER_CSR, payload)
         await new Promise<void>(resolve => setTimeout(() => resolve(), 2000))
-        this.emit(SocketActionTypes.CONNECTION_PROCESS_INFO, ConnectionProcessInfo.REGISTERING_USER_CERTIFICATE)
+        this.emit(SocketActionTypes.CONNECTION_PROCESS_INFO, ConnectionProcessInfo.SAVING_USER_CSR)
       })
       socket.on(SocketActionTypes.REGISTER_OWNER_CERTIFICATE, async (payload: RegisterOwnerCertificatePayload) => {
         this.logger(`Registering owner certificate (${payload.communityId})`)
@@ -114,6 +116,13 @@ export class SocketService extends EventEmitter implements OnModuleInit {
       socket.on(SocketActionTypes.SAVE_OWNER_CERTIFICATE, async (payload: SaveOwnerCertificatePayload) => {
         this.logger(`Saving owner certificate (${payload.peerId}), community: ${payload.id}`)
         this.emit(SocketActionTypes.SAVED_OWNER_CERTIFICATE, payload)
+        const communityMetadataPayload: CommunityMetadata = {
+          id: payload.id,
+          ownerCertificate: payload.certificate,
+          rootCa: payload.permsData.certificate,
+        }
+        console.log('meta from state-manager', communityMetadataPayload)
+        this.emit(SocketActionTypes.SEND_COMMUNITY_METADATA, communityMetadataPayload)
       })
       socket.on(SocketActionTypes.CREATE_COMMUNITY, async (payload: InitCommunityPayload) => {
         this.logger(`Creating community ${payload.id}`)