mirror of
https://github.com/Such-Software/hash-wallet.git
synced 2026-10-26 06:08:40 +01:00
5179 lines
172 KiB
Dart
5179 lines
172 KiB
Dart
import 'dart:async';
|
|
import 'dart:convert';
|
|
import 'dart:isolate';
|
|
import 'dart:math' show Random;
|
|
|
|
import 'package:bitcoin_base/bitcoin_base.dart';
|
|
import 'package:cw_bitcoin/lightning/lightning_addres_type.dart';
|
|
import 'package:cw_bitcoin/lightning/lightning_wallet.dart';
|
|
import 'package:cw_bitcoin/locktime.dart';
|
|
import 'package:cw_core/hardware/hardware_wallet_service.dart';
|
|
import 'package:cw_core/root_dir.dart';
|
|
import 'package:cw_core/utils/proxy_wrapper.dart';
|
|
import 'package:cw_core/utils/print_verbose.dart';
|
|
import 'package:cw_bitcoin/bitcoin_wallet.dart';
|
|
import 'package:cw_bitcoin/coin_selection.dart';
|
|
import 'package:cw_bitcoin/litecoin_wallet.dart';
|
|
import 'package:shared_preferences/shared_preferences.dart';
|
|
import 'package:blockchain_utils/blockchain_utils.dart';
|
|
import 'package:collection/collection.dart';
|
|
import 'package:cw_bitcoin/address_from_output.dart';
|
|
import 'package:cw_bitcoin/bitcoin_address_record.dart';
|
|
import 'package:cw_bitcoin/bitcoin_transaction_credentials.dart';
|
|
import 'package:cw_bitcoin/bitcoin_transaction_priority.dart';
|
|
import 'package:cw_bitcoin/bitcoin_unspent.dart';
|
|
import 'package:cw_bitcoin/bitcoin_wallet_keys.dart';
|
|
import 'package:cw_bitcoin/electrum.dart' as electrum;
|
|
import 'package:cw_bitcoin/electrum_balance.dart';
|
|
import 'package:cw_bitcoin/electrum_derivations.dart';
|
|
import 'package:cw_bitcoin/electrum_transaction_history.dart';
|
|
import 'package:cw_bitcoin/electrum_transaction_info.dart';
|
|
import 'package:cw_bitcoin/electrum_wallet_addresses.dart';
|
|
import 'package:cw_bitcoin/exceptions.dart';
|
|
import 'package:cw_bitcoin/pending_bitcoin_transaction.dart';
|
|
import 'package:cw_bitcoin/utils.dart';
|
|
import 'package:cw_core/amount/money.dart';
|
|
import 'package:cw_core/crypto_currency.dart';
|
|
import 'package:cw_core/encryption_file_utils.dart';
|
|
import 'package:cw_core/get_height_by_date.dart';
|
|
import 'package:cw_core/node.dart';
|
|
import 'package:cw_core/output_info.dart';
|
|
import 'package:cw_core/pending_transaction.dart';
|
|
import 'package:cw_core/sync_status.dart';
|
|
import 'package:cw_core/transaction_direction.dart';
|
|
import 'package:cw_core/transaction_priority.dart';
|
|
import 'package:cw_core/unspent_coin_type.dart';
|
|
import 'package:cw_core/unspent_coins_info.dart';
|
|
import 'package:cw_core/utils/socket_health_logger.dart';
|
|
import 'package:cw_core/utils/tor/abstract.dart';
|
|
import 'package:cw_core/wallet_base.dart';
|
|
import 'package:cw_core/wallet_info.dart';
|
|
import 'package:cw_core/wallet_keys_file.dart';
|
|
import 'package:cw_core/wallet_type.dart';
|
|
import 'package:flutter/foundation.dart';
|
|
import 'package:hex/hex.dart';
|
|
import 'package:hive/hive.dart';
|
|
import 'package:mobx/mobx.dart';
|
|
import 'package:rxdart/subjects.dart';
|
|
import 'package:sp_scanner/sp_scanner.dart';
|
|
|
|
part 'electrum_wallet.g.dart';
|
|
|
|
class ElectrumWallet = ElectrumWalletBase with _$ElectrumWallet;
|
|
|
|
abstract class ElectrumWalletBase
|
|
extends WalletBase<ElectrumBalance, ElectrumTransactionHistory, ElectrumTransactionInfo>
|
|
with Store, WalletKeysFile {
|
|
ElectrumWalletBase({
|
|
required String password,
|
|
required WalletInfo walletInfo,
|
|
required DerivationInfo derivationInfo,
|
|
required Box<UnspentCoinsInfo> unspentCoinsInfo,
|
|
required this.network,
|
|
required this.encryptionFileUtils,
|
|
String? xpub,
|
|
String? mnemonic,
|
|
Uint8List? seedBytes,
|
|
this.passphrase,
|
|
List<BitcoinAddressRecord>? initialAddresses,
|
|
electrum.ElectrumClient? electrumClient,
|
|
ElectrumBalance? initialBalance,
|
|
CryptoCurrency? currency,
|
|
bool? alwaysScan,
|
|
bool useLightning = true,
|
|
}) : _masterHD = getMasterHD(seedBytes, network, walletInfo.hardwareWalletType),
|
|
accountHD = getAccountHDWallet(
|
|
currency, network, seedBytes, xpub, derivationInfo, walletInfo.hardwareWalletType),
|
|
syncStatus = NotConnectedSyncStatus(),
|
|
_password = password,
|
|
_feeRates = <int>[],
|
|
_isTransactionUpdating = false,
|
|
isEnabledAutoGenerateSubaddress = true,
|
|
unspentCoins = [],
|
|
_scripthashesUpdateSubject = {},
|
|
this.alwaysScan = alwaysScan,
|
|
silentPaymentsScanningActive = alwaysScan ?? false,
|
|
balance = ObservableMap<CryptoCurrency, ElectrumBalance>.of(
|
|
currency != null ? {currency: initialBalance ?? ElectrumBalance.zero(currency)} : {}),
|
|
this.unspentCoinsInfo = unspentCoinsInfo,
|
|
this.isTestnet = !network.isMainnet,
|
|
this._mnemonic = mnemonic,
|
|
this.electrumClient = electrumClient ?? electrum.ElectrumClient(),
|
|
_useLightning = useLightning,
|
|
super(walletInfo, derivationInfo) {
|
|
transactionHistory = ElectrumTransactionHistory(
|
|
walletInfo: walletInfo,
|
|
password: password,
|
|
encryptionFileUtils: encryptionFileUtils,
|
|
);
|
|
|
|
reaction((_) => syncStatus, _syncStatusReaction);
|
|
sharedPrefs.complete(SharedPreferences.getInstance());
|
|
// Probably not needed as init will be called right after creating the wallet.
|
|
_prepareHdForAccount(currentAccountIndex, currency);
|
|
}
|
|
|
|
int _purposeForType(BitcoinAddressType type) {
|
|
switch (type.value) {
|
|
case 'P2PKH':
|
|
return 44;
|
|
case 'P2SH/P2WPKH':
|
|
return 49;
|
|
case 'P2WPKH':
|
|
return 84;
|
|
case 'P2TR':
|
|
return 86;
|
|
default:
|
|
return 84;
|
|
}
|
|
}
|
|
|
|
int _coinTypeFor(CryptoCurrency cur) {
|
|
if (!network.isMainnet) return 1;
|
|
switch (cur) {
|
|
case CryptoCurrency.btc:
|
|
case CryptoCurrency.tbtc:
|
|
return 0;
|
|
case CryptoCurrency.ltc:
|
|
return 2;
|
|
case CryptoCurrency.bch:
|
|
return 145;
|
|
case CryptoCurrency.doge:
|
|
return 3;
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/// Returns the BIP32 account derivation path (m/purpose'/coinType'/0') for STANDARD addresses.
|
|
/// For LEGACY addresses, returns the wallet's legacy derivation base (derivationInfo.derivationPath)
|
|
/// which is already the account path used historically (e.g. m/0' or m/84'/0'/0').
|
|
String _accountDerivationPathForRecord(BaseBitcoinAddressRecord record) {
|
|
if (derivationInfo.derivationType == DerivationType.electrum) {
|
|
return derivationInfo.derivationPath ?? electrum_path; // m/0'
|
|
}
|
|
|
|
if (record.isLegacyDerivation) {
|
|
return derivationInfo.derivationPath ?? electrum_path;
|
|
}
|
|
|
|
final coinType = _coinTypeFor(currency);
|
|
final purpose = _purposeForType(record.type);
|
|
return "m/$purpose'/$coinType'/${record.accountIndex}'";
|
|
}
|
|
|
|
List<BitcoinAddressType> supportedAddressTypes(WalletType type) {
|
|
switch (type) {
|
|
case WalletType.bitcoin:
|
|
return BITCOIN_ADDRESS_TYPES;
|
|
case WalletType.bitcoinCash:
|
|
return BITCOIN_CASH_ADDRESS_TYPES;
|
|
case WalletType.dogecoin:
|
|
return DOGECOIN_ADDRESS_TYPES;
|
|
case WalletType.litecoin:
|
|
return LITECOIN_ADDRESS_TYPES;
|
|
default:
|
|
return BITCOIN_ADDRESS_TYPES;
|
|
}
|
|
}
|
|
|
|
static Bip32Slip10Secp256k1 getAccountHDWallet(
|
|
CryptoCurrency? currency,
|
|
BasedUtxoNetwork network,
|
|
Uint8List? seedBytes,
|
|
String? xpub,
|
|
DerivationInfo? derivationInfo,
|
|
HardwareWalletType? hardwareWalletType) {
|
|
if (seedBytes == null && xpub == null) {
|
|
throw Exception(
|
|
"To create a Wallet you need either a seed or an xpub. This should not happen");
|
|
}
|
|
|
|
if (seedBytes != null) {
|
|
switch (currency) {
|
|
case CryptoCurrency.btc:
|
|
case CryptoCurrency.ltc:
|
|
case CryptoCurrency.tbtc:
|
|
return Bip32Slip10Secp256k1.fromSeed(
|
|
seedBytes, getKeyNetVersion(network, hardwareWalletType))
|
|
.derivePath(
|
|
_hardenedDerivationPath(derivationInfo?.derivationPath ?? electrum_path))
|
|
as Bip32Slip10Secp256k1;
|
|
case CryptoCurrency.bch:
|
|
return bitcoinCashHDWallet(seedBytes);
|
|
case CryptoCurrency.doge:
|
|
return dogecoinHDWallet(seedBytes);
|
|
default:
|
|
throw Exception("Unsupported currency");
|
|
}
|
|
}
|
|
|
|
return Bip32Slip10Secp256k1.fromExtendedKey(
|
|
xpub!, getKeyNetVersion(network, hardwareWalletType));
|
|
}
|
|
|
|
static Bip32Slip10Secp256k1 bitcoinCashHDWallet(Uint8List seedBytes) =>
|
|
Bip32Slip10Secp256k1.fromSeed(seedBytes).derivePath("m/44'/145'/0'") as Bip32Slip10Secp256k1;
|
|
|
|
static Bip32Slip10Secp256k1 dogecoinHDWallet(Uint8List seedBytes) =>
|
|
Bip32Slip10Secp256k1.fromSeed(seedBytes).derivePath("m/44'/3'/0'") as Bip32Slip10Secp256k1;
|
|
|
|
static int estimatedTransactionSize(int inputsCount, int outputsCounts) =>
|
|
inputsCount * 68 + outputsCounts * 34 + 10;
|
|
|
|
// vbytes an input of the given script type adds to a transaction. The generic
|
|
// estimate above assumes P2WPKH (68); legacy and taproot inputs differ enough
|
|
// to break changeless-match arithmetic if not accounted for.
|
|
static int estimatedInputSize(BitcoinAddressType type) {
|
|
if (type == P2pkhAddressType.p2pkh) return 148;
|
|
if (type == P2shAddressType.p2wpkhInP2sh) return 91;
|
|
if (type == SegwitAddresType.p2tr) return 58;
|
|
if (type == SegwitAddresType.p2wsh) return 105;
|
|
if (type == SilentPaymentsAddresType.p2sp) return 58; // spent via taproot
|
|
return 68;
|
|
}
|
|
|
|
// vbytes an output of the given script type adds to a transaction. Silent
|
|
// payment outputs are delivered as taproot.
|
|
static int estimatedOutputSize(BitcoinAddressType type) {
|
|
if (type == P2pkhAddressType.p2pkh) return 34;
|
|
if (type == P2shAddressType.p2wpkhInP2sh) return 32;
|
|
if (type == SegwitAddresType.p2tr) return 43;
|
|
if (type == SegwitAddresType.p2wsh) return 43;
|
|
if (type == SilentPaymentsAddresType.p2sp) return 43;
|
|
return 31;
|
|
}
|
|
|
|
// Parses the account index from a BIP-44/49/84/86 derivation path.
|
|
// e.g. "m/84'/0'/1'" → 1. Returns 0 for unrecognised formats.
|
|
static int _parseAccountIndex(String? derivationPath) {
|
|
if (derivationPath == null) return 0;
|
|
final parts = derivationPath.split('/');
|
|
if (parts.length < 4) return 0;
|
|
return int.tryParse(parts[3].replaceAll("'", "")) ?? 0;
|
|
}
|
|
|
|
static Bip32KeyNetVersions? getKeyNetVersion(BasedUtxoNetwork network,
|
|
[HardwareWalletType? hardwareWalletType]) {
|
|
switch (network) {
|
|
case LitecoinNetwork.mainnet:
|
|
if ([HardwareWalletType.ledger, HardwareWalletType.trezor].contains(hardwareWalletType))
|
|
return Bip44Conf.litecoinMainNet.altKeyNetVer;
|
|
return null;
|
|
default:
|
|
return null;
|
|
}
|
|
}
|
|
|
|
static Bip32Slip10Secp256k1? getMasterHD(Uint8List? seedBytes,
|
|
[BasedUtxoNetwork? network, HardwareWalletType? hardwareWalletType]) {
|
|
if (seedBytes == null) return null;
|
|
|
|
return Bip32Slip10Secp256k1.fromSeed(
|
|
seedBytes, network != null ? getKeyNetVersion(network, hardwareWalletType) : null);
|
|
}
|
|
|
|
static const int addressHistoryChunkSize = 150;
|
|
static const int transactionChunkSize = 150;
|
|
static const int discoveryHistoryChunkSize = 20;
|
|
static const int transactionBatchTimeoutMs = 15000;
|
|
static const int batchTestTimeoutMs = 4000;
|
|
static const int batchTestHashesCount = 2;
|
|
static const bool useBatchForHistory = true;
|
|
|
|
static const int maxProbAccounts = 3;
|
|
|
|
final Map<String, Set<String>> _appliedCoinKeysByAddress = {};
|
|
|
|
@observable
|
|
bool? alwaysScan;
|
|
|
|
@computed
|
|
bool get useLightning => _useLightning && LightningWallet.isAvailable;
|
|
|
|
set useLightning(bool val) => _useLightning = val && LightningWallet.isAvailable;
|
|
|
|
@observable
|
|
bool _useLightning;
|
|
|
|
@observable
|
|
ObservableMap<int, ElectrumBalance> accountBalances = ObservableMap<int, ElectrumBalance>();
|
|
|
|
final Bip32Slip10Secp256k1? _masterHD;
|
|
final Bip32Slip10Secp256k1 accountHD;
|
|
final String? _mnemonic;
|
|
|
|
final mainHdByTypeAndAccount = <int, Map<BitcoinAddressType, Bip32Slip10Secp256k1>>{};
|
|
final sideHdByTypeAndAccount = <int, Map<BitcoinAddressType, Bip32Slip10Secp256k1>>{};
|
|
|
|
Bip32Slip10Secp256k1 get mainHd => accountHD.childKey(Bip32KeyIndex(0));
|
|
|
|
Bip32Slip10Secp256k1 get sideHd => accountHD.childKey(Bip32KeyIndex(1));
|
|
|
|
final EncryptionFileUtils encryptionFileUtils;
|
|
|
|
@override
|
|
final String? passphrase;
|
|
|
|
@override
|
|
@observable
|
|
bool isEnabledAutoGenerateSubaddress;
|
|
|
|
late electrum.ElectrumClient electrumClient;
|
|
Box<UnspentCoinsInfo> unspentCoinsInfo;
|
|
|
|
@override
|
|
late ElectrumWalletAddresses walletAddresses;
|
|
|
|
@override
|
|
@observable
|
|
late ObservableMap<CryptoCurrency, ElectrumBalance> balance;
|
|
|
|
@override
|
|
@observable
|
|
SyncStatus syncStatus;
|
|
|
|
bool _hasCompleteUnspentSet = false;
|
|
bool _isSyncing = false;
|
|
|
|
Future<WalletInfoAccount> loadCurrentAccount() async {
|
|
final accounts = await walletInfo.getAccounts();
|
|
final current = accounts.firstWhere(
|
|
(account) => account.accountIndex == currentAccountIndex,
|
|
orElse: () => accounts.first,
|
|
);
|
|
|
|
return current;
|
|
}
|
|
|
|
Future<List<int>> loadAccountIndexes() async {
|
|
if (!hasAccountsSupport) return [0];
|
|
|
|
final accounts = await walletInfo.getAccounts();
|
|
return accounts.map((account) => account.accountIndex).toList();
|
|
}
|
|
|
|
void _prepareHdForAccount(int accountIndex, CryptoCurrency? currency) {
|
|
// For the first account, we support all address types. For extra accounts, we only support SegwitAddresType.p2wpkh.
|
|
final supportedTypes =
|
|
accountIndex == 0 ? supportedAddressTypes(walletInfo.type) : EXTRA_ACCOUNT_ADDRESS_TYPES;
|
|
final isElectrumDerivation = derivationInfo.derivationType == DerivationType.electrum;
|
|
final canDeriveFromSeed = _masterHD != null && currency != null;
|
|
|
|
final mainMap = mainHdByTypeAndAccount[accountIndex] ??= {};
|
|
final sideMap = sideHdByTypeAndAccount[accountIndex] ??= {};
|
|
|
|
if (canDeriveFromSeed && !isElectrumDerivation) {
|
|
final coinType = _coinTypeFor(currency);
|
|
|
|
for (final type in supportedTypes) {
|
|
final purpose = _purposeForType(type);
|
|
final accountPath = "m/$purpose'/$coinType'/$accountIndex'";
|
|
|
|
mainMap[type] = _masterHD!.derivePath("$accountPath/0") as Bip32Slip10Secp256k1;
|
|
sideMap[type] = _masterHD!.derivePath("$accountPath/1") as Bip32Slip10Secp256k1;
|
|
}
|
|
} else {
|
|
// case for Electrum derivation or when we don't have seed but only xpub (view only wallet)
|
|
for (final type in supportedTypes) {
|
|
mainMap[type] = mainHd; // accountHD.child(0)
|
|
sideMap[type] = sideHd; // accountHD.child(1)
|
|
}
|
|
}
|
|
}
|
|
|
|
ElectrumBalance balanceForAccount(int accountIndex) =>
|
|
accountBalances[accountIndex] ?? ElectrumBalance.zero(currency);
|
|
|
|
void _updateAccountBalancesFromUnspents() {
|
|
if (!_hasCompleteUnspentSet) return;
|
|
|
|
final newBalances = <int, ElectrumBalance>{};
|
|
|
|
for (final coin in unspentCoins) {
|
|
final accountIndex = coin.bitcoinAddressRecord.accountIndex;
|
|
final current = newBalances[accountIndex] ?? ElectrumBalance.zero(currency);
|
|
final amount = Money.fromInt(coin.value, currency);
|
|
|
|
if (coin.isFrozen) {
|
|
current.frozen += amount;
|
|
}
|
|
|
|
if (coin.confirmations != null && coin.confirmations! > 0) {
|
|
current.confirmed += amount;
|
|
} else {
|
|
current.unconfirmed += amount;
|
|
}
|
|
|
|
newBalances[accountIndex] = current;
|
|
}
|
|
|
|
for (final accountIndex in walletAddresses.accountIndexes) {
|
|
newBalances.putIfAbsent(accountIndex, () => ElectrumBalance.zero(currency));
|
|
}
|
|
|
|
accountBalances = ObservableMap<int, ElectrumBalance>.of(newBalances);
|
|
_updateCurrentAccountBalance();
|
|
}
|
|
|
|
void _updateCurrentAccountBalance({int? accountIndex}) {
|
|
if (type != WalletType.bitcoin) return;
|
|
|
|
final targetAccountIndex = accountIndex ?? currentAccountIndex;
|
|
final newBalance = accountBalances[targetAccountIndex];
|
|
|
|
if (newBalance == null) {
|
|
// If the account balance is not found, set it to zero for the current currency.
|
|
balance[currency] = ElectrumBalance.zero(currency);
|
|
return;
|
|
}
|
|
|
|
balance[currency] = newBalance.copy();
|
|
}
|
|
|
|
Map<int, Set<String>> get addressesSetByAccount {
|
|
final result = <int, Set<String>>{};
|
|
for (final addr in walletAddresses.allAddresses) {
|
|
if (addr.type == SegwitAddresType.mweb) continue;
|
|
(result[addr.accountIndex] ??= <String>{}).add(addr.address);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
int? _accountForTransaction(
|
|
ElectrumTransactionBundle bundle,
|
|
Map<int, Set<String>> addressesByAccount,
|
|
) {
|
|
if (type != WalletType.bitcoin) return null;
|
|
|
|
int? accountForAddress(String address) {
|
|
for (final entry in addressesByAccount.entries) {
|
|
if (entry.value.contains(address)) return entry.key;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
for (var i = 0; i < bundle.originalTransaction.inputs.length; i++) {
|
|
final inputTransaction = bundle.ins[i];
|
|
if (inputTransaction == null) continue;
|
|
|
|
final outTransaction =
|
|
inputTransaction.outputs[bundle.originalTransaction.inputs[i].txIndex];
|
|
final account =
|
|
accountForAddress(addressFromOutputScript(outTransaction.scriptPubKey, network));
|
|
if (account != null) return account;
|
|
}
|
|
|
|
for (final out in bundle.originalTransaction.outputs) {
|
|
final account = accountForAddress(addressFromOutputScript(out.scriptPubKey, network));
|
|
if (account != null) return account;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
Set<String> get addressesSet => walletAddresses.allAddresses
|
|
.where((element) => element.type != SegwitAddresType.mweb)
|
|
.map((addr) => addr.address)
|
|
.toSet();
|
|
|
|
List<String> get scriptHashes => walletAddresses.addressesByReceiveType
|
|
.where((addr) => RegexUtils.addressTypeFromStr(addr.address, network) is! MwebAddress)
|
|
.map((addr) => (addr as BitcoinAddressRecord).getScriptHash(network))
|
|
.toList();
|
|
|
|
List<String> get publicScriptHashes => walletAddresses.allAddresses
|
|
.where((addr) => !addr.isHidden)
|
|
.where((addr) => RegexUtils.addressTypeFromStr(addr.address, network) is! MwebAddress)
|
|
.map((addr) => addr.getScriptHash(network))
|
|
.toList();
|
|
|
|
String get xpub => accountHD.publicKey.toExtended;
|
|
|
|
int get currentAccountIndex => walletInfo.currentAccountIndex;
|
|
|
|
@action
|
|
Future<void> setCurrentAccount(int accountIndex) async {
|
|
|
|
final isNewAccount = !walletAddresses.accountIndexes.contains(accountIndex);
|
|
if (isNewAccount) {
|
|
walletAddresses.accountIndexes.add(accountIndex);
|
|
|
|
accountBalances[accountIndex] = ElectrumBalance.zero(currency);
|
|
}
|
|
|
|
await walletInfo.setSelectedAccount(accountIndex);
|
|
|
|
_prepareHdForAccount(accountIndex, currency);
|
|
|
|
walletAddresses.currentAccountIndex = accountIndex;
|
|
|
|
final currentPageType = walletAddresses.addressPageType;
|
|
await walletAddresses.setAddressType(currentPageType);
|
|
|
|
// For extra accounts, we only prepare SegwitAddresType.p2wpkh type.
|
|
if (isNewAccount) {
|
|
await walletAddresses.prepareAccountAddresses(
|
|
accountIndex,
|
|
types: accountIndex == 0 ? BITCOIN_ADDRESS_TYPES : EXTRA_ACCOUNT_ADDRESS_TYPES,
|
|
);
|
|
await walletAddresses.updateAddressesInBox();
|
|
}
|
|
|
|
walletAddresses.updateReceiveAddresses();
|
|
walletAddresses.updateChangeAddresses();
|
|
|
|
_updateCurrentAccountBalance(accountIndex: accountIndex);
|
|
|
|
unawaited(() async {
|
|
try {
|
|
if (isNewAccount && !_isSyncing) {
|
|
final histories = <String, ElectrumTransactionInfo>{};
|
|
|
|
final typesToFetch = accountIndex == 0 ? BITCOIN_ADDRESS_TYPES : EXTRA_ACCOUNT_ADDRESS_TYPES;
|
|
// Explicit for clarity — fetchTransactionsForAddressTypeBatch already skips types
|
|
// with no addresses for this account, so this doesn't change RPC calls, just intent.
|
|
|
|
for (final addressType in typesToFetch) {
|
|
if (shouldUseBatchFetching) {
|
|
await fetchTransactionsForAddressTypeBatch(histories, addressType,
|
|
accountIndex: accountIndex);
|
|
} else {
|
|
await fetchTransactionsForAddressType(histories, addressType,
|
|
accountIndex: accountIndex);
|
|
}
|
|
}
|
|
|
|
await resolveQueuedTransactionDetails();
|
|
}
|
|
|
|
await updateAllUnspents();
|
|
} catch (e) {
|
|
printV('setCurrentAccount balance update failed: $e');
|
|
}
|
|
}());
|
|
}
|
|
|
|
bool get shouldUseBatchFetching => useBatchForHistory && _isBatchSupported == true;
|
|
|
|
bool get isInitialBitcoinAccountsSync =>
|
|
hasAccountsSupport &&
|
|
walletInfo.isMultiAccountsEnabled == true &&
|
|
(walletInfo.accountDiscoveryLimit ?? 0) < maxProbAccounts;
|
|
|
|
@override
|
|
String? get seed => _mnemonic;
|
|
|
|
@override
|
|
WalletKeysData get walletKeysData =>
|
|
WalletKeysData(mnemonic: _mnemonic, xPub: xpub, passphrase: passphrase);
|
|
|
|
@override
|
|
String get password => _password;
|
|
|
|
BasedUtxoNetwork network;
|
|
|
|
@override
|
|
bool isTestnet;
|
|
|
|
@override
|
|
bool get hasSilentPaymentsScanning => type == WalletType.bitcoin && keys.privateKey.isNotEmpty;
|
|
|
|
@override
|
|
bool get hasAccountsSupport =>
|
|
type == WalletType.bitcoin &&
|
|
isSoftwareWallet &&
|
|
_masterHD != null && // xpub / watch-only: can't derive other (hardened) accounts
|
|
derivationInfo.derivationType != DerivationType.electrum;
|
|
|
|
@observable
|
|
bool nodeSupportsSilentPayments = true;
|
|
@observable
|
|
bool silentPaymentsScanningActive = false;
|
|
|
|
bool _isTryingToConnect = false;
|
|
bool? _isBatchSupported;
|
|
DateTime? _syncBenchmarkStartTime;
|
|
DateTime? _syncStartedAt;
|
|
|
|
static const Duration maxSyncDuration = Duration(minutes: 2);
|
|
|
|
Completer<SharedPreferences> sharedPrefs = Completer();
|
|
|
|
Future<bool> checkIfMempoolAPIIsEnabled() async {
|
|
bool isMempoolAPIEnabled = (await sharedPrefs.future).getBool("use_mempool_fee_api") ?? true;
|
|
return isMempoolAPIEnabled;
|
|
}
|
|
|
|
@action
|
|
Future<void> setSilentPaymentsScanning(bool active) async {
|
|
silentPaymentsScanningActive = active;
|
|
|
|
if (active) {
|
|
syncStatus = AttemptingScanSyncStatus();
|
|
|
|
final tip = await getUpdatedChainTip();
|
|
|
|
if (tip == walletInfo.restoreHeight) {
|
|
syncStatus = SyncedTipSyncStatus(tip);
|
|
return;
|
|
}
|
|
|
|
if (tip > walletInfo.restoreHeight) {
|
|
_setListeners(walletInfo.restoreHeight, chainTipParam: currentChainTip);
|
|
}
|
|
} else {
|
|
alwaysScan = false;
|
|
|
|
_isolate?.then((value) => value.kill(priority: Isolate.immediate));
|
|
|
|
if (electrumClient.isConnected) {
|
|
if (!_isSyncing) syncStatus = SyncedSyncStatus();
|
|
} else {
|
|
syncStatus = NotConnectedSyncStatus();
|
|
}
|
|
}
|
|
}
|
|
|
|
int? currentChainTip;
|
|
|
|
Future<int> getCurrentChainTip() async {
|
|
if ((currentChainTip ?? 0) > 0) {
|
|
return currentChainTip!;
|
|
}
|
|
currentChainTip = await electrumClient.getCurrentBlockChainTip() ?? 0;
|
|
|
|
return currentChainTip!;
|
|
}
|
|
|
|
Future<int> getUpdatedChainTip() async {
|
|
final newTip = await electrumClient.getCurrentBlockChainTip();
|
|
if (newTip != null && newTip > (currentChainTip ?? 0)) {
|
|
currentChainTip = newTip;
|
|
}
|
|
return currentChainTip ?? 0;
|
|
}
|
|
|
|
/// Anti-fee-sniping locktime (current tip, exact-tip), LE-encoded for
|
|
/// `BitcoinTransactionBuilder`.
|
|
Future<List<int>> _antiFeeSnipingLocktime() async {
|
|
return locktimeToBytes(antiFeeSnipingLocktime(
|
|
chainTip: await getCurrentChainTip(),
|
|
synced: syncStatus is SyncedSyncStatus,
|
|
));
|
|
}
|
|
|
|
@override
|
|
BitcoinWalletKeys get keys {
|
|
String? wif;
|
|
String? privateKey;
|
|
String? publicKey;
|
|
|
|
// `keys` is wallet-level metadata
|
|
final hd =
|
|
mainHdByTypeAndAccount[0]?[SegwitAddresType.p2wpkh] ?? mainHd;
|
|
|
|
try {
|
|
wif = WifEncoder.encode(hd.privateKey.raw, netVer: network.wifNetVer);
|
|
} catch (_) {}
|
|
try {
|
|
privateKey = hd.privateKey.toHex();
|
|
} catch (_) {}
|
|
try {
|
|
publicKey = hd.publicKey.toHex();
|
|
} catch (_) {}
|
|
|
|
return BitcoinWalletKeys(
|
|
wif: wif ?? '',
|
|
privateKey: privateKey ?? '',
|
|
publicKey: publicKey ?? '',
|
|
xpub: xpub,
|
|
masterFingerprint: _masterHD?.fingerPrint.toHex() ?? '',
|
|
);
|
|
}
|
|
|
|
String _password;
|
|
List<BitcoinUnspent> unspentCoins;
|
|
List<int> _feeRates;
|
|
|
|
// ignore: prefer_final_fields
|
|
Map<String, BehaviorSubject<Object>?> _scripthashesUpdateSubject;
|
|
|
|
// ignore: prefer_final_fields
|
|
BehaviorSubject<Object>? _chainTipUpdateSubject;
|
|
bool _isTransactionUpdating;
|
|
Future<Isolate>? _isolate;
|
|
|
|
final Map<String, Map<String, dynamic>> _missingHistoryQueue = {};
|
|
|
|
Future<void>? _resolveMissingHistoryFuture;
|
|
final Map<String, int> _unresolvedAccountRetryCount = {};
|
|
static const int _maxUnresolvedAccountRetries = 3;
|
|
|
|
void Function(FlutterErrorDetails)? _onError;
|
|
Timer? _autoSaveTimer;
|
|
StreamSubscription<dynamic>? _receiveStream;
|
|
Timer? _updateFeeRateTimer;
|
|
static const int _autoSaveInterval = 1;
|
|
|
|
Future<void> init() async {
|
|
final accountIndexes = await loadAccountIndexes();
|
|
|
|
for (final accountIndex in accountIndexes) {
|
|
_prepareHdForAccount(accountIndex, currency);
|
|
}
|
|
|
|
await walletAddresses.init(accountIndexes: accountIndexes);
|
|
await transactionHistory.init();
|
|
await cleanUpDuplicateUnspentCoins();
|
|
_seedAccountBalancesFromAddressRecords();
|
|
await save();
|
|
|
|
_autoSaveTimer =
|
|
Timer.periodic(Duration(minutes: _autoSaveInterval), (_) async => await save());
|
|
}
|
|
|
|
@action
|
|
Future<void> _setListeners(int height,
|
|
{int? chainTipParam, bool? doSingleScan, List<int>? rescanHeights}) async {
|
|
if (this is! BitcoinWallet) return;
|
|
if (isHardwareWallet) return;
|
|
if (seed?.isEmpty ?? true) return;
|
|
|
|
final chainTip = chainTipParam ?? await getUpdatedChainTip();
|
|
final shouldUpdateSyncStatus = rescanHeights == null || rescanHeights.isEmpty;
|
|
|
|
if (chainTip == height) {
|
|
syncStatus = SyncedSyncStatus();
|
|
return;
|
|
}
|
|
|
|
if (shouldUpdateSyncStatus) syncStatus = AttemptingScanSyncStatus();
|
|
|
|
if (_isolate != null) {
|
|
final runningIsolate = await _isolate!;
|
|
runningIsolate.kill(priority: Isolate.immediate);
|
|
}
|
|
|
|
final appDir = await getAppDir();
|
|
String debugLogPath = "${appDir.path}/logs/debug.log";
|
|
|
|
final receivePort = ReceivePort();
|
|
_isolate = Isolate.spawn(
|
|
_handleScanSilentPayments,
|
|
ScanData(
|
|
sendPort: receivePort.sendPort,
|
|
silentAddress: walletAddresses.silentAddress!,
|
|
masterHD: _masterHD!,
|
|
network: network,
|
|
height: height,
|
|
chainTip: chainTip,
|
|
electrumClient: electrum.ElectrumClient(),
|
|
transactionHistoryIds: transactionHistory.transactions.keys.toList(),
|
|
node: (await getNodeSupportsSilentPayments()) == true
|
|
? ScanNode(node!.uri, node!.useSSL)
|
|
: null,
|
|
labels: walletAddresses.labels,
|
|
labelIndexes: walletAddresses.silentAddresses
|
|
.where((addr) => addr.type == SilentPaymentsAddresType.p2sp && addr.index >= 1)
|
|
.map((addr) => addr.index)
|
|
.toList(),
|
|
isSingleScan: doSingleScan ?? false,
|
|
debugLogPath: debugLogPath,
|
|
rescanHeights: rescanHeights,
|
|
),
|
|
);
|
|
|
|
await _receiveStream?.cancel();
|
|
_receiveStream = receivePort.listen((var message) async {
|
|
if (message is Map<String, ElectrumTransactionInfo>) {
|
|
for (final map in message.entries) {
|
|
final txid = map.key;
|
|
final tx = map.value;
|
|
|
|
if (tx.unspents != null) {
|
|
final existingTxInfo = transactionHistory.transactions[txid];
|
|
final txAlreadyExisted = existingTxInfo != null;
|
|
|
|
// Updating tx after re-scanned
|
|
if (txAlreadyExisted) {
|
|
existingTxInfo.amount = tx.amount;
|
|
existingTxInfo.confirmations = tx.confirmations;
|
|
existingTxInfo.height = tx.height;
|
|
existingTxInfo.date = tx.date;
|
|
existingTxInfo.isReceivedSilentPayment = tx.isReceivedSilentPayment;
|
|
existingTxInfo.direction = tx.direction;
|
|
existingTxInfo.isPending = tx.isPending;
|
|
existingTxInfo.unspents = tx.unspents;
|
|
|
|
final newUnspents = tx.unspents!
|
|
.where((unspent) => !(existingTxInfo.unspents?.any((element) =>
|
|
element.hash.contains(unspent.hash) &&
|
|
element.vout == unspent.vout &&
|
|
element.value == unspent.value) ??
|
|
false))
|
|
.toList();
|
|
|
|
if (newUnspents.isNotEmpty) {
|
|
newUnspents.forEach(_updateSilentAddressRecord);
|
|
|
|
existingTxInfo.unspents ??= [];
|
|
existingTxInfo.unspents!.addAll(newUnspents);
|
|
|
|
final newAmount = newUnspents.length > 1
|
|
? newUnspents.map((e) => e.value).reduce((value, unspent) => value + unspent)
|
|
: newUnspents[0].value;
|
|
|
|
if (existingTxInfo.direction == TransactionDirection.incoming) {
|
|
existingTxInfo.amount += Money.fromInt(newAmount, currency);
|
|
}
|
|
|
|
// Updates existing TX
|
|
transactionHistory.addOne(existingTxInfo);
|
|
// Update balance record
|
|
balance[currency]!.confirmed += Money.fromInt(newAmount, currency);
|
|
}
|
|
} else {
|
|
// else: First time seeing this TX after scanning
|
|
tx.unspents!.forEach(_updateSilentAddressRecord);
|
|
|
|
// Add new TX record
|
|
transactionHistory.addMany(message);
|
|
|
|
// Update balance record
|
|
balance[currency]!.confirmed += tx.amount;
|
|
|
|
await save();
|
|
}
|
|
|
|
await updateAllUnspents();
|
|
}
|
|
}
|
|
}
|
|
|
|
if (message is SyncResponse) {
|
|
if (message.syncStatus is UnsupportedSyncStatus) {
|
|
nodeSupportsSilentPayments = false;
|
|
}
|
|
|
|
if (message.syncStatus is SyncingSyncStatus) {
|
|
var status = message.syncStatus as SyncingSyncStatus;
|
|
if (shouldUpdateSyncStatus) syncStatus = SyncingSyncStatus(status.blocksLeft, status.ptc);
|
|
} else {
|
|
if (shouldUpdateSyncStatus) syncStatus = message.syncStatus;
|
|
}
|
|
|
|
await walletInfo.updateRestoreHeight(message.height);
|
|
}
|
|
});
|
|
}
|
|
|
|
void _updateSilentAddressRecord(BitcoinSilentPaymentsUnspent unspent) {
|
|
final silentAddress = walletAddresses.silentAddress!;
|
|
final silentPaymentAddress = SilentPaymentAddress(
|
|
version: silentAddress.version,
|
|
B_scan: silentAddress.B_scan,
|
|
B_spend: unspent.silentPaymentLabel != null
|
|
? silentAddress.B_spend.tweakAdd(
|
|
BigintUtils.fromBytes(BytesUtils.fromHexString(unspent.silentPaymentLabel!)),
|
|
)
|
|
: silentAddress.B_spend,
|
|
);
|
|
|
|
final addressRecord = walletAddresses.silentAddresses
|
|
.firstWhereOrNull((address) => address.address == silentPaymentAddress.toString());
|
|
addressRecord?.txCount += 1;
|
|
addressRecord?.balance += unspent.value;
|
|
|
|
walletAddresses.addSilentAddresses(
|
|
[unspent.bitcoinAddressRecord as BitcoinSilentPaymentAddressRecord],
|
|
);
|
|
}
|
|
|
|
DateTime? _lastSilentPaymentsScan;
|
|
static const Duration _silentPaymentsScanDelay = Duration(minutes: 1);
|
|
|
|
Iterable<BitcoinUnspent> get unspentCoinsForCurrentAccount {
|
|
if (type != WalletType.bitcoin) {
|
|
return unspentCoins;
|
|
}
|
|
|
|
return unspentCoins
|
|
.where((coin) => coin.bitcoinAddressRecord.accountIndex == currentAccountIndex);
|
|
}
|
|
|
|
@action
|
|
@override
|
|
Future<void> startSync() async {
|
|
if (_isSyncing) {
|
|
final startedAt = _syncStartedAt;
|
|
if (startedAt != null && DateTime.now().difference(startedAt) > maxSyncDuration) {
|
|
printV('startSync: previous sync appears stuck, allowing a new one');
|
|
_isSyncing = false;
|
|
} else {
|
|
printV('startSync: already syncing, skipping');
|
|
return;
|
|
}
|
|
}
|
|
|
|
_isSyncing = true;
|
|
_syncStartedAt = DateTime.now();
|
|
try {
|
|
if (_syncBenchmarkStartTime == null) {
|
|
_syncBenchmarkStartTime = DateTime.now();
|
|
printV('[ELECTRUM_WALLET SYNC] Starting: ${_syncBenchmarkStartTime!}');
|
|
}
|
|
|
|
syncStatus = SyncronizingSyncStatus();
|
|
|
|
if (hasSilentPaymentsScanning) {
|
|
silentPaymentsScanningActive = alwaysScan ?? false;
|
|
await _setInitialHeight();
|
|
|
|
final now = DateTime.now();
|
|
final shouldForceRescan = _lastSilentPaymentsScan == null ||
|
|
now.difference(_lastSilentPaymentsScan!) >= _silentPaymentsScanDelay;
|
|
|
|
// Timer prevents server failure and this infinite looping and requesting
|
|
if (shouldForceRescan) {
|
|
_lastSilentPaymentsScan = now;
|
|
|
|
final rescanHeights = <int>[];
|
|
|
|
transactionHistory.transactions.values.forEach((tx) {
|
|
if (tx.unspents != null && tx.unspents!.isNotEmpty)
|
|
for (final unspent in tx.unspents!) {
|
|
if (unspent.silentPaymentTweak != null && tx.height != null && tx.height! > 0) {
|
|
rescanHeights.add(tx.height!);
|
|
break;
|
|
}
|
|
}
|
|
});
|
|
|
|
if (rescanHeights.isNotEmpty)
|
|
_setListeners(walletInfo.restoreHeight, rescanHeights: rescanHeights);
|
|
}
|
|
}
|
|
|
|
await subscribeForUpdates();
|
|
await checkIfBatchSupported();
|
|
await updateTransactions();
|
|
|
|
await updateAllUnspents();
|
|
await updateBalance();
|
|
|
|
if (alwaysScan == true) {
|
|
setSilentPaymentsScanning(true);
|
|
} else if (syncStatus is LostConnectionSyncStatus) {
|
|
_syncBenchmarkStartTime = null;
|
|
} else {
|
|
final syncEnd = DateTime.now();
|
|
final totalMs = _syncBenchmarkStartTime != null
|
|
? syncEnd.difference(_syncBenchmarkStartTime!).inMilliseconds
|
|
: 0;
|
|
|
|
printV('[ELECTRUM_WALLET SYNC] Finished: $syncEnd, took ${totalMs} ms');
|
|
|
|
_syncBenchmarkStartTime = null;
|
|
syncStatus = SyncedSyncStatus();
|
|
}
|
|
|
|
await updateFeeRates();
|
|
|
|
_updateFeeRateTimer ??=
|
|
Timer.periodic(const Duration(minutes: 1), (timer) async => await updateFeeRates());
|
|
|
|
unawaited(resolveQueuedTransactionDetails());
|
|
} catch (e, stacktrace) {
|
|
final syncEnd = DateTime.now();
|
|
final totalMs = _syncBenchmarkStartTime != null
|
|
? syncEnd.difference(_syncBenchmarkStartTime!).inMilliseconds
|
|
: 0;
|
|
|
|
printV(stacktrace);
|
|
printV("startSync $e");
|
|
printV('[ELECTRUM_WALLET SYNC] Finished: $syncEnd, took ${totalMs} ms');
|
|
|
|
_syncBenchmarkStartTime = null;
|
|
syncStatus = FailedSyncStatus();
|
|
} finally {
|
|
_isSyncing = false;
|
|
}
|
|
}
|
|
|
|
static bool _isValidFeeRates(List<int> feeRates) =>
|
|
feeRates.length == 3 && feeRates.every((rate) => rate > 0);
|
|
|
|
@action
|
|
Future<void> updateFeeRates() async {
|
|
if (await checkIfMempoolAPIIsEnabled() && type == WalletType.bitcoin) {
|
|
try {
|
|
final response = await ProxyWrapper()
|
|
.get(
|
|
clearnetUri: Uri.parse("https://mempool.cakewallet.com/api/v1/fees/recommended"),
|
|
onionUri: Uri.parse(
|
|
"http://cakememcninjdqbaub3tp2iswuigxqtdoevnpgzkolmy4gvhrrsub3yd.onion/api/v1/fees/recommended"),
|
|
)
|
|
.timeout(Duration(seconds: 15));
|
|
|
|
final result = json.decode(response.body) as Map<String, dynamic>;
|
|
final slowFee = (result['economyFee'] as num?)?.toInt() ?? 0;
|
|
int mediumFee = (result['hourFee'] as num?)?.toInt() ?? 0;
|
|
int fastFee = (result['fastestFee'] as num?)?.toInt() ?? 0;
|
|
if (slowFee == mediumFee) {
|
|
mediumFee++;
|
|
}
|
|
while (fastFee <= mediumFee) {
|
|
fastFee++;
|
|
}
|
|
_feeRates = [slowFee, mediumFee, fastFee];
|
|
return;
|
|
} catch (e) {
|
|
printV(e);
|
|
}
|
|
}
|
|
|
|
final feeRates = await electrumClient.feeRates(network: network);
|
|
if (_isValidFeeRates(feeRates)) {
|
|
_feeRates = feeRates;
|
|
} else if (isTestnet) {
|
|
_feeRates = [1, 1, 1];
|
|
}
|
|
}
|
|
|
|
Node? node;
|
|
|
|
Future<bool> getNodeIsElectrs() async {
|
|
if (node == null) {
|
|
return false;
|
|
}
|
|
|
|
final version = await electrumClient.version();
|
|
|
|
if (version.isNotEmpty) {
|
|
final server = version[0];
|
|
|
|
if (server.toLowerCase().contains('electrs')) {
|
|
node!.isElectrs = true;
|
|
// TODO figure out why condition was needed
|
|
// if (node!.isInBox) {
|
|
node!.save();
|
|
// }
|
|
return node!.isElectrs!;
|
|
}
|
|
}
|
|
|
|
node!.isElectrs = false;
|
|
return node!.isElectrs!;
|
|
}
|
|
|
|
Future<bool> getNodeSupportsSilentPayments() async {
|
|
// As of today (august 2024), only ElectrumRS supports silent payments
|
|
if (!(await getNodeIsElectrs())) {
|
|
return false;
|
|
}
|
|
|
|
if (node == null) {
|
|
return false;
|
|
}
|
|
|
|
try {
|
|
final tweaksResponse = await electrumClient.getTweaks(height: 0);
|
|
|
|
if (tweaksResponse != null) {
|
|
node!.supportsSilentPayments = true;
|
|
node!.save();
|
|
return node!.supportsSilentPayments!;
|
|
}
|
|
} on electrum.RequestFailedTimeoutException catch (_) {
|
|
node!.supportsSilentPayments = false;
|
|
node!.save();
|
|
return node!.supportsSilentPayments!;
|
|
} catch (_) {}
|
|
|
|
node!.supportsSilentPayments = false;
|
|
node!.save();
|
|
return node!.supportsSilentPayments!;
|
|
}
|
|
|
|
@action
|
|
@override
|
|
Future<void> connectToNode({required Node node}) async {
|
|
this.node = node;
|
|
_isBatchSupported = null;
|
|
|
|
if (syncStatus is ConnectingSyncStatus) return;
|
|
|
|
try {
|
|
syncStatus = ConnectingSyncStatus();
|
|
|
|
await _receiveStream?.cancel();
|
|
await electrumClient.close();
|
|
_isBatchSupported = null;
|
|
|
|
electrumClient.onConnectionStatusChange = _onConnectionStatusChange;
|
|
|
|
await electrumClient.connectToUri(node.uri, useSSL: node.useSSL);
|
|
} catch (e, stacktrace) {
|
|
printV(stacktrace);
|
|
printV("connectToNode $e");
|
|
syncStatus = FailedSyncStatus();
|
|
}
|
|
}
|
|
|
|
BigInt get networkDustAmount => BigInt.from(546);
|
|
|
|
bool _isBelowDust(BigInt amount) =>
|
|
amount <= networkDustAmount && network != BitcoinNetwork.testnet;
|
|
|
|
// Random draw priority per outpoint. Assigned lazily with a secure RNG and kept
|
|
// until the next createTransaction call, so the recursive estimate passes of one
|
|
// transaction build all see the same input order (reshuffling between passes made
|
|
// fee estimation unstable). Cleared per transaction so each send is a fresh draw.
|
|
final Random _coinSelectionRng = Random.secure();
|
|
final Map<String, int> _coinSelectionOrder = {};
|
|
|
|
int _coinSelectionPriority(BitcoinUnspent utx) => _coinSelectionOrder.putIfAbsent(
|
|
'${utx.hash}:${utx.vout}', () => _coinSelectionRng.nextInt(1 << 32));
|
|
|
|
UtxoDetails _createUTXOS({
|
|
required bool sendAll,
|
|
required bool paysToSilentPayment,
|
|
int credentialsAmount = 0,
|
|
int? inputsCount,
|
|
int feeRate = 0,
|
|
int? outputsVBytes,
|
|
UnspentCoinType coinTypeToSpendFrom = UnspentCoinType.any,
|
|
}) {
|
|
List<UtxoWithAddress> utxos = [];
|
|
List<Outpoint> vinOutpoints = [];
|
|
List<ECPrivateInfo> inputPrivKeyInfos = [];
|
|
final publicKeys = <String, PublicKeyWithDerivationPath>{};
|
|
int allInputsAmount = 0;
|
|
bool spendsSilentPayment = false;
|
|
bool spendsUnconfirmedTX = false;
|
|
|
|
int leftAmount = credentialsAmount;
|
|
var availableInputs = unspentCoinsForCurrentAccount.where((utx) {
|
|
if (!utx.isSending || utx.isFrozen) {
|
|
return false;
|
|
}
|
|
|
|
switch (coinTypeToSpendFrom) {
|
|
case UnspentCoinType.mweb:
|
|
return utx.bitcoinAddressRecord.type == SegwitAddresType.mweb;
|
|
case UnspentCoinType.nonMweb:
|
|
return utx.bitcoinAddressRecord.type != SegwitAddresType.mweb;
|
|
case UnspentCoinType.any:
|
|
case UnspentCoinType.lightning:
|
|
return true;
|
|
}
|
|
}).toList();
|
|
final unconfirmedCoins = availableInputs.where((utx) => utx.confirmations == 0).toList();
|
|
|
|
// Single Random Draw: order the pool by each coin's random priority so selection is
|
|
// non-deterministic, removing the predictable address/scan order (a fingerprint).
|
|
// The priority is stable across the repeated calls of one transaction build.
|
|
// MWEB coins are kept last afterwards.
|
|
availableInputs.sort((a, b) {
|
|
final byPriority = _coinSelectionPriority(a).compareTo(_coinSelectionPriority(b));
|
|
if (byPriority != 0) return byPriority;
|
|
return '${a.hash}:${a.vout}'.compareTo('${b.hash}:${b.vout}');
|
|
});
|
|
availableInputs = [
|
|
...availableInputs.where((u) => u.bitcoinAddressRecord.type != SegwitAddresType.mweb),
|
|
...availableInputs.where((u) => u.bitcoinAddressRecord.type == SegwitAddresType.mweb),
|
|
];
|
|
|
|
// Branch-and-bound: prefer an input set whose excess over the amount plus its own fee
|
|
// stays below dust, so the caller drops the change output and the send is changeless.
|
|
// When no such set exists, the shuffled pool below acts as a single random draw.
|
|
final canTryChangeless = !sendAll &&
|
|
inputsCount == null &&
|
|
credentialsAmount > 0 &&
|
|
feeRate > 0 &&
|
|
outputsVBytes != null &&
|
|
outputsVBytes > 0 &&
|
|
!availableInputs.any((u) => u.bitcoinAddressRecord.type == SegwitAddresType.mweb);
|
|
if (canTryChangeless) {
|
|
final match = changelessMatch(
|
|
values: [for (final u in availableInputs) u.value],
|
|
// estimatedTransactionSize(0, 0) is the fixed tx overhead (version,
|
|
// counters, locktime); the outputs' own vbytes come pre-computed per type.
|
|
target: credentialsAmount + (estimatedTransactionSize(0, 0) + outputsVBytes!) * feeRate,
|
|
inputCosts: [
|
|
for (final u in availableInputs)
|
|
estimatedInputSize(u.bitcoinAddressRecord.type) * feeRate
|
|
],
|
|
window: networkDustAmount.toInt(),
|
|
);
|
|
if (match != null) {
|
|
final chosen = match.indices.toSet();
|
|
availableInputs = [
|
|
for (final i in match.indices) availableInputs[i],
|
|
for (var i = 0; i < availableInputs.length; i++)
|
|
if (!chosen.contains(i)) availableInputs[i],
|
|
];
|
|
inputsCount = match.indices.length;
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < availableInputs.length; i++) {
|
|
final utx = availableInputs[i];
|
|
if (!spendsUnconfirmedTX) spendsUnconfirmedTX = utx.confirmations == 0;
|
|
|
|
if (paysToSilentPayment) {
|
|
// Check inputs for shared secret derivation
|
|
if (utx.bitcoinAddressRecord.type == SegwitAddresType.p2wsh) {
|
|
throw BitcoinTransactionSilentPaymentsNotSupported();
|
|
}
|
|
}
|
|
|
|
allInputsAmount += utx.value;
|
|
leftAmount = leftAmount - utx.value;
|
|
|
|
final address = RegexUtils.addressTypeFromStr(utx.address, network);
|
|
ECPrivate? privkey;
|
|
bool? isSilentPayment = false;
|
|
final hd = _hdForAddressRecord(record: utx.bitcoinAddressRecord);
|
|
|
|
if (utx.bitcoinAddressRecord is BitcoinSilentPaymentAddressRecord) {
|
|
final unspentAddress = utx.bitcoinAddressRecord as BitcoinSilentPaymentAddressRecord;
|
|
privkey = ECPrivate.fromHex(
|
|
_masterHD!.derivePath(unspentAddress.spendDerivationPath).privateKey.toHex())
|
|
.tweakAdd(
|
|
BigintUtils.fromBytes(BytesUtils.fromHexString(unspentAddress.silentPaymentTweak!)),
|
|
);
|
|
spendsSilentPayment = true;
|
|
isSilentPayment = true;
|
|
} else if (!isHardwareWallet && keys.privateKey.isNotEmpty) {
|
|
privkey =
|
|
generateECPrivate(hd: hd, index: utx.bitcoinAddressRecord.index, network: network);
|
|
}
|
|
|
|
vinOutpoints.add(Outpoint(txid: utx.hash, index: utx.vout));
|
|
String pubKeyHex;
|
|
|
|
if (privkey != null) {
|
|
inputPrivKeyInfos.add(ECPrivateInfo(
|
|
privkey,
|
|
address.type == SegwitAddresType.p2tr,
|
|
tweak: !isSilentPayment,
|
|
));
|
|
|
|
pubKeyHex = privkey.getPublic().toHex();
|
|
} else {
|
|
pubKeyHex = hd.childKey(Bip32KeyIndex(utx.bitcoinAddressRecord.index)).publicKey.toHex();
|
|
}
|
|
|
|
final baseDerivationPath = _accountDerivationPathForRecord(utx.bitcoinAddressRecord);
|
|
|
|
final derivationPath = "${_hardenedDerivationPath(baseDerivationPath)}"
|
|
"/${utx.bitcoinAddressRecord.isHidden ? "1" : "0"}"
|
|
"/${utx.bitcoinAddressRecord.index}";
|
|
publicKeys[address.pubKeyHash()] = PublicKeyWithDerivationPath(pubKeyHex, derivationPath);
|
|
|
|
utxos.add(
|
|
UtxoWithAddress(
|
|
utxo: BitcoinUtxo(
|
|
txHash: utx.hash,
|
|
value: BigInt.from(utx.value),
|
|
vout: utx.vout,
|
|
scriptType: _getScriptType(address),
|
|
isSilentPayment: isSilentPayment,
|
|
),
|
|
ownerDetails: UtxoAddressDetails(
|
|
publicKey: pubKeyHex,
|
|
address: address,
|
|
),
|
|
),
|
|
);
|
|
|
|
// sendAll continues for all inputs
|
|
if (!sendAll) {
|
|
bool amountIsAcquired = leftAmount <= 0;
|
|
if ((inputsCount == null && amountIsAcquired) || inputsCount == i + 1) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (utxos.isEmpty) {
|
|
throw BitcoinTransactionNoInputsException();
|
|
}
|
|
|
|
return UtxoDetails(
|
|
availableInputs: availableInputs,
|
|
unconfirmedCoins: unconfirmedCoins,
|
|
utxos: utxos,
|
|
vinOutpoints: vinOutpoints,
|
|
inputPrivKeyInfos: inputPrivKeyInfos,
|
|
publicKeys: publicKeys,
|
|
allInputsAmount: allInputsAmount,
|
|
spendsSilentPayment: spendsSilentPayment,
|
|
spendsUnconfirmedTX: spendsUnconfirmedTX,
|
|
);
|
|
}
|
|
|
|
Future<EstimatedTxResult> estimateSendAllTx(
|
|
List<BitcoinOutput> outputs,
|
|
int feeRate, {
|
|
String? memo,
|
|
bool hasSilentPayment = false,
|
|
UnspentCoinType coinTypeToSpendFrom = UnspentCoinType.any,
|
|
}) async {
|
|
final utxoDetails = _createUTXOS(
|
|
sendAll: true,
|
|
paysToSilentPayment: hasSilentPayment,
|
|
coinTypeToSpendFrom: coinTypeToSpendFrom,
|
|
);
|
|
|
|
int fee = await calcFee(
|
|
utxos: utxoDetails.utxos,
|
|
outputs: outputs,
|
|
network: network,
|
|
memo: memo,
|
|
feeRate: feeRate,
|
|
inputPrivKeyInfos: utxoDetails.inputPrivKeyInfos,
|
|
vinOutpoints: utxoDetails.vinOutpoints,
|
|
);
|
|
|
|
if (fee <= 0) {
|
|
throw BitcoinTransactionNoFeeException();
|
|
}
|
|
|
|
// Here, when sending all, the output amount equals to the input value - fee to fully spend every input on the transaction and have no amount left for change
|
|
final amount = BigInt.from(utxoDetails.allInputsAmount - fee);
|
|
|
|
if (amount <= BigInt.zero) {
|
|
throw BitcoinTransactionWrongBalanceException(amount: utxoDetails.allInputsAmount + fee);
|
|
}
|
|
|
|
// Attempting to send less than the dust limit
|
|
if (_isBelowDust(amount)) {
|
|
throw BitcoinTransactionNoDustException();
|
|
}
|
|
|
|
if (outputs.length == 1) {
|
|
outputs[0] = BitcoinOutput(
|
|
address: outputs.last.address,
|
|
value: amount,
|
|
isSilentPayment: hasSilentPayment,
|
|
);
|
|
}
|
|
|
|
return EstimatedTxResult(
|
|
utxos: utxoDetails.utxos,
|
|
inputPrivKeyInfos: utxoDetails.inputPrivKeyInfos,
|
|
publicKeys: utxoDetails.publicKeys,
|
|
fee: Money.fromInt(fee, currency),
|
|
amount: Money(amount, currency),
|
|
isSendAll: true,
|
|
hasChange: false,
|
|
memo: memo,
|
|
spendsUnconfirmedTX: utxoDetails.spendsUnconfirmedTX,
|
|
spendsSilentPayment: utxoDetails.spendsSilentPayment,
|
|
);
|
|
}
|
|
|
|
Future<EstimatedTxResult> estimateTxForAmount(
|
|
Money credentialsAmount,
|
|
List<BitcoinOutput> outputs,
|
|
List<BitcoinOutput> updatedOutputs,
|
|
int feeRate, {
|
|
int? inputsCount,
|
|
String? memo,
|
|
bool? useUnconfirmed,
|
|
bool hasSilentPayment = false,
|
|
UnspentCoinType coinTypeToSpendFrom = UnspentCoinType.any,
|
|
}) async {
|
|
// Attempting to send less than the dust limit
|
|
if (_isBelowDust(credentialsAmount.amount)) {
|
|
throw BitcoinTransactionNoDustException();
|
|
}
|
|
|
|
// if mweb isn't enabled, don't consider spending mweb coins:
|
|
if (this is LitecoinWallet) {
|
|
var mwebEnabled = (this as LitecoinWallet).mwebEnabled;
|
|
if (!mwebEnabled) {
|
|
coinTypeToSpendFrom = UnspentCoinType.nonMweb;
|
|
}
|
|
}
|
|
|
|
// If there is only one output, and the amount to send is more than the max spendable amount
|
|
// then it is actually a send all transaction
|
|
|
|
if (outputs.length == 1) {
|
|
final maxSpendable = await _maxSpendableNoChangeAmount(
|
|
initialOutput: outputs.first,
|
|
feeRate: feeRate,
|
|
memo: memo,
|
|
hasSilentPayment: hasSilentPayment,
|
|
coinTypeToSpendFrom: coinTypeToSpendFrom,
|
|
);
|
|
if (credentialsAmount > maxSpendable) {
|
|
throw BitcoinTransactionWrongBalanceException();
|
|
}
|
|
if (credentialsAmount >= maxSpendable) {
|
|
final estimateOutput = [
|
|
BitcoinOutput(
|
|
address: outputs.first.address,
|
|
value: BigInt.zero,
|
|
isSilentPayment: outputs.first.isSilentPayment,
|
|
)
|
|
];
|
|
return estimateSendAllTx(
|
|
estimateOutput,
|
|
feeRate,
|
|
memo: memo,
|
|
hasSilentPayment: hasSilentPayment,
|
|
coinTypeToSpendFrom: coinTypeToSpendFrom,
|
|
);
|
|
}
|
|
}
|
|
|
|
// Per-type output sizes for the changeless target. MWEB outputs follow a
|
|
// different size model entirely, so they disable the changeless path (null).
|
|
int? outputsVBytes = 0;
|
|
for (final out in outputs) {
|
|
final type =
|
|
out.isSilentPayment == true ? SilentPaymentsAddresType.p2sp : _getScriptType(out.address);
|
|
if (type == SegwitAddresType.mweb) {
|
|
outputsVBytes = null;
|
|
break;
|
|
}
|
|
outputsVBytes = outputsVBytes! + estimatedOutputSize(type);
|
|
}
|
|
|
|
final utxoDetails = _createUTXOS(
|
|
sendAll: false,
|
|
credentialsAmount: credentialsAmount.amount.toInt(),
|
|
inputsCount: inputsCount,
|
|
feeRate: feeRate,
|
|
outputsVBytes: outputsVBytes,
|
|
paysToSilentPayment: hasSilentPayment,
|
|
coinTypeToSpendFrom: coinTypeToSpendFrom,
|
|
);
|
|
|
|
final spendingAllCoins = utxoDetails.availableInputs.length == utxoDetails.utxos.length;
|
|
final spendingAllConfirmedCoins = !utxoDetails.spendsUnconfirmedTX &&
|
|
utxoDetails.utxos.length ==
|
|
utxoDetails.availableInputs.length - utxoDetails.unconfirmedCoins.length;
|
|
|
|
final amountLeftForChangeAndFee =
|
|
utxoDetails.allInputsAmount - credentialsAmount.amount.toInt();
|
|
|
|
if (amountLeftForChangeAndFee <= 0) {
|
|
if (!spendingAllCoins) {
|
|
return estimateTxForAmount(
|
|
credentialsAmount,
|
|
outputs,
|
|
updatedOutputs,
|
|
feeRate,
|
|
inputsCount: utxoDetails.utxos.length + 1,
|
|
memo: memo,
|
|
hasSilentPayment: hasSilentPayment,
|
|
coinTypeToSpendFrom: coinTypeToSpendFrom,
|
|
);
|
|
}
|
|
|
|
throw BitcoinTransactionWrongBalanceException();
|
|
}
|
|
|
|
final changeAddress = await walletAddresses.getChangeAddress(
|
|
inputs: utxoDetails.availableInputs,
|
|
outputs: updatedOutputs,
|
|
coinTypeToSpendFrom: coinTypeToSpendFrom,
|
|
);
|
|
final address = RegexUtils.addressTypeFromStr(changeAddress.address, network);
|
|
updatedOutputs.add(BitcoinOutput(
|
|
address: address,
|
|
value: BigInt.from(amountLeftForChangeAndFee),
|
|
isChange: true,
|
|
));
|
|
outputs.add(BitcoinOutput(
|
|
address: address,
|
|
value: BigInt.from(amountLeftForChangeAndFee),
|
|
isChange: true,
|
|
));
|
|
|
|
// Must match the address' account root (purpose/coinType) and legacy derivation when applicable.
|
|
final changeBaseDerivationPath = _accountDerivationPathForRecord(changeAddress);
|
|
final changeDerivationPath = "${_hardenedDerivationPath(changeBaseDerivationPath)}"
|
|
"/${changeAddress.isHidden ? "1" : "0"}"
|
|
"/${changeAddress.index}";
|
|
final changeHd = _hdForAddressRecord(record: changeAddress).childKey(Bip32KeyIndex(changeAddress.index));
|
|
final changePubKeyHex = changeHd.publicKey.toHex();
|
|
|
|
utxoDetails.publicKeys[address.pubKeyHash()] =
|
|
PublicKeyWithDerivationPath(changePubKeyHex, changeDerivationPath);
|
|
|
|
// calcFee updates the silent payment outputs to calculate the tx size accounting
|
|
// for taproot addresses, but if more inputs are needed to make up for fees,
|
|
// the silent payment outputs need to be recalculated for the new inputs
|
|
var temp = outputs.map((output) => output).toList();
|
|
int fee = await calcFee(
|
|
utxos: utxoDetails.utxos,
|
|
// Always take only not updated bitcoin outputs here so for every estimation
|
|
// the SP outputs are re-generated to the proper taproot addresses
|
|
outputs: temp,
|
|
network: network,
|
|
memo: memo,
|
|
feeRate: feeRate,
|
|
inputPrivKeyInfos: utxoDetails.inputPrivKeyInfos,
|
|
vinOutpoints: utxoDetails.vinOutpoints,
|
|
);
|
|
|
|
updatedOutputs.clear();
|
|
for (int i = 0; i < temp.length; i++) {
|
|
final output = temp[i];
|
|
final oldOutput = outputs[i];
|
|
|
|
updatedOutputs.add(BitcoinOutput(
|
|
address: output.address,
|
|
value: output.value,
|
|
isSilentPayment: oldOutput.isSilentPayment,
|
|
isChange: output.isChange,
|
|
));
|
|
}
|
|
|
|
if (fee <= 0) {
|
|
throw BitcoinTransactionNoFeeException();
|
|
}
|
|
|
|
var amount = credentialsAmount;
|
|
final lastOutput = updatedOutputs.last;
|
|
final amountLeftForChange = BigInt.from(amountLeftForChangeAndFee - fee);
|
|
|
|
if (_isBelowDust(amountLeftForChange)) {
|
|
// If has change that is lower than dust, will end up with tx rejected by network rules
|
|
// so remove the change amount
|
|
updatedOutputs.removeLast();
|
|
outputs.removeLast();
|
|
|
|
// If the computed change is negative or below dust:
|
|
// - negative: try a no-change tx (recalculate fee without change)
|
|
// - non-negative but dust: drop change and add remainder to fee
|
|
if (amountLeftForChange < BigInt.zero) {
|
|
final tempNoChange = outputs.map((o) => o).toList();
|
|
final feeNoChange = await calcFee(
|
|
utxos: utxoDetails.utxos,
|
|
outputs: tempNoChange,
|
|
network: network,
|
|
memo: memo,
|
|
feeRate: feeRate,
|
|
inputPrivKeyInfos: utxoDetails.inputPrivKeyInfos,
|
|
vinOutpoints: utxoDetails.vinOutpoints,
|
|
);
|
|
final leftover =
|
|
utxoDetails.allInputsAmount - credentialsAmount.amount.toInt() - feeNoChange;
|
|
|
|
if (leftover >= 0) {
|
|
final finalFee = feeNoChange + leftover; // absorb tiny remainder
|
|
return EstimatedTxResult(
|
|
utxos: utxoDetails.utxos,
|
|
inputPrivKeyInfos: utxoDetails.inputPrivKeyInfos,
|
|
publicKeys: utxoDetails.publicKeys,
|
|
fee: Money.fromInt(finalFee, currency),
|
|
amount: amount,
|
|
hasChange: false,
|
|
isSendAll: spendingAllCoins,
|
|
memo: memo,
|
|
spendsUnconfirmedTX: utxoDetails.spendsUnconfirmedTX,
|
|
spendsSilentPayment: utxoDetails.spendsSilentPayment,
|
|
);
|
|
}
|
|
|
|
if (!spendingAllCoins) {
|
|
return estimateTxForAmount(
|
|
credentialsAmount,
|
|
outputs,
|
|
updatedOutputs,
|
|
feeRate,
|
|
inputsCount: utxoDetails.utxos.length + 1,
|
|
memo: memo,
|
|
useUnconfirmed: useUnconfirmed ?? spendingAllConfirmedCoins,
|
|
hasSilentPayment: hasSilentPayment,
|
|
coinTypeToSpendFrom: coinTypeToSpendFrom,
|
|
);
|
|
} else {
|
|
throw BitcoinTransactionWrongBalanceException();
|
|
}
|
|
}
|
|
|
|
// if the amount left for change is less than dust, but not less than 0
|
|
// then add it to the fees
|
|
fee += amountLeftForChange.toInt();
|
|
|
|
return EstimatedTxResult(
|
|
utxos: utxoDetails.utxos,
|
|
inputPrivKeyInfos: utxoDetails.inputPrivKeyInfos,
|
|
publicKeys: utxoDetails.publicKeys,
|
|
fee: Money.fromInt(fee, currency),
|
|
amount: amount,
|
|
hasChange: false,
|
|
isSendAll: spendingAllCoins,
|
|
memo: memo,
|
|
spendsUnconfirmedTX: utxoDetails.spendsUnconfirmedTX,
|
|
spendsSilentPayment: utxoDetails.spendsSilentPayment,
|
|
);
|
|
} else {
|
|
// Here, lastOutput already is change, return the amount left without the fee to the user's address.
|
|
updatedOutputs[updatedOutputs.length - 1] = BitcoinOutput(
|
|
address: lastOutput.address,
|
|
value: amountLeftForChange,
|
|
isSilentPayment: lastOutput.isSilentPayment,
|
|
isChange: true,
|
|
);
|
|
outputs[outputs.length - 1] = BitcoinOutput(
|
|
address: lastOutput.address,
|
|
value: amountLeftForChange,
|
|
isSilentPayment: lastOutput.isSilentPayment,
|
|
isChange: true,
|
|
);
|
|
|
|
return EstimatedTxResult(
|
|
utxos: utxoDetails.utxos,
|
|
inputPrivKeyInfos: utxoDetails.inputPrivKeyInfos,
|
|
publicKeys: utxoDetails.publicKeys,
|
|
fee: Money.fromInt(fee, currency),
|
|
amount: amount,
|
|
hasChange: true,
|
|
isSendAll: spendingAllCoins,
|
|
memo: memo,
|
|
spendsUnconfirmedTX: utxoDetails.spendsUnconfirmedTX,
|
|
spendsSilentPayment: utxoDetails.spendsSilentPayment,
|
|
);
|
|
}
|
|
}
|
|
|
|
Future<Money> _maxSpendableNoChangeAmount({
|
|
required BitcoinOutput initialOutput,
|
|
required int feeRate,
|
|
String? memo,
|
|
bool hasSilentPayment = false,
|
|
UnspentCoinType coinTypeToSpendFrom = UnspentCoinType.any,
|
|
}) async {
|
|
final utxoDetailsAll = _createUTXOS(
|
|
sendAll: true,
|
|
paysToSilentPayment: hasSilentPayment,
|
|
coinTypeToSpendFrom: coinTypeToSpendFrom,
|
|
);
|
|
|
|
final output = [
|
|
BitcoinOutput(
|
|
address: initialOutput.address,
|
|
value: BigInt.zero,
|
|
isSilentPayment: initialOutput.isSilentPayment,
|
|
)
|
|
];
|
|
|
|
final feeNoChange = await calcFee(
|
|
utxos: utxoDetailsAll.utxos,
|
|
outputs: output,
|
|
network: network,
|
|
memo: memo,
|
|
feeRate: feeRate,
|
|
inputPrivKeyInfos: utxoDetailsAll.inputPrivKeyInfos,
|
|
vinOutpoints: utxoDetailsAll.vinOutpoints,
|
|
);
|
|
|
|
final maxSpendable = utxoDetailsAll.allInputsAmount - feeNoChange;
|
|
return Money.fromInt(maxSpendable > 0 ? maxSpendable : 0, currency);
|
|
}
|
|
|
|
Future<int> calcFee({
|
|
required List<UtxoWithAddress> utxos,
|
|
required List<BitcoinBaseOutput> outputs,
|
|
required BasedUtxoNetwork network,
|
|
String? memo,
|
|
required int feeRate,
|
|
List<ECPrivateInfo>? inputPrivKeyInfos,
|
|
List<Outpoint>? vinOutpoints,
|
|
}) async {
|
|
int estimatedSize;
|
|
if (network is BitcoinCashNetwork) {
|
|
estimatedSize = ForkedTransactionBuilder.estimateTransactionSize(
|
|
utxos: utxos,
|
|
outputs: outputs,
|
|
network: network,
|
|
memo: memo,
|
|
);
|
|
} else {
|
|
estimatedSize = BitcoinTransactionBuilder.estimateTransactionSize(
|
|
utxos: utxos,
|
|
outputs: outputs,
|
|
network: network,
|
|
memo: memo,
|
|
inputPrivKeyInfos: inputPrivKeyInfos,
|
|
vinOutpoints: vinOutpoints,
|
|
);
|
|
}
|
|
|
|
return feeAmountWithFeeRate(feeRate, 0, 0, size: estimatedSize);
|
|
}
|
|
|
|
@override
|
|
Future<PendingTransaction> createTransaction(Object credentials) async {
|
|
try {
|
|
// New transaction, new random draw: drop the previous input ordering so this
|
|
// build gets fresh priorities, then keep them fixed for all estimate passes.
|
|
_coinSelectionOrder.clear();
|
|
|
|
// start by updating unspent coins
|
|
await updateAllUnspents();
|
|
|
|
final outputs = <BitcoinOutput>[];
|
|
final transactionCredentials = credentials as BitcoinTransactionCredentials;
|
|
final hasMultiDestination = transactionCredentials.outputs.length > 1;
|
|
final sendAll = !hasMultiDestination && transactionCredentials.outputs.first.sendAll;
|
|
final memo = transactionCredentials.outputs.first.memo;
|
|
final coinTypeToSpendFrom = transactionCredentials.coinTypeToSpendFrom;
|
|
|
|
var credentialsAmount = Money.zero(currency);
|
|
var hasSilentPayment = false;
|
|
|
|
for (final out in transactionCredentials.outputs) {
|
|
final outputAmount = out.cryptoAmount;
|
|
|
|
if (!sendAll && _isBelowDust(outputAmount.amount)) {
|
|
throw BitcoinTransactionNoDustException();
|
|
}
|
|
|
|
if (hasMultiDestination) {
|
|
if (out.sendAll) {
|
|
throw BitcoinTransactionWrongBalanceException();
|
|
}
|
|
}
|
|
|
|
credentialsAmount += outputAmount;
|
|
|
|
final address = RegexUtils.addressTypeFromStr(
|
|
out.isParsedAddress ? out.extractedAddress! : out.address, network);
|
|
final isSilentPayment = address is SilentPaymentAddress;
|
|
|
|
if (isSilentPayment) {
|
|
hasSilentPayment = true;
|
|
}
|
|
|
|
if (sendAll) {
|
|
// The value will be changed after estimating the Tx size and deducting the fee from the total to be sent
|
|
outputs.add(BitcoinOutput(
|
|
address: address,
|
|
value: BigInt.zero,
|
|
isSilentPayment: isSilentPayment,
|
|
));
|
|
} else {
|
|
outputs.add(BitcoinOutput(
|
|
address: address,
|
|
value: outputAmount.amount,
|
|
isSilentPayment: isSilentPayment,
|
|
));
|
|
}
|
|
}
|
|
|
|
final feeRateInt = transactionCredentials.feeRate != null
|
|
? transactionCredentials.feeRate!
|
|
: feeRate(transactionCredentials.priority!);
|
|
|
|
EstimatedTxResult estimatedTx;
|
|
final updatedOutputs = outputs
|
|
.map((e) => BitcoinOutput(
|
|
address: e.address,
|
|
value: e.value,
|
|
isSilentPayment: e.isSilentPayment,
|
|
isChange: e.isChange,
|
|
))
|
|
.toList();
|
|
|
|
if (sendAll) {
|
|
estimatedTx = await estimateSendAllTx(
|
|
updatedOutputs,
|
|
feeRateInt,
|
|
memo: memo,
|
|
hasSilentPayment: hasSilentPayment,
|
|
coinTypeToSpendFrom: coinTypeToSpendFrom,
|
|
);
|
|
} else {
|
|
estimatedTx = await estimateTxForAmount(
|
|
credentialsAmount,
|
|
outputs,
|
|
updatedOutputs,
|
|
feeRateInt,
|
|
memo: memo,
|
|
hasSilentPayment: hasSilentPayment,
|
|
coinTypeToSpendFrom: coinTypeToSpendFrom,
|
|
);
|
|
}
|
|
|
|
for (final output in updatedOutputs) {
|
|
// TODO: get from server
|
|
// if (output.isSilentPayment && output.value.toInt() > silentPaymentsMin) {
|
|
if (output.isSilentPayment && output.value.toInt() <= 1000) {
|
|
throw BitcoinTransactionNoDustException();
|
|
}
|
|
}
|
|
|
|
if (walletInfo.isHardwareWallet) {
|
|
final transaction = await buildHardwareWalletTransaction(
|
|
utxos: estimatedTx.utxos,
|
|
outputs: updatedOutputs,
|
|
publicKeys: estimatedTx.publicKeys,
|
|
fee: estimatedTx.fee.amount,
|
|
network: network,
|
|
memo: estimatedTx.memo,
|
|
// Shuffle so the change output isn't placed deterministically last
|
|
// (privacy fingerprint). Applied by orderOutputs in the builder.
|
|
outputOrdering: BitcoinOrdering.shuffle,
|
|
enableRBF: true,
|
|
cwOutputs: transactionCredentials.outputs,
|
|
);
|
|
|
|
return PendingBitcoinTransaction(
|
|
transaction,
|
|
type,
|
|
accountIndex: currentAccountIndex,
|
|
electrumClient: electrumClient,
|
|
amount: estimatedTx.amount,
|
|
fee: estimatedTx.fee,
|
|
feeRate: feeRateInt.toString(),
|
|
network: network,
|
|
hasChange: estimatedTx.hasChange,
|
|
isSendAll: estimatedTx.isSendAll,
|
|
hasTaprootInputs: false,
|
|
// ToDo: (Konsti) Support Taproot,
|
|
isViewOnly: false,
|
|
)..addListener((transaction) async {
|
|
transactionHistory.addOne(transaction);
|
|
await updateAllUnspents();
|
|
await updateBalance();
|
|
});
|
|
}
|
|
|
|
final locktime = await _antiFeeSnipingLocktime();
|
|
|
|
BasedBitcoinTransacationBuilder txb;
|
|
if (network is BitcoinCashNetwork) {
|
|
txb = ForkedTransactionBuilder(
|
|
utxos: estimatedTx.utxos,
|
|
outputs: updatedOutputs,
|
|
fee: estimatedTx.fee.amount,
|
|
network: network,
|
|
memo: estimatedTx.memo,
|
|
// Shuffle so the change output isn't placed deterministically last
|
|
// (privacy fingerprint). Change is found by isChange, not position.
|
|
inputOrdering: BitcoinOrdering.shuffle,
|
|
outputOrdering: BitcoinOrdering.shuffle,
|
|
enableRBF: !estimatedTx.spendsUnconfirmedTX,
|
|
);
|
|
} else {
|
|
txb = BitcoinTransactionBuilder(
|
|
utxos: estimatedTx.utxos,
|
|
outputs: updatedOutputs,
|
|
fee: estimatedTx.fee.amount,
|
|
network: network,
|
|
memo: estimatedTx.memo,
|
|
inputOrdering: BitcoinOrdering.shuffle,
|
|
outputOrdering: BitcoinOrdering.shuffle,
|
|
enableRBF: !estimatedTx.spendsUnconfirmedTX,
|
|
locktime: locktime,
|
|
);
|
|
}
|
|
|
|
bool hasTaprootInputs = false;
|
|
|
|
final transaction = txb.buildTransaction((txDigest, utxo, publicKey, sighash) {
|
|
if (keys.privateKey.isEmpty) return "";
|
|
String error = "Cannot find private key.";
|
|
|
|
ECPrivateInfo? key;
|
|
|
|
if (estimatedTx.inputPrivKeyInfos.isEmpty) {
|
|
error += "\nNo private keys generated.";
|
|
} else {
|
|
error += "\nAddress: ${utxo.ownerDetails.address.toAddress(network)}";
|
|
|
|
key = estimatedTx.inputPrivKeyInfos.firstWhereOrNull((element) {
|
|
final elemPubkey = element.privkey.getPublic().toHex();
|
|
if (elemPubkey == publicKey) {
|
|
return true;
|
|
} else {
|
|
error += "\nExpected: $publicKey";
|
|
error += "\nPubkey: $elemPubkey";
|
|
return false;
|
|
}
|
|
});
|
|
}
|
|
|
|
if (key == null) {
|
|
throw Exception(error);
|
|
}
|
|
|
|
if (utxo.utxo.isP2tr()) {
|
|
hasTaprootInputs = true;
|
|
return key.privkey.signTapRoot(
|
|
txDigest,
|
|
sighash: sighash,
|
|
tweak: utxo.utxo.isSilentPayment != true,
|
|
);
|
|
} else {
|
|
return key.privkey.signInput(txDigest, sigHash: sighash);
|
|
}
|
|
});
|
|
|
|
return PendingBitcoinTransaction(
|
|
transaction,
|
|
type,
|
|
accountIndex: currentAccountIndex,
|
|
electrumClient: electrumClient,
|
|
amount: estimatedTx.amount,
|
|
fee: estimatedTx.fee,
|
|
feeRate: feeRateInt.toString(),
|
|
network: network,
|
|
hasChange: estimatedTx.hasChange,
|
|
isSendAll: estimatedTx.isSendAll,
|
|
hasTaprootInputs: hasTaprootInputs,
|
|
utxos: estimatedTx.utxos,
|
|
derivedOutputs: updatedOutputs,
|
|
publicKeys: estimatedTx.publicKeys,
|
|
isViewOnly: keys.privateKey.isEmpty,
|
|
)..addListener((transaction) async {
|
|
transactionHistory.addOne(transaction);
|
|
if (estimatedTx.spendsSilentPayment) {
|
|
transactionHistory.transactions.values.forEach((tx) {
|
|
tx.unspents?.removeWhere(
|
|
(unspent) => estimatedTx.utxos.any((e) => e.utxo.txHash == unspent.hash));
|
|
transactionHistory.addOne(tx);
|
|
});
|
|
}
|
|
|
|
unspentCoins
|
|
.removeWhere((utxo) => estimatedTx.utxos.any((e) => e.utxo.txHash == utxo.hash));
|
|
|
|
await updateAllUnspents();
|
|
await updateBalance();
|
|
});
|
|
} catch (e) {
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
HardwareWalletService? hardwareWalletService;
|
|
|
|
Future<BtcTransaction> buildHardwareWalletTransaction({
|
|
required List<BitcoinOutput> outputs,
|
|
required BigInt fee,
|
|
required BasedUtxoNetwork network,
|
|
required List<UtxoWithAddress> utxos,
|
|
required List<OutputInfo> cwOutputs,
|
|
required Map<String, PublicKeyWithDerivationPath> publicKeys,
|
|
String? memo,
|
|
bool enableRBF = false,
|
|
BitcoinOrdering inputOrdering = BitcoinOrdering.bip69,
|
|
BitcoinOrdering outputOrdering = BitcoinOrdering.bip69,
|
|
}) async =>
|
|
throw UnimplementedError();
|
|
|
|
String toJSON() => json.encode({
|
|
'mnemonic': _mnemonic,
|
|
'xpub': xpub,
|
|
'passphrase': passphrase ?? '',
|
|
'account_index': walletAddresses.currentReceiveAddressIndexByType,
|
|
'change_address_index': walletAddresses.currentChangeAddressIndexByType,
|
|
'addresses': walletAddresses.allAddresses.map((addr) => addr.toJSON()).toList(),
|
|
'address_page_type': walletInfo.addressPageType == null
|
|
? SegwitAddresType.p2wpkh.toString()
|
|
: walletInfo.addressPageType.toString(),
|
|
'balance': balance[currency]?.toJSON(),
|
|
'lightningBalance': balance[CryptoCurrency.btcln]?.toJSON(),
|
|
'derivationTypeIndex': derivationInfo.derivationType?.index,
|
|
'derivationPath': derivationInfo.derivationPath,
|
|
'silent_addresses': walletAddresses.silentAddresses.map((addr) => addr.toJSON()).toList(),
|
|
'silent_address_index': walletAddresses.currentSilentAddressIndex.toString(),
|
|
'mweb_addresses': walletAddresses.mwebAddresses.map((addr) => addr.toJSON()).toList(),
|
|
'alwaysScan': alwaysScan,
|
|
'useLightning': useLightning,
|
|
'cachedLightningAddress': walletAddresses.lightningAddress
|
|
});
|
|
|
|
int feeRate(TransactionPriority priority) {
|
|
try {
|
|
if (priority is BitcoinTransactionPriority) {
|
|
return _feeRates[priority.raw];
|
|
}
|
|
|
|
return 0;
|
|
} catch (_) {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
int feeAmountForPriority(TransactionPriority priority, int inputsCount, int outputsCount,
|
|
{int? size}) =>
|
|
feeRate(priority) * (size ?? estimatedTransactionSize(inputsCount, outputsCount));
|
|
|
|
int feeAmountWithFeeRate(int feeRate, int inputsCount, int outputsCount, {int? size}) =>
|
|
feeRate * (size ?? estimatedTransactionSize(inputsCount, outputsCount));
|
|
|
|
@override
|
|
int calculateEstimatedFee(TransactionPriority? priority, int? amount,
|
|
{int? outputsCount, int? size}) {
|
|
if (priority is BitcoinTransactionPriority) {
|
|
return calculateEstimatedFeeWithFeeRate(feeRate(priority), amount,
|
|
outputsCount: outputsCount, size: size);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int calculateEstimatedFeeWithFeeRate(int feeRate, int? amount, {int? outputsCount, int? size}) {
|
|
if (size != null) {
|
|
return feeAmountWithFeeRate(feeRate, 0, 0, size: size);
|
|
}
|
|
|
|
int inputsCount = 0;
|
|
|
|
if (amount != null) {
|
|
int totalValue = 0;
|
|
|
|
for (final input in unspentCoinsForCurrentAccount) {
|
|
if (totalValue >= amount) {
|
|
break;
|
|
}
|
|
|
|
if (input.isSending) {
|
|
totalValue += input.value;
|
|
inputsCount += 1;
|
|
}
|
|
}
|
|
|
|
if (totalValue < amount) return 0;
|
|
} else {
|
|
for (final input in unspentCoinsForCurrentAccount) {
|
|
if (input.isSending) {
|
|
inputsCount += 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
// If send all, then we have no change value
|
|
final _outputsCount = outputsCount ?? (amount != null ? 2 : 1);
|
|
|
|
return feeAmountWithFeeRate(feeRate, inputsCount, _outputsCount);
|
|
}
|
|
|
|
@override
|
|
Future<void> save() async {
|
|
if (!(await WalletKeysFile.hasKeysFile(walletInfo.name, walletInfo.type))) {
|
|
await saveKeysFile(_password, encryptionFileUtils);
|
|
saveKeysFile(_password, encryptionFileUtils, true);
|
|
}
|
|
|
|
final path = await makePath();
|
|
await encryptionFileUtils.write(path: path, password: _password, data: toJSON());
|
|
await transactionHistory.save();
|
|
}
|
|
|
|
@override
|
|
Future<void> changePassword(String password) async {
|
|
_password = password;
|
|
await save();
|
|
await transactionHistory.changePassword(password);
|
|
}
|
|
|
|
@action
|
|
@override
|
|
Future<void> rescan({required int height, bool? doSingleScan}) async {
|
|
if (keys.privateKey.isEmpty) return;
|
|
|
|
silentPaymentsScanningActive = true;
|
|
_setListeners(height, doSingleScan: doSingleScan);
|
|
}
|
|
|
|
@override
|
|
Future<void> close({bool shouldCleanup = false}) async {
|
|
_missingHistoryQueue.clear();
|
|
_unresolvedAccountRetryCount.clear();
|
|
try {
|
|
await _receiveStream?.cancel();
|
|
await electrumClient.close();
|
|
_isBatchSupported = null;
|
|
} catch (_) {}
|
|
_autoSaveTimer?.cancel();
|
|
_updateFeeRateTimer?.cancel();
|
|
}
|
|
|
|
@action
|
|
Future<void> updateAllUnspents() async {
|
|
|
|
List<BitcoinUnspent> updatedUnspentCoins = [];
|
|
|
|
final previousUnspentCoins = List<BitcoinUnspent>.from(unspentCoins.where((utxo) =>
|
|
utxo.bitcoinAddressRecord.type != SegwitAddresType.mweb &&
|
|
utxo.bitcoinAddressRecord is! BitcoinSilentPaymentAddressRecord));
|
|
|
|
if (hasSilentPaymentsScanning) {
|
|
// Update unspents stored from scanned silent payment transactions
|
|
transactionHistory.transactions.values.forEach((tx) {
|
|
if (tx.unspents != null) {
|
|
updatedUnspentCoins.addAll(tx.unspents!);
|
|
}
|
|
});
|
|
}
|
|
|
|
// Set the balance of all non-silent payment and non-mweb addresses to 0 before updating
|
|
|
|
final targetAddresses = walletAddresses.allAddresses
|
|
.where((element) => element.type != SegwitAddresType.mweb)
|
|
.toList();
|
|
|
|
for (final addr in targetAddresses) {
|
|
if (addr is! BitcoinSilentPaymentAddressRecord) {
|
|
addr.balance = 0;
|
|
_appliedCoinKeysByAddress[addr.address]?.clear();
|
|
}
|
|
}
|
|
|
|
final results = shouldUseBatchFetching
|
|
? await _fetchUnspentsBatch(targetAddresses)
|
|
: await _fetchUnspentsRegular(targetAddresses);
|
|
|
|
final failedCount = results.where((result) => result == null).length;
|
|
|
|
if (failedCount == 0) {
|
|
for (final result in results) {
|
|
updatedUnspentCoins.addAll(result!);
|
|
}
|
|
unspentCoins = updatedUnspentCoins;
|
|
_hasCompleteUnspentSet = true;
|
|
} else {
|
|
if (updatedUnspentCoins.isEmpty) {
|
|
unspentCoins = handleFailedUtxoFetch(
|
|
failedCount: failedCount,
|
|
previousUnspentCoins: previousUnspentCoins,
|
|
updatedUnspentCoins: updatedUnspentCoins,
|
|
results: results,
|
|
);
|
|
} else {
|
|
unspentCoins = updatedUnspentCoins;
|
|
}
|
|
}
|
|
|
|
final currentWalletUnspentCoins =
|
|
unspentCoinsInfo.values.where((element) => element.walletId == id);
|
|
|
|
if (currentWalletUnspentCoins.length != updatedUnspentCoins.length) {
|
|
unspentCoins.forEach((coin) => addCoinInfo(coin));
|
|
}
|
|
|
|
await updateCoins(unspentCoins);
|
|
_updateAccountBalancesFromUnspents();
|
|
await _refreshUnspentCoinsInfo();
|
|
}
|
|
|
|
Future<List<List<BitcoinUnspent>?>> _fetchUnspentsRegular(
|
|
List<BitcoinAddressRecord> addresses,
|
|
) async {
|
|
final addressFutures = addresses.map((address) => fetchUnspent(address)).toList();
|
|
return Future.wait(addressFutures);
|
|
}
|
|
|
|
Future<List<List<BitcoinUnspent>?>> _fetchUnspentsBatch(
|
|
List<BitcoinAddressRecord> addresses,
|
|
) async {
|
|
final byScriptHash = <String, BitcoinAddressRecord>{
|
|
for (final address in addresses) address.getScriptHash(network): address,
|
|
};
|
|
|
|
final scriptHashes = byScriptHash.keys.toList();
|
|
|
|
try {
|
|
final failedScriptHashes = <String>{};
|
|
final unspentByScriptHash =
|
|
await _processChunksToMap<String, String, List<Map<String, dynamic>>>(
|
|
items: scriptHashes,
|
|
chunkSize: addressHistoryChunkSize,
|
|
processChunk: _getListUnspentBatch,
|
|
onChunkError: (chunk, _) => failedScriptHashes.addAll(chunk),
|
|
);
|
|
|
|
final txHashes = <String>{};
|
|
final coinsByScriptHash = <String, List<BitcoinUnspent>>{};
|
|
|
|
for (final entry in unspentByScriptHash.entries) {
|
|
final addressRecord = byScriptHash[entry.key];
|
|
if (addressRecord == null) continue;
|
|
|
|
final coins = <BitcoinUnspent>[];
|
|
|
|
for (final unspent in entry.value) {
|
|
final coin = BitcoinUnspent.fromJSON(addressRecord, unspent);
|
|
coin.isChange = addressRecord.isHidden;
|
|
coins.add(coin);
|
|
txHashes.add(coin.hash);
|
|
}
|
|
|
|
coinsByScriptHash[entry.key] = coins;
|
|
}
|
|
|
|
final txInfoByHash = await fetchTransactionInfoBatch(
|
|
hashes: txHashes.toList(),
|
|
retryOnFailure: true,
|
|
retryDelay: const Duration(seconds: 1),
|
|
);
|
|
|
|
for (final coins in coinsByScriptHash.values) {
|
|
for (final coin in coins) {
|
|
final tx = txInfoByHash[coin.hash];
|
|
coin.confirmations = tx?.confirmations;
|
|
coin.isPegOut = tx?.isHogEx;
|
|
}
|
|
}
|
|
|
|
return addresses.map((address) {
|
|
final scriptHash = address.getScriptHash(network);
|
|
if (failedScriptHashes.contains(scriptHash)) return null;
|
|
if (!unspentByScriptHash.containsKey(scriptHash)) return null;
|
|
return coinsByScriptHash[scriptHash] ?? <BitcoinUnspent>[];
|
|
}).toList();
|
|
} catch (e) {
|
|
printV('fetchUnspentsBatch failed: $e');
|
|
return List<List<BitcoinUnspent>?>.filled(addresses.length, null);
|
|
}
|
|
}
|
|
|
|
List<BitcoinUnspent> handleFailedUtxoFetch({
|
|
required int failedCount,
|
|
required List<BitcoinUnspent> previousUnspentCoins,
|
|
required List<BitcoinUnspent> updatedUnspentCoins,
|
|
required List<List<BitcoinUnspent>?> results,
|
|
}) {
|
|
if (failedCount == results.length) {
|
|
printV("All UTXOs failed to fetch, falling back to previous UTXOs");
|
|
return previousUnspentCoins;
|
|
}
|
|
|
|
final successfulUtxos = <BitcoinUnspent>[];
|
|
for (final result in results) {
|
|
if (result != null) {
|
|
successfulUtxos.addAll(result);
|
|
}
|
|
}
|
|
|
|
if (failedCount > 0 && successfulUtxos.isEmpty) {
|
|
printV("Some UTXOs failed, but no successful UTXOs, falling back to previous UTXOs");
|
|
return previousUnspentCoins;
|
|
}
|
|
|
|
if (failedCount > 0) {
|
|
printV("Some UTXOs failed, updating with successful UTXOs");
|
|
updatedUnspentCoins.addAll(successfulUtxos);
|
|
}
|
|
|
|
return updatedUnspentCoins;
|
|
}
|
|
|
|
Future<void> updateCoins(List<BitcoinUnspent> newUnspentCoins) async {
|
|
if (newUnspentCoins.isEmpty) {
|
|
return;
|
|
}
|
|
|
|
newUnspentCoins.forEach((coin) {
|
|
final coinInfoList = unspentCoinsInfo.values.where(
|
|
(element) =>
|
|
element.walletId.contains(id) &&
|
|
element.hash.contains(coin.hash) &&
|
|
element.vout == coin.vout,
|
|
);
|
|
|
|
if (coinInfoList.isNotEmpty) {
|
|
final coinInfo = coinInfoList.first;
|
|
|
|
coin.isFrozen = coinInfo.isFrozen;
|
|
coin.isSending = coinInfo.isSending;
|
|
coin.note = coinInfo.note;
|
|
|
|
if (coin.bitcoinAddressRecord is! BitcoinSilentPaymentAddressRecord) {
|
|
final addr = coin.bitcoinAddressRecord.address;
|
|
final coinKey = '${coin.hash}:${coin.vout}';
|
|
final appliedKeys = _appliedCoinKeysByAddress.putIfAbsent(addr, () => <String>{});
|
|
|
|
if (appliedKeys.add(coinKey)) {
|
|
coin.bitcoinAddressRecord.balance += coinInfo.value;
|
|
}
|
|
}
|
|
} else {
|
|
addCoinInfo(coin);
|
|
}
|
|
});
|
|
}
|
|
|
|
@action
|
|
Future<void> updateUnspentsForAddress(BitcoinAddressRecord address) async {
|
|
final newUnspentCoins = await fetchUnspent(address);
|
|
await updateCoins(newUnspentCoins ?? []);
|
|
}
|
|
|
|
@action
|
|
Future<List<BitcoinUnspent>?> fetchUnspent(BitcoinAddressRecord address) async {
|
|
List<BitcoinUnspent> updatedUnspentCoins = [];
|
|
|
|
final unspents = await electrumClient.getListUnspent(address.getScriptHash(network));
|
|
|
|
// Failed to fetch unspents
|
|
if (unspents == null) return null;
|
|
|
|
await Future.wait(unspents.map((unspent) async {
|
|
try {
|
|
final coin = BitcoinUnspent.fromJSON(address, unspent);
|
|
final tx = await fetchTransactionInfo(hash: coin.hash);
|
|
coin.isChange = address.isHidden;
|
|
coin.confirmations = tx?.confirmations;
|
|
coin.isPegOut = tx?.isHogEx;
|
|
|
|
updatedUnspentCoins.add(coin);
|
|
} catch (_) {}
|
|
}));
|
|
|
|
return updatedUnspentCoins;
|
|
}
|
|
|
|
@action
|
|
Future<void> addCoinInfo(BitcoinUnspent coin) async {
|
|
// Check if the coin is already in the unspentCoinsInfo for the wallet
|
|
final existingCoinInfo = unspentCoinsInfo.values.firstWhereOrNull(
|
|
(element) =>
|
|
element.walletId == walletInfo.id &&
|
|
element.hash == coin.hash &&
|
|
element.vout == coin.vout,
|
|
);
|
|
|
|
if (existingCoinInfo == null) {
|
|
final newInfo = UnspentCoinsInfo(
|
|
walletId: id,
|
|
hash: coin.hash,
|
|
isFrozen: coin.isFrozen,
|
|
isSending: coin.isSending,
|
|
noteRaw: coin.note,
|
|
address: coin.bitcoinAddressRecord.address,
|
|
value: coin.value,
|
|
vout: coin.vout,
|
|
isChange: coin.isChange,
|
|
isSilentPayment: coin is BitcoinSilentPaymentsUnspent,
|
|
);
|
|
|
|
await unspentCoinsInfo.add(newInfo);
|
|
}
|
|
}
|
|
|
|
Future<void> _refreshUnspentCoinsInfo() async {
|
|
try {
|
|
final List<dynamic> keys = [];
|
|
final currentWalletUnspentCoins =
|
|
unspentCoinsInfo.values.where((record) => record.walletId == id);
|
|
|
|
for (final element in currentWalletUnspentCoins) {
|
|
if (element.isFrozen) continue;
|
|
if (RegexUtils.addressTypeFromStr(element.address, network) is MwebAddress) continue;
|
|
|
|
final existUnspentCoins = unspentCoins.where((coin) => element == coin);
|
|
|
|
if (existUnspentCoins.isEmpty) {
|
|
keys.add(element.key);
|
|
}
|
|
}
|
|
|
|
if (keys.isNotEmpty) {
|
|
await unspentCoinsInfo.deleteAll(keys);
|
|
}
|
|
} catch (e) {
|
|
printV("refreshUnspentCoinsInfo $e");
|
|
}
|
|
}
|
|
|
|
Future<void> cleanUpDuplicateUnspentCoins() async {
|
|
final currentWalletUnspentCoins =
|
|
unspentCoinsInfo.values.where((element) => element.walletId == id);
|
|
final Map<String, UnspentCoinsInfo> uniqueUnspentCoins = {};
|
|
final List<dynamic> duplicateKeys = [];
|
|
|
|
for (final unspentCoin in currentWalletUnspentCoins) {
|
|
final key = '${unspentCoin.hash}:${unspentCoin.vout}';
|
|
if (!uniqueUnspentCoins.containsKey(key)) {
|
|
uniqueUnspentCoins[key] = unspentCoin;
|
|
} else {
|
|
duplicateKeys.add(unspentCoin.key);
|
|
}
|
|
}
|
|
|
|
if (duplicateKeys.isNotEmpty) await unspentCoinsInfo.deleteAll(duplicateKeys);
|
|
}
|
|
|
|
void _seedAccountBalancesFromAddressRecords() {
|
|
if (type != WalletType.bitcoin) return;
|
|
if (accountBalances.isNotEmpty) return;
|
|
|
|
final newBalances = <int, ElectrumBalance>{};
|
|
|
|
for (final addr in walletAddresses.allAddresses) {
|
|
if (addr.type == SegwitAddresType.mweb) continue;
|
|
final current = newBalances[addr.accountIndex] ?? ElectrumBalance.zero(currency);
|
|
current.confirmed += Money.fromInt(addr.balance, currency);
|
|
newBalances[addr.accountIndex] = current;
|
|
}
|
|
|
|
for (final accountIndex in walletAddresses.accountIndexes) {
|
|
newBalances.putIfAbsent(accountIndex, () => ElectrumBalance.zero(currency));
|
|
}
|
|
|
|
// balance[currency] came from the wallet file and is authoritative for the
|
|
// selected account — prefer it if the address records look stale.
|
|
final persisted = balance[currency];
|
|
final seeded = newBalances[currentAccountIndex];
|
|
if (persisted != null && seeded != null) {
|
|
final seededIsZero = seeded.confirmed == Money.zero(currency) &&
|
|
seeded.unconfirmed == Money.zero(currency);
|
|
final persistedIsNonZero = persisted.confirmed != Money.zero(currency) ||
|
|
persisted.unconfirmed != Money.zero(currency);
|
|
if (seededIsZero && persistedIsNonZero) {
|
|
newBalances[currentAccountIndex] = persisted;
|
|
}
|
|
}
|
|
|
|
accountBalances = ObservableMap<int, ElectrumBalance>.of(newBalances);
|
|
_updateCurrentAccountBalance();
|
|
}
|
|
|
|
int transactionVSize(String transactionHex) => BtcTransaction.fromRaw(transactionHex).getVSize();
|
|
|
|
Future<String?> canReplaceByFee(ElectrumTransactionInfo tx) async {
|
|
try {
|
|
final bundle = await getTransactionExpanded(hash: tx.txHash);
|
|
_updateInputsAndOutputs(tx, bundle);
|
|
if (bundle.confirmations > 0) return null;
|
|
return bundle.originalTransaction.canReplaceByFee ? bundle.originalTransaction.toHex() : null;
|
|
} catch (e) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
Future<bool> isChangeSufficientForFee(String txId, int newFee) async {
|
|
final bundle = await getTransactionExpanded(hash: txId);
|
|
final outputs = bundle.originalTransaction.outputs;
|
|
|
|
final ownAddresses = walletAddresses.allAddresses.map((addr) => addr.address).toSet();
|
|
|
|
final receiverAmount = outputs
|
|
.where((output) =>
|
|
!ownAddresses.contains(addressFromOutputScript(output.scriptPubKey, network)))
|
|
.fold<int>(0, (sum, output) => sum + output.amount.toInt());
|
|
|
|
if (receiverAmount == 0) {
|
|
throw Exception("Receiver output not found.");
|
|
}
|
|
|
|
final availableInputs =
|
|
unspentCoinsForCurrentAccount.where((utxo) => utxo.isSending && !utxo.isFrozen).toList();
|
|
int totalBalance = availableInputs.fold<int>(
|
|
0, (previousValue, element) => previousValue + element.value.toInt());
|
|
|
|
int allInputsAmount = 0;
|
|
for (int i = 0; i < bundle.originalTransaction.inputs.length; i++) {
|
|
final input = bundle.originalTransaction.inputs[i];
|
|
final inputTransaction = bundle.ins[i];
|
|
if (inputTransaction == null) {
|
|
throw Exception("Missing input transaction for fee calculation");
|
|
}
|
|
final vout = input.txIndex;
|
|
final outTransaction = inputTransaction.outputs[vout];
|
|
allInputsAmount += outTransaction.amount.toInt();
|
|
}
|
|
|
|
final totalOutAmount = bundle.originalTransaction.outputs
|
|
.fold<int>(0, (previousValue, element) => previousValue + element.amount.toInt());
|
|
var currentFee = allInputsAmount - totalOutAmount;
|
|
|
|
final remainingFee = (newFee - currentFee > 0) ? newFee - currentFee : newFee;
|
|
return totalBalance - receiverAmount - remainingFee >= networkDustAmount.toInt();
|
|
}
|
|
|
|
Future<PendingBitcoinTransaction> replaceByFee(String hash, int newFee) async {
|
|
try {
|
|
final bundle = await getTransactionExpanded(hash: hash);
|
|
|
|
final utxos = <UtxoWithAddress>[];
|
|
final outputs = <BitcoinOutput>[];
|
|
List<ECPrivate> privateKeys = [];
|
|
|
|
var allInputsAmount = 0;
|
|
String? memo;
|
|
|
|
// Add original inputs
|
|
for (var i = 0; i < bundle.originalTransaction.inputs.length; i++) {
|
|
final input = bundle.originalTransaction.inputs[i];
|
|
final inputTransaction = bundle.ins[i];
|
|
if (inputTransaction == null) {
|
|
throw Exception("Missing input transaction for replace-by-fee");
|
|
}
|
|
final vout = input.txIndex;
|
|
final outTransaction = inputTransaction.outputs[vout];
|
|
final address = addressFromOutputScript(outTransaction.scriptPubKey, network);
|
|
allInputsAmount += outTransaction.amount.toInt();
|
|
|
|
final addressRecord =
|
|
walletAddresses.allAddresses.firstWhere((element) => element.address == address);
|
|
final btcAddress = RegexUtils.addressTypeFromStr(addressRecord.address, network);
|
|
|
|
final hd = _hdForAddressRecord(record: addressRecord);
|
|
|
|
final privkey = generateECPrivate(hd: hd, index: addressRecord.index, network: network);
|
|
|
|
privateKeys.add(privkey);
|
|
|
|
utxos.add(
|
|
UtxoWithAddress(
|
|
utxo: BitcoinUtxo(
|
|
txHash: input.txId,
|
|
value: outTransaction.amount,
|
|
vout: vout,
|
|
scriptType: _getScriptType(btcAddress),
|
|
),
|
|
ownerDetails:
|
|
UtxoAddressDetails(publicKey: privkey.getPublic().toHex(), address: btcAddress),
|
|
),
|
|
);
|
|
}
|
|
|
|
// Add original outputs
|
|
for (final out in bundle.originalTransaction.outputs) {
|
|
final script = out.scriptPubKey.script;
|
|
if (script.contains('OP_RETURN') && memo == null) {
|
|
final index = script.indexOf('OP_RETURN');
|
|
if (index + 1 <= script.length) {
|
|
try {
|
|
final opReturnData = script[index + 1].toString();
|
|
memo = utf8.decode(HEX.decode(opReturnData));
|
|
continue;
|
|
} catch (_) {
|
|
throw Exception('Cannot decode OP_RETURN data');
|
|
}
|
|
}
|
|
}
|
|
|
|
final address = addressFromOutputScript(out.scriptPubKey, network);
|
|
final btcAddress = RegexUtils.addressTypeFromStr(address, network);
|
|
outputs.add(BitcoinOutput(address: btcAddress, value: BigInt.from(out.amount.toInt())));
|
|
}
|
|
|
|
// Calculate the total amount and fees
|
|
int totalOutAmount =
|
|
outputs.fold<int>(0, (previousValue, output) => previousValue + output.value.toInt());
|
|
int currentFee = allInputsAmount - totalOutAmount;
|
|
var remainingFee = BigInt.from(newFee - currentFee);
|
|
|
|
if (remainingFee <= BigInt.zero) {
|
|
throw Exception("New fee must be higher than the current fee.");
|
|
}
|
|
|
|
// Deduct fee from change outputs first, if possible
|
|
if (remainingFee > BigInt.zero) {
|
|
final changeAddresses = walletAddresses.allAddresses.where((element) => element.isHidden);
|
|
for (int i = outputs.length - 1; i >= 0; i--) {
|
|
final output = outputs[i];
|
|
final isChange = changeAddresses
|
|
.any((element) => element.address == output.address.toAddress(network));
|
|
|
|
if (isChange) {
|
|
final outputAmount = output.value;
|
|
if (outputAmount > networkDustAmount) {
|
|
final deduction = (outputAmount - networkDustAmount >= remainingFee)
|
|
? remainingFee
|
|
: outputAmount - networkDustAmount;
|
|
outputs[i] = BitcoinOutput(address: output.address, value: outputAmount - deduction);
|
|
remainingFee -= deduction;
|
|
|
|
if (remainingFee <= BigInt.zero) break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// If still not enough, add UTXOs until the fee is covered, drawing them at
|
|
// random instead of in the predictable wallet scan order (address, then age).
|
|
if (remainingFee > BigInt.zero) {
|
|
final unusedUtxos = unspentCoinsForCurrentAccount
|
|
.where((utxo) => utxo.isSending && !utxo.isFrozen && utxo.confirmations! > 0)
|
|
.toList()
|
|
..shuffle(Random.secure());
|
|
|
|
for (final utxo in unusedUtxos) {
|
|
final address = RegexUtils.addressTypeFromStr(utxo.address, network);
|
|
|
|
final hd = _hdForAddressRecord(record: utxo.bitcoinAddressRecord);
|
|
|
|
final privkey = generateECPrivate(
|
|
hd: hd,
|
|
index: utxo.bitcoinAddressRecord.index,
|
|
network: network,
|
|
);
|
|
privateKeys.add(privkey);
|
|
|
|
utxos.add(UtxoWithAddress(
|
|
utxo: BitcoinUtxo(
|
|
txHash: utxo.hash,
|
|
value: BigInt.from(utxo.value),
|
|
vout: utxo.vout,
|
|
scriptType: _getScriptType(address)),
|
|
ownerDetails:
|
|
UtxoAddressDetails(publicKey: privkey.getPublic().toHex(), address: address),
|
|
));
|
|
|
|
allInputsAmount += utxo.value;
|
|
remainingFee -= BigInt.from(utxo.value);
|
|
|
|
if (remainingFee < BigInt.zero) {
|
|
final changeOutput = outputs.firstWhereOrNull((output) => walletAddresses.allAddresses
|
|
.any((addr) => addr.address == output.address.toAddress(network)));
|
|
if (changeOutput != null) {
|
|
final newValue = changeOutput.value + (-remainingFee);
|
|
outputs[outputs.indexOf(changeOutput)] =
|
|
BitcoinOutput(address: changeOutput.address, value: newValue);
|
|
} else {
|
|
final changeAddress = await walletAddresses.getChangeAddress();
|
|
outputs.add(BitcoinOutput(
|
|
address: RegexUtils.addressTypeFromStr(changeAddress.address, network),
|
|
value: -remainingFee));
|
|
}
|
|
|
|
remainingFee = BigInt.zero;
|
|
break;
|
|
}
|
|
|
|
if (remainingFee <= BigInt.zero) break;
|
|
}
|
|
}
|
|
|
|
// Deduct from the receiver's output if remaining fee is still greater than 0
|
|
if (remainingFee > BigInt.zero) {
|
|
for (int i = 0; i < outputs.length; i++) {
|
|
final output = outputs[i];
|
|
final outputAmount = output.value;
|
|
|
|
if (outputAmount > networkDustAmount) {
|
|
final deduction = (outputAmount - networkDustAmount >= remainingFee)
|
|
? remainingFee
|
|
: outputAmount - networkDustAmount;
|
|
|
|
outputs[i] = BitcoinOutput(address: output.address, value: outputAmount - deduction);
|
|
remainingFee -= deduction;
|
|
|
|
if (remainingFee <= BigInt.zero) break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Final check if the remaining fee couldn't be deducted
|
|
if (remainingFee > BigInt.zero) {
|
|
throw Exception("Not enough funds to cover the fee.");
|
|
}
|
|
|
|
// Identify all change outputs
|
|
final changeAddresses = walletAddresses.allAddresses.where((element) => element.isHidden);
|
|
final List<BitcoinOutput> changeOutputs = outputs
|
|
.where((output) => changeAddresses
|
|
.any((element) => element.address == output.address.toAddress(network)))
|
|
.toList();
|
|
|
|
int totalChangeAmount =
|
|
changeOutputs.fold<int>(0, (sum, output) => sum + output.value.toInt());
|
|
|
|
// The final amount that the receiver will receive
|
|
int sendingAmount = allInputsAmount - newFee - totalChangeAmount;
|
|
|
|
final txb = BitcoinTransactionBuilder(
|
|
utxos: utxos,
|
|
outputs: outputs,
|
|
fee: BigInt.from(newFee),
|
|
network: network,
|
|
memo: memo,
|
|
inputOrdering: BitcoinOrdering.shuffle,
|
|
outputOrdering: BitcoinOrdering.shuffle,
|
|
enableRBF: true,
|
|
locktime: await _antiFeeSnipingLocktime(),
|
|
);
|
|
|
|
final transaction = txb.buildTransaction((txDigest, utxo, publicKey, sighash) {
|
|
final key =
|
|
privateKeys.firstWhereOrNull((element) => element.getPublic().toHex() == publicKey);
|
|
if (key == null) {
|
|
throw Exception("Cannot find private key");
|
|
}
|
|
|
|
if (utxo.utxo.isP2tr()) {
|
|
return key.signTapRoot(txDigest, sighash: sighash);
|
|
} else {
|
|
return key.signInput(txDigest, sigHash: sighash);
|
|
}
|
|
});
|
|
|
|
return PendingBitcoinTransaction(
|
|
transaction,
|
|
type,
|
|
accountIndex: transactionHistory.transactions[hash]?.accountIndex ?? currentAccountIndex,
|
|
electrumClient: electrumClient,
|
|
amount: Money.fromInt(sendingAmount, currency),
|
|
fee: Money.fromInt(newFee, currency),
|
|
network: network,
|
|
hasChange: changeOutputs.isNotEmpty,
|
|
feeRate: newFee.toString(),
|
|
isViewOnly: keys.privateKey.isEmpty,
|
|
)..addListener((transaction) async {
|
|
transactionHistory.transactions.values.forEach((tx) {
|
|
if (tx.id == hash) {
|
|
tx.isReplaced = true;
|
|
tx.isPending = false;
|
|
transactionHistory.addOne(tx);
|
|
}
|
|
});
|
|
transactionHistory.addOne(transaction);
|
|
await updateAllUnspents();
|
|
await updateBalance();
|
|
});
|
|
} catch (e) {
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
Future<ElectrumTransactionBundle> getTransactionExpanded(
|
|
{required String hash, int? height}) async {
|
|
String transactionHex;
|
|
int? time;
|
|
int? confirmations;
|
|
|
|
final verboseTransaction = await electrumClient.getTransactionVerbose(hash: hash);
|
|
|
|
if (verboseTransaction.isEmpty) {
|
|
transactionHex = await electrumClient.getTransactionHex(hash: hash);
|
|
|
|
if (height != null && height > 0 && await checkIfMempoolAPIIsEnabled()) {
|
|
try {
|
|
final blockHash = await ProxyWrapper()
|
|
.get(
|
|
clearnetUri: Uri.parse(
|
|
"https://mempool.cakewallet.com/api/v1/block-height/$height",
|
|
),
|
|
)
|
|
.timeout(Duration(seconds: 15));
|
|
|
|
if (blockHash.statusCode == 200 &&
|
|
blockHash.body.isNotEmpty &&
|
|
jsonDecode(blockHash.body) != null) {
|
|
final blockResponse = await ProxyWrapper()
|
|
.get(
|
|
clearnetUri: Uri.parse(
|
|
"https://mempool.cakewallet.com/api/v1/block/${blockHash.body}",
|
|
),
|
|
)
|
|
.timeout(Duration(seconds: 15));
|
|
if (blockResponse.statusCode == 200 &&
|
|
blockResponse.body.isNotEmpty &&
|
|
jsonDecode(blockResponse.body)['timestamp'] != null) {
|
|
time = int.parse(jsonDecode(blockResponse.body)['timestamp'].toString());
|
|
}
|
|
}
|
|
} catch (_) {}
|
|
}
|
|
} else {
|
|
transactionHex = verboseTransaction['hex'] as String;
|
|
time = verboseTransaction['time'] as int?;
|
|
confirmations = verboseTransaction['confirmations'] as int?;
|
|
}
|
|
|
|
if (height != null) {
|
|
if (time == null && height > 0) {
|
|
time = (getDateByBitcoinHeight(height).millisecondsSinceEpoch / 1000).round();
|
|
}
|
|
|
|
if (confirmations == null) {
|
|
final tip = await getUpdatedChainTip();
|
|
if (tip > 0 && height > 0) {
|
|
// Add one because the block itself is the first confirmation
|
|
confirmations = tip - height + 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
final original = BtcTransaction.fromRaw(transactionHex);
|
|
final ins = <BtcTransaction?>[];
|
|
|
|
for (final vin in original.inputs) {
|
|
try {
|
|
final verboseTransaction = await electrumClient.getTransactionVerbose(hash: vin.txId);
|
|
|
|
final String inputTransactionHex;
|
|
|
|
if (verboseTransaction.isEmpty) {
|
|
inputTransactionHex = await electrumClient.getTransactionHex(hash: vin.txId);
|
|
} else {
|
|
inputTransactionHex = verboseTransaction['hex'] as String;
|
|
}
|
|
|
|
ins.add(inputTransactionHex.isEmpty ? null : BtcTransaction.fromRaw(inputTransactionHex));
|
|
} catch (_) {
|
|
ins.add(null);
|
|
}
|
|
}
|
|
|
|
return ElectrumTransactionBundle(
|
|
original,
|
|
ins: ins,
|
|
time: time,
|
|
confirmations: confirmations ?? 0,
|
|
);
|
|
}
|
|
|
|
Future<ElectrumTransactionInfo?> fetchTransactionInfo(
|
|
{required String hash, int? height, bool? retryOnFailure}) async {
|
|
try {
|
|
final bundle = await getTransactionExpanded(hash: hash, height: height);
|
|
final addressesByAccount = addressesSetByAccount;
|
|
final owner = _accountForTransaction(bundle, addressesByAccount);
|
|
|
|
final info = ElectrumTransactionInfo.fromElectrumBundle(
|
|
bundle,
|
|
walletInfo.type,
|
|
network,
|
|
addresses: owner != null ? addressesByAccount[owner]! : addressesSet,
|
|
height: height,
|
|
);
|
|
info.accountIndex = owner;
|
|
return info;
|
|
} catch (e) {
|
|
if (e is FormatException && retryOnFailure == true) {
|
|
await Future.delayed(const Duration(seconds: 2));
|
|
return fetchTransactionInfo(hash: hash, height: height);
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
|
|
bool isMine(Script script) {
|
|
final derivedAddress = addressFromOutputScript(script, network);
|
|
return addressesSet.contains(derivedAddress);
|
|
}
|
|
|
|
@override
|
|
Future<Map<String, ElectrumTransactionInfo>> fetchTransactions() async {
|
|
try {
|
|
final Map<String, ElectrumTransactionInfo> historiesWithDetails = {};
|
|
|
|
printV("[BATCH_TEST] Fetching transactions with batch: $shouldUseBatchFetching");
|
|
|
|
if (type == WalletType.bitcoin) {
|
|
if (isInitialBitcoinAccountsSync) {
|
|
await fetchBitcoinTransactionsForInitialRestore(historiesWithDetails);
|
|
} else {
|
|
await Future.wait(BITCOIN_ADDRESS_TYPES.map((type) => shouldUseBatchFetching
|
|
? fetchTransactionsForAddressTypeBatch(historiesWithDetails, type)
|
|
: fetchTransactionsForAddressType(historiesWithDetails, type)));
|
|
}
|
|
} else if (type == WalletType.bitcoinCash) {
|
|
await Future.wait(BITCOIN_CASH_ADDRESS_TYPES.map((type) => shouldUseBatchFetching
|
|
? fetchTransactionsForAddressTypeBatch(historiesWithDetails, type)
|
|
: fetchTransactionsForAddressType(historiesWithDetails, type)));
|
|
} else if (type == WalletType.litecoin) {
|
|
await Future.wait(LITECOIN_ADDRESS_TYPES.where((type) => type != SegwitAddresType.mweb).map(
|
|
(type) => shouldUseBatchFetching
|
|
? fetchTransactionsForAddressTypeBatch(historiesWithDetails, type)
|
|
: fetchTransactionsForAddressType(historiesWithDetails, type)));
|
|
} else if (type == WalletType.dogecoin) {
|
|
await Future.wait(DOGECOIN_ADDRESS_TYPES.map((type) => shouldUseBatchFetching
|
|
? fetchTransactionsForAddressTypeBatch(historiesWithDetails, type)
|
|
: fetchTransactionsForAddressType(historiesWithDetails, type)));
|
|
}
|
|
|
|
printV('[QUICK_SYNC] deferred ${_missingHistoryQueue.length} transactions to background');
|
|
|
|
transactionHistory.transactions.values.forEach((tx) async {
|
|
final isPendingSilentPaymentUtxo = (tx.isPending || tx.confirmations == 0) &&
|
|
historiesWithDetails[tx.id] == null &&
|
|
!_missingHistoryQueue.containsKey(tx.id);
|
|
|
|
if (isPendingSilentPaymentUtxo) {
|
|
final info =
|
|
await fetchTransactionInfo(hash: tx.id, height: tx.height, retryOnFailure: true);
|
|
|
|
if (info != null) {
|
|
tx.confirmations = info.confirmations;
|
|
tx.isPending = tx.confirmations == 0;
|
|
transactionHistory.addOne(tx);
|
|
await transactionHistory.save();
|
|
}
|
|
}
|
|
});
|
|
|
|
return historiesWithDetails;
|
|
} catch (e) {
|
|
printV("fetchTransactions $e");
|
|
return {};
|
|
}
|
|
}
|
|
|
|
Future<void> fetchTransactionsForAddressType(
|
|
Map<String, ElectrumTransactionInfo> historiesWithDetails,
|
|
BitcoinAddressType type, {
|
|
int? accountIndex,
|
|
}) async {
|
|
final addressesByType = walletAddresses.allAddresses
|
|
.where((addr) => addr.type == type)
|
|
.where((addr) => accountIndex == null || addr.accountIndex == accountIndex)
|
|
.toList();
|
|
|
|
|
|
final branchCache = <String, List<BitcoinAddressRecord>>{};
|
|
List<BitcoinAddressRecord> branchFor(BitcoinAddressRecord record) =>
|
|
branchCache.putIfAbsent(
|
|
'${record.accountIndex}:${record.isHidden}:${record.isLegacyDerivation}',
|
|
() => getAddressBranchByType(
|
|
type: type,
|
|
hidden: record.isHidden,
|
|
legacy: record.isLegacyDerivation,
|
|
accountIndex: record.accountIndex,
|
|
),
|
|
);
|
|
|
|
walletAddresses.hiddenAddresses
|
|
.addAll(addressesByType.where((addr) => addr.isHidden).map((e) => e.address));
|
|
await walletAddresses.saveAddressesInBox();
|
|
|
|
await Future.wait(addressesByType.map((addressRecord) async {
|
|
final result = await _fetchAddressHistory(addressRecord, await getCurrentChainTip());
|
|
|
|
if (result.hasHistory) {
|
|
historiesWithDetails.addAll(result.transactions);
|
|
|
|
final matchedAddresses = branchFor(addressRecord);
|
|
final isUsedAddressAboveGap = matchedAddresses.indexOf(addressRecord) >=
|
|
matchedAddresses.length -
|
|
(addressRecord.isHidden
|
|
? ElectrumWalletAddressesBase.defaultChangeAddressesCount
|
|
: ElectrumWalletAddressesBase.defaultReceiveAddressesCount);
|
|
|
|
if (isUsedAddressAboveGap) {
|
|
|
|
// Discover new addresses for the same address type until the gap limit is respected
|
|
await walletAddresses.discoverAddresses(
|
|
matchedAddresses,
|
|
addressRecord.isHidden,
|
|
(address) async {
|
|
await subscribeForUpdates();
|
|
return _fetchAddressHistory(address, await getCurrentChainTip())
|
|
.then((result) => result.hasHistory ? address.address : null);
|
|
},
|
|
type: type,
|
|
isLegacyDerivation: addressRecord.isLegacyDerivation,
|
|
accountIndex: addressRecord.accountIndex,
|
|
);
|
|
|
|
}
|
|
}
|
|
}),);
|
|
}
|
|
|
|
Future<AddressHistoryResult> _fetchAddressHistory(
|
|
BitcoinAddressRecord addressRecord, int? currentHeight) =>
|
|
_fetchAddressHistories([addressRecord], currentHeight, addressHistoryChunkSize);
|
|
|
|
Future<AddressHistoryResult> _fetchAddressHistories(
|
|
List<BitcoinAddressRecord> addressRecords,
|
|
int? currentHeight,
|
|
int historyChunkSize) async {
|
|
final scan = await _scanAddressHistories(addressRecords, historyChunkSize);
|
|
|
|
final split = await _markUsedAndSplitHistory(scan, addressRecords, currentHeight);
|
|
|
|
_enqueueMissingHistory(split.missingHistoryItems);
|
|
|
|
return split;
|
|
}
|
|
|
|
void _enqueueMissingHistory(List<Map<String, dynamic>> missingHistoryItems) {
|
|
for (final item in missingHistoryItems) {
|
|
final txid = item['tx_hash'] as String?;
|
|
if (txid == null || txid.isEmpty) continue;
|
|
_missingHistoryQueue.putIfAbsent(txid, () => item);
|
|
}
|
|
}
|
|
|
|
Future<void> resolveQueuedTransactionDetails() {
|
|
final inProgress = _resolveMissingHistoryFuture;
|
|
if (inProgress != null) return inProgress;
|
|
|
|
if (_missingHistoryQueue.isEmpty) return Future.value();
|
|
|
|
final future = _drainMissingHistoryQueue();
|
|
_resolveMissingHistoryFuture = future;
|
|
return future.whenComplete(() => _resolveMissingHistoryFuture = null);
|
|
}
|
|
|
|
Future<void> _drainMissingHistoryQueue() async {
|
|
final watch = Stopwatch()..start();
|
|
var resolvedCount = 0;
|
|
try {
|
|
printV('[QUICK_SYNC] resolving ${_missingHistoryQueue.length} deferred transactions');
|
|
|
|
while (_missingHistoryQueue.isNotEmpty) {
|
|
final queued = _missingHistoryQueue.values.toList(growable: false);
|
|
_missingHistoryQueue.clear();
|
|
final resolved = await _resolveTransactions(queued, addressHistoryChunkSize);
|
|
resolvedCount += resolved.length;
|
|
}
|
|
} finally {
|
|
printV(
|
|
'[QUICK_SYNC] resolved $resolvedCount deferred transactions in ${watch.elapsedMilliseconds} ms');
|
|
}
|
|
}
|
|
|
|
Future<AddressHistoryScan> _scanAddressHistories(
|
|
List<BitcoinAddressRecord> addressRecords, int historyChunkSize) async {
|
|
final historyByScriptHash = <String, List<Map<String, dynamic>>>{};
|
|
var hadFailures = false;
|
|
|
|
if (shouldUseBatchFetching) {
|
|
final scriptHashes = addressRecords.map((a) => a.getScriptHash(network)).toList();
|
|
|
|
historyByScriptHash.addAll(
|
|
await _processChunksToMap<String, String, List<Map<String, dynamic>>>(
|
|
items: scriptHashes,
|
|
chunkSize: historyChunkSize,
|
|
processChunk: _getHistoryBatch,
|
|
onChunkError: (chunk, error) {
|
|
hadFailures = true;
|
|
printV('address history scan failed for ${chunk.length} scripthashes: $error');
|
|
},
|
|
),
|
|
);
|
|
|
|
return AddressHistoryScan(
|
|
historyByScriptHash: historyByScriptHash,
|
|
hadFailures: hadFailures,
|
|
);
|
|
}
|
|
|
|
await Future.wait(addressRecords.map((addressRecord) async {
|
|
final scriptHash = addressRecord.getScriptHash(network);
|
|
|
|
try {
|
|
historyByScriptHash[scriptHash] = await electrumClient.getHistory(scriptHash);
|
|
} catch (e) {
|
|
hadFailures = true;
|
|
printV('address history scan failed for ${addressRecord.address}: $e');
|
|
}
|
|
}));
|
|
|
|
return AddressHistoryScan(
|
|
historyByScriptHash: historyByScriptHash,
|
|
hadFailures: hadFailures,
|
|
);
|
|
}
|
|
|
|
Future<AddressHistoryResult> _markUsedAndSplitHistory(AddressHistoryScan scan,
|
|
List<BitcoinAddressRecord> addressRecords, int? currentHeight) async {
|
|
|
|
String lastTxId = '';
|
|
bool didUpdateHistory = false;
|
|
|
|
try {
|
|
final Map<String, ElectrumTransactionInfo> transactions = {};
|
|
final missingHistoryItems = <Map<String, dynamic>>[];
|
|
var hasHistory = false;
|
|
|
|
final byScriptHash = <String, BitcoinAddressRecord>{};
|
|
for (final a in addressRecords) {
|
|
byScriptHash[a.getScriptHash(network)] = a;
|
|
}
|
|
|
|
for (final entry in scan.historyByScriptHash.entries) {
|
|
final sh = entry.key;
|
|
final addressRecord = byScriptHash[sh];
|
|
if (addressRecord == null) continue;
|
|
|
|
final history = entry.value;
|
|
if (history.isEmpty) continue;
|
|
|
|
hasHistory = true;
|
|
addressRecord.setAsUsed();
|
|
addressRecord.txCount = history.length;
|
|
walletAddresses.clearLockIfMatches(addressRecord.type, addressRecord.address);
|
|
|
|
//removes transactions no longer returned by the api, presumed replaced/invalid.
|
|
if (this is BitcoinWallet) {
|
|
final beforeLen = transactionHistory.transactions.length;
|
|
transactionHistory.transactions.removeWhere((hash, tx) {
|
|
return tx.outputAddresses != null &&
|
|
tx.outputAddresses!.contains(addressRecord.address) &&
|
|
!history.any((h) => h['tx_hash'] == hash);
|
|
});
|
|
if (transactionHistory.transactions.length != beforeLen) {
|
|
didUpdateHistory = true;
|
|
}
|
|
}
|
|
|
|
for (final item in history) {
|
|
final txid = item['tx_hash'] as String?;
|
|
final height = item['height'] as int? ?? 0;
|
|
if (txid == null || txid.isEmpty) continue;
|
|
|
|
lastTxId = txid;
|
|
|
|
final storedTx = transactionHistory.transactions[txid];
|
|
// If we've already tried resolving this tx's account owner
|
|
// several times and it still can't be determined, stop treating it
|
|
// as "missing" every scan - otherwise we'd refetch its full raw tx
|
|
// (and all its inputs' raw txs) forever with no chance of ever
|
|
// converging.
|
|
final hasExhaustedAccountRetries =
|
|
(_unresolvedAccountRetryCount[txid] ?? 0) >= _maxUnresolvedAccountRetries;
|
|
final needsAccount = type == WalletType.bitcoin &&
|
|
storedTx != null &&
|
|
storedTx.accountIndex == null &&
|
|
!hasExhaustedAccountRetries;
|
|
|
|
if (storedTx != null && !needsAccount) {
|
|
if (height > 0) {
|
|
final oldHeight = storedTx.height;
|
|
final oldConfs = storedTx.confirmations;
|
|
final oldPending = storedTx.isPending;
|
|
|
|
storedTx.height = height;
|
|
|
|
// the tx's block itself is the first confirmation so add 1
|
|
if ((currentHeight ?? 0) > 0) {
|
|
storedTx.confirmations = currentHeight! - height + 1;
|
|
}
|
|
|
|
storedTx.isPending = storedTx.confirmations == 0;
|
|
|
|
if (storedTx.height != oldHeight ||
|
|
storedTx.confirmations != oldConfs ||
|
|
storedTx.isPending != oldPending) {
|
|
transactionHistory.addOne(storedTx);
|
|
didUpdateHistory = true;
|
|
}
|
|
}
|
|
|
|
transactions[txid] = storedTx;
|
|
} else {
|
|
missingHistoryItems.add({
|
|
'tx_hash': txid,
|
|
'height': height,
|
|
'script_hash': sh,
|
|
'address': addressRecord.address,
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
if (didUpdateHistory) {
|
|
await transactionHistory.save();
|
|
}
|
|
|
|
return AddressHistoryResult(
|
|
transactions: transactions,
|
|
missingHistoryItems: missingHistoryItems,
|
|
hasHistory: hasHistory,
|
|
hadFailures: scan.hadFailures,
|
|
);
|
|
} catch (e, stacktrace) {
|
|
final prefix = lastTxId.isNotEmpty ? '$lastTxId - ' : '';
|
|
_onError?.call(FlutterErrorDetails(
|
|
exception: '$prefix$e',
|
|
stack: stacktrace,
|
|
library: runtimeType.toString(),
|
|
));
|
|
return AddressHistoryResult(
|
|
transactions: {},
|
|
missingHistoryItems: const [],
|
|
hasHistory: false,
|
|
hadFailures: true,
|
|
);
|
|
}
|
|
}
|
|
|
|
// Tracks how many times we've resolved a tx and still couldn't determine
|
|
// its owning account. Used by `_markUsedAndSplitHistory` to stop
|
|
// requeueing a tx forever when its account can never be determined.
|
|
void _trackAccountResolution(ElectrumTransactionInfo tx) {
|
|
if (type != WalletType.bitcoin) return;
|
|
|
|
if (tx.accountIndex == null) {
|
|
_unresolvedAccountRetryCount.update(tx.id, (count) => count + 1, ifAbsent: () => 1);
|
|
} else {
|
|
_unresolvedAccountRetryCount.remove(tx.id);
|
|
}
|
|
}
|
|
|
|
Future<Map<String, ElectrumTransactionInfo>> _resolveTransactions(
|
|
List<Map<String, dynamic>> missingHistoryItems, int historyChunkSize) async {
|
|
final Map<String, ElectrumTransactionInfo> resolved = {};
|
|
|
|
if (missingHistoryItems.isEmpty) return resolved;
|
|
|
|
if (!shouldUseBatchFetching) {
|
|
await Future.wait(missingHistoryItems.map((item) async {
|
|
final txid = (item['tx_hash'] as String).trim();
|
|
if (txid.isEmpty) return;
|
|
|
|
try {
|
|
final tx = await fetchTransactionInfo(
|
|
hash: txid,
|
|
height: item['height'] as int?,
|
|
retryOnFailure: true,
|
|
);
|
|
|
|
if (tx == null) return;
|
|
|
|
resolved[tx.id] = tx;
|
|
|
|
_trackAccountResolution(tx);
|
|
|
|
_applyLitecoinPegOutTag(tx);
|
|
|
|
transactionHistory.addOne(tx);
|
|
await transactionHistory.save();
|
|
} catch (e, stacktrace) {
|
|
_onError?.call(FlutterErrorDetails(
|
|
exception: '$txid - $e',
|
|
stack: stacktrace,
|
|
library: runtimeType.toString(),
|
|
));
|
|
}
|
|
}));
|
|
|
|
return resolved;
|
|
}
|
|
|
|
try {
|
|
for (var i = 0; i < missingHistoryItems.length; i += historyChunkSize) {
|
|
final end = (i + historyChunkSize < missingHistoryItems.length)
|
|
? i + historyChunkSize
|
|
: missingHistoryItems.length;
|
|
final chunkHistory = missingHistoryItems.sublist(i, end);
|
|
|
|
final hashes = chunkHistory
|
|
.map((e) => (e['tx_hash'] as String).trim())
|
|
.where((h) => h.isNotEmpty)
|
|
.toList(growable: false);
|
|
|
|
final heightsByHash = <String, int?>{
|
|
for (final e in chunkHistory) (e['tx_hash'] as String): (e['height'] as int?),
|
|
};
|
|
|
|
final infosByHash = await fetchTransactionInfoBatch(
|
|
hashes: hashes,
|
|
heightsByHash: heightsByHash,
|
|
retryOnFailure: true,
|
|
retryDelay: const Duration(seconds: 1),
|
|
);
|
|
|
|
bool chunkUpdatedHistory = false;
|
|
|
|
for (final txid in hashes) {
|
|
final tx = infosByHash[txid];
|
|
if (tx == null) continue;
|
|
|
|
resolved[tx.id] = tx;
|
|
|
|
_trackAccountResolution(tx);
|
|
|
|
_applyLitecoinPegOutTag(tx);
|
|
|
|
transactionHistory.addOne(tx);
|
|
chunkUpdatedHistory = true;
|
|
}
|
|
|
|
if (chunkUpdatedHistory) {
|
|
await transactionHistory.save();
|
|
}
|
|
}
|
|
|
|
return resolved;
|
|
} catch (e, stacktrace) {
|
|
_onError?.call(FlutterErrorDetails(
|
|
exception: '$e',
|
|
stack: stacktrace,
|
|
library: runtimeType.toString(),
|
|
));
|
|
return resolved;
|
|
}
|
|
}
|
|
|
|
Future<void> fetchBitcoinTransactionsForInitialRestore(
|
|
Map<String, ElectrumTransactionInfo> historiesWithDetails,
|
|
) async {
|
|
int accountIndex = 0;
|
|
|
|
while (accountIndex < maxProbAccounts) {
|
|
final isAccountProbe = accountIndex > 0;
|
|
|
|
if (!mainHdByTypeAndAccount.containsKey(accountIndex)) {
|
|
_prepareHdForAccount(accountIndex, currency);
|
|
}
|
|
|
|
if (!walletAddresses.accountIndexes.contains(accountIndex)) {
|
|
walletAddresses.accountIndexes.add(accountIndex);
|
|
await walletAddresses.prepareAccountAddresses(
|
|
accountIndex,
|
|
types: isAccountProbe ? EXTRA_ACCOUNT_ADDRESS_TYPES : BITCOIN_ADDRESS_TYPES,
|
|
);
|
|
}
|
|
|
|
final probeTypes = isAccountProbe ? EXTRA_ACCOUNT_ADDRESS_TYPES : BITCOIN_ADDRESS_TYPES;
|
|
|
|
for (final addressType in probeTypes) {
|
|
if (shouldUseBatchFetching) {
|
|
await fetchTransactionsForAddressTypeBatch(
|
|
historiesWithDetails,
|
|
addressType,
|
|
accountIndex: accountIndex,
|
|
);
|
|
} else {
|
|
await fetchTransactionsForAddressType(
|
|
historiesWithDetails,
|
|
addressType,
|
|
accountIndex: accountIndex,
|
|
);
|
|
}
|
|
}
|
|
|
|
final accountHasHistory = walletAddresses.allAddresses
|
|
.where((addr) => addr.accountIndex == accountIndex)
|
|
.any((addr) => addr.isUsed);
|
|
|
|
if (!accountHasHistory) {
|
|
final persistedAccounts = await walletInfo.getAccounts();
|
|
final isUserAccount =
|
|
persistedAccounts.any((account) => account.accountIndex == accountIndex);
|
|
|
|
if (isAccountProbe && !isUserAccount) {
|
|
walletAddresses.accountIndexes.remove(accountIndex);
|
|
walletAddresses.removeAddressesForAccount(accountIndex);
|
|
}
|
|
break;
|
|
}
|
|
|
|
// If the account has history, add it to the wallet (if it's not the first account).
|
|
if (isAccountProbe) {
|
|
await walletInfo.addAccount(
|
|
accountIndex: accountIndex,
|
|
label: "Account $accountIndex",
|
|
);
|
|
}
|
|
// Move on to the next account index
|
|
accountIndex++;
|
|
}
|
|
if (electrumClient.isConnected) {
|
|
await walletInfo.setAccountDiscoveryLimit(maxProbAccounts);
|
|
}
|
|
}
|
|
|
|
Future<void> fetchTransactionsForAddressTypeBatch(
|
|
Map<String, ElectrumTransactionInfo> historiesWithDetails,
|
|
BitcoinAddressType type, {
|
|
int? accountIndex,
|
|
}) async {
|
|
final addressesByType = walletAddresses.allAddresses
|
|
.where((addr) => addr.type == type)
|
|
.where((addr) => accountIndex == null || addr.accountIndex == accountIndex)
|
|
.toList();
|
|
|
|
walletAddresses.hiddenAddresses
|
|
.addAll(addressesByType.where((addr) => addr.isHidden).map((e) => e.address));
|
|
await walletAddresses.saveAddressesInBox();
|
|
|
|
final accountIndexes = addressesByType.map((addr) => addr.accountIndex).toSet();
|
|
|
|
for (final account in accountIndexes) {
|
|
for (final isHidden in [false, true]) {
|
|
for (final isLegacyDerivation in [false, true]) {
|
|
await fetchTransactionsForAddressesBranchBatch(
|
|
historiesWithDetails,
|
|
type,
|
|
getAddressBranchByType(
|
|
type: type,
|
|
hidden: isHidden,
|
|
legacy: isLegacyDerivation,
|
|
accountIndex: account,
|
|
),
|
|
isHidden: isHidden,
|
|
isLegacyDerivation: isLegacyDerivation,
|
|
accountIndex: account,
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
Future<void> fetchTransactionsForAddressesBranchBatch(
|
|
Map<String, ElectrumTransactionInfo> historiesWithDetails,
|
|
BitcoinAddressType type,
|
|
List<BitcoinAddressRecord> branchAddresses, {
|
|
required bool isHidden,
|
|
required bool isLegacyDerivation,
|
|
required int accountIndex,
|
|
}) async {
|
|
if (branchAddresses.isEmpty) return;
|
|
|
|
final tip = await getCurrentChainTip();
|
|
final currentBranch = [...branchAddresses];
|
|
|
|
final initialHistory =
|
|
await _processChunksToMap<BitcoinAddressRecord, String, ElectrumTransactionInfo>(
|
|
items: currentBranch,
|
|
chunkSize: addressHistoryChunkSize,
|
|
processChunk: (chunk) async =>
|
|
(await _fetchAddressHistories(chunk, tip, addressHistoryChunkSize)).transactions,
|
|
);
|
|
|
|
if (initialHistory.isNotEmpty) {
|
|
historiesWithDetails.addAll(initialHistory);
|
|
}
|
|
|
|
final gapLimit = isHidden
|
|
? ElectrumWalletAddressesBase.defaultChangeAddressesCount
|
|
: ElectrumWalletAddressesBase.defaultReceiveAddressesCount;
|
|
|
|
final highestUsedIndex = _highestUsedIndex(currentBranch);
|
|
final shouldDiscover =
|
|
highestUsedIndex >= 0 && highestUsedIndex >= currentBranch.length - gapLimit;
|
|
|
|
if (!shouldDiscover) return;
|
|
|
|
final newAddresses = await walletAddresses.discoverAddressesBatch(
|
|
currentBranch,
|
|
isHidden,
|
|
(newAddresses) async {
|
|
final newHistory =
|
|
await _fetchAddressHistories(newAddresses, tip, discoveryHistoryChunkSize);
|
|
|
|
if (newHistory.transactions.isNotEmpty) {
|
|
historiesWithDetails.addAll(newHistory.transactions);
|
|
}
|
|
|
|
return newAddresses
|
|
.where((addressRecord) => addressRecord.isUsed)
|
|
.map((addressRecord) => addressRecord.address)
|
|
.toSet();
|
|
},
|
|
type: type,
|
|
isLegacyDerivation: isLegacyDerivation,
|
|
accountIndex: accountIndex,
|
|
);
|
|
|
|
if (newAddresses.isNotEmpty) {
|
|
currentBranch.addAll(newAddresses);
|
|
|
|
if (isHidden) {
|
|
walletAddresses.hiddenAddresses.addAll(newAddresses.map((e) => e.address));
|
|
await walletAddresses.saveAddressesInBox();
|
|
}
|
|
}
|
|
}
|
|
|
|
List<BitcoinAddressRecord> getAddressBranchByType({
|
|
required BitcoinAddressType type,
|
|
required bool hidden,
|
|
required bool legacy,
|
|
int? accountIndex,
|
|
}) =>
|
|
walletAddresses.allAddresses
|
|
.where((addr) =>
|
|
addr.type == type &&
|
|
(accountIndex == null || addr.accountIndex == accountIndex) &&
|
|
addr.isHidden == hidden &&
|
|
addr.isLegacyDerivation == legacy)
|
|
.toList()
|
|
..sort((a, b) => a.index.compareTo(b.index));
|
|
|
|
int _highestUsedIndex(List<BitcoinAddressRecord> addresses) {
|
|
for (int i = addresses.length - 1; i >= 0; i--) {
|
|
if (addresses[i].isUsed) return i;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
Future<Map<String, Map<String, dynamic>>> _getTransactionVerboseBatch(List<String> hashes) {
|
|
return electrumClient.getBatchTransactionVerbose(
|
|
hashes,
|
|
timeout: transactionBatchTimeoutMs,
|
|
);
|
|
}
|
|
|
|
Future<Map<String, String?>> _getTransactionHexBatch(List<String> hashes) {
|
|
return electrumClient.getBatchTransactionHex(
|
|
hashes,
|
|
timeout: transactionBatchTimeoutMs,
|
|
);
|
|
}
|
|
|
|
Future<Map<String, List<Map<String, dynamic>>>> _getHistoryBatch(List<String> scriptHashes) {
|
|
return electrumClient.getBatchHistory(
|
|
scriptHashes,
|
|
timeout: transactionBatchTimeoutMs,
|
|
);
|
|
}
|
|
|
|
Future<Map<String, List<Map<String, dynamic>>>> _getListUnspentBatch(List<String> scriptHashes) {
|
|
return electrumClient.getBatchUnspent(
|
|
scriptHashes,
|
|
timeout: transactionBatchTimeoutMs,
|
|
);
|
|
}
|
|
|
|
Future<Map<String, Map<String, dynamic>>> _getBalanceBatch(List<String> scriptHashes) {
|
|
return electrumClient.getBatchBalance(
|
|
scriptHashes,
|
|
timeout: transactionBatchTimeoutMs,
|
|
);
|
|
}
|
|
|
|
Future<Map<String, ElectrumTransactionInfo?>> fetchTransactionInfoBatch({
|
|
required List<String> hashes,
|
|
Map<String, int?>? heightsByHash,
|
|
bool retryOnFailure = false,
|
|
Duration retryDelay = const Duration(seconds: 2),
|
|
}) async {
|
|
final result = <String, ElectrumTransactionInfo?>{};
|
|
final uniqueHashes = hashes.map((h) => h.trim()).where((h) => h.isNotEmpty).toSet().toList();
|
|
|
|
if (uniqueHashes.isEmpty) return result;
|
|
|
|
await _processTransactionInfoBatch(
|
|
txIds: uniqueHashes,
|
|
result: result,
|
|
heightsByHash: heightsByHash,
|
|
);
|
|
|
|
if (retryOnFailure) {
|
|
final failedHashes = uniqueHashes.where((txId) => result[txId] == null).toList();
|
|
|
|
if (failedHashes.isNotEmpty) {
|
|
await Future.delayed(retryDelay);
|
|
|
|
await _processTransactionInfoBatch(
|
|
txIds: failedHashes,
|
|
result: result,
|
|
heightsByHash: heightsByHash,
|
|
);
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
Future<void> _processTransactionInfoBatch({
|
|
required List<String> txIds,
|
|
required Map<String, ElectrumTransactionInfo?> result,
|
|
required Map<String, int?>? heightsByHash,
|
|
}) async {
|
|
final addressesByAccount = addressesSetByAccount;
|
|
|
|
for (var i = 0; i < txIds.length; i += transactionChunkSize) {
|
|
final end =
|
|
(i + transactionChunkSize < txIds.length) ? i + transactionChunkSize : txIds.length;
|
|
final chunk = txIds.sublist(i, end);
|
|
|
|
final bundlesByHash = await getTransactionExpandedBatch(
|
|
hashes: chunk,
|
|
heightsByHash: heightsByHash,
|
|
);
|
|
|
|
for (final txId in chunk) {
|
|
try {
|
|
final bundle = bundlesByHash[txId];
|
|
if (bundle == null) {
|
|
result[txId] = null;
|
|
continue;
|
|
}
|
|
|
|
final owner = _accountForTransaction(bundle, addressesByAccount);
|
|
|
|
final info = ElectrumTransactionInfo.fromElectrumBundle(
|
|
bundle,
|
|
walletInfo.type,
|
|
network,
|
|
addresses: owner != null ? addressesByAccount[owner]! : addressesSet,
|
|
height: heightsByHash?[txId],
|
|
);
|
|
info.id = txId;
|
|
info.accountIndex = owner;
|
|
result[txId] = info;
|
|
} catch (_) {
|
|
result[txId] = null;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Future<Map<String, ElectrumTransactionBundle>> getTransactionExpandedBatch(
|
|
{required List<String> hashes, Map<String, int?>? heightsByHash}) async {
|
|
final bundles = <String, ElectrumTransactionBundle>{};
|
|
if (hashes.isEmpty) return bundles;
|
|
|
|
final verboseByHash = await _fetchTransactionVerboseBatch(hashes);
|
|
|
|
final originalByHash = _parseTransactions(verboseByHash);
|
|
|
|
final inputTxIdsByHash = _collectInputTxIdsByHash(originalByHash);
|
|
|
|
final allInputTxids = <String>{};
|
|
for (final txids in inputTxIdsByHash.values) {
|
|
allInputTxids.addAll(txids);
|
|
}
|
|
|
|
final inputTxIds = allInputTxids.toList(growable: false);
|
|
|
|
final inputVerboseByTxId = inputTxIds.isEmpty
|
|
? <String, Map<String, dynamic>>{}
|
|
: await _fetchTransactionVerboseBatch(inputTxIds);
|
|
|
|
final parsedInputTxById = _parseTransactions(inputVerboseByTxId);
|
|
|
|
return _buildTransactionBundlesBatch(
|
|
unique: hashes,
|
|
heightsByHash: heightsByHash,
|
|
tip: await getUpdatedChainTip(),
|
|
originalByHash: originalByHash,
|
|
verboseByHash: verboseByHash,
|
|
inputTxidsByHash: inputTxIdsByHash,
|
|
parsedInputTxById: parsedInputTxById,
|
|
);
|
|
}
|
|
|
|
Future<Map<String, Map<String, dynamic>>> _fetchTransactionVerboseBatch(
|
|
List<String> txIds) async {
|
|
final verboseTransactionByHash =
|
|
await _processChunksToMap<String, String, Map<String, dynamic>>(
|
|
items: txIds,
|
|
chunkSize: transactionChunkSize,
|
|
processChunk: _getTransactionVerboseBatch,
|
|
);
|
|
|
|
final emptyHex = <String>[];
|
|
for (final txId in txIds) {
|
|
final vTx = verboseTransactionByHash[txId];
|
|
if (vTx == null || vTx.isEmpty || vTx['hex'] == null) {
|
|
emptyHex.add(txId);
|
|
}
|
|
}
|
|
|
|
final hexByHash = await _processChunksToMap<String, String, String?>(
|
|
items: emptyHex,
|
|
chunkSize: transactionChunkSize,
|
|
processChunk: _getTransactionHexBatch,
|
|
);
|
|
|
|
for (final txId in txIds) {
|
|
final verbose = verboseTransactionByHash[txId] ?? <String, dynamic>{};
|
|
if ((verbose['hex'] as String?) == null) {
|
|
final hex = hexByHash[txId];
|
|
if (hex != null && hex.isNotEmpty) {
|
|
verboseTransactionByHash[txId] = {
|
|
...verbose,
|
|
'hex': hex,
|
|
};
|
|
}
|
|
}
|
|
}
|
|
|
|
return verboseTransactionByHash;
|
|
}
|
|
|
|
Map<String, BtcTransaction> _parseTransactions(
|
|
Map<String, Map<String, dynamic>> verboseByHash,
|
|
) {
|
|
final result = <String, BtcTransaction>{};
|
|
|
|
for (final entry in verboseByHash.entries) {
|
|
final hex = entry.value['hex'] as String?;
|
|
if (hex == null || hex.isEmpty) continue;
|
|
|
|
try {
|
|
result[entry.key] = BtcTransaction.fromRaw(hex);
|
|
} catch (_) {}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
Map<String, List<String>> _collectInputTxIdsByHash(
|
|
Map<String, BtcTransaction> originalByHash,
|
|
) {
|
|
final inputTxIdsByHash = <String, List<String>>{};
|
|
|
|
for (final entry in originalByHash.entries) {
|
|
final txId = entry.key;
|
|
final original = entry.value;
|
|
|
|
final inputTxIds = <String>[];
|
|
for (final vin in original.inputs) {
|
|
inputTxIds.add(vin.txId);
|
|
}
|
|
|
|
inputTxIdsByHash[txId] = inputTxIds;
|
|
}
|
|
|
|
return inputTxIdsByHash;
|
|
}
|
|
|
|
Future<Map<String, ElectrumTransactionBundle>> _buildTransactionBundlesBatch({
|
|
required List<String> unique,
|
|
required Map<String, int?>? heightsByHash,
|
|
required int tip,
|
|
required Map<String, BtcTransaction> originalByHash,
|
|
required Map<String, Map<String, dynamic>> verboseByHash,
|
|
required Map<String, List<String>> inputTxidsByHash,
|
|
required Map<String, BtcTransaction> parsedInputTxById,
|
|
}) async {
|
|
final bundles = <String, ElectrumTransactionBundle>{};
|
|
|
|
// Identify heights that need mempool timestamp lookup
|
|
final heightsNeedingTime = <int>{};
|
|
for (final txid in originalByHash.keys) {
|
|
final verbose = verboseByHash[txid] ?? const <String, dynamic>{};
|
|
final time = verbose['time'] as int?;
|
|
final h = heightsByHash?[txid];
|
|
if (time == null && h != null && h > 0) {
|
|
heightsNeedingTime.add(h);
|
|
}
|
|
}
|
|
|
|
final mempoolTimes = await _fetchBlockTimestampsFromMempoolByHeights(heightsNeedingTime);
|
|
|
|
for (final txid in unique) {
|
|
final original = originalByHash[txid];
|
|
if (original == null) continue;
|
|
|
|
final verbose = verboseByHash[txid] ?? const <String, dynamic>{};
|
|
|
|
int? time = verbose['time'] as int?;
|
|
int? confirmations = verbose['confirmations'] as int?;
|
|
final h = heightsByHash?[txid];
|
|
|
|
if (h != null) {
|
|
if (time == null && h > 0) {
|
|
final mp = mempoolTimes[h];
|
|
time = mp ?? (getDateByBitcoinHeight(h).millisecondsSinceEpoch / 1000).round();
|
|
}
|
|
|
|
if (confirmations == null && tip > 0 && h > 0) {
|
|
confirmations = tip - h + 1;
|
|
if (confirmations < 0) confirmations = 0;
|
|
}
|
|
}
|
|
|
|
final inputTxids = inputTxidsByHash[txid] ?? const <String>[];
|
|
|
|
final ins = <BtcTransaction?>[
|
|
for (final inputTxid in inputTxids) parsedInputTxById[inputTxid],
|
|
];
|
|
|
|
bundles[txid] = ElectrumTransactionBundle(
|
|
original,
|
|
ins: ins,
|
|
time: time,
|
|
confirmations: confirmations ?? 0,
|
|
);
|
|
}
|
|
|
|
return bundles;
|
|
}
|
|
|
|
Future<Map<int, int>> _fetchBlockTimestampsFromMempoolByHeights(
|
|
Set<int> heights,
|
|
) async {
|
|
final out = <int, int>{};
|
|
if (heights.isEmpty) return out;
|
|
if (!(await checkIfMempoolAPIIsEnabled())) return out;
|
|
|
|
// Best-effort: if any call fails, we just skip that height.
|
|
await Future.wait(heights.map((h) async {
|
|
try {
|
|
final blockHashResp = await ProxyWrapper()
|
|
.get(
|
|
clearnetUri: Uri.parse(
|
|
'https://mempool.cakewallet.com/api/v1/block-height/$h',
|
|
),
|
|
)
|
|
.timeout(const Duration(seconds: 15));
|
|
|
|
if (blockHashResp.statusCode != 200 || blockHashResp.body.isEmpty) return;
|
|
|
|
final blockHash = blockHashResp.body.trim();
|
|
if (blockHash.isEmpty) return;
|
|
|
|
final blockResp = await ProxyWrapper()
|
|
.get(
|
|
clearnetUri: Uri.parse(
|
|
'https://mempool.cakewallet.com/api/v1/block/$blockHash',
|
|
),
|
|
)
|
|
.timeout(const Duration(seconds: 15));
|
|
|
|
if (blockResp.statusCode != 200 || blockResp.body.isEmpty) return;
|
|
|
|
final decoded = jsonDecode(blockResp.body);
|
|
final ts = decoded is Map<String, dynamic> ? decoded['timestamp'] : null;
|
|
if (ts == null) return;
|
|
|
|
final parsed = int.tryParse(ts.toString());
|
|
if (parsed == null) return;
|
|
|
|
out[h] = parsed;
|
|
} catch (_) {
|
|
// ignore
|
|
}
|
|
}));
|
|
|
|
return out;
|
|
}
|
|
|
|
Future<Map<K, V>> _processChunksToMap<T, K, V>({
|
|
required List<T> items,
|
|
required int chunkSize,
|
|
required Future<Map<K, V>> Function(List<T> chunk) processChunk,
|
|
void Function(List<T> chunk, Object error)? onChunkError,
|
|
}) async {
|
|
final result = <K, V>{};
|
|
|
|
for (var i = 0; i < items.length; i += chunkSize) {
|
|
final end = (i + chunkSize < items.length) ? i + chunkSize : items.length;
|
|
final chunk = items.sublist(i, end);
|
|
|
|
try {
|
|
final chunkResult = await processChunk(chunk);
|
|
result.addAll(chunkResult);
|
|
} on electrum.RequestFailedTimeoutException catch (e) {
|
|
onChunkError?.call(chunk, e);
|
|
continue;
|
|
} catch (e) {
|
|
onChunkError?.call(chunk, e);
|
|
continue;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
Future<void> updateTransactions() async {
|
|
printV("updateTransactions() called!");
|
|
|
|
if (_isTransactionUpdating) {
|
|
printV("updateTransactions: already running, skipping");
|
|
return;
|
|
}
|
|
|
|
_isTransactionUpdating = true;
|
|
try {
|
|
currentChainTip = await getUpdatedChainTip();
|
|
|
|
bool updated = false;
|
|
transactionHistory.transactions.values.forEach((tx) {
|
|
if ((tx.height ?? 0) > 0 && (currentChainTip ?? 0) > 0) {
|
|
var confirmations = currentChainTip! - tx.height! + 1;
|
|
if (confirmations < 0) {
|
|
// if our chain tip is outdated then it could lead to negative confirmations so this is just a failsafe:
|
|
confirmations = 0;
|
|
}
|
|
if (confirmations != tx.confirmations) {
|
|
updated = true;
|
|
tx.confirmations = confirmations;
|
|
transactionHistory.addOne(tx);
|
|
}
|
|
}
|
|
});
|
|
|
|
if (updated) {
|
|
await transactionHistory.save();
|
|
}
|
|
|
|
await fetchTransactions();
|
|
walletAddresses.updateReceiveAddresses();
|
|
} catch (e, stacktrace) {
|
|
printV(stacktrace);
|
|
printV(e);
|
|
} finally {
|
|
_isTransactionUpdating = false;
|
|
}
|
|
}
|
|
|
|
Future<void> subscribeForUpdates() async {
|
|
final unsubscribedScriptHashes = walletAddresses.allAddresses.where(
|
|
(address) =>
|
|
!_scripthashesUpdateSubject.containsKey(address.getScriptHash(network)) &&
|
|
address.type != SegwitAddresType.mweb,
|
|
);
|
|
|
|
await Future.wait(unsubscribedScriptHashes.map((address) async {
|
|
final sh = address.getScriptHash(network);
|
|
if (!(_scripthashesUpdateSubject[sh]?.isClosed ?? true)) {
|
|
try {
|
|
await _scripthashesUpdateSubject[sh]?.close();
|
|
} catch (e) {
|
|
printV("failed to close: $e");
|
|
}
|
|
}
|
|
try {
|
|
_scripthashesUpdateSubject[sh] = await electrumClient.scripthashUpdate(sh);
|
|
} catch (e) {
|
|
printV("failed scripthashUpdate: $e");
|
|
}
|
|
_scripthashesUpdateSubject[sh]?.listen((event) async {
|
|
try {
|
|
await updateUnspentsForAddress(address);
|
|
|
|
await updateBalance();
|
|
|
|
await _fetchAddressHistory(address, await getCurrentChainTip());
|
|
await resolveQueuedTransactionDetails();
|
|
} catch (e, s) {
|
|
printV("sub error: $e");
|
|
_onError?.call(FlutterErrorDetails(
|
|
exception: e,
|
|
stack: s,
|
|
library: this.runtimeType.toString(),
|
|
));
|
|
}
|
|
}, onError: (e, s) {
|
|
printV("sub_listen error: $e $s");
|
|
});
|
|
}));
|
|
}
|
|
|
|
Future<List<Map<String, dynamic>>> fetchBalancesBatch(
|
|
List<BitcoinAddressRecord> addresses,
|
|
) async {
|
|
final scriptHashes = addresses.map((address) => address.getScriptHash(network)).toList();
|
|
|
|
if (scriptHashes.isEmpty) {
|
|
return <Map<String, dynamic>>[];
|
|
}
|
|
|
|
try {
|
|
final balancesByScriptHash = await _processChunksToMap<String, String, Map<String, dynamic>>(
|
|
items: scriptHashes,
|
|
chunkSize: addressHistoryChunkSize,
|
|
processChunk: _getBalanceBatch,
|
|
);
|
|
|
|
final balances = scriptHashes
|
|
.map((scriptHash) => balancesByScriptHash[scriptHash] ?? <String, dynamic>{})
|
|
.toList();
|
|
|
|
final hasMissingBalance = balances.any((balance) => balance['confirmed'] == null);
|
|
if (hasMissingBalance) {
|
|
printV('fetchBalancesBatch returned missing balances, falling back to regular flow');
|
|
return fetchBalancesRegular(addresses);
|
|
}
|
|
|
|
return balances;
|
|
} catch (e) {
|
|
printV('fetchBalancesBatch failed, falling back to regular flow: $e');
|
|
return fetchBalancesRegular(addresses);
|
|
}
|
|
}
|
|
|
|
Future<List<Map<String, dynamic>>> fetchBalancesRegular(
|
|
List<BitcoinAddressRecord> addresses,
|
|
) async {
|
|
final balanceFutures = <Future<Map<String, dynamic>>>[];
|
|
|
|
for (final address in addresses) {
|
|
final sh = address.getScriptHash(network);
|
|
balanceFutures.add(electrumClient.getBalance(sh));
|
|
}
|
|
|
|
return Future.wait(balanceFutures);
|
|
}
|
|
|
|
Future<ElectrumBalance> fetchBalances() async {
|
|
final addresses = walletAddresses.allAddresses
|
|
.where((address) => address.address.isNotEmpty)
|
|
.where((address) => RegexUtils.addressTypeFromStr(address.address, network) is! MwebAddress)
|
|
.toList();
|
|
|
|
List<Map<String, dynamic>> balances;
|
|
try {
|
|
balances = shouldUseBatchFetching
|
|
? await fetchBalancesBatch(addresses)
|
|
: await fetchBalancesRegular(addresses);
|
|
} catch (e) {
|
|
printV("fetchBalances network error, returning last known balance: $e");
|
|
syncStatus = LostConnectionSyncStatus();
|
|
return balance[currency] ??
|
|
ElectrumBalance(
|
|
confirmed: Money.zero(currency),
|
|
unconfirmed: Money.zero(currency),
|
|
frozen: Money.zero(currency),
|
|
);
|
|
}
|
|
|
|
printV(
|
|
'Fetched balances for ${addresses.length} addresses. Batch fetching: $shouldUseBatchFetching');
|
|
|
|
// If the balances list is empty (no addresses or all fetches silently returned nothing),
|
|
// preserve the last known balance rather than returning zero.
|
|
if (balances.isEmpty) {
|
|
return balance[currency] ??
|
|
ElectrumBalance(
|
|
confirmed: Money.zero(currency),
|
|
unconfirmed: Money.zero(currency),
|
|
frozen: Money.zero(currency),
|
|
);
|
|
}
|
|
|
|
var totalFrozen = 0;
|
|
var totalConfirmed = 0;
|
|
var totalUnconfirmed = 0;
|
|
|
|
final confirmedByAccount = <int, int>{};
|
|
final unconfirmedByAccount = <int, int>{};
|
|
final frozenByAccount = <int, int>{};
|
|
|
|
if (hasSilentPaymentsScanning) {
|
|
// Add values from unspent coins that are not fetched by the address list
|
|
// i.e. scanned silent payments
|
|
transactionHistory.transactions.values.forEach((tx) {
|
|
if (tx.unspents != null) {
|
|
tx.unspents!.forEach((unspent) {
|
|
if (unspent.bitcoinAddressRecord is BitcoinSilentPaymentAddressRecord) {
|
|
final account = unspent.bitcoinAddressRecord.accountIndex;
|
|
if (unspent.isFrozen) {
|
|
totalFrozen += unspent.value;
|
|
frozenByAccount[account] = (frozenByAccount[account] ?? 0) + unspent.value;
|
|
}
|
|
totalConfirmed += unspent.value;
|
|
confirmedByAccount[account] = (confirmedByAccount[account] ?? 0) + unspent.value;
|
|
}
|
|
});
|
|
}
|
|
});
|
|
}
|
|
|
|
unspentCoinsInfo.values.forEach((info) {
|
|
unspentCoins.forEach((element) {
|
|
if (element.bitcoinAddressRecord is BitcoinSilentPaymentAddressRecord) return;
|
|
|
|
if (element.hash == info.hash &&
|
|
element.vout == info.vout &&
|
|
element.bitcoinAddressRecord.address == info.address &&
|
|
element.value == info.value) {
|
|
if (info.isFrozen) {
|
|
totalFrozen += element.value;
|
|
final account = element.bitcoinAddressRecord.accountIndex;
|
|
frozenByAccount[account] = (frozenByAccount[account] ?? 0) + element.value;
|
|
}
|
|
}
|
|
});
|
|
});
|
|
|
|
// Check if ALL returned balances have null confirmed — indicates server is unreachable.
|
|
final allNull = balances.every((b) => b['confirmed'] == null);
|
|
if (allNull) {
|
|
// if we got null balance responses from the server, set our connection status to lost and return our last known balance:
|
|
printV("got null balance responses from the server, setting connection status to lost");
|
|
syncStatus = LostConnectionSyncStatus();
|
|
return balance[currency] ??
|
|
ElectrumBalance(
|
|
confirmed: Money.zero(currency),
|
|
unconfirmed: Money.zero(currency),
|
|
frozen: Money.zero(currency),
|
|
);
|
|
}
|
|
|
|
for (var i = 0; i < balances.length; i++) {
|
|
final addressRecord = addresses[i];
|
|
final balance = balances[i];
|
|
final confirmed = balance['confirmed'] as int? ?? 0;
|
|
final unconfirmed = balance['unconfirmed'] as int? ?? 0;
|
|
totalConfirmed += confirmed;
|
|
totalUnconfirmed += unconfirmed;
|
|
|
|
final account = addressRecord.accountIndex;
|
|
confirmedByAccount[account] = (confirmedByAccount[account] ?? 0) + confirmed;
|
|
unconfirmedByAccount[account] = (unconfirmedByAccount[account] ?? 0) + unconfirmed;
|
|
|
|
addressRecord.balance = confirmed + unconfirmed;
|
|
if (confirmed > 0 || unconfirmed > 0) {
|
|
addressRecord.setAsUsed();
|
|
walletAddresses.clearLockIfMatches(addressRecord.type, addressRecord.address);
|
|
}
|
|
}
|
|
|
|
if (hasAccountsSupport) {
|
|
final perAccount = <int, ElectrumBalance>{};
|
|
final accounts = <int>{
|
|
...confirmedByAccount.keys,
|
|
...unconfirmedByAccount.keys,
|
|
...frozenByAccount.keys,
|
|
...walletAddresses.accountIndexes,
|
|
};
|
|
|
|
for (final account in accounts) {
|
|
perAccount[account] = ElectrumBalance(
|
|
confirmed: Money.fromInt(confirmedByAccount[account] ?? 0, currency),
|
|
unconfirmed: Money.fromInt(unconfirmedByAccount[account] ?? 0, currency),
|
|
frozen: Money.fromInt(frozenByAccount[account] ?? 0, currency),
|
|
);
|
|
}
|
|
|
|
accountBalances = ObservableMap<int, ElectrumBalance>.of(perAccount);
|
|
}
|
|
|
|
return ElectrumBalance(
|
|
confirmed: Money.fromInt(totalConfirmed, currency),
|
|
unconfirmed: Money.fromInt(totalUnconfirmed, currency),
|
|
frozen: Money.fromInt(totalFrozen, currency),
|
|
);
|
|
}
|
|
|
|
List<ElectrumTransactionInfo> get currentAccountBitcoinTransactions {
|
|
final all = transactionHistory.transactions.values;
|
|
if (!hasAccountsSupport) return all.toList();
|
|
|
|
final accountIndex = currentAccountIndex;
|
|
final accountAddresses = walletAddresses.allAddresses
|
|
.where((a) => a.accountIndex == accountIndex)
|
|
.map((a) => a.address)
|
|
.toSet();
|
|
|
|
return all.where((tx) {
|
|
|
|
if (tx.additionalInfo["isLightning"] == true) return accountIndex == 0;
|
|
if (tx.isReceivedSilentPayment) return accountIndex == 0;
|
|
|
|
// Locally created transactions store the account index explicitly,
|
|
// so use it first instead of checking the addresses.
|
|
if (tx.accountIndex != null) return tx.accountIndex == accountIndex;
|
|
|
|
return (tx.inputAddresses ?? const <String>[]).any(accountAddresses.contains) ||
|
|
(tx.outputAddresses ?? const <String>[]).any(accountAddresses.contains);
|
|
}).toList();
|
|
}
|
|
|
|
Future<void> updateBalance() async {
|
|
printV("updateBalance() called!");
|
|
|
|
if (!electrumClient.isConnected) {
|
|
printV("updateBalance: not connected, keeping existing balance");
|
|
return;
|
|
}
|
|
|
|
try {
|
|
final fetchedTotal = await fetchBalances();
|
|
|
|
if (!electrumClient.isConnected || syncStatus is LostConnectionSyncStatus) {
|
|
printV("updateBalance: connection lost during fetch, keeping existing balance");
|
|
return;
|
|
}
|
|
|
|
if (type == WalletType.bitcoin && hasAccountsSupport) {
|
|
// If the wallet has accounts support, we only want to update the balance for the current account.
|
|
final accountBalance = accountBalances[currentAccountIndex];
|
|
if (accountBalance != null) {
|
|
balance[currency] = accountBalance.copy();
|
|
} else {
|
|
printV("updateBalance: no balance for account $currentAccountIndex, keeping existing");
|
|
}
|
|
} else {
|
|
balance[currency] = fetchedTotal;
|
|
}
|
|
|
|
await save();
|
|
} catch (e) {
|
|
printV("updateBalance failed: $e");
|
|
}
|
|
}
|
|
|
|
@override
|
|
Future<bool> checkNodeHealth() async {
|
|
try {
|
|
final addresses = walletAddresses.allAddresses
|
|
.where(
|
|
(address) => RegexUtils.addressTypeFromStr(address.address, network) is! MwebAddress)
|
|
.toList();
|
|
|
|
if (addresses.isEmpty) {
|
|
return false;
|
|
}
|
|
|
|
final firstAddress = addresses.first;
|
|
final sh = firstAddress.getScriptHash(network);
|
|
await electrumClient.getBalance(sh, throwOnError: true);
|
|
return true;
|
|
} catch (e) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
@override
|
|
void setExceptionHandler(void Function(FlutterErrorDetails) onError) => _onError = onError;
|
|
|
|
@override
|
|
Future<String> signMessage(String message, {String? address = null}) async {
|
|
final addressRecord = address != null
|
|
? walletAddresses.allAddresses.firstWhereOrNull((addr) => addr.address == address)
|
|
: null;
|
|
|
|
if (addressRecord != null && addressRecord.type == SegwitAddresType.p2tr) {
|
|
throw UnsupportedError("Cannot sign message with Taproot address");
|
|
}
|
|
|
|
final hd = addressRecord != null
|
|
? _hdForAddressRecord(record: addressRecord).childKey(Bip32KeyIndex(addressRecord.index))
|
|
: mainHd;
|
|
|
|
final priv = ECPrivate.fromHex(hd.privateKey.privKey.toHex());
|
|
|
|
String messagePrefix = '\x18Bitcoin Signed Message:\n';
|
|
final hexEncoded = priv.signMessage(utf8.encode(message), messagePrefix: messagePrefix);
|
|
final decodedSig = hex.decode(hexEncoded);
|
|
return base64Encode(decodedSig);
|
|
}
|
|
|
|
void _applyLitecoinPegOutTag(ElectrumTransactionInfo tx) {
|
|
if (this is! LitecoinWallet) return;
|
|
|
|
// if we have a peg out transaction with the same value
|
|
// that matches this received transaction, mark it as being from a peg out:
|
|
for (final tx2 in transactionHistory.transactions.values) {
|
|
final heightDiff = ((tx2.height ?? 0) - (tx.height ?? 0)).abs();
|
|
// this isn't a perfect matching algorithm since we don't have the right input/output information from these transaction models (the addresses are in different formats), but this should be more than good enough for now as it's extremely unlikely a user receives the EXACT same amount from 2 different sources and one of them is a peg out and the other isn't WITHIN 5 blocks of each other
|
|
if (tx2.additionalInfo["isPegOut"] == true && tx2.amount == tx.amount && heightDiff <= 5) {
|
|
tx.additionalInfo["fromPegOut"] = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
Future<void> checkIfBatchSupported() async {
|
|
if (_isBatchSupported != null) {
|
|
printV('[BATCH_TEST] Already checked: $_isBatchSupported');
|
|
return;
|
|
}
|
|
|
|
final hashes = publicScriptHashes.take(batchTestHashesCount).toList();
|
|
|
|
if (hashes.length < batchTestHashesCount) {
|
|
_isBatchSupported = false;
|
|
printV('[BATCH_TEST] Failed: not enough script hashes');
|
|
return;
|
|
}
|
|
|
|
try {
|
|
final paramsList = hashes.map((hash) => <Object>[hash]).toList();
|
|
|
|
printV('[BATCH_TEST] Start: hashes=${hashes.length}, timeout=${batchTestTimeoutMs}ms');
|
|
|
|
final result = await electrumClient.callBatchWithTimeout(
|
|
method: 'blockchain.scripthash.get_history',
|
|
paramsList: paramsList,
|
|
timeout: batchTestTimeoutMs,
|
|
);
|
|
|
|
final hasError = result.any((item) =>
|
|
item is Map<String, dynamic> && item.containsKey('error') && item['error'] != null);
|
|
|
|
if (hasError) {
|
|
_isBatchSupported = false;
|
|
printV('[BATCH_TEST] Result: supported=false (server returned error)');
|
|
return;
|
|
}
|
|
|
|
_isBatchSupported = true;
|
|
printV('[BATCH_TEST] Result: supported=true');
|
|
} on electrum.RequestFailedTimeoutException catch (e) {
|
|
_isBatchSupported = false;
|
|
printV('[BATCH_TEST] Timeout: $e');
|
|
} catch (e) {
|
|
_isBatchSupported = false;
|
|
printV('[BATCH_TEST] Exception: $e');
|
|
}
|
|
}
|
|
|
|
@override
|
|
Future<bool> verifyMessage(String message, String signature, {String? address = null}) async {
|
|
if (address == null) {
|
|
return false;
|
|
}
|
|
|
|
List<int> sigDecodedBytes = [];
|
|
|
|
if (signature.endsWith('=')) {
|
|
sigDecodedBytes = base64.decode(signature);
|
|
} else {
|
|
sigDecodedBytes = hex.decode(signature);
|
|
}
|
|
|
|
if (sigDecodedBytes.length != 64 && sigDecodedBytes.length != 65) {
|
|
throw ArgumentException(
|
|
"signature must be 64 bytes without recover-id or 65 bytes with recover-id");
|
|
}
|
|
|
|
String messagePrefix = '\x18Bitcoin Signed Message:\n';
|
|
final messageHash = QuickCrypto.sha256Hash(
|
|
BitcoinSignerUtils.magicMessage(utf8.encode(message), messagePrefix));
|
|
|
|
List<int> correctSignature =
|
|
sigDecodedBytes.length == 65 ? sigDecodedBytes.sublist(1) : List.from(sigDecodedBytes);
|
|
List<int> rBytes = correctSignature.sublist(0, 32);
|
|
List<int> sBytes = correctSignature.sublist(32);
|
|
final sig = ECDSASignature(BigintUtils.fromBytes(rBytes), BigintUtils.fromBytes(sBytes));
|
|
|
|
List<int> possibleRecoverIds = [0, 1];
|
|
|
|
final baseAddress = RegexUtils.addressTypeFromStr(address, network);
|
|
|
|
for (int recoveryId in possibleRecoverIds) {
|
|
final pubKey = sig.recoverPublicKey(messageHash, Curves.generatorSecp256k1, recoveryId);
|
|
|
|
final recoveredPub = ECPublic.fromBytes(pubKey!.toBytes());
|
|
|
|
String? recoveredAddress;
|
|
|
|
if (baseAddress is P2pkAddress) {
|
|
recoveredAddress = recoveredPub.toP2pkAddress().toAddress(network);
|
|
} else if (baseAddress is P2pkhAddress) {
|
|
recoveredAddress = recoveredPub.toP2pkhAddress().toAddress(network);
|
|
} else if (baseAddress is P2wshAddress) {
|
|
recoveredAddress = recoveredPub.toP2wshAddress().toAddress(network);
|
|
} else if (baseAddress is P2wpkhAddress) {
|
|
recoveredAddress = recoveredPub.toP2wpkhAddress().toAddress(network);
|
|
}
|
|
|
|
if (recoveredAddress == address) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
Future<void> _setInitialHeight() async {
|
|
if (_chainTipUpdateSubject != null) return;
|
|
|
|
currentChainTip = await getUpdatedChainTip();
|
|
|
|
if ((currentChainTip == null || currentChainTip! == 0) && walletInfo.restoreHeight == 0) {
|
|
await walletInfo.updateRestoreHeight(currentChainTip!);
|
|
}
|
|
|
|
_chainTipUpdateSubject = electrumClient.chainTipSubscribe();
|
|
_chainTipUpdateSubject?.listen((e) async {
|
|
final event = e as Map<String, dynamic>;
|
|
final height = int.tryParse(event['height'].toString());
|
|
|
|
if (height != null) {
|
|
currentChainTip = height;
|
|
|
|
if (alwaysScan == true && syncStatus is SyncedSyncStatus) {
|
|
_setListeners(walletInfo.restoreHeight);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
static String _hardenedDerivationPath(String derivationPath) =>
|
|
derivationPath.substring(0, derivationPath.lastIndexOf("'") + 1);
|
|
|
|
@action
|
|
void _onConnectionStatusChange(electrum.ConnectionStatus status) {
|
|
switch (status) {
|
|
case electrum.ConnectionStatus.connected:
|
|
if (syncStatus is NotConnectedSyncStatus ||
|
|
syncStatus is LostConnectionSyncStatus ||
|
|
syncStatus is ConnectingSyncStatus) {
|
|
syncStatus = ConnectedSyncStatus();
|
|
}
|
|
|
|
break;
|
|
case electrum.ConnectionStatus.disconnected:
|
|
// Always show disconnected status when connection is lost, regardless of current sync state
|
|
if (syncStatus is! NotConnectedSyncStatus) {
|
|
syncStatus = NotConnectedSyncStatus();
|
|
}
|
|
break;
|
|
case electrum.ConnectionStatus.failed:
|
|
if (syncStatus is! LostConnectionSyncStatus) {
|
|
syncStatus = LostConnectionSyncStatus();
|
|
}
|
|
break;
|
|
case electrum.ConnectionStatus.connecting:
|
|
if (syncStatus is! ConnectingSyncStatus) {
|
|
syncStatus = ConnectingSyncStatus();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
void _syncStatusReaction(SyncStatus syncStatus) async {
|
|
printV("SYNC_STATUS_CHANGE: ${syncStatus}");
|
|
if (syncStatus is SyncingSyncStatus) {
|
|
return;
|
|
}
|
|
|
|
if (syncStatus is NotConnectedSyncStatus || syncStatus is LostConnectionSyncStatus) {
|
|
// Needs to re-subscribe to all scripthashes when reconnected
|
|
_scripthashesUpdateSubject = {};
|
|
|
|
if (_isTryingToConnect) return;
|
|
|
|
_isTryingToConnect = true;
|
|
|
|
Timer(Duration(seconds: 5), () {
|
|
if (this.syncStatus is NotConnectedSyncStatus ||
|
|
this.syncStatus is LostConnectionSyncStatus) {
|
|
this.electrumClient.connectToUri(
|
|
node!.uri,
|
|
useSSL: node!.useSSL ?? false,
|
|
);
|
|
}
|
|
_isTryingToConnect = false;
|
|
});
|
|
}
|
|
|
|
// Message is shown on the UI for 3 seconds, revert to synced
|
|
if (syncStatus is SyncedTipSyncStatus) {
|
|
Timer(Duration(seconds: 3), () {
|
|
if (this.syncStatus is SyncedTipSyncStatus) this.syncStatus = SyncedSyncStatus();
|
|
});
|
|
}
|
|
}
|
|
|
|
void _updateInputsAndOutputs(ElectrumTransactionInfo tx, ElectrumTransactionBundle bundle) {
|
|
tx.inputAddresses = tx.inputAddresses?.where((address) => address.isNotEmpty).toList();
|
|
|
|
if (tx.inputAddresses == null ||
|
|
tx.inputAddresses!.isEmpty ||
|
|
tx.outputAddresses == null ||
|
|
tx.outputAddresses!.isEmpty) {
|
|
List<String> inputAddresses = [];
|
|
List<String> outputAddresses = [];
|
|
|
|
for (int i = 0; i < bundle.originalTransaction.inputs.length; i++) {
|
|
final input = bundle.originalTransaction.inputs[i];
|
|
final inputTransaction = bundle.ins[i];
|
|
if (inputTransaction == null) continue;
|
|
final vout = input.txIndex;
|
|
final outTransaction = inputTransaction.outputs[vout];
|
|
final address = addressFromOutputScript(outTransaction.scriptPubKey, network);
|
|
|
|
if (address.isNotEmpty) inputAddresses.add(address);
|
|
}
|
|
|
|
for (int i = 0; i < bundle.originalTransaction.outputs.length; i++) {
|
|
final out = bundle.originalTransaction.outputs[i];
|
|
final address = addressFromOutputScript(out.scriptPubKey, network);
|
|
|
|
if (address.isNotEmpty) outputAddresses.add(address);
|
|
|
|
// Check if the script contains OP_RETURN
|
|
final script = out.scriptPubKey.script;
|
|
if (script.contains('OP_RETURN')) {
|
|
final index = script.indexOf('OP_RETURN');
|
|
if (index + 1 <= script.length) {
|
|
try {
|
|
final opReturnData = script[index + 1].toString();
|
|
final decodedString = utf8.decode(HEX.decode(opReturnData));
|
|
outputAddresses.add('OP_RETURN:$decodedString');
|
|
} catch (_) {
|
|
outputAddresses.add('OP_RETURN:');
|
|
}
|
|
}
|
|
}
|
|
}
|
|
tx.inputAddresses = inputAddresses;
|
|
tx.outputAddresses = outputAddresses;
|
|
|
|
transactionHistory.addOne(tx);
|
|
}
|
|
}
|
|
|
|
/// Checks the health of the socket connection
|
|
/// and triggers a full reconnection if needed
|
|
@override
|
|
Future<bool> checkSocketHealth() async {
|
|
try {
|
|
SocketHealthLogger().logHealthCheck(
|
|
walletType: type,
|
|
walletName: name,
|
|
syncStatus: syncStatus.toString(),
|
|
wasReconnected: false,
|
|
trigger: 'socket_health_check_start',
|
|
);
|
|
|
|
if (!electrumClient.isConnected || !electrumClient.isInternalStateConsistent) {
|
|
if (!electrumClient.isConnected) {
|
|
SocketHealthLogger().logHealthCheck(
|
|
walletType: type,
|
|
walletName: name,
|
|
isHealthy: false,
|
|
syncStatus: syncStatus.toString(),
|
|
wasReconnected: false,
|
|
trigger: 'socket_health_check_socket_not_connected',
|
|
);
|
|
}
|
|
|
|
if (!electrumClient.isInternalStateConsistent) {
|
|
SocketHealthLogger().logHealthCheck(
|
|
walletType: type,
|
|
walletName: name,
|
|
isHealthy: false,
|
|
syncStatus: syncStatus.toString(),
|
|
wasReconnected: false,
|
|
trigger: 'socket_health_check_internal_state_inconsistent',
|
|
);
|
|
}
|
|
|
|
await _performFullReconnection();
|
|
|
|
SocketHealthLogger().logHealthCheck(
|
|
walletType: type,
|
|
walletName: name,
|
|
isHealthy: true,
|
|
syncStatus: syncStatus.toString(),
|
|
wasReconnected: true,
|
|
trigger:
|
|
'socket_health_check_reconnection_success_for_unhealthy_basic_check_or_internal_state_inconsistent',
|
|
);
|
|
|
|
return true;
|
|
}
|
|
|
|
// Make a call to the server to check if the connection is healthy
|
|
// If the call fails, we need to reconnect
|
|
try {
|
|
final result = await electrumClient.call(
|
|
method: 'server.version',
|
|
params: ['', '1.4'],
|
|
);
|
|
|
|
if (result == null) {
|
|
throw Exception('Call mechanism test returned null');
|
|
}
|
|
|
|
SocketHealthLogger().logHealthCheck(
|
|
walletType: type,
|
|
walletName: name,
|
|
isHealthy: true,
|
|
syncStatus: syncStatus.toString(),
|
|
wasReconnected: false,
|
|
trigger: 'socket_health_check_server_state_ok',
|
|
);
|
|
|
|
return true;
|
|
} catch (e) {
|
|
SocketHealthLogger().logHealthCheck(
|
|
walletType: type,
|
|
walletName: name,
|
|
isHealthy: false,
|
|
error: e.toString(),
|
|
syncStatus: syncStatus.toString(),
|
|
wasReconnected: false,
|
|
trigger: 'socket_health_check_server_state_failed',
|
|
);
|
|
|
|
await _performFullReconnection();
|
|
|
|
SocketHealthLogger().logHealthCheck(
|
|
walletType: type,
|
|
walletName: name,
|
|
isHealthy: true,
|
|
syncStatus: syncStatus.toString(),
|
|
wasReconnected: true,
|
|
trigger: 'socket_health_check_reconnection_success_for_server_state_failed',
|
|
);
|
|
|
|
return true;
|
|
}
|
|
} catch (e) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
Future<void> _performFullReconnection() async {
|
|
try {
|
|
SocketHealthLogger().logHealthCheck(
|
|
walletType: type,
|
|
walletName: name,
|
|
syncStatus: syncStatus.toString(),
|
|
wasReconnected: true,
|
|
trigger: 'full_reconnection_start',
|
|
);
|
|
|
|
await _receiveStream?.cancel();
|
|
|
|
await electrumClient.close();
|
|
|
|
if (node != null) {
|
|
electrumClient.onConnectionStatusChange = _onConnectionStatusChange;
|
|
|
|
await electrumClient.connectToUri(node!.uri, useSSL: node!.useSSL);
|
|
|
|
await startSync();
|
|
|
|
SocketHealthLogger().logHealthCheck(
|
|
walletType: type,
|
|
walletName: name,
|
|
isHealthy: true,
|
|
syncStatus: syncStatus.toString(),
|
|
wasReconnected: true,
|
|
trigger: 'full_reconnection_success',
|
|
);
|
|
}
|
|
} catch (e) {
|
|
SocketHealthLogger().logHealthCheck(
|
|
walletType: type,
|
|
walletName: name,
|
|
isHealthy: false,
|
|
error: e.toString(),
|
|
syncStatus: syncStatus.toString(),
|
|
wasReconnected: false,
|
|
trigger: 'full_reconnection_failed',
|
|
);
|
|
|
|
syncStatus = FailedSyncStatus();
|
|
}
|
|
}
|
|
|
|
Bip32Slip10Secp256k1 _hdForAddressRecord({required BaseBitcoinAddressRecord record}) {
|
|
final addrType = record.type;
|
|
|
|
if (record.isLegacyDerivation) {
|
|
return record.isHidden ? walletAddresses.legacySideHd : walletAddresses.legacyMainHd;
|
|
}
|
|
|
|
final accountIndex = record.accountIndex;
|
|
|
|
if (record.isHidden) {
|
|
return sideHdByTypeAndAccount[accountIndex]?[addrType] ?? sideHd;
|
|
} else {
|
|
return mainHdByTypeAndAccount[accountIndex]?[addrType] ?? mainHd;
|
|
}
|
|
}
|
|
}
|
|
|
|
class ScanNode {
|
|
final Uri uri;
|
|
final bool? useSSL;
|
|
|
|
ScanNode(this.uri, this.useSSL);
|
|
}
|
|
|
|
class ScanData {
|
|
final SendPort sendPort;
|
|
final SilentPaymentOwner silentAddress;
|
|
final Bip32Slip10Secp256k1 masterHD;
|
|
final int height;
|
|
final ScanNode? node;
|
|
final BasedUtxoNetwork network;
|
|
final int chainTip;
|
|
final electrum.ElectrumClient electrumClient;
|
|
final List<String> transactionHistoryIds;
|
|
final Map<String, String> labels;
|
|
final List<int> labelIndexes;
|
|
final bool isSingleScan;
|
|
final String debugLogPath;
|
|
final List<int>? rescanHeights;
|
|
|
|
ScanData({
|
|
required this.sendPort,
|
|
required this.silentAddress,
|
|
required this.masterHD,
|
|
required this.height,
|
|
required this.node,
|
|
required this.network,
|
|
required this.chainTip,
|
|
required this.electrumClient,
|
|
required this.transactionHistoryIds,
|
|
required this.labels,
|
|
required this.labelIndexes,
|
|
required this.isSingleScan,
|
|
required this.debugLogPath,
|
|
required this.rescanHeights,
|
|
});
|
|
|
|
factory ScanData.fromHeight(ScanData scanData, int newHeight) {
|
|
return ScanData(
|
|
sendPort: scanData.sendPort,
|
|
silentAddress: scanData.silentAddress,
|
|
masterHD: scanData.masterHD,
|
|
height: newHeight,
|
|
node: scanData.node,
|
|
network: scanData.network,
|
|
chainTip: scanData.chainTip,
|
|
transactionHistoryIds: scanData.transactionHistoryIds,
|
|
electrumClient: scanData.electrumClient,
|
|
labels: scanData.labels,
|
|
labelIndexes: scanData.labelIndexes,
|
|
isSingleScan: scanData.isSingleScan,
|
|
debugLogPath: scanData.debugLogPath,
|
|
rescanHeights: scanData.rescanHeights,
|
|
);
|
|
}
|
|
}
|
|
|
|
class SyncResponse {
|
|
final int height;
|
|
final SyncStatus syncStatus;
|
|
|
|
SyncResponse(this.height, this.syncStatus);
|
|
}
|
|
|
|
Future<void> _handleScanSilentPayments(ScanData scanData) async {
|
|
final shouldUpdateSyncStatus = scanData.rescanHeights == null || scanData.rescanHeights!.isEmpty;
|
|
final hasForcedRescanHeights = !shouldUpdateSyncStatus;
|
|
CakeTor.instance = await CakeTorInstance.getInstance();
|
|
|
|
var node = scanData.node?.uri ?? Uri.parse("tcp://electrs.cakewallet.com:50001");
|
|
|
|
void log(String message, LogLevel level) {
|
|
printV("[Scanning] $message", file: scanData.debugLogPath, level: level);
|
|
}
|
|
|
|
try {
|
|
// if (scanData.shouldSwitchNodes) {
|
|
var scanningClient = await ElectrumProvider.connect(
|
|
ElectrumTCPService.connect(node),
|
|
);
|
|
// }
|
|
|
|
log("connected to ${node.toString()}", LogLevel.info);
|
|
|
|
final receivers = [
|
|
Receiver(
|
|
scanData.silentAddress.b_scan.toHex(),
|
|
scanData.silentAddress.B_spend.toHex(),
|
|
scanData.network == BitcoinNetwork.testnet,
|
|
scanData.labelIndexes,
|
|
scanData.labelIndexes.length,
|
|
),
|
|
Receiver(
|
|
scanData.masterHD.derivePath(SILENT_PAYMENTS_SCAN_PATH_TESTNET).privateKey.toHex(),
|
|
scanData.masterHD.derivePath(SILENT_PAYMENTS_SPEND_PATH_TESTNET).publicKey.toHex(),
|
|
scanData.network == BitcoinNetwork.testnet,
|
|
scanData.labelIndexes,
|
|
scanData.labelIndexes.length,
|
|
)
|
|
];
|
|
|
|
log(
|
|
"using receiver: b_scan: ${scanData.silentAddress.b_scan.toHex()}, b_spend: ${scanData.silentAddress.B_spend.toHex()}, network: ${scanData.network.value}, labelIndexes: ${scanData.labelIndexes}",
|
|
LogLevel.info,
|
|
);
|
|
log(
|
|
"using receiver: b_scan: ${receivers[1].bScan}, b_spend: ${receivers[1].BSpend}, network: ${scanData.network.value}, labelIndexes: ${scanData.labelIndexes}",
|
|
LogLevel.info,
|
|
);
|
|
|
|
void scan(int syncHeight, bool isSingleScan) async {
|
|
int initialSyncHeight = syncHeight;
|
|
|
|
int getCountToScanPerRequest(int syncHeight) {
|
|
if (isSingleScan) {
|
|
return 1;
|
|
}
|
|
|
|
final amountLeft = scanData.chainTip - syncHeight + 1;
|
|
return amountLeft;
|
|
}
|
|
|
|
// Initial status UI update, send how many blocks in total to scan
|
|
if (shouldUpdateSyncStatus)
|
|
scanData.sendPort.send(SyncResponse(syncHeight, StartingScanSyncStatus(syncHeight)));
|
|
|
|
final req = ElectrumTweaksSubscribe(
|
|
height: syncHeight,
|
|
count: getCountToScanPerRequest(syncHeight),
|
|
historicalMode: hasForcedRescanHeights,
|
|
);
|
|
|
|
var _scanningStream = await scanningClient.subscribe(req);
|
|
|
|
log(
|
|
"initial request: height: $syncHeight, count: ${getCountToScanPerRequest(syncHeight)}",
|
|
LogLevel.info,
|
|
);
|
|
|
|
void endScanningSuccesfully() {
|
|
if (isSingleScan) {
|
|
scanData.sendPort.send(SyncResponse(syncHeight, SyncedSyncStatus()));
|
|
} else {
|
|
scanData.sendPort.send(
|
|
SyncResponse(syncHeight, SyncedTipSyncStatus(scanData.chainTip)),
|
|
);
|
|
}
|
|
|
|
_scanningStream?.close();
|
|
_scanningStream = null;
|
|
|
|
log(
|
|
"ended: syncHeight: $syncHeight, chainTip: ${scanData.chainTip}, isSingleScan: ${isSingleScan}",
|
|
LogLevel.info,
|
|
);
|
|
}
|
|
|
|
void listenFn(Map<String, dynamic> event, ElectrumTweaksSubscribe req) async {
|
|
final response = req.onResponse(event);
|
|
|
|
if (response == null || _scanningStream == null) {
|
|
log(
|
|
"ending: response = $response, stream = $_scanningStream",
|
|
LogLevel.error,
|
|
);
|
|
return;
|
|
}
|
|
|
|
// is success or error msg
|
|
final noData = response.message != null;
|
|
|
|
if (noData) {
|
|
if (isSingleScan) {
|
|
log("ending: noData and isSingleScan", LogLevel.info);
|
|
|
|
endScanningSuccesfully();
|
|
return;
|
|
}
|
|
|
|
// re-subscribe to continue receiving messages, starting from the next unscanned height
|
|
final nextHeight = syncHeight + 1;
|
|
|
|
if (nextHeight <= scanData.chainTip) {
|
|
log(
|
|
"resubscribing: nextHeight: $nextHeight, count: ${getCountToScanPerRequest(nextHeight)}",
|
|
LogLevel.info,
|
|
);
|
|
|
|
final nextStream = scanningClient.subscribe(
|
|
ElectrumTweaksSubscribe(
|
|
height: nextHeight,
|
|
count: getCountToScanPerRequest(nextHeight),
|
|
historicalMode: hasForcedRescanHeights,
|
|
),
|
|
);
|
|
|
|
if (nextStream != null) {
|
|
nextStream.listen((event) => listenFn(event, req));
|
|
} else {
|
|
if (shouldUpdateSyncStatus)
|
|
scanData.sendPort.send(
|
|
SyncResponse(scanData.height, LostConnectionSyncStatus()),
|
|
);
|
|
}
|
|
}
|
|
|
|
log(
|
|
"ending: resubscribing: nextHeight: $nextHeight, count: ${getCountToScanPerRequest(nextHeight)}",
|
|
LogLevel.info,
|
|
);
|
|
return;
|
|
}
|
|
|
|
final tweakHeight = response.block;
|
|
|
|
// Continuous status UI update, send how many blocks left to scan
|
|
final syncingStatus = isSingleScan
|
|
? SyncingSyncStatus(1, 0)
|
|
: SyncingSyncStatus.fromHeightValues(scanData.chainTip, initialSyncHeight, tweakHeight);
|
|
|
|
if (shouldUpdateSyncStatus) scanData.sendPort.send(SyncResponse(syncHeight, syncingStatus));
|
|
|
|
try {
|
|
final blockTweaks = response.blockTweaks;
|
|
|
|
var blockDate = DateTime.now();
|
|
bool isDateNow = true;
|
|
|
|
for (final txid in blockTweaks.keys) {
|
|
final tweakData = blockTweaks[txid];
|
|
final outputPubkeys = tweakData!.outputPubkeys;
|
|
final tweak = tweakData.tweak;
|
|
|
|
try {
|
|
final addToWallet = <String, dynamic>{};
|
|
|
|
receivers.forEach((receiver) {
|
|
final preparedList = outputPubkeys.keys.toList().map((e) => [e]).toList();
|
|
// NOTE: scanOutputs, from sp_scanner package, called from rust here
|
|
final scanResult = scanOutputs(preparedList, tweak, receiver);
|
|
|
|
if (scanResult.isEmpty) return;
|
|
|
|
if (addToWallet[receiver.BSpend] == null) {
|
|
addToWallet[receiver.BSpend] = scanResult;
|
|
} else {
|
|
addToWallet[receiver.BSpend].addAll(scanResult);
|
|
}
|
|
});
|
|
|
|
if (addToWallet.isEmpty) {
|
|
// no results tx, continue to next tx
|
|
continue;
|
|
}
|
|
|
|
log(
|
|
"FOUND: addToWallet: ${addToWallet.length}, txid: $txid, tweak: $tweak, height: $tweakHeight",
|
|
LogLevel.info,
|
|
);
|
|
|
|
// Every tx in the block has the same date (the block date)
|
|
// So, if blockDate exists, reuse
|
|
if (isDateNow) {
|
|
try {
|
|
final rootURL = "https://cake.mempool.space";
|
|
final tweakBlockHash = await ProxyWrapper()
|
|
.get(clearnetUri: Uri.parse("$rootURL/api/block-height/$tweakHeight"))
|
|
.timeout(Duration(seconds: 15));
|
|
final blockResponse = await ProxyWrapper()
|
|
.get(clearnetUri: Uri.parse("$rootURL/api/block/${tweakBlockHash.body}"))
|
|
.timeout(Duration(seconds: 15));
|
|
|
|
if (blockResponse.statusCode == 200 &&
|
|
blockResponse.body.isNotEmpty &&
|
|
jsonDecode(blockResponse.body)['timestamp'] != null) {
|
|
blockDate = DateTime.fromMillisecondsSinceEpoch(
|
|
int.parse(jsonDecode(blockResponse.body)['timestamp'].toString()) * 1000,
|
|
);
|
|
isDateNow = false;
|
|
}
|
|
} catch (e, stacktrace) {
|
|
printV(stacktrace);
|
|
printV(e.toString());
|
|
}
|
|
}
|
|
|
|
// initial placeholder ElectrumTransactionInfo object to update values based on new scanned unspent(s) on the following loop
|
|
final txInfo = ElectrumTransactionInfo(
|
|
WalletType.bitcoin,
|
|
id: txid,
|
|
height: tweakHeight,
|
|
amount: Money.zero(CryptoCurrency.btc),
|
|
fee: Money.zero(CryptoCurrency.btc),
|
|
direction: TransactionDirection.incoming,
|
|
isReplaced: false,
|
|
date: scanData.network == BitcoinNetwork.mainnet
|
|
? (isDateNow ? getDateByBitcoinHeight(tweakHeight) : blockDate)
|
|
: DateTime.now(),
|
|
confirmations: scanData.chainTip - tweakHeight + 1,
|
|
isReceivedSilentPayment: true,
|
|
isPending: false,
|
|
unspents: [],
|
|
);
|
|
|
|
List<BitcoinUnspent> unspents = [];
|
|
|
|
addToWallet.forEach((BSpend, scanResultPerLabel) {
|
|
scanResultPerLabel.forEach((label, scanOutput) {
|
|
final labelValue = label == "None" ? null : label.toString();
|
|
|
|
(scanOutput as Map<String, dynamic>).forEach((outputPubkey, tweak) {
|
|
final t_k = tweak as String;
|
|
|
|
final receivingOutputAddress = ECPublic.fromHex(outputPubkey)
|
|
.toTaprootAddress(tweak: false)
|
|
.toAddress(scanData.network);
|
|
|
|
final matchingOutput = outputPubkeys[outputPubkey]!;
|
|
final amount = matchingOutput.amount;
|
|
final pos = matchingOutput.vout;
|
|
final spent = matchingOutput.spendingInput;
|
|
|
|
final matchingReceiver =
|
|
receivers.indexWhere((receiver) => receiver.BSpend == BSpend);
|
|
|
|
// final labelIndex = labelValue != null ? scanData.labels[label] : 0;
|
|
// final balance = ElectrumBalance();
|
|
// balance.confirmed = amount;
|
|
|
|
final receivedAddressRecord = BitcoinSilentPaymentAddressRecord(
|
|
receivingOutputAddress,
|
|
index: 0,
|
|
isHidden: false,
|
|
isUsed: true,
|
|
network: scanData.network,
|
|
silentPaymentTweak: t_k,
|
|
type: SegwitAddresType.p2tr,
|
|
txCount: 1,
|
|
balance: amount,
|
|
spendDerivationPath: matchingReceiver == 0
|
|
? SILENT_PAYMENTS_SPEND_PATH
|
|
: SILENT_PAYMENTS_SPEND_PATH_TESTNET,
|
|
);
|
|
|
|
final unspent = BitcoinSilentPaymentsUnspent(
|
|
receivedAddressRecord,
|
|
txid,
|
|
amount,
|
|
pos,
|
|
silentPaymentTweak: t_k,
|
|
silentPaymentLabel: labelValue,
|
|
);
|
|
|
|
if (spent == null) {
|
|
unspents.add(unspent);
|
|
txInfo.unspents!.add(unspent);
|
|
}
|
|
|
|
txInfo.amount += Money.fromInt(unspent.value, txInfo.amount.currency);
|
|
});
|
|
});
|
|
});
|
|
|
|
scanData.sendPort.send({txInfo.id: txInfo});
|
|
} catch (e, stacktrace) {
|
|
if (shouldUpdateSyncStatus)
|
|
scanData.sendPort.send(
|
|
SyncResponse(syncHeight, LostConnectionSyncStatus()),
|
|
);
|
|
|
|
log(stacktrace.toString(), LogLevel.error);
|
|
log(e.toString(), LogLevel.error);
|
|
return;
|
|
}
|
|
}
|
|
} catch (e, stacktrace) {
|
|
if (shouldUpdateSyncStatus)
|
|
scanData.sendPort.send(
|
|
SyncResponse(syncHeight, LostConnectionSyncStatus()),
|
|
);
|
|
|
|
log(stacktrace.toString(), LogLevel.error);
|
|
log(e.toString(), LogLevel.error);
|
|
return;
|
|
}
|
|
|
|
syncHeight = tweakHeight;
|
|
|
|
if ((tweakHeight >= scanData.chainTip) || isSingleScan) {
|
|
endScanningSuccesfully();
|
|
}
|
|
}
|
|
|
|
_scanningStream?.listen((event) => listenFn(event, req));
|
|
}
|
|
|
|
if (scanData.rescanHeights != null) {
|
|
for (final height in scanData.rescanHeights!) {
|
|
log("rescanning from height: $height", LogLevel.info);
|
|
scan(height, true);
|
|
}
|
|
} else {
|
|
scan(scanData.height, scanData.isSingleScan);
|
|
}
|
|
} catch (e) {
|
|
log("Error in _handleScanSilentPayments: $e", LogLevel.error);
|
|
if (shouldUpdateSyncStatus)
|
|
scanData.sendPort.send(SyncResponse(scanData.height, LostConnectionSyncStatus()));
|
|
}
|
|
}
|
|
|
|
class EstimatedTxResult {
|
|
EstimatedTxResult({
|
|
required this.utxos,
|
|
required this.inputPrivKeyInfos,
|
|
required this.publicKeys,
|
|
required this.fee,
|
|
required this.amount,
|
|
required this.hasChange,
|
|
required this.isSendAll,
|
|
this.memo,
|
|
required this.spendsSilentPayment,
|
|
required this.spendsUnconfirmedTX,
|
|
});
|
|
|
|
final List<UtxoWithAddress> utxos;
|
|
final List<ECPrivateInfo> inputPrivKeyInfos;
|
|
final Map<String, PublicKeyWithDerivationPath> publicKeys; // PubKey to derivationPath
|
|
final Money fee;
|
|
final Money amount;
|
|
final bool spendsSilentPayment;
|
|
|
|
// final bool sendsToSilentPayment;
|
|
final bool hasChange;
|
|
final bool isSendAll;
|
|
final String? memo;
|
|
final bool spendsUnconfirmedTX;
|
|
}
|
|
|
|
class PublicKeyWithDerivationPath {
|
|
const PublicKeyWithDerivationPath(this.publicKey, this.derivationPath);
|
|
|
|
final String derivationPath;
|
|
final String publicKey;
|
|
}
|
|
|
|
BitcoinAddressType _getScriptType(BitcoinBaseAddress type) {
|
|
if (type is P2pkhAddress) {
|
|
return P2pkhAddressType.p2pkh;
|
|
} else if (type is P2shAddress) {
|
|
return P2shAddressType.p2wpkhInP2sh;
|
|
} else if (type is P2wshAddress) {
|
|
return SegwitAddresType.p2wsh;
|
|
} else if (type is P2trAddress) {
|
|
return SegwitAddresType.p2tr;
|
|
} else if (type is MwebAddress) {
|
|
return SegwitAddresType.mweb;
|
|
} else if (type is SilentPaymentsAddresType) {
|
|
return SilentPaymentsAddresType.p2sp;
|
|
} else {
|
|
return SegwitAddresType.p2wpkh;
|
|
}
|
|
}
|
|
|
|
class UtxoDetails {
|
|
final List<BitcoinUnspent> availableInputs;
|
|
final List<BitcoinUnspent> unconfirmedCoins;
|
|
final List<UtxoWithAddress> utxos;
|
|
final List<Outpoint> vinOutpoints;
|
|
final List<ECPrivateInfo> inputPrivKeyInfos;
|
|
final Map<String, PublicKeyWithDerivationPath> publicKeys; // PubKey to derivationPath
|
|
final int allInputsAmount;
|
|
final bool spendsSilentPayment;
|
|
final bool spendsUnconfirmedTX;
|
|
|
|
UtxoDetails({
|
|
required this.availableInputs,
|
|
required this.unconfirmedCoins,
|
|
required this.utxos,
|
|
required this.vinOutpoints,
|
|
required this.inputPrivKeyInfos,
|
|
required this.publicKeys,
|
|
required this.allInputsAmount,
|
|
required this.spendsSilentPayment,
|
|
required this.spendsUnconfirmedTX,
|
|
});
|
|
}
|
|
|
|
class AddressHistoryScan {
|
|
AddressHistoryScan({
|
|
required this.historyByScriptHash,
|
|
required this.hadFailures,
|
|
});
|
|
|
|
final Map<String, List<Map<String, dynamic>>> historyByScriptHash;
|
|
final bool hadFailures;
|
|
}
|
|
|
|
class AddressHistoryResult {
|
|
AddressHistoryResult({
|
|
required this.transactions,
|
|
required this.missingHistoryItems,
|
|
required this.hasHistory,
|
|
required this.hadFailures,
|
|
});
|
|
|
|
final Map<String, ElectrumTransactionInfo> transactions;
|
|
final List<Map<String, dynamic>> missingHistoryItems;
|
|
final bool hasHistory;
|
|
final bool hadFailures;
|
|
} |