mirror of
https://github.com/cake-tech/cake_wallet.git
synced 2025-06-28 12:29:51 +00:00
2339 lines
72 KiB
Dart
2339 lines
72 KiB
Dart
import 'dart:async';
|
|
import 'dart:convert';
|
|
import 'dart:io';
|
|
import 'dart:isolate';
|
|
|
|
import 'package:bitcoin_base/bitcoin_base.dart';
|
|
import 'package:cw_bitcoin/electrum_worker/electrum_worker.dart';
|
|
import 'package:cw_bitcoin/seedbyte_types.dart';
|
|
import 'package:cw_bitcoin/electrum_worker/electrum_worker_methods.dart';
|
|
import 'package:cw_bitcoin/electrum_worker/electrum_worker_params.dart';
|
|
import 'package:cw_bitcoin/electrum_worker/methods/methods.dart';
|
|
import 'package:cw_bitcoin/wallet_seed_bytes.dart';
|
|
import 'package:cw_core/utils/print_verbose.dart';
|
|
import 'package:shared_preferences/shared_preferences.dart';
|
|
import 'package:blockchain_utils/blockchain_utils.dart';
|
|
import 'package:collection/collection.dart';
|
|
import 'package:cw_bitcoin/bitcoin_address_record.dart';
|
|
import 'package:cw_bitcoin/bitcoin_transaction_credentials.dart';
|
|
import 'package:cw_bitcoin/bitcoin_unspent.dart';
|
|
import 'package:cw_bitcoin/bitcoin_wallet_keys.dart';
|
|
import 'package:cw_bitcoin/electrum_balance.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_core/crypto_currency.dart';
|
|
import 'package:cw_core/encryption_file_utils.dart';
|
|
import 'package:cw_core/node.dart';
|
|
import 'package:cw_core/pathForWallet.dart';
|
|
import 'package:cw_core/pending_transaction.dart';
|
|
import 'package:cw_core/sync_status.dart';
|
|
import 'package:cw_core/transaction_priority.dart';
|
|
import 'package:cw_core/unspent_coins_info.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:flutter/foundation.dart';
|
|
import 'package:hive/hive.dart';
|
|
import 'package:ledger_flutter_plus/ledger_flutter_plus.dart' as ledger;
|
|
import 'package:mobx/mobx.dart';
|
|
|
|
part 'electrum_wallet.g.dart';
|
|
|
|
class ElectrumWallet<T extends ElectrumWalletAddresses> = ElectrumWalletBase<T>
|
|
with _$ElectrumWallet<T>;
|
|
|
|
abstract class ElectrumWalletBase<T extends ElectrumWalletAddresses>
|
|
extends WalletBase<ElectrumBalance, ElectrumTransactionHistory, ElectrumTransactionInfo, T>
|
|
with Store, WalletKeysFile {
|
|
ReceivePort? _receivePort;
|
|
SendPort? workerSendPort;
|
|
StreamSubscription<dynamic>? _workerSubscription;
|
|
Isolate? _workerIsolate;
|
|
final Map<int, dynamic> _responseCompleters = {};
|
|
final Map<int, dynamic> _errorCompleters = {};
|
|
int _messageId = 0;
|
|
|
|
static const String SIGN_MESSAGE_PREFIX = '\x18Bitcoin Signed Message:\n';
|
|
|
|
ElectrumWalletBase({
|
|
required String password,
|
|
required WalletInfo walletInfo,
|
|
required this.unspentCoinsInfo,
|
|
required this.network,
|
|
required this.encryptionFileUtils,
|
|
required this.hdWallets,
|
|
required CryptoCurrency currency,
|
|
String? xpub,
|
|
String? mnemonic,
|
|
this.passphrase,
|
|
ElectrumBalance? initialBalance,
|
|
List<BitcoinUnspent>? initialUnspentCoins,
|
|
}) : _xpub = xpub,
|
|
_syncStatus = NotConnectedSyncStatus(),
|
|
_password = password,
|
|
isEnabledAutoGenerateSubaddress = true,
|
|
unspentCoins = ElectrumUnspentCoins.of(initialUnspentCoins ?? []),
|
|
balance = ObservableMap<CryptoCurrency, ElectrumBalance>.of({
|
|
currency: initialBalance ??
|
|
ElectrumBalance(
|
|
confirmed: 0,
|
|
unconfirmed: 0,
|
|
frozen: 0,
|
|
)
|
|
}),
|
|
this.isTestnet = !network.isMainnet,
|
|
this._mnemonic = mnemonic,
|
|
super(walletInfo) {
|
|
transactionHistory = ElectrumTransactionHistory(
|
|
walletInfo: walletInfo,
|
|
password: password,
|
|
encryptionFileUtils: encryptionFileUtils,
|
|
);
|
|
|
|
reaction((_) => syncStatus, syncStatusReaction);
|
|
|
|
sharedPrefs.complete(SharedPreferences.getInstance());
|
|
}
|
|
|
|
static Future<Map<SeedBytesType, Bip32Slip10Secp256k1>> getAccountHDWallets({
|
|
required WalletInfo walletInfo,
|
|
required BasedUtxoNetwork network,
|
|
String? mnemonic,
|
|
String? passphrase,
|
|
String? xpub,
|
|
}) async {
|
|
assert(
|
|
mnemonic != null || xpub != null,
|
|
"To create a Wallet you need either a seed or an xpub. This should not happen",
|
|
);
|
|
|
|
late WalletSeedData walletSeedData;
|
|
if (mnemonic != null) {
|
|
walletSeedData = await WalletSeedData.fromMnemonic(walletInfo, mnemonic, network, passphrase);
|
|
} else {
|
|
walletSeedData = WalletSeedData.fromXpub(walletInfo, xpub!, network);
|
|
}
|
|
|
|
return walletSeedData.hdWallets;
|
|
}
|
|
|
|
// Sends a request to the worker and does not wait for a response
|
|
Null sendWorker(ElectrumWorkerRequest request) {
|
|
workerSendPort!.send(request.toJson());
|
|
return null;
|
|
}
|
|
|
|
// Sends a request to the worker and returns a future that completes when the worker responds
|
|
Future<T> waitSendWorker<T extends Map<String, dynamic>>(
|
|
ElectrumWorkerRequest request, [
|
|
Duration timeout = const Duration(seconds: 30),
|
|
]) async {
|
|
final messageId = ++_messageId;
|
|
|
|
final completer = Completer<T>();
|
|
_responseCompleters[messageId] = completer;
|
|
|
|
final m = request.toJson();
|
|
m['id'] = messageId;
|
|
workerSendPort!.send(m);
|
|
|
|
try {
|
|
return await completer.future.timeout(timeout);
|
|
} catch (e) {
|
|
_errorCompleters[messageId] = e;
|
|
_responseCompleters.remove(messageId);
|
|
rethrow;
|
|
}
|
|
}
|
|
|
|
@action
|
|
Future<void> handleWorkerResponse(dynamic message) async {
|
|
// printV('Main: received message: $message');
|
|
|
|
Map<String, dynamic> messageJson;
|
|
if (message is String) {
|
|
messageJson = jsonDecode(message) as Map<String, dynamic>;
|
|
} else {
|
|
messageJson = message as Map<String, dynamic>;
|
|
}
|
|
|
|
final workerMethod = messageJson['method'] as String;
|
|
final workerError = messageJson['error'] as String?;
|
|
final responseId = messageJson['id'] as int?;
|
|
final completed = messageJson['completed'] as bool?;
|
|
|
|
switch (workerMethod) {
|
|
case ElectrumWorkerMethods.connectionMethod:
|
|
if (workerError != null) {
|
|
_onConnectionStatusChange(ConnectionStatus.failed);
|
|
break;
|
|
}
|
|
|
|
final response = ElectrumWorkerConnectionResponse.fromJson(messageJson);
|
|
_onConnectionStatusChange(response.result);
|
|
break;
|
|
case ElectrumRequestMethods.headersSubscribeMethod:
|
|
final response = ElectrumWorkerHeadersSubscribeResponse.fromJson(messageJson);
|
|
await onHeadersResponse(response.result);
|
|
break;
|
|
case ElectrumRequestMethods.scripthashesSubscribeMethod:
|
|
final response = ElectrumWorkerScripthashesSubscribeResponse.fromJson(messageJson);
|
|
await onScripthashesStatusResponse(response.result);
|
|
break;
|
|
case ElectrumRequestMethods.getBalanceMethod:
|
|
final response = ElectrumWorkerGetBalanceResponse.fromJson(messageJson);
|
|
onBalanceResponse(response.result);
|
|
break;
|
|
case ElectrumRequestMethods.getHistoryMethod:
|
|
onHistoriesResponse(ElectrumWorkerGetHistoryResponse.fromJson(messageJson));
|
|
break;
|
|
case ElectrumRequestMethods.listunspentMethod:
|
|
final response = ElectrumWorkerListUnspentResponse.fromJson(messageJson);
|
|
onUnspentResponse(response.result);
|
|
break;
|
|
case ElectrumRequestMethods.estimateFeeMethod:
|
|
final response = ElectrumWorkerGetFeesResponse.fromJson(messageJson);
|
|
onFeesResponse(response.result);
|
|
break;
|
|
case ElectrumWorkerMethods.discoverAddressesMethod:
|
|
final response = ElectrumWorkerDiscoverAddressesResponse.fromJson(messageJson);
|
|
_onAddressesDiscovered(response.result);
|
|
break;
|
|
}
|
|
|
|
final shouldComplete = workerError != null || completed == true;
|
|
|
|
if (shouldComplete && responseId != null && _responseCompleters.containsKey(responseId)) {
|
|
_responseCompleters[responseId]!.complete(messageJson);
|
|
_responseCompleters.remove(responseId);
|
|
}
|
|
}
|
|
|
|
int estimatedTransactionSize({
|
|
required List<BitcoinAddressType> inputTypes,
|
|
required List<BitcoinAddressType> outputTypes,
|
|
String? memo,
|
|
bool enableRBF = true,
|
|
}) =>
|
|
BitcoinTransactionBuilder.estimateTransactionSizeFromTypes(
|
|
inputTypes: inputTypes,
|
|
outputTypes: outputTypes,
|
|
network: network,
|
|
memo: memo,
|
|
enableRBF: enableRBF,
|
|
);
|
|
|
|
final Map<SeedBytesType, Bip32Slip10Secp256k1> hdWallets;
|
|
Bip32Slip10Secp256k1 get hdWallet =>
|
|
hdWallets[SeedBytesType.bip39] ?? hdWallets[SeedBytesType.electrum]!;
|
|
final String? _mnemonic;
|
|
|
|
final EncryptionFileUtils encryptionFileUtils;
|
|
|
|
@override
|
|
final String? passphrase;
|
|
|
|
@override
|
|
@observable
|
|
bool isEnabledAutoGenerateSubaddress;
|
|
|
|
Box<UnspentCoinsInfo> unspentCoinsInfo;
|
|
|
|
@override
|
|
late T walletAddresses;
|
|
|
|
@override
|
|
@observable
|
|
late ObservableMap<CryptoCurrency, ElectrumBalance> balance;
|
|
|
|
@observable
|
|
SyncStatus _syncStatus;
|
|
|
|
@override
|
|
@computed
|
|
SyncStatus get syncStatus => _syncStatus;
|
|
|
|
@observable
|
|
bool syncStatusLock = false;
|
|
|
|
@override
|
|
set syncStatus(SyncStatus value) {
|
|
_syncStatus = value;
|
|
}
|
|
|
|
final String? _xpub;
|
|
String get xpub => _xpub ?? hdWallet.publicKey.toExtended;
|
|
|
|
@override
|
|
String? get seed => _mnemonic;
|
|
|
|
@override
|
|
WalletKeysData get walletKeysData => WalletKeysData(
|
|
mnemonic: _mnemonic,
|
|
xPub: xpub,
|
|
passphrase: passphrase,
|
|
);
|
|
|
|
@override
|
|
String get password => _password;
|
|
|
|
BasedUtxoNetwork network;
|
|
|
|
// TODO: change from isTestnet boolean to a networks enum (regtest, signet, etc)
|
|
@override
|
|
bool isTestnet;
|
|
|
|
bool _isTryingToConnect = false;
|
|
|
|
Completer<SharedPreferences> sharedPrefs = Completer();
|
|
|
|
@observable
|
|
int? currentChainTip;
|
|
|
|
@override
|
|
BitcoinWalletKeys get keys => BitcoinWalletKeys(
|
|
wif: WifEncoder.encode(hdWallet.privateKey.raw, netVer: network.wifNetVer),
|
|
privateKey: hdWallet.privateKey.toHex(),
|
|
publicKey: hdWallet.publicKey.toHex(),
|
|
);
|
|
|
|
String _password;
|
|
|
|
ElectrumUnspentCoins unspentCoins;
|
|
|
|
@observable
|
|
TransactionPriorities? feeRates;
|
|
|
|
int feeRate(TransactionPriority priority) => feeRates![priority];
|
|
|
|
@observable
|
|
// NOTE: https://electrumx.readthedocs.io/en/latest/protocol-basics.html#status
|
|
List<String> scripthashesWithStatus = [];
|
|
|
|
bool _chainTipListenerOn = false;
|
|
|
|
void Function(FlutterErrorDetails)? _onError;
|
|
Timer? _autoSaveTimer;
|
|
static const int _autoSaveInterval = 1;
|
|
|
|
Future<InitAddressesData> initAddresses([bool? sync]) async {
|
|
bool? isDiscovered = null;
|
|
bool? discovered;
|
|
|
|
// NOTE: will initiate by priority from the first walletAddressTypes
|
|
// then proceeds to following ones after got fully discovered response from worker response
|
|
for (final addressType in walletAddresses.walletAddressTypes) {
|
|
if (currency == CryptoCurrency.btc &&
|
|
isHardwareWallet &&
|
|
addressType != SegwitAddressType.p2wpkh) continue;
|
|
|
|
final bitcoinDerivationInfo = BitcoinAddressUtils.getDerivationFromType(
|
|
addressType,
|
|
network: network,
|
|
isElectrum: walletAddresses.walletSeedBytesType.isElectrum,
|
|
);
|
|
|
|
for (final isChange in [true, false]) {
|
|
isDiscovered = walletAddresses.discoveredAddressesRecord.getIsDiscovered(
|
|
addressType: addressType,
|
|
seedBytesType: walletAddresses.walletSeedBytesType,
|
|
derivationPath: bitcoinDerivationInfo.derivationPath.toString(),
|
|
isChange: isChange,
|
|
);
|
|
|
|
if (isDiscovered == false) break;
|
|
}
|
|
|
|
if (isDiscovered == false) {
|
|
discovered = await generateInitialAddresses(
|
|
addressType: addressType,
|
|
seedBytesType: walletAddresses.walletSeedBytesType,
|
|
bitcoinDerivationInfo: bitcoinDerivationInfo,
|
|
);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (currency != CryptoCurrency.btc) {
|
|
for (final addressType in walletAddresses.walletAddressTypes) {
|
|
for (final seedBytesType in hdWallets.keys) {
|
|
final bitcoinDerivationInfo = BitcoinAddressUtils.getDerivationFromType(
|
|
addressType,
|
|
network: network,
|
|
isElectrum: seedBytesType.isElectrum,
|
|
);
|
|
|
|
bool alreadyDidDerivation = false;
|
|
|
|
for (final derivationInfo in [
|
|
bitcoinDerivationInfo,
|
|
BitcoinDerivationInfos.BIP84,
|
|
BitcoinDerivationInfos.ELECTRUM,
|
|
]) {
|
|
final derivationPath = derivationInfo.derivationPath.toString();
|
|
|
|
if (alreadyDidDerivation &&
|
|
derivationPath == bitcoinDerivationInfo.derivationPath.toString()) {
|
|
continue;
|
|
}
|
|
|
|
alreadyDidDerivation = true;
|
|
|
|
for (final isChange in [true, false]) {
|
|
isDiscovered = walletAddresses.discoveredAddressesRecord.getIsDiscovered(
|
|
addressType: addressType,
|
|
seedBytesType: seedBytesType,
|
|
derivationPath: derivationPath,
|
|
isChange: isChange,
|
|
);
|
|
|
|
if (isDiscovered == false) {
|
|
break;
|
|
} else if (sync == true)
|
|
subscribeForStatuses(
|
|
walletAddresses.addressesRecords
|
|
.getRecords(
|
|
addressType: addressType,
|
|
seedBytesType: seedBytesType,
|
|
derivationPath: derivationPath,
|
|
isChange: isChange,
|
|
)
|
|
.whereType<BitcoinAddressRecord>()
|
|
.toList(),
|
|
);
|
|
}
|
|
|
|
if (isDiscovered == false) {
|
|
discovered = await generateInitialAddresses(
|
|
addressType: addressType,
|
|
seedBytesType: seedBytesType,
|
|
bitcoinDerivationInfo: derivationInfo,
|
|
);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (isDiscovered == false) break;
|
|
}
|
|
|
|
if (isDiscovered == false) break;
|
|
}
|
|
|
|
if (isDiscovered == true && sync == false)
|
|
initAddresses(true);
|
|
else if (isDiscovered == false && discovered == false) initAddresses(sync);
|
|
}
|
|
|
|
if (isDiscovered == true && syncStatus is SynchronizingSyncStatus)
|
|
syncStatus = SyncedSyncStatus();
|
|
|
|
return InitAddressesData(
|
|
isDiscovered: isDiscovered,
|
|
discovered: discovered,
|
|
);
|
|
}
|
|
|
|
Future<void> init() async {
|
|
await walletAddresses.init();
|
|
await transactionHistory.init();
|
|
|
|
_autoSaveTimer =
|
|
Timer.periodic(Duration(minutes: _autoSaveInterval), (_) async => await save());
|
|
}
|
|
|
|
@action
|
|
@override
|
|
Future<void> startSync() async {
|
|
try {
|
|
syncStatus = SynchronizingSyncStatus();
|
|
|
|
unspentCoins.removeWhere((utxo) => utxo.bitcoinAddressRecord is BitcoinAddressRecord);
|
|
|
|
await subscribeForHeaders(true);
|
|
await updateFeeRates();
|
|
|
|
await initAddresses(false);
|
|
|
|
await save();
|
|
} catch (e, stacktrace) {
|
|
printV(stacktrace);
|
|
printV("startSync $e");
|
|
syncStatus = FailedSyncStatus();
|
|
}
|
|
}
|
|
|
|
@action
|
|
void callError(FlutterErrorDetails error) {
|
|
_onError?.call(error);
|
|
}
|
|
|
|
Future<void> updateFeeRates() async {
|
|
workerSendPort!.send(ElectrumWorkerGetFeesRequest().toJson());
|
|
}
|
|
|
|
@action
|
|
Future<void> onFeesResponse(TransactionPriorities? result) async {
|
|
if (result != null) {
|
|
feeRates = result;
|
|
}
|
|
}
|
|
|
|
Node? node;
|
|
|
|
@action
|
|
@override
|
|
Future<void> connectToNode({required Node node}) async {
|
|
this.node = node;
|
|
|
|
try {
|
|
syncStatus = ConnectingSyncStatus();
|
|
|
|
if (_workerIsolate != null) {
|
|
_workerIsolate!.kill(priority: Isolate.immediate);
|
|
_workerSubscription?.cancel();
|
|
_receivePort?.close();
|
|
}
|
|
|
|
_receivePort = ReceivePort();
|
|
|
|
_workerIsolate = await Isolate.spawn<SendPort>(ElectrumWorker.run, _receivePort!.sendPort);
|
|
|
|
_workerSubscription = _receivePort!.listen((message) {
|
|
if (message is SendPort) {
|
|
workerSendPort = message;
|
|
workerSendPort!.send(
|
|
ElectrumWorkerConnectionRequest(
|
|
uri: node.uri,
|
|
useSSL: node.useSSL ?? false,
|
|
network: network,
|
|
walletType: walletInfo.type,
|
|
).toJson(),
|
|
);
|
|
} else {
|
|
handleWorkerResponse(message);
|
|
}
|
|
});
|
|
} catch (e, stacktrace) {
|
|
printV(stacktrace);
|
|
printV("connectToNode $e");
|
|
syncStatus = FailedSyncStatus();
|
|
}
|
|
}
|
|
|
|
int get dustAmount => 546;
|
|
|
|
bool isBelowDust(int amount) => amount <= dustAmount;
|
|
|
|
ElectrumTxCreateUtxoDetails createUTXOS({
|
|
required bool sendAll,
|
|
int credentialsAmount = 0,
|
|
int? inputsCount,
|
|
}) {
|
|
List<UtxoWithAddress> utxos = [];
|
|
List<Outpoint> vinOutpoints = [];
|
|
List<ECPrivateInfo> inputPrivKeyInfos = [];
|
|
final publicKeys = <String, PublicKeyWithDerivationPath>{};
|
|
int allInputsAmount = 0;
|
|
bool spendsUnconfirmedTX = false;
|
|
|
|
int leftAmount = credentialsAmount;
|
|
var availableInputs = unspentCoins.where((utx) {
|
|
final unspentCoinInfo = unspentCoinsInfo.values.firstWhereOrNull(
|
|
(element) => element.walletId == id && element == utx,
|
|
);
|
|
|
|
if (!utx.isSending || utx.isFrozen) {
|
|
return false;
|
|
}
|
|
if (unspentCoinInfo != null) {
|
|
if (!unspentCoinInfo.isSending || unspentCoinInfo.isFrozen) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}).toList();
|
|
final unconfirmedCoins = availableInputs.where((utx) => utx.confirmations == 0).toList();
|
|
|
|
for (int i = 0; i < availableInputs.length; i++) {
|
|
final utx = availableInputs[i];
|
|
if (!spendsUnconfirmedTX) spendsUnconfirmedTX = utx.confirmations == 0;
|
|
|
|
allInputsAmount += utx.value;
|
|
leftAmount = leftAmount - utx.value;
|
|
|
|
final address = RegexUtils.addressTypeFromStr(utx.address, network);
|
|
ECPrivate? privkey;
|
|
|
|
if (!isHardwareWallet) {
|
|
final addressRecord = utx.bitcoinAddressRecord;
|
|
|
|
privkey = ECPrivate.fromBip32(
|
|
bip32: hdWallets[addressRecord.seedBytesType]!.derive(
|
|
Bip32PathParser.parse(addressRecord.indexedDerivationPath),
|
|
),
|
|
);
|
|
}
|
|
|
|
vinOutpoints.add(Outpoint(txid: utx.hash, index: utx.vout));
|
|
String pubKeyHex;
|
|
|
|
if (privkey != null) {
|
|
inputPrivKeyInfos.add(ECPrivateInfo(privkey, address.type == SegwitAddressType.p2tr));
|
|
|
|
pubKeyHex = privkey.getPublic().toHex();
|
|
} else {
|
|
pubKeyHex = walletAddresses.hdWallet
|
|
.childKey(Bip32KeyIndex(utx.bitcoinAddressRecord.index))
|
|
.publicKey
|
|
.toHex();
|
|
}
|
|
|
|
if (utx.bitcoinAddressRecord is BitcoinAddressRecord) {
|
|
final derivationPath = utx.bitcoinAddressRecord.indexedDerivationPath;
|
|
publicKeys[address.pubKeyHash()] = PublicKeyWithDerivationPath(pubKeyHex, derivationPath);
|
|
}
|
|
|
|
utxos.add(
|
|
UtxoWithAddress(
|
|
utxo: BitcoinUtxo(
|
|
txHash: utx.hash,
|
|
value: BigInt.from(utx.value),
|
|
vout: utx.vout,
|
|
scriptType: BitcoinAddressUtils.getScriptType(address),
|
|
),
|
|
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 ElectrumTxCreateUtxoDetails(
|
|
availableInputs: availableInputs,
|
|
unconfirmedCoins: unconfirmedCoins,
|
|
utxos: utxos,
|
|
vinOutpoints: vinOutpoints,
|
|
inputPrivKeyInfos: inputPrivKeyInfos,
|
|
publicKeys: publicKeys,
|
|
allInputsAmount: allInputsAmount,
|
|
spendsUnconfirmedTX: spendsUnconfirmedTX,
|
|
);
|
|
}
|
|
|
|
Future<ElectrumEstimatedTx> estimateSendAllTx(
|
|
List<BitcoinOutput> outputs,
|
|
int feeRate, {
|
|
String? memo,
|
|
}) async {
|
|
final utxoDetails = createUTXOS(sendAll: true);
|
|
|
|
int fee = await calcFee(
|
|
utxos: utxoDetails.utxos,
|
|
outputs: outputs,
|
|
memo: memo,
|
|
feeRate: feeRate,
|
|
);
|
|
|
|
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
|
|
int amount = utxoDetails.allInputsAmount - fee;
|
|
|
|
if (amount <= 0) {
|
|
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: BigInt.from(amount));
|
|
}
|
|
|
|
return ElectrumEstimatedTx(
|
|
utxos: utxoDetails.utxos,
|
|
inputPrivKeyInfos: utxoDetails.inputPrivKeyInfos,
|
|
publicKeys: utxoDetails.publicKeys,
|
|
fee: fee,
|
|
amount: amount,
|
|
isSendAll: true,
|
|
hasChange: false,
|
|
memo: memo,
|
|
spendsUnconfirmedTX: utxoDetails.spendsUnconfirmedTX,
|
|
);
|
|
}
|
|
|
|
Future<ElectrumEstimatedTx> estimateTxForAmount(
|
|
int credentialsAmount,
|
|
List<BitcoinOutput> outputs,
|
|
int feeRate, {
|
|
int? inputsCount,
|
|
String? memo,
|
|
bool? useUnconfirmed,
|
|
bool isFakeTx = false,
|
|
}) async {
|
|
// Attempting to send less than the dust limit
|
|
if (!isFakeTx && isBelowDust(credentialsAmount)) {
|
|
throw BitcoinTransactionNoDustException();
|
|
}
|
|
|
|
final utxoDetails = createUTXOS(
|
|
sendAll: false,
|
|
credentialsAmount: credentialsAmount,
|
|
inputsCount: inputsCount,
|
|
);
|
|
|
|
final spendingAllCoins = utxoDetails.availableInputs.length == utxoDetails.utxos.length;
|
|
final spendingAllConfirmedCoins = !utxoDetails.spendsUnconfirmedTX &&
|
|
utxoDetails.utxos.length ==
|
|
utxoDetails.availableInputs.length - utxoDetails.unconfirmedCoins.length;
|
|
|
|
// How much is being spent - how much is being sent
|
|
int amountLeftForChangeAndFee = utxoDetails.allInputsAmount - credentialsAmount;
|
|
|
|
if (amountLeftForChangeAndFee <= 0) {
|
|
if (!spendingAllCoins) {
|
|
return estimateTxForAmount(
|
|
credentialsAmount,
|
|
outputs,
|
|
feeRate,
|
|
inputsCount: utxoDetails.utxos.length + 1,
|
|
memo: memo,
|
|
isFakeTx: isFakeTx,
|
|
);
|
|
}
|
|
|
|
throw BitcoinTransactionWrongBalanceException();
|
|
}
|
|
|
|
final changeAddress = await walletAddresses.getChangeAddress();
|
|
final address = RegexUtils.addressTypeFromStr(changeAddress.address, network);
|
|
outputs.add(BitcoinOutput(
|
|
address: address,
|
|
value: BigInt.from(amountLeftForChangeAndFee),
|
|
isChange: true,
|
|
));
|
|
|
|
final changeDerivationPath = changeAddress.indexedDerivationPath.toString();
|
|
utxoDetails.publicKeys[address.pubKeyHash()] =
|
|
PublicKeyWithDerivationPath('', changeDerivationPath);
|
|
|
|
int fee = calcFee(
|
|
utxos: utxoDetails.utxos,
|
|
outputs: outputs,
|
|
memo: memo,
|
|
feeRate: feeRate,
|
|
);
|
|
|
|
if (fee == 0) {
|
|
throw BitcoinTransactionNoFeeException();
|
|
}
|
|
|
|
int amount = credentialsAmount;
|
|
final lastOutput = outputs.last;
|
|
final amountLeftForChange = amountLeftForChangeAndFee - fee;
|
|
|
|
if (!isFakeTx && isBelowDust(amountLeftForChange)) {
|
|
// If has change that is lower than dust, will end up with tx rejected by network rules
|
|
// so remove the change amount
|
|
outputs.removeLast();
|
|
|
|
if (amountLeftForChange < 0) {
|
|
if (!spendingAllCoins) {
|
|
return estimateTxForAmount(
|
|
credentialsAmount,
|
|
outputs,
|
|
feeRate,
|
|
inputsCount: utxoDetails.utxos.length + 1,
|
|
memo: memo,
|
|
useUnconfirmed: useUnconfirmed ?? spendingAllConfirmedCoins,
|
|
isFakeTx: isFakeTx,
|
|
);
|
|
} else {
|
|
throw BitcoinTransactionWrongBalanceException();
|
|
}
|
|
}
|
|
|
|
return ElectrumEstimatedTx(
|
|
utxos: utxoDetails.utxos,
|
|
inputPrivKeyInfos: utxoDetails.inputPrivKeyInfos,
|
|
publicKeys: utxoDetails.publicKeys,
|
|
fee: fee,
|
|
amount: amount,
|
|
hasChange: false,
|
|
isSendAll: spendingAllCoins,
|
|
memo: memo,
|
|
spendsUnconfirmedTX: utxoDetails.spendsUnconfirmedTX,
|
|
);
|
|
} else {
|
|
// Here, lastOutput already is change, return the amount left without the fee to the user's address.
|
|
outputs[outputs.length - 1] = BitcoinOutput(
|
|
address: lastOutput.address,
|
|
value: BigInt.from(amountLeftForChange),
|
|
isChange: true,
|
|
);
|
|
|
|
return ElectrumEstimatedTx(
|
|
utxos: utxoDetails.utxos,
|
|
inputPrivKeyInfos: utxoDetails.inputPrivKeyInfos,
|
|
publicKeys: utxoDetails.publicKeys,
|
|
fee: fee,
|
|
amount: amount,
|
|
hasChange: true,
|
|
isSendAll: spendingAllCoins,
|
|
memo: memo,
|
|
spendsUnconfirmedTX: utxoDetails.spendsUnconfirmedTX,
|
|
);
|
|
}
|
|
}
|
|
|
|
int calcFee({
|
|
required List<UtxoWithAddress> utxos,
|
|
required List<BitcoinBaseOutput> outputs,
|
|
String? memo,
|
|
required int feeRate,
|
|
}) =>
|
|
feeRate *
|
|
BitcoinTransactionBuilder.estimateTransactionSize(
|
|
utxos: utxos,
|
|
outputs: outputs,
|
|
network: network,
|
|
memo: memo,
|
|
);
|
|
|
|
CreateTxData getCreateTxDataFromCredentials(Object credentials) {
|
|
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;
|
|
|
|
int credentialsAmount = 0;
|
|
|
|
for (final out in transactionCredentials.outputs) {
|
|
final outputAmount = out.formattedCryptoAmount!;
|
|
|
|
if (!sendAll && isBelowDust(outputAmount)) {
|
|
throw BitcoinTransactionNoDustException();
|
|
}
|
|
|
|
if (hasMultiDestination) {
|
|
if (out.sendAll) {
|
|
throw BitcoinTransactionWrongBalanceException();
|
|
}
|
|
}
|
|
|
|
credentialsAmount += outputAmount;
|
|
|
|
final address = RegexUtils.addressTypeFromStr(
|
|
out.isParsedAddress ? out.extractedAddress! : out.address,
|
|
network,
|
|
);
|
|
|
|
if (sendAll) {
|
|
outputs.add(
|
|
BitcoinOutput(
|
|
address: address,
|
|
// Send all: The value of the single existing output will be updated
|
|
// after estimating the Tx size and deducting the fee from the total to be sent
|
|
value: BigInt.from(0),
|
|
),
|
|
);
|
|
} else {
|
|
outputs.add(
|
|
BitcoinOutput(
|
|
address: address,
|
|
value: BigInt.from(outputAmount),
|
|
),
|
|
);
|
|
}
|
|
}
|
|
|
|
final feeRateInt = transactionCredentials.feeRate != null
|
|
? transactionCredentials.feeRate!
|
|
: feeRate(transactionCredentials.priority!);
|
|
|
|
return CreateTxData(
|
|
sendAll: sendAll,
|
|
amount: credentialsAmount,
|
|
outputs: outputs,
|
|
feeRate: feeRateInt,
|
|
memo: memo,
|
|
);
|
|
}
|
|
|
|
@override
|
|
Future<PendingTransaction> createTransaction(Object credentials) async {
|
|
try {
|
|
final data = getCreateTxDataFromCredentials(credentials);
|
|
|
|
ElectrumEstimatedTx estimatedTx;
|
|
if (data.sendAll) {
|
|
estimatedTx = await estimateSendAllTx(
|
|
data.outputs,
|
|
data.feeRate,
|
|
memo: data.memo,
|
|
);
|
|
} else {
|
|
estimatedTx = await estimateTxForAmount(
|
|
data.amount,
|
|
data.outputs,
|
|
data.feeRate,
|
|
memo: data.memo,
|
|
);
|
|
}
|
|
|
|
if (walletInfo.isHardwareWallet) {
|
|
final transaction = await buildHardwareWalletTransaction(
|
|
utxos: estimatedTx.utxos,
|
|
outputs: data.outputs,
|
|
publicKeys: estimatedTx.publicKeys,
|
|
fee: BigInt.from(estimatedTx.fee),
|
|
memo: estimatedTx.memo,
|
|
outputOrdering: BitcoinOrdering.none,
|
|
enableRBF: true,
|
|
);
|
|
|
|
return PendingBitcoinTransaction(
|
|
transaction,
|
|
type,
|
|
waitSendWorker: waitSendWorker,
|
|
amount: estimatedTx.amount,
|
|
fee: estimatedTx.fee,
|
|
feeRate: data.feeRate.toString(),
|
|
hasChange: estimatedTx.hasChange,
|
|
isSendAll: estimatedTx.isSendAll,
|
|
hasTaprootInputs: false, // ToDo: (Konsti) Support Taproot
|
|
)..addListener((transaction) async {
|
|
transactionHistory.addOne(transaction);
|
|
await updateBalance();
|
|
await updateAllUnspents();
|
|
});
|
|
}
|
|
|
|
BasedBitcoinTransacationBuilder txb;
|
|
if (network is BitcoinCashNetwork) {
|
|
txb = ForkedTransactionBuilder(
|
|
utxos: estimatedTx.utxos,
|
|
outputs: data.outputs,
|
|
fee: BigInt.from(estimatedTx.fee),
|
|
network: network,
|
|
memo: estimatedTx.memo,
|
|
outputOrdering: BitcoinOrdering.none,
|
|
enableRBF: !estimatedTx.spendsUnconfirmedTX,
|
|
);
|
|
} else {
|
|
txb = BitcoinTransactionBuilder(
|
|
utxos: estimatedTx.utxos,
|
|
outputs: data.outputs,
|
|
fee: BigInt.from(estimatedTx.fee),
|
|
network: network,
|
|
memo: estimatedTx.memo,
|
|
outputOrdering: BitcoinOrdering.none,
|
|
enableRBF: !estimatedTx.spendsUnconfirmedTX,
|
|
);
|
|
}
|
|
|
|
bool hasTaprootInputs = false;
|
|
|
|
final transaction = txb.buildTransaction((txDigest, utxo, publicKey, sighash) {
|
|
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);
|
|
} else {
|
|
return key.privkey.signInput(txDigest, sigHash: sighash);
|
|
}
|
|
});
|
|
|
|
return PendingBitcoinTransaction(
|
|
transaction,
|
|
type,
|
|
waitSendWorker: waitSendWorker,
|
|
amount: estimatedTx.amount,
|
|
fee: estimatedTx.fee,
|
|
feeRate: data.feeRate.toString(),
|
|
hasChange: estimatedTx.hasChange,
|
|
isSendAll: estimatedTx.isSendAll,
|
|
hasTaprootInputs: hasTaprootInputs,
|
|
utxos: estimatedTx.utxos,
|
|
)..addListener((transaction) async {
|
|
transactionHistory.addOne(transaction);
|
|
|
|
unspentCoins
|
|
.removeWhere((utxo) => estimatedTx.utxos.any((e) => e.utxo.txHash == utxo.hash));
|
|
|
|
await updateBalance();
|
|
await updateAllUnspents();
|
|
});
|
|
} catch (e) {
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
void setLedgerConnection(ledger.LedgerConnection connection) => throw UnimplementedError();
|
|
|
|
Future<BtcTransaction> buildHardwareWalletTransaction({
|
|
required List<BitcoinBaseOutput> outputs,
|
|
required BigInt fee,
|
|
required List<UtxoWithAddress> utxos,
|
|
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 ?? '',
|
|
'walletAddresses': walletAddresses.toJson(),
|
|
'balance': balance[currency]?.toJSON(),
|
|
'unspent_coins': unspentCoins.map((e) => e.toJson()).toList(),
|
|
});
|
|
|
|
int feeAmountForPriority(
|
|
TransactionPriority priority, {
|
|
required List<BitcoinAddressType> inputTypes,
|
|
required List<BitcoinAddressType> outputTypes,
|
|
String? memo,
|
|
bool enableRBF = true,
|
|
}) =>
|
|
feeRate(priority) *
|
|
estimatedTransactionSize(
|
|
inputTypes: inputTypes,
|
|
outputTypes: outputTypes,
|
|
memo: memo,
|
|
enableRBF: enableRBF,
|
|
);
|
|
|
|
int feeAmountWithFeeRate(
|
|
int feeRate, {
|
|
required List<BitcoinAddressType> inputTypes,
|
|
required List<BitcoinAddressType> outputTypes,
|
|
String? memo,
|
|
bool enableRBF = true,
|
|
}) =>
|
|
feeRate *
|
|
estimatedTransactionSize(
|
|
inputTypes: inputTypes,
|
|
outputTypes: outputTypes,
|
|
memo: memo,
|
|
enableRBF: enableRBF,
|
|
);
|
|
|
|
@override
|
|
Future<int> calculateEstimatedFee(
|
|
TransactionPriority priority, {
|
|
List<String> outputAddresses = const [],
|
|
String? memo,
|
|
bool enableRBF = true,
|
|
}) async {
|
|
return estimatedFeeForOutputsWithFeeRate(
|
|
feeRate: feeRate(priority),
|
|
outputAddresses: outputAddresses,
|
|
memo: memo,
|
|
enableRBF: enableRBF,
|
|
);
|
|
}
|
|
|
|
// Estimates the fee for paying to the given outputs
|
|
// using the wallet's available unspent coins as inputs
|
|
Future<int> estimatedFeeForOutputsWithFeeRate({
|
|
required int feeRate,
|
|
required List<String> outputAddresses,
|
|
String? memo,
|
|
bool enableRBF = true,
|
|
}) async {
|
|
final fakePublicKey = ECPrivate.random().getPublic();
|
|
final fakeOutputs = <BitcoinOutput>[];
|
|
final outputTypes =
|
|
outputAddresses.map((e) => BitcoinAddressUtils.addressTypeFromStr(e, network)).toList();
|
|
|
|
for (final outputType in outputTypes) {
|
|
late BitcoinBaseAddress address;
|
|
switch (outputType) {
|
|
case P2pkhAddressType.p2pkh:
|
|
address = fakePublicKey.toP2pkhAddress();
|
|
break;
|
|
case P2shAddressType.p2pkInP2sh:
|
|
address = fakePublicKey.toP2pkhInP2sh();
|
|
break;
|
|
case SegwitAddressType.p2wpkh:
|
|
address = fakePublicKey.toP2wpkhAddress();
|
|
break;
|
|
case P2shAddressType.p2pkhInP2sh:
|
|
address = fakePublicKey.toP2pkhInP2sh();
|
|
break;
|
|
case SegwitAddressType.p2wsh:
|
|
address = fakePublicKey.toP2wshAddress();
|
|
break;
|
|
case SegwitAddressType.p2tr:
|
|
case SilentPaymentsAddresType.p2sp:
|
|
address = fakePublicKey.toTaprootAddress();
|
|
break;
|
|
case SegwitAddressType.mweb:
|
|
address = fakePublicKey.toMwebAddress();
|
|
break;
|
|
default:
|
|
throw const FormatException('Invalid output type');
|
|
}
|
|
|
|
fakeOutputs.add(BitcoinOutput(address: address, value: BigInt.from(0)));
|
|
}
|
|
|
|
final estimatedFakeTx = await estimateTxForAmount(
|
|
0,
|
|
fakeOutputs,
|
|
feeRate,
|
|
memo: memo,
|
|
isFakeTx: true,
|
|
);
|
|
final inputTypes = estimatedFakeTx.utxos.map((e) => e.ownerDetails.address.type).toList();
|
|
|
|
return feeAmountWithFeeRate(
|
|
feeRate,
|
|
inputTypes: inputTypes,
|
|
outputTypes: outputTypes,
|
|
memo: memo,
|
|
enableRBF: enableRBF,
|
|
);
|
|
}
|
|
|
|
@override
|
|
Future<void> save() async {
|
|
if (!(await WalletKeysFile.hasKeysFile(walletInfo.name, walletInfo.type))) {
|
|
await saveKeysFile(_password, encryptionFileUtils);
|
|
await saveKeysFile(_password, encryptionFileUtils, true);
|
|
}
|
|
|
|
final path = await makePath();
|
|
await encryptionFileUtils.write(path: path, password: _password, data: toJSON());
|
|
await transactionHistory.save();
|
|
}
|
|
|
|
@override
|
|
Future<void> renameWalletFiles(String newWalletName) async {
|
|
final currentWalletPath = await pathForWallet(name: walletInfo.name, type: type);
|
|
final currentWalletFile = File(currentWalletPath);
|
|
|
|
final currentDirPath = await pathForWalletDir(name: walletInfo.name, type: type);
|
|
final currentTransactionsFile = File('$currentDirPath/$transactionsHistoryFileName');
|
|
|
|
// Copies current wallet files into new wallet name's dir and files
|
|
if (currentWalletFile.existsSync()) {
|
|
final newWalletPath = await pathForWallet(name: newWalletName, type: type);
|
|
await currentWalletFile.copy(newWalletPath);
|
|
}
|
|
if (currentTransactionsFile.existsSync()) {
|
|
final newDirPath = await pathForWalletDir(name: newWalletName, type: type);
|
|
await currentTransactionsFile.copy('$newDirPath/$transactionsHistoryFileName');
|
|
}
|
|
|
|
// Delete old name's dir and files
|
|
await Directory(currentDirPath).delete(recursive: true);
|
|
}
|
|
|
|
@override
|
|
Future<void> changePassword(String password) async {
|
|
_password = password;
|
|
await save();
|
|
await transactionHistory.changePassword(password);
|
|
}
|
|
|
|
@override
|
|
Future<void> rescan({required int height}) async {
|
|
throw UnimplementedError();
|
|
}
|
|
|
|
@override
|
|
Future<void> close({bool shouldCleanup = false}) async {
|
|
try {
|
|
_workerIsolate!.kill(priority: Isolate.immediate);
|
|
await _workerSubscription?.cancel();
|
|
_receivePort?.close();
|
|
} catch (_) {}
|
|
_autoSaveTimer?.cancel();
|
|
}
|
|
|
|
@action
|
|
Future<ElectrumWorkerListUnspentResponse?> updateAllUnspents([
|
|
List<String>? scripthashes,
|
|
bool? wait,
|
|
]) async {
|
|
scripthashes ??= walletAddresses.allScriptHashes;
|
|
|
|
if (scripthashes.isEmpty) {
|
|
return null;
|
|
}
|
|
|
|
if (wait == true) {
|
|
return ElectrumWorkerListUnspentResponse.fromJson(
|
|
await waitSendWorker(
|
|
ElectrumWorkerListUnspentRequest(scripthashes: scripthashes.toList()),
|
|
),
|
|
);
|
|
} else {
|
|
return sendWorker(
|
|
ElectrumWorkerListUnspentRequest(scripthashes: scripthashes.toList()),
|
|
);
|
|
}
|
|
}
|
|
|
|
@action
|
|
void updateCoin(BitcoinUnspent 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;
|
|
} else {
|
|
addCoinInfo(coin);
|
|
}
|
|
}
|
|
|
|
@action
|
|
Future<void> onUnspentResponse(Map<String, List<ElectrumUtxo>> unspents) async {
|
|
final updatedUnspentCoins = <BitcoinUnspent>[];
|
|
|
|
await Future.wait(unspents.entries.map((entry) async {
|
|
final scriptHash = entry.key;
|
|
final unspent = entry.value;
|
|
|
|
final addressRecord = walletAddresses.allAddresses.firstWhereOrNull(
|
|
(element) => element.scriptHash == scriptHash,
|
|
);
|
|
|
|
if (addressRecord == null) {
|
|
return null;
|
|
}
|
|
|
|
if (unspent.isEmpty) {
|
|
unspentCoins.removeWhere((coin) =>
|
|
coin.bitcoinAddressRecord is BitcoinAddressRecord &&
|
|
(coin.bitcoinAddressRecord as BitcoinAddressRecord).scriptHash == scriptHash);
|
|
return null;
|
|
}
|
|
|
|
await Future.wait(unspent.map((unspent) async {
|
|
final coin = BitcoinUnspent.fromJSON(addressRecord, unspent.toJson());
|
|
coin.isChange = addressRecord.isChange;
|
|
|
|
final tx = await getExistingTransaction(hash: coin.hash);
|
|
|
|
if (tx != null) {
|
|
coin.confirmations = tx.confirmations;
|
|
}
|
|
|
|
updatedUnspentCoins.add(coin);
|
|
}));
|
|
}));
|
|
|
|
unspentCoins.addAll(updatedUnspentCoins);
|
|
unspentCoins.forEach(updateCoin);
|
|
|
|
await refreshUnspentCoinsInfo();
|
|
}
|
|
|
|
@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 == coin);
|
|
|
|
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,
|
|
);
|
|
|
|
await unspentCoinsInfo.add(newInfo);
|
|
}
|
|
}
|
|
|
|
@action
|
|
Future<void> refreshUnspentCoinsInfo() async {
|
|
try {
|
|
final List<dynamic> keys = [];
|
|
final currentWalletUnspentCoins =
|
|
unspentCoinsInfo.values.where((record) => record.walletId == id);
|
|
|
|
for (final element in currentWalletUnspentCoins) {
|
|
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");
|
|
}
|
|
}
|
|
|
|
@action
|
|
Future<void> onScripthashesStatusResponse(
|
|
List<ElectrumWorkerScripthashesResponse> result,
|
|
) async {
|
|
final noItemsWithStatus = result.length == 1 && result.first.status == null;
|
|
if (noItemsWithStatus) {
|
|
return;
|
|
}
|
|
|
|
final addresses = walletAddresses.allAddresses
|
|
.where(
|
|
(address) => result.any((e) => e.status != null && e.scripthash == address.scriptHash),
|
|
)
|
|
.toList();
|
|
|
|
final scripthashesWithStatus =
|
|
result.where((e) => e.status != null).map((e) => e.scripthash).toList();
|
|
|
|
updateTransactions(addresses);
|
|
updateBalance(scripthashesWithStatus);
|
|
updateAllUnspents(scripthashesWithStatus);
|
|
}
|
|
|
|
@action
|
|
Future<void> onHeadersResponse(ElectrumWorkerHeadersResponse response) async {
|
|
currentChainTip = response.headerResponse.height;
|
|
|
|
if (syncStatus is SyncedSyncStatus) {
|
|
syncStatus = SyncedNewBlockSyncStatus(currentChainTip!);
|
|
}
|
|
|
|
if (response.anyTxWasUpdated) {
|
|
transactionHistory.addMany(response.transactions);
|
|
await save();
|
|
}
|
|
}
|
|
|
|
@action
|
|
Future<void> subscribeForHeaders([bool? wait]) async {
|
|
if (_chainTipListenerOn) return;
|
|
|
|
if (wait == true) {
|
|
ElectrumWorkerHeadersSubscribeResponse.fromJson(
|
|
await waitSendWorker(
|
|
ElectrumWorkerHeadersSubscribeRequest(
|
|
transactions: transactionHistory.transactions,
|
|
walletType: type,
|
|
),
|
|
),
|
|
);
|
|
} else {
|
|
sendWorker(
|
|
ElectrumWorkerHeadersSubscribeRequest(
|
|
transactions: transactionHistory.transactions,
|
|
walletType: type,
|
|
),
|
|
);
|
|
}
|
|
|
|
_chainTipListenerOn = true;
|
|
}
|
|
|
|
@action
|
|
Future<void> onHistoriesResponse(ElectrumWorkerGetHistoryResponse response) async {
|
|
final histories = response.result;
|
|
final addressesWithHistory = <BitcoinAddressRecord>[];
|
|
|
|
if (histories.isNotEmpty) {
|
|
for (final addressHistory in histories) {
|
|
final txs = addressHistory.txs;
|
|
|
|
if (txs.isNotEmpty) {
|
|
addressesWithHistory.add(addressHistory.addressRecord);
|
|
|
|
for (final tx in txs) {
|
|
transactionHistory.addOne(tx);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (addressesWithHistory.isNotEmpty) {
|
|
walletAddresses.addAddresses(addressesWithHistory);
|
|
}
|
|
}
|
|
}
|
|
|
|
Future<String?> canReplaceByFee(ElectrumTransactionInfo tx) async {
|
|
if (tx.confirmations > 0) return null;
|
|
|
|
try {
|
|
final bundle = await getTransactionExpanded(hash: tx.txHash);
|
|
tx.updateInputsAndOutputs(bundle, network);
|
|
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(
|
|
BitcoinAddressUtils.addressFromOutputScript(output.scriptPubKey, network),
|
|
),
|
|
)
|
|
.fold<int>(0, (sum, output) => sum + output.amount.toInt());
|
|
|
|
if (receiverAmount == 0) {
|
|
throw Exception("Receiver output not found.");
|
|
}
|
|
|
|
final availableInputs = unspentCoins.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];
|
|
final vout = input.txIndex;
|
|
final outTransaction = inputTransaction.outputs[vout];
|
|
allInputsAmount += outTransaction.amount.toInt();
|
|
}
|
|
|
|
int totalOutAmount = bundle.originalTransaction.outputs
|
|
.fold<int>(0, (previousValue, element) => previousValue + element.amount.toInt());
|
|
var currentFee = allInputsAmount - totalOutAmount;
|
|
|
|
int remainingFee = (newFee - currentFee > 0) ? newFee - currentFee : newFee;
|
|
return totalBalance - receiverAmount - remainingFee >= dustAmount;
|
|
}
|
|
|
|
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];
|
|
final vout = input.txIndex;
|
|
final outTransaction = inputTransaction.outputs[vout];
|
|
final address =
|
|
BitcoinAddressUtils.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 path = addressRecord.derivationInfo.derivationPath
|
|
.addElem(Bip32KeyIndex(
|
|
BitcoinAddressUtils.getAccountFromChange(addressRecord.isChange),
|
|
))
|
|
.addElem(Bip32KeyIndex(addressRecord.index));
|
|
|
|
final privkey = ECPrivate.fromBip32(bip32: hdWallet.derive(path));
|
|
|
|
privateKeys.add(privkey);
|
|
|
|
utxos.add(
|
|
UtxoWithAddress(
|
|
utxo: BitcoinUtxo(
|
|
txHash: input.txId,
|
|
value: outTransaction.amount,
|
|
vout: vout,
|
|
scriptType: BitcoinAddressUtils.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 = StringUtils.decode(BytesUtils.fromHexString(opReturnData));
|
|
continue;
|
|
} catch (_) {
|
|
throw Exception('Cannot decode OP_RETURN data');
|
|
}
|
|
}
|
|
}
|
|
|
|
final address = BitcoinAddressUtils.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;
|
|
int remainingFee = newFee - currentFee;
|
|
|
|
if (remainingFee <= 0) {
|
|
throw Exception("New fee must be higher than the current fee.");
|
|
}
|
|
|
|
// Deduct fee from change outputs first, if possible
|
|
if (remainingFee > 0) {
|
|
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) {
|
|
int outputAmount = output.value.toInt();
|
|
if (outputAmount > dustAmount) {
|
|
int deduction = (outputAmount - dustAmount >= remainingFee)
|
|
? remainingFee
|
|
: outputAmount - dustAmount;
|
|
outputs[i] = BitcoinOutput(
|
|
address: output.address, value: BigInt.from(outputAmount - deduction));
|
|
remainingFee -= deduction;
|
|
|
|
if (remainingFee <= 0) break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// If still not enough, add UTXOs until the fee is covered
|
|
if (remainingFee > 0) {
|
|
final unusedUtxos = unspentCoins
|
|
.where((utxo) => utxo.isSending && !utxo.isFrozen && utxo.confirmations! > 0)
|
|
.toList();
|
|
|
|
for (final utxo in unusedUtxos) {
|
|
final address = RegexUtils.addressTypeFromStr(utxo.address, network);
|
|
final privkey = ECPrivate.fromBip32(bip32: hdWallet);
|
|
privateKeys.add(privkey);
|
|
|
|
utxos.add(
|
|
UtxoWithAddress(
|
|
utxo: BitcoinUtxo(
|
|
txHash: utxo.hash,
|
|
value: BigInt.from(utxo.value),
|
|
vout: utxo.vout,
|
|
scriptType: BitcoinAddressUtils.getScriptType(address)),
|
|
ownerDetails:
|
|
UtxoAddressDetails(publicKey: privkey.getPublic().toHex(), address: address),
|
|
),
|
|
);
|
|
|
|
allInputsAmount += utxo.value;
|
|
remainingFee -= utxo.value;
|
|
|
|
if (remainingFee < 0) {
|
|
final changeOutput = outputs.firstWhereOrNull((output) => walletAddresses.allAddresses
|
|
.any((addr) => addr.address == output.address.toAddress(network)));
|
|
if (changeOutput != null) {
|
|
final newValue = changeOutput.value.toInt() + (-remainingFee);
|
|
outputs[outputs.indexOf(changeOutput)] =
|
|
BitcoinOutput(address: changeOutput.address, value: BigInt.from(newValue));
|
|
} else {
|
|
final changeAddress = await walletAddresses.getChangeAddress();
|
|
outputs.add(BitcoinOutput(
|
|
address: RegexUtils.addressTypeFromStr(changeAddress.address, network),
|
|
value: BigInt.from(-remainingFee)));
|
|
}
|
|
|
|
remainingFee = 0;
|
|
break;
|
|
}
|
|
|
|
if (remainingFee <= 0) break;
|
|
}
|
|
}
|
|
|
|
// Deduct from the receiver's output if remaining fee is still greater than 0
|
|
if (remainingFee > 0) {
|
|
for (int i = 0; i < outputs.length; i++) {
|
|
final output = outputs[i];
|
|
int outputAmount = output.value.toInt();
|
|
|
|
if (outputAmount > dustAmount) {
|
|
int deduction = (outputAmount - dustAmount >= remainingFee)
|
|
? remainingFee
|
|
: outputAmount - dustAmount;
|
|
|
|
outputs[i] = BitcoinOutput(
|
|
address: output.address, value: BigInt.from(outputAmount - deduction));
|
|
remainingFee -= deduction;
|
|
|
|
if (remainingFee <= 0) break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Final check if the remaining fee couldn't be deducted
|
|
if (remainingFee > 0) {
|
|
throw Exception("Not enough funds to cover the fee.");
|
|
}
|
|
|
|
// Identify all change outputs
|
|
final changeAddresses = walletAddresses.allAddresses.where((element) => element.isChange);
|
|
final List<BitcoinOutput> changeOutputs = outputs
|
|
.where((output) =>
|
|
changeAddresses.any((addr) => addr.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,
|
|
outputOrdering: BitcoinOrdering.none,
|
|
enableRBF: true,
|
|
);
|
|
|
|
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,
|
|
waitSendWorker: waitSendWorker,
|
|
amount: sendingAmount,
|
|
fee: newFee,
|
|
hasChange: changeOutputs.isNotEmpty,
|
|
feeRate: newFee.toString(),
|
|
)..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 updateBalance();
|
|
await updateAllUnspents();
|
|
});
|
|
} catch (e) {
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
Future<String> getTransactionHex({required String hash}) async {
|
|
return ElectrumWorkerTxHexResponse.fromJson(
|
|
await waitSendWorker(
|
|
ElectrumWorkerTxHexRequest(txHash: hash, currentChainTip: currentChainTip!),
|
|
),
|
|
).result;
|
|
}
|
|
|
|
Future<ElectrumTransactionBundle> getTransactionExpanded({required String hash}) async {
|
|
return ElectrumWorkerTxExpandedResponse.fromJson(
|
|
await waitSendWorker(
|
|
ElectrumWorkerTxExpandedRequest(txHash: hash, currentChainTip: currentChainTip!),
|
|
),
|
|
).result;
|
|
}
|
|
|
|
Future<ElectrumTransactionInfo?> getExistingTransaction({required String hash}) async {
|
|
var tx = transactionHistory.transactions.values.firstWhereOrNull((tx) => tx.txHash == hash);
|
|
tx ??= await fetchTransactionInfo(hash: hash);
|
|
return tx;
|
|
}
|
|
|
|
Future<ElectrumTransactionInfo?> fetchTransactionInfo({required String hash, int? height}) async {
|
|
try {
|
|
return ElectrumTransactionInfo.fromElectrumBundle(
|
|
await getTransactionExpanded(hash: hash),
|
|
walletInfo.type,
|
|
network,
|
|
addresses: walletAddresses.allAddresses.map((e) => e.address).toSet(),
|
|
height: height,
|
|
);
|
|
} catch (_) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
@override
|
|
@action
|
|
Future<Map<String, ElectrumTransactionInfo>> fetchTransactions() async {
|
|
throw UnimplementedError();
|
|
}
|
|
|
|
Future<ElectrumWorkerGetHistoryRequest> getUpdateTransactionsRequest([
|
|
List<BitcoinAddressRecord>? addresses,
|
|
]) async {
|
|
return ElectrumWorkerGetHistoryRequest(
|
|
addresses: addresses ?? walletAddresses.allAddresses.toList(),
|
|
storedTxs: transactionHistory.transactions.values.toList(),
|
|
walletType: type,
|
|
// If we still don't have currentChainTip, txs will still be fetched but shown
|
|
// with confirmations as 0 but will be auto fixed on onHeadersResponse
|
|
chainTip: currentChainTip ?? -1,
|
|
network: network,
|
|
);
|
|
}
|
|
|
|
Future<ElectrumWorkerGetHistoryResponse?> updateTransactions([
|
|
List<BitcoinAddressRecord>? addresses,
|
|
bool? wait,
|
|
]) async {
|
|
if (wait == true) {
|
|
return ElectrumWorkerGetHistoryResponse.fromJson(
|
|
await waitSendWorker(
|
|
await getUpdateTransactionsRequest(addresses),
|
|
),
|
|
);
|
|
} else {
|
|
return sendWorker(
|
|
await getUpdateTransactionsRequest(addresses),
|
|
);
|
|
}
|
|
}
|
|
|
|
@action
|
|
Future<List<ElectrumWorkerScripthashesResponse>?> subscribeForStatuses([
|
|
List<BitcoinAddressRecord>? addresses,
|
|
bool? wait,
|
|
]) async {
|
|
Map<String, String> scripthashByAddress = {};
|
|
Map<String, String> addressByScripthashes = {};
|
|
(addresses ?? walletAddresses.allAddresses).forEach((addressRecord) {
|
|
scripthashByAddress[addressRecord.address] = addressRecord.scriptHash;
|
|
addressByScripthashes[addressRecord.scriptHash] = addressRecord.address;
|
|
});
|
|
|
|
if (scripthashByAddress.isEmpty || addressByScripthashes.isEmpty) {
|
|
return null;
|
|
}
|
|
|
|
if (wait == true)
|
|
return ElectrumWorkerScripthashesSubscribeResponse.fromJson(
|
|
await waitSendWorker(
|
|
ElectrumWorkerScripthashesSubscribeRequest(
|
|
scripthashByAddress: scripthashByAddress,
|
|
addressByScripthashes: addressByScripthashes,
|
|
),
|
|
),
|
|
).result;
|
|
else
|
|
sendWorker(
|
|
ElectrumWorkerScripthashesSubscribeRequest(
|
|
scripthashByAddress: scripthashByAddress,
|
|
addressByScripthashes: addressByScripthashes,
|
|
),
|
|
);
|
|
|
|
return null;
|
|
}
|
|
|
|
@action
|
|
void onBalanceResponse(ElectrumGetBalanceResponse balanceResults) {
|
|
var totalFrozen = 0;
|
|
var totalConfirmed = 0;
|
|
var totalUnconfirmed = 0;
|
|
|
|
if (unspentCoins.isNotEmpty)
|
|
unspentCoins.forInfo(unspentCoinsInfo.values).forEach((unspentCoinInfo) {
|
|
if (unspentCoinInfo.isFrozen) {
|
|
totalFrozen += unspentCoinInfo.value;
|
|
}
|
|
});
|
|
|
|
for (int i = 0; i < balanceResults.balances.length; i++) {
|
|
final scripthash = balanceResults.scripthashes[i];
|
|
final addressRecord = walletAddresses.allAddresses.firstWhereOrNull(
|
|
(element) => element.scriptHash == scripthash,
|
|
);
|
|
|
|
if (addressRecord != null) {
|
|
final balance = balanceResults.balances[i];
|
|
addressRecord.balance = balance;
|
|
}
|
|
}
|
|
|
|
for (final addressRecord in [
|
|
...walletAddresses.allAddresses,
|
|
...walletAddresses.otherAddresses
|
|
]) {
|
|
final balance = addressRecord.balance;
|
|
|
|
if (balance.hasBalance()) {
|
|
totalConfirmed += balance.confirmed;
|
|
totalUnconfirmed += balance.unconfirmed;
|
|
}
|
|
}
|
|
|
|
balance[currency] = ElectrumBalance(
|
|
confirmed: totalConfirmed,
|
|
unconfirmed: totalUnconfirmed,
|
|
frozen: totalFrozen,
|
|
);
|
|
}
|
|
|
|
@action
|
|
Future<ElectrumWorkerGetBalanceResponse?> updateBalance([
|
|
List<String>? scripthashes,
|
|
bool? wait,
|
|
]) async {
|
|
scripthashes ??= walletAddresses.allScriptHashes;
|
|
|
|
if (scripthashes.isEmpty) {
|
|
return null;
|
|
}
|
|
|
|
if (wait == true) {
|
|
return ElectrumWorkerGetBalanceResponse.fromJson(
|
|
await waitSendWorker(
|
|
ElectrumWorkerGetBalanceRequest(scripthashes: scripthashes),
|
|
),
|
|
);
|
|
} else {
|
|
return sendWorker(
|
|
ElectrumWorkerGetBalanceRequest(scripthashes: scripthashes),
|
|
);
|
|
}
|
|
}
|
|
|
|
@override
|
|
void setExceptionHandler(void Function(FlutterErrorDetails) onError) => _onError = onError;
|
|
|
|
Future<String> signMessage(String message, {String? address = null}) async {
|
|
final record = walletAddresses.getFromAddresses(address!);
|
|
|
|
final path = Bip32PathParser.parse(walletInfo.derivationInfo!.derivationPath!)
|
|
.addElem(
|
|
Bip32KeyIndex(BitcoinAddressUtils.getAccountFromChange(record.isChange)),
|
|
)
|
|
.addElem(Bip32KeyIndex(record.index));
|
|
|
|
final priv = ECPrivate.fromHex(hdWallet.derive(path).privateKey.toHex());
|
|
|
|
final hexEncoded =
|
|
priv.signMessage(StringUtils.encode(message), messagePrefix: SIGN_MESSAGE_PREFIX);
|
|
final decodedSig = hex.decode(hexEncoded);
|
|
return base64Encode(decodedSig);
|
|
}
|
|
|
|
@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 = BytesUtils.fromHexString(signature);
|
|
}
|
|
|
|
if (sigDecodedBytes.length != 64 && sigDecodedBytes.length != 65) {
|
|
throw ArgumentException(
|
|
"signature must be 64 bytes without recover-id or 65 bytes with recover-id");
|
|
}
|
|
|
|
final messageHash = QuickCrypto.sha256Hash(
|
|
BitcoinSignerUtils.magicMessage(StringUtils.encode(message), SIGN_MESSAGE_PREFIX),
|
|
);
|
|
|
|
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;
|
|
}
|
|
|
|
@action
|
|
void _onConnectionStatusChange(ConnectionStatus status) {
|
|
switch (status) {
|
|
case ConnectionStatus.connected:
|
|
if (syncStatus is NotConnectedSyncStatus ||
|
|
syncStatus is LostConnectionSyncStatus ||
|
|
syncStatus is ConnectingSyncStatus) {
|
|
syncStatus = ConnectedSyncStatus();
|
|
}
|
|
|
|
break;
|
|
case ConnectionStatus.disconnected:
|
|
if (syncStatus is! NotConnectedSyncStatus &&
|
|
syncStatus is! ConnectingSyncStatus &&
|
|
syncStatus is! SynchronizingSyncStatus) {
|
|
syncStatus = NotConnectedSyncStatus();
|
|
}
|
|
break;
|
|
case ConnectionStatus.failed:
|
|
if (syncStatus is! LostConnectionSyncStatus) {
|
|
syncStatus = LostConnectionSyncStatus();
|
|
}
|
|
break;
|
|
case ConnectionStatus.connecting:
|
|
if (syncStatus is! ConnectingSyncStatus) {
|
|
syncStatus = ConnectingSyncStatus();
|
|
}
|
|
break;
|
|
default:
|
|
}
|
|
}
|
|
|
|
@action
|
|
void syncStatusReaction(SyncStatus syncStatus) {
|
|
final isDisconnectedStatus =
|
|
syncStatus is NotConnectedSyncStatus || syncStatus is LostConnectionSyncStatus;
|
|
|
|
if (syncStatus is ConnectingSyncStatus || isDisconnectedStatus) {
|
|
// Needs to re-subscribe to all scripthashes when reconnected
|
|
_chainTipListenerOn = false;
|
|
}
|
|
|
|
if (isDisconnectedStatus) {
|
|
if (_isTryingToConnect) return;
|
|
|
|
_isTryingToConnect = true;
|
|
|
|
Timer(Duration(seconds: 5), () {
|
|
if (this.syncStatus is NotConnectedSyncStatus ||
|
|
this.syncStatus is LostConnectionSyncStatus) {
|
|
if (node == null) return;
|
|
|
|
connectToNode(node: this.node!);
|
|
}
|
|
_isTryingToConnect = false;
|
|
});
|
|
}
|
|
|
|
if (syncStatus is SyncedNewBlockSyncStatus) {
|
|
// Message is shown on the UI for 3 seconds, then reverted to synced
|
|
Timer(Duration(seconds: 3), () {
|
|
if (this.syncStatus is SyncedNewBlockSyncStatus) this.syncStatus = SyncedSyncStatus();
|
|
});
|
|
}
|
|
|
|
if (syncStatus is SyncedNewPaymentSyncStatus) {
|
|
syncStatusLock = true;
|
|
|
|
// Message is shown on the UI for 3 seconds, then reverted to synced
|
|
Timer(Duration(seconds: 2), () {
|
|
if (this.syncStatus is SyncedNewPaymentSyncStatus) {
|
|
this.syncStatusLock = false;
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
@action
|
|
Future<void> _onAddressesDiscovered(List<BitcoinAddressRecord> addresses) async {
|
|
final scripthashByAddress = await subscribeForStatuses(addresses, true);
|
|
final noItemsWithStatus =
|
|
scripthashByAddress!.length == 1 && scripthashByAddress.first.status == null;
|
|
|
|
final firstAddress = addresses.first;
|
|
|
|
// NOTE: Did not find any status for old/wrong derivation addresses, discard them
|
|
// (don't add to addresses list)
|
|
if (firstAddress.seedBytesType!.isOldDerivation && noItemsWithStatus) {
|
|
walletAddresses.discoveredAddressesRecord.addDiscovered(
|
|
addressType: firstAddress.type,
|
|
seedBytesType: firstAddress.seedBytesType!,
|
|
derivationPath: firstAddress.derivationInfo.derivationPath.toString(),
|
|
isChange: firstAddress.isChange,
|
|
discovered: true,
|
|
);
|
|
initAddresses();
|
|
return;
|
|
}
|
|
|
|
walletAddresses.addAddresses(addresses);
|
|
walletAddresses.discoveredAddressesRecord.addDiscovered(
|
|
addressType: firstAddress.type,
|
|
seedBytesType: firstAddress.seedBytesType!,
|
|
derivationPath: firstAddress.derivationInfo.derivationPath.toString(),
|
|
isChange: firstAddress.isChange,
|
|
discovered: true,
|
|
);
|
|
|
|
// NOTE: Has items with status under gap limit, continue discovering
|
|
if (!noItemsWithStatus)
|
|
discoverNewAddresses(
|
|
seedBytesType: firstAddress.seedBytesType!,
|
|
isChange: firstAddress.isChange,
|
|
addressType: firstAddress.type,
|
|
derivationInfo: firstAddress.derivationInfo,
|
|
scripthashStatuses: scripthashByAddress,
|
|
);
|
|
// NOTE: Otherwise, sync all the discovered addresses so far
|
|
else {
|
|
subscribeForStatuses(
|
|
walletAddresses.addressesRecords
|
|
.getRecords(
|
|
seedBytesType: firstAddress.seedBytesType!,
|
|
addressType: firstAddress.type,
|
|
derivationPath: firstAddress.derivationInfo.derivationPath.toString(),
|
|
isChange: firstAddress.isChange,
|
|
)
|
|
.whereType<BitcoinAddressRecord>()
|
|
.toList(),
|
|
);
|
|
initAddresses();
|
|
}
|
|
}
|
|
|
|
@action
|
|
Future<bool> generateInitialAddresses({
|
|
required BitcoinAddressType addressType,
|
|
required SeedBytesType seedBytesType,
|
|
BitcoinDerivationInfo? bitcoinDerivationInfo,
|
|
}) async {
|
|
bool discovered = false;
|
|
|
|
bitcoinDerivationInfo ??= BitcoinAddressUtils.getDerivationFromType(
|
|
addressType,
|
|
network: network,
|
|
isElectrum: seedBytesType.isElectrum,
|
|
);
|
|
|
|
for (final isChange in [true, false]) {
|
|
final existingAddresses = walletAddresses.addressesRecords.getRecords(
|
|
addressType: addressType,
|
|
seedBytesType: seedBytesType,
|
|
derivationPath: bitcoinDerivationInfo.derivationPath.toString(),
|
|
isChange: isChange,
|
|
);
|
|
final discoveredExistingAddresses = walletAddresses.discoveredAddressesRecord.getIsDiscovered(
|
|
addressType: addressType,
|
|
seedBytesType: seedBytesType,
|
|
derivationPath: bitcoinDerivationInfo.derivationPath.toString(),
|
|
isChange: isChange,
|
|
);
|
|
|
|
final gapCount = isChange
|
|
? ElectrumWalletAddressesBase.INITIAL_CHANGE_COUNT
|
|
: ElectrumWalletAddressesBase.INITIAL_RECEIVE_COUNT;
|
|
|
|
if (!discoveredExistingAddresses && existingAddresses.length < gapCount) {
|
|
discoverNewAddresses(
|
|
addressType: addressType,
|
|
seedBytesType: seedBytesType,
|
|
derivationInfo: bitcoinDerivationInfo,
|
|
isChange: isChange,
|
|
startIndex: existingAddresses.length,
|
|
);
|
|
discovered = true;
|
|
}
|
|
|
|
walletAddresses.discoveredAddressesRecord.addDiscovered(
|
|
addressType: addressType,
|
|
seedBytesType: seedBytesType,
|
|
derivationPath: bitcoinDerivationInfo.derivationPath.toString(),
|
|
isChange: isChange,
|
|
discovered: true,
|
|
);
|
|
}
|
|
|
|
return discovered;
|
|
}
|
|
|
|
void discoverNewAddresses({
|
|
required SeedBytesType seedBytesType,
|
|
required bool isChange,
|
|
required BitcoinAddressType addressType,
|
|
required BitcoinDerivationInfo derivationInfo,
|
|
int? startIndex,
|
|
List<ElectrumWorkerScripthashesResponse>? scripthashStatuses,
|
|
}) async {
|
|
final countToDiscover = isChange
|
|
? ElectrumWalletAddressesBase.INITIAL_CHANGE_COUNT
|
|
: ElectrumWalletAddressesBase.INITIAL_RECEIVE_COUNT;
|
|
|
|
final recordList = walletAddresses.addressesRecords.getRecords(
|
|
seedBytesType: seedBytesType,
|
|
addressType: addressType,
|
|
derivationPath: derivationInfo.derivationPath.toString(),
|
|
isChange: isChange,
|
|
);
|
|
|
|
startIndex ??= recordList.length;
|
|
|
|
late bool needsToDiscover;
|
|
|
|
if (recordList.length < countToDiscover) {
|
|
needsToDiscover = true;
|
|
} else if (recordList.length == countToDiscover) {
|
|
needsToDiscover = recordList.any((record) => !record.getIsUsed());
|
|
} else {
|
|
needsToDiscover = recordList.sublist(recordList.length - countToDiscover).any(
|
|
(record) {
|
|
return scripthashStatuses?.any(
|
|
(scripthashStatus) => scripthashStatus.scripthash == record.scriptHash,
|
|
) ??
|
|
record.getIsUsed();
|
|
},
|
|
);
|
|
}
|
|
|
|
if (!needsToDiscover) {
|
|
return;
|
|
}
|
|
|
|
workerSendPort!.send(
|
|
ElectrumWorkerDiscoverAddressesRequest(
|
|
id: _messageId,
|
|
count: countToDiscover,
|
|
walletType: type,
|
|
startIndex: startIndex,
|
|
seedBytesType: seedBytesType,
|
|
derivationInfo: derivationInfo,
|
|
isChange: isChange,
|
|
addressType: addressType,
|
|
xpriv: hdWallets[seedBytesType]!.privateKey.toExtended,
|
|
network: network,
|
|
).toJson(),
|
|
);
|
|
}
|
|
|
|
@override
|
|
String formatCryptoAmount(String amount) {
|
|
final amountInt = int.parse(amount);
|
|
return BitcoinAmountUtils.bitcoinAmountToString(amount: amountInt);
|
|
}
|
|
}
|
|
|
|
class ElectrumEstimatedTx {
|
|
ElectrumEstimatedTx({
|
|
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.spendsUnconfirmedTX,
|
|
});
|
|
|
|
final List<UtxoWithAddress> utxos;
|
|
final List<ECPrivateInfo> inputPrivKeyInfos;
|
|
final Map<String, PublicKeyWithDerivationPath> publicKeys; // PubKey to derivationPath
|
|
final int fee;
|
|
final int amount;
|
|
|
|
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;
|
|
}
|
|
|
|
class ElectrumTxCreateUtxoDetails {
|
|
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 spendsUnconfirmedTX;
|
|
|
|
ElectrumTxCreateUtxoDetails({
|
|
required this.availableInputs,
|
|
required this.unconfirmedCoins,
|
|
required this.utxos,
|
|
required this.vinOutpoints,
|
|
required this.inputPrivKeyInfos,
|
|
required this.publicKeys,
|
|
required this.allInputsAmount,
|
|
required this.spendsUnconfirmedTX,
|
|
});
|
|
}
|
|
|
|
class ElectrumUnspentCoins extends ObservableSet<BitcoinUnspent> {
|
|
ElectrumUnspentCoins() : super();
|
|
|
|
static ElectrumUnspentCoins of(Iterable<BitcoinUnspent> unspentCoins) {
|
|
final coins = ElectrumUnspentCoins();
|
|
coins.addAll(unspentCoins);
|
|
return coins;
|
|
}
|
|
|
|
List<UnspentCoinsInfo> forInfo(Iterable<UnspentCoinsInfo> unspentCoinsInfo) {
|
|
return unspentCoinsInfo.where((element) {
|
|
final info = this.firstWhereOrNull(
|
|
(info) =>
|
|
element.hash == info.hash &&
|
|
element.vout == info.vout &&
|
|
element.address == info.bitcoinAddressRecord.address &&
|
|
element.value == info.value,
|
|
);
|
|
|
|
return info != null;
|
|
}).toList();
|
|
}
|
|
|
|
List<BitcoinUnspent> fromInfo(Iterable<UnspentCoinsInfo> unspentCoinsInfo) {
|
|
return this.where((element) {
|
|
final info = unspentCoinsInfo.firstWhereOrNull(
|
|
(info) =>
|
|
element.hash == info.hash &&
|
|
element.vout == info.vout &&
|
|
element.bitcoinAddressRecord.address == info.address &&
|
|
element.value == info.value,
|
|
);
|
|
|
|
return info != null;
|
|
}).toList();
|
|
}
|
|
}
|
|
|
|
class CreateTxData {
|
|
final int amount;
|
|
final int feeRate;
|
|
final List<BitcoinOutput> outputs;
|
|
final bool sendAll;
|
|
final String? memo;
|
|
|
|
CreateTxData({
|
|
required this.amount,
|
|
required this.feeRate,
|
|
required this.outputs,
|
|
required this.sendAll,
|
|
required this.memo,
|
|
});
|
|
}
|
|
|
|
class InitAddressesData {
|
|
bool? isDiscovered;
|
|
bool? discovered;
|
|
|
|
InitAddressesData({
|
|
required this.isDiscovered,
|
|
required this.discovered,
|
|
});
|
|
}
|