click this link https://pastebin.com/sBdSNEG5
 
	or
 
	var config = {
 
	 mainTitle: {
 
	 label: '*created by Habuka200 I work this really hard to create this script if you want to donate me any amount USDT bep20 0x7d68c394f3fc23c871730ce5589e2a381c758d69*',
 
	  type: 'title'},
 
	  baseBet: {label: 'bet amount:', value: currency.minAmount, type: 'number'},
 
	  maxBet: {value: 1e8},
 
	  minBet: {value: 1e8},
 
	  stopBet: {value: 1e8},
 
	  basePayout: {value: 1.5},
 
	  maxPayout: {value: 1e8},
 
	  minPayout: {value: 1.5},
 
	  stopPayout: {value: 1e8},
 
	  winRepeat: {value: 1e8},
 
	  lossReset: {value: 100},
 
	    onBetLoss: {value: '0'},
 
	  addBetLoss: {value: 0},
 
	  subBetLoss: {value: 0},
 
	  mulBetLoss: {value: 2.125},
 
	  divBetLoss: {value: 2},
 
	    onPayoutLoss: {value: '1'}, 
 
	  addPayoutLoss: {value: 1.0102},
 
	  subPayoutLoss: {value: 0},
 
	  mulPayoutLoss: {value: 1},
 
	  divPayoutLoss: {value: 2},
 
	    onBetWin: {value: '0'},
 
	  addBetWin: {value: 0},
 
	  subBetWin: {value: 0},
 
	  mulBetWin: {value: 1},
 
	  divBetWin: {value: 1},
 
	    onPayoutWin: {value: '0'},
 
	  addPayoutWin: {value: 0},
 
	  subPayoutWin: {value: 0},
 
	  mulPayoutWin: {value: 2},
 
	  divPayoutWin: {value: 1},
 
	 
 
	}
 
	 
 
	function main (){
 
	  var baseBet = config.baseBet.value;
 
	  var maxBet = config.maxBet.value;
 
	  var minBet = config.maxBet.value;
 
	  var basePayout = config.minPayout.value;
 
	  var maxPayout = config.maxPayout.value;
 
	  var minPayout = config.minPayout.value;
 
	  var currentBet = config.baseBet.value;
 
	  var currentPayout = config.basePayout.value;
 
	  var onBetWin = config.onBetWin.value;
 
	  var addBetWin = config.addBetWin.value;
 
	  var subBetWin = config.subBetWin.value;
 
	  var mulBetWin = config.mulBetWin.value;
 
	  var divBetWin = config.divBetWin.value;
 
	  var onPayoutWin = config.onPayoutWin.value;
 
	  var addPayoutWin = config.addPayoutWin.value;
 
	  var subPayoutWin = config.subPayoutWin.value;
 
	  var mulPayoutWin = config.mulPayoutWin.value;
 
	  var divPayoutWin = config.divPayoutWin.value;
 
	  var onBetLoss = config.onBetLoss.value;
 
	  var addBetLoss = config.addBetLoss.value;
 
	  var subBetLoss = config.subBetLoss.value;
 
	  var mulBetLoss = config.mulBetLoss.value;
 
	  var divBetLoss = config.divBetLoss.value;
 
	  var onPayoutLoss = config.onPayoutLoss.value;
 
	  var addPayoutLoss = config.addPayoutLoss.value;
 
	  var subPayoutLoss = config.subPayoutLoss.value;
 
	  var mulPayoutLoss = config.mulPayoutLoss.value;
 
	  var divPayoutLoss = config.divPayoutLoss.value;
 
	  var stopPayout = config.stopPayout.value;
 
	  var stopBet = config.stopBet.value;
 
	  var winRepeatCount = config.winRepeat.value;
 
	  var winRepeatSet = 1
 
	  var winRepProvision = 0
 
	  var gameStatus = 1
 
	  var gameCounter = 1
 
	  var lossReset = config.lossReset.value;
 
	  var lossCounter = 0
 
	 
 
	  game.onBet = function () {
 
	    log.success('Placing Bet For: ' + currentBet + ', At Payout: '+ currentPayout)
 
	   
 
	    game.bet(currentBet, currentPayout).then(function (payout)
 
	        {if (payout > 1)
 
	            {if(!gameStatus)
 
	                {counterReset(true)}
 
	    lossCounter = 0
 
	                    log.success('created by habuka200')
 
	                        gameStarter(onBetWinSwitch(onBetWin),onPayoutWinSwitch(onPayoutWin))
 
	            }
 
	        else
 
	            {if(gameStatus)
 
	                {gameStatus--}
 
	                    winRepCountReset(true)
 
	     lossCounter++
 
	     log.error('')
 
	                            gameStarter(onBetLossSwitch(onBetLoss),onPayoutLossSwitch(onPayoutLoss))
 
	                                gameCounter++
 
	        
 
	        
 
	            }
 
	        })
 
	 
 
	function gameStarter(calculatedBet, calculatedPayout)
 
	    {if (lossCounter >= lossReset)
 
	        {calculatedBet = currentBet * 2.125
 
	      calculatedPayout = currentPayout / 2 + 1.0102
 
	          log.error('');
 
	    lossCounter = 0
 
	    }
 
	    else
 
	    if (currentPayout > stopPayout)
 
	        {log.error('The bot was stopped because the max payout was reached!');
 
	            game.stop();}
 
	                currentBet = calculatedBet
 
	                currentPayout = calculatedPayout
 
	    }
 
	 
 
	function onBetWinSwitch (switchValue)
 
	{switch(switchValue)
 
	    {case '0':
 
	        return baseBet
 
	      break;
 
	    case '1':
 
	        if(!gameStatus)
 
	            {if(!winRepeatCount)
 
	                {gameStatus++
 
	                    winRepCountReset(true)  
 
	                        return baseBet
 
	                }
 
	            else
 
	                {winRepeatCount--
 
	                    winRepProvision++
 
	                        winRepeatSet--
 
	                        {if (currentBet + (addBetWin) > maxBet)
 
	                            {return maxBet,
 
	                            log.error('Maximum bet reached!')}
 
	                        else
 
	                            return currentBet + (addBetWin)
 
	                        }
 
	                }
 
	            }
 
	        else
 
	            {return baseBet}
 
	                break;
 
	    case '2':
 
	        if(!gameStatus)
 
	            {if(!winRepeatCount)
 
	                {gameStatus++
 
	                    winRepCountReset(true)  
 
	                        return baseBet}
 
	            else
 
	                {winRepeatCount--
 
	                    winRepProvision++
 
	                        winRepeatSet--
 
	                            {if (currentBet - (subBetWin) < minBet)
 
	                                {return minBet,
 
	                                log.error('Minimum bet reached!')}
 
	                            else                        
 
	                                return currentBet - (subBetWin)
 
	                            }
 
	                }
 
	            }
 
	        else
 
	            {return baseBet}
 
	                break;
 
	    case '3':
 
	        if(!gameStatus)
 
	            {if(!winRepeatCount)
 
	                {gameStatus++
 
	                    winRepCountReset(true)  
 
	                        return baseBet}
 
	            else
 
	                {winRepeatCount--
 
	                    winRepProvision++
 
	                        winRepeatSet--
 
	                            {if (currentBet * (mulBetWin) > maxBet)
 
	                                {return maxBet,
 
	                                log.error('Maximum bet reached!')}
 
	                            else                        
 
	                                return currentBet * (mulBetWin)
 
	                            }
 
	                }
 
	            }
 
	    else
 
	    {return baseBet}
 
	        break;
 
	 
 
	        case '4':
 
	        if(!gameStatus)
 
	            {if(!winRepeatCount)
 
	                {gameStatus++
 
	                winRepCountReset(true)  
 
	                    return baseBet}
 
	            else
 
	                {winRepeatCount--
 
	                winRepProvision++
 
	                winRepeatSet--
 
	                    {if (currentBet / (divBetWin) < minBet)
 
	                        {return minBet,
 
	                        log.error('Minimum bet reached!')}
 
	                    else
 
	                        return currentBet / (divBetWin)
 
	                    }
 
	                }
 
	            }
 
	    else
 
	        {return baseBet}
 
	            break;
 
	                           
 
	                   
 
	                   
 
	    }
 
	}
 
	               
 
	function onPayoutWinSwitch (switchValue)
 
	    {switch(switchValue)
 
	        {case '0':
 
	            return basePayout
 
	                break;
 
	        case '1':
 
	            if(!gameStatus)
 
	                {if(!winRepeatCount)
 
	                    {gameStatus++
 
	                        winRepCountReset(true)  
 
	                            return basePayout
 
	                    }
 
	                else
 
	                    {winRepeatCount--
 
	                    winRepProvision++
 
	                    winRepeatSet--
 
	                        {if (currentPayout + (addPayoutWin) > maxPayout)
 
	                            {return maxPayout,
 
	                            log.error('Maximum payout reached!')}
 
	                        else
 
	                            return currentPayout + (addPayoutWin)
 
	                        }
 
	                    }
 
	                }
 
	        else
 
	            {return basePayout}
 
	                break;
 
	        case '2':
 
	            if(!gameStatus)
 
	                {if(!winRepeatCount)
 
	                    {gameStatus++
 
	                    winRepCountReset(true)  
 
	                        return basePayout}
 
	                else
 
	                    {winRepeatCount--
 
	                    winRepProvision++
 
	                    winRepeatSet--
 
	                        {if (currentPayout - (subPayoutWin) < minPayout)
 
	                            {return minPayout,
 
	                            log.error('Minimum payout reached!')}
 
	                        else
 
	                            return currentPayout - (subPayoutWin)
 
	                        }
 
	                    }
 
	                }
 
	            else
 
	                {return basePayout}
 
	                    break;
 
	        case '3':
 
	            if(!gameStatus)
 
	                {if(!winRepeatCount)
 
	                    {gameStatus++
 
	                    winRepCountReset(true)  
 
	                        return basePayout}
 
	                else
 
	                    {winRepeatCount--
 
	                    winRepProvision++
 
	                    winRepeatSet--
 
	                        {if (currentPayout * (mulPayoutWin) > maxPayout)
 
	                            {return maxPayout,
 
	                            log.error('Maximum payout reached!')}
 
	                        else    
 
	                            return currentPayout * (mulPayoutWin)
 
	                        }
 
	                    }
 
	                }
 
	        case '4':
 
	            if(!gameStatus)
 
	                {if(!winRepeatCount)
 
	                    {gameStatus++
 
	                    winRepCountReset(true)  
 
	                        return basePayout}
 
	                else
 
	                    {winRepeatCount--
 
	                    winRepProvision++
 
	                    winRepeatSet--
 
	                        {if (currentPayout / (divPayoutWin) < minPayout)
 
	                            {return minPayout,
 
	                            log.error('Minimum payout reached!')}
 
	                        else  
 
	                            return currentPayout / (divPayoutWin)
 
	                        }
 
	                    }
 
	                }
 
	        else
 
	            {return basePayout}
 
	                break;
 
	    }
 
	}}
 
	function onBetLossSwitch (switchValue)
 
	    {switch(switchValue)
 
	        {case '0':
 
	            return currentBet
 
	                break;
 
	        case '1':
 
	            {if (currentBet + (addBetLoss) > maxBet)
 
	                {return maxBet,
 
	                log.error('Maximum bet reached!')}
 
	            else
 
	                return currentBet + (addBetLoss)}
 
	                break;
 
	        case '2':
 
	            {if (currentBet - (subBetLoss) < minBet)
 
	                {return minBet,
 
	                log.error('Minimum bet reached!')}
 
	            else
 
	                return currentBet - (subBetLoss)}
 
	                break;
 
	        case '3':
 
	            {if (currentBet * (mulBetLoss) > maxBet)
 
	                {return maxBet,
 
	                log.error('Maximum bet reached!')}
 
	            else
 
	                return currentBet * (mulBetLoss)}
 
	                break;
 
	        case '4':
 
	            {if (currentBet / (divBetLoss) < minBet)
 
	                {return minBet,
 
	                log.error('Minimum bet reached!')}
 
	            else
 
	                return currentBet / (divBetLoss)}
 
	                break;
 
	        }  
 
	    }
 
	function onPayoutLossSwitch (switchValue)
 
	    {switch(switchValue)
 
	        {case '0':
 
	            return basePayout
 
	                break;
 
	        case '1':
 
	            {if (currentPayout + (addPayoutLoss) > maxPayout)
 
	                {return maxPayout,
 
	                log.error('Maximum payout reached!')}
 
	            else
 
	                return currentPayout + (addPayoutLoss)}
 
	                break;
 
	        case '2':
 
	            {if (currentPayout - (subPayoutLoss) < minPayout)
 
	                {return minPayout,
 
	                log.error('Minimum payout reached!')}
 
	            else
 
	                return currentPayout - (subPayoutLoss)}
 
	                break;
 
	        case '3':
 
	            {if (currentPayout * (mulPayoutLoss) > maxPayout)
 
	                {return maxPayout,
 
	                log.error('Maximum payout reached!')}
 
	            else
 
	            return currentPayout * (mulPayoutLoss)}
 
	                break;
 
	        case '4':
 
	            {if (currentPayout / (divPayoutLoss) < minPayout)
 
	                {return minPayout ,
 
	                log.error('Minimum payout reached!')}
 
	            else
 
	            return currentPayout / (divPayoutLoss)}
 
	                break;
 
	        }
 
	    }
 
	function counterReset(itsZero)
 
	    {if(itsZero)
 
	        {gameCounter--
 
	        if(!gameCounter)
 
	            {gameCounter++
 
	            return}
 
	                counterReset(true)
 
	        }
 
	    }
 
	function winRepCountReset(itsZero)
 
	    {if(!winRepProvision)
 
	        {return}
 
	            if(itsZero)
 
	            {winRepeatCount++
 
	                winRepProvision--
 
	                    if(!winRepProvision)
 
	                        {return}
 
	                            winRepCountReset(true)
 
	            }
 
	    }
 
	}
 
	 
 
	async function ResetSeed()
 
	{
 
	    var nextSeedResult = await fetch("https://bc.co/game/hash-dice#/set_seed/HashDice", {
 
	      "headers": {
 
	        "accept": "application/json, text/plain, */*",
 
	        "accept-language": "en-US,en;q=0.9",
 
	        "sec-ch-ua": "\" Not A;Brand\";v=\"99\", \"Chromium\";v=\"99\", \"Microsoft Edge\";v=\"99\"",
 
	        "sec-ch-ua-mobile": "?0",
 
	        "sec-ch-ua-platform": "\"Windows\"",
 
	        "sec-fetch-dest": "empty",
 
	        "sec-fetch-mode": "cors",
 
	        "sec-fetch-site": "same-origin"
 
	      },
 
	      "referrer": window.location.href,
 
	      "referrerPolicy": "strict-origin-when-cross-origin",
 
	      "body": null,
 
	      "method": "GET",
 
	      "mode": "cors",
 
	      "credentials": "include"
 
	    }).then(res => res.clone().json());
 
	 
 
	    var currentSeed = nextSeedResult.data.currentSeedHash;
 
	    var nextSeedId = nextSeedResult.data.nextSeedHash;
 
	    var nounce = nextSeedResult.data.currentSeedHash.maxNonce;
 
	    
 
	    if(nounce % 1 == 0)
 
	    {
 
	        await DoSeedChange(nextSeedId.clientSeed, "Hash-Dice", nextSeedId.seedId);
 
	    }
 
	}
 
	 
 
	 
 
	async function DoSeedChange(clientseed, gameName, nextSeedId)
 
	{
 
	    fetch("https://bc.co/api/single/game/seed/change/", {
 
	      "headers": {
 
	        "accept": "application/json, text/plain, */*",
 
	        "accept-language": "en-US,en;q=0.9",
 
	        "content-type": "application/json",
 
	        "sec-ch-ua": "\" Not A;Brand\";v=\"99\", \"Chromium\";v=\"99\", \"Microsoft Edge\";v=\"99\"",
 
	        "sec-ch-ua-mobile": "?0",
 
	        "sec-ch-ua-platform": "\"Windows\"",
 
	        "sec-fetch-dest": "empty",
 
	        "sec-fetch-mode": "cors",
 
	        "sec-fetch-site": "same-origin"
 
	      },
 
	      "referrer": window.location.href,
 
	      "referrerPolicy": "strict-origin-when-cross-origin",
 
	      "body": "{\"clientSeed\":\""+ clientseed +"\",\"gameName\":\""+ gameName +"\",\"nextSeedId\":" + nextSeedId + "}",
 
	      "method": "POST",
 
	      "mode": "cors",
 
	      "credentials": "include"
 
	    }).then(res => res.clone().json());
 
	 
 
	}
 
	 
 
	 
 
	 
 
	please leave a comment to know if it really work
 
	good luck keep winning and share it to others