mirror of
https://github.com/cake-tech/cake_wallet.git
synced 2024-12-25 04:59:33 +00:00
568 lines
19 KiB
Dart
568 lines
19 KiB
Dart
import 'package:bitcoin_base/bitcoin_base.dart';
|
|
import 'package:bitcoin_flutter/bitcoin_flutter.dart' as bitcoin;
|
|
import 'package:blockchain_utils/blockchain_utils.dart';
|
|
import 'package:cw_bitcoin/bitcoin_address_record.dart';
|
|
import 'package:cw_core/wallet_addresses.dart';
|
|
import 'package:cw_core/wallet_info.dart';
|
|
import 'package:cw_core/wallet_type.dart';
|
|
import 'package:mobx/mobx.dart';
|
|
|
|
part 'electrum_wallet_addresses.g.dart';
|
|
|
|
class ElectrumWalletAddresses = ElectrumWalletAddressesBase with _$ElectrumWalletAddresses;
|
|
|
|
const List<BitcoinAddressType> ADDRESS_TYPES = [
|
|
SegwitAddresType.p2wpkh,
|
|
P2pkhAddressType.p2pkh,
|
|
SegwitAddresType.p2tr,
|
|
SegwitAddresType.p2wsh,
|
|
P2shAddressType.p2wpkhInP2sh,
|
|
];
|
|
|
|
abstract class ElectrumWalletAddressesBase extends WalletAddresses with Store {
|
|
ElectrumWalletAddressesBase(
|
|
WalletInfo walletInfo, {
|
|
required this.mainHd,
|
|
required this.sideHd,
|
|
required this.network,
|
|
List<BitcoinAddressRecord>? initialAddresses,
|
|
Map<String, int>? initialRegularAddressIndex,
|
|
Map<String, int>? initialChangeAddressIndex,
|
|
List<BitcoinSilentPaymentAddressRecord>? initialSilentAddresses,
|
|
int initialSilentAddressIndex = 1,
|
|
bitcoin.HDWallet? masterHd,
|
|
BitcoinAddressType? initialAddressPageType,
|
|
}) : _addresses = ObservableList<BitcoinAddressRecord>.of((initialAddresses ?? []).toSet()),
|
|
addressesByReceiveType =
|
|
ObservableList<BaseBitcoinAddressRecord>.of((<BitcoinAddressRecord>[]).toSet()),
|
|
receiveAddresses = ObservableList<BitcoinAddressRecord>.of((initialAddresses ?? [])
|
|
.where((addressRecord) => !addressRecord.isHidden && !addressRecord.isUsed)
|
|
.toSet()),
|
|
changeAddresses = ObservableList<BitcoinAddressRecord>.of((initialAddresses ?? [])
|
|
.where((addressRecord) => addressRecord.isHidden && !addressRecord.isUsed)
|
|
.toSet()),
|
|
currentReceiveAddressIndexByType = initialRegularAddressIndex ?? {},
|
|
currentChangeAddressIndexByType = initialChangeAddressIndex ?? {},
|
|
_addressPageType = initialAddressPageType ??
|
|
(walletInfo.addressPageType != null
|
|
? BitcoinAddressType.fromValue(walletInfo.addressPageType!)
|
|
: SegwitAddresType.p2wpkh),
|
|
silentAddresses = ObservableList<BitcoinSilentPaymentAddressRecord>.of(
|
|
(initialSilentAddresses ?? []).toSet()),
|
|
currentSilentAddressIndex = initialSilentAddressIndex,
|
|
super(walletInfo) {
|
|
if (masterHd != null) {
|
|
silentAddress = SilentPaymentOwner.fromPrivateKeys(
|
|
b_scan: ECPrivate.fromHex(masterHd.derivePath(SCAN_PATH).privKey!),
|
|
b_spend: ECPrivate.fromHex(masterHd.derivePath(SPEND_PATH).privKey!),
|
|
hrp: network == BitcoinNetwork.testnet ? 'tsp' : 'sp');
|
|
|
|
if (silentAddresses.length == 0)
|
|
silentAddresses.add(BitcoinSilentPaymentAddressRecord(
|
|
silentAddress.toString(),
|
|
index: 1,
|
|
isHidden: false,
|
|
name: "",
|
|
silentPaymentTweak: null,
|
|
network: network,
|
|
type: SilentPaymentsAddresType.p2sp,
|
|
));
|
|
}
|
|
|
|
updateAddressesByMatch();
|
|
}
|
|
|
|
static const defaultReceiveAddressesCount = 22;
|
|
static const defaultChangeAddressesCount = 17;
|
|
static const gap = 20;
|
|
|
|
final ObservableList<BitcoinAddressRecord> _addresses;
|
|
late ObservableList<BaseBitcoinAddressRecord> addressesByReceiveType;
|
|
final ObservableList<BitcoinAddressRecord> receiveAddresses;
|
|
final ObservableList<BitcoinAddressRecord> changeAddresses;
|
|
final ObservableList<BitcoinSilentPaymentAddressRecord> silentAddresses;
|
|
final BasedUtxoNetwork network;
|
|
final bitcoin.HDWallet mainHd;
|
|
final bitcoin.HDWallet sideHd;
|
|
|
|
@observable
|
|
SilentPaymentOwner? silentAddress;
|
|
|
|
@observable
|
|
late BitcoinAddressType _addressPageType;
|
|
|
|
@computed
|
|
BitcoinAddressType get addressPageType => _addressPageType;
|
|
|
|
@observable
|
|
String? activeSilentAddress;
|
|
|
|
@computed
|
|
List<BitcoinAddressRecord> get allAddresses => _addresses;
|
|
|
|
@override
|
|
@computed
|
|
String get address {
|
|
if (addressPageType == SilentPaymentsAddresType.p2sp) {
|
|
if (activeSilentAddress != null) {
|
|
return activeSilentAddress!;
|
|
}
|
|
|
|
return silentAddress.toString();
|
|
}
|
|
|
|
String receiveAddress;
|
|
|
|
final typeMatchingReceiveAddresses =
|
|
receiveAddresses.where(_isAddressPageTypeMatch).where((addr) => !addr.isUsed);
|
|
|
|
if ((isEnabledAutoGenerateSubaddress && receiveAddresses.isEmpty) ||
|
|
typeMatchingReceiveAddresses.isEmpty) {
|
|
receiveAddress = generateNewAddress().address;
|
|
} else {
|
|
final previousAddressMatchesType =
|
|
previousAddressRecord != null && previousAddressRecord!.type == addressPageType;
|
|
|
|
if (previousAddressMatchesType &&
|
|
typeMatchingReceiveAddresses.first.address != addressesByReceiveType.first.address) {
|
|
receiveAddress = previousAddressRecord!.address;
|
|
} else {
|
|
receiveAddress = typeMatchingReceiveAddresses.first.address;
|
|
}
|
|
}
|
|
|
|
return receiveAddress;
|
|
}
|
|
|
|
@observable
|
|
bool isEnabledAutoGenerateSubaddress = true;
|
|
|
|
@override
|
|
set address(String addr) {
|
|
if (addressPageType == SilentPaymentsAddresType.p2sp) {
|
|
final selected = silentAddresses.firstWhere((addressRecord) => addressRecord.address == addr);
|
|
|
|
if (selected.silentPaymentTweak != null && silentAddress != null) {
|
|
activeSilentAddress =
|
|
silentAddress!.toLabeledSilentPaymentAddress(selected.index).toString();
|
|
} else {
|
|
activeSilentAddress = silentAddress!.toString();
|
|
}
|
|
return;
|
|
}
|
|
|
|
final addressRecord = _addresses.firstWhere((addressRecord) => addressRecord.address == addr);
|
|
|
|
previousAddressRecord = addressRecord;
|
|
receiveAddresses.remove(addressRecord);
|
|
receiveAddresses.insert(0, addressRecord);
|
|
}
|
|
|
|
@override
|
|
String get primaryAddress => getAddress(index: 0, hd: mainHd, addressType: addressPageType);
|
|
|
|
Map<String, int> currentReceiveAddressIndexByType;
|
|
|
|
int get currentReceiveAddressIndex =>
|
|
currentReceiveAddressIndexByType[_addressPageType.toString()] ?? 0;
|
|
|
|
void set currentReceiveAddressIndex(int index) =>
|
|
currentReceiveAddressIndexByType[_addressPageType.toString()] = index;
|
|
|
|
Map<String, int> currentChangeAddressIndexByType;
|
|
|
|
int get currentChangeAddressIndex =>
|
|
currentChangeAddressIndexByType[_addressPageType.toString()] ?? 0;
|
|
|
|
void set currentChangeAddressIndex(int index) =>
|
|
currentChangeAddressIndexByType[_addressPageType.toString()] = index;
|
|
|
|
int currentSilentAddressIndex;
|
|
|
|
@observable
|
|
BitcoinAddressRecord? previousAddressRecord;
|
|
|
|
@computed
|
|
int get totalCountOfReceiveAddresses => addressesByReceiveType.fold(0, (acc, addressRecord) {
|
|
if (!addressRecord.isHidden) {
|
|
return acc + 1;
|
|
}
|
|
return acc;
|
|
});
|
|
|
|
@computed
|
|
int get totalCountOfChangeAddresses => addressesByReceiveType.fold(0, (acc, addressRecord) {
|
|
if (addressRecord.isHidden) {
|
|
return acc + 1;
|
|
}
|
|
return acc;
|
|
});
|
|
|
|
@override
|
|
Future<void> init() async {
|
|
if (walletInfo.type == WalletType.bitcoinCash) {
|
|
await _generateInitialAddresses(type: P2pkhAddressType.p2pkh);
|
|
} else if (walletInfo.type == WalletType.litecoin) {
|
|
await _generateInitialAddresses();
|
|
} else if (walletInfo.type == WalletType.bitcoin) {
|
|
await _generateInitialAddresses();
|
|
await _generateInitialAddresses(type: P2pkhAddressType.p2pkh);
|
|
await _generateInitialAddresses(type: P2shAddressType.p2wpkhInP2sh);
|
|
await _generateInitialAddresses(type: SegwitAddresType.p2tr);
|
|
await _generateInitialAddresses(type: SegwitAddresType.p2wsh);
|
|
}
|
|
updateAddressesByMatch();
|
|
updateReceiveAddresses();
|
|
updateChangeAddresses();
|
|
await updateAddressesInBox();
|
|
|
|
if (currentReceiveAddressIndex >= receiveAddresses.length) {
|
|
currentReceiveAddressIndex = 0;
|
|
}
|
|
|
|
if (currentChangeAddressIndex >= changeAddresses.length) {
|
|
currentChangeAddressIndex = 0;
|
|
}
|
|
}
|
|
|
|
@action
|
|
Future<String> getChangeAddress() async {
|
|
updateChangeAddresses();
|
|
|
|
if (changeAddresses.isEmpty) {
|
|
final newAddresses = await _createNewAddresses(gap,
|
|
startIndex: totalCountOfChangeAddresses > 0 ? totalCountOfChangeAddresses - 1 : 0,
|
|
isHidden: true);
|
|
addAddresses(newAddresses);
|
|
}
|
|
|
|
if (currentChangeAddressIndex >= changeAddresses.length) {
|
|
currentChangeAddressIndex = 0;
|
|
}
|
|
|
|
updateChangeAddresses();
|
|
final address = changeAddresses[currentChangeAddressIndex].address;
|
|
currentChangeAddressIndex += 1;
|
|
return address;
|
|
}
|
|
|
|
Map<String, String> get labels {
|
|
final G = ECPublic.fromBytes(BigintUtils.toBytes(Curves.generatorSecp256k1.x, length: 32));
|
|
final labels = <String, String>{};
|
|
for (int i = 0; i < silentAddresses.length; i++) {
|
|
final silentAddressRecord = silentAddresses[i];
|
|
final silentPaymentTweak = silentAddressRecord.silentPaymentTweak;
|
|
|
|
if (silentPaymentTweak != null &&
|
|
SilentPaymentAddress.regex.hasMatch(silentAddressRecord.address)) {
|
|
labels[G
|
|
.tweakMul(BigintUtils.fromBytes(BytesUtils.fromHexString(silentPaymentTweak)))
|
|
.toHex()] = silentPaymentTweak;
|
|
}
|
|
}
|
|
return labels;
|
|
}
|
|
|
|
@action
|
|
BaseBitcoinAddressRecord generateNewAddress({String label = ''}) {
|
|
if (addressPageType == SilentPaymentsAddresType.p2sp && silentAddress != null) {
|
|
final currentSilentAddressIndex = silentAddresses
|
|
.where((addressRecord) => addressRecord.type != SegwitAddresType.p2tr)
|
|
.length +
|
|
1;
|
|
|
|
this.currentSilentAddressIndex = currentSilentAddressIndex;
|
|
|
|
final address = BitcoinSilentPaymentAddressRecord(
|
|
silentAddress!.toLabeledSilentPaymentAddress(currentSilentAddressIndex).toString(),
|
|
index: currentSilentAddressIndex,
|
|
isHidden: false,
|
|
name: label,
|
|
silentPaymentTweak:
|
|
BytesUtils.toHexString(silentAddress!.generateLabel(currentSilentAddressIndex)),
|
|
network: network,
|
|
type: SilentPaymentsAddresType.p2sp,
|
|
);
|
|
|
|
silentAddresses.add(address);
|
|
updateAddressesByMatch();
|
|
|
|
return address;
|
|
}
|
|
|
|
final newAddressIndex = addressesByReceiveType.fold(
|
|
0, (int acc, addressRecord) => addressRecord.isHidden == false ? acc + 1 : acc);
|
|
|
|
final address = BitcoinAddressRecord(
|
|
getAddress(index: newAddressIndex, hd: mainHd, addressType: addressPageType),
|
|
index: newAddressIndex,
|
|
isHidden: false,
|
|
name: label,
|
|
type: addressPageType,
|
|
network: network,
|
|
);
|
|
_addresses.add(address);
|
|
updateAddressesByMatch();
|
|
return address;
|
|
}
|
|
|
|
String getAddress(
|
|
{required int index, required bitcoin.HDWallet hd, BitcoinAddressType? addressType}) =>
|
|
'';
|
|
|
|
@override
|
|
Future<void> updateAddressesInBox() async {
|
|
try {
|
|
addressesMap.clear();
|
|
addressesMap[address] = 'Active';
|
|
|
|
allAddressesMap.clear();
|
|
_addresses.forEach((addressRecord) {
|
|
allAddressesMap[addressRecord.address] = addressRecord.name;
|
|
});
|
|
|
|
final lastP2wpkh = _addresses
|
|
.where((addressRecord) =>
|
|
_isUnusedReceiveAddressByType(addressRecord, SegwitAddresType.p2wpkh))
|
|
.toList()
|
|
.last;
|
|
if (lastP2wpkh.address != address) {
|
|
addressesMap[lastP2wpkh.address] = 'P2WPKH';
|
|
} else {
|
|
addressesMap[address] = 'Active - P2WPKH';
|
|
}
|
|
|
|
final lastP2pkh = _addresses.firstWhere(
|
|
(addressRecord) => _isUnusedReceiveAddressByType(addressRecord, P2pkhAddressType.p2pkh));
|
|
if (lastP2pkh.address != address) {
|
|
addressesMap[lastP2pkh.address] = 'P2PKH';
|
|
} else {
|
|
addressesMap[address] = 'Active - P2PKH';
|
|
}
|
|
|
|
final lastP2sh = _addresses.firstWhere((addressRecord) =>
|
|
_isUnusedReceiveAddressByType(addressRecord, P2shAddressType.p2wpkhInP2sh));
|
|
if (lastP2sh.address != address) {
|
|
addressesMap[lastP2sh.address] = 'P2SH';
|
|
} else {
|
|
addressesMap[address] = 'Active - P2SH';
|
|
}
|
|
|
|
final lastP2tr = _addresses.firstWhere(
|
|
(addressRecord) => _isUnusedReceiveAddressByType(addressRecord, SegwitAddresType.p2tr));
|
|
if (lastP2tr.address != address) {
|
|
addressesMap[lastP2tr.address] = 'P2TR';
|
|
} else {
|
|
addressesMap[address] = 'Active - P2TR';
|
|
}
|
|
|
|
final lastP2wsh = _addresses.firstWhere(
|
|
(addressRecord) => _isUnusedReceiveAddressByType(addressRecord, SegwitAddresType.p2wsh));
|
|
if (lastP2wsh.address != address) {
|
|
addressesMap[lastP2wsh.address] = 'P2WSH';
|
|
} else {
|
|
addressesMap[address] = 'Active - P2WSH';
|
|
}
|
|
|
|
silentAddresses.forEach((addressRecord) {
|
|
if (addressRecord.type != SilentPaymentsAddresType.p2sp) {
|
|
return;
|
|
}
|
|
|
|
if (addressRecord.address != address) {
|
|
addressesMap[addressRecord.address] = addressRecord.name.isEmpty
|
|
? "Silent Payments"
|
|
: "Silent Payments - " + addressRecord.name;
|
|
} else {
|
|
addressesMap[address] = 'Active - Silent Payments';
|
|
}
|
|
});
|
|
|
|
await saveAddressesInBox();
|
|
} catch (e) {
|
|
print(e.toString());
|
|
}
|
|
}
|
|
|
|
@action
|
|
void updateAddress(String address, String label) {
|
|
BaseBitcoinAddressRecord? foundAddress;
|
|
_addresses.forEach((addressRecord) {
|
|
if (addressRecord.address == address) {
|
|
foundAddress = addressRecord;
|
|
}
|
|
});
|
|
silentAddresses.forEach((addressRecord) {
|
|
if (addressRecord.address == address) {
|
|
foundAddress = addressRecord;
|
|
}
|
|
});
|
|
|
|
if (foundAddress != null) {
|
|
foundAddress!.setNewName(label);
|
|
|
|
if (foundAddress is BitcoinAddressRecord) {
|
|
final index = _addresses.indexOf(foundAddress);
|
|
_addresses.remove(foundAddress);
|
|
_addresses.insert(index, foundAddress as BitcoinAddressRecord);
|
|
} else {
|
|
final index = silentAddresses.indexOf(foundAddress as BitcoinSilentPaymentAddressRecord);
|
|
silentAddresses.remove(foundAddress);
|
|
silentAddresses.insert(index, foundAddress as BitcoinSilentPaymentAddressRecord);
|
|
}
|
|
}
|
|
}
|
|
|
|
@action
|
|
void updateAddressesByMatch() {
|
|
if (addressPageType == SilentPaymentsAddresType.p2sp) {
|
|
addressesByReceiveType.clear();
|
|
addressesByReceiveType.addAll(silentAddresses);
|
|
return;
|
|
}
|
|
|
|
addressesByReceiveType.clear();
|
|
addressesByReceiveType.addAll(_addresses.where(_isAddressPageTypeMatch).toList());
|
|
}
|
|
|
|
@action
|
|
void updateReceiveAddresses() {
|
|
receiveAddresses.removeRange(0, receiveAddresses.length);
|
|
final newAddresses =
|
|
_addresses.where((addressRecord) => !addressRecord.isHidden && !addressRecord.isUsed);
|
|
receiveAddresses.addAll(newAddresses);
|
|
}
|
|
|
|
@action
|
|
void updateChangeAddresses() {
|
|
changeAddresses.removeRange(0, changeAddresses.length);
|
|
final newAddresses = _addresses.where((addressRecord) =>
|
|
addressRecord.isHidden &&
|
|
!addressRecord.isUsed &&
|
|
// TODO: feature to change change address type. For now fixed to p2wpkh, the cheapest type
|
|
(walletInfo.type != WalletType.bitcoin || addressRecord.type == SegwitAddresType.p2wpkh));
|
|
changeAddresses.addAll(newAddresses);
|
|
}
|
|
|
|
@action
|
|
Future<void> discoverAddresses(List<BitcoinAddressRecord> addressList, bool isHidden,
|
|
Future<String?> Function(BitcoinAddressRecord, Set<String>) getAddressHistory,
|
|
{BitcoinAddressType type = SegwitAddresType.p2wpkh}) async {
|
|
if (!isHidden) {
|
|
_validateSideHdAddresses(addressList.toList());
|
|
}
|
|
|
|
final newAddresses = await _createNewAddresses(gap,
|
|
startIndex: addressList.length, isHidden: isHidden, type: type);
|
|
addAddresses(newAddresses);
|
|
|
|
final addressesWithHistory = await Future.wait(newAddresses
|
|
.map((addr) => getAddressHistory(addr, _addresses.map((e) => e.address).toSet())));
|
|
final isLastAddressUsed = addressesWithHistory.last == addressList.last.address;
|
|
|
|
if (isLastAddressUsed) {
|
|
discoverAddresses(addressList, isHidden, getAddressHistory, type: type);
|
|
}
|
|
}
|
|
|
|
Future<void> _generateInitialAddresses(
|
|
{BitcoinAddressType type = SegwitAddresType.p2wpkh}) async {
|
|
var countOfReceiveAddresses = 0;
|
|
var countOfHiddenAddresses = 0;
|
|
|
|
_addresses.forEach((addr) {
|
|
if (addr.type == type) {
|
|
if (addr.isHidden) {
|
|
countOfHiddenAddresses += 1;
|
|
return;
|
|
}
|
|
|
|
countOfReceiveAddresses += 1;
|
|
}
|
|
});
|
|
|
|
if (countOfReceiveAddresses < defaultReceiveAddressesCount) {
|
|
final addressesCount = defaultReceiveAddressesCount - countOfReceiveAddresses;
|
|
final newAddresses = await _createNewAddresses(addressesCount,
|
|
startIndex: countOfReceiveAddresses, isHidden: false, type: type);
|
|
addAddresses(newAddresses);
|
|
}
|
|
|
|
if (countOfHiddenAddresses < defaultChangeAddressesCount) {
|
|
final addressesCount = defaultChangeAddressesCount - countOfHiddenAddresses;
|
|
final newAddresses = await _createNewAddresses(addressesCount,
|
|
startIndex: countOfHiddenAddresses, isHidden: true, type: type);
|
|
addAddresses(newAddresses);
|
|
}
|
|
}
|
|
|
|
Future<List<BitcoinAddressRecord>> _createNewAddresses(int count,
|
|
{int startIndex = 0, bool isHidden = false, BitcoinAddressType? type}) async {
|
|
final list = <BitcoinAddressRecord>[];
|
|
|
|
for (var i = startIndex; i < count + startIndex; i++) {
|
|
final address = BitcoinAddressRecord(
|
|
getAddress(index: i, hd: _getHd(isHidden), addressType: type ?? addressPageType),
|
|
index: i,
|
|
isHidden: isHidden,
|
|
type: type ?? addressPageType,
|
|
network: network,
|
|
);
|
|
list.add(address);
|
|
}
|
|
|
|
return list;
|
|
}
|
|
|
|
@action
|
|
void addAddresses(Iterable<BitcoinAddressRecord> addresses) {
|
|
final addressesSet = this._addresses.toSet();
|
|
addressesSet.addAll(addresses);
|
|
this._addresses.clear();
|
|
this._addresses.addAll(addressesSet);
|
|
updateAddressesByMatch();
|
|
}
|
|
|
|
@action
|
|
void addSilentAddresses(Iterable<BitcoinSilentPaymentAddressRecord> addresses) {
|
|
final addressesSet = this.silentAddresses.toSet();
|
|
addressesSet.addAll(addresses);
|
|
this.silentAddresses.clear();
|
|
this.silentAddresses.addAll(addressesSet);
|
|
updateAddressesByMatch();
|
|
}
|
|
|
|
void _validateSideHdAddresses(List<BitcoinAddressRecord> addrWithTransactions) {
|
|
addrWithTransactions.forEach((element) {
|
|
if (element.address !=
|
|
getAddress(index: element.index, hd: mainHd, addressType: element.type))
|
|
element.isHidden = true;
|
|
});
|
|
}
|
|
|
|
@action
|
|
Future<void> setAddressType(BitcoinAddressType type) async {
|
|
_addressPageType = type;
|
|
updateAddressesByMatch();
|
|
walletInfo.addressPageType = addressPageType.toString();
|
|
await walletInfo.save();
|
|
}
|
|
|
|
bool _isAddressPageTypeMatch(BitcoinAddressRecord addressRecord) {
|
|
return _isAddressByType(addressRecord, addressPageType);
|
|
}
|
|
|
|
bitcoin.HDWallet _getHd(bool isHidden) => isHidden ? sideHd : mainHd;
|
|
bool _isAddressByType(BitcoinAddressRecord addr, BitcoinAddressType type) => addr.type == type;
|
|
bool _isUnusedReceiveAddressByType(BitcoinAddressRecord addr, BitcoinAddressType type) =>
|
|
!addr.isHidden && !addr.isUsed && addr.type == type;
|
|
|
|
@action
|
|
void deleteSilentPaymentAddress(String address) {
|
|
final addressRecord = silentAddresses.firstWhere((addressRecord) =>
|
|
addressRecord.type == SilentPaymentsAddresType.p2sp && addressRecord.address == address);
|
|
|
|
silentAddresses.remove(addressRecord);
|
|
updateAddressesByMatch();
|
|
}
|
|
}
|