cake_wallet/cw_lightning/lib/lightning_wallet.dart

395 lines
13 KiB
Dart
Raw Normal View History

2024-02-16 20:37:08 +00:00
import 'dart:convert';
2024-02-08 19:45:21 +00:00
import 'dart:io';
2024-02-23 17:29:11 +00:00
import 'package:bitcoin_base/bitcoin_base.dart';
2024-02-08 19:45:21 +00:00
import 'package:breez_sdk/breez_sdk.dart';
import 'package:breez_sdk/bridge_generated.dart';
import 'package:cw_bitcoin/bitcoin_mnemonic.dart';
2024-02-16 20:37:08 +00:00
import 'package:cw_bitcoin/bitcoin_wallet_keys.dart';
import 'package:cw_bitcoin/electrum.dart';
import 'package:cw_bitcoin/electrum_wallet_addresses.dart';
2024-02-23 17:29:11 +00:00
import 'package:cw_bitcoin/electrum_wallet_snapshot.dart';
import 'package:cw_bitcoin/litecoin_network.dart';
2024-02-08 19:45:21 +00:00
import 'package:cw_core/crypto_currency.dart';
2024-02-16 20:37:08 +00:00
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';
2024-02-22 03:03:19 +00:00
import 'package:cw_core/transaction_direction.dart';
2024-02-16 20:37:08 +00:00
import 'package:cw_core/transaction_priority.dart';
2024-02-08 19:45:21 +00:00
import 'package:cw_core/unspent_coins_info.dart';
2024-02-16 20:37:08 +00:00
import 'package:cw_core/utils/file.dart';
2024-02-22 03:03:19 +00:00
import 'package:cw_core/wallet_type.dart';
2024-02-16 20:37:08 +00:00
import 'package:cw_lightning/lightning_balance.dart';
2024-02-22 03:03:19 +00:00
import 'package:cw_lightning/lightning_transaction_history.dart';
import 'package:cw_lightning/lightning_transaction_info.dart';
2024-02-08 19:45:21 +00:00
import 'package:hive/hive.dart';
import 'package:mobx/mobx.dart';
import 'package:flutter/foundation.dart';
import 'package:bitcoin_flutter/bitcoin_flutter.dart' as bitcoin;
import 'package:cw_core/wallet_info.dart';
2024-02-08 19:59:06 +00:00
import 'package:cw_bitcoin/bitcoin_address_record.dart';
import 'package:cw_bitcoin/bitcoin_wallet_addresses.dart';
2024-02-08 19:45:21 +00:00
import 'package:path_provider/path_provider.dart';
import 'package:cw_lightning/.secrets.g.dart' as secrets;
2024-02-16 20:37:08 +00:00
import 'package:cw_core/wallet_base.dart';
2024-02-08 19:45:21 +00:00
2024-02-08 19:59:06 +00:00
part 'lightning_wallet.g.dart';
2024-02-08 19:45:21 +00:00
class LightningWallet = LightningWalletBase with _$LightningWallet;
2024-02-22 03:03:19 +00:00
abstract class LightningWalletBase
extends WalletBase<LightningBalance, LightningTransactionHistory, LightningTransactionInfo>
2024-02-16 20:37:08 +00:00
with Store {
final bitcoin.HDWallet hd;
final String mnemonic;
String _password;
2024-02-22 03:03:19 +00:00
bool _isTransactionUpdating;
2024-02-16 20:37:08 +00:00
late ElectrumClient electrumClient;
@override
@observable
late ObservableMap<CryptoCurrency, LightningBalance> balance;
@override
late ElectrumWalletAddresses walletAddresses;
bitcoin.NetworkType networkType = bitcoin.bitcoin;
2024-02-23 17:29:11 +00:00
late BasedUtxoNetwork network;
2024-02-16 20:37:08 +00:00
@override
BitcoinWalletKeys get keys =>
BitcoinWalletKeys(wif: hd.wif!, privateKey: hd.privKey!, publicKey: hd.pubKey!);
@override
@observable
SyncStatus syncStatus;
2024-02-15 22:27:05 +00:00
2024-02-23 17:29:11 +00:00
LightningWalletBase({
required String mnemonic,
required String password,
required WalletInfo walletInfo,
required Box<UnspentCoinsInfo> unspentCoinsInfo,
required Uint8List seedBytes,
String? addressPageType,
ElectrumClient? electrumClient,
BasedUtxoNetwork? networkParam,
List<BitcoinAddressRecord>? initialAddresses,
LightningBalance? initialBalance,
Map<String, int>? initialRegularAddressIndex,
Map<String, int>? initialChangeAddressIndex,
}) : hd = bitcoin.HDWallet.fromSeed(seedBytes, network: bitcoin.bitcoin).derivePath("m/0'/0"),
2024-02-16 20:37:08 +00:00
syncStatus = NotConnectedSyncStatus(),
mnemonic = mnemonic,
_password = password,
2024-02-22 03:03:19 +00:00
_isTransactionUpdating = false,
2024-02-16 20:37:08 +00:00
balance = ObservableMap<CryptoCurrency, LightningBalance>.of({
CryptoCurrency.btc:
initialBalance ?? const LightningBalance(confirmed: 0, unconfirmed: 0, frozen: 0)
}),
super(walletInfo) {
2024-02-22 03:03:19 +00:00
transactionHistory = LightningTransactionHistory(walletInfo: walletInfo, password: password);
2024-02-23 17:29:11 +00:00
this.network = networkType == bitcoin.bitcoin
? BitcoinNetwork.mainnet
: networkType == litecoinNetwork
? LitecoinNetwork.mainnet
: BitcoinNetwork.testnet;
this.isTestnet = networkType == bitcoin.testnet;
walletAddresses = BitcoinWalletAddresses(
walletInfo,
electrumClient: electrumClient ?? ElectrumClient(),
initialAddresses: initialAddresses,
initialRegularAddressIndex: initialRegularAddressIndex,
initialChangeAddressIndex: initialChangeAddressIndex,
mainHd: hd,
sideHd: bitcoin.HDWallet.fromSeed(seedBytes, network: networkType).derivePath("m/0'/1"),
network: networkParam ?? network,
);
2024-02-08 19:45:21 +00:00
2024-02-16 20:37:08 +00:00
this.electrumClient = electrumClient ?? ElectrumClient();
2024-02-08 19:45:21 +00:00
// initialize breeze:
2024-02-13 18:13:17 +00:00
try {
setupBreez(seedBytes);
} catch (e) {
print("Error initializing Breez: $e");
}
2024-02-08 19:45:21 +00:00
autorun((_) {
this.walletAddresses.isEnabledAutoGenerateSubaddress = this.isEnabledAutoGenerateSubaddress;
});
}
2024-02-23 17:29:11 +00:00
static Future<LightningWallet> create({
required String mnemonic,
required String password,
required WalletInfo walletInfo,
required Box<UnspentCoinsInfo> unspentCoinsInfo,
BasedUtxoNetwork? network,
List<BitcoinAddressRecord>? initialAddresses,
Map<String, int>? initialRegularAddressIndex,
Map<String, int>? initialChangeAddressIndex,
}) async {
2024-02-08 19:59:06 +00:00
return LightningWallet(
2024-02-23 17:29:11 +00:00
mnemonic: mnemonic,
password: password,
walletInfo: walletInfo,
unspentCoinsInfo: unspentCoinsInfo,
initialAddresses: initialAddresses,
seedBytes: await mnemonicToSeedBytes(mnemonic),
initialRegularAddressIndex: initialRegularAddressIndex,
initialChangeAddressIndex: initialChangeAddressIndex,
);
2024-02-08 19:45:21 +00:00
}
2024-02-08 19:59:06 +00:00
static Future<LightningWallet> open({
2024-02-08 19:45:21 +00:00
required String name,
required WalletInfo walletInfo,
required Box<UnspentCoinsInfo> unspentCoinsInfo,
required String password,
}) async {
2024-02-23 17:29:11 +00:00
final snp = await ElectrumWalletSnapshot.load(name, walletInfo.type, password,
walletInfo.network != null ? BasedUtxoNetwork.fromName(walletInfo.network!) : null);
2024-02-08 19:59:06 +00:00
return LightningWallet(
2024-02-23 17:29:11 +00:00
mnemonic: snp.mnemonic,
password: password,
walletInfo: walletInfo,
unspentCoinsInfo: unspentCoinsInfo,
initialAddresses: snp.addresses,
// initialBalance: snp.balance,
seedBytes: await mnemonicToSeedBytes(snp.mnemonic),
initialRegularAddressIndex: snp.regularAddressIndex,
initialChangeAddressIndex: snp.changeAddressIndex,
addressPageType: snp.addressPageType,
networkParam: snp.network,
);
2024-02-08 19:45:21 +00:00
}
2024-02-13 18:13:17 +00:00
Future<void> setupBreez(Uint8List seedBytes) async {
// Initialize SDK logs listener
final sdk = BreezSDK();
2024-02-16 20:37:08 +00:00
try {
sdk.initialize();
} catch (e) {
print("Error initializing Breez: $e");
}
2024-02-08 19:45:21 +00:00
2024-02-13 18:13:17 +00:00
NodeConfig breezNodeConfig = NodeConfig.greenlight(
config: GreenlightNodeConfig(
partnerCredentials: null,
inviteCode: secrets.breezInviteCode,
),
);
Config breezConfig = await sdk.defaultConfig(
envType: EnvironmentType.Production,
apiKey: secrets.breezApiKey,
nodeConfig: breezNodeConfig,
);
2024-02-08 19:45:21 +00:00
2024-02-13 18:13:17 +00:00
// Customize the config object according to your needs
String workingDir = (await getApplicationDocumentsDirectory()).path;
workingDir = "$workingDir/wallets/lightning/${walletInfo.name}/breez/";
new Directory(workingDir).createSync(recursive: true);
breezConfig = breezConfig.copyWith(workingDir: workingDir);
2024-02-16 20:37:08 +00:00
try {
// disconnect if already connected
2024-02-16 20:37:08 +00:00
await sdk.disconnect();
} catch (_) {}
try {
2024-02-16 20:37:08 +00:00
await sdk.connect(config: breezConfig, seed: seedBytes);
} catch (e) {
print("Error connecting to Breez: $e");
}
2024-02-13 18:13:17 +00:00
2024-02-15 22:27:05 +00:00
sdk.nodeStateStream.listen((event) {
if (event == null) return;
2024-02-16 20:37:08 +00:00
balance[CryptoCurrency.btc] = LightningBalance(
confirmed: event.maxPayableMsat ~/ 1000,
unconfirmed: event.maxReceivableMsat ~/ 1000,
2024-02-15 22:27:05 +00:00
frozen: 0,
);
});
2024-02-22 17:32:06 +00:00
sdk.paymentsStream.listen((payments) {
_isTransactionUpdating = true;
print("payment event: $payments");
var txs = convertToTxInfo(payments);
transactionHistory.addMany(txs);
_isTransactionUpdating = false;
});
2024-02-22 03:03:19 +00:00
2024-02-15 22:27:05 +00:00
print("initialized breez: ${(await sdk.isInitialized())}");
2024-02-08 19:45:21 +00:00
}
2024-02-16 20:37:08 +00:00
@override
int calculateEstimatedFee(TransactionPriority priority, int? amount) {
throw UnimplementedError("calculateEstimatedFee");
}
@action
@override
Future<void> startSync() async {
try {
syncStatus = AttemptingSyncStatus();
2024-02-22 03:03:19 +00:00
await updateTransactions();
2024-02-16 20:37:08 +00:00
syncStatus = SyncedSyncStatus();
} catch (e) {
print(e);
syncStatus = FailedSyncStatus();
rethrow;
}
}
@override
Future<void> changePassword(String password) {
throw UnimplementedError("changePassword");
}
@override
void close() {}
@action
@override
Future<void> connectToNode({required Node node}) async {
try {
syncStatus = ConnectingSyncStatus();
2024-02-22 03:03:19 +00:00
await updateTransactions();
2024-02-16 20:37:08 +00:00
syncStatus = ConnectedSyncStatus();
} catch (e) {
print(e);
syncStatus = FailedSyncStatus();
}
}
@override
Future<PendingTransaction> createTransaction(Object credentials) async {
throw UnimplementedError("createTransaction");
}
2024-02-22 03:03:19 +00:00
Future<bool> updateTransactions() async {
try {
if (_isTransactionUpdating) {
return false;
}
_isTransactionUpdating = true;
final transactions = await fetchTransactions();
transactionHistory.addMany(transactions);
await transactionHistory.save();
_isTransactionUpdating = false;
return true;
} catch (_) {
_isTransactionUpdating = false;
return false;
}
}
2024-02-22 17:32:06 +00:00
Map<String, LightningTransactionInfo> convertToTxInfo(List<Payment> payments) {
2024-02-22 17:47:29 +00:00
Map<String, LightningTransactionInfo> transactions = {};
2024-02-22 03:03:19 +00:00
2024-02-22 17:47:29 +00:00
for (Payment tx in payments) {
if (tx.paymentType == PaymentType.ClosedChannel) {
continue;
2024-02-22 03:03:19 +00:00
}
2024-02-22 17:47:29 +00:00
bool isSend = tx.paymentType == PaymentType.Sent;
2024-02-22 17:32:06 +00:00
transactions[tx.id] = LightningTransactionInfo(
2024-02-22 03:03:19 +00:00
WalletType.lightning,
isPending: false,
id: tx.id,
amount: tx.amountMsat ~/ 1000,
fee: tx.feeMsat,
date: DateTime.fromMillisecondsSinceEpoch(tx.paymentTime * 1000),
height: tx.paymentTime,
direction: isSend ? TransactionDirection.outgoing : TransactionDirection.incoming,
confirmations: 1,
);
}
2024-02-22 17:32:06 +00:00
return transactions;
}
@override
Future<Map<String, LightningTransactionInfo>> fetchTransactions() async {
final sdk = await BreezSDK();
final payments = await sdk.listPayments(req: ListPaymentsRequest());
final transactions = convertToTxInfo(payments);
2024-02-22 03:03:19 +00:00
2024-02-22 17:32:06 +00:00
return transactions;
2024-02-16 20:37:08 +00:00
}
@override
2024-02-22 03:03:19 +00:00
Future<void> rescan({required int height}) async {
updateTransactions();
}
2024-02-16 20:37:08 +00:00
Future<void> init() async {
await walletAddresses.init();
await transactionHistory.init();
await save();
}
String toJSON() => json.encode({
'mnemonic': mnemonic,
2024-02-23 17:29:11 +00:00
'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(),
'network_type': network == BitcoinNetwork.testnet ? 'testnet' : 'mainnet',
2024-02-16 20:37:08 +00:00
});
@override
Future<void> save() async {
final path = await makePath();
await write(path: path, password: _password, data: toJSON());
await transactionHistory.save();
}
Future<void> updateBalance() async {
// balance[currency] = await _fetchBalances();
await save();
}
@override
String get seed => mnemonic;
Future<String> makePath() async => pathForWallet(name: walletInfo.name, type: walletInfo.type);
// String toJSON() => json.encode({
// 'seedKey': _hexSeed,
// 'mnemonic': _mnemonic,
// 'currentBalance': balance[currency]?.currentBalance.toString() ?? "0",
// 'receivableBalance': balance[currency]?.receivableBalance.toString() ?? "0",
// 'derivationType': _derivationType.toString()
// });
@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);
}
2024-02-08 19:45:21 +00:00
}