mirror of
https://github.com/cake-tech/cake_wallet.git
synced 2024-12-26 13:39:39 +00:00
556 lines
17 KiB
Dart
556 lines
17 KiB
Dart
import 'dart:async';
|
|
import 'dart:convert';
|
|
|
|
import 'package:cw_core/crypto_currency.dart';
|
|
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';
|
|
import 'package:cw_core/transaction_priority.dart';
|
|
import 'package:cw_core/wallet_addresses.dart';
|
|
import 'package:cw_core/wallet_base.dart';
|
|
import 'package:cw_core/wallet_info.dart';
|
|
import 'package:cw_ethereum/ethereum_balance.dart';
|
|
import 'package:cw_ethereum/ethereum_client.dart';
|
|
import 'package:cw_ethereum/ethereum_exceptions.dart';
|
|
import 'package:cw_ethereum/ethereum_transaction_credentials.dart';
|
|
import 'package:cw_ethereum/ethereum_transaction_history.dart';
|
|
import 'package:cw_ethereum/ethereum_transaction_info.dart';
|
|
import 'package:cw_ethereum/ethereum_transaction_priority.dart';
|
|
import 'package:cw_ethereum/ethereum_wallet_addresses.dart';
|
|
import 'package:cw_ethereum/file.dart';
|
|
import 'package:cw_core/erc20_token.dart';
|
|
import 'package:hive/hive.dart';
|
|
import 'package:hex/hex.dart';
|
|
import 'package:mobx/mobx.dart';
|
|
import 'package:web3dart/web3dart.dart';
|
|
import 'package:bip39/bip39.dart' as bip39;
|
|
import 'package:bip32/bip32.dart' as bip32;
|
|
|
|
part 'ethereum_wallet.g.dart';
|
|
|
|
class EthereumWallet = EthereumWalletBase with _$EthereumWallet;
|
|
|
|
abstract class EthereumWalletBase
|
|
extends WalletBase<ERC20Balance, EthereumTransactionHistory, EthereumTransactionInfo>
|
|
with Store {
|
|
EthereumWalletBase({
|
|
required WalletInfo walletInfo,
|
|
required String mnemonic,
|
|
required String password,
|
|
ERC20Balance? initialBalance,
|
|
}) : syncStatus = NotConnectedSyncStatus(),
|
|
_password = password,
|
|
_mnemonic = mnemonic,
|
|
_priorityFees = [],
|
|
_client = EthereumClient(),
|
|
walletAddresses = EthereumWalletAddresses(walletInfo),
|
|
balance = ObservableMap<CryptoCurrency, ERC20Balance>.of(
|
|
{CryptoCurrency.eth: initialBalance ?? ERC20Balance(BigInt.zero)}),
|
|
super(walletInfo) {
|
|
this.walletInfo = walletInfo;
|
|
|
|
if (!Hive.isAdapterRegistered(Erc20Token.typeId)) {
|
|
Hive.registerAdapter(Erc20TokenAdapter());
|
|
}
|
|
}
|
|
|
|
final String _mnemonic;
|
|
final String _password;
|
|
|
|
late final Box<Erc20Token> erc20TokensBox;
|
|
|
|
late final EthPrivateKey _privateKey;
|
|
|
|
late EthereumClient _client;
|
|
|
|
List<int> _priorityFees;
|
|
int? _gasPrice;
|
|
|
|
@override
|
|
WalletAddresses walletAddresses;
|
|
|
|
@override
|
|
@observable
|
|
SyncStatus syncStatus;
|
|
|
|
@override
|
|
@observable
|
|
late ObservableMap<CryptoCurrency, ERC20Balance> balance;
|
|
|
|
Future<void> init() async {
|
|
erc20TokensBox = await Hive.openBox<Erc20Token>(Erc20Token.boxName);
|
|
await walletAddresses.init();
|
|
_privateKey = await getPrivateKey(_mnemonic, _password);
|
|
transactionHistory = EthereumTransactionHistory();
|
|
walletAddresses.address = _privateKey.address.toString();
|
|
}
|
|
|
|
@override
|
|
int calculateEstimatedFee(TransactionPriority priority, int? amount) {
|
|
try {
|
|
if (priority is EthereumTransactionPriority) {
|
|
return _gasPrice! * _priorityFees[priority.raw];
|
|
}
|
|
|
|
return 0;
|
|
} catch (e) {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
@override
|
|
Future<void> changePassword(String password) {
|
|
throw UnimplementedError("changePassword");
|
|
}
|
|
|
|
@override
|
|
void close() {
|
|
_client.stop();
|
|
}
|
|
|
|
@action
|
|
@override
|
|
Future<void> connectToNode({required Node node}) async {
|
|
try {
|
|
syncStatus = ConnectingSyncStatus();
|
|
|
|
final isConnected = _client.connect(node);
|
|
|
|
if (!isConnected) {
|
|
throw Exception("Ethereum Node connection failed");
|
|
}
|
|
|
|
_client.setListeners(_privateKey.address, _onNewTransaction);
|
|
_updateBalance();
|
|
|
|
syncStatus = ConnectedSyncStatus();
|
|
} catch (e) {
|
|
syncStatus = FailedSyncStatus();
|
|
}
|
|
}
|
|
|
|
@override
|
|
Future<PendingTransaction> createTransaction(Object credentials) async {
|
|
final _credentials = credentials as EthereumTransactionCredentials;
|
|
final outputs = _credentials.outputs;
|
|
final hasMultiDestination = outputs.length > 1;
|
|
final _erc20Balance = balance[_credentials.currency]!;
|
|
int totalAmount = 0;
|
|
|
|
if (hasMultiDestination) {
|
|
if (outputs.any((item) => item.sendAll || (item.formattedCryptoAmount ?? 0) <= 0)) {
|
|
throw EthereumTransactionCreationException();
|
|
}
|
|
|
|
totalAmount = outputs.fold(0, (acc, value) => acc + (value.formattedCryptoAmount ?? 0));
|
|
|
|
if (_erc20Balance.balance < EtherAmount.inWei(totalAmount as BigInt).getInWei) {
|
|
throw EthereumTransactionCreationException();
|
|
}
|
|
} else {
|
|
final output = outputs.first;
|
|
final int allAmount = _erc20Balance.balance.toInt() - feeRate(_credentials.priority!);
|
|
totalAmount = output.sendAll ? allAmount : output.formattedCryptoAmount ?? 0;
|
|
|
|
if ((output.sendAll &&
|
|
_erc20Balance.balance < EtherAmount.inWei(totalAmount as BigInt).getInWei) ||
|
|
(!output.sendAll && _erc20Balance.balance.toInt() <= 0)) {
|
|
throw EthereumTransactionCreationException();
|
|
}
|
|
}
|
|
|
|
final pendingEthereumTransaction = await _client.signTransaction(
|
|
privateKey: _privateKey,
|
|
toAddress: _credentials.outputs.first.address,
|
|
amount: totalAmount.toString(),
|
|
gas: _priorityFees[_credentials.priority!.raw],
|
|
priority: _credentials.priority!,
|
|
currency: _credentials.currency,
|
|
);
|
|
|
|
return pendingEthereumTransaction;
|
|
}
|
|
|
|
@override
|
|
Future<Map<String, EthereumTransactionInfo>> fetchTransactions() {
|
|
throw UnimplementedError("fetchTransactions");
|
|
}
|
|
|
|
@override
|
|
Object get keys => throw UnimplementedError("keys");
|
|
|
|
@override
|
|
Future<void> rescan({required int height}) {
|
|
throw UnimplementedError("rescan");
|
|
}
|
|
|
|
@override
|
|
Future<void> save() async {
|
|
await walletAddresses.updateAddressesInBox();
|
|
final path = await makePath();
|
|
await write(path: path, password: _password, data: toJSON());
|
|
await transactionHistory.save();
|
|
}
|
|
|
|
@override
|
|
String get seed => _mnemonic;
|
|
|
|
@action
|
|
@override
|
|
Future<void> startSync() async {
|
|
try {
|
|
syncStatus = AttemptingSyncStatus();
|
|
await _updateBalance();
|
|
_gasPrice = await _client.getGasUnitPrice();
|
|
_priorityFees = await _client.getEstimatedGasForPriorities();
|
|
|
|
Timer.periodic(
|
|
const Duration(minutes: 1), (timer) async => _gasPrice = await _client.getGasUnitPrice());
|
|
Timer.periodic(const Duration(minutes: 1),
|
|
(timer) async => _priorityFees = await _client.getEstimatedGasForPriorities());
|
|
|
|
syncStatus = SyncedSyncStatus();
|
|
} catch (e) {
|
|
syncStatus = FailedSyncStatus();
|
|
}
|
|
}
|
|
|
|
int feeRate(TransactionPriority priority) {
|
|
try {
|
|
if (priority is EthereumTransactionPriority) {
|
|
return _priorityFees[priority.raw];
|
|
}
|
|
|
|
return 0;
|
|
} catch (e) {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
Future<String> makePath() async => pathForWallet(name: walletInfo.name, type: walletInfo.type);
|
|
|
|
String toJSON() => json.encode({
|
|
'mnemonic': _mnemonic,
|
|
'balance': balance[currency]!.toJSON(),
|
|
});
|
|
|
|
static Future<EthereumWallet> open({
|
|
required String name,
|
|
required String password,
|
|
required WalletInfo walletInfo,
|
|
}) async {
|
|
final path = await pathForWallet(name: name, type: walletInfo.type);
|
|
final jsonSource = await read(path: path, password: password);
|
|
final data = json.decode(jsonSource) as Map;
|
|
final mnemonic = data['mnemonic'] as String;
|
|
final balance = ERC20Balance.fromJSON(data['balance'] as String) ?? ERC20Balance(BigInt.zero);
|
|
|
|
return EthereumWallet(
|
|
walletInfo: walletInfo,
|
|
password: password,
|
|
mnemonic: mnemonic,
|
|
initialBalance: balance,
|
|
);
|
|
}
|
|
|
|
Future<void> _updateBalance() async {
|
|
balance[currency] = await _fetchEthBalance();
|
|
|
|
await _fetchErc20Balances();
|
|
await save();
|
|
}
|
|
|
|
Future<ERC20Balance> _fetchEthBalance() async {
|
|
final balance = await _client.getBalance(_privateKey.address);
|
|
return ERC20Balance(balance.getInWei);
|
|
}
|
|
|
|
Future<void> _fetchErc20Balances() async {
|
|
for (var token in erc20TokensBox.values) {
|
|
try {
|
|
if (token.enabled) {
|
|
balance[token] = await _client.fetchERC20Balances(
|
|
_privateKey.address,
|
|
token.contractAddress,
|
|
);
|
|
} else {
|
|
balance.remove(token);
|
|
}
|
|
} catch (_) {}
|
|
}
|
|
}
|
|
|
|
Future<EthPrivateKey> getPrivateKey(String mnemonic, String password) async {
|
|
final seed = bip39.mnemonicToSeed(mnemonic);
|
|
|
|
final root = bip32.BIP32.fromSeed(seed);
|
|
|
|
const _hdPathEthereum = "m/44'/60'/0'/0";
|
|
const index = 0;
|
|
final addressAtIndex = root.derivePath("$_hdPathEthereum/$index");
|
|
|
|
return EthPrivateKey.fromHex(HEX.encode(addressAtIndex.privateKey as List<int>));
|
|
}
|
|
|
|
Future<void>? updateBalance() async => await _updateBalance();
|
|
|
|
List<Erc20Token> get erc20Currencies => erc20TokensBox.values.toList();
|
|
|
|
Future<void> addErc20Token(Erc20Token token) async {
|
|
String? iconPath;
|
|
try {
|
|
iconPath = CryptoCurrency.all
|
|
.firstWhere((element) => element.title.toUpperCase() == token.symbol.toUpperCase())
|
|
.iconPath;
|
|
} catch (_) {}
|
|
|
|
final _token = Erc20Token(
|
|
name: token.name,
|
|
symbol: token.symbol,
|
|
contractAddress: token.contractAddress,
|
|
decimal: token.decimal,
|
|
enabled: token.enabled,
|
|
iconPath: iconPath,
|
|
);
|
|
|
|
await erc20TokensBox.put(_token.contractAddress, _token);
|
|
|
|
if (_token.enabled) {
|
|
balance[_token] = await _client.fetchERC20Balances(
|
|
_privateKey.address,
|
|
_token.contractAddress,
|
|
);
|
|
} else {
|
|
balance.remove(_token);
|
|
}
|
|
}
|
|
|
|
Future<void> deleteErc20Token(Erc20Token token) async {
|
|
await token.delete();
|
|
|
|
balance.remove(token);
|
|
_updateBalance();
|
|
}
|
|
|
|
Future<Erc20Token?> getErc20Token(String contractAddress) async =>
|
|
await _client.getErc20Token(contractAddress);
|
|
|
|
void _onNewTransaction(FilterEvent event) {
|
|
_updateBalance();
|
|
// TODO: Add in transaction history
|
|
}
|
|
|
|
void addInitialTokens() {
|
|
final Map<CryptoCurrency, Map<String, dynamic>> _initialErc20Currencies = {
|
|
CryptoCurrency.usdc: {
|
|
'contractAddress': "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
|
|
'decimal': 6,
|
|
'enabled': true,
|
|
},
|
|
CryptoCurrency.usdterc20: {
|
|
'contractAddress': "0xdac17f958d2ee523a2206206994597c13d831ec7",
|
|
'decimal': 6,
|
|
'enabled': true,
|
|
},
|
|
CryptoCurrency.dai: {
|
|
'contractAddress': "0x6B175474E89094C44Da98b954EedeAC495271d0F",
|
|
'decimal': 18,
|
|
'enabled': true,
|
|
},
|
|
CryptoCurrency.weth: {
|
|
'contractAddress': "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
|
|
'decimal': 18,
|
|
'enabled': false,
|
|
},
|
|
CryptoCurrency.pepe: {
|
|
'contractAddress': "0x6982508145454ce325ddbe47a25d4ec3d2311933",
|
|
'decimal': 18,
|
|
'enabled': false,
|
|
},
|
|
CryptoCurrency.shib: {
|
|
'contractAddress': "0x95ad61b0a150d79219dcf64e1e6cc01f0b64c4ce",
|
|
'decimal': 18,
|
|
'enabled': false,
|
|
},
|
|
CryptoCurrency.ape: {
|
|
'contractAddress': "0x4d224452801aced8b2f0aebe155379bb5d594381",
|
|
'decimal': 18,
|
|
'enabled': false,
|
|
},
|
|
CryptoCurrency.matic: {
|
|
'contractAddress': "0x7d1afa7b718fb893db30a3abc0cfc608aacfebb0",
|
|
'decimal': 18,
|
|
'enabled': false,
|
|
},
|
|
CryptoCurrency.wbtc: {
|
|
'contractAddress': "0x2260fac5e5542a773aa44fbcfedf7c193bc2c599",
|
|
'decimal': 8,
|
|
'enabled': false,
|
|
},
|
|
CryptoCurrency.gtc: {
|
|
'contractAddress': "0xde30da39c46104798bb5aa3fe8b9e0e1f348163f",
|
|
'decimal': 18,
|
|
'enabled': false,
|
|
},
|
|
CryptoCurrency.comp: {
|
|
'contractAddress': "0xc00e94cb662c3520282e6f5717214004a7f26888",
|
|
'decimal': 18,
|
|
'enabled': false,
|
|
},
|
|
CryptoCurrency.aave: {
|
|
'contractAddress': "0x7fc66500c84a76ad7e9c93437bfc5ac33e2ddae9",
|
|
'decimal': 18,
|
|
'enabled': false,
|
|
},
|
|
CryptoCurrency.uni: {
|
|
'contractAddress': "0x1f9840a85d5af5bf1d1762f925bdaddc4201f984",
|
|
'decimal': 18,
|
|
'enabled': false,
|
|
},
|
|
CryptoCurrency.mana: {
|
|
'contractAddress': "0x0f5d2fb29fb7d3cfee444a200298f468908cc942",
|
|
'decimal': 18,
|
|
'enabled': false,
|
|
},
|
|
CryptoCurrency.storj: {
|
|
'contractAddress': "0xb64ef51c888972c908cfacf59b47c1afbc0ab8ac",
|
|
'decimal': 8,
|
|
'enabled': false,
|
|
},
|
|
CryptoCurrency.mkr: {
|
|
'contractAddress': "0x9f8F72aA9304c8B593d555F12eF6589cC3A579A2",
|
|
'decimal': 18,
|
|
'enabled': false,
|
|
},
|
|
CryptoCurrency.oxt: {
|
|
'contractAddress': "0x4575f41308EC1483f3d399aa9a2826d74Da13Deb",
|
|
'decimal': 18,
|
|
'enabled': false,
|
|
},
|
|
CryptoCurrency.paxg: {
|
|
'contractAddress': "0x45804880De22913dAFE09f4980848ECE6EcbAf78",
|
|
'decimal': 18,
|
|
'enabled': false,
|
|
},
|
|
CryptoCurrency.bnb: {
|
|
'contractAddress': "0xB8c77482e45F1F44dE1745F52C74426C631bDD52",
|
|
'decimal': 18,
|
|
'enabled': true,
|
|
},
|
|
CryptoCurrency.steth: {
|
|
'contractAddress': "0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84",
|
|
'decimal': 18,
|
|
'enabled': false,
|
|
},
|
|
CryptoCurrency.ldo: {
|
|
'contractAddress': "0x5A98FcBEA516Cf06857215779Fd812CA3beF1B32",
|
|
'decimal': 18,
|
|
'enabled': false,
|
|
},
|
|
CryptoCurrency.arb: {
|
|
'contractAddress': "0xB50721BCf8d664c30412Cfbc6cf7a15145234ad1",
|
|
'decimal': 18,
|
|
'enabled': false,
|
|
},
|
|
CryptoCurrency.grt: {
|
|
'contractAddress': "0xc944E90C64B2c07662A292be6244BDf05Cda44a7",
|
|
'decimal': 18,
|
|
'enabled': false,
|
|
},
|
|
CryptoCurrency.frax: {
|
|
'contractAddress': "0x853d955aCEf822Db058eb8505911ED77F175b99e",
|
|
'decimal': 18,
|
|
'enabled': false,
|
|
},
|
|
CryptoCurrency.gusd: {
|
|
'contractAddress': "0x056Fd409E1d7A124BD7017459dFEa2F387b6d5Cd",
|
|
'decimal': 18,
|
|
'enabled': false,
|
|
},
|
|
CryptoCurrency.ceth: {
|
|
'contractAddress': "0x4Ddc2D193948926D02f9B1fE9e1daa0718270ED5",
|
|
'decimal': 8,
|
|
'enabled': false,
|
|
},
|
|
CryptoCurrency.busd: {
|
|
'contractAddress': "0x4Fabb145d64652a948d72533023f6E7A623C7C53",
|
|
'decimal': 18,
|
|
'enabled': false,
|
|
},
|
|
CryptoCurrency.tusd: {
|
|
'contractAddress': "0x0000000000085d4780B73119b644AE5ecd22b376",
|
|
'decimal': 18,
|
|
'enabled': false,
|
|
},
|
|
CryptoCurrency.cro: {
|
|
'contractAddress': "0xA0b73E1Ff0B80914AB6fe0444E65848C4C34450b",
|
|
'decimal': 8,
|
|
'enabled': false,
|
|
},
|
|
CryptoCurrency.usdp: {
|
|
'contractAddress': "0x8E870D67F660D95d5be530380D0eC0bd388289E1",
|
|
'decimal': 18,
|
|
'enabled': false,
|
|
},
|
|
CryptoCurrency.ftm: {
|
|
'contractAddress': "0x4E15361FD6b4BB609Fa63C81A2be19d873717870",
|
|
'decimal': 18,
|
|
'enabled': false,
|
|
},
|
|
CryptoCurrency.btt: {
|
|
'contractAddress': "0xC669928185DbCE49d2230CC9B0979BE6DC797957",
|
|
'decimal': 18,
|
|
'enabled': false,
|
|
},
|
|
CryptoCurrency.nexo: {
|
|
'contractAddress': "0xB62132e35a6c13ee1EE0f84dC5d40bad8d815206",
|
|
'decimal': 18,
|
|
'enabled': false,
|
|
},
|
|
CryptoCurrency.dydx: {
|
|
'contractAddress': "0x92D6C1e31e14520e676a687F0a93788B716BEff5",
|
|
'decimal': 18,
|
|
'enabled': false,
|
|
},
|
|
CryptoCurrency.cake: {
|
|
'contractAddress': "0x152649eA73beAb28c5b49B26eb48f7EAD6d4c898",
|
|
'decimal': 18,
|
|
'enabled': false,
|
|
},
|
|
CryptoCurrency.bat: {
|
|
'contractAddress': "0x0D8775F648430679A709E98d2b0Cb6250d2887EF",
|
|
'decimal': 18,
|
|
'enabled': false,
|
|
},
|
|
CryptoCurrency.1inch: {
|
|
'contractAddress': "0x111111111117dC0aa78b770fA6A738034120C302",
|
|
'decimal': 18,
|
|
'enabled': false,
|
|
},
|
|
CryptoCurrency.ens: {
|
|
'contractAddress': "0xC18360217D8F7Ab5e7c516566761Ea12Ce7F9D72",
|
|
'decimal': 18,
|
|
'enabled': false,
|
|
},
|
|
CryptoCurrency.zrx: {
|
|
'contractAddress': "0xE41d2489571d322189246DaFA5ebDe1F4699F498",
|
|
'decimal': 18,
|
|
'enabled': false,
|
|
},
|
|
};
|
|
|
|
for (var currency in _initialErc20Currencies.keys) {
|
|
erc20TokensBox.put(
|
|
_initialErc20Currencies[currency]!['contractAddress'],
|
|
Erc20Token(
|
|
name: currency.fullName ?? currency.title,
|
|
symbol: currency.title,
|
|
contractAddress: _initialErc20Currencies[currency]!['contractAddress'],
|
|
decimal: _initialErc20Currencies[currency]!['decimal'],
|
|
enabled: _initialErc20Currencies[currency]!['enabled'] ?? true,
|
|
iconPath: currency.iconPath,
|
|
));
|
|
}
|
|
}
|
|
}
|