getAddressTxsResponse method

Future<BcnTransactionsResponse> getAddressTxsResponse(String address, int count)

Implementation

Future<BcnTransactionsResponse> getAddressTxsResponse(
    String address, int count) async {
  Completer<BcnTransactionsResponse> _completer =
      new Completer<BcnTransactionsResponse>();

  Map<String, dynamic> mapParams;
  BcnTransactionsRequest bcnTransactionsRequest;
  BcnTransactionsResponse bcnTransactionsResponse;

  if (this.nodeType == DEMO_NODE) {
    bcnTransactionsResponse = new BcnTransactionsResponse();
    bcnTransactionsResponse.result = new BcnTransactionsResponseResult();
  } else {
    mapParams = {
      'method': BcnTransactionsRequest.METHOD_NAME,
      "params": [
        {"address": address, "count": count}
      ],
      'id': 101,
      'key': this.keyApp
    };

    try {
      if (this.nodeType == NORMAL_VPS_NODE) {
        SSHClientStatus sshClientStatus;
        sshClientStatus = await VpsUtil().connectVps(this.apiUrl, keyApp);
        if (sshClientStatus.sshClientStatus) {
          sshClient = sshClientStatus.sshClient;
        }
        var response = await ssh.HttpClientImpl(
            clientFactory: () =>
                ssh.SSHTunneledBaseClient(sshClientStatus.sshClient)).request(
            this.apiUrl,
            method: 'POST',
            data: jsonEncode(mapParams),
            headers: requestHeaders);
        if (response.status == 200) {
          bcnTransactionsResponse =
              bcnTransactionsResponseFromJson(response.text);
        }
      } else {
        bcnTransactionsRequest = BcnTransactionsRequest.fromJson(mapParams);
        String body = json.encode(bcnTransactionsRequest.toJson());
        http.Response responseHttp = await http.post(Uri.parse(this.apiUrl),
            body: body, headers: requestHeaders);
        if (responseHttp.statusCode == 200) {
          bcnTransactionsResponse =
              bcnTransactionsResponseFromJson(responseHttp.body);
        }
      }

      List<Transaction> listTxsMempool =
          List<Transaction>.empty(growable: true);
      BcnMempoolResponse bcnMempoolResponse = await getMemPool(address);
      if (bcnMempoolResponse != null && bcnMempoolResponse.result != null) {
        List<String> hashList = bcnMempoolResponse.result;
        if (hashList != null) {
          for (int i = 0; i < hashList.length; i++) {
            BcnTransactionResponse bcnTransactionResponse =
                await getTransaction(hashList[i], address);
            if (bcnTransactionResponse != null &&
                bcnTransactionResponse.result != null) {
              Transaction transaction = new Transaction();
              transaction.amount = bcnTransactionResponse.result.amount;
              transaction.blockHash = bcnTransactionResponse.result.blockHash;
              transaction.epoch = bcnTransactionResponse.result.epoch;
              transaction.from = bcnTransactionResponse.result.from;
              transaction.hash = bcnTransactionResponse.result.hash;
              transaction.maxFee = bcnTransactionResponse.result.maxFee;
              transaction.nonce = bcnTransactionResponse.result.nonce;
              transaction.payload = bcnTransactionResponse.result.payload;
              transaction.timestamp = bcnTransactionResponse.result.timestamp;
              transaction.tips = bcnTransactionResponse.result.tips;
              transaction.to = bcnTransactionResponse.result.to;
              transaction.type = bcnTransactionResponse.result.type;
              transaction.usedFee = bcnTransactionResponse.result.usedFee;
              listTxsMempool.add(transaction);
            }
          }
        }
      }

      if (bcnTransactionsResponse != null &&
          bcnTransactionsResponse.result != null &&
          bcnTransactionsResponse.result.transactions != null) {
        bcnTransactionsResponse.result.transactions = new List.from(
            bcnTransactionsResponse.result.transactions.reversed);
        if (listTxsMempool.isNotEmpty) {
          bcnTransactionsResponse.result.transactions.addAll(listTxsMempool);
        }
      }
    } catch (e) {
      logger.e(e.toString());
    }
  }

  _completer.complete(bcnTransactionsResponse);

  return _completer.future;
}