mirror of
https://github.com/Such-Software/hash-wallet.git
synced 2026-10-17 05:41:29 +02:00
2060 lines
76 KiB
Dart
2060 lines
76 KiB
Dart
import 'dart:io';
|
|
|
|
const bitcoinOutputPath = 'lib/bitcoin/bitcoin.dart';
|
|
const moneroOutputPath = 'lib/monero/monero.dart';
|
|
const bitcoinCashOutputPath = 'lib/bitcoin_cash/bitcoin_cash.dart';
|
|
const nanoOutputPath = 'lib/nano/nano.dart';
|
|
const solanaOutputPath = 'lib/solana/solana.dart';
|
|
const tronOutputPath = 'lib/tron/tron.dart';
|
|
const wowneroOutputPath = 'lib/wownero/wownero.dart';
|
|
const zanoOutputPath = 'lib/zano/zano.dart';
|
|
const decredOutputPath = 'lib/decred/decred.dart';
|
|
const dogecoinOutputPath = 'lib/dogecoin/dogecoin.dart';
|
|
const evmOutputPath = 'lib/evm/evm.dart';
|
|
const zcashOutputPath = 'lib/zcash/zcash.dart';
|
|
const walletTypesPath = 'lib/wallet_types.g.dart';
|
|
const secureStoragePath = 'lib/core/secure_storage.dart';
|
|
const pubspecDefaultPath = 'pubspec_default.yaml';
|
|
const pubspecOutputPath = 'pubspec.yaml';
|
|
|
|
Future<void> main(List<String> args) async {
|
|
const prefix = '--';
|
|
final hasBitcoin = args.contains('${prefix}bitcoin');
|
|
final hasMonero = args.contains('${prefix}monero');
|
|
final hasEthereum = args.contains('${prefix}ethereum');
|
|
final hasBitcoinCash = args.contains('${prefix}bitcoinCash');
|
|
final hasNano = args.contains('${prefix}nano');
|
|
final hasBanano = args.contains('${prefix}banano');
|
|
final hasPolygon = args.contains('${prefix}polygon');
|
|
final hasSolana = args.contains('${prefix}solana');
|
|
final hasTron = args.contains('${prefix}tron');
|
|
final hasWownero = args.contains('${prefix}wownero');
|
|
final hasZano = args.contains('${prefix}zano');
|
|
final hasDecred = args.contains('${prefix}decred');
|
|
final hasDogecoin = args.contains('${prefix}dogecoin');
|
|
final hasBase = args.contains('${prefix}base');
|
|
final hasArbitrum = args.contains('${prefix}arbitrum');
|
|
final hasBsc = args.contains('${prefix}bsc');
|
|
final hasZcash = args.contains('${prefix}zcash');
|
|
final hasEVM = hasEthereum || hasPolygon || hasBase || hasArbitrum || hasBsc;
|
|
final excludeFlutterSecureStorage = args.contains('${prefix}excludeFlutterSecureStorage');
|
|
|
|
await generateBitcoin(hasBitcoin);
|
|
await generateMonero(hasMonero);
|
|
await generateBitcoinCash(hasBitcoinCash);
|
|
await generateNano(hasNano);
|
|
await generateSolana(hasSolana);
|
|
await generateTron(hasTron);
|
|
await generateWownero(hasWownero);
|
|
await generateZano(hasZano);
|
|
// await generateBanano(hasEthereum);
|
|
await generateDecred(hasDecred);
|
|
await generateDogecoin(hasDogecoin);
|
|
await generateEVM(hasEVM);
|
|
await generateZcash(hasZcash);
|
|
|
|
await generatePubspec(
|
|
hasMonero: hasMonero,
|
|
hasBitcoin: hasBitcoin,
|
|
hasEthereum: hasEthereum,
|
|
hasNano: hasNano,
|
|
hasBanano: hasBanano,
|
|
hasBitcoinCash: hasBitcoinCash,
|
|
hasFlutterSecureStorage: !excludeFlutterSecureStorage,
|
|
hasPolygon: hasPolygon,
|
|
hasSolana: hasSolana,
|
|
hasTron: hasTron,
|
|
hasWownero: hasWownero,
|
|
hasZano: hasZano,
|
|
hasDecred: hasDecred,
|
|
hasDogecoin: hasDogecoin,
|
|
hasBase: hasBase,
|
|
hasArbitrum: hasArbitrum,
|
|
hasBsc: hasBsc,
|
|
hasZcash: hasZcash,
|
|
);
|
|
await generateWalletTypes(
|
|
hasMonero: hasMonero,
|
|
hasBitcoin: hasBitcoin,
|
|
hasEthereum: hasEthereum,
|
|
hasNano: hasNano,
|
|
hasBanano: hasBanano,
|
|
hasBitcoinCash: hasBitcoinCash,
|
|
hasPolygon: hasPolygon,
|
|
hasSolana: hasSolana,
|
|
hasTron: hasTron,
|
|
hasWownero: hasWownero,
|
|
hasZano: hasZano,
|
|
hasDecred: hasDecred,
|
|
hasDogecoin: hasDogecoin,
|
|
hasBase: hasBase,
|
|
hasArbitrum: hasArbitrum,
|
|
hasBsc: hasBsc,
|
|
hasZcash: hasZcash,
|
|
);
|
|
await injectSecureStorage(!excludeFlutterSecureStorage);
|
|
}
|
|
|
|
Future<void> generateBitcoin(bool hasImplementation) async {
|
|
final outputFile = File(bitcoinOutputPath);
|
|
const bitcoinCommonHeaders = """
|
|
import 'dart:io' show Platform;
|
|
import 'dart:typed_data';
|
|
import 'package:bitcoin_base/bitcoin_base.dart';
|
|
import 'package:cake_wallet/view_model/hardware_wallet/ledger_view_model.dart';
|
|
import 'package:cake_wallet/view_model/send/output.dart';
|
|
import 'package:cw_core/hardware/hardware_account_data.dart';
|
|
import 'package:cw_core/hardware/hardware_wallet_service.dart';
|
|
import 'package:cw_core/node.dart';
|
|
import 'package:cw_core/payjoin_session.dart';
|
|
import 'package:cw_core/output_info.dart';
|
|
import 'package:cw_core/pending_transaction.dart';
|
|
import 'package:cw_core/receive_page_option.dart';
|
|
import 'package:cw_core/transaction_info.dart';
|
|
import 'package:cw_core/transaction_priority.dart';
|
|
import 'package:cw_core/unspent_coin_type.dart';
|
|
import 'package:cw_core/unspent_coins_info.dart';
|
|
import 'package:cw_core/unspent_transaction_output.dart';
|
|
import 'package:cw_core/wallet_base.dart';
|
|
import 'package:cw_core/wallet_credentials.dart';
|
|
import 'package:cw_core/wallet_info.dart';
|
|
import 'package:cw_core/wallet_service.dart';
|
|
import 'package:cw_core/wallet_type.dart';
|
|
import 'package:cw_core/utils/print_verbose.dart';
|
|
import 'package:cw_core/get_height_by_date.dart';
|
|
import 'package:hive/hive.dart';
|
|
import 'package:ledger_flutter_plus/ledger_flutter_plus.dart' as ledger;
|
|
import 'package:bitbox_flutter/bitbox_flutter.dart' as bitbox;
|
|
import 'package:trezor_connect/trezor_connect.dart' as trezor;
|
|
import 'package:blockchain_utils/blockchain_utils.dart';
|
|
import 'package:bip39/bip39.dart' as bip39;
|
|
""";
|
|
const bitcoinCWHeaders = """
|
|
import 'package:cw_bitcoin/utils.dart';
|
|
import 'package:cw_bitcoin/electrum_derivations.dart';
|
|
import 'package:cw_bitcoin/electrum.dart';
|
|
import 'package:cw_bitcoin/electrum_transaction_info.dart';
|
|
import 'package:cw_bitcoin/pending_bitcoin_transaction.dart';
|
|
import 'package:cw_bitcoin/bitcoin_receive_page_option.dart';
|
|
import 'package:cw_bitcoin/electrum_wallet.dart';
|
|
import 'package:cw_bitcoin/bitcoin_unspent.dart';
|
|
import 'package:cw_bitcoin/bitcoin_mnemonic.dart';
|
|
import 'package:cw_bitcoin/bitcoin_transaction_priority.dart';
|
|
import 'package:cw_bitcoin/bitcoin_wallet.dart';
|
|
import 'package:cw_bitcoin/bitcoin_wallet_service.dart';
|
|
import 'package:cw_bitcoin/bitcoin_wallet_creation_credentials.dart';
|
|
import 'package:cw_bitcoin/bitcoin_amount_format.dart';
|
|
import 'package:cw_bitcoin/bitcoin_address_record.dart';
|
|
import 'package:cw_bitcoin/bitcoin_wallet_addresses.dart';
|
|
import 'package:cw_bitcoin/bitcoin_transaction_credentials.dart';
|
|
import 'package:cw_bitcoin/lightning/pending_lightning_transaction.dart';
|
|
import 'package:cw_bitcoin/litecoin_wallet_service.dart';
|
|
import 'package:cw_bitcoin/litecoin_wallet.dart';
|
|
import 'package:cw_bitcoin/hardware/bitcoin_ledger_service.dart';
|
|
import 'package:cw_bitcoin/hardware/litecoin_ledger_service.dart';
|
|
import 'package:cw_bitcoin/hardware/bitbox_service.dart';
|
|
import 'package:cw_bitcoin/hardware/trezor_service.dart';
|
|
import 'package:mobx/mobx.dart';
|
|
import "package:breez_sdk_spark_flutter/src/rust/errors.dart";
|
|
""";
|
|
const bitcoinCwPart = "part 'cw_bitcoin.dart';";
|
|
const bitcoinContent = """
|
|
|
|
class ElectrumSubAddress {
|
|
ElectrumSubAddress({
|
|
required this.id,
|
|
required this.name,
|
|
required this.address,
|
|
required this.txCount,
|
|
required this.balance,
|
|
required this.isChange,
|
|
this.isLegacyDerivation = false});
|
|
final int id;
|
|
final String name;
|
|
final String address;
|
|
final int txCount;
|
|
final int balance;
|
|
final bool isChange;
|
|
final bool isLegacyDerivation;
|
|
}
|
|
|
|
abstract class Bitcoin {
|
|
TransactionPriority getMediumTransactionPriority();
|
|
|
|
WalletCredentials createBitcoinRestoreWalletFromSeedCredentials({
|
|
required String name,
|
|
required String mnemonic,
|
|
required String password,
|
|
required DerivationType derivationType,
|
|
required String derivationPath,
|
|
String? passphrase,
|
|
});
|
|
WalletCredentials createBitcoinRestoreWalletFromWIFCredentials({required String name, required String password, required String wif, WalletInfo? walletInfo});
|
|
WalletCredentials createBitcoinWalletFromKeys({required String name, required String password, required String xpub, HardwareWalletType? hardwareWalletType});
|
|
WalletCredentials createLitecoinWalletFromKeys({required String name, required String password, required String xpub, required String scanSecret, required String spendPubkey, HardwareWalletType? hardwareWalletType});
|
|
WalletCredentials createBitcoinNewWalletCredentials({required String name, WalletInfo? walletInfo, String? password, String? passphrase, String? mnemonic});
|
|
WalletCredentials createBitcoinHardwareWalletCredentials({required String name, required HardwareAccountData accountData, WalletInfo? walletInfo});
|
|
List<String> getWordList();
|
|
Map<String, String> getWalletKeys(Object wallet);
|
|
List<TransactionPriority> getTransactionPriorities();
|
|
List<TransactionPriority> getLitecoinTransactionPriorities();
|
|
TransactionPriority deserializeBitcoinTransactionPriority(int raw);
|
|
TransactionPriority deserializeLitecoinTransactionPriority(int raw);
|
|
int getFeeRate(Object wallet, TransactionPriority priority);
|
|
Future<void> generateNewAddress(Object wallet, String label);
|
|
Future<void> updateAddress(Object wallet,String address, String label);
|
|
Object createBitcoinTransactionCredentials(List<Output> outputs, {required TransactionPriority priority, int? feeRate, UnspentCoinType coinTypeToSpendFrom = UnspentCoinType.any, String? payjoinUri});
|
|
|
|
String getAddress(Object wallet);
|
|
List<ElectrumSubAddress> getSilentPaymentAddresses(Object wallet);
|
|
List<ElectrumSubAddress> getSilentPaymentReceivedAddresses(Object wallet);
|
|
|
|
Future<int> estimateFakeSendAllTxAmount(Object wallet, TransactionPriority priority,
|
|
{UnspentCoinType coinTypeToSpendFrom = UnspentCoinType.any});
|
|
List<ElectrumSubAddress> getSubAddresses(Object wallet);
|
|
|
|
String formatterBitcoinAmountToString({required int amount});
|
|
double formatterBitcoinAmountToDouble({required int amount});
|
|
int formatterStringDoubleToBitcoinAmount(String amount);
|
|
String bitcoinTransactionPriorityWithLabel(TransactionPriority priority, int rate, {int? customRate});
|
|
|
|
List<Unspent> getUnspents(Object wallet, {UnspentCoinType coinTypeToSpendFrom = UnspentCoinType.any});
|
|
Future<void> updateUnspents(Object wallet);
|
|
WalletService createBitcoinWalletService(
|
|
Box<UnspentCoinsInfo> unspentCoinSource, Box<PayjoinSession> payjoinSessionSource, bool isDirect);
|
|
WalletService createLitecoinWalletService(Box<UnspentCoinsInfo> unspentCoinSource, bool isDirect);
|
|
TransactionPriority getBitcoinTransactionPriorityMedium();
|
|
TransactionPriority getBitcoinTransactionPriorityCustom();
|
|
TransactionPriority getLitecoinTransactionPriorityMedium();
|
|
TransactionPriority getBitcoinTransactionPrioritySlow();
|
|
TransactionPriority getLitecoinTransactionPrioritySlow();
|
|
Future<List<DerivationType>> compareDerivationMethods(
|
|
{required String mnemonic, required Node node});
|
|
Future<List<DerivationInfo>> getDerivationsFromMnemonic(
|
|
{required String mnemonic, required Node node, String? passphrase});
|
|
Map<DerivationType, List<DerivationInfo>> getElectrumDerivations();
|
|
Future<void> setAddressType(Object wallet, dynamic option);
|
|
ReceivePageOption getSelectedAddressType(Object wallet);
|
|
BitcoinAddressType getBitcoinAddressType(ReceivePageOption option);
|
|
ReceivePageOption getBitcoinLightningReceivePageOption();
|
|
ReceivePageOption getBitcoinSegwitPageOption();
|
|
ReceivePageOption getLitecoinMwebReceivePageOption();
|
|
bool isPayjoinAvailable(Object wallet);
|
|
bool hasSelectedSilentPayments(Object wallet);
|
|
bool isBitcoinReceivePageOption(ReceivePageOption option);
|
|
BitcoinAddressType getOptionToType(ReceivePageOption option);
|
|
bool hasTaprootInput(PendingTransaction pendingTransaction);
|
|
bool getScanningActive(Object wallet);
|
|
Future<void> setScanningActive(Object wallet, bool active);
|
|
Future<void> setIsAlwaysScanningSP(Object wallet, bool active);
|
|
bool getIsAlwaysScanningSP(Object wallet);
|
|
bool isTestnet(Object wallet);
|
|
|
|
Future<PendingTransaction> replaceByFee(Object wallet, String transactionHash, String fee);
|
|
Future<String?> canReplaceByFee(Object wallet, Object tx);
|
|
int getTransactionVSize(Object wallet, String txHex);
|
|
Future<bool> isChangeSufficientForFee(Object wallet, String txId, String newFee);
|
|
int getFeeAmountForPriority(Object wallet, TransactionPriority priority, int inputsCount, int outputsCount, {int? size});
|
|
int getEstimatedFeeWithFeeRate(Object wallet, int feeRate, int? amount,
|
|
{int? outputsCount, int? size});
|
|
int feeAmountWithFeeRate(Object wallet, int feeRate, int inputsCount, int outputsCount, {int? size});
|
|
Future<bool> checkIfMempoolAPIIsEnabled(Object wallet);
|
|
Future<int> getHeightByDate({required DateTime date, bool? bitcoinMempoolAPIEnabled});
|
|
int getLitecoinHeightByDate({required DateTime date});
|
|
Future<void> rescan(Object wallet, {required int height, bool? doSingleScan});
|
|
Future<bool> getNodeIsElectrsSPEnabled(Object wallet);
|
|
void deleteSilentPaymentAddress(Object wallet, String address);
|
|
Future<void> updateFeeRates(Object wallet);
|
|
int getMaxCustomFeeRate(Object wallet);
|
|
Future<void> setHardwareWalletService(WalletBase wallet, HardwareWalletService service);
|
|
HardwareWalletService getLedgerHardwareWalletService(ledger.LedgerConnection connection, bool isBitcoin);
|
|
HardwareWalletService getBitboxHardwareWalletService(bitbox.BitboxManager manager, bool isBitcoin);
|
|
HardwareWalletService getTrezorHardwareWalletService(trezor.TrezorConnect connect, bool isBitcoin);
|
|
List<Output> updateOutputs(PendingTransaction pendingTransaction, List<Output> outputs);
|
|
bool txIsReceivedSilentPayment(TransactionInfo txInfo);
|
|
bool txIsMweb(TransactionInfo txInfo);
|
|
Future<void> setMwebEnabled(Object wallet, bool enabled);
|
|
bool getMwebEnabled(Object wallet);
|
|
String? getUnusedMwebAddress(Object wallet);
|
|
String? getUnusedSegwitAddress(Object wallet);
|
|
Future<String?> getUnusedSpakDepositAddress(Object wallet);
|
|
Future<void> commitPsbtUR(Object wallet, List<String> urCodes);
|
|
|
|
void updatePayjoinState(Object wallet, bool state);
|
|
String getPayjoinEndpoint(Object wallet);
|
|
void resumePayjoinSessions(Object wallet);
|
|
void stopPayjoinSessions(Object wallet);
|
|
Map<String, String> getSilentPaymentKeys(Object wallet);
|
|
List<String>? getTransactionAddresses(Object wallet, TransactionInfo tx);
|
|
String getNetworkName(Object wallet);
|
|
bool useLightning(Object wallet);
|
|
void updateUseLightning(Object wallet, bool value);
|
|
Future<void> setLightningUsername(Object wallet, String username);
|
|
Future<String?> getLightningUsername(Object wallet);
|
|
Future<String?> getLightningInvoice(Object wallet, BigInt amount);
|
|
String? getBreezSdkError(Object exception);
|
|
}
|
|
""";
|
|
|
|
const bitcoinEmptyDefinition = 'Bitcoin? bitcoin;\n';
|
|
const bitcoinCWDefinition = 'Bitcoin? bitcoin = CWBitcoin();\n';
|
|
|
|
final output = '$bitcoinCommonHeaders\n' +
|
|
(hasImplementation ? '$bitcoinCWHeaders\n' : '\n') +
|
|
(hasImplementation ? '$bitcoinCwPart\n\n' : '\n') +
|
|
(hasImplementation ? bitcoinCWDefinition : bitcoinEmptyDefinition) +
|
|
'\n' +
|
|
bitcoinContent;
|
|
|
|
if (outputFile.existsSync()) {
|
|
await outputFile.delete();
|
|
}
|
|
|
|
await outputFile.writeAsString(output);
|
|
}
|
|
|
|
Future<void> generateMonero(bool hasImplementation) async {
|
|
final outputFile = File(moneroOutputPath);
|
|
const moneroCommonHeaders = """
|
|
import 'package:cw_core/unspent_transaction_output.dart';
|
|
import 'package:cw_core/unspent_coins_info.dart';
|
|
import 'package:mobx/mobx.dart';
|
|
import 'package:cw_core/wallet_credentials.dart';
|
|
import 'package:cw_core/wallet_info.dart';
|
|
import 'package:cw_core/transaction_priority.dart';
|
|
import 'package:cw_core/transaction_history.dart';
|
|
import 'package:cw_core/transaction_info.dart';
|
|
import 'package:cw_core/balance.dart';
|
|
import 'package:cw_core/output_info.dart';
|
|
import 'package:cake_wallet/view_model/send/output.dart';
|
|
import 'package:cw_core/wallet_service.dart';
|
|
import 'package:hive/hive.dart';
|
|
import 'package:ledger_flutter_plus/ledger_flutter_plus.dart' as ledger;
|
|
import 'package:polyseed/polyseed.dart';""";
|
|
const moneroCWHeaders = """
|
|
import 'package:cw_core/account.dart' as monero_account;
|
|
import 'package:cw_core/get_height_by_date.dart';
|
|
import 'package:cw_core/monero_amount_format.dart';
|
|
import 'package:cw_core/monero_transaction_priority.dart';
|
|
import 'package:cw_monero/api/wallet_manager.dart';
|
|
import 'package:cw_monero/api/wallet.dart' as monero_wallet_api;
|
|
import 'package:cw_monero/ledger.dart';
|
|
import 'package:cw_monero/monero_unspent.dart';
|
|
import 'package:cw_monero/api/account_list.dart';
|
|
import 'package:cw_monero/monero_wallet_service.dart';
|
|
import 'package:cw_monero/monero_wallet.dart';
|
|
import 'package:cw_monero/monero_transaction_info.dart';
|
|
import 'package:cw_monero/monero_transaction_creation_credentials.dart';
|
|
import 'package:cw_monero/mnemonics/english.dart';
|
|
import 'package:cw_monero/mnemonics/chinese_simplified.dart';
|
|
import 'package:cw_monero/mnemonics/dutch.dart';
|
|
import 'package:cw_monero/mnemonics/german.dart';
|
|
import 'package:cw_monero/mnemonics/japanese.dart';
|
|
import 'package:cw_monero/mnemonics/russian.dart';
|
|
import 'package:cw_monero/mnemonics/spanish.dart';
|
|
import 'package:cw_monero/mnemonics/portuguese.dart';
|
|
import 'package:cw_monero/mnemonics/french.dart';
|
|
import 'package:cw_monero/mnemonics/italian.dart';
|
|
import 'package:cw_monero/pending_monero_transaction.dart';
|
|
""";
|
|
const moneroCwPart = "part 'cw_monero.dart';";
|
|
const moneroContent = """
|
|
class Account {
|
|
Account({required this.id, required this.label, this.balance});
|
|
final int id;
|
|
final String label;
|
|
final String? balance;
|
|
}
|
|
|
|
class Subaddress {
|
|
Subaddress({
|
|
required this.id,
|
|
required this.label,
|
|
required this.address,
|
|
required this.received,
|
|
required this.txCount});
|
|
final int id;
|
|
final String label;
|
|
final String address;
|
|
final String? received;
|
|
final int txCount;
|
|
}
|
|
|
|
class MoneroBalance extends Balance {
|
|
MoneroBalance({required this.fullBalance, required this.unlockedBalance})
|
|
: formattedFullBalance = monero!.formatterMoneroAmountToString(amount: fullBalance),
|
|
formattedUnlockedBalance =
|
|
monero!.formatterMoneroAmountToString(amount: unlockedBalance),
|
|
super.fromInt(unlockedBalance, fullBalance);
|
|
|
|
MoneroBalance.fromString(
|
|
{required this.formattedFullBalance,
|
|
required this.formattedUnlockedBalance})
|
|
: fullBalance = monero!.formatterMoneroParseAmount(amount: formattedFullBalance),
|
|
unlockedBalance = monero!.formatterMoneroParseAmount(amount: formattedUnlockedBalance),
|
|
super.fromInt(monero!.formatterMoneroParseAmount(amount: formattedUnlockedBalance),
|
|
monero!.formatterMoneroParseAmount(amount: formattedFullBalance));
|
|
|
|
final int fullBalance;
|
|
final int unlockedBalance;
|
|
final String formattedFullBalance;
|
|
final String formattedUnlockedBalance;
|
|
|
|
@override
|
|
String get formattedAvailableBalance => formattedUnlockedBalance;
|
|
|
|
@override
|
|
String get formattedAdditionalBalance => formattedFullBalance;
|
|
}
|
|
|
|
abstract class MoneroWalletDetails {
|
|
@observable
|
|
late Account account;
|
|
|
|
@observable
|
|
late MoneroBalance balance;
|
|
}
|
|
|
|
abstract class Monero {
|
|
MoneroAccountList getAccountList(Object wallet);
|
|
|
|
MoneroSubaddressList getSubaddressList(Object wallet);
|
|
|
|
TransactionHistoryBase getTransactionHistory(Object wallet);
|
|
|
|
MoneroWalletDetails getMoneroWalletDetails(Object wallet);
|
|
|
|
String getTransactionAddress(Object wallet, int accountIndex, int addressIndex);
|
|
|
|
String getSubaddressLabel(Object wallet, int accountIndex, int addressIndex);
|
|
|
|
int getHeightByDate({required DateTime date});
|
|
TransactionPriority getDefaultTransactionPriority();
|
|
TransactionPriority getMoneroTransactionPrioritySlow();
|
|
TransactionPriority getMoneroTransactionPriorityAutomatic();
|
|
TransactionPriority deserializeMoneroTransactionPriority({required int raw});
|
|
List<TransactionPriority> getTransactionPriorities();
|
|
List<String> getMoneroWordList(String language);
|
|
|
|
List<Unspent> getUnspents(Object wallet);
|
|
Future<void> updateUnspents(Object wallet);
|
|
|
|
Future<int> getCurrentHeight();
|
|
|
|
Future<bool> commitTransactionUR(Object wallet, String ur);
|
|
|
|
Map<String, String> exportOutputsUR(Object wallet);
|
|
|
|
bool needExportOutputs(Object wallet, int amount);
|
|
|
|
bool importKeyImagesUR(Object wallet, String ur);
|
|
|
|
WalletCredentials createMoneroRestoreWalletFromKeysCredentials({
|
|
required String name,
|
|
required String spendKey,
|
|
required String viewKey,
|
|
required String address,
|
|
required String password,
|
|
required String language,
|
|
HardwareWalletType? hardwareWalletType,
|
|
required int height});
|
|
WalletCredentials createMoneroRestoreWalletFromSeedCredentials({required String name, required String password, required String passphrase, required int height, required String mnemonic});
|
|
WalletCredentials createMoneroRestoreWalletFromHardwareCredentials({required String name, required String password, required int height, required ledger.LedgerConnection ledgerConnection});
|
|
WalletCredentials createMoneroNewWalletCredentials({required String name, required String language, required int seedType, required String? passphrase, String? password, String? mnemonic});
|
|
Map<String, String> getKeys(Object wallet);
|
|
int? getRestoreHeight(Object wallet);
|
|
Object createMoneroTransactionCreationCredentials({required List<Output> outputs, required TransactionPriority priority});
|
|
Object createMoneroTransactionCreationCredentialsRaw({required List<OutputInfo> outputs, required TransactionPriority priority});
|
|
String formatterMoneroAmountToString({required int amount});
|
|
double formatterMoneroAmountToDouble({required int amount});
|
|
int formatterMoneroParseAmount({required String amount});
|
|
Account getCurrentAccount(Object wallet);
|
|
void monerocCheck();
|
|
bool isViewOnly();
|
|
void setCurrentAccount(Object wallet, int id, String label, String? balance);
|
|
void onStartup();
|
|
int getTransactionInfoAccountId(TransactionInfo tx);
|
|
WalletService createMoneroWalletService(Box<UnspentCoinsInfo> unspentCoinSource);
|
|
Map<String, String> pendingTransactionInfo(Object transaction);
|
|
Future<void> setLedgerConnection(Object wallet, ledger.LedgerConnection connection);
|
|
void resetLedgerConnection();
|
|
void setGlobalLedgerConnection(ledger.LedgerConnection connection);
|
|
String? getLastLedgerCommand();
|
|
Map<String, List<int>> debugCallLength();
|
|
Map<String, dynamic> getWalletCacheDebug();
|
|
}
|
|
|
|
abstract class MoneroSubaddressList {
|
|
ObservableList<Subaddress> get subaddresses;
|
|
void update(Object wallet, {required int accountIndex});
|
|
void refresh(Object wallet, {required int accountIndex});
|
|
List<Subaddress> getAll(Object wallet);
|
|
Future<void> addSubaddress(Object wallet, {required int accountIndex, required String label});
|
|
Future<void> setLabelSubaddress(Object wallet,
|
|
{required int accountIndex, required int addressIndex, required String label});
|
|
}
|
|
|
|
abstract class MoneroAccountList {
|
|
ObservableList<Account> get accounts;
|
|
void update(Object wallet);
|
|
void refresh(Object wallet);
|
|
List<Account> getAll(Object wallet);
|
|
Future<void> addAccount(Object wallet, {required String label});
|
|
Future<void> setLabelAccount(Object wallet, {required int accountIndex, required String label});
|
|
}
|
|
""";
|
|
|
|
const moneroEmptyDefinition = 'Monero? monero;\n';
|
|
const moneroCWDefinition = 'Monero? monero = CWMonero();\n';
|
|
|
|
final output = '$moneroCommonHeaders\n' +
|
|
(hasImplementation ? '$moneroCWHeaders\n' : '\n') +
|
|
(hasImplementation ? '$moneroCwPart\n\n' : '\n') +
|
|
(hasImplementation ? moneroCWDefinition : moneroEmptyDefinition) +
|
|
'\n' +
|
|
moneroContent;
|
|
|
|
if (outputFile.existsSync()) {
|
|
await outputFile.delete();
|
|
}
|
|
|
|
await outputFile.writeAsString(output);
|
|
}
|
|
|
|
Future<void> generateWownero(bool hasImplementation) async {
|
|
final outputFile = File(wowneroOutputPath);
|
|
const wowneroCommonHeaders = """
|
|
import 'package:cw_core/unspent_transaction_output.dart';
|
|
import 'package:cw_core/unspent_coins_info.dart';
|
|
import 'package:mobx/mobx.dart';
|
|
import 'package:cw_core/wallet_credentials.dart';
|
|
import 'package:cw_core/wallet_info.dart';
|
|
import 'package:cw_core/transaction_priority.dart';
|
|
import 'package:cw_core/transaction_history.dart';
|
|
import 'package:cw_core/transaction_info.dart';
|
|
import 'package:cw_core/balance.dart';
|
|
import 'package:cw_core/output_info.dart';
|
|
import 'package:cake_wallet/view_model/send/output.dart';
|
|
import 'package:cw_core/crypto_currency.dart';
|
|
import 'package:cake_wallet/core/key_service.dart';
|
|
import 'package:cake_wallet/core/secure_storage.dart';
|
|
import 'package:cake_wallet/entities/haven_seed_store.dart';
|
|
import 'package:cw_core/cake_hive.dart';
|
|
import 'package:cw_core/wallet_info.dart';
|
|
import 'package:cw_core/wallet_type.dart';
|
|
import 'package:cw_core/wallet_service.dart';
|
|
import 'package:hive/hive.dart';
|
|
import 'package:polyseed/polyseed.dart';""";
|
|
const wowneroCWHeaders = """
|
|
import 'package:cw_core/get_height_by_date.dart';
|
|
import 'package:cw_core/wownero_amount_format.dart';
|
|
import 'package:cw_core/monero_transaction_priority.dart';
|
|
import 'package:cw_wownero/wownero_unspent.dart';
|
|
import 'package:cw_wownero/wownero_wallet_service.dart';
|
|
import 'package:cw_wownero/wownero_wallet.dart';
|
|
import 'package:cw_wownero/wownero_transaction_info.dart';
|
|
import 'package:cw_wownero/wownero_transaction_creation_credentials.dart';
|
|
import 'package:cw_core/account.dart' as wownero_account;
|
|
import 'package:cw_wownero/api/wallet.dart' as wownero_wallet_api;
|
|
import 'package:cw_wownero/api/wallet_manager.dart';
|
|
import 'package:cw_wownero/mnemonics/english.dart';
|
|
import 'package:cw_wownero/mnemonics/chinese_simplified.dart';
|
|
import 'package:cw_wownero/mnemonics/dutch.dart';
|
|
import 'package:cw_wownero/mnemonics/german.dart';
|
|
import 'package:cw_wownero/mnemonics/japanese.dart';
|
|
import 'package:cw_wownero/mnemonics/russian.dart';
|
|
import 'package:cw_wownero/mnemonics/spanish.dart';
|
|
import 'package:cw_wownero/mnemonics/portuguese.dart';
|
|
import 'package:cw_wownero/mnemonics/french.dart';
|
|
import 'package:cw_wownero/mnemonics/italian.dart';
|
|
import 'package:cw_wownero/pending_wownero_transaction.dart';
|
|
""";
|
|
const wowneroCwPart = "part 'cw_wownero.dart';";
|
|
const wowneroContent = """
|
|
class Account {
|
|
Account({required this.id, required this.label, this.balance});
|
|
final int id;
|
|
final String label;
|
|
final String? balance;
|
|
}
|
|
|
|
class Subaddress {
|
|
Subaddress({
|
|
required this.id,
|
|
required this.label,
|
|
required this.address});
|
|
final int id;
|
|
final String label;
|
|
final String address;
|
|
}
|
|
|
|
class WowneroBalance extends Balance {
|
|
WowneroBalance({required this.fullBalance, required this.unlockedBalance})
|
|
: formattedFullBalance = wownero!.formatterWowneroAmountToString(amount: fullBalance),
|
|
formattedUnlockedBalance =
|
|
wownero!.formatterWowneroAmountToString(amount: unlockedBalance),
|
|
super.fromInt(unlockedBalance, fullBalance);
|
|
|
|
WowneroBalance.fromString(
|
|
{required this.formattedFullBalance,
|
|
required this.formattedUnlockedBalance})
|
|
: fullBalance = wownero!.formatterWowneroParseAmount(amount: formattedFullBalance),
|
|
unlockedBalance = wownero!.formatterWowneroParseAmount(amount: formattedUnlockedBalance),
|
|
super.fromInt(wownero!.formatterWowneroParseAmount(amount: formattedUnlockedBalance),
|
|
wownero!.formatterWowneroParseAmount(amount: formattedFullBalance));
|
|
|
|
final int fullBalance;
|
|
final int unlockedBalance;
|
|
final String formattedFullBalance;
|
|
final String formattedUnlockedBalance;
|
|
|
|
@override
|
|
String get formattedAvailableBalance => formattedUnlockedBalance;
|
|
|
|
@override
|
|
String get formattedAdditionalBalance => formattedFullBalance;
|
|
}
|
|
|
|
abstract class WowneroWalletDetails {
|
|
@observable
|
|
late Account account;
|
|
|
|
@observable
|
|
late WowneroBalance balance;
|
|
}
|
|
|
|
abstract class Wownero {
|
|
WowneroAccountList getAccountList(Object wallet);
|
|
|
|
WowneroSubaddressList getSubaddressList(Object wallet);
|
|
|
|
TransactionHistoryBase getTransactionHistory(Object wallet);
|
|
|
|
WowneroWalletDetails getWowneroWalletDetails(Object wallet);
|
|
|
|
String getTransactionAddress(Object wallet, int accountIndex, int addressIndex);
|
|
|
|
String getSubaddressLabel(Object wallet, int accountIndex, int addressIndex);
|
|
|
|
int getHeightByDate({required DateTime date});
|
|
TransactionPriority getDefaultTransactionPriority();
|
|
TransactionPriority getWowneroTransactionPrioritySlow();
|
|
TransactionPriority getWowneroTransactionPriorityAutomatic();
|
|
TransactionPriority deserializeWowneroTransactionPriority({required int raw});
|
|
List<TransactionPriority> getTransactionPriorities();
|
|
List<String> getWowneroWordList(String language);
|
|
|
|
List<Unspent> getUnspents(Object wallet);
|
|
Future<void> updateUnspents(Object wallet);
|
|
|
|
Future<int> getCurrentHeight();
|
|
void wownerocCheck();
|
|
|
|
WalletCredentials createWowneroRestoreWalletFromKeysCredentials({
|
|
required String name,
|
|
required String spendKey,
|
|
required String viewKey,
|
|
required String address,
|
|
required String password,
|
|
required String language,
|
|
required int height});
|
|
WalletCredentials createWowneroRestoreWalletFromSeedCredentials({required String name, required String password, required String passphrase, required int height, required String mnemonic});
|
|
WalletCredentials createWowneroNewWalletCredentials({required String name, required String language, required bool isPolyseed, String? password, String? passphrase});
|
|
int? getRestoreHeight(Object wallet);
|
|
Map<String, String> getKeys(Object wallet);
|
|
Object createWowneroTransactionCreationCredentials({required List<Output> outputs, required TransactionPriority priority});
|
|
Object createWowneroTransactionCreationCredentialsRaw({required List<OutputInfo> outputs, required TransactionPriority priority});
|
|
String formatterWowneroAmountToString({required int amount});
|
|
double formatterWowneroAmountToDouble({required int amount});
|
|
int formatterWowneroParseAmount({required String amount});
|
|
Account getCurrentAccount(Object wallet);
|
|
void setCurrentAccount(Object wallet, int id, String label, String? balance);
|
|
void onStartup();
|
|
int getTransactionInfoAccountId(TransactionInfo tx);
|
|
WalletService createWowneroWalletService(Box<UnspentCoinsInfo> unspentCoinSource);
|
|
Map<String, String> pendingTransactionInfo(Object transaction);
|
|
String getLegacySeed(Object wallet, String langName);
|
|
Map<String, List<int>> debugCallLength();
|
|
Future<void> backupSeeds(Box<HavenSeedStore> havenSeedStore);
|
|
}
|
|
|
|
abstract class WowneroSubaddressList {
|
|
ObservableList<Subaddress> get subaddresses;
|
|
void update(Object wallet, {required int accountIndex});
|
|
void refresh(Object wallet, {required int accountIndex});
|
|
List<Subaddress> getAll(Object wallet);
|
|
Future<void> addSubaddress(Object wallet, {required int accountIndex, required String label});
|
|
Future<void> setLabelSubaddress(Object wallet,
|
|
{required int accountIndex, required int addressIndex, required String label});
|
|
}
|
|
|
|
abstract class WowneroAccountList {
|
|
ObservableList<Account> get accounts;
|
|
void update(Object wallet);
|
|
void refresh(Object wallet);
|
|
List<Account> getAll(Object wallet);
|
|
Future<void> addAccount(Object wallet, {required String label});
|
|
Future<void> setLabelAccount(Object wallet, {required int accountIndex, required String label});
|
|
}
|
|
""";
|
|
|
|
const wowneroEmptyDefinition = 'Wownero? wownero;\n';
|
|
const wowneroCWDefinition = 'Wownero? wownero = CWWownero();\n';
|
|
|
|
final output = '$wowneroCommonHeaders\n' +
|
|
(hasImplementation ? '$wowneroCWHeaders\n' : '\n') +
|
|
(hasImplementation ? '$wowneroCwPart\n\n' : '\n') +
|
|
(hasImplementation ? wowneroCWDefinition : wowneroEmptyDefinition) +
|
|
'\n' +
|
|
wowneroContent;
|
|
|
|
if (outputFile.existsSync()) {
|
|
await outputFile.delete();
|
|
}
|
|
|
|
await outputFile.writeAsString(output);
|
|
}
|
|
|
|
Future<void> generateBitcoinCash(bool hasImplementation) async {
|
|
final outputFile = File(bitcoinCashOutputPath);
|
|
const bitcoinCashCommonHeaders = """
|
|
import 'dart:typed_data';
|
|
|
|
import 'package:cw_core/unspent_transaction_output.dart';
|
|
import 'package:cw_core/transaction_priority.dart';
|
|
import 'package:cw_core/unspent_coins_info.dart';
|
|
import 'package:cw_core/wallet_credentials.dart';
|
|
import 'package:cw_core/wallet_info.dart';
|
|
import 'package:cw_core/wallet_service.dart';
|
|
import 'package:hive/hive.dart';
|
|
""";
|
|
const bitcoinCashCWHeaders = """
|
|
import 'package:cw_bitcoin_cash/cw_bitcoin_cash.dart';
|
|
import 'package:cw_bitcoin/bitcoin_transaction_priority.dart';
|
|
""";
|
|
const bitcoinCashCwPart = "part 'cw_bitcoin_cash.dart';";
|
|
const bitcoinCashContent = """
|
|
abstract class BitcoinCash {
|
|
String getCashAddrFormat(String address);
|
|
|
|
WalletService createBitcoinCashWalletService(
|
|
Box<UnspentCoinsInfo> unspentCoinSource, bool isDirect);
|
|
|
|
WalletCredentials createBitcoinCashNewWalletCredentials(
|
|
{required String name, WalletInfo? walletInfo, String? password, String? passphrase, String? mnemonic});
|
|
|
|
WalletCredentials createBitcoinCashRestoreWalletFromSeedCredentials(
|
|
{required String name, required String mnemonic, required String password, String? passphrase});
|
|
|
|
TransactionPriority deserializeBitcoinCashTransactionPriority(int raw);
|
|
|
|
TransactionPriority getDefaultTransactionPriority();
|
|
|
|
List<TransactionPriority> getTransactionPriorities();
|
|
|
|
TransactionPriority getBitcoinCashTransactionPrioritySlow();
|
|
}
|
|
""";
|
|
|
|
const bitcoinCashEmptyDefinition = 'BitcoinCash? bitcoinCash;\n';
|
|
const bitcoinCashCWDefinition = 'BitcoinCash? bitcoinCash = CWBitcoinCash();\n';
|
|
|
|
final output = '$bitcoinCashCommonHeaders\n' +
|
|
(hasImplementation ? '$bitcoinCashCWHeaders\n' : '\n') +
|
|
(hasImplementation ? '$bitcoinCashCwPart\n\n' : '\n') +
|
|
(hasImplementation ? bitcoinCashCWDefinition : bitcoinCashEmptyDefinition) +
|
|
'\n' +
|
|
bitcoinCashContent;
|
|
|
|
if (outputFile.existsSync()) {
|
|
await outputFile.delete();
|
|
}
|
|
|
|
await outputFile.writeAsString(output);
|
|
}
|
|
|
|
Future<void> generateNano(bool hasImplementation) async {
|
|
final outputFile = File(nanoOutputPath);
|
|
const nanoCommonHeaders = """
|
|
import 'package:cw_core/cake_hive.dart';
|
|
import 'package:cw_core/nano_account.dart';
|
|
import 'package:cw_core/account.dart';
|
|
import 'package:cw_core/node.dart';
|
|
import 'package:cw_core/wallet_credentials.dart';
|
|
import 'package:cw_core/wallet_info.dart';
|
|
import 'package:cw_core/transaction_info.dart';
|
|
import 'package:cw_core/transaction_history.dart';
|
|
import 'package:cw_core/wallet_service.dart';
|
|
import 'package:cw_core/output_info.dart';
|
|
import 'package:cw_core/nano_account_info_response.dart';
|
|
import 'package:cw_core/n2_node.dart';
|
|
import 'package:cw_core/utils/print_verbose.dart';
|
|
import 'package:mobx/mobx.dart';
|
|
import 'package:hive/hive.dart';
|
|
import 'package:cake_wallet/view_model/send/output.dart';
|
|
""";
|
|
const nanoCWHeaders = """
|
|
import 'package:cw_nano/nano_client.dart';
|
|
import 'package:cw_nano/nano_mnemonic.dart';
|
|
import 'package:cw_nano/nano_wallet.dart';
|
|
import 'package:cw_nano/nano_wallet_service.dart';
|
|
import 'package:cw_nano/nano_transaction_info.dart';
|
|
import 'package:cw_nano/nano_transaction_credentials.dart';
|
|
import 'package:cw_nano/nano_wallet_creation_credentials.dart';
|
|
// needed for nano_util:
|
|
import 'dart:convert';
|
|
import 'dart:typed_data';
|
|
import 'package:convert/convert.dart';
|
|
import "package:ed25519_hd_key/ed25519_hd_key.dart";
|
|
import 'package:libcrypto/libcrypto.dart';
|
|
import 'package:nanodart/nanodart.dart' as ND;
|
|
import 'package:nanoutil/nanoutil.dart';
|
|
""";
|
|
const nanoCwPart = "part 'cw_nano.dart';";
|
|
const nanoContent = """
|
|
abstract class Nano {
|
|
NanoAccountList getAccountList(Object wallet);
|
|
|
|
Account getCurrentAccount(Object wallet);
|
|
|
|
void setCurrentAccount(Object wallet, int id, String label, String? balance);
|
|
|
|
WalletService createNanoWalletService(bool isDirect);
|
|
|
|
WalletCredentials createNanoNewWalletCredentials({
|
|
required String name,
|
|
String? password,
|
|
String? mnemonic,
|
|
WalletInfo? walletInfo,
|
|
String? passphrase,
|
|
});
|
|
|
|
WalletCredentials createNanoRestoreWalletFromSeedCredentials({
|
|
required String name,
|
|
required String password,
|
|
required String mnemonic,
|
|
required DerivationType derivationType,
|
|
String? passphrase,
|
|
});
|
|
|
|
WalletCredentials createNanoRestoreWalletFromKeysCredentials({
|
|
required String name,
|
|
required String password,
|
|
required String seedKey,
|
|
required DerivationType derivationType,
|
|
});
|
|
|
|
List<String> getNanoWordList(String language);
|
|
Map<String, String> getKeys(Object wallet);
|
|
Object createNanoTransactionCredentials(List<Output> outputs);
|
|
Future<void> changeRep(Object wallet, String address);
|
|
Future<bool> updateTransactions(Object wallet);
|
|
BigInt getTransactionAmountRaw(TransactionInfo transactionInfo);
|
|
String getRepresentative(Object wallet);
|
|
Future<List<N2Node>> getN2Reps(Object wallet);
|
|
bool isRepOk(Object wallet);
|
|
}
|
|
|
|
abstract class NanoAccountList {
|
|
ObservableList<NanoAccount> get accounts;
|
|
void update(Object wallet);
|
|
void refresh(Object wallet);
|
|
Future<List<NanoAccount>> getAll(Object wallet);
|
|
Future<void> addAccount(Object wallet, {required String label});
|
|
Future<void> setLabelAccount(Object wallet, {required int accountIndex, required String label});
|
|
}
|
|
|
|
abstract class NanoUtil {
|
|
bool isValidBip39Seed(String seed);
|
|
static const int maxDecimalDigits = 6; // Max digits after decimal
|
|
BigInt rawPerNano = BigInt.parse("1000000000000000000000000000000");
|
|
BigInt rawPerNyano = BigInt.parse("1000000000000000000000000");
|
|
BigInt rawPerBanano = BigInt.parse("100000000000000000000000000000");
|
|
BigInt rawPerXMR = BigInt.parse("1000000000000");
|
|
BigInt convertXMRtoNano = BigInt.parse("1000000000000000000");
|
|
String getRawAsUsableString(String? raw, BigInt rawPerCur);
|
|
String getRawAccuracy(String? raw, BigInt rawPerCur);
|
|
String getAmountAsRaw(String amount, BigInt rawPerCur);
|
|
|
|
// derivationInfo:
|
|
Future<AccountInfoResponse?> getInfoFromSeedOrMnemonic(
|
|
DerivationType derivationType, {
|
|
String? seedKey,
|
|
String? mnemonic,
|
|
required Node node,
|
|
});
|
|
Future<List<DerivationType>> compareDerivationMethods({
|
|
String? mnemonic,
|
|
String? privateKey,
|
|
required Node node,
|
|
});
|
|
Future<List<DerivationInfo>> getDerivationsFromMnemonic({
|
|
String? mnemonic,
|
|
String? seedKey,
|
|
required Node node,
|
|
});
|
|
}
|
|
""";
|
|
|
|
const nanoEmptyDefinition = 'Nano? nano;\nNanoUtil? nanoUtil;\n';
|
|
const nanoCWDefinition = 'Nano? nano = CWNano();\nNanoUtil? nanoUtil = CWNanoUtil();\n';
|
|
|
|
final output = '$nanoCommonHeaders\n' +
|
|
(hasImplementation ? '$nanoCWHeaders\n' : '\n') +
|
|
(hasImplementation ? '$nanoCwPart\n\n' : '\n') +
|
|
(hasImplementation ? nanoCWDefinition : nanoEmptyDefinition) +
|
|
'\n' +
|
|
nanoContent;
|
|
|
|
if (outputFile.existsSync()) {
|
|
await outputFile.delete();
|
|
}
|
|
|
|
await outputFile.writeAsString(output);
|
|
}
|
|
|
|
Future<void> generateSolana(bool hasImplementation) async {
|
|
final outputFile = File(solanaOutputPath);
|
|
const solanaCommonHeaders = """
|
|
import 'package:cake_wallet/view_model/send/output.dart';
|
|
import 'package:cake_wallet/exchange/provider/jupiter_exchange_provider.dart';
|
|
import 'package:cw_core/crypto_currency.dart';
|
|
import 'package:cw_core/output_info.dart';
|
|
import 'package:cw_core/pending_transaction.dart';
|
|
import 'package:cw_core/transaction_info.dart';
|
|
import 'package:cw_core/wallet_base.dart';
|
|
import 'package:cw_core/wallet_credentials.dart';
|
|
import 'package:cw_core/wallet_info.dart';
|
|
import 'package:cw_core/wallet_service.dart';
|
|
import 'package:cw_core/spl_token.dart';
|
|
|
|
""";
|
|
const solanaCWHeaders = """
|
|
import 'package:cw_solana/solana_wallet.dart';
|
|
import 'package:cw_solana/solana_mnemonics.dart';
|
|
import 'package:cw_solana/solana_wallet_service.dart';
|
|
import 'package:cw_solana/solana_transaction_info.dart';
|
|
import 'package:cw_solana/pending_solana_transaction.dart';
|
|
import 'package:cw_solana/solana_transaction_credentials.dart';
|
|
import 'package:cw_solana/solana_wallet_creation_credentials.dart';
|
|
import 'package:cw_solana/default_spl_tokens.dart';
|
|
|
|
import 'dart:convert';
|
|
import 'dart:typed_data';
|
|
import 'package:on_chain/solana/solana.dart' hide Store;
|
|
""";
|
|
const solanaCwPart = "part 'cw_solana.dart';";
|
|
const solanaContent = """
|
|
abstract class Solana {
|
|
List<String> getSolanaWordList(String language);
|
|
WalletService createSolanaWalletService(bool isDirect);
|
|
WalletCredentials createSolanaNewWalletCredentials(
|
|
{required String name, WalletInfo? walletInfo, String? password, String? mnemonic, String? passphrase});
|
|
WalletCredentials createSolanaRestoreWalletFromSeedCredentials(
|
|
{required String name, required String mnemonic, required String password, String? passphrase});
|
|
WalletCredentials createSolanaRestoreWalletFromPrivateKey(
|
|
{required String name, required String privateKey, required String password});
|
|
|
|
String getAddress(WalletBase wallet);
|
|
String getPrivateKey(WalletBase wallet);
|
|
String getPublicKey(WalletBase wallet);
|
|
|
|
Object createSolanaTransactionCredentials(
|
|
List<Output> outputs, {
|
|
required CryptoCurrency currency,
|
|
});
|
|
|
|
Object createSolanaTransactionCredentialsRaw(
|
|
List<OutputInfo> outputs, {
|
|
required CryptoCurrency currency,
|
|
});
|
|
List<CryptoCurrency> getSPLTokenCurrencies(WalletBase wallet);
|
|
Future<void> addSPLToken(
|
|
WalletBase wallet,
|
|
CryptoCurrency token,
|
|
String contractAddress,
|
|
);
|
|
Future<void> deleteSPLToken(WalletBase wallet, CryptoCurrency token);
|
|
Future<CryptoCurrency?> getSPLToken(WalletBase wallet, String contractAddress);
|
|
|
|
CryptoCurrency assetOfTransaction(WalletBase wallet, TransactionInfo transaction);
|
|
double getTransactionAmountRaw(TransactionInfo transactionInfo);
|
|
String getTokenAddress(CryptoCurrency asset);
|
|
List<int>? getValidationLength(CryptoCurrency type);
|
|
double? getEstimateFees(WalletBase wallet);
|
|
List<SPLToken> getDefaultSPLTokens();
|
|
List<String> getDefaultTokenContractAddresses();
|
|
List<String> getDefaultTokenSymbols();
|
|
bool isTokenAlreadyAdded(WalletBase wallet, String contractAddress);
|
|
|
|
// Jupiter swap transaction handling
|
|
// Signs and prepares a base64-encoded unsigned transaction for sending
|
|
Future<PendingTransaction> signAndPrepareJupiterSwapTransaction(
|
|
WalletBase wallet,
|
|
String base64Transaction,
|
|
String requestId,
|
|
String destinationAddress,
|
|
double amount,
|
|
double fee,
|
|
);
|
|
|
|
// Fast transaction update after sending
|
|
// Polls for a specific transaction by signature with exponential backoff
|
|
// Falls back to full refresh if transaction is not found after max retries
|
|
Future<void> pollForTransaction(
|
|
WalletBase wallet,
|
|
String signature, {
|
|
Duration initialDelay = const Duration(seconds: 1),
|
|
int maxRetries = 5,
|
|
});
|
|
|
|
// Updates balances for specific tokens by mint addresses
|
|
// Also updates native SOL balance
|
|
// If tokenMints is null or empty, updates all tokens (full refresh)
|
|
Future<void> updateTokenBalances(
|
|
WalletBase wallet, {
|
|
List<String>? tokenMints,
|
|
});
|
|
}
|
|
|
|
class JupiterSwapFailedException implements Exception {
|
|
final String message;
|
|
final String signature;
|
|
final num? errorCode;
|
|
final String? errorMessage;
|
|
|
|
JupiterSwapFailedException({
|
|
required this.message,
|
|
required this.signature,
|
|
this.errorCode,
|
|
this.errorMessage,
|
|
});
|
|
|
|
@override
|
|
String toString() => message;
|
|
}
|
|
|
|
""";
|
|
|
|
const solanaEmptyDefinition = 'Solana? solana;\n';
|
|
const solanaCWDefinition = 'Solana? solana = CWSolana();\n';
|
|
|
|
final output = '$solanaCommonHeaders\n' +
|
|
(hasImplementation ? '$solanaCWHeaders\n' : '\n') +
|
|
(hasImplementation ? '$solanaCwPart\n\n' : '\n') +
|
|
(hasImplementation ? solanaCWDefinition : solanaEmptyDefinition) +
|
|
'\n' +
|
|
solanaContent;
|
|
|
|
if (outputFile.existsSync()) {
|
|
await outputFile.delete();
|
|
}
|
|
|
|
await outputFile.writeAsString(output);
|
|
}
|
|
|
|
Future<void> generateTron(bool hasImplementation) async {
|
|
final outputFile = File(tronOutputPath);
|
|
const tronCommonHeaders = """
|
|
import 'package:cake_wallet/view_model/send/output.dart';
|
|
import 'package:cw_core/crypto_currency.dart';
|
|
import 'package:cw_core/output_info.dart';
|
|
import 'package:cw_core/transaction_info.dart';
|
|
import 'package:cw_core/wallet_base.dart';
|
|
import 'package:cw_core/wallet_credentials.dart';
|
|
import 'package:cw_core/wallet_info.dart';
|
|
import 'package:cw_core/wallet_service.dart';
|
|
import 'package:cw_core/tron_token.dart';
|
|
import 'package:hive/hive.dart';
|
|
|
|
""";
|
|
const tronCWHeaders = """
|
|
import 'package:cw_evm/evm_chain_mnemonics.dart';
|
|
import 'package:cw_tron/tron_transaction_credentials.dart';
|
|
import 'package:cw_tron/tron_transaction_info.dart';
|
|
import 'package:cw_tron/tron_wallet_creation_credentials.dart';
|
|
|
|
import 'package:cw_tron/tron_client.dart';
|
|
import 'package:cw_tron/tron_wallet.dart';
|
|
import 'package:cw_tron/tron_wallet_service.dart';
|
|
import 'package:cw_tron/default_tron_tokens.dart';
|
|
|
|
""";
|
|
const tronCwPart = "part 'cw_tron.dart';";
|
|
const tronContent = """
|
|
abstract class Tron {
|
|
List<String> getTronWordList(String language);
|
|
WalletService createTronWalletService(bool isDirect);
|
|
WalletCredentials createTronNewWalletCredentials({required String name, WalletInfo? walletInfo, String? password, String? mnemonic, String? passphrase});
|
|
WalletCredentials createTronRestoreWalletFromSeedCredentials({required String name, required String mnemonic, required String password, String? passphrase});
|
|
WalletCredentials createTronRestoreWalletFromPrivateKey({required String name, required String privateKey, required String password});
|
|
String getAddress(WalletBase wallet);
|
|
|
|
Object createTronTransactionCredentials(
|
|
List<Output> outputs, {
|
|
required CryptoCurrency currency,
|
|
});
|
|
|
|
List<CryptoCurrency> getTronTokenCurrencies(WalletBase wallet);
|
|
Future<void> addTronToken(WalletBase wallet, CryptoCurrency token, String contractAddress);
|
|
Future<void> deleteTronToken(WalletBase wallet, CryptoCurrency token);
|
|
Future<CryptoCurrency?> getTronToken(WalletBase wallet, String contractAddress);
|
|
|
|
double getTransactionAmountRaw(TransactionInfo transactionInfo);
|
|
CryptoCurrency assetOfTransaction(WalletBase wallet, TransactionInfo transaction);
|
|
String getTokenAddress(CryptoCurrency asset);
|
|
String getTronBase58Address(String hexAddress, WalletBase wallet);
|
|
|
|
String? getTronNativeEstimatedFee(WalletBase wallet);
|
|
String? getTronTRC20EstimatedFee(WalletBase wallet);
|
|
|
|
void updateTronGridUsageState(WalletBase wallet, bool isEnabled);
|
|
List<TronToken> getDefaultTronTokens();
|
|
List<String> getDefaultTokenContractAddresses();
|
|
List<String> getDefaultTokenSymbols();
|
|
bool isTokenAlreadyAdded(WalletBase wallet, String contractAddress);
|
|
}
|
|
""";
|
|
|
|
const tronEmptyDefinition = 'Tron? tron;\n';
|
|
const tronCWDefinition = 'Tron? tron = CWTron();\n';
|
|
|
|
final output = '$tronCommonHeaders\n' +
|
|
(hasImplementation ? '$tronCWHeaders\n' : '\n') +
|
|
(hasImplementation ? '$tronCwPart\n\n' : '\n') +
|
|
(hasImplementation ? tronCWDefinition : tronEmptyDefinition) +
|
|
'\n' +
|
|
tronContent;
|
|
|
|
if (outputFile.existsSync()) {
|
|
await outputFile.delete();
|
|
}
|
|
|
|
await outputFile.writeAsString(output);
|
|
}
|
|
|
|
Future<void> generateZano(bool hasImplementation) async {
|
|
final outputFile = File(zanoOutputPath);
|
|
const zanoCommonHeaders = """
|
|
import 'package:cake_wallet/utils/language_list.dart';
|
|
import 'package:cake_wallet/view_model/send/output.dart';
|
|
import 'package:collection/collection.dart';
|
|
import 'package:cw_core/crypto_currency.dart';
|
|
import 'package:cw_core/monero_transaction_priority.dart';
|
|
import 'package:cw_core/output_info.dart';
|
|
import 'package:cw_core/transaction_history.dart';
|
|
import 'package:cw_core/transaction_info.dart';
|
|
import 'package:cw_core/transaction_priority.dart';
|
|
import 'package:cw_core/wallet_base.dart';
|
|
import 'package:cw_core/wallet_credentials.dart';
|
|
import 'package:cw_core/wallet_info.dart';
|
|
import 'package:cw_core/wallet_service.dart';
|
|
import 'package:cw_core/zano_asset.dart';
|
|
import 'package:hive/hive.dart';
|
|
""";
|
|
const zanoCWHeaders = """
|
|
import 'package:cw_zano/mnemonics/english.dart';
|
|
import 'package:cw_zano/model/zano_transaction_credentials.dart';
|
|
import 'package:cw_zano/model/zano_transaction_info.dart';
|
|
import 'package:cw_zano/zano_formatter.dart';
|
|
import 'package:cw_zano/zano_wallet.dart';
|
|
import 'package:cw_zano/zano_wallet_service.dart';
|
|
import 'package:cw_zano/zano_wallet_api.dart' as api;
|
|
import 'package:cw_zano/zano_utils.dart';
|
|
""";
|
|
const zanoCwPart = "part 'cw_zano.dart';";
|
|
const zanoContent = """
|
|
abstract class Zano {
|
|
TransactionPriority getDefaultTransactionPriority();
|
|
TransactionPriority deserializeMoneroTransactionPriority({required int raw});
|
|
List<TransactionPriority> getTransactionPriorities();
|
|
List<String> getWordList(String language);
|
|
|
|
WalletCredentials createZanoRestoreWalletFromSeedCredentials({required String name, required String password, required String passphrase, required int height, required String mnemonic});
|
|
WalletCredentials createZanoNewWalletCredentials({required String name, required String? password, required String? passphrase});
|
|
Map<String, String> getKeys(Object wallet);
|
|
Object createZanoTransactionCredentials({required List<Output> outputs, required TransactionPriority priority, required CryptoCurrency currency});
|
|
double formatterIntAmountToDouble({required int amount, required CryptoCurrency currency, required bool forFee});
|
|
int formatterParseAmount({required String amount, required CryptoCurrency currency});
|
|
WalletService createZanoWalletService();
|
|
CryptoCurrency? assetOfTransaction(WalletBase wallet, TransactionInfo tx);
|
|
List<ZanoAsset> getZanoAssets(WalletBase wallet);
|
|
String getZanoAssetAddress(CryptoCurrency asset);
|
|
Future<void> changeZanoAssetAvailability(WalletBase wallet, CryptoCurrency token);
|
|
Future<CryptoCurrency> addZanoAssetById(WalletBase wallet, String assetId);
|
|
Future<void> deleteZanoAsset(WalletBase wallet, CryptoCurrency token);
|
|
Future<CryptoCurrency?> getZanoAsset(WalletBase wallet, String contractAddress);
|
|
String getAddress(WalletBase wallet);
|
|
bool validateAddress(String address);
|
|
Map<String, List<int>> debugCallLength();
|
|
bool isTokenAlreadyAdded(WalletBase wallet, String contractAddress);
|
|
}
|
|
""";
|
|
const zanoEmptyDefinition = 'Zano? zano;\n';
|
|
const zanoCWDefinition = 'Zano? zano = CWZano();\n';
|
|
|
|
final output = '$zanoCommonHeaders\n' +
|
|
(hasImplementation ? '$zanoCWHeaders\n' : '\n') +
|
|
(hasImplementation ? '$zanoCwPart\n\n' : '\n') +
|
|
(hasImplementation ? zanoCWDefinition : zanoEmptyDefinition) +
|
|
'\n' +
|
|
zanoContent;
|
|
|
|
if (outputFile.existsSync()) {
|
|
await outputFile.delete();
|
|
}
|
|
|
|
await outputFile.writeAsString(output);
|
|
}
|
|
|
|
Future<void> generateDecred(bool hasImplementation) async {
|
|
final outputFile = File(decredOutputPath);
|
|
const decredCommonHeaders = """
|
|
import 'package:cw_core/wallet_credentials.dart';
|
|
import 'package:cw_core/address_info.dart';
|
|
import 'package:cw_core/wallet_info.dart';
|
|
import 'package:cw_core/transaction_priority.dart';
|
|
import 'package:cw_core/output_info.dart';
|
|
import 'package:cw_core/wallet_service.dart';
|
|
import 'package:cw_core/unspent_transaction_output.dart';
|
|
import 'package:cw_core/unspent_coins_info.dart';
|
|
import 'package:cake_wallet/view_model/send/output.dart';
|
|
import 'package:hive/hive.dart';
|
|
""";
|
|
const decredCWHeaders = """
|
|
import 'package:cw_decred/transaction_priority.dart';
|
|
import 'package:cw_decred/wallet.dart';
|
|
import 'package:cw_decred/wallet_service.dart';
|
|
import 'package:cw_decred/wallet_creation_credentials.dart';
|
|
import 'package:cw_decred/amount_format.dart';
|
|
import 'package:cw_decred/transaction_credentials.dart';
|
|
import 'package:cw_decred/mnemonic.dart';
|
|
""";
|
|
const decredCwPart = "part 'cw_decred.dart';";
|
|
const decredContent = """
|
|
|
|
abstract class Decred {
|
|
WalletCredentials createDecredNewWalletCredentials(
|
|
{required String name, WalletInfo? walletInfo});
|
|
WalletCredentials createDecredRestoreWalletFromSeedCredentials(
|
|
{required String name, required String mnemonic, required String password});
|
|
WalletCredentials createDecredRestoreWalletFromPubkeyCredentials(
|
|
{required String name, required String pubkey, required String password});
|
|
WalletService createDecredWalletService(Box<UnspentCoinsInfo> unspentCoinSource);
|
|
|
|
List<TransactionPriority> getTransactionPriorities();
|
|
TransactionPriority getDecredTransactionPriorityMedium();
|
|
TransactionPriority getDecredTransactionPrioritySlow();
|
|
TransactionPriority deserializeDecredTransactionPriority(int raw);
|
|
|
|
Object createDecredTransactionCredentials(List<Output> outputs, TransactionPriority priority);
|
|
|
|
List<WalletInfoAddressInfo> getAddressInfos(Object wallet);
|
|
Future<void> updateAddress(Object wallet, String address, String label);
|
|
Future<void> generateNewAddress(Object wallet, String label);
|
|
|
|
String formatterDecredAmountToString({required int amount});
|
|
double formatterDecredAmountToDouble({required int amount});
|
|
int formatterStringDoubleToDecredAmount(String amount);
|
|
|
|
List<Unspent> getUnspents(Object wallet);
|
|
void updateUnspents(Object wallet);
|
|
|
|
int heightByDate(DateTime date);
|
|
|
|
List<String> getDecredWordList();
|
|
|
|
String pubkey(Object wallet);
|
|
}
|
|
""";
|
|
|
|
const decredEmptyDefinition = 'Decred? decred;\n';
|
|
const decredCWDefinition = 'Decred? decred = CWDecred();\n';
|
|
|
|
final output = '$decredCommonHeaders\n' +
|
|
(hasImplementation ? '$decredCWHeaders\n' : '\n') +
|
|
(hasImplementation ? '$decredCwPart\n\n' : '\n') +
|
|
(hasImplementation ? decredCWDefinition : decredEmptyDefinition) +
|
|
'\n' +
|
|
decredContent;
|
|
|
|
if (outputFile.existsSync()) {
|
|
await outputFile.delete();
|
|
}
|
|
|
|
await outputFile.writeAsString(output);
|
|
}
|
|
|
|
Future<void> generateDogecoin(bool hasImplementation) async {
|
|
final outputFile = File(dogecoinOutputPath);
|
|
const dogecoinCommonHeaders = """
|
|
import 'package:cw_core/transaction_priority.dart';
|
|
import 'package:cw_core/unspent_coins_info.dart';
|
|
import 'package:cw_core/wallet_credentials.dart';
|
|
import 'package:cw_core/wallet_info.dart';
|
|
import 'package:cw_core/wallet_service.dart';
|
|
import 'package:hive/hive.dart';
|
|
""";
|
|
const dogecoinCWHeaders = """
|
|
import 'package:cw_dogecoin/cw_dogecoin.dart';
|
|
""";
|
|
const dogecoinCwPart = "part 'cw_dogecoin.dart';";
|
|
const dogecoinContent = """
|
|
abstract class DogeCoin {
|
|
|
|
WalletService createDogeCoinWalletService(Box<UnspentCoinsInfo> unspentCoinSource, bool isDirect);
|
|
|
|
WalletCredentials createDogeCoinNewWalletCredentials(
|
|
{required String name, WalletInfo? walletInfo, String? password, String? passphrase, String? mnemonic});
|
|
|
|
WalletCredentials createDogeCoinRestoreWalletFromSeedCredentials(
|
|
{required String name, required String mnemonic, required String password, String? passphrase});
|
|
|
|
TransactionPriority deserializeDogeCoinTransactionPriority(int raw);
|
|
|
|
TransactionPriority getDefaultTransactionPriority();
|
|
|
|
List<TransactionPriority> getTransactionPriorities();
|
|
|
|
TransactionPriority getDogeCoinTransactionPrioritySlow();
|
|
}
|
|
""";
|
|
|
|
const dogecoinEmptyDefinition = 'DogeCoin? dogecoin;\n';
|
|
const dogecoinCWDefinition = 'DogeCoin? dogecoin = CWDogeCoin();\n';
|
|
|
|
final output = '$dogecoinCommonHeaders\n' +
|
|
(hasImplementation ? '$dogecoinCWHeaders\n' : '\n') +
|
|
(hasImplementation ? '$dogecoinCwPart\n\n' : '\n') +
|
|
(hasImplementation ? dogecoinCWDefinition : dogecoinEmptyDefinition) +
|
|
'\n' +
|
|
dogecoinContent;
|
|
|
|
if (outputFile.existsSync()) {
|
|
await outputFile.delete();
|
|
}
|
|
|
|
await outputFile.writeAsString(output);
|
|
}
|
|
|
|
Future<void> generateEVM(bool hasImplementation) async {
|
|
final outputFile = File(evmOutputPath);
|
|
const evmCommonHeaders = """
|
|
import 'dart:math' as math;
|
|
import 'package:cake_wallet/core/utilities.dart';
|
|
import 'package:cake_wallet/view_model/send/output.dart';
|
|
import 'package:cw_core/crypto_currency.dart';
|
|
import 'package:cw_core/erc20_token.dart';
|
|
import 'package:cw_core/hardware/hardware_account_data.dart';
|
|
import 'package:cw_core/hardware/hardware_wallet_service.dart';
|
|
import 'package:cw_core/output_info.dart';
|
|
import 'package:cw_core/pending_transaction.dart';
|
|
import 'package:cw_core/transaction_info.dart';
|
|
import 'package:cw_core/transaction_priority.dart';
|
|
import 'package:cw_core/wallet_base.dart';
|
|
import 'package:cw_core/wallet_credentials.dart';
|
|
import 'package:cw_core/wallet_info.dart';
|
|
import 'package:cw_core/wallet_service.dart';
|
|
import 'package:cw_core/wallet_type.dart';
|
|
import 'package:cw_core/node.dart';
|
|
import 'package:ledger_flutter_plus/ledger_flutter_plus.dart' as ledger;
|
|
import 'package:bitbox_flutter/bitbox_flutter.dart' as bitbox;
|
|
import 'package:trezor_connect/trezor_connect.dart' as trezor;
|
|
import 'package:web3dart/web3dart.dart';
|
|
|
|
""";
|
|
const evmCWHeaders = """
|
|
import 'package:cake_wallet/core/fiat_conversion_service.dart';
|
|
import 'package:cake_wallet/di.dart';
|
|
import 'package:cake_wallet/entities/fiat_api_mode.dart';
|
|
import 'package:cake_wallet/entities/fiat_currency.dart';
|
|
import 'package:cake_wallet/store/settings_store.dart';
|
|
import 'package:cw_evm/utils/evm_chain_formatter.dart';
|
|
import 'package:cw_evm/evm_chain_mnemonics.dart';
|
|
import 'package:cw_evm/evm_chain_registry.dart';
|
|
import 'package:cw_evm/evm_erc20_balance.dart';
|
|
import 'package:cw_evm/evm_chain_transaction_credentials.dart';
|
|
import 'package:cw_evm/evm_chain_transaction_info.dart';
|
|
import 'package:cw_evm/evm_chain_transaction_priority.dart';
|
|
import 'package:cw_evm/hardware/evm_chain_bitbox_credentials.dart';
|
|
import 'package:cw_evm/hardware/evm_chain_ledger_credentials.dart';
|
|
import 'package:cw_evm/hardware/evm_chain_trezor_credentials.dart';
|
|
import 'package:cw_evm/evm_chain_wallet.dart';
|
|
import 'package:cw_evm/hardware/evm_chain_bitbox_service.dart';
|
|
import 'package:cw_evm/hardware/evm_chain_ledger_service.dart';
|
|
import 'package:cw_evm/hardware/evm_chain_trezor_service.dart';
|
|
import 'package:cw_evm/evm_chain_wallet_service.dart';
|
|
import 'package:cw_evm/evm_chain_wallet_creation_credentials.dart';
|
|
import 'package:cw_evm/utils/evm_chain_utils.dart';
|
|
import 'package:cw_evm/evm_chain_default_tokens.dart';
|
|
import 'package:cw_evm/deuro/deuro_savings.dart';
|
|
import 'package:eth_sig_util/util/utils.dart';
|
|
|
|
""";
|
|
const evmCwPart = "part 'cw_evm.dart';";
|
|
const evmContent = """
|
|
/// Unified abstract class for all EVM chains
|
|
///
|
|
/// This replaces separate proxy classes (Ethereum, Polygon, Base, Arbitrum)
|
|
/// with a single unified interface that works for all EVM chains.
|
|
/// Methods take WalletType parameter to determine chain-specific behavior.
|
|
abstract class EVM {
|
|
List<String> getEVMWordList(String language);
|
|
|
|
/// Create unified wallet service for any EVM chain
|
|
WalletService createEVMWalletService(WalletType walletType, bool isDirect);
|
|
|
|
/// Generic credential creation - uses WalletType
|
|
WalletCredentials createEVMNewWalletCredentials({
|
|
required String name,
|
|
WalletInfo? walletInfo,
|
|
String? password,
|
|
String? mnemonic,
|
|
String? passphrase,
|
|
});
|
|
|
|
WalletCredentials createEVMRestoreWalletFromSeedCredentials({
|
|
required String name,
|
|
required String mnemonic,
|
|
required String password,
|
|
String? passphrase,
|
|
});
|
|
|
|
WalletCredentials createEVMRestoreWalletFromPrivateKey({
|
|
required String name,
|
|
required String privateKey,
|
|
required String password,
|
|
});
|
|
|
|
WalletCredentials createEVMHardwareWalletCredentials({
|
|
required String name,
|
|
required HardwareAccountData hwAccountData,
|
|
WalletInfo? walletInfo,
|
|
});
|
|
|
|
// Generic methods that work for all EVM chains
|
|
String getAddress(WalletBase wallet);
|
|
String getPrivateKey(WalletBase wallet);
|
|
String getPublicKey(WalletBase wallet);
|
|
TransactionPriority getDefaultTransactionPriority();
|
|
TransactionPriority getEVMTransactionPrioritySlow();
|
|
List<TransactionPriority> getTransactionPriorities();
|
|
TransactionPriority deserializeEVMTransactionPriority(int raw);
|
|
|
|
Object createEVMTransactionCredentials(
|
|
List<Output> outputs, {
|
|
required TransactionPriority? priority,
|
|
required CryptoCurrency currency,
|
|
int? feeRate,
|
|
bool useBlinkProtection = true,
|
|
});
|
|
|
|
Object createEVMTransactionCredentialsRaw(
|
|
List<OutputInfo> outputs, {
|
|
TransactionPriority? priority,
|
|
required CryptoCurrency currency,
|
|
required int feeRate,
|
|
bool useBlinkProtection = true,
|
|
});
|
|
|
|
int formatterEVMParseAmount(String amount);
|
|
double formatterEVMAmountToDouble({
|
|
TransactionInfo? transaction,
|
|
BigInt? amount,
|
|
int exponent = 18,
|
|
});
|
|
|
|
List<Erc20Token> getERC20Currencies(WalletBase wallet);
|
|
Future<void> addErc20Token(WalletBase wallet, CryptoCurrency token);
|
|
Future<void> deleteErc20Token(WalletBase wallet, CryptoCurrency token);
|
|
Future<void> removeTokenTransactionsInHistory(WalletBase wallet, CryptoCurrency token);
|
|
Future<Erc20Token?> getErc20Token(WalletBase wallet, String contractAddress);
|
|
|
|
CryptoCurrency assetOfTransaction(WalletBase wallet, TransactionInfo transaction);
|
|
void updateScanProviderUsageState(WalletBase wallet, bool isEnabled);
|
|
Web3Client? getWeb3Client(WalletBase wallet);
|
|
String getTokenAddress(CryptoCurrency asset);
|
|
BigInt? getERC20AvailableBalance(Object balance);
|
|
|
|
Future<bool> isApprovalRequired(
|
|
WalletBase wallet,
|
|
String tokenContract,
|
|
String spender,
|
|
BigInt requiredAmount,
|
|
);
|
|
|
|
Future<BigInt?> getAllowance(
|
|
WalletBase wallet,
|
|
String tokenContract,
|
|
String spender);
|
|
|
|
Future<PendingTransaction> createTokenApproval(
|
|
WalletBase wallet,
|
|
BigInt amount,
|
|
String spender,
|
|
CryptoCurrency token,
|
|
TransactionPriority? priority,
|
|
{bool useBlinkProtection = true}
|
|
);
|
|
|
|
Future<PendingTransaction> createRawCallDataTransaction(
|
|
WalletBase wallet,
|
|
String to,
|
|
String dataHex,
|
|
BigInt valueWei,
|
|
TransactionPriority? priority,
|
|
{bool useBlinkProtection = true,
|
|
String? sourceTokenAddress,
|
|
BigInt? sourceTokenAmount}
|
|
);
|
|
|
|
// Hardware wallet methods
|
|
Future<void> setHardwareWalletService(WalletBase wallet, HardwareWalletService service);
|
|
HardwareWalletService getLedgerHardwareWalletService(ledger.LedgerConnection connection);
|
|
HardwareWalletService getBitboxHardwareWalletService(bitbox.BitboxManager manager);
|
|
HardwareWalletService getTrezorHardwareWalletService(trezor.TrezorConnect connect);
|
|
|
|
// Utility methods
|
|
List<Erc20Token> getDefaultTokensByChainId(int chainId);
|
|
List<String> getDefaultTokenContractAddresses(WalletBase wallet);
|
|
List<String> getDefaultTokenSymbols(WalletBase wallet);
|
|
bool isTokenAlreadyAdded(WalletBase wallet, String contractAddress);
|
|
String? getEVMNativeEstimatedFee(WalletBase wallet);
|
|
String? getEVMERC20EstimatedFee(WalletBase wallet);
|
|
|
|
// Chain-specific integrations (optional, can be null for non-Ethereum chains)
|
|
Future<BigInt>? getDEuroSavingsBalance(WalletBase wallet) => null;
|
|
Future<BigInt>? getDEuroAccruedInterest(WalletBase wallet) => null;
|
|
Future<BigInt>? getDEuroInterestRate(WalletBase wallet) => null;
|
|
Future<BigInt>? getDEuroSavingsApproved(WalletBase wallet) => null;
|
|
Future<PendingTransaction>? addDEuroSaving(WalletBase wallet, BigInt amount, TransactionPriority priority) => null;
|
|
Future<PendingTransaction>? removeDEuroSaving(WalletBase wallet, BigInt amount, TransactionPriority priority) => null;
|
|
Future<PendingTransaction>? reinvestDEuroInterest(WalletBase wallet, TransactionPriority priority) => null;
|
|
Future<PendingTransaction>? enableDEuroSaving(WalletBase wallet, TransactionPriority priority) => null;
|
|
|
|
// Registry helper methods (for backward compatibility helpers)
|
|
int getChainIdByWalletType(WalletType walletType);
|
|
String getChainNameByWalletType(WalletType walletType);
|
|
String getTokenNameByWalletType(WalletType walletType);
|
|
String getCaip2ByChainId(int chainId);
|
|
int? getChainIdByTag(String tag);
|
|
int? getChainIdByTitle(String title);
|
|
WalletType? getWalletTypeByChainId(int chainId);
|
|
String getChainNameByChainId(int chainId);
|
|
String getTokenNameByChainId(int chainId);
|
|
|
|
// Chain selection methods
|
|
List<ChainInfo> getAllChains();
|
|
ChainInfo? getCurrentChain(WalletBase wallet);
|
|
|
|
int? getSelectedChainId(WalletBase wallet);
|
|
Future<void> selectChain(WalletBase wallet, int chainId, {required Node node});
|
|
|
|
String? getExplorerUrlForChainId(int chainId, {bool showProtocol = true});
|
|
|
|
bool hasPriorityFee(int chainId);
|
|
|
|
Future<void> discoverAndAddWalletTokens(WalletBase wallet);
|
|
}
|
|
|
|
class ChainInfo {
|
|
const ChainInfo({
|
|
required this.chainId,
|
|
required this.name,
|
|
required this.shortCode,
|
|
});
|
|
|
|
final int chainId;
|
|
final String name;
|
|
final String shortCode;
|
|
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
other is ChainInfo && runtimeType == other.runtimeType && chainId == other.chainId;
|
|
|
|
@override
|
|
int get hashCode => chainId.hashCode;
|
|
}
|
|
""";
|
|
|
|
const evmEmptyDefinition = 'EVM? evm;\n';
|
|
const evmCWDefinition = 'EVM? evm = CWEVM();\n';
|
|
|
|
final output = '$evmCommonHeaders\n' +
|
|
(hasImplementation ? '$evmCWHeaders\n' : '\n') +
|
|
(hasImplementation ? '$evmCwPart\n\n' : '\n') +
|
|
(hasImplementation ? evmCWDefinition : evmEmptyDefinition) +
|
|
'\n' +
|
|
evmContent;
|
|
|
|
if (outputFile.existsSync()) {
|
|
await outputFile.delete();
|
|
}
|
|
|
|
await outputFile.writeAsString(output);
|
|
}
|
|
|
|
Future<void> generateZcash(bool hasImplementation) async {
|
|
final outputFile = File(zcashOutputPath);
|
|
const zcashCommonHeaders = """
|
|
import 'package:cake_wallet/view_model/send/output.dart';
|
|
import 'package:cw_core/balance.dart';
|
|
import 'package:cw_core/crypto_amount_format.dart';
|
|
import 'package:cw_core/crypto_currency.dart';
|
|
import 'package:cw_core/output_info.dart';
|
|
import 'package:cw_core/transaction_history.dart';
|
|
import 'package:cw_core/transaction_info.dart';
|
|
import 'package:cw_core/transaction_priority.dart';
|
|
import 'package:cw_core/monero_transaction_priority.dart';
|
|
import 'package:cw_core/wallet_base.dart';
|
|
import 'package:cw_core/wallet_credentials.dart';
|
|
import 'package:cw_core/wallet_info.dart';
|
|
import 'package:cw_core/wallet_service.dart';
|
|
import 'package:cw_core/receive_page_option.dart';
|
|
|
|
""";
|
|
const zcashCWHeaders = """
|
|
import 'package:cw_zcash/cw_zcash.dart';
|
|
import 'package:cw_zcash/src/zcash_wallet_addresses.dart';
|
|
|
|
""";
|
|
const zcashCwPart = "part 'cw_zcash.dart';";
|
|
const zcashContent = """
|
|
abstract class Zcash {
|
|
List<String> getZcashWordList(String language);
|
|
WalletService createZcashWalletService(bool isDirect);
|
|
WalletCredentials createZcashNewWalletCredentials(
|
|
{required String name,
|
|
WalletInfo? walletInfo,
|
|
String? password,
|
|
String? mnemonic,
|
|
required String? passphrase});
|
|
WalletCredentials createZcashRestoreWalletFromSeedCredentials(
|
|
{required String name,
|
|
required String mnemonic,
|
|
required String password,
|
|
String? passphrase,
|
|
required int? height});
|
|
WalletCredentials createZcashRestoreWalletFromPrivateKey(
|
|
{required String name, required String privateKey, required String password, required int height});
|
|
String getAddress(WalletBase wallet);
|
|
String getPrivateKey(WalletBase wallet);
|
|
String getPublicKey(WalletBase wallet);
|
|
Map<String, String> getKeys(Object wallet);
|
|
|
|
Object createZcashTransactionCredentials(
|
|
List<Output> outputs, {
|
|
required CryptoCurrency currency,
|
|
int? feeRate,
|
|
});
|
|
|
|
Object createZcashTransactionCredentialsRaw(
|
|
List<OutputInfo> outputs, {
|
|
required CryptoCurrency currency,
|
|
required int feeRate,
|
|
});
|
|
|
|
int formatterZcashParseAmount(String amount);
|
|
double formatterZcashAmountToDouble({TransactionInfo? transaction, BigInt? amount});
|
|
String formatterZcashAmountToString({required int amount});
|
|
|
|
List<WalletInfoAddressInfo> getAddressInfos(Object wallet);
|
|
|
|
TransactionPriority getDefaultTransactionPriority();
|
|
TransactionPriority getZcashTransactionPriorityAutomatic();
|
|
TransactionPriority deserializeZcashTransactionPriority({required int raw});
|
|
List<TransactionPriority> getTransactionPriorities();
|
|
ReceivePageOption getSelectedAddressType(Object wallet);
|
|
dynamic getZcashAddressType(ReceivePageOption option);
|
|
bool hasSelectedTransparentAddress(Object wallet);
|
|
Future<void> setAddressType(Object wallet, dynamic option);
|
|
dynamic getOptionToType(ReceivePageOption option);
|
|
void unlockDatabase(String password);
|
|
Future<int> getHeightByDate(DateTime date);
|
|
bool showMissingFundsCard(WalletBase wallet);
|
|
Future<void> rescanInternalChange(WalletBase wallet);
|
|
}
|
|
""";
|
|
|
|
const zcashEmptyDefinition = 'Zcash? zcash;\n';
|
|
const zcashCWDefinition = 'Zcash? zcash = CWZcash();\n';
|
|
|
|
final output = '$zcashCommonHeaders\n' +
|
|
(hasImplementation ? '$zcashCWHeaders\n' : '\n') +
|
|
(hasImplementation ? '$zcashCwPart\n\n' : '\n') +
|
|
(hasImplementation ? zcashCWDefinition : zcashEmptyDefinition) +
|
|
'\n' +
|
|
zcashContent;
|
|
|
|
if (outputFile.existsSync()) {
|
|
await outputFile.delete();
|
|
}
|
|
|
|
await outputFile.writeAsString(output);
|
|
}
|
|
|
|
Future<void> generatePubspec({
|
|
required bool hasMonero,
|
|
required bool hasBitcoin,
|
|
required bool hasEthereum,
|
|
required bool hasNano,
|
|
required bool hasBanano,
|
|
required bool hasBitcoinCash,
|
|
required bool hasFlutterSecureStorage,
|
|
required bool hasPolygon,
|
|
required bool hasSolana,
|
|
required bool hasTron,
|
|
required bool hasWownero,
|
|
required bool hasZano,
|
|
required bool hasDecred,
|
|
required bool hasDogecoin,
|
|
required bool hasBase,
|
|
required bool hasArbitrum,
|
|
required bool hasBsc,
|
|
required bool hasZcash,
|
|
}) async {
|
|
const cwCore = """
|
|
cw_core:
|
|
path: ./cw_core
|
|
""";
|
|
const cwMonero = """
|
|
cw_monero:
|
|
path: ./cw_monero
|
|
""";
|
|
const cwBitcoin = """
|
|
cw_bitcoin:
|
|
path: ./cw_bitcoin
|
|
""";
|
|
const flutterSecureStorage = """
|
|
flutter_secure_storage:
|
|
git:
|
|
url: https://github.com/cake-tech/flutter_secure_storage.git
|
|
path: flutter_secure_storage
|
|
ref: ca897a08677edb443b366352dd7412735e098e7b
|
|
""";
|
|
const cwBitcoinCash = """
|
|
cw_bitcoin_cash:
|
|
path: ./cw_bitcoin_cash
|
|
""";
|
|
const cwNano = """
|
|
cw_nano:
|
|
path: ./cw_nano
|
|
""";
|
|
const cwBanano = """
|
|
cw_banano:
|
|
path: ./cw_banano
|
|
""";
|
|
const cwSolana = """
|
|
cw_solana:
|
|
path: ./cw_solana
|
|
""";
|
|
const cwEVM = """
|
|
cw_evm:
|
|
path: ./cw_evm
|
|
""";
|
|
const cwTron = """
|
|
cw_tron:
|
|
path: ./cw_tron
|
|
""";
|
|
const cwWownero = """
|
|
cw_wownero:
|
|
path: ./cw_wownero
|
|
""";
|
|
const cwZano = """
|
|
cw_zano:
|
|
path: ./cw_zano
|
|
""";
|
|
const cwDecred = """
|
|
cw_decred:
|
|
path: ./cw_decred
|
|
""";
|
|
const cwDogecoin = """
|
|
cw_dogecoin:
|
|
path: ./cw_dogecoin
|
|
""";
|
|
const cwZcash = """
|
|
cw_zcash:
|
|
path: ./cw_zcash
|
|
""";
|
|
|
|
final inputFile = File(pubspecOutputPath);
|
|
final inputText = await inputFile.readAsString();
|
|
final inputLines = inputText.split('\n');
|
|
final dependenciesIndex = inputLines.indexWhere((line) => Platform.isWindows
|
|
// On Windows it could contains `\r` (Carriage Return). It could be fixed in newer dart versions.
|
|
? line.toLowerCase() == 'dependencies:\r' || line.toLowerCase() == 'dependencies:'
|
|
: line.toLowerCase() == 'dependencies:');
|
|
var output = cwCore;
|
|
|
|
if (hasMonero) {
|
|
output += '\n$cwMonero';
|
|
}
|
|
|
|
if (hasBitcoin) {
|
|
output += '\n$cwBitcoin';
|
|
}
|
|
|
|
if (hasNano) {
|
|
output += '\n$cwNano';
|
|
}
|
|
|
|
if (hasBanano) {
|
|
output += '\n$cwBanano';
|
|
}
|
|
|
|
if (hasBitcoinCash) {
|
|
output += '\n$cwBitcoinCash';
|
|
}
|
|
|
|
if (hasSolana) {
|
|
output += '\n$cwSolana';
|
|
}
|
|
|
|
if (hasTron) {
|
|
output += '\n$cwTron';
|
|
}
|
|
|
|
if (hasDecred) {
|
|
output += '\n$cwDecred';
|
|
}
|
|
|
|
if (hasFlutterSecureStorage) {
|
|
output += '\n$flutterSecureStorage\n';
|
|
}
|
|
|
|
if (hasEthereum || hasPolygon || hasBase || hasArbitrum || hasBsc) {
|
|
output += '\n$cwEVM';
|
|
}
|
|
|
|
if (hasWownero) {
|
|
output += '\n$cwWownero';
|
|
}
|
|
|
|
if (hasZano) {
|
|
output += '\n$cwZano';
|
|
}
|
|
|
|
if (hasDogecoin) {
|
|
output += '\n$cwDogecoin';
|
|
}
|
|
|
|
if (hasZcash) {
|
|
output += '\n$cwZcash';
|
|
}
|
|
|
|
final outputLines = output.split('\n');
|
|
inputLines.insertAll(dependenciesIndex + 1, outputLines);
|
|
final outputContent = inputLines.join('\n');
|
|
final outputFile = File(pubspecOutputPath);
|
|
|
|
if (outputFile.existsSync()) {
|
|
await outputFile.delete();
|
|
}
|
|
|
|
await outputFile.writeAsString(outputContent);
|
|
}
|
|
|
|
Future<void> generateWalletTypes({
|
|
required bool hasMonero,
|
|
required bool hasBitcoin,
|
|
required bool hasEthereum,
|
|
required bool hasNano,
|
|
required bool hasBanano,
|
|
required bool hasBitcoinCash,
|
|
required bool hasPolygon,
|
|
required bool hasSolana,
|
|
required bool hasTron,
|
|
required bool hasWownero,
|
|
required bool hasZano,
|
|
required bool hasDecred,
|
|
required bool hasDogecoin,
|
|
required bool hasBase,
|
|
required bool hasArbitrum,
|
|
required bool hasBsc,
|
|
required bool hasZcash,
|
|
}) async {
|
|
final walletTypesFile = File(walletTypesPath);
|
|
|
|
if (walletTypesFile.existsSync()) {
|
|
await walletTypesFile.delete();
|
|
}
|
|
|
|
const outputHeader = "import 'package:cw_core/wallet_type.dart';";
|
|
const outputDefinition = 'final availableWalletTypes = <WalletType>[';
|
|
var outputContent = outputHeader + '\n\n' + outputDefinition + '\n';
|
|
|
|
if (hasMonero) {
|
|
outputContent += '\tWalletType.monero,\n';
|
|
}
|
|
|
|
if (hasBitcoin) {
|
|
outputContent += '\tWalletType.bitcoin,\n';
|
|
}
|
|
|
|
if (hasEthereum) {
|
|
outputContent += '\tWalletType.ethereum,\n';
|
|
}
|
|
|
|
if (hasBsc) {
|
|
outputContent += '\tWalletType.bsc,\n';
|
|
}
|
|
|
|
if (hasSolana) {
|
|
outputContent += '\tWalletType.solana,\n';
|
|
}
|
|
|
|
if (hasZcash) {
|
|
outputContent += '\tWalletType.zcash,\n';
|
|
}
|
|
|
|
if (hasTron) {
|
|
outputContent += '\tWalletType.tron,\n';
|
|
}
|
|
|
|
if (hasDogecoin) {
|
|
outputContent += '\tWalletType.dogecoin,\n';
|
|
}
|
|
|
|
if (hasBitcoinCash) {
|
|
outputContent += '\tWalletType.bitcoinCash,\n';
|
|
}
|
|
|
|
if (hasBitcoin) {
|
|
outputContent += '\tWalletType.litecoin,\n';
|
|
}
|
|
|
|
if (hasBase) {
|
|
outputContent += '\tWalletType.base,\n';
|
|
}
|
|
|
|
if (hasArbitrum) {
|
|
outputContent += '\tWalletType.arbitrum,\n';
|
|
}
|
|
|
|
if (hasPolygon) {
|
|
outputContent += '\tWalletType.polygon,\n';
|
|
}
|
|
|
|
if (hasNano) {
|
|
outputContent += '\tWalletType.nano,\n';
|
|
}
|
|
|
|
if (hasDecred) {
|
|
outputContent += '\tWalletType.decred,\n';
|
|
}
|
|
|
|
if (hasZano) {
|
|
outputContent += '\tWalletType.zano,\n';
|
|
}
|
|
|
|
if (hasBanano) {
|
|
outputContent += '\tWalletType.banano,\n';
|
|
}
|
|
|
|
// if (hasWownero) {
|
|
// outputContent += '\tWalletType.wownero,\n';
|
|
// }
|
|
|
|
outputContent += '];\n';
|
|
await walletTypesFile.writeAsString(outputContent);
|
|
}
|
|
|
|
Future<void> injectSecureStorage(bool hasFlutterSecureStorage) async {
|
|
const flutterSecureStorageHeader = """
|
|
import 'dart:async';
|
|
import 'dart:io';
|
|
import 'package:flutter_secure_storage/flutter_secure_storage.dart';
|
|
""";
|
|
const abstractSecureStorage = """
|
|
abstract class SecureStorage {
|
|
Future<String?> read({required String key});
|
|
Future<void> write({required String key, required String? value});
|
|
Future<void> delete({required String key});
|
|
Future<void> deleteAll();
|
|
// Legacy
|
|
Future<String?> readNoIOptions({required String key});
|
|
Future<Map<String, String>> readAll();
|
|
}""";
|
|
const defaultSecureStorage = """
|
|
class DefaultSecureStorage extends SecureStorage {
|
|
DefaultSecureStorage._(this._secureStorage);
|
|
|
|
factory DefaultSecureStorage() => _instance;
|
|
|
|
static final _instance = DefaultSecureStorage._(FlutterSecureStorage(
|
|
iOptions: IOSOptions(accessibility: KeychainAccessibility.first_unlock),
|
|
aOptions: AndroidOptions(encryptedSharedPreferences: true),
|
|
));
|
|
|
|
final FlutterSecureStorage _secureStorage;
|
|
|
|
@override
|
|
Future<String?> read({required String key}) async => await _readInternal(key, false);
|
|
|
|
@override
|
|
Future<void> write({required String key, required String? value}) async {
|
|
// delete the value before writing on macOS because of a weird bug
|
|
// https://github.com/mogol/flutter_secure_storage/issues/581
|
|
if (Platform.isMacOS) {
|
|
await _secureStorage.delete(key: key);
|
|
}
|
|
await _secureStorage.write(key: key, value: value);
|
|
}
|
|
|
|
@override
|
|
Future<void> delete({required String key}) async => _secureStorage.delete(key: key);
|
|
|
|
@override
|
|
Future<void> deleteAll() async => _secureStorage.deleteAll();
|
|
|
|
@override
|
|
Future<String?> readNoIOptions({required String key}) async => await _readInternal(key, true);
|
|
|
|
Future<String?> _readInternal(String key, bool useNoIOptions) async {
|
|
return await _secureStorage.read(
|
|
key: key,
|
|
iOptions: useNoIOptions ? IOSOptions() : null,
|
|
);
|
|
}
|
|
|
|
@override
|
|
Future<Map<String, String>> readAll() async {
|
|
return await _secureStorage.readAll();
|
|
}
|
|
}""";
|
|
const fakeSecureStorage = """
|
|
class FakeSecureStorage extends SecureStorage {
|
|
@override
|
|
Future<String?> read({required String key}) async => null;
|
|
@override
|
|
Future<void> write({required String key, required String? value}) async {}
|
|
@override
|
|
Future<void> delete({required String key}) async {}
|
|
@override
|
|
Future<void> deleteAll() async {}
|
|
@override
|
|
Future<String?> readNoIOptions({required String key}) async => null;
|
|
@override
|
|
Future<Map<String, String>> readAll() async => {};
|
|
}""";
|
|
final outputFile = File(secureStoragePath);
|
|
final header = hasFlutterSecureStorage
|
|
? '${flutterSecureStorageHeader}\n\nfinal SecureStorage secureStorageShared = DefaultSecureStorage();\n'
|
|
: 'final SecureStorage secureStorageShared = FakeSecureStorage();\n';
|
|
var output = '';
|
|
if (outputFile.existsSync()) {
|
|
await outputFile.delete();
|
|
}
|
|
|
|
output += '${header}\n${abstractSecureStorage}\n\n';
|
|
|
|
if (hasFlutterSecureStorage) {
|
|
output += '${defaultSecureStorage}\n';
|
|
} else {
|
|
output += '${fakeSecureStorage}\n';
|
|
}
|
|
|
|
await outputFile.writeAsString(output);
|
|
}
|