Topic: GPU-Mining-Profit. Zeit, aufzuwachen? (Read 3721 times)

####################################################
# Altcoin Switcher                                 #
# for most coins listed on Cryptsy                 #
# thx to area for his CryptoSwitcher without his   #
# coding style i would have not started playing    #  
# around with python  :)                           #
#                                                  #
# TipJar (BTC): 1H6L4VjrmRizXLLbrKLJQyx7vg87ZLjubD #
# Author: minime                                   #
####################################################


import urllib2
from bs4 import BeautifulSoup
import urllib2
import shutil
import os
import time
import paramiko
import subprocess
import numpy as np
import sys
# Ugly hack so git submodule init is adequate.
sys.path.insert(0, './PyCryptsy/')
from PyCryptsy import PyCryptsy
import itertools
import ConfigParser
import re
import simplejson
import socket

class Coin:
  def __init__(self, name):
   self.ratio=0 # assume totally unprofitable unless otherwise shown to be the case.
   self.willingToMine = False
   self.miningNow = False
   self.willingToSell = False
   self.command = '' # coins['arg'].div = float(coins['arg'].div.sting)the command that is run when we want to mine this coin.
   self.name = name
   self.cnt = 0
   self.median = 0
   self.m = 0
   self.h = 0
   self.fee = 0
   self.source = '--'
   self.price = 0.0
   self.div = 9999999999.9 # start off with ridiculously high diff so we dont mine the wrong coin
   self.reward = 0
   self.algo = ""
#list of Coins
coins = {}
coins['btc'] =  Coin('BitCoin')
coins['42'] =  Coin('42Coin')
coins['leaf'] =  Coin('LeafCoin')
coins['dgc'] =  Coin('DigitalCoin')
coins['glc'] =  Coin('GlobalCoin')
coins['lot'] =  Coin('LottoCoin')
coins['eac'] =  Coin('EarthCoin')
coins['arg'] =  Coin('Argentum')
coins['bqc'] =  Coin('BBQCoin')
coins['doge'] =  Coin('DogeCoin')
coins['frk'] =  Coin('Franko')
coins['anc'] =  Coin('AnonCoin')
coins['ftc'] =  Coin('FeatherCoin')
coins['cnc'] =  Coin('CHNCoin')
#coins['btb'] =  Coin('BitBar')
coins['mec'] =  Coin('MegaCoin')
coins['ltc'] =  Coin('LiteCoin')
coins['wdc'] =  Coin('WorldCoin')
#coins['nvc'] =  Coin('NovaCoin')
coins['mnc'] =  Coin('MinCoin')
coins['tag'] =  Coin('TagCoin')
coins['phs'] =  Coin('Philostone')
coins['cmc'] =  Coin('CosmosCoin')
coins['sbc'] =  Coin('StableCoin')
coins['fst'] =  Coin('FastCoin')
coins['elc'] =  Coin('ElaCoin')
coins['crc'] =  Coin('CraftCoin')
coins['lky'] =  Coin('LuckyCoin')
coins['gld'] =  Coin('GoldCoin')
coins['csc'] =  Coin('CasinoCoin')
coins['dmd'] =  Coin('Diamond')
coins['cat'] =  Coin('CatCoin')

# Read in config file
Config = ConfigParser.ConfigParser()
Config.read('./Switcher.config')

# Enable the coins you want to mine here.
for key in coins:
    try:
        coins[key].willingToMine = Config.getboolean('MineCoins','mine'+key)
    except:
        continue

# You should have scripts that stop all other forms of mining, set
# your clocks and environment variables appropriately, and start
# mining the appropriate coin. I have these called 'litecoin.sh',
# 'bitcoin.sh' etc., but edit and/or replace these as you see fit.

# Any coins you aren't mining you can just leave blank.
for key in coins:
    try:
        coins[key].command = Config.get('Scripts',key+'script')
    except:
        continue




#defibe idletime 5 min standart
try:
    idletime = int(Config.get('Misc','idletime'))
except:
    idletime = 5
    


# create http handler
opener = urllib2.build_opener()
opener.addheaders = [('User-agent', 'Switcher')]

extout = True

# main loop
cnt_all = 0
while True:
    # print header
    print "time:", time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())

    # get data from sources
    prestr = "getting data... "

    #getting dificulty of BitCoin needed as basis for Calculation
    req = urllib2.Request("http://blockexplorer.com/q/getdifficulty")
    f = opener.open(req, timeout = 15)
    coins['btc'].div = simplejson.load(f)
    coins['btc'].reward = float(25)
    #getting price of Bitcoin @Bitstamp needed as basis for Calculation  
    #req = urllib2.Request("https://www.bitstamp.net/api/ticker/")
    #opener_cyp = urllib2.build_opener()
    #f = opener_cyp.open(req, timeout = 15)
    #data_cyp = simplejson.load(f)
    #if coins['btc'].price < float(data_cyp['last']):
        #coins['btc'].price = float(data_cyp['last'])

    #getting Data from Cryptsy
    i=0
    while i < 5:
try:
         req = urllib2.Request("http://pubapi.cryptsy.com/api.php?method=orderdata")
         opener_cyp = urllib2.build_opener()
         f = opener_cyp.open(req, timeout = 20)
         data_cyp = simplejson.load(f)
if i == 5: break
i+=1
        except:
            continue

    
    # loop through coins
    for abbreviation, c in coins.items():
        # only get profitability for coins which we are interested in.
        # this saves network traffic and running time
     if c.willingToMine==False:
         continue

     success = 0
     #assign Prices from Cryptsy to coins
     fullstr = prestr + "price of " + coins[abbreviation].name + " at Cryptsy"
     print fullstr + (79-len(fullstr))*" " + "\r",
     for item in data_cyp['return']:
       if item.lower()==abbreviation:
         if data_cyp['return'][item]['secondarycode']=='BTC':
           if coins[abbreviation].price < float(data_cyp['return'][item]['buyorders'][0]['price']):
               coins[abbreviation].price = float(data_cyp['return'][item]['buyorders'][0]['price'])  
    
       if abbreviation == '42':
           try:
      fullstr = prestr + "difficulty of " + coins['42'].name
               print fullstr + (79-len(fullstr))*" " + "\r",
               usock = urllib2.urlopen('http://altexplorer.net/chain/42', timeout = 15)
               data = usock.read()
               usock.close()
               soup = BeautifulSoup(data)
               v = soup.findAll('td', limit=10)
               coins['42'].div = soup.findAll('td')[9]
               coins['42'].div = float(coins['42'].div.string)
               coins['42'].reward = float(0.000042)
           except:
               continue

       if abbreviation == 'leaf':
  try:
      fullstr = prestr + "difficulty of " + coins['leaf'].name
               print fullstr + (79-len(fullstr))*" " + "\r",
               req = urllib2.Request('http://explorer.leafco.in/chain/leafcoin/q/getdifficulty')
      opener_cyp = urllib2.build_opener()
      f = opener_cyp.open(req, timeout = 15)
      coins['leaf'].div = simplejson.load(f)
               coins['leaf'].div = float(coins['leaf'].div)
               coins['leaf'].reward = float(250000.50)
           except:
               continue

       if abbreviation == 'glc':
  try:
      fullstr = prestr + "difficulty of " + coins['glc'].name
               print fullstr + (79-len(fullstr))*" " + "\r",
      req = urllib2.Request('http://blockchainx.com/chain/Globalcoin/q/getdifficulty')
      opener_cyp = urllib2.build_opener()
      f = opener_cyp.open(req, timeout = 15)
      coins['glc'].div = simplejson.load(f)
      coins['glc'].div = float(coins['glc'].div)
      coins['glc'].reward = float(100)
           except:
               continue

       if abbreviation == 'lot':
  try:
      fullstr = prestr + "difficulty of " + coins['lot'].name
               print fullstr + (79-len(fullstr))*" " + "\r",
      req = urllib2.Request('http://lottocoin.info/chain/lottocoin/q/getdifficulty')
      opener_cyp = urllib2.build_opener()
      f = opener_cyp.open(req, timeout = 15)
      coins['lot'].div = simplejson.load(f)
      coins['lot'].div = float(coins['lot'].div)
      coins['lot'].reward = float(32896)
           except:
               continue

       if abbreviation == 'eac':
  try:
      fullstr = prestr + "difficulty of " + coins['eac'].name
               print fullstr + (79-len(fullstr))*" " + "\r",
      req = urllib2.Request('http://earthchain.info/chain/EarthCoin/q/getdifficulty')
      opener_cyp = urllib2.build_opener()
      f = opener_cyp.open(req, timeout = 15)
      coins['eac'].div = simplejson.load(f)
      coins['eac'].div = float(coins['eac'].div)
      coins['eac'].reward = float(10000)
           except:
               continue

       if abbreviation == 'arg':
  try:
      fullstr = prestr + "difficulty of " + coins['arg'].name
               print fullstr + (79-len(fullstr))*" " + "\r",
      req = urllib2.Request('http://arg.webboise.com/chain/Argentum/q/getdifficulty')
      opener_cyp = urllib2.build_opener()
      f = opener_cyp.open(req, timeout = 15)
      coins['arg'].div = simplejson.load(f)
         coins['arg'].div = float(coins['arg'].div)
      coins['arg'].reward = float(3)
           except:
               continue

       if abbreviation == 'bqc':
  try:
      fullstr = prestr + "difficulty of " + coins['bqc'].name
               print fullstr + (79-len(fullstr))*" " + "\r",
      req = urllib2.Request('http://bbq.cryptocoinexplorer.com/chain/BBQCoin/q/getdifficulty')
      opener_cyp = urllib2.build_opener()
      f = opener_cyp.open(req, timeout = 15)
      coins['bqc'].div = simplejson.load(f)
      coins['bqc'].div = float(coins['bqc'].div)
      coins['bqc'].reward = float(42)
           except:
               continue

       if abbreviation == 'doge':
  try:
      fullstr = prestr + "difficulty of " + coins['doge'].name
               print fullstr + (79-len(fullstr))*" " + "\r",
      req = urllib2.Request('http://dogechain.info/chain/Dogecoin/q/getdifficulty')
      opener_cyp = urllib2.build_opener()
      f = opener_cyp.open(req, timeout = 25)
      coins['doge'].div = simplejson.load(f)
      coins['doge'].div = float(coins['doge'].div)
      coins['doge'].reward = float(250000)
           except:
      continue

       if abbreviation == 'anc':
  try:
      fullstr = prestr + "difficulty of " + coins['anc'].name
               print fullstr + (79-len(fullstr))*" " + "\r",
      req = urllib2.Request('http://explorer.anoncoin.net/chain/Anoncoin/q/getdifficulty')
      opener_cyp = urllib2.build_opener()
      f = opener_cyp.open(req, timeout = 15)
      coins['anc'].div = simplejson.load(f)
      coins['anc'].div = float(coins['anc'].div)  
        coins['anc'].reward = float(5)
           except:
               continue

       if abbreviation == 'btb':
  try:
      fullstr = prestr + "difficulty of " + coins['btb'].name
               print fullstr + (79-len(fullstr))*" " + "\r",
      req = urllib2.Request('http://btb.cryptocoinexplorer.com/chain/bitbar/q/getdifficulty')
      opener_cyp = urllib2.build_opener()
      f = opener_cyp.open(req, timeout = 15)
      coins['btb'].div = simplejson.load(f)
      coins['btb'].div = float(coins['btb'].div)
      coins['btb'].reward = float(0.20)
           except:
               continue

       if abbreviation == 'mec':
  try:
      fullstr = prestr + "difficulty of " + coins['mec'].name
               print fullstr + (79-len(fullstr))*" " + "\r",
      req = urllib2.Request('http://mega.rapta.net:2750/chain/Megacoin/q/getdifficulty')
      opener_cyp = urllib2.build_opener()
      f = opener_cyp.open(req, timeout = 15)
      coins['mec'].div = simplejson.load(f)
      coins['mec'].div = float(coins['mec'].div)
      coins['mec'].reward = float(25)
           except:
               continue


       if abbreviation == 'mnc':
  try:
      fullstr = prestr + "difficulty of " + coins['mnc'].name
               print fullstr + (79-len(fullstr))*" " + "\r",
      usock = urllib2.urlopen('http://mnc.cryptoexplore.com/', timeout = 15)
      data = usock.read()
      usock.close()
      soup = BeautifulSoup(data)
      j = soup.findAll('td', limit=5)
      coins['mnc'].div = soup.findAll('td')[4]
      coins['mnc'].div = float(coins['mnc'].div.string)
      coins['mnc'].reward = float(2)
           except:
               continue

       if abbreviation == 'meow':
  try:
      fullstr = prestr + "difficulty of " + coins['meow'].name
               print fullstr + (79-len(fullstr))*" " + "\r",
      req = urllib2.Request('http://kittehcoinblockexplorer.com/chain/Kittehcoin/q/getdifficulty')
      opener_cyp = urllib2.build_opener()
      f = opener_cyp.open(req, timeout = 15)
      coins['meow'].div = simplejson.load(f)
      coins['meow'].div = float(coins['meow'].div)
      coins['meow'].reward = float(25500)
           except:
               continue

       if abbreviation == 'sbc':
  try:
      fullstr = prestr + "difficulty of " + coins['sbc'].name
               print fullstr + (79-len(fullstr))*" " + "\r",
      req = urllib2.Request('http://sbc.blockexplorer.io/chain/Stablecoin/q/getdifficulty')
      opener_cyp = urllib2.build_opener()
      f = opener_cyp.open(req, timeout = 15)
        coins['sbc'].div = simplejson.load(f)
      coins['sbc'].div = float(coins['sbc'].div)
      coins['sbc'].reward = float(25)
           except:
               continue  

       if abbreviation == 'frk':
  try:
      fullstr = prestr + "difficulty of " + coins['frk'].name
               print fullstr + (79-len(fullstr))*" " + "\r",
      req = urllib2.Request('http://frk.cryptocoinexplorer.com/chain/Franko/q/getdifficulty')
      opener_cyp = urllib2.build_opener()
      f = opener_cyp.open(req, timeout = 25)
        coins['frk'].div = simplejson.load(f)
      coins['frk'].div = float(coins['frk'].div)
      coins['frk'].reward = float(0.25)
           except:
               continue    

       if abbreviation == 'ftc':
  try:
      fullstr = prestr + "difficulty of " + coins['ftc'].name
               print fullstr + (79-len(fullstr))*" " + "\r",
      req = urllib2.Request('http://ftc.cryptocoinexplorer.com/chain/Feathercoin/q/getdifficulty')
      opener_cyp = urllib2.build_opener()
      f = opener_cyp.open(req, timeout = 25)
        coins['ftc'].div = simplejson.load(f)
      coins['ftc'].div = float(coins['ftc'].div)
      coins['ftc'].reward = float(200)
           except:
               continue

       if abbreviation == 'nvc':
  try:
      fullstr = prestr + "difficulty of " + coins['nvc'].name
               print fullstr + (79-len(fullstr))*" " + "\r",
      req = urllib2.Request('http://nvc.cryptocoinexplorer.com/chain/Novacoin/q/getdifficulty')
      opener_cyp = urllib2.build_opener()
      f = opener_cyp.open(req, timeout = 25)
        coins['nvc'].div = simplejson.load(f)
      coins['nvc'].div = float(coins['nvc'].div)
      coins['nvc'].reward = float(9.58)
           except:
               continue

       if abbreviation == 'wdc':
  try:
      fullstr = prestr + "difficulty of " + coins['wdc'].name
               print fullstr + (79-len(fullstr))*" " + "\r",
      req = urllib2.Request('http://wdc.cryptocoinexplorer.com/chain/Worldcoin/q/getdifficulty')
      opener_cyp = urllib2.build_opener()
      f = opener_cyp.open(req, timeout = 25)
        coins['wdc'].div = simplejson.load(f)
      coins['wdc'].div = float(coins['wdc'].div)
      coins['wdc'].reward = float(50.2834)
           except:
               continue

       if abbreviation == 'dgc':
  try:
      fullstr = prestr + "difficulty of " + coins['dgc'].name
               print fullstr + (79-len(fullstr))*" " + "\r",
      req = urllib2.Request('http://dgc.cryptocoinexplorer.com/chain/digitalcoin/q/getdifficulty')
      opener_cyp = urllib2.build_opener()
      f = opener_cyp.open(req, timeout = 25)
        coins['dgc'].div = simplejson.load(f)
      coins['dgc'].div = float(coins['dgc'].div)
      coins['dgc'].reward = float(15)
           except:
               continue

       if abbreviation == 'fst':
  try:
      fullstr = prestr + "difficulty of " + coins['fst'].name
               print fullstr + (79-len(fullstr))*" " + "\r",
      req = urllib2.Request('http://fst.webboise.com/chain/Fastcoin/q/getdifficulty')
      opener_cyp = urllib2.build_opener()
      f = opener_cyp.open(req, timeout = 25)
        coins['fst'].div = simplejson.load(f)
      coins['fst'].div = float(coins['fst'].div)
      coins['fst'].reward = float(32)
           except:
               continue

       if abbreviation == 'elc':
  try:
      fullstr = prestr + "difficulty of " + coins['elc'].name
               print fullstr + (79-len(fullstr))*" " + "\r",
      req = urllib2.Request('http://elc.webboise.com/chain/Elacoin/q/getdifficulty')
      opener_cyp = urllib2.build_opener()
      f = opener_cyp.open(req, timeout = 25)
        coins['elc'].div = simplejson.load(f)
      coins['elc'].div = float(coins['elc'].div)
      coins['elc'].reward = float(2.16594)
           except:
               continue

      

       if abbreviation == 'crc':
  try:
      fullstr = prestr + "difficulty of " + coins['crc'].name
               print fullstr + (79-len(fullstr))*" " + "\r",
      req = urllib2.Request('http://crc.cryptocoinexplorer.com/chain/CraftCoin/q/getdifficulty')
      opener_cyp = urllib2.build_opener()
      f = opener_cyp.open(req, timeout = 15)
        coins['crc'].div = simplejson.load(f)
      coins['crc'].div = float(coins['crc'].div)
      coins['crc'].reward = float(2)
           except:
               continue

       if abbreviation == 'lky':
  try:
      fullstr = prestr + "difficulty of " + coins['lky'].name
               print fullstr + (79-len(fullstr))*" " + "\r",
      req = urllib2.Request('http://explorer.luckycoinfoundation.org:49917/chain/luckycoin/q/getdifficulty')
      opener_cyp = urllib2.build_opener()
      f = opener_cyp.open(req, timeout = 15)
        coins['lky'].div = simplejson.load(f)
      coins['lky'].div = float(coins['lky'].div)
      coins['lky'].reward = float(44)
           except:
               continue

       if abbreviation == 'gld':
  try:
      fullstr = prestr + "difficulty of " + coins['gld'].name
               print fullstr + (79-len(fullstr))*" " + "\r",
      req = urllib2.Request('http://gld.cryptocoinexplorer.com/chain/Goldcoin/q/getdifficulty')
      opener_cyp = urllib2.build_opener()
      f = opener_cyp.open(req, timeout = 15)
        coins['gld'].div = simplejson.load(f)
      coins['gld'].div = float(coins['gld'].div)
      coins['gld'].reward = float(45)
           except:
               continue

       if abbreviation == 'csc':
  try:
      fullstr = prestr + "difficulty of " + coins['csc'].name
               print fullstr + (79-len(fullstr))*" " + "\r",
      req = urllib2.Request('http://casinocoin.mooo.com/chain/CasinoCoin/q/getdifficulty')
      opener_cyp = urllib2.build_opener()
      f = opener_cyp.open(req, timeout = 15)
        coins['csc'].div = simplejson.load(f)
      coins['csc'].div = float(coins['csc'].div)
      coins['csc'].reward = float(50)
           except:
               continue

       if abbreviation == 'dmd':
  try:
      fullstr = prestr + "difficulty of " + coins['dmd'].name
               print fullstr + (79-len(fullstr))*" " + "\r",
      req = urllib2.Request('http://www.diamondblocks.info/chain/Diamond/q/getdifficulty')
      opener_cyp = urllib2.build_opener()
      f = opener_cyp.open(req, timeout = 15)
        coins['dmd'].div = simplejson.load(f)
      coins['dmd'].div = float(coins['dmd'].div)
      coins['dmd'].reward = float(1)
           except:
               continue

       if abbreviation == 'cat':
  try:
      fullstr = prestr + "difficulty of " + coins['cat'].name
               print fullstr + (79-len(fullstr))*" " + "\r",
      req = urllib2.Request('http://catchain.info/chain/Catcoin/q/getdifficulty')
      opener_cyp = urllib2.build_opener()
      f = opener_cyp.open(req, timeout = 15)
        coins['cat'].div = simplejson.load(f)
      coins['cat'].div = float(coins['cat'].div)
      coins['cat'].reward = float(50)
           except:
               continue

       if abbreviation=='btc':
               coins['btc'].ratio=100.0
               coins['btc'].source = '--'
               coins['btc'].algo = "SHA-256"
               coins['btc'].price = 1.0
               success = 1
               break      


#calculating profitability
       if coins[abbreviation].price!=0.0:
                coins[abbreviation].ratio = (coins[abbreviation].reward/coins[abbreviation].div)/(coins['btc'].reward/coins['btc'].div)*coins[abbreviation].price*100/(1350000/1450)
# Now find the best profit coin
    bestcoin = 'btc'
    bestprof = 0
    print "comparing profitabilty..."
    print "-"*69          
    for abbreviation, c in coins.items():
        if extout == True:
                 print "%11s Price(BTC):%.8f Reward:%.2f diff:%.2f Profit:%.0f" % (coins[abbreviation].name, coins[abbreviation].price, coins[abbreviation].reward, coins[abbreviation].div, c.ratio),
    
        
                 print ""
    
        if c.ratio > bestprof and c.willingToMine:
                 bestcoin = abbreviation
                 bestprof = c.ratio

    print "-"*69        
    print "=> Best: %d, mining %s" % (bestprof, coins[bestcoin].name)
    coins[bestcoin].median = (coins[bestcoin].median * coins[bestcoin].cnt) + bestprof / (coins[bestcoin].cnt+1)
    coins[bestcoin].cnt = coins[bestcoin].cnt+1            

    if coins[bestcoin].miningNow == False:
        # i.e. if we're not already mining the best coin
        print '=> Switching to %s (running %s)' % (coins[bestcoin].name, coins[bestcoin].command)
        for abbreviation, c in coins.items():
            c.miningNow = False
        coins[bestcoin].miningNow = True
        subprocess.Popen(coins[bestcoin].command)

      
    print 'Work done for now... going back to sleep...:-)'
    i=0
    while i        print "Seconds remaining:", (idletime*60-i), " ", "\r",
        time.sleep(1)
        i+=1

####################################################
# Altcoin Switcher Config File                     #
#                                                  #
# thx to area for his CryptoSwitcher without his   #
# coding style i would have not started playing    #  
# around with python                               #
# will send ya some donation                       #
# TipJar (BTC): 1H6L4VjrmRizXLLbrKLJQyx7vg87ZLjubD #
# Author: minime                                   #
####################################################


################################################################################
[MineCoins]

# Enable the coins you want to mine here.
mine42 = False
mineLEAF = True
mineDGC = True
mineTAG = False
mineNOBL = False
mineKDC = False
mineCON = False
mineUSDE = False
mineGLC = True
mineDGB = True
mineLOT = True
mineEAC = True
mineARG = True
mineBQC = True
mineDOGE = True
mineFRK = True
mineANC = True
mineFTC = True
mineCNC = True
mineMEC = False
mineLTC = True
mineWDC = True
mineMNC = True
minePHS = True
mineCMC = True
mineSBC = False
mineFST = True
mineELC = True
mineCRC = True
mineLKY = True
mineGLD = True
mineCSC = True
mineDMD = False
mineCAT = False
mineNVC = False
mineBTB = False
mineGDC = False
################################################################################
[Scripts]

# You should have scripts that stop all other forms of mining, set all necesary
#  environment variables, and start mining the appropriate coin.

# Examples included are 'litecoin.sh.sample' and 'bitcoin.sh.sample'.
# Any coins you aren't mining you can just leave blank.
# For Windows you can use bat-files, eg "BTCscript = bitcoin.bat".
PHSscript = ./phillostone.sh
AMCscript = ./americacoin.sh
ANCscript = ./anoncoin.sh
BQCscript = ./bqc.sh
BTBscript = #
BTGscript = ./bitgem.sh
CNCscript = ./CHNcoin.sh
CRCscript = ./craftcoin.sh
ELCscript = ./elacoin.sh
FRKscript = ./franko.sh
FSTscript = ./fastcoin.sh
FTCscript = ./feathercoin.sh
GDCscript = ./grandcoin.sh
GLDscript = ./goldcoin.sh
LKYscript = ./luckycoin.sh
LTCscript = ./litecoin.sh
MECscript = #
MNCscript = ./mincoin.sh
DOGEscript = ./dogcoin.sh
SBCscript = #
WDCscript = ./worldcoin.sh
TAGscript = ./tagcoin.sh
ARGscript = ./argentum.sh
STRscript = ./startcoin.sh
LEAFscript = ./leafcoin.sh
DGCscript = ./digitalcoin.sh
GLCscript = ./globalcoin.sh
LOTscript = ./lottocoin.sh
EACscript = ./earthcoin.sh
DMDscript = #
CATscript = #
CSCscript = ./casinocoin.sh

42script = ./42coin.sh

DGBscript = ./dgbcoin.sh
NOBLscript = ./noblcoin.sh
KDCscript = ./KDCcoin.sh
CONscript = ./concoin.sh
USDEscript = ./usdecoin.sh
SMCscript = ./smscoin.sh

################################################################################
[Misc]

# Idle Time (in minutes) between two checks of coin profitability.
idletime = 5

# Gigahash per second you can output doing normal BTC mining.
ghashpersec = 0.7

# Gigakeys per second you can output doing vanity address mining.
gkeypersec = 0.05

# Trade multiplier - if not 1, sells not at the highest bid, but at this
#  multiple of it.  
tradeMultiplier = 1.02

# make sure our sell order is the lowest if tradeMultiplier > 1
tradeMultiplierCheck = False


################################################################################

#!/bin/bash
#Replace this script with one of your own.

#Send the quit command to any cgminer instances running
echo "{\"command\":\"quit\"}" | pkill -9 -f mining.py
#Set clocks
export DISPLAY=:0
screen -dmS cgm ./mining.py -pa scrypt -o gigahash.wemineltc.com -p 3333 -cu minime -cp xxxx -sp 6666 -gp 8888