cake_wallet/cw_lightning/lib/lightning_wallet.dart

343 lines
11 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-03-04 17:47:39 +00:00
import 'package:bitbox/bitbox.dart';
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-23 17:29:11 +00:00
import 'package:cw_bitcoin/electrum_wallet_snapshot.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-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_lightning/lightning_balance.dart';
2024-02-22 03:03:19 +00:00
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-03-04 17:47:39 +00:00
import 'package:cw_bitcoin/electrum_wallet.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-03-05 17:21:08 +00:00
abstract class LightningWalletBase extends ElectrumWallet with Store {
2024-03-04 17:47:39 +00:00
bool _isTransactionUpdating;
2024-02-16 20:37:08 +00:00
@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,
List<BitcoinAddressRecord>? initialAddresses,
LightningBalance? initialBalance,
Map<String, int>? initialRegularAddressIndex,
Map<String, int>? initialChangeAddressIndex,
2024-03-04 17:47:39 +00:00
}) : _isTransactionUpdating = false,
2024-02-16 20:37:08 +00:00
syncStatus = NotConnectedSyncStatus(),
2024-03-05 17:21:08 +00:00
_balance = ObservableMap<CryptoCurrency, LightningBalance>(),
2024-03-04 17:47:39 +00:00
super(
mnemonic: mnemonic,
password: password,
walletInfo: walletInfo,
unspentCoinsInfo: unspentCoinsInfo,
networkType: bitcoin.bitcoin,
initialAddresses: initialAddresses,
initialBalance: initialBalance,
seedBytes: seedBytes,
currency: CryptoCurrency.btcln,
) {
2024-03-05 17:21:08 +00:00
_balance[CryptoCurrency.btcln] =
initialBalance ?? LightningBalance(confirmed: 0, unconfirmed: 0, frozen: 0);
2024-02-23 17:29:11 +00:00
walletAddresses = BitcoinWalletAddresses(
walletInfo,
2024-03-04 17:47:39 +00:00
electrumClient: electrumClient,
2024-02-23 17:29:11 +00:00
initialAddresses: initialAddresses,
initialRegularAddressIndex: initialRegularAddressIndex,
initialChangeAddressIndex: initialChangeAddressIndex,
mainHd: hd,
sideHd: bitcoin.HDWallet.fromSeed(seedBytes, network: networkType).derivePath("m/0'/1"),
2024-03-04 17:47:39 +00:00
network: network,
2024-02-23 17:29:11 +00:00
);
2024-02-08 19:45:21 +00:00
2024-03-04 17:47:39 +00:00
// initialize breez:
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-03-05 17:21:08 +00:00
late final ObservableMap<CryptoCurrency, LightningBalance> _balance;
@override
@computed
ObservableMap<CryptoCurrency, LightningBalance> get balance => _balance;
2024-03-04 17:47:39 +00:00
static Future<LightningWallet> create(
{required String mnemonic,
required String password,
required WalletInfo walletInfo,
required Box<UnspentCoinsInfo> unspentCoinsInfo,
String? addressPageType,
List<BitcoinAddressRecord>? initialAddresses,
LightningBalance? initialBalance,
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,
2024-03-04 17:47:39 +00:00
initialBalance: initialBalance,
seedBytes: await Mnemonic.toSeed(mnemonic),
2024-02-23 17:29:11 +00:00
initialRegularAddressIndex: initialRegularAddressIndex,
initialChangeAddressIndex: initialChangeAddressIndex,
2024-03-04 17:47:39 +00:00
addressPageType: addressPageType,
2024-02-23 17:29:11 +00:00
);
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-04-17 16:20:04 +00:00
final snp =
await ElectrumWalletSnapshot.load(name, walletInfo.type, password, BitcoinNetwork.mainnet);
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,
2024-03-04 18:34:46 +00:00
initialBalance: LightningBalance(
confirmed: snp.balance.confirmed,
unconfirmed: snp.balance.unconfirmed,
frozen: snp.balance.frozen,
),
2024-02-23 17:29:11 +00:00
seedBytes: await mnemonicToSeedBytes(snp.mnemonic),
initialRegularAddressIndex: snp.regularAddressIndex,
initialChangeAddressIndex: snp.changeAddressIndex,
addressPageType: snp.addressPageType,
);
2024-02-08 19:45:21 +00:00
}
2024-02-13 18:13:17 +00:00
Future<void> setupBreez(Uint8List seedBytes) async {
2024-03-04 18:34:46 +00:00
final sdk = await BreezSDK();
2024-02-16 20:37:08 +00:00
try {
2024-03-04 18:34:46 +00:00
if (!(await sdk.isInitialized())) {
sdk.initialize();
}
2024-02-16 20:37:08 +00:00
} catch (e) {
print("Error initializing Breez: $e");
}
2024-02-08 19:45:21 +00:00
2024-04-29 16:02:45 +00:00
Uint8List deviceKey = base64.decode(secrets.greenlightKey);
Uint8List deviceCert = base64.decode(secrets.greenlightCert);
2024-04-17 16:20:04 +00:00
GreenlightCredentials greenlightCredentials = GreenlightCredentials(
deviceKey: deviceKey,
deviceCert: deviceCert,
);
2024-02-13 18:13:17 +00:00
NodeConfig breezNodeConfig = NodeConfig.greenlight(
config: GreenlightNodeConfig(
2024-04-17 16:20:04 +00:00
partnerCredentials: greenlightCredentials,
inviteCode: null,
2024-02-13 18:13:17 +00:00
),
);
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 {
await sdk.connect(
req: ConnectRequest(
config: breezConfig,
seed: seedBytes,
),
);
2024-02-16 20:37:08 +00:00
} 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-03-05 17:21:08 +00:00
_balance[CryptoCurrency.btcln] = LightningBalance(
2024-02-16 20:37:08 +00:00
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;
2024-02-27 18:23:34 +00:00
final txs = convertToTxInfo(payments);
2024-02-22 17:32:06 +00:00
transactionHistory.addMany(txs);
_isTransactionUpdating = false;
});
2024-02-22 03:03:19 +00:00
2024-04-18 20:13:06 +00:00
// TODO: get actual nds service url:
if (Platform.isAndroid || Platform.isIOS) {
String platform = Platform.isAndroid ? "android" : "ios";
String token = "TODO";
await sdk.registerWebhook(
webhookUrl: "https://your-nds-service.com/notify?platform=$platform&token=$token",
);
}
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
@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");
}
@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-03-04 18:34:46 +00:00
Map<String, LightningTransactionInfo> convertToTxInfo(List<Payment> payments) {
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-03-04 18:34:46 +00:00
transactions[tx.id] = LightningTransactionInfo(
2024-02-22 03:03:19 +00:00
isPending: false,
id: tx.id,
amount: tx.amountMsat ~/ 1000,
2024-03-01 17:55:44 +00:00
fee: tx.feeMsat ~/ 1000,
2024-02-22 03:03:19 +00:00
date: DateTime.fromMillisecondsSinceEpoch(tx.paymentTime * 1000),
direction: isSend ? TransactionDirection.outgoing : TransactionDirection.incoming,
);
}
2024-02-22 17:32:06 +00:00
return transactions;
}
@override
2024-03-04 18:34:46 +00:00
Future<Map<String, LightningTransactionInfo>> fetchTransactions() async {
2024-02-22 17:32:06 +00:00
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
});
2024-02-27 19:26:15 +00:00
Future<void> updateBalance() async {
// balance is updated automatically
}
2024-02-16 20:37:08 +00:00
@override
String get seed => mnemonic;
Future<String> makePath() async => pathForWallet(name: walletInfo.name, type: walletInfo.type);
2024-02-08 19:45:21 +00:00
}