init method

@override Future<void> init()

/////* PUBLIC METHODS */////////

Implementation

@override
Future<void> init() async {
  _relayConnected = false;
  _awaitRelayOnce = Completer<bool>();

  if (!_isValidProjectID()) {
    return;
  }
  if (!_hasValidNamespaces()) {
    return;
  }
  if (_status == ReownAppKitModalStatus.initializing ||
      _status == ReownAppKitModalStatus.initialized) {
    return;
  }

  _status = ReownAppKitModalStatus.initializing;
  _notify();

  _registerListeners();

  await _appKit.init();
  await _networkService.init();
  await _explorerService.init();
  await _coinbaseService.init();
  await _phantomService.init();
  await _solflareService.init();
  await _blockchainService.init();
  await _analyticsService.init();

  _analyticsService.sendEvent(ModalLoadedEvent());

  _currentSession = await _getStoredSession();
  _selectedChainID = _getStoredChainId();
  final isMagic = _currentSession?.sessionService.isMagic == true;
  final isCoinbase = _currentSession?.sessionService.isCoinbase == true;
  final isPhantom = _currentSession?.sessionService.isPhantom == true;
  final isSolflare = _currentSession?.sessionService.isSolflare == true;
  if (isMagic || isCoinbase || isPhantom || isSolflare) {
    _selectedChainID ??= _currentSession!.chainId;
    await _setSesionAndChainData(_currentSession!);
    if (isMagic) {
      await _magicService.init(chainId: _selectedChainID);
    }
  } else {
    _magicService.init();
  }

  await expirePreviousInactivePairings();

  final wcPairings = _appKit.pairings.getAll();
  final wcSessions = _appKit.sessions.getAll();

  // Loop through all the chain data
  final allNetworks = ReownAppKitModalNetworks.getAllSupportedNetworks();
  for (final chain in allNetworks) {
    final namespace = NamespaceUtils.getNamespaceFromChain(chain.chainId);
    final events = _sessionNamespaces[namespace]?.events ?? [];
    for (final event in events) {
      _appKit.registerEventHandler(chainId: chain.chainId, event: event);
    }
    _appKit.registerEventHandler(
      chainId: chain.chainId,
      event: 'reown_updateEmail',
    );
  }

  // There's a WC/Relay session stored
  if (wcSessions.isNotEmpty) {
    await _storeSession(
      ReownAppKitModalSession(sessionData: wcSessions.first),
    );
    // session should not outlive the pairing
    if (wcPairings.isEmpty) {
      await disconnect();
    } else {
      await _checkSIWEStatus();
    }
  } else {
    // Check for other type of sessions stored
    if (_currentSession != null) {
      if (_currentSession!.sessionService.isCoinbase) {
        final isConnected = await _coinbaseService.isConnected();
        if (!isConnected) {
          await _cleanSession();
        }
      } else if (_currentSession!.sessionService.isPhantom) {
        final isConnected = await _phantomService.isConnected();
        if (!isConnected) {
          await _cleanSession();
        }
      } else if (_currentSession!.sessionService.isSolflare) {
        final isConnected = await _solflareService.isConnected();
        if (!isConnected) {
          await _cleanSession();
        }
      } else {
        await _cleanSession();
      }
    }
  }

  // Get the chainId of the chain we are connected to.
  await _selectChainFromStoredId();

  onModalNetworkChange.subscribe(_onNetworkChainRequireSIWE);

  _relayConnected = _appKit.core.relayClient.isConnected;
  if (!_relayConnected && _isOnline) {
    _relayConnected = await _awaitRelayOnce.future;
  } else {
    if (!_awaitRelayOnce.isCompleted) {
      _awaitRelayOnce.complete(_relayConnected);
    }
  }
  _status = _relayConnected
      ? ReownAppKitModalStatus.initialized
      : ReownAppKitModalStatus.initializing;
  _appKit.core.logger.i(
    '[$runtimeType] status $_status with session ${jsonEncode(_currentSession?.toJson())}',
  );
  if (!_isOnline) {
    // We enable buttons anyway in case we want to use LM
    _status = ReownAppKitModalStatus.initialized;
  }
  _notify();

  if (_currentSession != null) {
    onModalConnect.broadcast(ModalConnect(_currentSession!));
  }
}