CakeWallet/cw_bitcoin/lib/bitcoin_wallet_addresses.dart

import 'dart:convert';

import 'package:collection/collection.dart';
import 'package:bitcoin_base/bitcoin_base.dart';
import 'package:blockchain_utils/blockchain_utils.dart';
import 'package:cw_bitcoin/bitcoin_address_record.dart';
import 'package:cw_bitcoin/seedbyte_types.dart';
import 'package:cw_bitcoin/electrum_wallet_addresses.dart';
import 'package:cw_core/wallet_info.dart';
import 'package:mobx/mobx.dart';

part 'bitcoin_wallet_addresses.g.dart';

class BitcoinWalletAddresses = BitcoinWalletAddressesBase with _$BitcoinWalletAddresses;

abstract class BitcoinWalletAddressesBase extends ElectrumWalletAddresses with Store {
  BitcoinWalletAddressesBase(
    WalletInfo walletInfo, {
    required super.hdWallets,
    required super.network,
    required super.isHardwareWallet,
    super.initialAddressesRecords,
    super.initialActiveAddressIndex,
    super.initialAddressPageType,
    this.loadedFromNewSnapshot = false,
    List<BitcoinSilentPaymentAddressRecord>? initialSilentAddresses,
    List<BitcoinReceivedSPAddressRecord>? initialReceivedSPAddresses,
  })  : silentPaymentAddresses = ObservableList<BitcoinSilentPaymentAddressRecord>.of(
          (initialSilentAddresses ?? []).toSet(),
        ),
        receivedSPAddresses = ObservableList<BitcoinReceivedSPAddressRecord>.of(
          (initialReceivedSPAddresses ?? []).toSet(),
        ),
        super(walletInfo) {
    silentPaymentWallet = SilentPaymentOwner.fromBip32(hdWallet);
    silentPaymentWallets = [silentPaymentWallet!];
  }

  final bool loadedFromNewSnapshot;

  static const _OLD_SP_PATH = "m/352'/1'/0'/#'/0";

  // NOTE: ordered in priority: eg. p2wpkh always first, most used address, etc.
  @override
  final walletAddressTypes = [
    SegwitAddressType.p2wpkh,
    SegwitAddressType.p2tr,
    P2shAddressType.p2wpkhInP2sh,
    P2pkhAddressType.p2pkh,
    SegwitAddressType.p2wsh,
  ];

  @observable
  SilentPaymentOwner? silentPaymentWallet;
  final ObservableList<BitcoinSilentPaymentAddressRecord> silentPaymentAddresses;
  final ObservableList<BitcoinReceivedSPAddressRecord> receivedSPAddresses;

  @observable
  List<SilentPaymentOwner> silentPaymentWallets = [];

  @observable
  BitcoinSilentPaymentAddressRecord? activeSilentAddress;

  @observable
  String? scanningSilentAddress;

  @observable
  int silentAddressIndex = 0;

  @override
  Future<void> init() async {
    if (silentPaymentAddresses.isEmpty) generateInitialSPAddresses();
    super.init();
  }

  @action
  Future<void> generateInitialSPAddresses() async {
    final addAddresses = silentPaymentAddresses.isEmpty;

    // Only initiate these old addresses if restoring a wallet and possibly wants the older cake derivation path
    if (walletInfo.isRecovery || silentPaymentAddresses.length > 2) {
      final oldScanPath = Bip32PathParser.parse(_OLD_SP_PATH.replaceFirst("#", "1"));
      final oldSpendPath = Bip32PathParser.parse(_OLD_SP_PATH.replaceFirst("#", "0"));

      final oldSilentPaymentWallet = SilentPaymentOwner.fromPrivateKeys(
        b_scan: ECPrivate(hdWallet.derive(oldScanPath).privateKey),
        b_spend: ECPrivate(hdWallet.derive(oldSpendPath).privateKey),
      );

      silentPaymentWallets.add(oldSilentPaymentWallet);

      if (addAddresses)
        silentPaymentAddresses.addAll(
          [
            BitcoinSilentPaymentAddressRecord(
              oldSilentPaymentWallet.toString(),
              network: network,
              labelIndex: 0,
              name: "",
              type: SilentPaymentsAddresType.p2sp,
              derivationPath: oldSpendPath.toString(),
              isHidden: true,
              isChange: false,
            ),
            BitcoinSilentPaymentAddressRecord(
              oldSilentPaymentWallet.toLabeledSilentPaymentAddress(0).toString(),
              network: network,
              name: "",
              labelIndex: 0,
              labelHex: BytesUtils.toHexString(oldSilentPaymentWallet.generateLabel(0)),
              type: SilentPaymentsAddresType.p2sp,
              derivationPath: oldSpendPath.toString(),
              isHidden: true,
              isChange: true,
            ),
          ],
        );
    }

    if (addAddresses)
      silentPaymentAddresses.addAll([
        BitcoinSilentPaymentAddressRecord(
          silentPaymentWallet!.toString(),
          network: network,
          labelIndex: 0,
          name: "",
          type: SilentPaymentsAddresType.p2sp,
          isChange: false,
        ),
        BitcoinSilentPaymentAddressRecord(
          silentPaymentWallet!.toLabeledSilentPaymentAddress(0).toString(),
          network: network,
          name: "",
          labelIndex: 0,
          labelHex: BytesUtils.toHexString(silentPaymentWallet!.generateLabel(0)),
          type: SilentPaymentsAddresType.p2sp,
          isChange: true,
        ),
      ]);
  }

  @override
  @action
  void resetActiveAddress() {
    if (activeSilentAddress != null &&
        (activeSilentAddress!.isChange || activeSilentAddress!.isHidden)) {
      try {
        activeSilentAddress = silentPaymentAddresses.firstWhere(
          (addressRecord) =>
              addressRecord.labelIndex == silentAddressIndex &&
              !addressRecord.isChange &&
              !addressRecord.isHidden,
        );

        return;
      } catch (_) {}
    }

    super.resetActiveAddress();
  }

  @override
  @computed
  String get address {
    if (addressPageType == SilentPaymentsAddresType.p2sp) {
      if (activeSilentAddress != null) {
        return activeSilentAddress!.address;
      }

      return silentPaymentWallet.toString();
    }

    return super.address;
  }

  @override
  set address(String addr) {
    if (addressPageType == SilentPaymentsAddresType.p2sp) {
      final selected = silentPaymentAddresses
              .firstWhereOrNull((addressRecord) => addressRecord.address == addr) ??
          silentPaymentAddresses[0];

      activeSilentAddress = selected;

      if (!selected.isChange) {
        silentAddressIndex = selected.labelIndex;
      }

      return;
    }

    super.address = addr;
  }

  @override
  @action
  BaseBitcoinAddressRecord generateNewAddress({String label = '', bool? isHidden}) {
    if (addressPageType == SilentPaymentsAddresType.p2sp) {
      return generateNewSPAddress(label: label, isHidden: isHidden);
    }

    return super.generateNewAddress(label: label);
  }

  @action
  BaseBitcoinAddressRecord generateNewSPAddress({String label = '', bool? isHidden}) {
    isHidden ??= false;

    final existingSilentPaymentAddresses = silentPaymentAddresses
        .where(
          (a) => !a.isChange && (isHidden == true ? a.isHidden : !a.isHidden),
        )
        .toList();
    final nextSPLabelIndex = existingSilentPaymentAddresses.length;

    late BitcoinSilentPaymentAddressRecord address;
    if (isHidden == true) {
      final oldScanPath = Bip32PathParser.parse(_OLD_SP_PATH.replaceFirst("#", "1"));
      final oldSpendPath = Bip32PathParser.parse(_OLD_SP_PATH.replaceFirst("#", "0"));

      final oldSilentPaymentWallet = SilentPaymentOwner.fromPrivateKeys(
        b_scan: ECPrivate(hdWallet.derive(oldScanPath).privateKey),
        b_spend: ECPrivate(hdWallet.derive(oldSpendPath).privateKey),
      );

      address = BitcoinSilentPaymentAddressRecord(
        oldSilentPaymentWallet.toLabeledSilentPaymentAddress(nextSPLabelIndex).toString(),
        network: network,
        labelIndex: nextSPLabelIndex,
        derivationPath: oldSpendPath.toString(),
        name: label,
        labelHex: BytesUtils.toHexString(oldSilentPaymentWallet.generateLabel(nextSPLabelIndex)),
        type: SilentPaymentsAddresType.p2sp,
        isChange: false,
        isHidden: true,
      );
    } else {
      address = BitcoinSilentPaymentAddressRecord(
        silentPaymentWallet!.toLabeledSilentPaymentAddress(nextSPLabelIndex).toString(),
        network: network,
        labelIndex: nextSPLabelIndex,
        name: label,
        labelHex: BytesUtils.toHexString(silentPaymentWallet!.generateLabel(nextSPLabelIndex)),
        type: SilentPaymentsAddresType.p2sp,
        isChange: false,
        isHidden: false,
      );
    }

    silentPaymentAddresses.add(address);

    return address;
  }

  @override
  @action
  Future<void> updateAddressesInBox() async {
    // receiveAddressesMapped.entries.forEach((e) {
    //   final addressType = e.key;
    //   final addresses = e.value;

    //   for (final addr in addresses) {
    //     if (getIsReceive(addr)) {
    //       allAddressesMap[addr.address] = addr.name;

    //       final isCurrentType = addr.type == addressPageType;

    //       if (addressType == SilentPaymentsAddresType.p2sp) {
    //         final addressString =
    //             '${addr.address.substring(0, 9 + 5)}...${addr.address.substring(addr.address.length - 9, addr.address.length)}';

    //         if (!isCurrentType) {
    //           addressesMap[addr.address] = addr.name.isEmpty
    //               ? "Silent Payments" + ': $addressString'
    //               : "Silent Payments - " + addr.name + ': $addressString';
    //         } else {
    //           addressesMap[address] = 'Active - Silent Payments' + ': $addressString';
    //         }

    //         // Silent Payments address don't break the loop because all are used
    //         // break;
    //       } else {
    //         if (!isCurrentType) {
    //           addressesMap[addr.address] = '${addressType.value.toUpperCase()}: ${addr.address}';
    //         } else {
    //           addressesMap[address] = 'Active - ${addressType.value.toUpperCase()}: $address';
    //         }

    //         // Break the loop, already got the firt unused address
    //         break;
    //       }
    //     }
    //   }
    // });

    await saveAddressesInBox();
  }

  @override
  @action
  void updateAddress(String address, String label) {
    super.updateAddress(address, label);

    BaseBitcoinAddressRecord? foundAddress;
    silentPaymentAddresses.forEach((addressRecord) {
      if (addressRecord.address == address) {
        foundAddress = addressRecord;
      }
    });

    if (foundAddress != null) {
      foundAddress!.setNewName(label);

      final index =
          silentPaymentAddresses.indexOf(foundAddress as BitcoinSilentPaymentAddressRecord);
      silentPaymentAddresses.remove(foundAddress);
      silentPaymentAddresses.insert(index, foundAddress as BitcoinSilentPaymentAddressRecord);
    }
  }

  @action
  void addSilentAddresses(Iterable<BitcoinSilentPaymentAddressRecord> addresses) {
    final addressesSet = this.silentPaymentAddresses.toSet();
    addressesSet.addAll(addresses);
    this.silentPaymentAddresses.clear();
    this.silentPaymentAddresses.addAll(addressesSet);
  }

  @action
  void addReceivedSPAddresses(Iterable<BitcoinReceivedSPAddressRecord> addresses) {
    final addressesSet = this.receivedSPAddresses.toSet();
    addressesSet.addAll(addresses);
    this.receivedSPAddresses.clear();
    this.receivedSPAddresses.addAll(addressesSet);
  }

  @action
  void deleteSilentPaymentAddress(String address) {
    final addressRecord = silentPaymentAddresses.firstWhereOrNull(
      (addressRecord) => addressRecord.address == address,
    );

    if (addressRecord == null) {
      return;
    }

    silentPaymentAddresses.remove(addressRecord);
  }

  Map<String, int> getLabels(List<String> addresses) {
    final labels = <String, int>{};

    for (int i = 0; i < silentPaymentAddresses.length; i++) {
      final silentAddressRecord = silentPaymentAddresses[i];
      if (!addresses.any((addr) => addr.startsWith(silentAddressRecord.address.substring(0, 9)))) {
        continue;
      }

      final silentPaymentTweak = silentAddressRecord.labelHex;

      if (silentPaymentTweak != null) {
        labels[silentPaymentTweak] = silentAddressRecord.labelIndex;
      }
    }
    return labels;
  }

  List<String> getUsableSilentPaymentAddresses() {
    final oldSpendPath = Bip32PathParser.parse(_OLD_SP_PATH.replaceFirst("#", "0"));
    final primaryAddress = silentPaymentAddresses.firstWhere(
      (addressRecord) =>
          !addressRecord.isChange &&
          addressRecord.labelIndex == 0 &&
          addressRecord.indexedDerivationPath != oldSpendPath.toString(),
    );

    final list = [primaryAddress.address];

    final hiddenAddress = silentPaymentAddresses.firstWhereOrNull(
      (addressRecord) =>
          !addressRecord.isChange &&
          addressRecord.labelIndex == 0 &&
          addressRecord.indexedDerivationPath == oldSpendPath.toString(),
    );

    // Do it like this to keep in order,
    // the primary address always first in the list
    if (hiddenAddress != null) {
      list.add(hiddenAddress.address);
    }

    return list;
  }

  @action
  void setSilentPaymentsScanWallet(String address) {
    scanningSilentAddress = address;
  }

  Map<String, dynamic> toJson() {
    final json = super.toJson();
    json['silentPaymentAddresses'] =
        silentPaymentAddresses.map((address) => address.toJSON()).toList();
    json['receivedSPAddresses'] = receivedSPAddresses.map((address) => address.toJSON()).toList();
    json['silentAddressIndex'] = silentAddressIndex.toString();
    json['loadedFromNewSnapshot'] = true;
    return json;
  }

  static Map<String, dynamic> fromSnapshot(Map<dynamic, dynamic> data) {
    final electrumSnapshot = ElectrumWalletAddressesBase.fromSnapshot(data);

    final silentAddressesTmp = data['silent_addresses'] as List? ?? <Object>[];
    final silentPaymentAddresses = <BitcoinReceivedSPAddressRecord>[];
    final receivedSPAddresses = <BitcoinSilentPaymentAddressRecord>[];

    silentAddressesTmp.whereType<String>().forEach((j) {
      final decoded = json.decode(j) as Map;
      if (decoded['tweak'] != null || decoded['silent_payment_tweak'] != null) {
        silentPaymentAddresses.add(BitcoinReceivedSPAddressRecord.fromJSON(j));
      } else {
        receivedSPAddresses.add(BitcoinSilentPaymentAddressRecord.fromJSON(j));
      }
    });
    var silentAddressIndex = 0;

    try {
      silentAddressIndex = int.parse(data['silent_address_index'] as String? ?? '0');
    } catch (_) {}

    return {
      'allAddresses': electrumSnapshot["addresses"],
      'addressPageType': data['address_page_type'] as String?,
      'receiveAddressIndexByType': electrumSnapshot["receiveAddressIndexByType"],
      'changeAddressIndexByType': electrumSnapshot["changeAddressIndexByType"],
      'silentPaymentAddresses': silentPaymentAddresses,
      'receivedSPAddresses': receivedSPAddresses,
      'silentAddressIndex': silentAddressIndex,
    };
  }

  static BitcoinWalletAddresses fromJson(
    Map<String, dynamic> snp,
    WalletInfo walletInfo, {
    required Map<SeedBytesType, Bip32Slip10Secp256k1> hdWallets,
    required BasedUtxoNetwork network,
    required bool isHardwareWallet,
  }) {
    final electrumJson = ElectrumWalletAddressesBase.fromJson(
      snp,
      walletInfo,
      hdWallets: hdWallets,
      network: network,
      isHardwareWallet: isHardwareWallet,
    );

    final initialSilentAddresses = (snp['silentPaymentAddresses'] as List)
        .map(
          (address) => BitcoinSilentPaymentAddressRecord.fromJSON(address as String),
        )
        .toList();
    final initialReceivedSPAddresses = (snp['receivedSPAddresses'] as List)
        .map(
          (address) => BitcoinReceivedSPAddressRecord.fromJSON(address as String),
        )
        .toList();

    return BitcoinWalletAddresses(
      walletInfo,
      hdWallets: hdWallets,
      network: network,
      isHardwareWallet: isHardwareWallet,
      initialAddressesRecords: electrumJson.addressesRecords,
      initialAddressPageType: electrumJson.addressPageType,
      initialActiveAddressIndex: electrumJson.activeIndexByType,
      initialSilentAddresses: initialSilentAddresses,
      initialReceivedSPAddresses: initialReceivedSPAddresses,
      loadedFromNewSnapshot: snp['loadedFromNewSnapshot'] as bool? ?? false,
    );
  }
}