parseEntityDetails function

Future<EntityDetails> parseEntityDetails(List<StateEntityDetailsResponseItem> entities, StateApi state)

Implementation

Future<EntityDetails> parseEntityDetails(
    List<StateEntityDetailsResponseItem> entities, StateApi state) async {
  Future<Map<String, String>> getLogicComponents() async {
    final logicVersionStore = entities.firstWhere((s) {
      return s.details?.type ==
              StateEntityDetailsResponseItemDetailsType.component &&
          (s.details as StateEntityDetailsResponseComponentDetails)
                  .blueprintName ==
              'RNSUpdatable';
    }).details as StateEntityDetailsResponseComponentDetails?;

    final componentVersionsField =
        logicVersionStore?.state?.asMap['fields'].firstWhere(
      (f) => f['field_name'] == 'component_versions',
    );

    final versionStoreIds = (await state.keyValueStoreData(
            stateKeyValueStoreDataRequest:
                StateKeyValueStoreDataRequest((builder) {
      builder.keyValueStoreAddress = componentVersionsField['value'];
      builder.keys.addAll([
        StateKeyValueStoreDataRequestKeyItem((builder) {
          builder.keyJson = ProgrammaticScryptoSborValueString((b) {
            b.kind = ProgrammaticScryptoSborValueKind.string;
            b.value = 'rns_logic';
          });
        }),
        StateKeyValueStoreDataRequestKeyItem((builder) {
          builder.keyJson = ProgrammaticScryptoSborValueString((b) {
            b.kind = ProgrammaticScryptoSborValueKind.string;
            b.value = 'rns_auction_logic';
          });
        }),
      ]);
    })))
        .data;

    final versionManagers = versionStoreIds?.entries.map((kv) {
      return (kv.value.programmaticJson as ProgrammaticScryptoSborValueTuple)
          .fields
          .fold<Map<String, dynamic>>(
        {},
        (acc, field) {
          if (isValueType(field)) {
            switch (field.kind) {
              case ProgrammaticScryptoSborValueKind.string:
                acc[field.fieldName!] =
                    (field as ProgrammaticScryptoSborValueString).value;
                break;
              case ProgrammaticScryptoSborValueKind.u128:
                acc[field.fieldName!] =
                    (field as ProgrammaticScryptoSborValueU128).value;
                break;
              case ProgrammaticScryptoSborValueKind.u64:
                acc[field.fieldName!] =
                    (field as ProgrammaticScryptoSborValueU64).value;
                break;
              case ProgrammaticScryptoSborValueKind.u32:
                acc[field.fieldName!] =
                    (field as ProgrammaticScryptoSborValueU32).value;
                break;
              case ProgrammaticScryptoSborValueKind.u16:
                acc[field.fieldName!] =
                    (field as ProgrammaticScryptoSborValueU16).value;
                break;
              case ProgrammaticScryptoSborValueKind.u8:
                acc[field.fieldName!] =
                    (field as ProgrammaticScryptoSborValueU8).value;
                break;
              case ProgrammaticScryptoSborValueKind.i128:
                acc[field.fieldName!] =
                    (field as ProgrammaticScryptoSborValueI128).value;
                break;
              case ProgrammaticScryptoSborValueKind.i64:
                acc[field.fieldName!] =
                    (field as ProgrammaticScryptoSborValueI64).value;
                break;
              case ProgrammaticScryptoSborValueKind.i32:
                acc[field.fieldName!] =
                    (field as ProgrammaticScryptoSborValueI32).value;
                break;
              case ProgrammaticScryptoSborValueKind.i16:
                acc[field.fieldName!] =
                    (field as ProgrammaticScryptoSborValueI16).value;
                break;
              case ProgrammaticScryptoSborValueKind.i8:
                acc[field.fieldName!] =
                    (field as ProgrammaticScryptoSborValueI8).value;
                break;
              case ProgrammaticScryptoSborValueKind.bool_:
                acc[field.fieldName!] =
                    (field as ProgrammaticScryptoSborValueBool).value;
                break;
              case ProgrammaticScryptoSborValueKind.own:
                final typedField = (field as ProgrammaticScryptoSborValueOwn);
                acc[typedField.fieldName!] = typedField.value;
                break;
              case ProgrammaticScryptoSborValueKind.reference:
                final typedField =
                    (field as ProgrammaticScryptoSborValueReference);
                acc[typedField.fieldName!] = typedField.value;
                break;
              default:
                break;
            }
          }
          return acc;
        },
      );
    }).toList();

    final logicComponents = await Future.wait(versionManagers?.map((v) async {
          final kv = await state.keyValueStoreData(
              stateKeyValueStoreDataRequest:
                  StateKeyValueStoreDataRequest((builder) {
            builder.keyValueStoreAddress = v['versions'];
            builder.keys.add(
              StateKeyValueStoreDataRequestKeyItem((builder) {
                builder.keyJson = ProgrammaticScryptoSborValueU64((b) {
                  b.kind = ProgrammaticScryptoSborValueKind.u64;
                  b.value = v['current_version'];
                });
              }),
            );
          }));
          return (kv.data?.entries[0].value.programmaticJson
                  as ProgrammaticScryptoSborValueReference)
              .value;
        }) ??
        []);

    return {
      'radixNameServiceComponent': logicComponents[0] as String,
      'rnsAuctionComponent': logicComponents[1] as String,
    };
  }

  final logicComponents = await getLogicComponents();

  final addresses = entities.fold<Map<String, dynamic>>({}, (acc, entity) {
    if (entity.details?.type ==
        StateEntityDetailsResponseItemDetailsType.component) {
      final stateFields =
          (entity.details as StateEntityDetailsResponseComponentDetails)
              .state!
              .asMap['fields'];

      final biddersVaultId = (stateFields.firstWhere(
          (f) => f['field_name'] == 'bidders_vault',
          orElse: () => {'value': null}))['value'];
      final settlementVaultId = stateFields.firstWhere(
          (f) => f['field_name'] == 'domain_settlement_periods',
          orElse: () => {'value': null})['value'];
      final subdomainVaults = stateFields.firstWhere(
          (f) => f['field_name'] == 'subdomain_vaults',
          orElse: () => {'value': null})['value'];
      final recordServiceVaultId = stateFields.firstWhere(
          (f) => f['field_name'] == 'record_vaults',
          orElse: () => {'value': null})['value'];
      final latestAuctionId = stateFields.firstWhere(
          (f) => f['field_name'] == 'auction_id',
          orElse: () => {'value': null})['value'];
      final latestBidId = stateFields.firstWhere(
          (f) => f['field_name'] == 'bid_id',
          orElse: () => {'value': null})['value'];
      final priceMap = parsePricingTiers(stateFields.firstWhere(
          (f) => f['field_name'] == 'price_mapping',
          orElse: () => null));

      final minimumPremium = stateFields.firstWhere(
          (f) => f['field_name'] == 'minimum_premium',
          orElse: () => {'value': null})['value'];
      final domainEventClaimsKvId = stateFields.firstWhere(
          (f) => f['field_name'] == 'domain_event_claims',
          orElse: () => {'value': null})['value'];
      final domainTldKvId = stateFields.firstWhere(
          (f) => f['field_name'] == 'domain_mintable',
          orElse: () => {'value': null})['value'];

      final name = nameMappings[
          (entity.details as StateEntityDetailsResponseComponentDetails)
              .blueprintName];

      acc.addAll({
        name ??
            ((entity.details as StateEntityDetailsResponseComponentDetails)
                .blueprintName): entity.address,
        if (subdomainVaults != null) 'subdomainVaults': subdomainVaults,
        if (biddersVaultId != null) 'biddersVaultId': biddersVaultId,
        if (settlementVaultId != null) 'settlementVaultId': settlementVaultId,
        if (recordServiceVaultId != null)
          'recordServiceVaultId': recordServiceVaultId,
        if (latestAuctionId != null) 'latestAuctionId': latestAuctionId,
        if (latestBidId != null) 'latestBidId': latestBidId,
        if (priceMap != null) 'priceMap': priceMap,
        if (minimumPremium != null) 'minimumPremium': minimumPremium,
        if (domainEventClaimsKvId != null)
          'domainEventClaimsKvId': domainEventClaimsKvId,
        if (domainTldKvId != null) 'domainTldKvId': domainTldKvId,
      });
    } else if (entity.details?.type ==
            StateEntityDetailsResponseItemDetailsType.fungibleResource ||
        entity.details?.type ==
            StateEntityDetailsResponseItemDetailsType.nonFungibleResource) {
      final items = entity.explicitMetadata?.items;

      if (items != null && items.isNotEmpty) {
        final resourceValue =
            (items[0].value.typed as MetadataStringValue).value;

        if (nameMappings[resourceValue] != null) {
          acc[nameMappings[resourceValue]!] = entity.address;
        }
      }
    }

    return acc;
  });

  return EntityDetails.fromMap({...logicComponents, ...addresses});
}