read method

Future<List<AEMessage>> read({ required ApiService apiService, required String discussionSCAddress, required KeyPair readerKeyPair, int limit = 0, int pagingOffset = 0, })

Implementation

Future<List<AEMessage>> read({
  required ApiService apiService,
  required String discussionSCAddress,
  required KeyPair readerKeyPair,
  int limit = 0,
  int pagingOffset = 0,
}) async {
  final messagesList = await apiService.getTransactionInputs(
    [discussionSCAddress],
    limit: limit,
    pagingOffset: pagingOffset,
  );
  final txContentMessagesList =
      messagesList[discussionSCAddress] ?? <TransactionInput>[];
  final txContentMessagesAddresses = txContentMessagesList
      .where(
        (txContentMessage) =>
            txContentMessage.from != null && txContentMessage.type == 'call',
      )
      .map((txContentMessage) => txContentMessage.from)
      .whereType<String>()
      .toList();

  final aeMessages = <AEMessage>[];
  final contents = await apiService.getTransaction(
    txContentMessagesAddresses,
    request:
        ' address, chainLength, data { content }, previousPublicKey, validationStamp { timestamp } ',
  );

  if (contents.isEmpty) return [];

  final discussionKeyAccess = uint8ListToHex(
    await DiscussionUtil().getDiscussionKeyAccess(
      apiService: apiService,
      discussionSCAddress: discussionSCAddress,
      keyPair: readerKeyPair,
    ),
  );

  for (final contentMessageAddress in txContentMessagesAddresses) {
    final contentMessageTransaction = contents[contentMessageAddress];
    if (contentMessageTransaction == null) continue;

    final transactionContentIM = TransactionContentMessaging.fromJson(
      jsonDecode(contentMessageTransaction.data!.content!),
    );
    final message = utf8.decode(
      _decodeMessage(
        transactionContentIM.message,
        discussionKeyAccess,
        compressionAlgo: transactionContentIM.compressionAlgo,
      ),
    );

    final senderGenesisPublicKeyMap = await apiService.getTransactionChain(
      {contentMessageTransaction.address!.address!: ''},
      request: 'previousPublicKey',
    );
    var senderGenesisPublicKey = '';
    if (senderGenesisPublicKeyMap.isNotEmpty &&
        senderGenesisPublicKeyMap[
                contentMessageTransaction.address!.address!] !=
            null &&
        senderGenesisPublicKeyMap[
                contentMessageTransaction.address!.address!]!
            .isNotEmpty) {
      senderGenesisPublicKey = senderGenesisPublicKeyMap[
                  contentMessageTransaction.address!.address!]?[0]
              .previousPublicKey ??
          '';
    }

    final aeMEssage = AEMessage(
      senderGenesisPublicKey: senderGenesisPublicKey,
      address: contentMessageTransaction.address!.address!,
      sender: contentMessageTransaction.previousPublicKey!,
      timestampCreation:
          contentMessageTransaction.validationStamp!.timestamp!,
      content: message,
    );

    aeMessages.add(
      aeMEssage,
    );
  }

  return aeMessages;
}