Merge multilingual support with null safety

.gitignore

@@ -10,3 +10,4 @@ build/
 # Directory created by dartdoc
 doc/api/
 .idea/
+.vscode/

CHANGELOG.md

@@ -10,6 +10,16 @@
 
 - Remove async function
 
+
+## 1.0.4
+
+-forked from bip39
+-added multi lingual support and languages
+
 ## 1.0.6
 
 - Resolved nullsafety code issues
+
+## 1.0.7
+
+- Add multilangual mnemonic support: English, French, Italian and Spanish

README.md

@@ -1,4 +1,4 @@
-# BIP39
+# BIP39_MULTI
 
 Dart implementation of [Bitcoin BIP39](https://github.com/bitcoin/bips/blob/master/bip-0039.mediawiki): Mnemonic code for generating deterministic keys
 
@@ -34,7 +34,7 @@ bip39.validateMnemonic('basket actual')
 
 
 ``` dart
-import 'package:bip39/bip39.dart' as bip39;
+import 'package:bip39_multi/bip39_multi.dart' as bip39;
 
 main() {
     // Only support BIP39 English word list
@@ -53,7 +53,7 @@ main() {
     isValid = await bip39.validateMnemonic('basket actual');
     // => false
 
-    String entropy = bip39.mnemonicToEntropy(mnemonic)
+    String entropy = bip39.mnemonicToEntropy(mnemonic);
     // => String '00000000000000000000000000000000'
 }
 ```

example/bip39_example.dart

@@ -1,9 +1,10 @@
-import 'package:bip39/bip39.dart' as bip39;
+import 'package:bip39_multi_nullsafety/bip39_multi_nullsafety.dart' as bip39;
 
 main() async {
   String randomMnemonic = bip39.generateMnemonic();
   print(randomMnemonic);
-  String seed = bip39.mnemonicToSeedHex("update elbow source spin squeeze horror world become oak assist bomb nuclear");
+  String seed = bip39.mnemonicToSeedHex(
+      "update elbow source spin squeeze horror world become oak assist bomb nuclear");
   print(seed);
   String mnemonic = bip39.entropyToMnemonic('00000000000000000000000000000000');
   print(mnemonic);

lib/src/bip39_base.dart

@@ -5,8 +5,9 @@ import 'package:crypto/crypto.dart' show sha256;
 import 'package:hex/hex.dart';
 
 import 'utils/pbkdf2.dart';
-import 'wordlists/english.dart';
+import 'wordlists/all.dart';
 
+const String _defaultLanguage="english";
 const int _SIZE_BYTE = 255;
 const _INVALID_MNEMONIC = 'Invalid mnemonic';
 const _INVALID_ENTROPY = 'Invalid entropy';
@@ -45,17 +46,18 @@ Uint8List _randomBytes(int size) {
   }
   return bytes;
 }
-
-String generateMnemonic(
-    {int strength = 128, RandomBytes randomBytes = _randomBytes}) {
+String generateMnemonic({
+  int strength = 128,
+  RandomBytes randomBytes = _randomBytes,
+  String language=_defaultLanguage
+}) {
   assert(strength % 32 == 0);
   final entropy = randomBytes(strength ~/ 8);
-  return entropyToMnemonic(HEX.encode(entropy));
+  return entropyToMnemonic(HEX.encode(entropy),language: language);
 }
-
-String entropyToMnemonic(String entropyString) {
+String entropyToMnemonic(String entropyString,{String language=_defaultLanguage}) {
   final entropy = Uint8List.fromList(HEX.decode(entropyString));
-  if (entropy.length < 16) {
+  if (entropy.length < 4) {
     throw ArgumentError(_INVALID_ENTROPY);
   }
   if (entropy.length > 32) {
@@ -72,9 +74,8 @@ String entropyToMnemonic(String entropyString) {
       .allMatches(bits)
       .map((match) => match.group(0)!)
       .toList(growable: false);
-  List<String> wordlist = WORDLIST;
-  String words =
-      chunks.map((binary) => wordlist[_binaryToByte(binary)]).join(' ');
+  List<String>? wordlist = WORDLIST[language];
+  String words = chunks.map((binary) => wordlist![_binaryToByte(binary)]).join(' ');
   return words;
 }
 
@@ -88,30 +89,28 @@ String mnemonicToSeedHex(String mnemonic, {String passphrase = ""}) {
     return byte.toRadixString(16).padLeft(2, '0');
   }).join('');
 }
-
-bool validateMnemonic(String mnemonic) {
+bool validateMnemonic(String mnemonic,{String language=_defaultLanguage}) {
   try {
-    mnemonicToEntropy(mnemonic);
+    mnemonicToEntropy(mnemonic,language: language);
   } catch (e) {
     return false;
   }
   return true;
 }
-
-String mnemonicToEntropy(mnemonic) {
+String mnemonicToEntropy (mnemonic,{String language=_defaultLanguage}) {
   var words = mnemonic.split(' ');
   if (words.length % 3 != 0) {
     throw new ArgumentError(_INVALID_MNEMONIC);
   }
-  final wordlist = WORDLIST;
-  // convert word indices to 11 bit binary strings
-  final bits = words.map((word) {
-    final index = wordlist.indexOf(word);
-    if (index == -1) {
-      throw new ArgumentError(_INVALID_MNEMONIC);
-    }
-    return index.toRadixString(2).padLeft(11, '0');
-  }).join('');
+  final wordlist = WORDLIST[language];
+    // convert word indices to 11 bit binary strings
+    final bits = words.map((word) {
+      final index = wordlist!.indexOf(word);
+      if (index == -1) {
+        throw new ArgumentError(_INVALID_MNEMONIC);
+      }
+      return index.toRadixString(2).padLeft(11, '0');
+    }).join('');
   // split the binary string into ENT/CS
   final dividerIndex = (bits.length / 33).floor() * 32;
   final entropyBits = bits.substring(0, dividerIndex);
@@ -123,7 +122,7 @@ String mnemonicToEntropy(mnemonic) {
       .allMatches(entropyBits)
       .map((match) => _binaryToByte(match.group(0)!))
       .toList(growable: false));
-  if (entropyBytes.length < 16) {
+  if (entropyBytes.length < 4) {
     throw StateError(_INVALID_ENTROPY);
   }
   if (entropyBytes.length > 32) {

lib/src/wordlists/all.dart

@@ -0,0 +1,11 @@
+import 'english.dart' as english;
+import 'french.dart' as french;
+import 'italian.dart' as italian;
+import 'spanish.dart' as spanish;
+
+const Map<String,List<String>> WORDLIST = {
+  "english":  english.WORDLIST,
+  "french":   french.WORDLIST,
+  "italian":  italian.WORDLIST,
+  "spanish":  spanish.WORDLIST
+};

lib/src/wordlists/english.dart

@@ -1,4 +1,4 @@
-const WORDLIST = [
+const List<String> WORDLIST = [
   "abandon",
   "ability",
   "able",