mirror of
https://github.com/cypherstack/stack_wallet.git
synced 2024-12-23 11:59:30 +00:00
593 lines
19 KiB
Dart
593 lines
19 KiB
Dart
import 'dart:async';
|
|
|
|
import 'package:decimal/decimal.dart';
|
|
import 'package:ethereum_addresses/ethereum_addresses.dart';
|
|
import 'package:flutter/widgets.dart';
|
|
import 'package:http/http.dart';
|
|
import 'package:isar/isar.dart';
|
|
import 'package:stackwallet/db/isar/main_db.dart';
|
|
import 'package:stackwallet/dto/ethereum/eth_token_tx_dto.dart';
|
|
import 'package:stackwallet/dto/ethereum/eth_token_tx_extra_dto.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/models/token_balance.dart';
|
|
import 'package:stackwallet/services/coins/ethereum/ethereum_wallet.dart';
|
|
import 'package:stackwallet/services/ethereum/ethereum_api.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/node_service.dart';
|
|
import 'package:stackwallet/services/transaction_notification_tracker.dart';
|
|
import 'package:stackwallet/utilities/amount/amount.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/extensions/impl/contract_abi.dart';
|
|
import 'package:stackwallet/utilities/flutter_secure_storage_interface.dart';
|
|
import 'package:stackwallet/utilities/logger.dart';
|
|
import 'package:tuple/tuple.dart';
|
|
import 'package:web3dart/web3dart.dart' as web3dart;
|
|
|
|
class EthTokenWallet extends ChangeNotifier with EthTokenCache {
|
|
final EthereumWallet ethWallet;
|
|
final TransactionNotificationTracker tracker;
|
|
final SecureStorageInterface _secureStore;
|
|
|
|
// late web3dart.EthereumAddress _contractAddress;
|
|
late web3dart.EthPrivateKey _credentials;
|
|
late web3dart.DeployedContract _deployedContract;
|
|
late web3dart.ContractFunction _balanceFunction;
|
|
late web3dart.ContractFunction _sendFunction;
|
|
late web3dart.Web3Client _client;
|
|
|
|
static const _gasLimit = 200000;
|
|
|
|
EthTokenWallet({
|
|
required EthContract token,
|
|
required this.ethWallet,
|
|
required SecureStorageInterface secureStore,
|
|
required this.tracker,
|
|
}) : _secureStore = secureStore,
|
|
_tokenContract = token {
|
|
// _contractAddress = web3dart.EthereumAddress.fromHex(token.address);
|
|
initCache(ethWallet.walletId, token);
|
|
}
|
|
|
|
EthContract get tokenContract => _tokenContract;
|
|
EthContract _tokenContract;
|
|
|
|
TokenBalance get balance => _balance ??= getCachedBalance();
|
|
TokenBalance? _balance;
|
|
|
|
Coin get coin => Coin.ethereum;
|
|
|
|
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 = estimateFeeFor(fee);
|
|
|
|
final client = await getEthClient();
|
|
|
|
final myAddress = await currentReceivingAddress;
|
|
final myWeb3Address = web3dart.EthereumAddress.fromHex(myAddress);
|
|
|
|
final est = await client.estimateGas(
|
|
sender: myWeb3Address,
|
|
to: web3dart.EthereumAddress.fromHex(address),
|
|
data: _sendFunction
|
|
.encodeCall([web3dart.EthereumAddress.fromHex(address), amount.raw]),
|
|
gasPrice: web3dart.EtherAmount.fromUnitAndValue(
|
|
web3dart.EtherUnit.wei,
|
|
fee,
|
|
),
|
|
amountOfGas: BigInt.from(_gasLimit),
|
|
);
|
|
|
|
final nonce = args?["nonce"] as int? ??
|
|
await client.getTransactionCount(myWeb3Address,
|
|
atBlock: const web3dart.BlockNum.pending());
|
|
|
|
final nResponse = await EthereumAPI.getAddressNonce(address: myAddress);
|
|
print("==============================================================");
|
|
print("TOKEN client.estimateGas: $est");
|
|
print("TOKEN estimateFeeFor : $feeEstimate");
|
|
print("TOKEN nonce custom response: $nResponse");
|
|
print("TOKEN actual nonce : $nonce");
|
|
print("==============================================================");
|
|
|
|
final tx = web3dart.Transaction.callContract(
|
|
contract: _deployedContract,
|
|
function: _sendFunction,
|
|
parameters: [web3dart.EthereumAddress.fromHex(address), amount.raw],
|
|
maxGas: _gasLimit,
|
|
gasPrice: web3dart.EtherAmount.fromUnitAndValue(
|
|
web3dart.EtherUnit.wei,
|
|
fee,
|
|
),
|
|
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;
|
|
}
|
|
|
|
Future<String> confirmSend({required Map<String, dynamic> txData}) async {
|
|
try {
|
|
final txid = await _client.sendTransaction(
|
|
_credentials,
|
|
txData["ethTx"] as web3dart.Transaction,
|
|
chainId: txData["chainId"] as int,
|
|
);
|
|
|
|
try {
|
|
txData["txid"] = txid;
|
|
await updateSentCachedTxData(txData);
|
|
} catch (e, s) {
|
|
// do not rethrow as that would get handled as a send failure further up
|
|
// also this is not critical code and transaction should show up on \
|
|
// refresh regardless
|
|
Logging.instance.log("$e\n$s", level: LogLevel.Warning);
|
|
}
|
|
|
|
notifyListeners();
|
|
return txid;
|
|
} catch (e) {
|
|
// rethrow to pass error in alert
|
|
rethrow;
|
|
}
|
|
}
|
|
|
|
Future<void> updateSentCachedTxData(Map<String, dynamic> txData) async {
|
|
final txid = txData["txid"] as String;
|
|
final addressString = txData["address"] as String;
|
|
final response = await EthereumAPI.getEthTransactionByHash(txid);
|
|
|
|
final transaction = Transaction(
|
|
walletId: ethWallet.walletId,
|
|
txid: txid,
|
|
timestamp: DateTime.now().millisecondsSinceEpoch ~/ 1000,
|
|
type: TransactionType.outgoing,
|
|
subType: TransactionSubType.ethToken,
|
|
// 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 int,
|
|
height: null,
|
|
isCancelled: false,
|
|
isLelantus: false,
|
|
otherData: tokenContract.address,
|
|
slateId: null,
|
|
nonce: (txData["nonce"] as int?) ??
|
|
response.value?.nonce.toBigIntFromHex.toInt(),
|
|
inputs: [],
|
|
outputs: [],
|
|
);
|
|
|
|
Address? address = await ethWallet.db.getAddress(
|
|
ethWallet.walletId,
|
|
addressString,
|
|
);
|
|
|
|
address ??= Address(
|
|
walletId: ethWallet.walletId,
|
|
value: addressString,
|
|
publicKey: [],
|
|
derivationIndex: -1,
|
|
derivationPath: null,
|
|
type: AddressType.ethereum,
|
|
subType: AddressSubType.nonWallet,
|
|
);
|
|
|
|
await ethWallet.db.addNewTransactionData(
|
|
[
|
|
Tuple2(transaction, address),
|
|
],
|
|
ethWallet.walletId,
|
|
);
|
|
}
|
|
|
|
Future<String> get currentReceivingAddress async {
|
|
final address = await _currentReceivingAddress;
|
|
return checksumEthereumAddress(
|
|
address?.value ?? _credentials.address.toString());
|
|
}
|
|
|
|
Future<Address?> get _currentReceivingAddress => ethWallet.db
|
|
.getAddresses(ethWallet.walletId)
|
|
.filter()
|
|
.typeEqualTo(AddressType.ethereum)
|
|
.subTypeEqualTo(AddressSubType.receiving)
|
|
.sortByDerivationIndexDesc()
|
|
.findFirst();
|
|
|
|
Amount estimateFeeFor(int feeRate) {
|
|
return estimateFee(feeRate, _gasLimit, coin.decimals);
|
|
}
|
|
|
|
Future<FeeObject> get fees => EthereumAPI.getFees();
|
|
|
|
Future<EthContract> _updateTokenABI({
|
|
required EthContract forContract,
|
|
required String usingContractAddress,
|
|
}) async {
|
|
final abiResponse = await EthereumAPI.getTokenAbi(
|
|
name: forContract.name,
|
|
contractAddress: usingContractAddress,
|
|
);
|
|
// Fetch token ABI so we can call token functions
|
|
if (abiResponse.value != null) {
|
|
final updatedToken = forContract.copyWith(abi: abiResponse.value!);
|
|
// Store updated contract
|
|
final id = await MainDB.instance.putEthContract(updatedToken);
|
|
return updatedToken..id = id;
|
|
} else {
|
|
throw abiResponse.exception!;
|
|
}
|
|
}
|
|
|
|
Future<void> initialize() async {
|
|
final contractAddress =
|
|
web3dart.EthereumAddress.fromHex(tokenContract.address);
|
|
|
|
// if (tokenContract.abi == null) {
|
|
_tokenContract = await _updateTokenABI(
|
|
forContract: tokenContract,
|
|
usingContractAddress: contractAddress.hex,
|
|
);
|
|
// }
|
|
|
|
String? mnemonicString = await ethWallet.mnemonicString;
|
|
|
|
//Get private key for given mnemonic
|
|
String privateKey = getPrivateKey(
|
|
mnemonicString!,
|
|
(await ethWallet.mnemonicPassphrase) ?? "",
|
|
);
|
|
_credentials = web3dart.EthPrivateKey.fromHex(privateKey);
|
|
|
|
_deployedContract = web3dart.DeployedContract(
|
|
ContractAbiExtensions.fromJsonList(
|
|
jsonList: tokenContract.abi!,
|
|
name: tokenContract.name,
|
|
),
|
|
contractAddress,
|
|
);
|
|
|
|
try {
|
|
_balanceFunction = _deployedContract.function('balanceOf');
|
|
_sendFunction = _deployedContract.function('transfer');
|
|
} catch (_) {
|
|
//====================================================================
|
|
// final list = List<Map<String, dynamic>>.from(
|
|
// jsonDecode(tokenContract.abi!) as List);
|
|
// final functionNames = list.map((e) => e["name"] as String);
|
|
//
|
|
// if (!functionNames.contains("balanceOf")) {
|
|
// list.add(
|
|
// {
|
|
// "encoding": "0x70a08231",
|
|
// "inputs": [
|
|
// {"name": "account", "type": "address"}
|
|
// ],
|
|
// "name": "balanceOf",
|
|
// "outputs": [
|
|
// {"name": "val_0", "type": "uint256"}
|
|
// ],
|
|
// "signature": "balanceOf(address)",
|
|
// "type": "function"
|
|
// },
|
|
// );
|
|
// }
|
|
//
|
|
// if (!functionNames.contains("transfer")) {
|
|
// list.add(
|
|
// {
|
|
// "encoding": "0xa9059cbb",
|
|
// "inputs": [
|
|
// {"name": "dst", "type": "address"},
|
|
// {"name": "rawAmount", "type": "uint256"}
|
|
// ],
|
|
// "name": "transfer",
|
|
// "outputs": [
|
|
// {"name": "val_0", "type": "bool"}
|
|
// ],
|
|
// "signature": "transfer(address,uint256)",
|
|
// "type": "function"
|
|
// },
|
|
// );
|
|
// }
|
|
//--------------------------------------------------------------------
|
|
//====================================================================
|
|
|
|
// function not found so likely a proxy so we need to fetch the impl
|
|
//====================================================================
|
|
// final updatedToken = tokenContract.copyWith(abi: jsonEncode(list));
|
|
// // Store updated contract
|
|
// final id = await MainDB.instance.putEthContract(updatedToken);
|
|
// _tokenContract = updatedToken..id = id;
|
|
//--------------------------------------------------------------------
|
|
final contractAddressResponse =
|
|
await EthereumAPI.getProxyTokenImplementationAddress(
|
|
contractAddress.hex);
|
|
|
|
if (contractAddressResponse.value != null) {
|
|
_tokenContract = await _updateTokenABI(
|
|
forContract: tokenContract,
|
|
usingContractAddress: contractAddressResponse.value!,
|
|
);
|
|
} else {
|
|
throw contractAddressResponse.exception!;
|
|
}
|
|
//====================================================================
|
|
}
|
|
|
|
_deployedContract = web3dart.DeployedContract(
|
|
ContractAbiExtensions.fromJsonList(
|
|
jsonList: tokenContract.abi!,
|
|
name: tokenContract.name,
|
|
),
|
|
contractAddress,
|
|
);
|
|
|
|
_balanceFunction = _deployedContract.function('balanceOf');
|
|
_sendFunction = _deployedContract.function('transfer');
|
|
|
|
_client = await getEthClient();
|
|
|
|
unawaited(refresh());
|
|
}
|
|
|
|
bool get isRefreshing => _refreshLock;
|
|
|
|
bool _refreshLock = false;
|
|
|
|
Future<void> refresh() async {
|
|
if (!_refreshLock) {
|
|
_refreshLock = true;
|
|
try {
|
|
GlobalEventBus.instance.fire(
|
|
WalletSyncStatusChangedEvent(
|
|
WalletSyncStatus.syncing,
|
|
ethWallet.walletId + tokenContract.address,
|
|
coin,
|
|
),
|
|
);
|
|
|
|
await refreshCachedBalance();
|
|
await _refreshTransactions();
|
|
} catch (e, s) {
|
|
Logging.instance.log(
|
|
"Caught exception in ${tokenContract.name} ${ethWallet.walletName} ${ethWallet.walletId} refresh(): $e\n$s",
|
|
level: LogLevel.Warning,
|
|
);
|
|
} finally {
|
|
_refreshLock = false;
|
|
GlobalEventBus.instance.fire(
|
|
WalletSyncStatusChangedEvent(
|
|
WalletSyncStatus.synced,
|
|
ethWallet.walletId + tokenContract.address,
|
|
coin,
|
|
),
|
|
);
|
|
notifyListeners();
|
|
}
|
|
}
|
|
}
|
|
|
|
Future<void> refreshCachedBalance() async {
|
|
final balanceRequest = await _client.call(
|
|
contract: _deployedContract,
|
|
function: _balanceFunction,
|
|
params: [_credentials.address],
|
|
);
|
|
|
|
String _balance = balanceRequest.first.toString();
|
|
|
|
final newBalance = TokenBalance(
|
|
contractAddress: tokenContract.address,
|
|
total: Amount.fromDecimal(
|
|
Decimal.parse(_balance),
|
|
fractionDigits: tokenContract.decimals,
|
|
),
|
|
spendable: Amount.fromDecimal(
|
|
Decimal.parse(_balance),
|
|
fractionDigits: tokenContract.decimals,
|
|
),
|
|
blockedTotal: Amount(
|
|
rawValue: BigInt.zero,
|
|
fractionDigits: tokenContract.decimals,
|
|
),
|
|
pendingSpendable: Amount(
|
|
rawValue: BigInt.zero,
|
|
fractionDigits: tokenContract.decimals,
|
|
),
|
|
);
|
|
await updateCachedBalance(newBalance);
|
|
notifyListeners();
|
|
}
|
|
|
|
Future<List<Transaction>> get transactions => ethWallet.db
|
|
.getTransactions(ethWallet.walletId)
|
|
.filter()
|
|
.otherDataEqualTo(tokenContract.address)
|
|
.sortByTimestampDesc()
|
|
.findAll();
|
|
|
|
String _addressFromTopic(String topic) =>
|
|
checksumEthereumAddress("0x${topic.substring(topic.length - 40)}");
|
|
|
|
Future<void> _refreshTransactions() async {
|
|
String addressString =
|
|
checksumEthereumAddress(await currentReceivingAddress);
|
|
|
|
final response = await EthereumAPI.getTokenTransactions(
|
|
address: addressString,
|
|
tokenContractAddress: tokenContract.address,
|
|
);
|
|
|
|
if (response.value == null) {
|
|
throw response.exception ??
|
|
Exception("Failed to fetch token transaction data");
|
|
}
|
|
|
|
// no need to continue if no transactions found
|
|
if (response.value!.isEmpty) {
|
|
return;
|
|
}
|
|
|
|
final response2 = await EthereumAPI.getEthTokenTransactionsByTxids(
|
|
response.value!.map((e) => e.transactionHash).toList(),
|
|
);
|
|
|
|
if (response2.value == null) {
|
|
throw response2.exception ??
|
|
Exception("Failed to fetch token transactions");
|
|
}
|
|
final List<Tuple2<EthTokenTxDto, EthTokenTxExtraDTO>> data = [];
|
|
for (final tokenDto in response.value!) {
|
|
data.add(
|
|
Tuple2(
|
|
tokenDto,
|
|
response2.value!.firstWhere(
|
|
(e) => e.hash == tokenDto.transactionHash,
|
|
),
|
|
),
|
|
);
|
|
}
|
|
|
|
final List<Tuple2<Transaction, Address?>> txnsData = [];
|
|
|
|
for (final tuple in data) {
|
|
// ignore all non Transfer events (for now)
|
|
if (tuple.item1.topics[0] == kTransferEventSignature) {
|
|
final Amount amount;
|
|
String fromAddress, toAddress;
|
|
amount = Amount(
|
|
rawValue: tuple.item1.data.toBigIntFromHex,
|
|
fractionDigits: tokenContract.decimals,
|
|
);
|
|
|
|
fromAddress = _addressFromTopic(
|
|
tuple.item1.topics[1],
|
|
);
|
|
toAddress = _addressFromTopic(
|
|
tuple.item1.topics[2],
|
|
);
|
|
|
|
bool isIncoming;
|
|
bool isSentToSelf = false;
|
|
if (fromAddress == addressString) {
|
|
isIncoming = false;
|
|
if (toAddress == addressString) {
|
|
isSentToSelf = true;
|
|
}
|
|
} else if (toAddress == addressString) {
|
|
isIncoming = true;
|
|
} else {
|
|
throw Exception("Unknown token transaction found for "
|
|
"${ethWallet.walletName} ${ethWallet.walletId}: "
|
|
"${tuple.item1.toString()}");
|
|
}
|
|
|
|
final txn = Transaction(
|
|
walletId: ethWallet.walletId,
|
|
txid: tuple.item1.transactionHash,
|
|
timestamp: tuple.item2.timestamp,
|
|
type:
|
|
isIncoming ? TransactionType.incoming : TransactionType.outgoing,
|
|
subType: TransactionSubType.ethToken,
|
|
amount: amount.raw.toInt(),
|
|
amountString: amount.toJsonString(),
|
|
fee: (tuple.item2.gasUsed.raw * tuple.item2.gasPrice.raw).toInt(),
|
|
height: tuple.item1.blockNumber,
|
|
isCancelled: false,
|
|
isLelantus: false,
|
|
slateId: null,
|
|
nonce: tuple.item2.nonce,
|
|
otherData: tuple.item1.address,
|
|
inputs: [],
|
|
outputs: [],
|
|
);
|
|
|
|
Address? transactionAddress = await ethWallet.db
|
|
.getAddresses(ethWallet.walletId)
|
|
.filter()
|
|
.valueEqualTo(toAddress)
|
|
.findFirst();
|
|
|
|
transactionAddress ??= Address(
|
|
walletId: ethWallet.walletId,
|
|
value: toAddress,
|
|
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 ethWallet.db.addNewTransactionData(txnsData, ethWallet.walletId);
|
|
|
|
// quick hack to notify manager to call notifyListeners if
|
|
// transactions changed
|
|
if (txnsData.isNotEmpty) {
|
|
GlobalEventBus.instance.fire(
|
|
UpdatedInBackgroundEvent(
|
|
"${tokenContract.name} transactions updated/added for: ${ethWallet.walletId} ${ethWallet.walletName}",
|
|
ethWallet.walletId,
|
|
),
|
|
);
|
|
}
|
|
}
|
|
|
|
bool validateAddress(String address) {
|
|
return isValidEthereumAddress(address);
|
|
}
|
|
|
|
NodeModel getCurrentNode() {
|
|
return NodeService(secureStorageInterface: _secureStore)
|
|
.getPrimaryNodeFor(coin: coin) ??
|
|
DefaultNodes.getNodeFor(coin);
|
|
}
|
|
|
|
Future<web3dart.Web3Client> getEthClient() async {
|
|
final node = getCurrentNode();
|
|
return web3dart.Web3Client(node.host, Client());
|
|
}
|
|
}
|