cake_wallet/lib/bitcoin/cw_bitcoin.dart

part of 'bitcoin.dart';

class CWBitcoin extends Bitcoin {
  WalletCredentials createBitcoinRestoreWalletFromSeedCredentials({
    required String name,
    required String mnemonic,
    required String password,
    required List<DerivationInfo>? derivations,
    String? passphrase,
  }) =>
      BitcoinRestoreWalletFromSeedCredentials(
        name: name,
        mnemonic: mnemonic,
        password: password,
        passphrase: passphrase,
        derivations: derivations,
      );

  @override
  WalletCredentials createBitcoinRestoreWalletFromWIFCredentials(
          {required String name,
          required String password,
          required String wif,
          WalletInfo? walletInfo}) =>
      BitcoinRestoreWalletFromWIFCredentials(
          name: name, password: password, wif: wif, walletInfo: walletInfo);

  @override
  WalletCredentials createBitcoinNewWalletCredentials({
    required String name,
    WalletInfo? walletInfo,
    String? password,
    String? passphrase,
    String? mnemonic,
    String? parentAddress,
  }) =>
      BitcoinNewWalletCredentials(
        name: name,
        walletInfo: walletInfo,
        password: password,
        passphrase: passphrase,
        mnemonic: mnemonic,
        parentAddress: parentAddress,
      );

  @override
  WalletCredentials createBitcoinHardwareWalletCredentials(
          {required String name,
          required HardwareAccountData accountData,
          WalletInfo? walletInfo}) =>
      BitcoinRestoreWalletFromHardware(
          name: name, hwAccountData: accountData, walletInfo: walletInfo);

  @override
  TransactionPriority getMediumTransactionPriority() => ElectrumTransactionPriority.medium;

  @override
  List<String> getWordList() => wordlist;

  @override
  Map<String, String> getWalletKeys(Object wallet) {
    final bitcoinWallet = wallet as ElectrumWallet;
    final keys = bitcoinWallet.keys;

    return <String, String>{
      'wif': keys.wif,
      'privateKey': keys.privateKey,
      'publicKey': keys.publicKey
    };
  }

  @override
  List<TransactionPriority> getTransactionPriorities() => ElectrumTransactionPriority.all;

  @override
  List<TransactionPriority> getLitecoinTransactionPriorities() => ElectrumTransactionPriority.all;

  @override
  TransactionPriority deserializeBitcoinTransactionPriority(int raw) =>
      ElectrumTransactionPriority.deserialize(raw: raw);

  @override
  TransactionPriority deserializeLitecoinTransactionPriority(int raw) =>
      ElectrumTransactionPriority.deserialize(raw: raw);

  @override
  int getFeeRate(Object wallet, TransactionPriority priority) {
    final bitcoinWallet = wallet as ElectrumWallet;
    return bitcoinWallet.feeRate(priority);
  }

  @override
  Future<void> generateNewAddress(Object wallet, String label) async {
    final bitcoinWallet = wallet as ElectrumWallet;
    await bitcoinWallet.walletAddresses.generateNewAddress(label: label);
    await wallet.save();
  }

  @override
  Future<void> updateAddress(Object wallet, String address, String label) async {
    final bitcoinWallet = wallet as ElectrumWallet;
    bitcoinWallet.walletAddresses.updateAddress(address, label);
    await wallet.save();
  }

  @override
  Object createBitcoinTransactionCredentials(
    List<Output> outputs, {
    required TransactionPriority priority,
    int? feeRate,
    UnspentCoinType coinTypeToSpendFrom = UnspentCoinType.any,
  }) {
    final bitcoinFeeRate =
        priority == ElectrumTransactionPriority.custom && feeRate != null ? feeRate : null;
    return BitcoinTransactionCredentials(
      outputs
          .map((out) => OutputInfo(
              fiatAmount: out.fiatAmount,
              cryptoAmount: out.cryptoAmount,
              address: out.address,
              note: out.note,
              sendAll: out.sendAll,
              extractedAddress: out.extractedAddress,
              isParsedAddress: out.isParsedAddress,
              formattedCryptoAmount: out.formattedCryptoAmount,
              memo: out.memo))
          .toList(),
      priority: priority as ElectrumTransactionPriority,
      feeRate: bitcoinFeeRate,
      coinTypeToSpendFrom: coinTypeToSpendFrom,
    );
  }

  @override
  @computed
  List<ElectrumSubAddress> getSubAddresses(Object wallet) {
    final electrumWallet = wallet as ElectrumWallet;
    return electrumWallet.walletAddresses.addressesByReceiveType
        .map(
          (addr) => ElectrumSubAddress(
            id: addr.index,
            name: addr.name,
            address: addr.address,
            derivationPath: (addr as BitcoinAddressRecord)
                .derivationInfo
                .derivationPath
                .addElem(
                  Bip32KeyIndex(addr.isChange ? 1 : 0),
                )
                .addElem(Bip32KeyIndex(addr.index))
                .toString(),
            txCount: addr.txCount,
            balance: addr.balance,
            isChange: addr.isChange,
          ),
        )
        .toList();
  }

  @override
  Future<int> estimateFakeSendAllTxAmount(Object wallet, TransactionPriority priority) async {
    try {
      final sk = ECPrivate.random();
      final electrumWallet = wallet as ElectrumWallet;

      if (wallet.type == WalletType.bitcoinCash) {
        final p2pkhAddr = sk.getPublic().toP2pkhAddress();
        final estimatedTx = await electrumWallet.estimateSendAllTx(
          [BitcoinOutput(address: p2pkhAddr, value: BigInt.zero)],
          getFeeRate(wallet, priority as BitcoinCashTransactionPriority),
        );

        return estimatedTx.amount;
      }

      final p2shAddr = sk.getPublic().toP2pkhInP2sh();
      final estimatedTx = await electrumWallet.estimateSendAllTx(
        [BitcoinOutput(address: p2shAddr, value: BigInt.zero)],
        getFeeRate(wallet, priority),
      );

      return estimatedTx.amount;
    } catch (_) {
      return 0;
    }
  }

  @override
  String getAddress(Object wallet) {
    final bitcoinWallet = wallet as ElectrumWallet;
    return bitcoinWallet.walletAddresses.address;
  }

  @override
  String formatterBitcoinAmountToString({required int amount}) =>
      BitcoinAmountUtils.bitcoinAmountToString(amount: amount);

  @override
  double formatterBitcoinAmountToDouble({required int amount}) =>
      BitcoinAmountUtils.bitcoinAmountToDouble(amount: amount);

  @override
  int formatterStringDoubleToBitcoinAmount(String amount) =>
      BitcoinAmountUtils.stringDoubleToBitcoinAmount(amount);

  @override
  String bitcoinTransactionPriorityWithLabel(TransactionPriority priority, int rate,
          {int? customRate}) =>
      (priority as ElectrumTransactionPriority).labelWithRate(rate, customRate);

  @override
  List<BitcoinUnspent> getUnspents(Object wallet,
      {UnspentCoinType coinTypeToSpendFrom = UnspentCoinType.any}) {
    final bitcoinWallet = wallet as ElectrumWallet;
    return bitcoinWallet.unspentCoins.where((element) {
      switch (coinTypeToSpendFrom) {
        case UnspentCoinType.mweb:
          return element.bitcoinAddressRecord.addressType == SegwitAddresType.mweb;
        case UnspentCoinType.nonMweb:
          return element.bitcoinAddressRecord.addressType != SegwitAddresType.mweb;
        case UnspentCoinType.any:
          return true;
      }
    }).toList();
  }

  Future<void> updateUnspents(Object wallet) async {
    final bitcoinWallet = wallet as ElectrumWallet;
    await bitcoinWallet.updateAllUnspents();
  }

  WalletService createBitcoinWalletService(
    Box<WalletInfo> walletInfoSource,
    Box<UnspentCoinsInfo> unspentCoinSource,
    bool alwaysScan,
    bool isDirect,
    bool mempoolAPIEnabled,
  ) {
    return BitcoinWalletService(
      walletInfoSource,
      unspentCoinSource,
      alwaysScan,
      isDirect,
      mempoolAPIEnabled,
    );
  }

  WalletService createLitecoinWalletService(
    Box<WalletInfo> walletInfoSource,
    Box<UnspentCoinsInfo> unspentCoinSource,
    bool alwaysScan,
    bool isDirect,
    bool mempoolAPIEnabled,
  ) {
    return LitecoinWalletService(
      walletInfoSource,
      unspentCoinSource,
      alwaysScan,
      isDirect,
      mempoolAPIEnabled,
    );
  }

  @override
  TransactionPriority getBitcoinTransactionPriorityMedium() => ElectrumTransactionPriority.fast;

  @override
  TransactionPriority getBitcoinTransactionPriorityCustom() => ElectrumTransactionPriority.custom;

  @override
  TransactionPriority getLitecoinTransactionPriorityMedium() => ElectrumTransactionPriority.medium;

  @override
  TransactionPriority getBitcoinTransactionPrioritySlow() => ElectrumTransactionPriority.medium;

  @override
  TransactionPriority getLitecoinTransactionPrioritySlow() => ElectrumTransactionPriority.slow;

  @override
  Future<void> setAddressType(Object wallet, dynamic option) async {
    final bitcoinWallet = wallet as ElectrumWallet;
    await bitcoinWallet.walletAddresses.setAddressType(option as BitcoinAddressType);
  }

  @override
  ReceivePageOption getSelectedAddressType(Object wallet) {
    final bitcoinWallet = wallet as ElectrumWallet;
    return BitcoinReceivePageOption.fromType(bitcoinWallet.walletAddresses.addressPageType);
  }

  @override
  bool hasSelectedSilentPayments(Object wallet) {
    final bitcoinWallet = wallet as ElectrumWallet;
    return bitcoinWallet.walletAddresses.addressPageType == SilentPaymentsAddresType.p2sp;
  }

  @override
  List<ReceivePageOption> getBitcoinReceivePageOptions() => BitcoinReceivePageOption.all;

  @override
  List<ReceivePageOption> getLitecoinReceivePageOptions() {
    if (Platform.isLinux || Platform.isMacOS || Platform.isWindows) {
      return BitcoinReceivePageOption.allLitecoin
          .where((element) => element != BitcoinReceivePageOption.mweb)
          .toList();
    }
    return BitcoinReceivePageOption.allLitecoin;
  }

  @override
  BitcoinAddressType getBitcoinAddressType(ReceivePageOption option) {
    switch (option) {
      case BitcoinReceivePageOption.p2pkh:
        return P2pkhAddressType.p2pkh;
      case BitcoinReceivePageOption.p2sh:
        return P2shAddressType.p2wpkhInP2sh;
      case BitcoinReceivePageOption.p2tr:
        return SegwitAddresType.p2tr;
      case BitcoinReceivePageOption.p2wsh:
        return SegwitAddresType.p2wsh;
      case BitcoinReceivePageOption.mweb:
        return SegwitAddresType.mweb;
      case BitcoinReceivePageOption.p2wpkh:
      default:
        return SegwitAddresType.p2wpkh;
    }
  }

  @override
  Future<List<DerivationType>> compareDerivationMethods(
      {required String mnemonic, required Node node}) async {
    if (await checkIfMnemonicIsElectrum2(mnemonic)) {
      return [DerivationType.electrum];
    }

    return [DerivationType.bip39, DerivationType.electrum];
  }

  int _countCharOccurrences(String str, String charToCount) {
    int count = 0;
    for (int i = 0; i < str.length; i++) {
      if (str[i] == charToCount) {
        count++;
      }
    }
    return count;
  }

  @override
  List<DerivationInfo> getOldDerivationInfos(List<DerivationInfo> list) {
    final oldList = <DerivationInfo>[];
    oldList.addAll(list);

    for (var derivationInfo in list) {
      final isElectrum = derivationInfo.derivationType == DerivationType.electrum;

      oldList.add(
        DerivationInfo(
          derivationType: DerivationType.old,
          derivationPath: isElectrum
              ? derivationInfo.derivationPath
              : BitcoinAddressUtils.getDerivationFromType(
                  SegwitAddresType.p2wpkh,
                ).derivationPath.toString(),
          scriptType: derivationInfo.scriptType,
        ),
      );
    }

    oldList.addAll(bitcoin!.getOldSPDerivationInfos());

    return oldList;
  }

  @override
  Future<List<DerivationInfo>> getDerivationInfosFromMnemonic({
    required String mnemonic,
    required Node node,
    String? passphrase,
  }) async {
    final list = <DerivationInfo>[];

    late BasedUtxoNetwork network;
    switch (node.type) {
      case WalletType.litecoin:
        network = LitecoinNetwork.mainnet;
        break;
      case WalletType.bitcoin:
      default:
        network = BitcoinNetwork.mainnet;
        break;
    }

    var electrumSeedBytes;
    try {
      electrumSeedBytes = ElectrumV2SeedGenerator.generateFromString(mnemonic, passphrase);
    } catch (e) {
      print("electrum_v2 seed error: $e");

      if (passphrase != null && passphrase.isEmpty) {
        try {
          // TODO: language pick
          electrumSeedBytes = ElectrumV1SeedGenerator(mnemonic).generate();
        } catch (e) {
          print("electrum_v1 seed error: $e");
        }
      }
    }

    if (electrumSeedBytes != null) {
      for (final addressType in BITCOIN_ADDRESS_TYPES) {
        list.add(
          DerivationInfo(
            derivationType: DerivationType.electrum,
            derivationPath: "m/0'",
            scriptType: addressType.value,
          ),
        );
      }
    }

    var bip39SeedBytes;
    try {
      bip39SeedBytes = Bip39SeedGenerator.generateFromString(mnemonic, passphrase);
    } catch (_) {}

    if (bip39SeedBytes != null) {
      for (final addressType in BITCOIN_ADDRESS_TYPES) {
        list.add(
          DerivationInfo(
            derivationType: DerivationType.bip39,
            derivationPath: BitcoinAddressUtils.getDerivationFromType(
              addressType,
            ).derivationPath.toString(),
            scriptType: addressType.value,
          ),
        );
      }
    }

    return list;
  }

  @override
  Map<DerivationType, List<DerivationInfo>> getElectrumDerivations() {
    return electrum_derivations;
  }

  @override
  bool hasTaprootInput(PendingTransaction pendingTransaction) {
    return (pendingTransaction as PendingBitcoinTransaction).hasTaprootInputs;
  }

  @override
  Future<PendingBitcoinTransaction> replaceByFee(
      Object wallet, String transactionHash, String fee) async {
    final bitcoinWallet = wallet as ElectrumWallet;
    return await bitcoinWallet.replaceByFee(transactionHash, int.parse(fee));
  }

  @override
  Future<String?> canReplaceByFee(Object wallet, Object transactionInfo) async {
    final bitcoinWallet = wallet as ElectrumWallet;
    final tx = transactionInfo as ElectrumTransactionInfo;
    return bitcoinWallet.canReplaceByFee(tx);
  }

  @override
  int getTransactionVSize(Object wallet, String transactionHex) {
    final bitcoinWallet = wallet as ElectrumWallet;
    return BtcTransaction.fromRaw(transactionHex).getVSize();
  }

  @override
  Future<bool> isChangeSufficientForFee(Object wallet, String txId, String newFee) async {
    final bitcoinWallet = wallet as ElectrumWallet;
    return bitcoinWallet.isChangeSufficientForFee(txId, int.parse(newFee));
  }

  @override
  int getFeeAmountForPriority(
      Object wallet, TransactionPriority priority, int inputsCount, int outputsCount,
      {int? size}) {
    final bitcoinWallet = wallet as ElectrumWallet;
    return bitcoinWallet.feeAmountForPriority(
        priority as ElectrumTransactionPriority, inputsCount, outputsCount);
  }

  @override
  int getEstimatedFeeWithFeeRate(Object wallet, int feeRate, int? amount,
      {int? outputsCount, int? size}) {
    final bitcoinWallet = wallet as ElectrumWallet;
    return bitcoinWallet.calculateEstimatedFeeWithFeeRate(
      feeRate,
      amount,
      outputsCount: outputsCount,
      size: size,
    );
  }

  @override
  int feeAmountWithFeeRate(Object wallet, int feeRate, int inputsCount, int outputsCount,
      {int? size}) {
    final bitcoinWallet = wallet as ElectrumWallet;
    return bitcoinWallet.feeAmountWithFeeRate(feeRate, inputsCount, outputsCount, size: size);
  }

  @override
  int getMaxCustomFeeRate(Object wallet) {
    final electrumWallet = wallet as ElectrumWallet;
    final feeRates = electrumWallet.feeRates;
    final maxFee = electrumWallet.feeRates is ElectrumTransactionPriorities
        ? ElectrumTransactionPriority.fast
        : BitcoinTransactionPriority.priority;

    return (electrumWallet.feeRate(maxFee) * 10).round();
  }

  @override
  void setLedgerConnection(WalletBase wallet, ledger.LedgerConnection connection) {
    (wallet as ElectrumWallet).setLedgerConnection(connection);
  }

  @override
  Future<List<HardwareAccountData>> getHardwareWalletBitcoinAccounts(LedgerViewModel ledgerVM,
      {int index = 0, int limit = 5}) async {
    final hardwareWalletService = BitcoinHardwareWalletService(ledgerVM.connection);
    try {
      return hardwareWalletService.getAvailableAccounts(index: index, limit: limit);
    } catch (err) {
      print(err);
      throw err;
    }
  }

  @override
  Future<List<HardwareAccountData>> getHardwareWalletLitecoinAccounts(LedgerViewModel ledgerVM,
      {int index = 0, int limit = 5}) async {
    final hardwareWalletService = LitecoinHardwareWalletService(ledgerVM.connection);
    try {
      return hardwareWalletService.getAvailableAccounts(index: index, limit: limit);
    } catch (err) {
      print(err);
      throw err;
    }
  }

  @override
  List<DerivationInfo> getOldSPDerivationInfos() {
    return [
      DerivationInfo(
        derivationType: DerivationType.bip39,
        derivationPath: "m/352'/1'/0'/1'/0",
        description: "Old SP Scan",
      ),
      DerivationInfo(
        derivationType: DerivationType.bip39,
        derivationPath: "m/352'/1'/0'/0'/0",
        description: "Old SP Spend",
      ),
    ];
  }

  @override
  List<ElectrumSubAddress> getSilentPaymentAddresses(Object wallet) {
    final walletAddresses = (wallet as BitcoinWallet).walletAddresses as BitcoinWalletAddresses;
    return walletAddresses.silentPaymentAddresses
        .map((addr) => ElectrumSubAddress(
              id: addr.index,
              name: addr.name,
              address: addr.address,
              derivationPath: Bip32PathParser.parse(addr.derivationPath)
                  .addElem(Bip32KeyIndex(addr.index))
                  .toString(),
              txCount: addr.txCount,
              balance: addr.balance,
              isChange: addr.isChange,
            ))
        .toList();
  }

  @override
  List<ElectrumSubAddress> getSilentPaymentReceivedAddresses(Object wallet) {
    final walletAddresses = (wallet as BitcoinWallet).walletAddresses as BitcoinWalletAddresses;
    return walletAddresses.receivedSPAddresses
        .map((addr) => ElectrumSubAddress(
              id: addr.index,
              name: addr.name,
              address: addr.address,
              derivationPath: "",
              txCount: addr.txCount,
              balance: addr.balance,
              isChange: addr.isChange,
            ))
        .toList();
  }

  @override
  bool isBitcoinReceivePageOption(ReceivePageOption option) {
    return option is BitcoinReceivePageOption;
  }

  @override
  BitcoinAddressType getOptionToType(ReceivePageOption option) {
    return (option as BitcoinReceivePageOption).toType();
  }

  @override
  @computed
  bool getScanningActive(Object wallet) {
    final bitcoinWallet = wallet as ElectrumWallet;
    return bitcoinWallet.silentPaymentsScanningActive;
  }

  @override
  Future<void> setScanningActive(Object wallet, bool active) async {
    final bitcoinWallet = wallet as BitcoinWallet;
    bitcoinWallet.setSilentPaymentsScanning(active);
  }

  @override
  bool isTestnet(Object wallet) {
    final bitcoinWallet = wallet as ElectrumWallet;
    return bitcoinWallet.isTestnet;
  }

  @override
  Future<void> registerSilentPaymentsKey(Object wallet, bool active) async {
    final bitcoinWallet = wallet as BitcoinWallet;
    return await bitcoinWallet.registerSilentPaymentsKey();
  }

  @override
  Future<bool> checkIfMempoolAPIIsEnabled(Object wallet) async {
    final bitcoinWallet = wallet as ElectrumWallet;
    return await bitcoinWallet.mempoolAPIEnabled;
  }

  @override
  Future<int> getHeightByDate({required DateTime date, bool? bitcoinMempoolAPIEnabled}) async {
    if (bitcoinMempoolAPIEnabled ?? false) {
      try {
        return await getBitcoinHeightByDateAPI(date: date);
      } catch (_) {}
    }
    return await getBitcoinHeightByDate(date: date);
  }

  @override
  int getLitecoinHeightByDate({required DateTime date}) => getLtcHeightByDate(date: date);

  @override
  Future<void> rescan(Object wallet, {required int height, bool? doSingleScan}) async {
    final bitcoinWallet = wallet as BitcoinWallet;
    bitcoinWallet.rescan(height: height, doSingleScan: doSingleScan);
  }

  @override
  Future<bool> getNodeIsElectrsSPEnabled(Object wallet) async {
    final bitcoinWallet = wallet as BitcoinWallet;
    return bitcoinWallet.getNodeSupportsSilentPayments();
  }

  @override
  void deleteSilentPaymentAddress(Object wallet, String address) {
    final walletAddresses = (wallet as BitcoinWallet).walletAddresses as BitcoinWalletAddresses;
    walletAddresses.deleteSilentPaymentAddress(address);
  }

  @override
  Future<void> updateFeeRates(Object wallet) async {
    final bitcoinWallet = wallet as ElectrumWallet;
    await bitcoinWallet.updateFeeRates();
  }

  @override
  Future<void> setMwebEnabled(Object wallet, bool enabled) async {
    final litecoinWallet = wallet as LitecoinWallet;
    litecoinWallet.setMwebEnabled(enabled);
  }

  @override
  bool getMwebEnabled(Object wallet) {
    final litecoinWallet = wallet as LitecoinWallet;
    return litecoinWallet.mwebEnabled;
  }

  List<Output> updateOutputs(PendingTransaction pendingTransaction, List<Output> outputs) {
    final pendingTx = pendingTransaction as PendingBitcoinTransaction;

    if (!pendingTx.hasSilentPayment) {
      return outputs;
    }

    final updatedOutputs = outputs.map((output) {
      try {
        final pendingOut = pendingTx.outputs[outputs.indexOf(output)];
        final updatedOutput = output;

        updatedOutput.stealthAddress = P2trAddress.fromScriptPubkey(script: pendingOut.scriptPubKey)
            .toAddress(BitcoinNetwork.mainnet);
        return updatedOutput;
      } catch (_) {}

      return output;
    }).toList();

    return updatedOutputs;
  }

  @override
  bool txIsReceivedSilentPayment(TransactionInfo txInfo) {
    final tx = txInfo as ElectrumTransactionInfo;
    return tx.isReceivedSilentPayment;
  }

  @override
  bool txIsMweb(TransactionInfo txInfo) {
    final tx = txInfo as ElectrumTransactionInfo;

    List<String> inputAddresses = tx.inputAddresses ?? [];
    List<String> outputAddresses = tx.outputAddresses ?? [];
    bool inputAddressesContainMweb = false;
    bool outputAddressesContainMweb = false;

    for (var address in inputAddresses) {
      if (address.toLowerCase().contains('mweb')) {
        inputAddressesContainMweb = true;
        break;
      }
    }

    for (var address in outputAddresses) {
      if (address.toLowerCase().contains('mweb')) {
        outputAddressesContainMweb = true;
        break;
      }
    }

    // TODO: this could be improved:
    return inputAddressesContainMweb || outputAddressesContainMweb;
  }

  String? getUnusedMwebAddress(Object wallet) {
    try {
      final electrumWallet = wallet as ElectrumWallet;
      final mwebAddress =
          electrumWallet.walletAddresses.mwebAddresses.firstWhere((element) => !element.isUsed);
      return mwebAddress.address;
    } catch (_) {
      return null;
    }
  }

  String? getUnusedSegwitAddress(Object wallet) {
    try {
      final electrumWallet = wallet as ElectrumWallet;
      final segwitAddress = electrumWallet.walletAddresses.allAddresses.firstWhere(
          (element) => !element.isUsed && element.addressType == SegwitAddresType.p2wpkh);
      return segwitAddress.address;
    } catch (_) {
      return null;
    }
  }
}