mirror of
https://github.com/cypherstack/stack_wallet.git
synced 2024-12-25 12:59:24 +00:00
796 lines
27 KiB
Dart
796 lines
27 KiB
Dart
// /*
|
|
// * 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:async';
|
|
//
|
|
// import 'package:bip39/bip39.dart' as bip39;
|
|
// import 'package:ethereum_addresses/ethereum_addresses.dart';
|
|
// import 'package:http/http.dart';
|
|
// import 'package:isar/isar.dart';
|
|
// import 'package:stackwallet/db/hive/db.dart';
|
|
// import 'package:stackwallet/db/isar/main_db.dart';
|
|
// import 'package:stackwallet/models/balance.dart';
|
|
// import 'package:stackwallet/models/isar/models/isar_models.dart';
|
|
// import 'package:stackwallet/models/node_model.dart';
|
|
// import 'package:stackwallet/models/paymint/fee_object_model.dart';
|
|
// import 'package:stackwallet/services/coins/coin_service.dart';
|
|
// import 'package:stackwallet/services/ethereum/ethereum_api.dart';
|
|
// import 'package:stackwallet/services/event_bus/events/global/node_connection_status_changed_event.dart';
|
|
// import 'package:stackwallet/services/event_bus/events/global/refresh_percent_changed_event.dart';
|
|
// import 'package:stackwallet/services/event_bus/events/global/updated_in_background_event.dart';
|
|
// import 'package:stackwallet/services/event_bus/events/global/wallet_sync_status_changed_event.dart';
|
|
// import 'package:stackwallet/services/event_bus/global_event_bus.dart';
|
|
// import 'package:stackwallet/services/mixins/eth_token_cache.dart';
|
|
// import 'package:stackwallet/services/mixins/wallet_cache.dart';
|
|
// import 'package:stackwallet/services/mixins/wallet_db.dart';
|
|
// import 'package:stackwallet/services/node_service.dart';
|
|
// import 'package:stackwallet/services/transaction_notification_tracker.dart';
|
|
// import 'package:stackwallet/utilities/amount/amount.dart';
|
|
// import 'package:stackwallet/utilities/constants.dart';
|
|
// import 'package:stackwallet/utilities/default_nodes.dart';
|
|
// import 'package:stackwallet/utilities/enums/coin_enum.dart';
|
|
// import 'package:stackwallet/utilities/enums/fee_rate_type_enum.dart';
|
|
// import 'package:stackwallet/utilities/eth_commons.dart';
|
|
// import 'package:stackwallet/utilities/extensions/extensions.dart';
|
|
// import 'package:stackwallet/utilities/flutter_secure_storage_interface.dart';
|
|
// import 'package:stackwallet/utilities/logger.dart';
|
|
// import 'package:stackwallet/utilities/prefs.dart';
|
|
// import 'package:stackwallet/widgets/crypto_notifications.dart';
|
|
// import 'package:tuple/tuple.dart';
|
|
// import 'package:web3dart/web3dart.dart' as web3;
|
|
//
|
|
// const int MINIMUM_CONFIRMATIONS = 3;
|
|
//
|
|
// class EthereumWallet extends CoinServiceAPI with WalletCache, WalletDB {
|
|
// EthereumWallet({
|
|
// required String walletId,
|
|
// required String walletName,
|
|
// required Coin coin,
|
|
// required SecureStorageInterface secureStore,
|
|
// required TransactionNotificationTracker tracker,
|
|
// MainDB? mockableOverride,
|
|
// }) {
|
|
// txTracker = tracker;
|
|
// _walletId = walletId;
|
|
// _walletName = walletName;
|
|
// _coin = coin;
|
|
// _secureStore = secureStore;
|
|
// initCache(walletId, coin);
|
|
// initWalletDB(mockableOverride: mockableOverride);
|
|
// }
|
|
//
|
|
// Balance getCachedTokenBalance(EthContract contract) {
|
|
// final jsonString = DB.instance.get<dynamic>(
|
|
// boxName: _walletId,
|
|
// key: TokenCacheKeys.tokenBalance(contract.address),
|
|
// ) as String?;
|
|
// if (jsonString == null) {
|
|
// return Balance(
|
|
// total: Amount(
|
|
// rawValue: BigInt.zero,
|
|
// fractionDigits: contract.decimals,
|
|
// ),
|
|
// spendable: Amount(
|
|
// rawValue: BigInt.zero,
|
|
// fractionDigits: contract.decimals,
|
|
// ),
|
|
// blockedTotal: Amount(
|
|
// rawValue: BigInt.zero,
|
|
// fractionDigits: contract.decimals,
|
|
// ),
|
|
// pendingSpendable: Amount(
|
|
// rawValue: BigInt.zero,
|
|
// fractionDigits: contract.decimals,
|
|
// ),
|
|
// );
|
|
// }
|
|
// return Balance.fromJson(
|
|
// jsonString,
|
|
// contract.decimals,
|
|
// );
|
|
// }
|
|
//
|
|
// bool longMutex = false;
|
|
//
|
|
// @override
|
|
// Future<List<Transaction>> get transactions => db
|
|
// .getTransactions(walletId)
|
|
// .filter()
|
|
// .otherDataEqualTo(
|
|
// null) // eth txns with other data where other data is the token contract address
|
|
// .sortByTimestampDesc()
|
|
// .findAll();
|
|
//
|
|
// @override
|
|
// Future<String> get currentReceivingAddress async {
|
|
// final address = await _currentReceivingAddress;
|
|
// return checksumEthereumAddress(
|
|
// address?.value ?? _credentials.address.hexEip55);
|
|
// }
|
|
//
|
|
// @override
|
|
// Future<void> initializeExisting() async {
|
|
// Logging.instance.log(
|
|
// "initializeExisting() ${coin.prettyName} wallet",
|
|
// level: LogLevel.Info,
|
|
// );
|
|
//
|
|
// await _initCredentials(
|
|
// (await mnemonicString)!,
|
|
// (await mnemonicPassphrase)!,
|
|
// );
|
|
//
|
|
// if (getCachedId() == null) {
|
|
// throw Exception(
|
|
// "Attempted to initialize an existing wallet using an unknown wallet ID!");
|
|
// }
|
|
// await _prefs.init();
|
|
// }
|
|
//
|
|
// @override
|
|
// Future<void> initializeNew(
|
|
// ({String mnemonicPassphrase, int wordCount})? data,
|
|
// ) async {
|
|
// Logging.instance.log(
|
|
// "Generating new ${coin.prettyName} wallet.",
|
|
// level: LogLevel.Info,
|
|
// );
|
|
//
|
|
// if (getCachedId() != null) {
|
|
// throw Exception(
|
|
// "Attempted to initialize a new wallet using an existing wallet ID!");
|
|
// }
|
|
//
|
|
// await _prefs.init();
|
|
//
|
|
// try {
|
|
// await _generateNewWallet(data);
|
|
// } catch (e, s) {
|
|
// Logging.instance.log(
|
|
// "Exception rethrown from initializeNew(): $e\n$s",
|
|
// level: LogLevel.Fatal,
|
|
// );
|
|
// rethrow;
|
|
// }
|
|
// await Future.wait([
|
|
// updateCachedId(walletId),
|
|
// updateCachedIsFavorite(false),
|
|
// ]);
|
|
// }
|
|
//
|
|
// Future<void> _generateNewWallet(
|
|
// ({String mnemonicPassphrase, int wordCount})? data,
|
|
// ) async {
|
|
// // Logging.instance
|
|
// // .log("IS_INTEGRATION_TEST: $integrationTestFlag", level: LogLevel.Info);
|
|
// // if (!integrationTestFlag) {
|
|
// // try {
|
|
// // final features = await electrumXClient.getServerFeatures();
|
|
// // Logging.instance.log("features: $features", level: LogLevel.Info);
|
|
// // switch (coin) {
|
|
// // case Coin.namecoin:
|
|
// // if (features['genesis_hash'] != GENESIS_HASH_MAINNET) {
|
|
// // throw Exception("genesis hash does not match main net!");
|
|
// // }
|
|
// // break;
|
|
// // default:
|
|
// // throw Exception(
|
|
// // "Attempted to generate a EthereumWallet using a non eth coin type: ${coin.name}");
|
|
// // }
|
|
// // } catch (e, s) {
|
|
// // Logging.instance.log("$e/n$s", level: LogLevel.Info);
|
|
// // }
|
|
// // }
|
|
//
|
|
// // this should never fail - sanity check
|
|
// if ((await mnemonicString) != null || (await mnemonicPassphrase) != null) {
|
|
// throw Exception(
|
|
// "Attempted to overwrite mnemonic on generate new wallet!");
|
|
// }
|
|
//
|
|
// final int strength;
|
|
// if (data == null || data.wordCount == 12) {
|
|
// strength = 128;
|
|
// } else if (data.wordCount == 24) {
|
|
// strength = 256;
|
|
// } else {
|
|
// throw Exception("Invalid word count");
|
|
// }
|
|
// final String mnemonic = bip39.generateMnemonic(strength: strength);
|
|
// final String passphrase = data?.mnemonicPassphrase ?? "";
|
|
// await _secureStore.write(key: '${_walletId}_mnemonic', value: mnemonic);
|
|
// await _secureStore.write(
|
|
// key: '${_walletId}_mnemonicPassphrase',
|
|
// value: passphrase,
|
|
// );
|
|
//
|
|
// await _generateAndSaveAddress(mnemonic, passphrase);
|
|
//
|
|
// Logging.instance.log("_generateNewWalletFinished", level: LogLevel.Info);
|
|
// }
|
|
//
|
|
// bool _isConnected = false;
|
|
//
|
|
// @override
|
|
// bool get isConnected => _isConnected;
|
|
//
|
|
// @override
|
|
// bool get isRefreshing => refreshMutex;
|
|
//
|
|
// bool refreshMutex = false;
|
|
//
|
|
// @override
|
|
// Future<Map<String, dynamic>> prepareSend({
|
|
// required String address,
|
|
// required Amount amount,
|
|
// Map<String, dynamic>? args,
|
|
// }) async {
|
|
// final feeRateType = args?["feeRate"];
|
|
// int fee = 0;
|
|
// final feeObject = await fees;
|
|
// switch (feeRateType) {
|
|
// case FeeRateType.fast:
|
|
// fee = feeObject.fast;
|
|
// break;
|
|
// case FeeRateType.average:
|
|
// fee = feeObject.medium;
|
|
// break;
|
|
// case FeeRateType.slow:
|
|
// fee = feeObject.slow;
|
|
// break;
|
|
// }
|
|
//
|
|
// final feeEstimate = await estimateFeeFor(amount, fee);
|
|
//
|
|
// // bool isSendAll = false;
|
|
// // final availableBalance = balance.spendable;
|
|
// // if (satoshiAmount == availableBalance) {
|
|
// // isSendAll = true;
|
|
// // }
|
|
// //
|
|
// // if (isSendAll) {
|
|
// // //Subtract fee amount from send amount
|
|
// // satoshiAmount -= feeEstimate;
|
|
// // }
|
|
//
|
|
// final client = getEthClient();
|
|
//
|
|
// final myAddress = await currentReceivingAddress;
|
|
// final myWeb3Address = web3.EthereumAddress.fromHex(myAddress);
|
|
//
|
|
// final est = await client.estimateGas(
|
|
// sender: myWeb3Address,
|
|
// to: web3.EthereumAddress.fromHex(address),
|
|
// gasPrice: web3.EtherAmount.fromUnitAndValue(
|
|
// web3.EtherUnit.wei,
|
|
// fee,
|
|
// ),
|
|
// amountOfGas: BigInt.from(_gasLimit),
|
|
// value: web3.EtherAmount.inWei(amount.raw),
|
|
// );
|
|
//
|
|
// final nonce = args?["nonce"] as int? ??
|
|
// await client.getTransactionCount(myWeb3Address,
|
|
// atBlock: const web3.BlockNum.pending());
|
|
//
|
|
// final nResponse = await EthereumAPI.getAddressNonce(address: myAddress);
|
|
// print("==============================================================");
|
|
// print("ETH client.estimateGas: $est");
|
|
// print("ETH estimateFeeFor : $feeEstimate");
|
|
// print("ETH nonce custom response: $nResponse");
|
|
// print("ETH actual nonce : $nonce");
|
|
// print("==============================================================");
|
|
//
|
|
// final tx = web3.Transaction(
|
|
// to: web3.EthereumAddress.fromHex(address),
|
|
// gasPrice: web3.EtherAmount.fromUnitAndValue(
|
|
// web3.EtherUnit.wei,
|
|
// fee,
|
|
// ),
|
|
// maxGas: _gasLimit,
|
|
// value: web3.EtherAmount.inWei(amount.raw),
|
|
// nonce: nonce,
|
|
// );
|
|
//
|
|
// Map<String, dynamic> txData = {
|
|
// "fee": feeEstimate,
|
|
// "feeInWei": fee,
|
|
// "address": address,
|
|
// "recipientAmt": amount,
|
|
// "ethTx": tx,
|
|
// "chainId": (await client.getChainId()).toInt(),
|
|
// "nonce": tx.nonce,
|
|
// };
|
|
//
|
|
// return txData;
|
|
// }
|
|
//
|
|
// @override
|
|
// Future<String> confirmSend({required Map<String, dynamic> txData}) async {
|
|
// web3.Web3Client client = getEthClient();
|
|
//
|
|
// final txid = await client.sendTransaction(
|
|
// _credentials,
|
|
// txData["ethTx"] as web3.Transaction,
|
|
// chainId: txData["chainId"] as int,
|
|
// );
|
|
//
|
|
// return txid;
|
|
// }
|
|
//
|
|
// @override
|
|
// Future<void> recoverFromMnemonic({
|
|
// required String mnemonic,
|
|
// String? mnemonicPassphrase,
|
|
// required int maxUnusedAddressGap,
|
|
// required int maxNumberOfIndexesToCheck,
|
|
// required int height,
|
|
// }) async {
|
|
// longMutex = true;
|
|
// final start = DateTime.now();
|
|
//
|
|
// try {
|
|
// // check to make sure we aren't overwriting a mnemonic
|
|
// // this should never fail
|
|
// if ((await mnemonicString) != null ||
|
|
// (await this.mnemonicPassphrase) != null) {
|
|
// longMutex = false;
|
|
// throw Exception("Attempted to overwrite mnemonic on restore!");
|
|
// }
|
|
//
|
|
// await _secureStore.write(
|
|
// key: '${_walletId}_mnemonic', value: mnemonic.trim());
|
|
// await _secureStore.write(
|
|
// key: '${_walletId}_mnemonicPassphrase',
|
|
// value: mnemonicPassphrase ?? "",
|
|
// );
|
|
//
|
|
// String privateKey =
|
|
// getPrivateKey(mnemonic.trim(), mnemonicPassphrase ?? "");
|
|
// _credentials = web3.EthPrivateKey.fromHex(privateKey);
|
|
//
|
|
// final address = Address(
|
|
// walletId: walletId,
|
|
// value: _credentials.address.hexEip55,
|
|
// publicKey: [], // maybe store address bytes here? seems a waste of space though
|
|
// derivationIndex: 0,
|
|
// derivationPath: DerivationPath()..value = "$hdPathEthereum/0",
|
|
// type: AddressType.ethereum,
|
|
// subType: AddressSubType.receiving,
|
|
// );
|
|
//
|
|
// await db.putAddress(address);
|
|
//
|
|
// await Future.wait([
|
|
// updateCachedId(walletId),
|
|
// updateCachedIsFavorite(false),
|
|
// ]);
|
|
// } catch (e, s) {
|
|
// Logging.instance.log(
|
|
// "Exception rethrown from recoverFromMnemonic(): $e\n$s",
|
|
// level: LogLevel.Error);
|
|
// longMutex = false;
|
|
// rethrow;
|
|
// }
|
|
//
|
|
// longMutex = false;
|
|
// final end = DateTime.now();
|
|
// Logging.instance.log(
|
|
// "$walletName recovery time: ${end.difference(start).inMilliseconds} millis",
|
|
// level: LogLevel.Info);
|
|
// }
|
|
//
|
|
// Future<List<Address>> _fetchAllOwnAddresses() => db
|
|
// .getAddresses(walletId)
|
|
// .filter()
|
|
// .not()
|
|
// .typeEqualTo(AddressType.nonWallet)
|
|
// .and()
|
|
// .group((q) => q
|
|
// .subTypeEqualTo(AddressSubType.receiving)
|
|
// .or()
|
|
// .subTypeEqualTo(AddressSubType.change))
|
|
// .findAll();
|
|
//
|
|
// Future<bool> refreshIfThereIsNewData() async {
|
|
// if (longMutex) return false;
|
|
// if (_hasCalledExit) return false;
|
|
// final currentChainHeight = await chainHeight;
|
|
//
|
|
// try {
|
|
// bool needsRefresh = false;
|
|
// Set<String> txnsToCheck = {};
|
|
//
|
|
// for (final String txid in txTracker.pendings) {
|
|
// if (!txTracker.wasNotifiedConfirmed(txid)) {
|
|
// txnsToCheck.add(txid);
|
|
// }
|
|
// }
|
|
//
|
|
// for (String txid in txnsToCheck) {
|
|
// final response = await EthereumAPI.getEthTransactionByHash(txid);
|
|
// final txBlockNumber = response.value?.blockNumber;
|
|
//
|
|
// if (txBlockNumber != null) {
|
|
// final int txConfirmations = currentChainHeight - txBlockNumber;
|
|
// bool isUnconfirmed = txConfirmations < MINIMUM_CONFIRMATIONS;
|
|
// if (!isUnconfirmed) {
|
|
// needsRefresh = true;
|
|
// break;
|
|
// }
|
|
// }
|
|
// }
|
|
// if (!needsRefresh) {
|
|
// var allOwnAddresses = await _fetchAllOwnAddresses();
|
|
// final response = await EthereumAPI.getEthTransactions(
|
|
// address: allOwnAddresses.elementAt(0).value,
|
|
// );
|
|
// if (response.value != null) {
|
|
// final allTxs = response.value!;
|
|
// for (final element in allTxs) {
|
|
// final txid = element.hash;
|
|
// if ((await db
|
|
// .getTransactions(walletId)
|
|
// .filter()
|
|
// .txidMatches(txid)
|
|
// .findFirst()) ==
|
|
// null) {
|
|
// Logging.instance.log(
|
|
// " txid not found in address history already $txid",
|
|
// level: LogLevel.Info);
|
|
// needsRefresh = true;
|
|
// break;
|
|
// }
|
|
// }
|
|
// } else {
|
|
// Logging.instance.log(
|
|
// " refreshIfThereIsNewData get eth transactions failed: ${response.exception}",
|
|
// level: LogLevel.Error,
|
|
// );
|
|
// }
|
|
// }
|
|
// return needsRefresh;
|
|
// } catch (e, s) {
|
|
// Logging.instance.log(
|
|
// "Exception caught in refreshIfThereIsNewData: $e\n$s",
|
|
// level: LogLevel.Error);
|
|
// rethrow;
|
|
// }
|
|
// }
|
|
//
|
|
// Future<void> getAllTxsToWatch() async {
|
|
// if (_hasCalledExit) return;
|
|
// List<Transaction> unconfirmedTxnsToNotifyPending = [];
|
|
// List<Transaction> unconfirmedTxnsToNotifyConfirmed = [];
|
|
//
|
|
// final currentChainHeight = await chainHeight;
|
|
//
|
|
// final txCount = await db.getTransactions(walletId).count();
|
|
//
|
|
// const paginateLimit = 50;
|
|
//
|
|
// for (int i = 0; i < txCount; i += paginateLimit) {
|
|
// final transactions = await db
|
|
// .getTransactions(walletId)
|
|
// .offset(i)
|
|
// .limit(paginateLimit)
|
|
// .findAll();
|
|
// for (final tx in transactions) {
|
|
// if (tx.isConfirmed(currentChainHeight, MINIMUM_CONFIRMATIONS)) {
|
|
// // get all transactions that were notified as pending but not as confirmed
|
|
// if (txTracker.wasNotifiedPending(tx.txid) &&
|
|
// !txTracker.wasNotifiedConfirmed(tx.txid)) {
|
|
// unconfirmedTxnsToNotifyConfirmed.add(tx);
|
|
// }
|
|
// } else {
|
|
// // get all transactions that were not notified as pending yet
|
|
// if (!txTracker.wasNotifiedPending(tx.txid)) {
|
|
// unconfirmedTxnsToNotifyPending.add(tx);
|
|
// }
|
|
// }
|
|
// }
|
|
// }
|
|
//
|
|
// // notify on unconfirmed transactions
|
|
// for (final tx in unconfirmedTxnsToNotifyPending) {
|
|
// final confirmations = tx.getConfirmations(currentChainHeight);
|
|
//
|
|
// if (tx.type == TransactionType.incoming) {
|
|
// CryptoNotificationsEventBus.instance.fire(
|
|
// CryptoNotificationEvent(
|
|
// title: "Incoming transaction",
|
|
// walletId: walletId,
|
|
// date: DateTime.fromMillisecondsSinceEpoch(tx.timestamp * 1000),
|
|
// shouldWatchForUpdates: confirmations < MINIMUM_CONFIRMATIONS,
|
|
// txid: tx.txid,
|
|
// confirmations: confirmations,
|
|
// requiredConfirmations: MINIMUM_CONFIRMATIONS,
|
|
// walletName: walletName,
|
|
// coin: coin,
|
|
// ),
|
|
// );
|
|
//
|
|
// await txTracker.addNotifiedPending(tx.txid);
|
|
// } else if (tx.type == TransactionType.outgoing) {
|
|
// CryptoNotificationsEventBus.instance.fire(
|
|
// CryptoNotificationEvent(
|
|
// title: "Sending transaction",
|
|
// walletId: walletId,
|
|
// date: DateTime.fromMillisecondsSinceEpoch(tx.timestamp * 1000),
|
|
// shouldWatchForUpdates: confirmations < MINIMUM_CONFIRMATIONS,
|
|
// txid: tx.txid,
|
|
// confirmations: confirmations,
|
|
// requiredConfirmations: MINIMUM_CONFIRMATIONS,
|
|
// walletName: walletName,
|
|
// coin: coin,
|
|
// ),
|
|
// );
|
|
//
|
|
// await txTracker.addNotifiedPending(tx.txid);
|
|
// }
|
|
// }
|
|
//
|
|
// // notify on confirmed
|
|
// for (final tx in unconfirmedTxnsToNotifyConfirmed) {
|
|
// if (tx.type == TransactionType.incoming) {
|
|
// CryptoNotificationsEventBus.instance.fire(
|
|
// CryptoNotificationEvent(
|
|
// title: "Incoming transaction confirmed",
|
|
// walletId: walletId,
|
|
// date: DateTime.fromMillisecondsSinceEpoch(tx.timestamp * 1000),
|
|
// shouldWatchForUpdates: false,
|
|
// txid: tx.txid,
|
|
// requiredConfirmations: MINIMUM_CONFIRMATIONS,
|
|
// walletName: walletName,
|
|
// coin: coin,
|
|
// ),
|
|
// );
|
|
//
|
|
// await txTracker.addNotifiedConfirmed(tx.txid);
|
|
// } else if (tx.type == TransactionType.outgoing) {
|
|
// CryptoNotificationsEventBus.instance.fire(
|
|
// CryptoNotificationEvent(
|
|
// title: "Outgoing transaction confirmed",
|
|
// walletId: walletId,
|
|
// date: DateTime.fromMillisecondsSinceEpoch(tx.timestamp * 1000),
|
|
// shouldWatchForUpdates: false,
|
|
// txid: tx.txid,
|
|
// requiredConfirmations: MINIMUM_CONFIRMATIONS,
|
|
// walletName: walletName,
|
|
// coin: coin,
|
|
// ),
|
|
// );
|
|
//
|
|
// await txTracker.addNotifiedConfirmed(tx.txid);
|
|
// }
|
|
// }
|
|
// }
|
|
//
|
|
// @override
|
|
// Future<void> updateSentCachedTxData(Map<String, dynamic> txData) async {
|
|
// final txid = txData["txid"] as String;
|
|
// final addressString = checksumEthereumAddress(txData["address"] as String);
|
|
// final response = await EthereumAPI.getEthTransactionByHash(txid);
|
|
//
|
|
// final transaction = Transaction(
|
|
// walletId: walletId,
|
|
// txid: txid,
|
|
// timestamp: DateTime.now().millisecondsSinceEpoch ~/ 1000,
|
|
// type: TransactionType.outgoing,
|
|
// subType: TransactionSubType.none,
|
|
// // precision may be lost here hence the following amountString
|
|
// amount: (txData["recipientAmt"] as Amount).raw.toInt(),
|
|
// amountString: (txData["recipientAmt"] as Amount).toJsonString(),
|
|
// fee: (txData["fee"] as Amount).raw.toInt(),
|
|
// height: null,
|
|
// isCancelled: false,
|
|
// isLelantus: false,
|
|
// otherData: null,
|
|
// slateId: null,
|
|
// nonce: (txData["nonce"] as int?) ??
|
|
// response.value?.nonce.toBigIntFromHex.toInt(),
|
|
// inputs: [],
|
|
// outputs: [],
|
|
// numberOfMessages: null,
|
|
// );
|
|
//
|
|
// Address? address = await db.getAddress(
|
|
// walletId,
|
|
// addressString,
|
|
// );
|
|
//
|
|
// address ??= Address(
|
|
// walletId: walletId,
|
|
// value: addressString,
|
|
// publicKey: [],
|
|
// derivationIndex: -1,
|
|
// derivationPath: null,
|
|
// type: AddressType.ethereum,
|
|
// subType: AddressSubType.nonWallet,
|
|
// );
|
|
//
|
|
// await db.addNewTransactionData(
|
|
// [
|
|
// Tuple2(transaction, address),
|
|
// ],
|
|
// walletId,
|
|
// );
|
|
// }
|
|
//
|
|
// // @override
|
|
// // bool validateAddress(String address) {
|
|
// // return isValidEthereumAddress(address);
|
|
// // }
|
|
//
|
|
// Future<void> _refreshTransactions({bool isRescan = false}) async {
|
|
// String thisAddress = await currentReceivingAddress;
|
|
//
|
|
// int firstBlock = 0;
|
|
//
|
|
// if (!isRescan) {
|
|
// firstBlock =
|
|
// await db.getTransactions(walletId).heightProperty().max() ?? 0;
|
|
//
|
|
// if (firstBlock > 10) {
|
|
// // add some buffer
|
|
// firstBlock -= 10;
|
|
// }
|
|
// }
|
|
//
|
|
// final response = await EthereumAPI.getEthTransactions(
|
|
// address: thisAddress,
|
|
// firstBlock: isRescan ? 0 : firstBlock,
|
|
// includeTokens: true,
|
|
// );
|
|
//
|
|
// if (response.value == null) {
|
|
// Logging.instance.log(
|
|
// "Failed to refresh transactions for ${coin.prettyName} $walletName "
|
|
// "$walletId: ${response.exception}",
|
|
// level: LogLevel.Warning,
|
|
// );
|
|
// return;
|
|
// }
|
|
//
|
|
// if (response.value!.isEmpty) {
|
|
// // no new transactions found
|
|
// return;
|
|
// }
|
|
//
|
|
// final txsResponse =
|
|
// await EthereumAPI.getEthTransactionNonces(response.value!);
|
|
//
|
|
// if (txsResponse.value != null) {
|
|
// final allTxs = txsResponse.value!;
|
|
// final List<Tuple2<Transaction, Address?>> txnsData = [];
|
|
// for (final tuple in allTxs) {
|
|
// final element = tuple.item1;
|
|
//
|
|
// Amount transactionAmount = element.value;
|
|
//
|
|
// bool isIncoming;
|
|
// bool txFailed = false;
|
|
// if (checksumEthereumAddress(element.from) == thisAddress) {
|
|
// if (element.isError) {
|
|
// txFailed = true;
|
|
// }
|
|
// isIncoming = false;
|
|
// } else if (checksumEthereumAddress(element.to) == thisAddress) {
|
|
// isIncoming = true;
|
|
// } else {
|
|
// continue;
|
|
// }
|
|
//
|
|
// //Calculate fees (GasLimit * gasPrice)
|
|
// // int txFee = element.gasPrice * element.gasUsed;
|
|
// Amount txFee = element.gasCost;
|
|
//
|
|
// final String addressString = checksumEthereumAddress(element.to);
|
|
// final int height = element.blockNumber;
|
|
//
|
|
// final txn = Transaction(
|
|
// walletId: walletId,
|
|
// txid: element.hash,
|
|
// timestamp: element.timestamp,
|
|
// type:
|
|
// isIncoming ? TransactionType.incoming : TransactionType.outgoing,
|
|
// subType: TransactionSubType.none,
|
|
// amount: transactionAmount.raw.toInt(),
|
|
// amountString: transactionAmount.toJsonString(),
|
|
// fee: txFee.raw.toInt(),
|
|
// height: height,
|
|
// isCancelled: txFailed,
|
|
// isLelantus: false,
|
|
// slateId: null,
|
|
// otherData: null,
|
|
// nonce: tuple.item2,
|
|
// inputs: [],
|
|
// outputs: [],
|
|
// numberOfMessages: null,
|
|
// );
|
|
//
|
|
// Address? transactionAddress = await db
|
|
// .getAddresses(walletId)
|
|
// .filter()
|
|
// .valueEqualTo(addressString)
|
|
// .findFirst();
|
|
//
|
|
// if (transactionAddress == null) {
|
|
// if (isIncoming) {
|
|
// transactionAddress = Address(
|
|
// walletId: walletId,
|
|
// value: addressString,
|
|
// publicKey: [],
|
|
// derivationIndex: 0,
|
|
// derivationPath: DerivationPath()..value = "$hdPathEthereum/0",
|
|
// type: AddressType.ethereum,
|
|
// subType: AddressSubType.receiving,
|
|
// );
|
|
// } else {
|
|
// final myRcvAddr = await currentReceivingAddress;
|
|
// final isSentToSelf = myRcvAddr == addressString;
|
|
//
|
|
// transactionAddress = Address(
|
|
// walletId: walletId,
|
|
// value: addressString,
|
|
// publicKey: [],
|
|
// derivationIndex: isSentToSelf ? 0 : -1,
|
|
// derivationPath: isSentToSelf
|
|
// ? (DerivationPath()..value = "$hdPathEthereum/0")
|
|
// : null,
|
|
// type: AddressType.ethereum,
|
|
// subType: isSentToSelf
|
|
// ? AddressSubType.receiving
|
|
// : AddressSubType.nonWallet,
|
|
// );
|
|
// }
|
|
// }
|
|
//
|
|
// txnsData.add(Tuple2(txn, transactionAddress));
|
|
// }
|
|
// await db.addNewTransactionData(txnsData, walletId);
|
|
//
|
|
// // quick hack to notify manager to call notifyListeners if
|
|
// // transactions changed
|
|
// if (txnsData.isNotEmpty) {
|
|
// GlobalEventBus.instance.fire(
|
|
// UpdatedInBackgroundEvent(
|
|
// "Transactions updated/added for: $walletId $walletName ",
|
|
// walletId,
|
|
// ),
|
|
// );
|
|
// }
|
|
// } else {
|
|
// Logging.instance.log(
|
|
// "Failed to refresh transactions with nonces for ${coin.prettyName} "
|
|
// "$walletName $walletId: ${txsResponse.exception}",
|
|
// level: LogLevel.Warning,
|
|
// );
|
|
// }
|
|
// }
|
|
//
|
|
// void stopNetworkAlivePinging() {
|
|
// _networkAliveTimer?.cancel();
|
|
// _networkAliveTimer = null;
|
|
// }
|
|
//
|
|
// void startNetworkAlivePinging() {
|
|
// // call once on start right away
|
|
// _periodicPingCheck();
|
|
//
|
|
// // then periodically check
|
|
// _networkAliveTimer = Timer.periodic(
|
|
// Constants.networkAliveTimerDuration,
|
|
// (_) async {
|
|
// _periodicPingCheck();
|
|
// },
|
|
// );
|
|
// }
|
|
// }
|