hash dice script 2025 created by habuka200

[habuka16]

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

Edited yesterday at 04:23 PM by habuka16