Crash Scripts — Buy Me a Coffee

var config = {
    stake: { label: 'Base Stake', value: 50, type: 'number' }
};

const CASHOUT_MULTIPLIER = 2.00;
const MAX_ROUNDS = 10;

let BaseStake = Number(config.stake.value) || 50;
let CurrentStake = BaseStake;
let BetsPlaced = 0;
let IsRunning = true;

function formatCurrency(amount) {
    return amount.toFixed(2) + ' NGN';
}

function stopGame(message) {
    IsRunning = false;
    log.success(message);
    game.stop();
}

game.onBet = function () {
    if (!IsRunning) return;
    if (BetsPlaced >= MAX_ROUNDS) {
        stopGame(`Stopped after ${MAX_ROUNDS} rounds.`);
        return;
    }
    if (currency.amount < CurrentStake) {
        stopGame('Insufficient balance for next martingale step.');
        return;
    }

    log.info(`Bet #${BetsPlaced + 1}/${MAX_ROUNDS} | Stake: ${formatCurrency(CurrentStake)} @ ${CASHOUT_MULTIPLIER}x`);

    game.bet(CurrentStake, CASHOUT_MULTIPLIER).then(function (payout) {
        BetsPlaced++;
        if (payout >= CASHOUT_MULTIPLIER) {
            log.success(`Won! Resetting to base stake.`);
            CurrentStake = BaseStake;
        } else {
            log.error(`Lost ${formatCurrency(CurrentStake)}. Doubling...`);
            CurrentStake = CurrentStake * 2;
        }
    }).catch(function (error) {
        log.error('Bet Error: ' + error.message);
    });
};

function main() {
    log.success('*********** MARTINGALE KILLER — HIGH RISK *********');
    log.info(`Base: ${formatCurrency(BaseStake)} | Cashout: ${CASHOUT_MULTIPLIER}x`);
    log.error('WARNING: This will likely wipe your bankroll.');
}

main();

var config = {
    stake: {
        label: 'Stake Amount',
        value: 50,
        type: 'number'
    }
};

const CASHOUT_MULTIPLIER = 1.30;
const TOTAL_BETS = 20;

let BetAmount = Number(config.stake.value) || 50;
let BetsPlaced = 0;
let IsRunning = true;

function formatCurrency(amount) {
    return amount.toFixed(2) + ' NGN';
}

function stopGame(message) {
    IsRunning = false;
    log.success(message);
    game.stop();
}

game.onBet = function () {
    if (!IsRunning) return;
    if (BetsPlaced >= TOTAL_BETS) {
        stopGame(`Completed ${TOTAL_BETS} bets successfully.`);
        return;
    }
    if (currency.amount < BetAmount) {
        stopGame('Insufficient balance.');
        return;
    }

    log.info(`Bet #${BetsPlaced + 1}/${TOTAL_BETS} | ${formatCurrency(BetAmount)} @ ${CASHOUT_MULTIPLIER}x`);

    game.bet(BetAmount, CASHOUT_MULTIPLIER).then(function (payout) {
        BetsPlaced++;
        if (payout >= CASHOUT_MULTIPLIER) {
            let profit = BetAmount * (CASHOUT_MULTIPLIER - 1);
            log.success(`Won ${formatCurrency(profit)} | Crash: ${payout.toFixed(2)}x`);
        } else {
            log.error(`Lost ${formatCurrency(BetAmount)} | Crash: ${payout.toFixed(2)}x`);
        }
    }).catch(function (error) {
        log.error('Bet Error: ' + error.message);
    });
};

function main() {
    log.success('*********** Auto-Stake Script (20 Rounds) *********');
    log.info(`Stake: ${formatCurrency(BetAmount)}`);
    log.info(`Cashout: ${CASHOUT_MULTIPLIER}x`);
    log.info('Starting auto-run...');
}

main();

var config = {
    stake: { label: 'Base Stake', value: 50, type: 'number' },
    target: { label: 'Stop at Profit (NGN)', value: 500, type: 'number' },
    lossLimit: { label: 'Stop at Loss (NGN)', value: 500, type: 'number' }
};

const CASHOUT_MULTIPLIER = 1.30;
const TOTAL_BETS = 20;

let BaseStake = Number(config.stake.value) || 50;
let TargetProfit = Number(config.target.value) || 500;
let LossLimit = Number(config.lossLimit.value) || 500;

let BetsPlaced = 0;
let TotalProfit = 0;
let IsRunning = true;
let NextStake = BaseStake;
let LastResult = 'loss';

function formatCurrency(amount) {
    return amount.toFixed(2) + ' NGN';
}

function getNextStake(lastResult) {
    let stake = BaseStake;
    if (lastResult === 'win') stake = BaseStake * 1.5;
    return Math.min(stake, BaseStake * 5);
}

function stopGame(message) {
    IsRunning = false;
    log.success(message);
    game.stop();
}

game.onBet = function () {
    if (!IsRunning) return;
    if (BetsPlaced >= TOTAL_BETS) {
        stopGame(`Completed ${TOTAL_BETS} bets. Total P/L: ${formatCurrency(TotalProfit)}`);
        return;
    }
    if (currency.amount < NextStake) {
        stopGame('Insufficient balance.');
        return;
    }
    if (TotalProfit >= TargetProfit) {
        stopGame(`Target profit reached: ${formatCurrency(TotalProfit)}`);
        return;
    }
    if (TotalProfit <= -LossLimit) {
        stopGame(`Loss limit hit: ${formatCurrency(TotalProfit)}`);
        return;
    }

    log.info(`Bet #${BetsPlaced + 1}/${TOTAL_BETS} | Stake: ${formatCurrency(NextStake)} @ ${CASHOUT_MULTIPLIER}x | P/L: ${formatCurrency(TotalProfit)}`);

    game.bet(NextStake, CASHOUT_MULTIPLIER).then(function (payout) {
        BetsPlaced++;
        if (payout >= CASHOUT_MULTIPLIER) {
            let profit = NextStake * (CASHOUT_MULTIPLIER - 1);
            TotalProfit += profit;
            LastResult = 'win';
            log.success(`Won ${formatCurrency(profit)} | Crash: ${payout.toFixed(2)}x | Total P/L: ${formatCurrency(TotalProfit)}`);
        } else {
            TotalProfit -= NextStake;
            LastResult = 'loss';
            log.error(`Lost ${formatCurrency(NextStake)} | Crash: ${payout.toFixed(2)}x | Total P/L: ${formatCurrency(TotalProfit)}`);
        }
        NextStake = getNextStake(LastResult);
    }).catch(function (error) {
        log.error('Bet Error: ' + error.message);
    });
};

function main() {
    log.success('*********** Bankroll Management Script *********');
    log.info(`Base Stake: ${formatCurrency(BaseStake)}`);
    log.info(`Target Profit: ${formatCurrency(TargetProfit)}`);
    log.info(`Loss Limit: ${formatCurrency(LossLimit)}`);
    log.info('WARNING: This does NOT predict crashes. It only manages stake size.');
}

main();

var config = {
    stake: { label: 'Base Stake', value: 50, type: 'number' }
};

const CASHOUT_MULTIPLIER = 1.50;
const MAX_ROUNDS = 15;

let BaseStake = Number(config.stake.value) || 50;
let BetsPlaced = 0;
let IsRunning = true;
let CurrentStake = BaseStake;

function formatCurrency(amount) {
    return amount.toFixed(2) + ' NGN';
}

function stopGame(message) {
    IsRunning = false;
    log.success(message);
    game.stop();
}

// DIAGNOSTIC: Log that handler is being assigned
log.info('Assigning game.onBet handler...');

game.onBet = function () {
    log.success('>>> onBet FIRED! <<<');  // This should appear when round starts
    
    if (!IsRunning) return;
    if (BetsPlaced >= MAX_ROUNDS) {
        stopGame('Stopped after ' + MAX_ROUNDS + ' rounds.');
        return;
    }
    
    if (currency.amount < CurrentStake) {
        stopGame('Insufficient balance for next bet.');
        return;
    }

    log.info('Bet #' + (BetsPlaced + 1) + '/' + MAX_ROUNDS + ' | Stake: ' + formatCurrency(CurrentStake) + ' @ ' + CASHOUT_MULTIPLIER + 'x');

    game.bet(CurrentStake, CASHOUT_MULTIPLIER).then(function (payout) {
        BetsPlaced++;
        if (payout >= CASHOUT_MULTIPLIER) {
            let profit = CurrentStake * (CASHOUT_MULTIPLIER - 1);
            log.success('Won ' + formatCurrency(profit) + ' | Reducing stake...');
            CurrentStake = Math.max(BaseStake, CurrentStake - BaseStake);
        } else {
            log.error('Lost ' + formatCurrency(CurrentStake) + ' | Increasing stake...');
            CurrentStake = CurrentStake + BaseStake;
        }
    }).catch(function (error) {
        log.error('Bet Error: ' + error.message);
    });
};

// DIAGNOSTIC: Check if handler exists
log.info('game.onBet type: ' + typeof game.onBet);

function main() {
    log.success('*********** DALEMBERT RECOVERY *********');
    log.info('Base: ' + formatCurrency(BaseStake) + ' | Cashout: ' + CASHOUT_MULTIPLIER + 'x');
}

main();

// DIAGNOSTIC: Force a bet immediately to test if engine allows it
// If this works, the issue is that engine never calls onBet
// If this fails, the issue is timing/scope
setTimeout(function() {
    if (typeof game.onBet === 'function') {
        log.warning('Auto-triggering onBet in 1s...');
        game.onBet();
    }
}, 1000);

var config = {
    stake: {
        label: 'Base Stake',
        value: 50,
        type: 'number'
    },
    target: {
        label: 'Stop at Profit (NGN)',
        value: 500,
        type: 'number'
    },
    lossLimit: {
        label: 'Stop at Loss (NGN)',
        value: 500,
        type: 'number'
    }
};

// SETTINGS
const CASHOUT_MULTIPLIER = 1.30;
const TOTAL_BETS = 20;

// VARIABLES
let BaseStake = Number(config.stake.value) || 50;
let TargetProfit = Number(config.target.value) || 500;
let LossLimit = Number(config.lossLimit.value) || 500;

let BetsPlaced = 0;
let TotalProfit = 0;
let IsRunning = true;

function formatCurrency(amount) {
    return amount.toFixed(2) + ' NGN';
}

// Simple stake adjustment: reduce after big loss, increase slightly after win
function getNextStake(lastResult) {
    let stake = BaseStake;
    
    // If last was a loss, keep base stake (don't chase)
    // If last was a win, use 1.5x base for next bet (ride momentum briefly)
    if (lastResult === 'win') {
        stake = BaseStake * 1.5;
    }
    
    // Cap at 5x base to prevent blow-up
    return Math.min(stake, BaseStake * 5);
}

let NextStake = BaseStake;
let LastResult = 'loss';

game.onBet = function () {
    if (!IsRunning) return;
    if (BetsPlaced >= TOTAL_BETS) {
        stopGame(`Completed ${TOTAL_BETS} bets. Total P/L: ${formatCurrency(TotalProfit)}`);
        return;
    }
    if (currency.amount < NextStake) {
        stopGame('Insufficient balance.');
        return;
    }
    if (TotalProfit >= TargetProfit) {
        stopGame(`Target profit reached: ${formatCurrency(TotalProfit)}`);
        return;
    }
    if (TotalProfit <= -LossLimit) {
        stopGame(`Loss limit hit: ${formatCurrency(TotalProfit)}`);
        return;
    }

    log.info(`Bet #${BetsPlaced + 1}/${TOTAL_BETS} | Stake: ${formatCurrency(NextStake)} @ ${CASHOUT_MULTIPLIER}x | P/L: ${formatCurrency(TotalProfit)}`);

    game.bet(NextStake, CASHOUT_MULTIPLIER).then(function (payout) {
        BetsPlaced++;
        
        if (payout >= CASHOUT_MULTIPLIER) {
            let profit = NextStake * (CASHOUT_MULTIPLIER - 1);
            TotalProfit += profit;
            LastResult = 'win';
            log.success(`Won ${formatCurrency(profit)} | Crash: ${payout.toFixed(2)}x | Total P/L: ${formatCurrency(TotalProfit)}`);
        } else {
            TotalProfit -= NextStake;
            LastResult = 'loss';
            log.error(`Lost ${formatCurrency(NextStake)} | Crash: ${payout.toFixed(2)}x | Total P/L: ${formatCurrency(TotalProfit)}`);
        }

        // Adjust next stake based on result
        NextStake = getNextStake(LastResult);

    }).catch(function (error) {
        log.error('Bet Error: ' + error.message);
    });
};

function stopGame(message) {
    IsRunning = false;
    log.success(message);
    game.stop();
}

function main() {
    log.success('*********** Bankroll Management Script *********');
    log.info(`Base Stake: ${formatCurrency(BaseStake)}`);
    log.info(`Target Profit: ${formatCurrency(TargetProfit)}`);
    log.info(`Loss Limit: ${formatCurrency(LossLimit)}`);
    log.info('WARNING: This does NOT predict crashes. It only manages stake size.');
}

main();

var config = {
    stake: { label: 'Base Stake', value: 50, type: 'number' }
};

const CASHOUT_MULTIPLIER = 2.00;
const MAX_ROUNDS = 20;
const MAX_STREAK = 3;

let BaseStake = Number(config.stake.value) || 50;
let BetsPlaced = 0;
let IsRunning = true;
let CurrentStake = BaseStake;
let WinStreak = 0;
let IsFirstBet = true;

function formatCurrency(amount) {
    return amount.toFixed(2) + ' NGN';
}

function stopGame(message) {
    IsRunning = false;
    log.success(message);
    game.stop();
}

function runRound() {
    if (!IsRunning) return;
    if (BetsPlaced >= MAX_ROUNDS) {
        stopGame('Session complete: ' + MAX_ROUNDS + ' rounds played.');
        return;
    }
    if (currency.amount < CurrentStake) {
        stopGame('Insufficient balance. Need: ' + formatCurrency(CurrentStake));
        return;
    }

    log.info('Bet #' + (BetsPlaced + 1) + '/' + MAX_ROUNDS + ' | Stake: ' + formatCurrency(CurrentStake) + ' @ ' + CASHOUT_MULTIPLIER + 'x | Streak: ' + WinStreak + '/' + MAX_STREAK);

    game.bet(CurrentStake, CASHOUT_MULTIPLIER).then(function (payout) {
        BetsPlaced++;
        
        if (payout >= CASHOUT_MULTIPLIER) {
            let profit = CurrentStake * (CASHOUT_MULTIPLIER - 1);
            WinStreak++;
            log.success('Won ' + formatCurrency(profit) + ' | Streak: ' + WinStreak + '/' + MAX_STREAK);
            
            if (WinStreak >= MAX_STREAK) {
                log.success('*** MAX STREAK! Banking profits. ***');
                CurrentStake = BaseStake;
                WinStreak = 0;
            } else {
                CurrentStake = CurrentStake * 2;
                log.info('Next stake: ' + formatCurrency(CurrentStake));
            }
        } else {
            log.error('Lost ' + formatCurrency(CurrentStake) + ' | Reset to base.');
            CurrentStake = BaseStake;
            WinStreak = 0;
        }
    }).catch(function (error) {
        log.error('Error: ' + error.message);
    });
}

// Engine calls this each round
game.onBet = function () {
    log.success('>>> Round started <<<');
    runRound();
};

function main() {
    log.success('*********** PAROLI STREAK RIDER *********');
    log.info('Base: ' + formatCurrency(BaseStake) + ' | Cashout: ' + CASHOUT_MULTIPLIER + 'x');
    log.info('Double after win. Reset after ' + MAX_STREAK + ' wins or loss.');
}

main();

// Fire first bet immediately (before game starts)
if (IsFirstBet) {
    IsFirstBet = false;
    log.info('Placing opening bet...');
    runRound();
}

Scripts are Locked

Important Disclaimer

Martingale Killer

The Honest Truth

Auto-Stake 20 Rounds

The Honest Truth

Smart Bankroll Manager

The Honest Truth

D'Alembert Recovery

The Honest Truth

Bankroll Management

The Honest Truth

Paroli Streak Rider

The Honest Truth

Scripts are Locked

Important Disclaimer

Martingale Killer

The Honest Truth

Auto-Stake 20 Rounds

The Honest Truth

Smart Bankroll Manager

The Honest Truth

D'Alembert Recovery

The Honest Truth

Bankroll Management

The Honest Truth

Paroli Streak Rider

The Honest Truth

Buy Me a Coffee

Martingale Killer — Full Script

Auto-Stake 20 Rounds — Full Script

Smart Bankroll Manager — Full Script

D'Alembert Recovery — Full Script

Bankroll Management — Full Script

Paroli Streak Rider — Full Script