updateWallet method

@override Future<Result<WalletUpdate, String>> updateWallet({ required ShelleyAddress stakeAddress, TemperalSortOrder sortOrder = TemperalSortOrder.descending, })

Collects the latest transactions for the wallet given it's staking address.

Implementation

@override
Future<Result<WalletUpdate, String>> updateWallet({
  required ShelleyAddress stakeAddress,
  TemperalSortOrder sortOrder = TemperalSortOrder.descending,
}) async {
  final content =
      await _loadAccountContent(stakeAddress: stakeAddress.toBech32());
  if (content.isErr()) {
    return Err(content.unwrapErr());
  }
  final account = content.unwrap();
  final controlledAmount =
      content.isOk() ? int.tryParse(account.controlledAmount) ?? 0 : 0;
  if (controlledAmount == coinZero && account.active == false) {
    //likely new wallet with no transactions, bail out
    return Ok(WalletUpdate(
      balance: controlledAmount,
      transactions: [],
      addresses: [],
      assets: {},
      stakeAccounts: [],
    ));
  }
  final addressesResult =
      await _addresses(stakeAddress: stakeAddress.toBech32());
  if (addressesResult.isErr()) {
    return Err(addressesResult.unwrapErr());
  }
  final addresses = addressesResult.unwrap();
  List<StakeAccount> stakeAccounts =
      []; //TODO should be a list, just show current staked pool for now
  if (account.poolId != null && account.active) {
    final stakeAccountResponse = await _stakeAccount(
        poolId: account.poolId!, stakeAddress: stakeAddress.toBech32());
    if (stakeAccountResponse.isErr()) {
      return Err(stakeAccountResponse.unwrapErr());
    }
    stakeAccounts = stakeAccountResponse.unwrap();
  }
  List<RawTransactionImpl> transactionList = [];
  Set<String> duplicateTxHashes = {}; //track and skip duplicates
  //final Set<String> addressSet = addresses.map((a) => a.toBech32()).toSet();
  for (var address in addresses) {
    final trans = await _transactions(
        address: address.toBech32(), duplicateTxHashes: duplicateTxHashes);
    if (trans.isErr()) {
      return Err(trans.unwrapErr());
    }
    trans.unwrap().forEach((tx) {
      transactionList.add(tx as RawTransactionImpl);
    });
  }
  //set transaction status
  transactionList = markSpentTransactions(transactionList);

  //sort
  transactionList.sort((d1, d2) => sortOrder == TemperalSortOrder.descending
      ? d2.time.compareTo(d1.time)
      : d1.time.compareTo(d2.time));
  Set<String> allAssetIds = transactionList
      .map((t) => t.assetIds)
      .fold(<String>{}, (result, entry) => result..addAll(entry));
  //logger.i("policyIDs: ${policyIDs.join(',')}");
  Map<String, CurrencyAsset> assets = {};
  for (var assetId in allAssetIds) {
    final asset = await _loadAsset(assetId: assetId);
    if (asset.isOk()) {
      assets[assetId] = asset.unwrap();
    }
    if (asset.isErr()) {
      return Err(asset.unwrapErr());
    }
  }
  return Ok(WalletUpdate(
      balance: controlledAmount,
      transactions: transactionList,
      addresses: addresses,
      assets: assets,
      stakeAccounts: stakeAccounts));
}