378 lines
11 KiB
Dart
378 lines
11 KiB
Dart
// import 'dart:ffi';
|
|
import 'dart:io';
|
|
import 'dart:typed_data';
|
|
import 'package:crypto/crypto.dart';
|
|
import 'package:dubp/dubp.dart';
|
|
import 'package:fast_base58/fast_base58.dart';
|
|
import 'package:flutter/foundation.dart';
|
|
import 'package:flutter/material.dart';
|
|
import 'dart:async';
|
|
import 'package:gecko/globals.dart';
|
|
import 'package:gecko/models/home.dart';
|
|
import 'package:gecko/models/myWallets.dart';
|
|
import 'package:image_picker/image_picker.dart';
|
|
import 'package:provider/provider.dart';
|
|
import 'package:truncate/truncate.dart';
|
|
import 'package:qrscan/qrscan.dart' as scanner;
|
|
|
|
class WalletOptionsProvider with ChangeNotifier {
|
|
TextEditingController pubkey = TextEditingController();
|
|
TextEditingController _newWalletName = TextEditingController();
|
|
bool isWalletUnlock = false;
|
|
bool ischangedPin = false;
|
|
TextEditingController newPin = new TextEditingController();
|
|
bool isEditing = false;
|
|
bool isBalanceBlur = true;
|
|
FocusNode walletNameFocus = FocusNode();
|
|
TextEditingController nameController = TextEditingController();
|
|
String walletID;
|
|
bool isDefaultWallet;
|
|
|
|
Future<NewWallet> get badWallet => null;
|
|
|
|
Future _getPubkeyFromDewif(
|
|
String _dewif, _pin, int _pinLenght, int derivation) async {
|
|
String _pubkey;
|
|
RegExp regExp = new RegExp(
|
|
r'^[A-Z0-9]+$',
|
|
caseSensitive: false,
|
|
multiLine: false,
|
|
);
|
|
|
|
if (regExp.hasMatch(_pin) == true && _pin.length == _pinLenght) {
|
|
} else {
|
|
return 'false';
|
|
}
|
|
if (derivation != -1) {
|
|
try {
|
|
List _pubkeysTmp = await DubpRust.getBip32DewifAccountsPublicKeys(
|
|
dewif: _dewif, secretCode: _pin, accountsIndex: [derivation]);
|
|
_pubkey = _pubkeysTmp[0];
|
|
this.pubkey.text = _pubkey;
|
|
notifyListeners();
|
|
|
|
return _pubkey;
|
|
} catch (e) {
|
|
log.w('Bad PIN code !\n' + e);
|
|
notifyListeners();
|
|
|
|
return 'false';
|
|
}
|
|
} else {
|
|
try {
|
|
_pubkey = await DubpRust.getDewifPublicKey(dewif: _dewif, pin: _pin);
|
|
this.pubkey.text = _pubkey;
|
|
notifyListeners();
|
|
return _pubkey;
|
|
} catch (e) {
|
|
log.w('Bad PIN code !\n' + e);
|
|
notifyListeners();
|
|
|
|
return 'false';
|
|
}
|
|
}
|
|
}
|
|
|
|
Future readLocalWallet(
|
|
context, WalletData _wallet, String _pin, int _pinLenght) async {
|
|
HomeProvider _homeProvider =
|
|
Provider.of<HomeProvider>(context, listen: false);
|
|
isWalletUnlock = false;
|
|
try {
|
|
File _walletFile = File('${walletsDirectory.path}/0/wallet.dewif');
|
|
String _localDewif = await _walletFile.readAsString();
|
|
String _localPubkey;
|
|
// log.d("$_localDewif $_pin $_pinLenght ${_wallet.derivation}");
|
|
|
|
// String mnemo = await DubpRust.getBip32DewifMnemonic(
|
|
// dewif: _localDewif, secretCode: _pin);
|
|
// log.d(mnemo.toString());
|
|
|
|
if ((_localPubkey = await _getPubkeyFromDewif(
|
|
_localDewif, _pin, _pinLenght, _wallet.derivation)) !=
|
|
'false') {
|
|
this.pubkey.text = _localPubkey;
|
|
isWalletUnlock = true;
|
|
return _localDewif;
|
|
} else {
|
|
throw 'Bad pubkey';
|
|
}
|
|
} catch (e) {
|
|
// _homeProvider.playSound('non', 0.6);
|
|
log.e('ERROR READING FILE: $e');
|
|
this.pubkey.clear();
|
|
return 'bad';
|
|
}
|
|
}
|
|
|
|
Future checkPinOK(String _createdDewif, String _pin, int _pinLenght) async {
|
|
isWalletUnlock = false;
|
|
try {
|
|
if (await _getPubkeyFromDewif(_createdDewif, _pin, _pinLenght, 3) !=
|
|
'false') {
|
|
return true;
|
|
} else {
|
|
throw false;
|
|
}
|
|
} catch (e) {
|
|
log.e('ERROR READING FILE: $e');
|
|
return false;
|
|
}
|
|
}
|
|
|
|
int getPinLenght(_walletNbr) {
|
|
String _localDewif;
|
|
if (_walletNbr is int) {
|
|
File _walletFile = File('${walletsDirectory.path}/0/wallet.dewif');
|
|
_localDewif = _walletFile.readAsStringSync();
|
|
} else {
|
|
_localDewif = _walletNbr;
|
|
}
|
|
|
|
final int _pinLenght = DubpRust.getDewifSecretCodeLen(
|
|
dewif: _localDewif, secretCodeType: SecretCodeType.letters);
|
|
|
|
return _pinLenght;
|
|
}
|
|
|
|
Future _renameWallet(_walletID, _newName) async {
|
|
final _walletConfig = File('${walletsDirectory.path}/0/list.conf');
|
|
|
|
String newConfig =
|
|
await _walletConfig.readAsLines().then((List<String> lines) {
|
|
int nbrLines = lines.length;
|
|
if (nbrLines != 1) {
|
|
for (String wLine in lines) {
|
|
String wID = "${wLine.split(':')[0]}:${wLine.split(':')[1]}";
|
|
String deri = wLine.split(':')[3];
|
|
if (wID == _walletID) {
|
|
lines.remove(wLine);
|
|
lines.add('$_walletID:$_newName:$deri');
|
|
}
|
|
}
|
|
return lines.join('\n');
|
|
} else {
|
|
return 'true';
|
|
}
|
|
});
|
|
|
|
await _walletConfig.delete();
|
|
await _walletConfig.writeAsString(newConfig);
|
|
_newWalletName.text = '';
|
|
}
|
|
|
|
Future<bool> renameWalletAlerte(
|
|
context, _walletName, _walletNbr, _derivation) async {
|
|
return showDialog<bool>(
|
|
context: context,
|
|
barrierDismissible: true,
|
|
builder: (BuildContext context) {
|
|
return AlertDialog(
|
|
title: Text('Choisissez un nouveau nom pour ce portefeuille'),
|
|
content: SingleChildScrollView(
|
|
child: ListBody(
|
|
children: <Widget>[
|
|
TextField(
|
|
controller: this._newWalletName,
|
|
maxLines: 1,
|
|
textAlign: TextAlign.center,
|
|
decoration: InputDecoration(),
|
|
style: TextStyle(
|
|
fontSize: 14.0,
|
|
color: Colors.black,
|
|
fontWeight: FontWeight.bold)),
|
|
],
|
|
),
|
|
),
|
|
actions: <Widget>[
|
|
TextButton(
|
|
child: Text("Valider"),
|
|
onPressed: () {
|
|
WidgetsBinding.instance.addPostFrameCallback((_) async {
|
|
// await _renameWallet(_walletName, this._newWalletName.text,
|
|
// _walletNbr, _derivation);
|
|
});
|
|
// notifyListeners();
|
|
Navigator.pop(context, true);
|
|
},
|
|
),
|
|
],
|
|
);
|
|
},
|
|
);
|
|
}
|
|
|
|
Future<bool> editWalletName(_wID) async {
|
|
bool nameState;
|
|
if (isEditing) {
|
|
if (!nameController.text.contains(':') &&
|
|
nameController.text.length <= 39) {
|
|
await _renameWallet(_wID, nameController.text);
|
|
nameState = true;
|
|
} else {
|
|
nameState = false;
|
|
}
|
|
} else {
|
|
walletNameFocus.requestFocus();
|
|
nameState = true;
|
|
}
|
|
|
|
isEditing ? isEditing = false : isEditing = true;
|
|
notifyListeners();
|
|
return nameState;
|
|
}
|
|
|
|
Future<int> deleteWallet(context, wallet) async {
|
|
final bool _answer = await _confirmDeletingWallet(context, wallet.name);
|
|
|
|
if (_answer) {
|
|
final _walletConfig = File('${walletsDirectory.path}/0/list.conf');
|
|
|
|
if (wallet.derivation != -1) {
|
|
String newConfig =
|
|
await _walletConfig.readAsLines().then((List<String> lines) {
|
|
lines.removeWhere((element) => element.contains(wallet.inLine()));
|
|
|
|
return lines.join('\n');
|
|
});
|
|
|
|
await _walletConfig.delete();
|
|
await _walletConfig.writeAsString(newConfig);
|
|
} else {
|
|
final _walletFile =
|
|
Directory('${walletsDirectory.path}/${wallet.number}');
|
|
await _walletFile.delete(recursive: true);
|
|
}
|
|
Navigator.popUntil(
|
|
context,
|
|
ModalRoute.withName('/mywallets'),
|
|
);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
Future<bool> _confirmDeletingWallet(context, _walletName) async {
|
|
return showDialog<bool>(
|
|
context: context,
|
|
barrierDismissible: true, // user must tap button!
|
|
builder: (BuildContext context) {
|
|
return AlertDialog(
|
|
title: Text(
|
|
'Êtes-vous sûr de vouloir supprimer le portefeuille "$_walletName" ?'),
|
|
content: SingleChildScrollView(
|
|
child: ListBody(
|
|
children: <Widget>[
|
|
Text('Vous pourrez restaurer ce portefeuille plus tard.'),
|
|
],
|
|
),
|
|
),
|
|
actions: <Widget>[
|
|
TextButton(
|
|
child: Text("Non", key: Key('cancelDeleting')),
|
|
onPressed: () {
|
|
Navigator.pop(context, false);
|
|
},
|
|
),
|
|
TextButton(
|
|
child: Text("Oui", key: Key('confirmDeleting')),
|
|
onPressed: () {
|
|
Navigator.pop(context, true);
|
|
},
|
|
),
|
|
],
|
|
);
|
|
},
|
|
);
|
|
}
|
|
|
|
Future<NewWallet> changePin(_name, _oldPin) async {
|
|
try {
|
|
final _walletFile = Directory('${walletsDirectory.path}/$_name');
|
|
final _dewif =
|
|
File(_walletFile.path + '/wallet.dewif').readAsLinesSync()[0];
|
|
|
|
NewWallet newWalletFile = await DubpRust.changeDewifPin(
|
|
dewif: _dewif,
|
|
oldPin: _oldPin,
|
|
);
|
|
|
|
newPin.text = newWalletFile.pin;
|
|
ischangedPin = true;
|
|
// notifyListeners();
|
|
return newWalletFile;
|
|
} catch (e) {
|
|
log.e('Impossible de changer le code PIN.');
|
|
return badWallet;
|
|
}
|
|
}
|
|
|
|
Future storeWallet(context, _name, _newWalletFile) async {
|
|
final Directory walletNameDirectory =
|
|
Directory('${walletsDirectory.path}/$_name');
|
|
final walletFile = File('${walletNameDirectory.path}/wallet.dewif');
|
|
|
|
walletFile.writeAsString('${_newWalletFile.dewif}');
|
|
Navigator.pop(context);
|
|
return _name;
|
|
}
|
|
|
|
snackCopyKey(context) {
|
|
final snackBar = SnackBar(
|
|
content:
|
|
Text("Cette clé publique a été copié dans votre presse-papier."),
|
|
duration: Duration(seconds: 2));
|
|
ScaffoldMessenger.of(context).showSnackBar(snackBar);
|
|
}
|
|
|
|
String getShortPubkey(String pubkey) {
|
|
log.d(pubkey);
|
|
List<int> pubkeyByte = Base58Decode(pubkey);
|
|
Digest pubkeyS256 = sha256.convert(sha256.convert(pubkeyByte).bytes);
|
|
String pubkeyCheksum = Base58Encode(pubkeyS256.bytes);
|
|
String pubkeyChecksumShort = truncate(pubkeyCheksum, 3,
|
|
omission: "", position: TruncatePosition.end);
|
|
|
|
String pubkeyShort = truncate(pubkey, 5,
|
|
omission: String.fromCharCode(0x2026),
|
|
position: TruncatePosition.end) +
|
|
truncate(pubkey, 4, omission: "", position: TruncatePosition.start) +
|
|
':$pubkeyChecksumShort';
|
|
|
|
return pubkeyShort;
|
|
}
|
|
|
|
void bluringBalance() {
|
|
isBalanceBlur = !isBalanceBlur;
|
|
notifyListeners();
|
|
}
|
|
|
|
Future<Uint8List> generateQRcode(String _pubkey) async {
|
|
return await scanner.generateBarCode(_pubkey);
|
|
}
|
|
|
|
void defAsDefaultWallet(String _id) {
|
|
defaultWalletFile.deleteSync();
|
|
defaultWalletFile.createSync();
|
|
defaultWalletFile.writeAsStringSync(_id);
|
|
notifyListeners();
|
|
}
|
|
|
|
Future changeAvatar() async {
|
|
File _image;
|
|
final picker = ImagePicker();
|
|
|
|
final pickedFile = await picker.getImage(source: ImageSource.gallery);
|
|
|
|
if (pickedFile != null) {
|
|
_image = File(pickedFile.path);
|
|
return _image;
|
|
} else {
|
|
log.w('No image selected.');
|
|
}
|
|
}
|
|
|
|
void reloadBuild() {
|
|
notifyListeners();
|
|
}
|
|
}
|