Change how the no missing word cases are handled

Author: Coding-Enthusiast

Src/FinderOuter/Services/MnemonicSevice.cs

@@ -1425,67 +1425,30 @@ public async void FindMissing(MnemonicSearchSpace ss, string pass, string path,
                 return;
             }
 
-            try
-            {
-                this.path = new BIP0032Path(path);
-            }
-            catch (Exception ex)
-            {
-                report.Fail($"Invalid path ({ex.Message}).");
-                this.path = null;
-            }
-
             if (!InputService.TryGetCompareService(compType, comp, out comparer))
             {
                 report.Fail($"Invalid extra input or input type {compType}.");
                 comparer = null;
             }
 
+            this.path = MnemonicSearchSpace.ProcessPath(path, out string pathError);
+
             if (ss.MissCount == 0)
             {
-                try
-                {
-                    BIP0032 temp = ss.mnType switch
-                    {
-                        MnemonicTypes.BIP39 => new BIP0039(ss.Input, ss.wl, pass),
-                        MnemonicTypes.Electrum => new ElectrumMnemonic(ss.Input, ss.wl, pass),
-                        _ => throw new ArgumentException("Undefined mnemonic type.")
-                    };
-
-                    report.Pass($"Given input is a valid {ss.mnType} mnemonic.");
-
-                    if (path is null || comparer is null)
-                    {
-                        report.AddMessageSafe("Path or compare input is not set correctly to check the derived key.");
-                        return;
-                    }
-
-                    uint startIndex = this.path.Indexes[^1];
-                    uint[] indices = new uint[this.path.Indexes.Length - 1];
-                    Array.Copy(this.path.Indexes, 0, indices, 0, indices.Length);
-                    BIP0032Path newPath = new(indices);
-
-                    PrivateKey[] keys = temp.GetPrivateKeys(newPath, 1, startIndex);
-                    if (comparer.Compare(keys[0].ToBytes()))
-                    {
-                        report.Pass($"The given child key is derived from this mnemonic at {this.path} path.");
-                    }
-                    else
-                    {
-                        report.Fail($"The given child key is not derived from this mnemonic or not at {this.path} path.");
-                    }
-                }
-                catch (Exception ex)
-                {
-                    report.Fail($"Mnemonic is not missing any characters but is invalid. Error: {ex.Message}");
-                }
+                report.FoundAnyResult = ss.ProcessNoMissing(comparer, pass, this.path, out string message);
+                report.AddMessageSafe(message);
+                return;
+            }
 
+            if (path is null)
+            {
+                report.Fail($"Could not parse the given derivation path (error message: {pathError}).");
                 return;
             }
 
-            if (path is null || comparer is null)
+            if (comparer is null || !comparer.IsInitialized)
             {
-                report.AddMessageSafe("Path or compare input is not set correctly to check the derived key.");
+                report.Fail("Set the compare value correctly to verify the derived key/address.");
                 return;
             }
 

Src/FinderOuter/Services/SearchSpaces/MnemonicSearchSpace.cs

@@ -125,7 +125,7 @@ public bool Process(string mnemonic, char missChar, MnemonicTypes mnType, BIP003
         }
 
 
-        private BIP0032Path ProcessPath(string path, out string error)
+        public static BIP0032Path ProcessPath(string path, out string error)
         {
             BIP0032Path result;
             try
@@ -142,7 +142,7 @@ private BIP0032Path ProcessPath(string path, out string error)
             return result;
         }
 
-        public bool ProcessNoMissing(ICompareService comparer, string pass, string path, out string message)
+        public bool ProcessNoMissing(ICompareService comparer, string pass, BIP0032Path path, out string message)
         {
             if (MissCount != 0)
             {
@@ -161,11 +161,10 @@ public bool ProcessNoMissing(ICompareService comparer, string pass, string path,
 
                 message = $"Given input is a valid {mnType} mnemonic.";
 
-                BIP0032Path bipPath = ProcessPath(path, out string error);
-                if (bipPath is null)
+                if (path is null)
                 {
                     message += Environment.NewLine;
-                    message += $"Could not set derivation path ({error}).";
+                    message += "Derivation path is not set.";
                     return true; // The mnemonic is valid, we just can't derive child keys to do extra checks
                 }
 
@@ -175,22 +174,22 @@ public bool ProcessNoMissing(ICompareService comparer, string pass, string path,
                     return true; // Same as above
                 }
 
-                uint startIndex = bipPath.Indexes[^1];
-                uint[] indices = new uint[bipPath.Indexes.Length - 1];
-                Array.Copy(bipPath.Indexes, 0, indices, 0, indices.Length);
+                uint startIndex = path.Indexes[^1];
+                uint[] indices = new uint[path.Indexes.Length - 1];
+                Array.Copy(path.Indexes, 0, indices, 0, indices.Length);
                 BIP0032Path newPath = new(indices);
 
                 PrivateKey[] keys = temp.GetPrivateKeys(newPath, 1, startIndex);
                 if (comparer.Compare(keys[0].ToBytes()))
                 {
                     message += Environment.NewLine;
-                    message += $"The given child key is correctly derived from this mnemonic at {bipPath} path.";
+                    message += $"The given child key is correctly derived from this mnemonic at {path} path.";
                     return true;
                 }
                 else
                 {
                     message += Environment.NewLine;
-                    message += $"The given child key is not derived from this mnemonic or not at {bipPath} path.";
+                    message += $"The given child key is not derived from this mnemonic or not at {path} path.";
                     message += $"List of all address types that can be derived from this mnemonic at the given path:" +
                                $"{Environment.NewLine}" +
                                $"{AddressService.GetAllAddresses(keys[0].ToPublicKey(comparer.Calc))}";