Exemplo n.º 1
0
        // NEW START
        ////////////////////////////////////////////
        // Pure functions
        //public static bool IsMinerAlgorithmAvaliable(List<Algorithm> algos, MinerBaseType minerBaseType, AlgorithmType algorithmType) {
        //    return algos.FindIndex((a) => a.MinerBaseType == minerBaseType && a.NiceHashID == algorithmType) > -1;
        //}

        public static string GetPathFor(MinerBaseType minerBaseType, AlgorithmType algoType, DeviceGroupType devGroupType, bool def = false)
        {
            if (!def & configurableMiners.Contains(minerBaseType))
            {
                // Override with internals
                var path = minerPathPackages.Find(p => p.DeviceType == devGroupType)
                           .MinerTypes.Find(p => p.Type == minerBaseType)
                           .Algorithms.Find(p => p.Algorithm == algoType);
                if (path != null)
                {
                    if (File.Exists(path.Path))
                    {
                        return(path.Path);
                    }
                    else
                    {
                        Helpers.ConsolePrint("PATHS", String.Format("Path {0} not found, using defaults", path.Path));
                    }
                }
            }
            switch (minerBaseType)
            {
            case MinerBaseType.ccminer:
                return(NVIDIA_GROUPS.ccminer_path(algoType, devGroupType));

            case MinerBaseType.sgminer:
                return(AMD_GROUP.sgminer_path(algoType));

            case MinerBaseType.nheqminer:
                return(Data.nheqminer);

            case MinerBaseType.ethminer:
                return(Data.ethminer);

            case MinerBaseType.Claymore:
                return(AMD_GROUP.ClaymorePath(algoType));

            case MinerBaseType.OptiminerAMD:
                return(Data.OptiminerZcashMiner);

            case MinerBaseType.excavator:
                return(Data.excavator);

            case MinerBaseType.XmrStackCPU:
                return(Data.XmrStackCPUMiner);

            case MinerBaseType.ccminer_alexis:
                return(NVIDIA_GROUPS.ccminer_unstable_path(algoType, devGroupType));

            case MinerBaseType.experimental:
                return(EXPERIMENTAL.GetPath(algoType, devGroupType));

            case MinerBaseType.EWBF:
                return(Data.EWBF);

            case MinerBaseType.Prospector:
                return(Data.prospector);
            }
            return(Data.NONE);
        }
Exemplo n.º 2
0
        // NEW START
        ////////////////////////////////////////////
        // Pure functions
        //public static bool IsMinerAlgorithmAvaliable(List<Algorithm> algos, MinerBaseType minerBaseType, AlgorithmType algorithmType) {
        //    return algos.FindIndex((a) => a.MinerBaseType == minerBaseType && a.NiceHashID == algorithmType) > -1;
        //}

        public static string GetPathFor(MinerBaseType minerBaseType, AlgorithmType algoType, DeviceGroupType devGroupType) {
            switch (minerBaseType) {
                case MinerBaseType.ccminer:
                    return NVIDIA_GROUPS.ccminer_path(algoType, devGroupType);
                case MinerBaseType.sgminer:
                    return AMD_GROUP.sgminer_path(algoType);
                case MinerBaseType.nheqminer:
                    return Data.nheqminer;
                case MinerBaseType.ethminer:
                    return Data.ethminer;
                case MinerBaseType.Claymore:
                    return AMD_GROUP.ClaymorePath(algoType);
                case MinerBaseType.OptiminerAMD:
                    return Data.OptiminerZcashMiner;
                case MinerBaseType.excavator:
                    return Data.excavator;
                case MinerBaseType.XmrStackCPU:
                    return Data.XmrStackCPUMiner;
                case MinerBaseType.ccminer_alexis:
                    return NVIDIA_GROUPS.ccminer_unstable_path(algoType, devGroupType);
                case MinerBaseType.experimental:
                    return EXPERIMENTAL.GetPath(algoType, devGroupType);
                case MinerBaseType.EWBF:
                    return Data.EWBF;
            }
            return Data.NONE;
        }
Exemplo n.º 3
0
        // NEW START
        ////////////////////////////////////////////
        // Pure functions
        //public static bool IsMinerAlgorithmAvaliable(List<Algorithm> algos, MinerBaseType minerBaseType, AlgorithmType algorithmType) {
        //    return algos.FindIndex((a) => a.MinerBaseType == minerBaseType && a.NiceHashID == algorithmType) > -1;
        //}

        public static string GetPathFor(MinerBaseType minerBaseType, AlgorithmType algoType, DeviceGroupType devGroupType, bool def = false)
        {
            if (!def & configurableMiners.Contains(minerBaseType))
            {
                // Override with internals
                var path = minerPathPackages.Find(p => p.DeviceType == devGroupType)
                           .MinerTypes.Find(p => p.Type == minerBaseType)
                           .Algorithms.Find(p => p.Algorithm == algoType);
                if (path != null)
                {
                    if (File.Exists(path.Path))
                    {
                        return(path.Path);
                    }
                    else
                    {
                        Helpers.ConsolePrint("PATHS", String.Format("Path {0} not found, using defaults", path.Path));
                    }
                }
            }
            switch (minerBaseType)
            {
            case MinerBaseType.ccminer:
                return(NVIDIA_GROUPS.Ccminer_path(algoType, devGroupType));

            case MinerBaseType.ccminer_22:
                return(NVIDIA_GROUPS.Ccminer_path(algoType, devGroupType));

            case MinerBaseType.ccminer_alexis_hsr:
                return(NVIDIA_GROUPS.Ccminer_path(algoType, devGroupType));

            case MinerBaseType.ccminer_alexis78:
                return(NVIDIA_GROUPS.Ccminer_path(algoType, devGroupType));

            case MinerBaseType.ccminer_klaust818:
                return(NVIDIA_GROUPS.Ccminer_path(algoType, devGroupType));

            case MinerBaseType.ccminer_palgin:
                return(NVIDIA_GROUPS.Ccminer_path(algoType, devGroupType));

            case MinerBaseType.ccminer_polytimos:
                return(NVIDIA_GROUPS.Ccminer_path(algoType, devGroupType));

            case MinerBaseType.ccminer_skunkkrnlx:
                return(NVIDIA_GROUPS.Ccminer_path(algoType, devGroupType));

            case MinerBaseType.ccminer_xevan:
                return(NVIDIA_GROUPS.Ccminer_path(algoType, devGroupType));

            case MinerBaseType.ccminer_tpruvot2:
                return(NVIDIA_GROUPS.Ccminer_path(algoType, devGroupType));

            case MinerBaseType.sgminer:
                return(AMD_GROUP.Sgminer_path(algoType));

            case MinerBaseType.GatelessGate:
                return(AMD_GROUP.Glg_path(algoType));

            case MinerBaseType.nheqminer:
                return(Data.nheqminer);

            case MinerBaseType.ethminer:
                return(Data.ethminer);

            case MinerBaseType.Claymore:
                return(AMD_GROUP.ClaymorePath(algoType));

            case MinerBaseType.OptiminerAMD:
                return(Data.OptiminerZcashMiner);

            case MinerBaseType.excavator:
                return(Data.excavator);

            case MinerBaseType.XmrStackCPU:
                return(Data.XmrStackCPUMiner);

            case MinerBaseType.ccminer_alexis:
                return(NVIDIA_GROUPS.Ccminer_unstable_path(algoType, devGroupType));

            case MinerBaseType.experimental:
                return(EXPERIMENTAL.GetPath(algoType, devGroupType));

            case MinerBaseType.EWBF:
                return(Data.EWBF);

            case MinerBaseType.DSTM:
                return(Data.DSTM);

            case MinerBaseType.Prospector:
                return(Data.prospector);

            case MinerBaseType.Xmrig:
                return(Data.Xmrig);

            case MinerBaseType.XmrStakAMD:
                return(Data.XmrStakAMD);

            case MinerBaseType.Claymore_old:
                return(Data.ClaymoreCryptoNightMiner_old);

            case MinerBaseType.hsrneoscrypt:
                return(NVIDIA_GROUPS.Hsrneoscrypt_path(algoType, devGroupType));

                //case MinerBaseType.mkxminer:
                //return Data.mkxminer;
            }
            return(Data.NONE);
        }
Exemplo n.º 4
0
        // NEW START
        ////////////////////////////////////////////
        // Pure functions
        //public static bool IsMinerAlgorithmAvaliable(List<Algorithm> algos, MinerBaseType minerBaseType, AlgorithmType algorithmType) {
        //    return algos.FindIndex((a) => a.MinerBaseType == minerBaseType && a.CryptoMiner937ID == algorithmType) > -1;
        //}
        /// <summary>
        /// The GetPathFor
        /// </summary>
        /// <param name="minerBaseType">The <see cref="MinerBaseType"/></param>
        /// <param name="algoType">The <see cref="AlgorithmType"/></param>
        /// <param name="devGroupType">The <see cref="DeviceGroupType"/></param>
        /// <param name="def">The <see cref="bool"/></param>
        /// <returns>The <see cref="string"/></returns>
        public static string GetPathFor(MinerBaseType minerBaseType, AlgorithmType algoType, DeviceGroupType devGroupType, CPUExtensionType MostOptimizedCPUExtensionType, bool def = false)
        {
            if (!def & configurableMiners.Contains(minerBaseType))
            {
                // Override with internals
                var path = minerPathPackages.Find(p => p.DeviceType == devGroupType)
                           .MinerTypes.Find(p => p.Type == minerBaseType)
                           .Algorithms.Find(p => p.Algorithm == algoType);
                if (path != null)
                {
                    if (File.Exists(path.Path))
                    {
                        return(path.Path);
                    }
                    else
                    {
                        Helpers.ConsolePrint("PATHS", String.Format("Path {0} not found, using defaults", path.Path));
                    }
                }
            }
            switch (minerBaseType)
            {
            case MinerBaseType.cpuminer:
                return(CPU_GROUP.cpu_miner_opt(MostOptimizedCPUExtensionType));

            case MinerBaseType.ccminer:
                return(NVIDIA_GROUPS.Ccminer_path(algoType, devGroupType));

            case MinerBaseType.ccminer_tpruvot2:
                return(NVIDIA_GROUPS.Ccminer_path(algoType, devGroupType));

            case MinerBaseType.sgminer:
                return(AMD_GROUP.Sgminer_path(algoType));

            case MinerBaseType.GatelessGate:
                return(AMD_GROUP.Glg_path(algoType));

            case MinerBaseType.Claymore:
                return(AMD_GROUP.ClaymorePath(algoType));

            case MinerBaseType.OptiminerAMD:
                return(Data.OptiminerZcashMiner);

            case MinerBaseType.experimental:
                return(EXPERIMENTAL.GetPath(algoType, devGroupType));

            case MinerBaseType.CPU_XMRig:
                return(Data.CPU_XMRig);

            case MinerBaseType.CPU_XMRigUPX:
                return(Data.CPU_XMRigUPX);

            case MinerBaseType.CPU_RKZ:
                return(Data.CPU_RKZ);

            case MinerBaseType.CPU_rplant:
                return(Data.CPU_rplant);

            case MinerBaseType.CPU_nosuch:
                return(Data.CPU_nosuch);

            case MinerBaseType.trex:
                return(NVIDIA_GROUPS.trex(algoType, devGroupType));

            case MinerBaseType.MiniZ:
                return(NVIDIA_GROUPS.MiniZ(algoType, devGroupType));

            case MinerBaseType.ZEnemy:
                return(NVIDIA_GROUPS.ZEnemy(algoType, devGroupType));

            case MinerBaseType.CryptoDredge:
                return(NVIDIA_GROUPS.CryptoDredge(algoType, devGroupType));

            case MinerBaseType.CPU_verium:
                return(Data.CPU_verium);
            }
            return(Data.NONE);
        }