Ecosystem/stack_wallet
1
0
Fork 0
mirror of https://github.com/cypherstack/stack_wallet.git synced 2025-01-22 02:24:30 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

WIP tezos

Browse source
This commit is contained in:
julian 2023-11-20 13:55:22 -06:00
parent 273fd981f4
commit 62c1628fa7
13 changed files with 1111 additions and 796 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
lib/pages/add_wallet_views/new_wallet_recovery_phrase_view/new_wallet_recovery_phrase_view.dart
View file

@ -83,7 +83,7 @@ class _NewWalletRecoveryPhraseViewState
await _wallet.exit();
await ref
.read(pWallets)
.deleteWallet(_wallet.walletId, ref.read(secureStoreProvider));
.deleteWallet(_wallet.info, ref.read(secureStoreProvider));
}
Future<void> _copy() async {

2
lib/pages/add_wallet_views/restore_wallet_view/restore_wallet_view.dart
View file

@ -258,7 +258,7 @@ class _RestoreWalletViewState extends ConsumerState<RestoreWalletView> {
isRestoring = false;
await ref.read(pWallets).deleteWallet(
info.walletId,
info,
ref.read(secureStoreProvider),
);
},

3
lib/pages/add_wallet_views/restore_wallet_view/sub_widgets/restore_failed_dialog.dart
View file

@ -14,6 +14,7 @@ import 'package:stackwallet/providers/global/secure_store_provider.dart';
import 'package:stackwallet/providers/providers.dart';
import 'package:stackwallet/themes/stack_colors.dart';
import 'package:stackwallet/utilities/text_styles.dart';
import 'package:stackwallet/wallets/isar/providers/wallet_info_provider.dart';
import 'package:stackwallet/widgets/stack_dialog.dart';
class RestoreFailedDialog extends ConsumerStatefulWidget {
@ -65,7 +66,7 @@ class _RestoreFailedDialogState extends ConsumerState<RestoreFailedDialog> {
),
onPressed: () async {
await ref.read(pWallets).deleteWallet(
walletId,
ref.read(pWalletInfo(walletId)),
ref.read(secureStoreProvider),
);

2
lib/pages/add_wallet_views/verify_recovery_phrase_view/verify_recovery_phrase_view.dart
View file

@ -262,7 +262,7 @@ class _VerifyRecoveryPhraseViewState
Future<void> delete() async {
await ref.read(pWallets).deleteWallet(
_wallet.walletId,
_wallet.info,
ref.read(secureStoreProvider),
);
}

2
lib/pages/settings_views/wallet_settings_view/wallet_settings_wallet_settings/delete_wallet_recovery_phrase_view.dart
View file

@ -197,7 +197,7 @@ class _DeleteWalletRecoveryPhraseViewState
.getPrimaryEnabledButtonStyle(context),
onPressed: () async {
await ref.read(pWallets).deleteWallet(
widget.walletId,
ref.read(pWalletInfo(widget.walletId)),
ref.read(secureStoreProvider),
);

3
lib/pages_desktop_specific/my_stack_view/wallet_view/sub_widgets/delete_wallet_keys_popup.dart
View file

@ -22,6 +22,7 @@ import 'package:stackwallet/themes/stack_colors.dart';
import 'package:stackwallet/utilities/assets.dart';
import 'package:stackwallet/utilities/clipboard_interface.dart';
import 'package:stackwallet/utilities/text_styles.dart';
import 'package:stackwallet/wallets/isar/providers/wallet_info_provider.dart';
import 'package:stackwallet/widgets/desktop/desktop_dialog.dart';
import 'package:stackwallet/widgets/desktop/desktop_dialog_close_button.dart';
import 'package:stackwallet/widgets/desktop/primary_button.dart';
@ -238,7 +239,7 @@ class _ConfirmDeleteState extends ConsumerState<ConfirmDelete> {
label: "Continue",
onPressed: () async {
await ref.read(pWallets).deleteWallet(
widget.walletId,
ref.read(pWalletInfo(widget.walletId)),
ref.read(secureStoreProvider),
);

9
lib/services/coins/coin_service.dart
View file

@ -21,7 +21,6 @@ import 'package:stackwallet/services/coins/monero/monero_wallet.dart';
import 'package:stackwallet/services/coins/namecoin/namecoin_wallet.dart';
import 'package:stackwallet/services/coins/particl/particl_wallet.dart';
import 'package:stackwallet/services/coins/stellar/stellar_wallet.dart';
import 'package:stackwallet/services/coins/tezos/tezos_wallet.dart';
import 'package:stackwallet/services/transaction_notification_tracker.dart';
import 'package:stackwallet/utilities/amount/amount.dart';
import 'package:stackwallet/utilities/enums/coin_enum.dart';
@ -175,13 +174,7 @@ abstract class CoinServiceAPI {
);
case Coin.tezos:
return TezosWallet(
walletId: walletId,
walletName: walletName,
coin: coin,
secureStore: secureStorageInterface,
tracker: tracker,
);
throw UnimplementedError("moved");
case Coin.wownero:
throw UnimplementedError("moved");

1465
lib/services/coins/tezos/tezos_wallet.dart
View file

File diff suppressed because it is too large Load diff

13
lib/services/wallets.dart
View file

@ -55,36 +55,37 @@ class Wallets {
}
Future<void> deleteWallet(
String walletId,
WalletInfo info,
SecureStorageInterface secureStorage,
) async {
final walletId = info.walletId;
Logging.instance.log(
"deleteWallet called with walletId=$walletId",
level: LogLevel.Warning,
);
final wallet = getWallet(walletId);
final wallet = _wallets[walletId];
_wallets.remove(walletId);
await wallet.exit();
await wallet?.exit();
await secureStorage.delete(key: Wallet.mnemonicKey(walletId: walletId));
await secureStorage.delete(
key: Wallet.mnemonicPassphraseKey(walletId: walletId));
await secureStorage.delete(key: Wallet.privateKeyKey(walletId: walletId));
if (wallet.info.coin == Coin.wownero) {
if (info.coin == Coin.wownero) {
final wowService =
wownero.createWowneroWalletService(DB.instance.moneroWalletInfoBox);
await wowService.remove(walletId);
Logging.instance
.log("monero wallet: $walletId deleted", level: LogLevel.Info);
} else if (wallet.info.coin == Coin.monero) {
} else if (info.coin == Coin.monero) {
final xmrService =
monero.createMoneroWalletService(DB.instance.moneroWalletInfoBox);
await xmrService.remove(walletId);
Logging.instance
.log("monero wallet: $walletId deleted", level: LogLevel.Info);
} else if (wallet.info.coin == Coin.epicCash) {
} else if (info.coin == Coin.epicCash) {
final deleteResult = await deleteEpicWallet(
walletId: walletId, secureStore: secureStorage);
Logging.instance.log(

2
lib/wallets/api/tezos/tezos_api.dart
View file

@ -10,7 +10,7 @@ import 'package:stackwallet/wallets/api/tezos/tezos_transaction.dart';
abstract final class TezosAPI {
static final HTTP _client = HTTP();
static const String _baseURL = 'https://api.tzstats.com';
static const String _baseURL = 'https://api.mainnet.tzkt.io';
static Future<List<TezosTransaction>?> getTransactions(String address) async {
try {

31
lib/wallets/crypto_currency/coins/tezos.dart
View file

@ -1,4 +1,5 @@
import 'package:stackwallet/models/node_model.dart';
import 'package:stackwallet/utilities/default_nodes.dart';
import 'package:stackwallet/utilities/enums/coin_enum.dart';
import 'package:stackwallet/wallets/crypto_currency/crypto_currency.dart';
import 'package:stackwallet/wallets/crypto_currency/intermediate/bip39_currency.dart';
@ -12,21 +13,37 @@ class Tezos extends Bip39Currency {
throw Exception("Unsupported network: $network");
}
}
@override
// TODO: implement defaultNode
NodeModel get defaultNode => throw UnimplementedError();
@override
// TODO: implement genesisHash
String get genesisHash => throw UnimplementedError();
@override
// TODO: implement minConfirms
int get minConfirms => throw UnimplementedError();
int get minConfirms => 1;
@override
bool validateAddress(String address) {
// TODO: implement validateAddress
throw UnimplementedError();
return RegExp(r"^tz[1-9A-HJ-NP-Za-km-z]{34}$").hasMatch(address);
}
@override
NodeModel get defaultNode {
switch (network) {
case CryptoCurrencyNetwork.main:
return NodeModel(
host: "https://mainnet.api.tez.ie",
port: 443,
name: DefaultNodes.defaultName,
id: DefaultNodes.buildId(Coin.tezos),
useSSL: true,
enabled: true,
coinName: Coin.tezos.name,
isFailover: true,
isDown: false,
);
default:
throw UnimplementedError();
}
}
}

8
lib/wallets/models/tx_data.dart
View file

@ -3,6 +3,7 @@ import 'package:stackwallet/models/isar/models/isar_models.dart';
import 'package:stackwallet/models/paynym/paynym_account_lite.dart';
import 'package:stackwallet/utilities/amount/amount.dart';
import 'package:stackwallet/utilities/enums/fee_rate_type_enum.dart';
import 'package:tezart/tezart.dart' as tezart;
import 'package:web3dart/web3dart.dart' as web3dart;
class TxData {
@ -51,6 +52,9 @@ class TxData {
final TransactionSubType? txSubType;
final List<Map<String, dynamic>>? mintsMapLelantus;
// tezos specific
final tezart.OperationsList? tezosOperationsList;
TxData({
this.feeRateType,
this.feeRateAmount,
@ -80,6 +84,7 @@ class TxData {
this.txType,
this.txSubType,
this.mintsMapLelantus,
this.tezosOperationsList,
});
Amount? get amount => recipients != null && recipients!.isNotEmpty
@ -121,6 +126,7 @@ class TxData {
TransactionType? txType,
TransactionSubType? txSubType,
List<Map<String, dynamic>>? mintsMapLelantus,
tezart.OperationsList? tezosOperationsList,
}) {
return TxData(
feeRateType: feeRateType ?? this.feeRateType,
@ -152,6 +158,7 @@ class TxData {
txType: txType ?? this.txType,
txSubType: txSubType ?? this.txSubType,
mintsMapLelantus: mintsMapLelantus ?? this.mintsMapLelantus,
tezosOperationsList: tezosOperationsList ?? this.tezosOperationsList,
);
}
@ -185,5 +192,6 @@ class TxData {
'txType: $txType, '
'txSubType: $txSubType, '
'mintsMapLelantus: $mintsMapLelantus, '
'tezosOperationsList: $tezosOperationsList, '
'}';
}

365
lib/wallets/wallet/impl/tezos_wallet.dart
View file

@ -1,85 +1,380 @@
import 'package:isar/isar.dart';
import 'package:stackwallet/models/balance.dart';
import 'package:stackwallet/models/isar/models/blockchain_data/address.dart';
import 'package:stackwallet/models/isar/models/blockchain_data/transaction.dart';
import 'package:stackwallet/models/node_model.dart';
import 'package:stackwallet/models/paymint/fee_object_model.dart';
import 'package:stackwallet/services/node_service.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/extensions/impl/string.dart';
import 'package:stackwallet/utilities/logger.dart';
import 'package:stackwallet/wallets/api/tezos/tezos_api.dart';
import 'package:stackwallet/wallets/api/tezos/tezos_rpc_api.dart';
import 'package:stackwallet/wallets/api/tezos/tezos_transaction.dart';
import 'package:stackwallet/wallets/crypto_currency/coins/tezos.dart';
import 'package:stackwallet/wallets/crypto_currency/crypto_currency.dart';
import 'package:stackwallet/wallets/models/tx_data.dart';
import 'package:stackwallet/wallets/wallet/intermediate/bip39_wallet.dart';
import 'package:tezart/tezart.dart' as tezart;
import 'package:tuple/tuple.dart';
const int GAS_LIMIT = 10200;
class TezosWallet extends Bip39Wallet {
TezosWallet(CryptoCurrencyNetwork network) : super(Tezos(network));
NodeModel? _xtzNode;
Future<tezart.Keystore> _getKeyStore() async {
final mnemonic = await getMnemonic();
final passphrase = await getMnemonicPassphrase();
return tezart.Keystore.fromMnemonic(mnemonic, password: passphrase);
}
Future<Address> _getAddressFromMnemonic() async {
final keyStore = await _getKeyStore();
return Address(
walletId: walletId,
value: keyStore.address,
publicKey: keyStore.publicKey.toUint8ListFromBase58CheckEncoded,
derivationIndex: 0,
derivationPath: null,
type: info.coin.primaryAddressType,
subType: AddressSubType.receiving,
);
}
// ===========================================================================
@override
Future<void> init() async {
final _address = await getCurrentReceivingAddress();
if (_address == null) {
final address = await _getAddressFromMnemonic();
await mainDB.updateOrPutAddresses([address]);
}
await super.init();
}
@override
// TODO: implement changeAddressFilterOperation
FilterOperation? get changeAddressFilterOperation =>
throw UnimplementedError();
throw UnimplementedError("Not used for $runtimeType");
@override
// TODO: implement receivingAddressFilterOperation
FilterOperation? get receivingAddressFilterOperation =>
throw UnimplementedError();
FilterGroup.and(standardReceivingAddressFilters);
@override
Future<TxData> confirmSend({required TxData txData}) {
Future<TxData> prepareSend({required TxData txData}) async {
if (txData.recipients == null || txData.recipients!.length != 1) {
throw Exception("$runtimeType prepareSend requires 1 recipient");
}
Amount sendAmount = txData.amount!;
if (sendAmount > info.cachedBalance.spendable) {
throw Exception("Insufficient available balance");
}
final bool isSendAll = sendAmount == info.cachedBalance.spendable;
final sourceKeyStore = await _getKeyStore();
final tezartClient = tezart.TezartClient(
(_xtzNode ?? getCurrentNode()).host,
);
final opList = await tezartClient.transferOperation(
source: sourceKeyStore,
destination: txData.recipients!.first.address,
amount: sendAmount.raw.toInt(),
);
await opList.computeFees();
final fee = Amount(
rawValue: opList.operations
.map(
(e) => BigInt.from(e.fee),
)
.fold(
BigInt.zero,
(p, e) => p + e,
),
fractionDigits: cryptoCurrency.fractionDigits,
);
if (isSendAll) {
sendAmount = sendAmount - fee;
}
return txData.copyWith(
recipients: [
(
amount: sendAmount,
address: txData.recipients!.first.address,
)
],
fee: fee,
tezosOperationsList: opList,
);
}
@override
Future<TxData> confirmSend({required TxData txData}) async {
// TODO: implement confirmSend
throw UnimplementedError();
}
@override
Future<Amount> estimateFeeFor(Amount amount, int feeRate) {
// TODO: implement estimateFeeFor
Future<Amount> estimateFeeFor(Amount amount, int feeRate) async {
throw UnimplementedError();
// final ADDRESS_REPLACEME = (await getCurrentReceivingAddress())!.value;
//
// try {
// final sourceKeyStore = await _getKeyStore();
// final tezartClient = tezart.TezartClient(
// (_xtzNode ?? getCurrentNode()).host,
// );
//
// final opList = await tezartClient.transferOperation(
// source: sourceKeyStore,
// destination: ADDRESS_REPLACEME,
// amount: amount.raw.toInt(),
// );
//
// await opList.run();
// await opList.estimate();
//
// final fee = Amount(
// rawValue: opList.operations
// .map(
// (e) => BigInt.from(e.fee),
// )
// .fold(
// BigInt.zero,
// (p, e) => p + e,
// ),
// fractionDigits: cryptoCurrency.fractionDigits,
// );
//
// return fee;
// } catch (e, s) {
// Logging.instance.log(
// "Error in estimateFeeFor() in tezos_wallet.dart: $e\n$s}",
// level: LogLevel.Error,
// );
// rethrow;
// }
}
@override
// TODO: implement fees
Future<FeeObject> get fees => throw UnimplementedError();
@override
Future<bool> pingCheck() {
// TODO: implement pingCheck
throw UnimplementedError();
Future<FeeObject> get fees async {
final feePerTx = (await estimateFeeFor(
Amount(
rawValue: BigInt.one,
fractionDigits: cryptoCurrency.fractionDigits,
),
42))
.raw
.toInt();
Logging.instance.log("feePerTx:$feePerTx", level: LogLevel.Info);
return FeeObject(
numberOfBlocksFast: 10,
numberOfBlocksAverage: 10,
numberOfBlocksSlow: 10,
fast: feePerTx,
medium: feePerTx,
slow: feePerTx,
);
}
@override
Future<TxData> prepareSend({required TxData txData}) {
// TODO: implement prepareSend
throw UnimplementedError();
Future<bool> pingCheck() async {
final currentNode = getCurrentNode();
return await TezosRpcAPI.testNetworkConnection(
nodeInfo: (
host: currentNode.host,
port: currentNode.port,
),
);
}
@override
Future<void> recover({required bool isRescan}) {
// TODO: implement recover
throw UnimplementedError();
Future<void> recover({required bool isRescan}) async {
await refreshMutex.protect(() async {
if (isRescan) {
await mainDB.deleteWalletBlockchainData(walletId);
}
final address = await _getAddressFromMnemonic();
await mainDB.updateOrPutAddresses([address]);
await Future.wait([
updateBalance(),
updateTransactions(),
updateChainHeight(),
]);
});
}
@override
Future<void> updateBalance() {
// TODO: implement updateBalance
throw UnimplementedError();
Future<void> updateBalance() async {
try {
final currentNode = _xtzNode ?? getCurrentNode();
final balance = await TezosRpcAPI.getBalance(
nodeInfo: (host: currentNode.host, port: currentNode.port),
address: (await getCurrentReceivingAddress())!.value,
);
final balanceInAmount = Amount(
rawValue: balance!,
fractionDigits: cryptoCurrency.fractionDigits,
);
final newBalance = Balance(
total: balanceInAmount,
spendable: balanceInAmount,
blockedTotal: Amount(
rawValue: BigInt.zero,
fractionDigits: cryptoCurrency.fractionDigits,
),
pendingSpendable: Amount(
rawValue: BigInt.zero,
fractionDigits: cryptoCurrency.fractionDigits,
),
);
await info.updateBalance(newBalance: newBalance, isar: mainDB.isar);
} catch (e, s) {
Logging.instance.log(
"Error getting balance in tezos_wallet.dart: $e\n$s}",
level: LogLevel.Error,
);
}
}
@override
Future<void> updateChainHeight() {
// TODO: implement updateChainHeight
throw UnimplementedError();
Future<void> updateChainHeight() async {
try {
final currentNode = _xtzNode ?? getCurrentNode();
final height = await TezosRpcAPI.getChainHeight(
nodeInfo: (
host: currentNode.host,
port: currentNode.port,
),
);
await info.updateCachedChainHeight(
newHeight: height!,
isar: mainDB.isar,
);
} catch (e, s) {
Logging.instance.log(
"Error occurred in tezos_wallet.dart while getting"
" chain height for tezos: $e\n$s}",
level: LogLevel.Error,
);
}
}
@override
Future<void> updateNode() {
// TODO: implement updateNode
throw UnimplementedError();
Future<void> updateNode() async {
_xtzNode = NodeService(secureStorageInterface: secureStorageInterface)
.getPrimaryNodeFor(coin: info.coin) ??
DefaultNodes.getNodeFor(info.coin);
await refresh();
}
@override
Future<void> updateTransactions() {
// TODO: implement updateTransactions
throw UnimplementedError();
NodeModel getCurrentNode() {
return _xtzNode ??
NodeService(secureStorageInterface: secureStorageInterface)
.getPrimaryNodeFor(coin: info.coin) ??
DefaultNodes.getNodeFor(info.coin);
}
@override
Future<void> updateUTXOs() {
// TODO: implement updateUTXOs
throw UnimplementedError();
Future<void> updateTransactions() async {
// TODO: optimize updateTransactions
final myAddress = (await getCurrentReceivingAddress())!;
List<TezosTransaction>? txs =
await TezosAPI.getTransactions(myAddress.value);
Logging.instance.log("Transactions: $txs", level: LogLevel.Info);
if (txs == null || txs.isEmpty) {
return;
}
List<Tuple2<Transaction, Address>> transactions = [];
for (final theTx in txs) {
final TransactionType txType;
if (myAddress.value == theTx.senderAddress) {
txType = TransactionType.outgoing;
} else if (myAddress.value == theTx.receiverAddress) {
if (myAddress.value == theTx.senderAddress) {
txType = TransactionType.sentToSelf;
} else {
txType = TransactionType.incoming;
}
} else {
txType = TransactionType.unknown;
}
var transaction = Transaction(
walletId: walletId,
txid: theTx.hash,
timestamp: theTx.timestamp,
type: txType,
subType: TransactionSubType.none,
amount: theTx.amountInMicroTez,
amountString: Amount(
rawValue: BigInt.parse(theTx.amountInMicroTez.toString()),
fractionDigits: cryptoCurrency.fractionDigits,
).toJsonString(),
fee: theTx.feeInMicroTez,
height: theTx.height,
isCancelled: false,
isLelantus: false,
slateId: "",
otherData: "",
inputs: [],
outputs: [],
nonce: 0,
numberOfMessages: null,
);
final Address theAddress;
switch (txType) {
case TransactionType.incoming:
case TransactionType.sentToSelf:
theAddress = myAddress;
break;
case TransactionType.outgoing:
case TransactionType.unknown:
theAddress = Address(
walletId: walletId,
value: theTx.receiverAddress,
publicKey: [],
derivationIndex: 0,
derivationPath: null,
type: AddressType.unknown,
subType: AddressSubType.unknown,
);
break;
}
transactions.add(Tuple2(transaction, theAddress));
}
await mainDB.addNewTransactionData(transactions, walletId);
}
@override
Future<void> updateUTXOs() async {
// do nothing. Not used in tezos
}
}