Ecosystem/stack_wallet
1
0
Fork 0
mirror of https://github.com/cypherstack/stack_wallet.git synced 2024-11-06 12:27:41 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
stack_wallet/lib/services/mixins/paynym_wallet_interface.dart

1433 lines
48 KiB
Dart
Raw Normal View History

untested paynym refactor impl
2023-11-16 16:54:57 +00:00
// /*
// * This file is part of Stack Wallet.
// *
// * Copyright (c) 2023 Cypher Stack
// * All Rights Reserved.
// * The code is distributed under GPLv3 license, see LICENSE file for details.
// * Generated by Cypher Stack on 2023-05-26
// *
// */
//
// import 'dart:convert';
// import 'dart:math';
// import 'dart:typed_data';
//
// import 'package:bip32/bip32.dart' as bip32;
// import 'package:bip47/bip47.dart';
// import 'package:bip47/src/util.dart';
// import 'package:bitcoindart/bitcoindart.dart' as btc_dart;
// import 'package:bitcoindart/src/utils/constants/op.dart' as op;
// import 'package:bitcoindart/src/utils/script.dart' as bscript;
// import 'package:isar/isar.dart';
// import 'package:pointycastle/digests/sha256.dart';
// import 'package:stackwallet/db/isar/main_db.dart';
// import 'package:stackwallet/electrumx_rpc/electrumx_client.dart';
// import 'package:stackwallet/exceptions/wallet/insufficient_balance_exception.dart';
// import 'package:stackwallet/exceptions/wallet/paynym_send_exception.dart';
// import 'package:stackwallet/models/isar/models/isar_models.dart';
// import 'package:stackwallet/models/signing_data.dart';
// import 'package:stackwallet/utilities/amount/amount.dart';
// import 'package:stackwallet/utilities/bip32_utils.dart';
// import 'package:stackwallet/utilities/bip47_utils.dart';
// import 'package:stackwallet/utilities/enums/coin_enum.dart';
// import 'package:stackwallet/utilities/flutter_secure_storage_interface.dart';
// import 'package:stackwallet/utilities/format.dart';
// import 'package:stackwallet/utilities/logger.dart';
// import 'package:stackwallet/wallets/models/tx_data.dart';
// import 'package:tuple/tuple.dart';
//
// const String kPCodeKeyPrefix = "pCode_key_";
//
// String _basePaynymDerivePath({required bool testnet}) =>
// "m/47'/${testnet ? "1" : "0"}'/0'";
// String _notificationDerivationPath({required bool testnet}) =>
// "${_basePaynymDerivePath(testnet: testnet)}/0";
//
// String _receivingPaynymAddressDerivationPath(
// int index, {
// required bool testnet,
// }) =>
// "${_basePaynymDerivePath(testnet: testnet)}/$index/0";
// String _sendPaynymAddressDerivationPath(
// int index, {
// required bool testnet,
// }) =>
// "${_basePaynymDerivePath(testnet: testnet)}/0/$index";
//
// mixin PaynymWalletInterface {
// // passed in wallet data
// late final String _walletId;
// late final String _walletName;
// late final btc_dart.NetworkType _network;
// late final Coin _coin;
// late final MainDB _db;
// late final ElectrumXClient _electrumXClient;
// late final SecureStorageInterface _secureStorage;
// late final int _dustLimit;
// late final int _dustLimitP2PKH;
// late final int _minConfirms;
//
// // passed in wallet functions
// late final Future<String?> Function() _getMnemonicString;
// late final Future<String?> Function() _getMnemonicPassphrase;
// late final Future<int> Function() _getChainHeight;
// late final Future<String> Function() _getCurrentChangeAddress;
// late final int Function({
// required int vSize,
// required int feeRatePerKB,
// }) _estimateTxFee;
// late final Future<Map<String, dynamic>> Function({
// required String address,
// required Amount amount,
// Map<String, dynamic>? args,
// }) _prepareSend;
// late final Future<int> Function({
// required String address,
// }) _getTxCount;
// late final Future<List<SigningData>> Function(
// List<UTXO> utxosToUse,
// ) _fetchBuildTxData;
// late final Future<void> Function() _refresh;
// late final Future<void> Function() _checkChangeAddressForTransactions;
//
// // initializer
// void initPaynymWalletInterface({
// required String walletId,
// required String walletName,
// required btc_dart.NetworkType network,
// required Coin coin,
// required MainDB db,
// required ElectrumXClient electrumXClient,
// required SecureStorageInterface secureStorage,
// required int dustLimit,
// required int dustLimitP2PKH,
// required int minConfirms,
// required Future<String?> Function() getMnemonicString,
// required Future<String?> Function() getMnemonicPassphrase,
// required Future<int> Function() getChainHeight,
// required Future<String> Function() getCurrentChangeAddress,
// required int Function({
// required int vSize,
// required int feeRatePerKB,
// }) estimateTxFee,
// required Future<Map<String, dynamic>> Function({
// required String address,
// required Amount amount,
// Map<String, dynamic>? args,
// }) prepareSend,
// required Future<int> Function({
// required String address,
// }) getTxCount,
// required Future<List<SigningData>> Function(
// List<UTXO> utxosToUse,
// ) fetchBuildTxData,
// required Future<void> Function() refresh,
// required Future<void> Function() checkChangeAddressForTransactions,
// }) {
// _walletId = walletId;
// _walletName = walletName;
// _network = network;
// _coin = coin;
// _db = db;
// _electrumXClient = electrumXClient;
// _secureStorage = secureStorage;
// _dustLimit = dustLimit;
// _dustLimitP2PKH = dustLimitP2PKH;
// _minConfirms = minConfirms;
// _getMnemonicString = getMnemonicString;
// _getMnemonicPassphrase = getMnemonicPassphrase;
// _getChainHeight = getChainHeight;
// _getCurrentChangeAddress = getCurrentChangeAddress;
// _estimateTxFee = estimateTxFee;
// _prepareSend = prepareSend;
// _getTxCount = getTxCount;
// _fetchBuildTxData = fetchBuildTxData;
// _refresh = refresh;
// _checkChangeAddressForTransactions = checkChangeAddressForTransactions;
// }
//
// // convenience getter
// btc_dart.NetworkType get networkType => _network;
//
// Future<bip32.BIP32> getBip47BaseNode() async {
// final root = await _getRootNode();
// final node = root.derivePath(
// _basePaynymDerivePath(
// testnet: _coin.isTestNet,
// ),
// );
// return node;
// }
//
// Future<Uint8List> getPrivateKeyForPaynymReceivingAddress({
// required String paymentCodeString,
// required int index,
// }) async {
// final bip47base = await getBip47BaseNode();
//
// final paymentAddress = PaymentAddress(
// bip32Node: bip47base.derive(index),
// paymentCode: PaymentCode.fromPaymentCode(
// paymentCodeString,
// networkType: networkType,
// ),
// networkType: networkType,
// index: 0,
// );
//
// final pair = paymentAddress.getReceiveAddressKeyPair();
//
// return pair.privateKey!;
// }
//
// Future<Address> currentReceivingPaynymAddress({
// required PaymentCode sender,
// required bool isSegwit,
// }) async {
// final keys = await lookupKey(sender.toString());
//
// final address = await _db
// .getAddresses(_walletId)
// .filter()
// .subTypeEqualTo(AddressSubType.paynymReceive)
// .and()
// .group((q) {
// if (isSegwit) {
// return q
// .typeEqualTo(AddressType.p2sh)
// .or()
// .typeEqualTo(AddressType.p2wpkh);
// } else {
// return q.typeEqualTo(AddressType.p2pkh);
// }
// })
// .and()
// .anyOf<String, Address>(keys, (q, String e) => q.otherDataEqualTo(e))
// .sortByDerivationIndexDesc()
// .findFirst();
//
// if (address == null) {
// final generatedAddress = await _generatePaynymReceivingAddress(
// sender: sender,
// index: 0,
// generateSegwitAddress: isSegwit,
// );
//
// final existing = await _db
// .getAddresses(_walletId)
// .filter()
// .valueEqualTo(generatedAddress.value)
// .findFirst();
//
// if (existing == null) {
// // Add that new address
// await _db.putAddress(generatedAddress);
// } else {
// // we need to update the address
// await _db.updateAddress(existing, generatedAddress);
// }
//
// return currentReceivingPaynymAddress(
// isSegwit: isSegwit,
// sender: sender,
// );
// } else {
// return address;
// }
// }
//
// Future<Address> _generatePaynymReceivingAddress({
// required PaymentCode sender,
// required int index,
// required bool generateSegwitAddress,
// }) async {
// final root = await _getRootNode();
// final node = root.derivePath(
// _basePaynymDerivePath(
// testnet: _coin.isTestNet,
// ),
// );
//
// final paymentAddress = PaymentAddress(
// bip32Node: node.derive(index),
// paymentCode: sender,
// networkType: networkType,
// index: 0,
// );
//
// final addressString = generateSegwitAddress
// ? paymentAddress.getReceiveAddressP2WPKH()
// : paymentAddress.getReceiveAddressP2PKH();
//
// final address = Address(
// walletId: _walletId,
// value: addressString,
// publicKey: [],
// derivationIndex: index,
// derivationPath: DerivationPath()
// ..value = _receivingPaynymAddressDerivationPath(
// index,
// testnet: _coin.isTestNet,
// ),
// type: generateSegwitAddress ? AddressType.p2wpkh : AddressType.p2pkh,
// subType: AddressSubType.paynymReceive,
// otherData: await storeCode(sender.toString()),
// );
//
// return address;
// }
//
// Future<Address> _generatePaynymSendAddress({
// required PaymentCode other,
// required int index,
// required bool generateSegwitAddress,
// bip32.BIP32? mySendBip32Node,
// }) async {
// final node = mySendBip32Node ?? await deriveNotificationBip32Node();
//
// final paymentAddress = PaymentAddress(
// bip32Node: node,
// paymentCode: other,
// networkType: networkType,
// index: index,
// );
//
// final addressString = generateSegwitAddress
// ? paymentAddress.getSendAddressP2WPKH()
// : paymentAddress.getSendAddressP2PKH();
//
// final address = Address(
// walletId: _walletId,
// value: addressString,
// publicKey: [],
// derivationIndex: index,
// derivationPath: DerivationPath()
// ..value = _sendPaynymAddressDerivationPath(
// index,
// testnet: _coin.isTestNet,
// ),
// type: AddressType.nonWallet,
// subType: AddressSubType.paynymSend,
// otherData: await storeCode(other.toString()),
// );
//
// return address;
// }
//
// Future<void> checkCurrentPaynymReceivingAddressForTransactions({
// required PaymentCode sender,
// required bool isSegwit,
// }) async {
// final address = await currentReceivingPaynymAddress(
// sender: sender,
// isSegwit: isSegwit,
// );
//
// final txCount = await _getTxCount(address: address.value);
// if (txCount > 0) {
// // generate next address and add to db
// final nextAddress = await _generatePaynymReceivingAddress(
// sender: sender,
// index: address.derivationIndex + 1,
// generateSegwitAddress: isSegwit,
// );
//
// final existing = await _db
// .getAddresses(_walletId)
// .filter()
// .valueEqualTo(nextAddress.value)
// .findFirst();
//
// if (existing == null) {
// // Add that new address
// await _db.putAddress(nextAddress);
// } else {
// // we need to update the address
// await _db.updateAddress(existing, nextAddress);
// }
// // keep checking until address with no tx history is set as current
// await checkCurrentPaynymReceivingAddressForTransactions(
// sender: sender,
// isSegwit: isSegwit,
// );
// }
// }
//
// Future<void> checkAllCurrentReceivingPaynymAddressesForTransactions() async {
// final codes = await getAllPaymentCodesFromNotificationTransactions();
// final List<Future<void>> futures = [];
// for (final code in codes) {
// futures.add(checkCurrentPaynymReceivingAddressForTransactions(
// sender: code,
// isSegwit: true,
// ));
// futures.add(checkCurrentPaynymReceivingAddressForTransactions(
// sender: code,
// isSegwit: false,
// ));
// }
// await Future.wait(futures);
// }
//
// // generate bip32 payment code root
// Future<bip32.BIP32> _getRootNode() async {
// return _cachedRootNode ??= await Bip32Utils.getBip32Root(
// (await _getMnemonicString())!,
// (await _getMnemonicPassphrase())!,
// _network,
// );
// }
//
// bip32.BIP32? _cachedRootNode;
//
// Future<bip32.BIP32> deriveNotificationBip32Node() async {
// final root = await _getRootNode();
// final node = root
// .derivePath(
// _basePaynymDerivePath(
// testnet: _coin.isTestNet,
// ),
// )
// .derive(0);
// return node;
// }
//
// /// fetch or generate this wallet's bip47 payment code
// Future<PaymentCode> getPaymentCode({
// required bool isSegwit,
// }) async {
// final node = await _getRootNode();
//
// final paymentCode = PaymentCode.fromBip32Node(
// node.derivePath(_basePaynymDerivePath(testnet: _coin.isTestNet)),
// networkType: networkType,
// shouldSetSegwitBit: isSegwit,
// );
//
// return paymentCode;
// }
//
// Future<Uint8List> signWithNotificationKey(Uint8List data) async {
// final myPrivateKeyNode = await deriveNotificationBip32Node();
// final pair = btc_dart.ECPair.fromPrivateKey(myPrivateKeyNode.privateKey!,
// network: _network);
// final signed = pair.sign(SHA256Digest().process(data));
// return signed;
// }
//
// Future<String> signStringWithNotificationKey(String data) async {
// final bytes =
// await signWithNotificationKey(Uint8List.fromList(utf8.encode(data)));
// return Format.uint8listToString(bytes);
// }
//
// Future<Map<String, dynamic>> preparePaymentCodeSend({
// required PaymentCode paymentCode,
// required bool isSegwit,
// required Amount amount,
// Map<String, dynamic>? args,
// }) async {
// if (!(await hasConnected(paymentCode.toString()))) {
// throw PaynymSendException(
// "No notification transaction sent to $paymentCode");
// } else {
// final myPrivateKeyNode = await deriveNotificationBip32Node();
// final sendToAddress = await nextUnusedSendAddressFrom(
// pCode: paymentCode,
// privateKeyNode: myPrivateKeyNode,
// isSegwit: isSegwit,
// );
//
// return _prepareSend(
// address: sendToAddress.value,
// amount: amount,
// args: args,
// );
// }
// }
//
// /// get the next unused address to send to given the receiver's payment code
// /// and your own private key
// Future<Address> nextUnusedSendAddressFrom({
// required PaymentCode pCode,
// required bool isSegwit,
// required bip32.BIP32 privateKeyNode,
// int startIndex = 0,
// }) async {
// // https://en.bitcoin.it/wiki/BIP_0047#Path_levels
// const maxCount = 2147483647;
//
// for (int i = startIndex; i < maxCount; i++) {
// final keys = await lookupKey(pCode.toString());
// final address = await _db
// .getAddresses(_walletId)
// .filter()
// .subTypeEqualTo(AddressSubType.paynymSend)
// .and()
// .anyOf<String, Address>(keys, (q, String e) => q.otherDataEqualTo(e))
// .and()
// .derivationIndexEqualTo(i)
// .findFirst();
//
// if (address != null) {
// final count = await _getTxCount(address: address.value);
// // return address if unused, otherwise continue to next index
// if (count == 0) {
// return address;
// }
// } else {
// final address = await _generatePaynymSendAddress(
// other: pCode,
// index: i,
// generateSegwitAddress: isSegwit,
// mySendBip32Node: privateKeyNode,
// );
//
// final storedAddress = await _db.getAddress(_walletId, address.value);
// if (storedAddress == null) {
// await _db.putAddress(address);
// } else {
// await _db.updateAddress(storedAddress, address);
// }
// final count = await _getTxCount(address: address.value);
// // return address if unused, otherwise continue to next index
// if (count == 0) {
// return address;
// }
// }
// }
//
// throw PaynymSendException("Exhausted unused send addresses!");
// }
//
// Future<TxData> prepareNotificationTx({
// required int selectedTxFeeRate,
// required String targetPaymentCodeString,
// int additionalOutputs = 0,
// List<UTXO>? utxos,
// }) async {
// try {
// final amountToSend = _dustLimitP2PKH;
// final List<UTXO> availableOutputs =
// utxos ?? await _db.getUTXOs(_walletId).findAll();
// final List<UTXO> spendableOutputs = [];
// int spendableSatoshiValue = 0;
//
// // Build list of spendable outputs and totaling their satoshi amount
// for (var i = 0; i < availableOutputs.length; i++) {
// if (availableOutputs[i].isBlocked == false &&
// availableOutputs[i]
// .isConfirmed(await _getChainHeight(), _minConfirms) ==
// true) {
// spendableOutputs.add(availableOutputs[i]);
// spendableSatoshiValue += availableOutputs[i].value;
// }
// }
//
// if (spendableSatoshiValue < amountToSend) {
// // insufficient balance
// throw InsufficientBalanceException(
// "Spendable balance is less than the minimum required for a notification transaction.");
// } else if (spendableSatoshiValue == amountToSend) {
// // insufficient balance due to missing amount to cover fee
// throw InsufficientBalanceException(
// "Remaining balance does not cover the network fee.");
// }
//
// // sort spendable by age (oldest first)
// spendableOutputs.sort((a, b) => b.blockTime!.compareTo(a.blockTime!));
//
// int satoshisBeingUsed = 0;
// int outputsBeingUsed = 0;
// List<UTXO> utxoObjectsToUse = [];
//
// for (int i = 0;
// satoshisBeingUsed < amountToSend && i < spendableOutputs.length;
// i++) {
// utxoObjectsToUse.add(spendableOutputs[i]);
// satoshisBeingUsed += spendableOutputs[i].value;
// outputsBeingUsed += 1;
// }
//
// // add additional outputs if required
// for (int i = 0;
// i < additionalOutputs && outputsBeingUsed < spendableOutputs.length;
// i++) {
// utxoObjectsToUse.add(spendableOutputs[outputsBeingUsed]);
// satoshisBeingUsed += spendableOutputs[outputsBeingUsed].value;
// outputsBeingUsed += 1;
// }
//
// // gather required signing data
// final utxoSigningData = await _fetchBuildTxData(utxoObjectsToUse);
//
// final int vSizeForNoChange = (await _createNotificationTx(
// targetPaymentCodeString: targetPaymentCodeString,
// utxoSigningData: utxoSigningData,
// change: 0,
// // override amount to get around absurd fees error
// overrideAmountForTesting: satoshisBeingUsed,
// ))
// .item2;
//
// final int vSizeForWithChange = (await _createNotificationTx(
// targetPaymentCodeString: targetPaymentCodeString,
// utxoSigningData: utxoSigningData,
// change: satoshisBeingUsed - amountToSend,
// ))
// .item2;
//
// // Assume 2 outputs, for recipient and payment code script
// int feeForNoChange = _estimateTxFee(
// vSize: vSizeForNoChange,
// feeRatePerKB: selectedTxFeeRate,
// );
//
// // Assume 3 outputs, for recipient, payment code script, and change
// int feeForWithChange = _estimateTxFee(
// vSize: vSizeForWithChange,
// feeRatePerKB: selectedTxFeeRate,
// );
//
// if (_coin == Coin.dogecoin || _coin == Coin.dogecoinTestNet) {
// if (feeForNoChange < vSizeForNoChange * 1000) {
// feeForNoChange = vSizeForNoChange * 1000;
// }
// if (feeForWithChange < vSizeForWithChange * 1000) {
// feeForWithChange = vSizeForWithChange * 1000;
// }
// }
//
// if (satoshisBeingUsed - amountToSend > feeForNoChange + _dustLimitP2PKH) {
// // try to add change output due to "left over" amount being greater than
// // the estimated fee + the dust limit
// int changeAmount = satoshisBeingUsed - amountToSend - feeForWithChange;
//
// // check estimates are correct and build notification tx
// if (changeAmount >= _dustLimitP2PKH &&
// satoshisBeingUsed - amountToSend - changeAmount ==
// feeForWithChange) {
// var txn = await _createNotificationTx(
// targetPaymentCodeString: targetPaymentCodeString,
// utxoSigningData: utxoSigningData,
// change: changeAmount,
// );
//
// int feeBeingPaid = satoshisBeingUsed - amountToSend - changeAmount;
//
// // make sure minimum fee is accurate if that is being used
// if (txn.item2 - feeBeingPaid == 1) {
// changeAmount -= 1;
// feeBeingPaid += 1;
// txn = await _createNotificationTx(
// targetPaymentCodeString: targetPaymentCodeString,
// utxoSigningData: utxoSigningData,
// change: changeAmount,
// );
// }
//
// final txData = TxData(
// raw: txn.item1,
// recipients: [
// (
// address: targetPaymentCodeString,
// amount: amountToSend.toAmountAsRaw(
// fractionDigits: _coin.decimals,
// ),
// )
// ],
// fee: feeBeingPaid.toAmountAsRaw(
// fractionDigits: _coin.decimals,
// ),
// vSize: txn.item2,
// utxos: utxoSigningData.map((e) => e.utxo).toSet(),
// note: "PayNym connect");
//
// return txData;
// } else {
// // something broke during fee estimation or the change amount is smaller
// // than the dust limit. Try without change
// final txn = await _createNotificationTx(
// targetPaymentCodeString: targetPaymentCodeString,
// utxoSigningData: utxoSigningData,
// change: 0,
// );
//
// int feeBeingPaid = satoshisBeingUsed - amountToSend;
//
// final txData = TxData(
// raw: txn.item1,
// recipients: [
// (
// address: targetPaymentCodeString,
// amount: amountToSend.toAmountAsRaw(
// fractionDigits: _coin.decimals,
// ),
// )
// ],
// fee: feeBeingPaid.toAmountAsRaw(
// fractionDigits: _coin.decimals,
// ),
// vSize: txn.item2,
// utxos: utxoSigningData.map((e) => e.utxo).toSet(),
// note: "PayNym connect");
//
// return txData;
// }
// } else if (satoshisBeingUsed - amountToSend >= feeForNoChange) {
// // since we already checked if we need to add a change output we can just
// // build without change here
// final txn = await _createNotificationTx(
// targetPaymentCodeString: targetPaymentCodeString,
// utxoSigningData: utxoSigningData,
// change: 0,
// );
//
// int feeBeingPaid = satoshisBeingUsed - amountToSend;
//
// final txData = TxData(
// raw: txn.item1,
// recipients: [
// (
// address: targetPaymentCodeString,
// amount: amountToSend.toAmountAsRaw(
// fractionDigits: _coin.decimals,
// ),
// )
// ],
// fee: feeBeingPaid.toAmountAsRaw(
// fractionDigits: _coin.decimals,
// ),
// vSize: txn.item2,
// utxos: utxoSigningData.map((e) => e.utxo).toSet(),
// note: "PayNym connect");
//
// return txData;
// } else {
// // if we get here we do not have enough funds to cover the tx total so we
// // check if we have any more available outputs and try again
// if (spendableOutputs.length > outputsBeingUsed) {
// return prepareNotificationTx(
// selectedTxFeeRate: selectedTxFeeRate,
// targetPaymentCodeString: targetPaymentCodeString,
// additionalOutputs: additionalOutputs + 1,
// );
// } else {
// throw InsufficientBalanceException(
// "Remaining balance does not cover the network fee.");
// }
// }
// } catch (e) {
// rethrow;
// }
// }
//
// // return tuple with string value equal to the raw tx hex and the int value
// // equal to its vSize
// Future<Tuple2<String, int>> _createNotificationTx({
// required String targetPaymentCodeString,
// required List<SigningData> utxoSigningData,
// required int change,
// int? overrideAmountForTesting,
// }) async {
// try {
// final targetPaymentCode = PaymentCode.fromPaymentCode(
// targetPaymentCodeString,
// networkType: _network,
// );
// final myCode = await getPaymentCode(isSegwit: false);
//
// final utxo = utxoSigningData.first.utxo;
// final txPoint = utxo.txid.fromHex.reversed.toList();
// final txPointIndex = utxo.vout;
//
// final rev = Uint8List(txPoint.length + 4);
// Util.copyBytes(Uint8List.fromList(txPoint), 0, rev, 0, txPoint.length);
// final buffer = rev.buffer.asByteData();
// buffer.setUint32(txPoint.length, txPointIndex, Endian.little);
//
// final myKeyPair = utxoSigningData.first.keyPair!;
//
// final S = SecretPoint(
// myKeyPair.privateKey!,
// targetPaymentCode.notificationPublicKey(),
// );
//
// final blindingMask = PaymentCode.getMask(S.ecdhSecret(), rev);
//
// final blindedPaymentCode = PaymentCode.blind(
// payload: myCode.getPayload(),
// mask: blindingMask,
// unBlind: false,
// );
//
// final opReturnScript = bscript.compile([
// (op.OPS["OP_RETURN"] as int),
// blindedPaymentCode,
// ]);
//
// // build a notification tx
// final txb = btc_dart.TransactionBuilder(network: _network);
// txb.setVersion(1);
//
// txb.addInput(
// utxo.txid,
// txPointIndex,
// null,
// utxoSigningData.first.output!,
// );
//
// // add rest of possible inputs
// for (var i = 1; i < utxoSigningData.length; i++) {
// final utxo = utxoSigningData[i].utxo;
// txb.addInput(
// utxo.txid,
// utxo.vout,
// null,
// utxoSigningData[i].output!,
// );
// }
// final String notificationAddress =
// targetPaymentCode.notificationAddressP2PKH();
//
// txb.addOutput(
// notificationAddress,
// overrideAmountForTesting ?? _dustLimitP2PKH,
// );
// txb.addOutput(opReturnScript, 0);
//
// // TODO: add possible change output and mark output as dangerous
// if (change > 0) {
// // generate new change address if current change address has been used
// await _checkChangeAddressForTransactions();
// final String changeAddress = await _getCurrentChangeAddress();
// txb.addOutput(changeAddress, change);
// }
//
// txb.sign(
// vin: 0,
// keyPair: myKeyPair,
// witnessValue: utxo.value,
// witnessScript: utxoSigningData.first.redeemScript,
// );
//
// // sign rest of possible inputs
// for (var i = 1; i < utxoSigningData.length; i++) {
// txb.sign(
// vin: i,
// keyPair: utxoSigningData[i].keyPair!,
// witnessValue: utxoSigningData[i].utxo.value,
// witnessScript: utxoSigningData[i].redeemScript,
// );
// }
//
// final builtTx = txb.build();
//
// return Tuple2(builtTx.toHex(), builtTx.virtualSize());
// } catch (e, s) {
// Logging.instance.log(
// "_createNotificationTx(): $e\n$s",
// level: LogLevel.Error,
// );
// rethrow;
// }
// }
//
// Future<String> broadcastNotificationTx({
// required Map<String, dynamic> preparedTx,
// }) async {
// try {
// Logging.instance.log("confirmNotificationTx txData: $preparedTx",
// level: LogLevel.Info);
// final txHash = await _electrumXClient.broadcastTransaction(
// rawTx: preparedTx["hex"] as String);
// Logging.instance.log("Sent txHash: $txHash", level: LogLevel.Info);
//
// // TODO: only refresh transaction data
// try {
// await _refresh();
// } catch (e) {
// Logging.instance.log(
// "refresh() failed in confirmNotificationTx ($_walletName::$_walletId): $e",
// level: LogLevel.Error,
// );
// }
//
// return txHash;
// } catch (e, s) {
// Logging.instance.log("Exception rethrown from confirmSend(): $e\n$s",
// level: LogLevel.Error);
// rethrow;
// }
// }
//
// // Future<bool?> _checkHasConnectedCache(String paymentCodeString) async {
// // final value = await _secureStorage.read(
// // key: "$_connectedKeyPrefix$paymentCodeString");
// // if (value == null) {
// // return null;
// // } else {
// // final int rawBool = int.parse(value);
// // return rawBool > 0;
// // }
// // }
// //
// // Future<void> _setConnectedCache(
// // String paymentCodeString, bool hasConnected) async {
// // await _secureStorage.write(
// // key: "$_connectedKeyPrefix$paymentCodeString",
// // value: hasConnected ? "1" : "0");
// // }
//
// // TODO optimize
// Future<bool> hasConnected(String paymentCodeString) async {
// // final didConnect = await _checkHasConnectedCache(paymentCodeString);
// // if (didConnect == true) {
// // return true;
// // }
// //
// // final keys = await lookupKey(paymentCodeString);
// //
// // final tx = await _db
// // .getTransactions(_walletId)
// // .filter()
// // .subTypeEqualTo(TransactionSubType.bip47Notification).and()
// // .address((q) =>
// // q.anyOf<String, Transaction>(keys, (q, e) => q.otherDataEqualTo(e)))
// // .findAll();
//
// final myNotificationAddress = await getMyNotificationAddress();
//
// final txns = await _db
// .getTransactions(_walletId)
// .filter()
// .subTypeEqualTo(TransactionSubType.bip47Notification)
// .findAll();
//
// for (final tx in txns) {
// if (tx.type == TransactionType.incoming &&
// tx.address.value?.value == myNotificationAddress.value) {
// final unBlindedPaymentCode = await unBlindedPaymentCodeFromTransaction(
// transaction: tx,
// );
//
// if (unBlindedPaymentCode != null &&
// paymentCodeString == unBlindedPaymentCode.toString()) {
// // await _setConnectedCache(paymentCodeString, true);
// return true;
// }
//
// final unBlindedPaymentCodeBad =
// await unBlindedPaymentCodeFromTransactionBad(
// transaction: tx,
// );
//
// if (unBlindedPaymentCodeBad != null &&
// paymentCodeString == unBlindedPaymentCodeBad.toString()) {
// // await _setConnectedCache(paymentCodeString, true);
// return true;
// }
// } else if (tx.type == TransactionType.outgoing) {
// if (tx.address.value?.otherData != null) {
// final code =
// await paymentCodeStringByKey(tx.address.value!.otherData!);
// if (code == paymentCodeString) {
// // await _setConnectedCache(paymentCodeString, true);
// return true;
// }
// }
// }
// }
//
// // otherwise return no
// // await _setConnectedCache(paymentCodeString, false);
// return false;
// }
//
// Uint8List? _pubKeyFromInput(Input input) {
// final scriptSigComponents = input.scriptSigAsm?.split(" ") ?? [];
// if (scriptSigComponents.length > 1) {
// return scriptSigComponents[1].fromHex;
// }
// if (input.witness != null) {
// try {
// final witnessComponents = jsonDecode(input.witness!) as List;
// if (witnessComponents.length == 2) {
// return (witnessComponents[1] as String).fromHex;
// }
// } catch (_) {
// //
// }
// }
// return null;
// }
//
// Future<PaymentCode?> unBlindedPaymentCodeFromTransaction({
// required Transaction transaction,
// }) async {
// try {
// final blindedCodeBytes =
// Bip47Utils.getBlindedPaymentCodeBytesFrom(transaction);
//
// // transaction does not contain a payment code
// if (blindedCodeBytes == null) {
// return null;
// }
//
// final designatedInput = transaction.inputs.first;
//
// final txPoint = designatedInput.txid.fromHex.reversed.toList();
// final txPointIndex = designatedInput.vout;
//
// final rev = Uint8List(txPoint.length + 4);
// Util.copyBytes(Uint8List.fromList(txPoint), 0, rev, 0, txPoint.length);
// final buffer = rev.buffer.asByteData();
// buffer.setUint32(txPoint.length, txPointIndex, Endian.little);
//
// final pubKey = _pubKeyFromInput(designatedInput)!;
//
// final myPrivateKey = (await deriveNotificationBip32Node()).privateKey!;
//
// final S = SecretPoint(myPrivateKey, pubKey);
//
// final mask = PaymentCode.getMask(S.ecdhSecret(), rev);
//
// final unBlindedPayload = PaymentCode.blind(
// payload: blindedCodeBytes,
// mask: mask,
// unBlind: true,
// );
//
// final unBlindedPaymentCode = PaymentCode.fromPayload(
// unBlindedPayload,
// networkType: _network,
// );
//
// return unBlindedPaymentCode;
// } catch (e) {
// Logging.instance.log(
// "unBlindedPaymentCodeFromTransaction() failed: $e\nFor tx: $transaction",
// level: LogLevel.Warning,
// );
// return null;
// }
// }
//
// Future<PaymentCode?> unBlindedPaymentCodeFromTransactionBad({
// required Transaction transaction,
// }) async {
// try {
// final blindedCodeBytes =
// Bip47Utils.getBlindedPaymentCodeBytesFrom(transaction);
//
// // transaction does not contain a payment code
// if (blindedCodeBytes == null) {
// return null;
// }
//
// final designatedInput = transaction.inputs.first;
//
// final txPoint = designatedInput.txid.fromHex.toList();
// final txPointIndex = designatedInput.vout;
//
// final rev = Uint8List(txPoint.length + 4);
// Util.copyBytes(Uint8List.fromList(txPoint), 0, rev, 0, txPoint.length);
// final buffer = rev.buffer.asByteData();
// buffer.setUint32(txPoint.length, txPointIndex, Endian.little);
//
// final pubKey = _pubKeyFromInput(designatedInput)!;
//
// final myPrivateKey = (await deriveNotificationBip32Node()).privateKey!;
//
// final S = SecretPoint(myPrivateKey, pubKey);
//
// final mask = PaymentCode.getMask(S.ecdhSecret(), rev);
//
// final unBlindedPayload = PaymentCode.blind(
// payload: blindedCodeBytes,
// mask: mask,
// unBlind: true,
// );
//
// final unBlindedPaymentCode = PaymentCode.fromPayload(
// unBlindedPayload,
// networkType: _network,
// );
//
// return unBlindedPaymentCode;
// } catch (e) {
// Logging.instance.log(
// "unBlindedPaymentCodeFromTransactionBad() failed: $e\nFor tx: $transaction",
// level: LogLevel.Warning,
// );
// return null;
// }
// }
//
// Future<List<PaymentCode>>
// getAllPaymentCodesFromNotificationTransactions() async {
// final txns = await _db
// .getTransactions(_walletId)
// .filter()
// .subTypeEqualTo(TransactionSubType.bip47Notification)
// .findAll();
//
// List<PaymentCode> codes = [];
//
// for (final tx in txns) {
// // tx is sent so we can check the address's otherData for the code String
// if (tx.type == TransactionType.outgoing &&
// tx.address.value?.otherData != null) {
// final codeString =
// await paymentCodeStringByKey(tx.address.value!.otherData!);
// if (codeString != null &&
// codes.where((e) => e.toString() == codeString).isEmpty) {
// codes.add(
// PaymentCode.fromPaymentCode(
// codeString,
// networkType: _network,
// ),
// );
// }
// } else {
// // otherwise we need to un blind the code
// final unBlinded = await unBlindedPaymentCodeFromTransaction(
// transaction: tx,
// );
// if (unBlinded != null &&
// codes.where((e) => e.toString() == unBlinded.toString()).isEmpty) {
// codes.add(unBlinded);
// }
//
// final unBlindedBad = await unBlindedPaymentCodeFromTransactionBad(
// transaction: tx,
// );
// if (unBlindedBad != null &&
// codes
// .where((e) => e.toString() == unBlindedBad.toString())
// .isEmpty) {
// codes.add(unBlindedBad);
// }
// }
// }
//
// return codes;
// }
//
// Future<void> checkForNotificationTransactionsTo(
// Set<String> otherCodeStrings) async {
// final sentNotificationTransactions = await _db
// .getTransactions(_walletId)
// .filter()
// .subTypeEqualTo(TransactionSubType.bip47Notification)
// .and()
// .typeEqualTo(TransactionType.outgoing)
// .findAll();
//
// final List<PaymentCode> codes = [];
// for (final codeString in otherCodeStrings) {
// codes.add(PaymentCode.fromPaymentCode(codeString, networkType: _network));
// }
//
// for (final tx in sentNotificationTransactions) {
// if (tx.address.value != null && tx.address.value!.otherData == null) {
// final oldAddress =
// await _db.getAddress(_walletId, tx.address.value!.value);
// for (final code in codes) {
// final notificationAddress = code.notificationAddressP2PKH();
// if (notificationAddress == oldAddress!.value) {
// final address = Address(
// walletId: _walletId,
// value: notificationAddress,
// publicKey: [],
// derivationIndex: 0,
// derivationPath: oldAddress.derivationPath,
// type: oldAddress.type,
// subType: AddressSubType.paynymNotification,
// otherData: await storeCode(code.toString()),
// );
// await _db.updateAddress(oldAddress, address);
// }
// }
// }
// }
// }
//
// Future<void> restoreAllHistory({
// required int maxUnusedAddressGap,
// required int maxNumberOfIndexesToCheck,
// required Set<String> paymentCodeStrings,
// }) async {
// final codes = await getAllPaymentCodesFromNotificationTransactions();
// final List<PaymentCode> extraCodes = [];
// for (final codeString in paymentCodeStrings) {
// if (codes.where((e) => e.toString() == codeString).isEmpty) {
// final extraCode = PaymentCode.fromPaymentCode(
// codeString,
// networkType: _network,
// );
// if (extraCode.isValid()) {
// extraCodes.add(extraCode);
// }
// }
// }
//
// codes.addAll(extraCodes);
//
// final List<Future<void>> futures = [];
// for (final code in codes) {
// futures.add(
// restoreHistoryWith(
// other: code,
// maxUnusedAddressGap: maxUnusedAddressGap,
// maxNumberOfIndexesToCheck: maxNumberOfIndexesToCheck,
// checkSegwitAsWell: code.isSegWitEnabled(),
// ),
// );
// }
//
// await Future.wait(futures);
// }
//
// Future<void> restoreHistoryWith({
// required PaymentCode other,
// required bool checkSegwitAsWell,
// required int maxUnusedAddressGap,
// required int maxNumberOfIndexesToCheck,
// }) async {
// // https://en.bitcoin.it/wiki/BIP_0047#Path_levels
// const maxCount = 2147483647;
// assert(maxNumberOfIndexesToCheck < maxCount);
//
// final mySendBip32Node = await deriveNotificationBip32Node();
//
// List<Address> addresses = [];
// int receivingGapCounter = 0;
// int outgoingGapCounter = 0;
//
// // non segwit receiving
// for (int i = 0;
// i < maxNumberOfIndexesToCheck &&
// receivingGapCounter < maxUnusedAddressGap;
// i++) {
// if (receivingGapCounter < maxUnusedAddressGap) {
// final address = await _generatePaynymReceivingAddress(
// sender: other,
// index: i,
// generateSegwitAddress: false,
// );
//
// addresses.add(address);
//
// final count = await _getTxCount(address: address.value);
//
// if (count > 0) {
// receivingGapCounter = 0;
// } else {
// receivingGapCounter++;
// }
// }
// }
//
// // non segwit sends
// for (int i = 0;
// i < maxNumberOfIndexesToCheck &&
// outgoingGapCounter < maxUnusedAddressGap;
// i++) {
// if (outgoingGapCounter < maxUnusedAddressGap) {
// final address = await _generatePaynymSendAddress(
// other: other,
// index: i,
// generateSegwitAddress: false,
// mySendBip32Node: mySendBip32Node,
// );
//
// addresses.add(address);
//
// final count = await _getTxCount(address: address.value);
//
// if (count > 0) {
// outgoingGapCounter = 0;
// } else {
// outgoingGapCounter++;
// }
// }
// }
//
// if (checkSegwitAsWell) {
// int receivingGapCounterSegwit = 0;
// int outgoingGapCounterSegwit = 0;
// // segwit receiving
// for (int i = 0;
// i < maxNumberOfIndexesToCheck &&
// receivingGapCounterSegwit < maxUnusedAddressGap;
// i++) {
// if (receivingGapCounterSegwit < maxUnusedAddressGap) {
// final address = await _generatePaynymReceivingAddress(
// sender: other,
// index: i,
// generateSegwitAddress: true,
// );
//
// addresses.add(address);
//
// final count = await _getTxCount(address: address.value);
//
// if (count > 0) {
// receivingGapCounterSegwit = 0;
// } else {
// receivingGapCounterSegwit++;
// }
// }
// }
//
// // segwit sends
// for (int i = 0;
// i < maxNumberOfIndexesToCheck &&
// outgoingGapCounterSegwit < maxUnusedAddressGap;
// i++) {
// if (outgoingGapCounterSegwit < maxUnusedAddressGap) {
// final address = await _generatePaynymSendAddress(
// other: other,
// index: i,
// generateSegwitAddress: true,
// mySendBip32Node: mySendBip32Node,
// );
//
// addresses.add(address);
//
// final count = await _getTxCount(address: address.value);
//
// if (count > 0) {
// outgoingGapCounterSegwit = 0;
// } else {
// outgoingGapCounterSegwit++;
// }
// }
// }
// }
// await _db.updateOrPutAddresses(addresses);
// }
//
// Future<Address> getMyNotificationAddress() async {
// final storedAddress = await _db
// .getAddresses(_walletId)
// .filter()
// .subTypeEqualTo(AddressSubType.paynymNotification)
// .and()
// .typeEqualTo(AddressType.p2pkh)
// .and()
// .not()
// .typeEqualTo(AddressType.nonWallet)
// .findFirst();
//
// if (storedAddress != null) {
// return storedAddress;
// } else {
// final root = await _getRootNode();
// final node = root.derivePath(
// _basePaynymDerivePath(
// testnet: _coin.isTestNet,
// ),
// );
// final paymentCode = PaymentCode.fromBip32Node(
// node,
// networkType: _network,
// shouldSetSegwitBit: false,
// );
//
// final data = btc_dart.PaymentData(
// pubkey: paymentCode.notificationPublicKey(),
// );
//
// final addressString = btc_dart
// .P2PKH(
// data: data,
// network: _network,
// )
// .data
// .address!;
//
// Address address = Address(
// walletId: _walletId,
// value: addressString,
// publicKey: paymentCode.getPubKey(),
// derivationIndex: 0,
// derivationPath: DerivationPath()
// ..value = _notificationDerivationPath(
// testnet: _coin.isTestNet,
// ),
// type: AddressType.p2pkh,
// subType: AddressSubType.paynymNotification,
// otherData: await storeCode(paymentCode.toString()),
// );
//
// // check against possible race condition. Ff this function was called
// // multiple times an address could've been saved after the check at the
// // beginning to see if there already was notification address. This would
// // lead to a Unique Index violation error
// await _db.isar.writeTxn(() async {
// final storedAddress = await _db
// .getAddresses(_walletId)
// .filter()
// .subTypeEqualTo(AddressSubType.paynymNotification)
// .and()
// .typeEqualTo(AddressType.p2pkh)
// .and()
// .not()
// .typeEqualTo(AddressType.nonWallet)
// .findFirst();
//
// if (storedAddress == null) {
// await _db.isar.addresses.put(address);
// } else {
// address = storedAddress;
// }
// });
//
// return address;
// }
// }
//
// /// look up a key that corresponds to a payment code string
// Future<List<String>> lookupKey(String paymentCodeString) async {
// final keys =
// (await _secureStorage.keys).where((e) => e.startsWith(kPCodeKeyPrefix));
// final List<String> result = [];
// for (final key in keys) {
// final value = await _secureStorage.read(key: key);
// if (value == paymentCodeString) {
// result.add(key);
// }
// }
// return result;
// }
//
// /// fetch a payment code string
// Future<String?> paymentCodeStringByKey(String key) async {
// final value = await _secureStorage.read(key: key);
// return value;
// }
//
// /// store payment code string and return the generated key used
// Future<String> storeCode(String paymentCodeString) async {
// final key = _generateKey();
// await _secureStorage.write(key: key, value: paymentCodeString);
// return key;
// }
//
// /// generate a new payment code string storage key
// String _generateKey() {
// final bytes = _randomBytes(24);
// return "$kPCodeKeyPrefix${bytes.toHex}";
// }
//
// // https://github.com/AaronFeickert/stack_wallet_backup/blob/master/lib/secure_storage.dart#L307-L311
// /// Generate cryptographically-secure random bytes
// Uint8List _randomBytes(int n) {
// final Random rng = Random.secure();
// return Uint8List.fromList(
// List<int>.generate(n, (_) => rng.nextInt(0xFF + 1)));
// }
// }
Reference in a new issue Copy permalink