generateNamespaces static method

Map<String, Namespace> generateNamespaces({ required Set<String> availableAccounts, required Set<String> availableMethods, required Set<String> availableEvents, required Map<String, RequiredNamespace> requiredNamespaces, Map<String, RequiredNamespace>? optionalNamespaces, })

Using the availabe accounts, methods, and events, construct the namespaces If optional namespaces are provided, then they will be added to the namespaces as well

Implementation

static Map<String, Namespace> generateNamespaces({
  required Set<String> availableAccounts,
  required Set<String> availableMethods,
  required Set<String> availableEvents,
  required Map<String, RequiredNamespace> requiredNamespaces,
  Map<String, RequiredNamespace>? optionalNamespaces,
}) {
  final Map<String, Namespace> requiredNS = _constructNamespaces(
    availableAccounts: availableAccounts,
    availableMethods: availableMethods,
    availableEvents: availableEvents,
    namespacesMap: requiredNamespaces,
  );
  final Map<String, Namespace> optionalNS = _constructNamespaces(
    availableAccounts: availableAccounts,
    availableMethods: availableMethods,
    availableEvents: availableEvents,
    namespacesMap: optionalNamespaces ?? {},
  );

  // Merge requiredNS and optionalNS, avoiding duplicates
  final Map<String, Namespace> merged = Map.from(requiredNS);

  for (final entry in optionalNS.entries) {
    final key = entry.key;
    final optionalNamespace = entry.value;

    if (merged.containsKey(key)) {
      // Key exists in both, merge the values
      final existingNamespace = merged[key]!;

      // Merge chains (remove duplicates)
      final mergedChains = <String>{};
      if (existingNamespace.chains != null) {
        mergedChains.addAll(existingNamespace.chains!);
      }
      if (optionalNamespace.chains != null) {
        mergedChains.addAll(optionalNamespace.chains!);
      }
      final finalChains =
          mergedChains.isNotEmpty ? mergedChains.toList() : null;

      // Merge accounts (remove duplicates)
      final mergedAccounts = <String>{};
      mergedAccounts.addAll(existingNamespace.accounts);
      mergedAccounts.addAll(optionalNamespace.accounts);

      // Merge methods (remove duplicates)
      final mergedMethods = <String>{};
      mergedMethods.addAll(existingNamespace.methods);
      mergedMethods.addAll(optionalNamespace.methods);

      // Merge events (remove duplicates)
      final mergedEvents = <String>{};
      mergedEvents.addAll(existingNamespace.events);
      mergedEvents.addAll(optionalNamespace.events);

      // Only include if accounts list is not empty
      if (mergedAccounts.isNotEmpty) {
        merged[key] = Namespace(
          chains: finalChains,
          accounts: mergedAccounts.toList(),
          methods: mergedMethods.toList(),
          events: mergedEvents.toList(),
        );
      } else {
        // Remove the key if accounts list is empty
        merged.remove(key);
      }
    } else {
      // Key only exists in optional, add it to merged only if accounts list is not empty
      if (optionalNamespace.accounts.isNotEmpty) {
        merged[key] = optionalNamespace;
      }
    }
  }

  return regenerateNamespacesWithChains(merged);
}