Handle multiple invitation addresses

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

@@ -12,6 +12,7 @@ import { TestConfig } from '../const'
 import logger from './logger'
 import { createCertificatesTestHelper } from './client-server'
 import { Libp2pNodeParams } from '../libp2p/libp2p.types'
+import { createLibp2pAddress, createLibp2pListenAddress } from '@quiet/common'
 const log = logger('test')
 
 export interface Ports {
@@ -143,14 +144,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

@@ -174,9 +174,6 @@ export class ConnectionsManagerService extends EventEmitter implements OnModuleI
     if (community) {
       await this.launchCommunity(community)
     }
-    if (registrarData) {
-      await this.registrationService.launchRegistrar(registrarData)
-    }
   }
 
   public async closeAllServices(options: { saveTor: boolean } = { saveTor: false }) {
@@ -282,12 +279,14 @@ export class ConnectionsManagerService extends EventEmitter implements OnModuleI
   }
 
   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) {
@@ -336,6 +335,7 @@ export class ConnectionsManagerService extends EventEmitter implements OnModuleI
     const _peerId = await peerIdFromKeys(restoredRsa.marshalPubKey(), restoredRsa.marshalPrivKey())
 
     let peers = payload.peers
+    console.log('LAUNCH COMMUNITY PAYLOAD PEERS', peers)
     if (!peers || peers.length === 0) {
       peers = [this.libp2pService.createLibp2pAddress(onionAddress, _peerId.toString())]
     }
@@ -344,9 +344,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,
@@ -387,6 +384,7 @@ export class ConnectionsManagerService extends EventEmitter implements OnModuleI
     })
 
     this.registrationService.on(SocketActionTypes.CONNECTION_PROCESS_INFO, data => {
+      console.log('CONNECTION_PROCESS_INFO', data)
       this.serverIoProvider.io.emit(SocketActionTypes.CONNECTION_PROCESS_INFO, data)
     })
   }
@@ -395,24 +393,27 @@ export class ConnectionsManagerService extends EventEmitter implements OnModuleI
       this.registrarState = payload
     })
     this.registrationService.on(SocketActionTypes.SAVED_OWNER_CERTIFICATE, payload => {
+      console.log('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.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)
-    })
+    // this.registrationService.on(SocketActionTypes.SEND_USER_CERTIFICATE, payload => {
+    //   console.log('SEND_USER_CERTIFICATE', payload)
+    //   this.serverIoProvider.io.emit(SocketActionTypes.SEND_USER_CERTIFICATE, payload)
+    // })
+    // this.registrationService.on(RegistrationEvents.NEW_USER, async payload => {
+    //   console.log('NEW_USER', payload)
+    //   await this.storageService?.saveCertificate(payload)
+    // })
   }
   private attachsocketServiceListeners() {
     // Community
@@ -434,9 +435,11 @@ export class ConnectionsManagerService extends EventEmitter implements OnModuleI
       }
     })
     this.socketService.on(SocketActionTypes.CREATE_NETWORK, async (args: Community) => {
+      console.log('SocketActionTypes.CREATE_NETWORK')
       await this.createNetwork(args)
     })
     this.socketService.on(SocketActionTypes.CREATE_COMMUNITY, async (args: InitCommunityPayload) => {
+      console.log('SocketActionTypes.CREATE_COMMUNITY')
       await this.createCommunity(args)
     })
     this.socketService.on(SocketActionTypes.LAUNCH_COMMUNITY, async (args: InitCommunityPayload) => {
@@ -446,37 +449,56 @@ export class ConnectionsManagerService extends EventEmitter implements OnModuleI
       await this.launchCommunity(args)
     })
     // Registration
-    this.socketService.on(SocketActionTypes.LAUNCH_REGISTRAR, async (args: LaunchRegistrarPayload) => {
-      this.logger(`socketService - ${SocketActionTypes.LAUNCH_REGISTRAR}`)
-
-      const communityData = await this.localDbService.get(LocalDBKeys.REGISTRAR)
-      if (!communityData) {
-        await this.localDbService.put(LocalDBKeys.REGISTRAR, args)
-      }
-      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.LAUNCH_REGISTRAR, async (args: LaunchRegistrarPayload) => {
+    //   this.logger(`socketService - ${SocketActionTypes.LAUNCH_REGISTRAR}`)
+
+    //   const communityData = await this.localDbService.get(LocalDBKeys.REGISTRAR)
+    //   if (!communityData) {
+    //     await this.localDbService.put(LocalDBKeys.REGISTRAR, args)
+    //   }
+    //   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.SAVED_OWNER_CERTIFICATE, async (args: SaveOwnerCertificatePayload) => {
+      console.log('SAVED_OWNER_CERTIFICATE')
       const saveCertificatePayload: SaveCertificatePayload = {
         certificate: args.certificate,
         rootPermsData: args.permsData,
       }
       await this.storageService?.saveCertificate(saveCertificatePayload)
     })
     this.socketService.on(SocketActionTypes.REGISTER_USER_CERTIFICATE, async (args: RegisterUserCertificatePayload) => {
+      console.log('!!!! REGISTER_USER_CERTIFICATE')
       // if (!this.socksProxyAgent) {
       //   this.createAgent()
       // }
 
-      await this.registrationService.sendCertificateRegistrationRequest(
-        args.serviceAddress,
-        args.userCsr,
-        args.communityId,
-        120_000,
-        this.socksProxyAgent
-      )
+      // await this.registrationService.sendCertificateRegistrationRequest(
+      //   args.serviceAddress,
+      //   args.userCsr,
+      //   args.communityId,
+      //   120_000,
+      //   this.socksProxyAgent
+      // )
+      // const response = await this.registrationService.registerUser(args.userCsr)
+      this.emit(SocketActionTypes.CONNECTION_PROCESS_INFO, ConnectionProcessInfo.CONNECTING_TO_COMMUNITY)
+      console.log('emitting SocketActionTypes.SEND_USER_CERTIFICATE')
+      this.serverIoProvider.io.emit(SocketActionTypes.SEND_USER_CERTIFICATE, {
+        // TEMPORARY
+        communityId: args.communityId,
+        payload: {
+          peers: [],
+        },
+      })
+      // this.emit(SocketActionTypes.SEND_USER_CERTIFICATE, {
+      //   // TEMPORARY
+      //   communityId: args.communityId,
+      //   payload: {
+      //     peers: [],
+      //   },
+      // })
     })
     this.socketService.on(
       SocketActionTypes.REGISTER_OWNER_CERTIFICATE,

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 {
@@ -45,6 +45,7 @@ export class Libp2pService extends EventEmitter {
   }
 
   public async createInstance(params: Libp2pNodeParams): Promise<any> {
+    console.log('Libp2p.createInstance::: peers:::', params.peers)
     if (this.libp2pInstance) {
       return this.libp2pInstance
     }

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.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,6 +40,7 @@ export class RegistrationService extends EventEmitter implements OnModuleInit {
 
   onModuleInit() {
     this.on(RegistrationEvents.SET_CERTIFICATES, certs => {
+      console.log('SET CERTIFICATES', certs)
       this.setCertificates(certs)
     })
     this.setRouting()
@@ -123,7 +124,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/socket/socket.service.ts

@@ -101,7 +101,7 @@ export class SocketService extends EventEmitter implements OnModuleInit {
       })
 
       socket.on(SocketActionTypes.REGISTER_USER_CERTIFICATE, async (payload: RegisterUserCertificatePayload) => {
-        this.logger(`Registering user certificate (${payload.communityId}) on ${payload.serviceAddress}`)
+        this.logger(`Registering user CSR (${payload.communityId}) on ${payload.serviceAddress}`)
         this.emit(SocketActionTypes.REGISTER_USER_CERTIFICATE, payload)
         await new Promise<void>(resolve => setTimeout(() => resolve(), 2000))
         this.emit(SocketActionTypes.CONNECTION_PROCESS_INFO, ConnectionProcessInfo.REGISTERING_USER_CERTIFICATE)
@@ -124,10 +124,10 @@ export class SocketService extends EventEmitter implements OnModuleInit {
         this.emit(SocketActionTypes.LAUNCH_COMMUNITY, payload)
         this.emit(SocketActionTypes.CONNECTION_PROCESS_INFO, ConnectionProcessInfo.LAUNCHING_COMMUNITY)
       })
-      socket.on(SocketActionTypes.LAUNCH_REGISTRAR, async (payload: LaunchRegistrarPayload) => {
-        this.logger(`Launching registrar for community ${payload.id}, user ${payload.peerId}`)
-        this.emit(SocketActionTypes.LAUNCH_REGISTRAR, payload)
-      })
+      // socket.on(SocketActionTypes.LAUNCH_REGISTRAR, async (payload: LaunchRegistrarPayload) => {
+      //   this.logger(`Launching registrar for community ${payload.id}, user ${payload.peerId}`)
+      //   this.emit(SocketActionTypes.LAUNCH_REGISTRAR, payload)
+      // })
       socket.on(SocketActionTypes.CREATE_NETWORK, async (community: Community) => {
         this.logger(`Creating network for community ${community.id}`)
         this.emit(SocketActionTypes.CREATE_NETWORK, community)

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

@@ -172,7 +172,7 @@ export class StorageService extends EventEmitter {
       return
     }
     for (const a of addr) {
-      this.logger(`Pubsub - subscribe to ${addr}`)
+      this.logger(`Pubsub - subscribe to ${a}`)
       // @ts-ignore
       await this.orbitDb._pubsub.subscribe(
         a,

packages/backend/src/nest/tor/tor-control.service.ts

@@ -52,7 +52,7 @@ export class TorControl implements OnModuleInit {
     })
   }
 
-  private async disconnect() {
+  private disconnect() {
     try {
       this.connection?.end()
     } catch (e) {
@@ -63,12 +63,19 @@ export class TorControl implements OnModuleInit {
 
   // eslint-disable-next-line @typescript-eslint/ban-types
   private async _sendCommand(command: string, resolve: Function, reject: Function) {
-    await this.connect()
+    try {
+      await this.connect()
+    } catch (e) {
+      console.error(`ERROR for ${command}`, e)
+      this.disconnect()
+      await this.connect()
+    }
+
     const connectionTimeout = setTimeout(() => {
       reject('TOR: Send command timeout')
     }, 5000)
     this.connection?.on('data', async data => {
-      await this.disconnect()
+      this.disconnect()
       const dataArray = data.toString().split(/\r?\n/)
       if (dataArray[0].startsWith('250')) {
         resolve({ code: 250, messages: dataArray })

packages/backend/src/nest/websocketOverTor/websocketOverTor.tor.spec.ts

@@ -4,13 +4,7 @@ import { multiaddr } from '@multiformats/multiaddr'
 import getPort from 'get-port'
 import { type DirResult } from 'tmp'
 import { jest, describe, it, expect, afterEach, beforeAll, afterAll } from '@jest/globals'
-import {
-  createLibp2pAddress,
-  torBinForPlatform,
-  torDirForPlatform,
-  createTmpDir,
-  tmpQuietDirPath,
-} from '../common/utils'
+import { torBinForPlatform, torDirForPlatform, createTmpDir, tmpQuietDirPath } from '../common/utils'
 import { type CreateListenerOptions } from '@libp2p/interface-transport'
 import { createServer } from 'it-ws/server'
 import { createCertificatesTestHelper } from '../common/client-server'
@@ -22,6 +16,7 @@ import { Tor } from '../tor/tor.service'
 import crypto from 'crypto'
 import { TorControl } from '../tor/tor-control.service'
 import { TorControlAuthType } from '../tor/tor.types'
+import { createLibp2pAddress } from '@quiet/common'
 jest.setTimeout(120000)
 
 describe('websocketOverTor', () => {