polygon_id_sdk.dart

import 'dart:convert';

import 'package:flutter/widgets.dart';
import 'package:hive_flutter/hive_flutter.dart';
import 'package:polygonid_flutter_sdk/common/domain/domain_logger.dart';
import 'package:polygonid_flutter_sdk/common/domain/entities/chain_config_entity.dart';
import 'package:polygonid_flutter_sdk/common/domain/entities/env_entity.dart';
import 'package:polygonid_flutter_sdk/common/domain/repositories/config_repository.dart';
import 'package:polygonid_flutter_sdk/common/domain/use_cases/get_env_use_case.dart';
import 'package:polygonid_flutter_sdk/common/domain/use_cases/get_selected_chain_use_case.dart';
import 'package:polygonid_flutter_sdk/common/domain/use_cases/set_env_use_case.dart';
import 'package:polygonid_flutter_sdk/common/domain/use_cases/set_selected_chain_use_case.dart';
import 'package:polygonid_flutter_sdk/common/kms/kms.dart';
import 'package:polygonid_flutter_sdk/sdk/circuits.dart';
import 'package:polygonid_flutter_sdk/sdk/di/injector.dart';
import 'package:polygonid_flutter_sdk/sdk/error_handling.dart';
import 'package:polygonid_flutter_sdk/sdk/polygonid_flutter_channel.dart';

import 'credential.dart';
import 'iden3comm.dart';
import 'identity.dart';
import 'proof.dart';

class PolygonIsSdkNotInitializedException implements Exception {
  String message;

  PolygonIsSdkNotInitializedException(this.message);
}

class PolygonIdSdk {
  static PolygonIdSdk? _ref;

  static PolygonIdSdk get I {
    if (_ref == null) {
      throw PolygonIsSdkNotInitializedException(
          "The PolygonID SDK has not been initialized,"
          "please call and await PolygonIdSDK.init()");
    }

    return _ref!;
  }

  /// Initializes the PolygonId SDK
  /// Pass [env] to set the environment that contains pushUrl, ipfsUrl, chainConfigs, didMethods
  /// Set [newIdentity] param to use a new identity creation and private key handling mechanisms
  static Future<void> init({
    EnvEntity? env,
    required bool newIdentity,
  }) async {
    // As [PolygonIdSdk] uses path_provider plugin, we need to ensure the
    // platform is initialized
    WidgetsFlutterBinding.ensureInitialized();

    String? stacktraceEncryptionKey = env?.stacktraceEncryptionKey;
    if (stacktraceEncryptionKey != null &&
        stacktraceEncryptionKey.isNotEmpty &&
        utf8.encode(stacktraceEncryptionKey).length == 32) {
      await Hive.initFlutter();
      await Hive.openBox(
        'stacktrace',
        encryptionCipher: HiveAesCipher(utf8.encode(stacktraceEncryptionKey)),
      );
    }

    // Init injection
    await configureInjection(newIdentity);
    await getItSdk.allReady();

    // Set env
    if (env != null) {
      await getItSdk.get<SetEnvUseCase>().execute(param: env);
    }
    if (env?.chainConfigs.entries.isNotEmpty ?? false) {
      await getItSdk
          .get<SetSelectedChainUseCase>()
          .execute(param: env!.chainConfigs.keys.first);
    }

    // SDK singleton
    _ref = PolygonIdSdk._();
    _ref!.identity = getItSdk.get<Identity>();
    _ref!.credential = await getItSdk.getAsync<Credential>();
    _ref!.proof = await getItSdk.getAsync<Proof>();
    _ref!.iden3comm = await getItSdk.getAsync<Iden3comm>();
    _ref!.errorHandling = getItSdk.get<ErrorHandling>();
    _ref!.kms = getItSdk.get<KMS>();
    _ref!.circuits = await getItSdk.getAsync<Circuits>();

    // Channel
    getItSdk<PolygonIdFlutterChannel>();

    // Logging
    Domain.logger = getItSdk<PolygonIdSdkLogger>();
  }

  late Identity identity;
  late Credential credential;
  late Proof proof;
  late Iden3comm iden3comm;
  late ErrorHandling errorHandling;
  late KMS kms;
  late Circuits circuits;

  PolygonIdSdk._();

  /// Set the environment for the SDK to operate
  Future<void> setEnv({required EnvEntity env}) {
    return getItSdk.get<SetEnvUseCase>().execute(param: env);
  }

  /// Get the current set environment for the SDK
  Future<EnvEntity> getEnv() {
    return getItSdk.get<GetEnvUseCase>().execute();
  }

  /// Get the current selected chain configuration
  Future<ChainConfigEntity> getSelectedChain() {
    return getItSdk.get<GetSelectedChainUseCase>().execute();
  }

  /// Get the current selected chain id
  Future<String?> getSelectedChainId() {
    return getItSdk.get<ConfigRepository>().getSelectedChainId();
  }

  /// Set the selected chain configuration by its id
  Future<void> setSelectedChain({required String chainConfigId}) {
    return getItSdk
        .get<SetSelectedChainUseCase>()
        .execute(param: chainConfigId);
  }

  /// Switch the log on or off
  Future<void> switchLog({required bool enabled}) async {
    Domain.logEnabled = enabled;
  }
}