├── cookies.txt
├── image.png
├── proxy.txt
├── requirements.txt
├── README.md
└── bot.py


/cookies.txt:
--------------------------------------------------------------------------------
1 | your_cookie_1
2 | your_cookie_2


--------------------------------------------------------------------------------
/image.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vonssy/GoblinMeme-BOT/HEAD/image.png


--------------------------------------------------------------------------------
/proxy.txt:
--------------------------------------------------------------------------------
1 | ip:port # Default Protcol HTTP.
2 | protocol://ip:port
3 | protocol://user:pass@ip:port


--------------------------------------------------------------------------------
/requirements.txt:
--------------------------------------------------------------------------------
1 | aiohttp==3.11.10
2 | aiohttp-socks==0.9.1
3 | fake-useragent==1.5.1
4 | colorama==0.4.6
5 | pytz==2024.1


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Goblin Meme BOT
 2 | Goblin Meme BOT
 3 | 
 4 | - Register Here : [Goblin Meme](https://goblin.meme?referral_code=1SOLX6)
 5 | - Sign Up With X
 6 | 
 7 | ## Features
 8 | 
 9 |   - Auto Get Account Information
10 |   - Auto Run With [Proxyscrape Free Proxy](https://proxyscrape.com/free-proxy-list) - `Choose 1`
11 |   - Auto Run With Private Proxy - `Choose 2`
12 |   - Auto Run Without Proxy - `Choose 3`
13 |   - Auto Rotate Invalid Proxies - `y` or `n`
14 |   - Auto Mining n Open Box
15 |   - Multi Accounts
16 | 
17 | ## Requiremnets
18 | 
19 | - Make sure you have Python3.9 or higher installed and pip.
20 | 
21 | ## Instalation
22 | 
23 | 1. **Clone The Repositories:**
24 |    ```bash
25 |    git clone https://github.com/vonssy/GoblinMeme-BOT.git
26 |    ```
27 |    ```bash
28 |    cd GoblinMeme-BOT
29 |    ```
30 | 
31 | 2. **Install Requirements:**
32 |    ```bash
33 |    pip install -r requirements.txt #or pip3 install -r requirements.txt
34 |    ```
35 | 
36 | ## Configuration
37 | 
38 | ### Screenshots
39 | 
40 | <div style="text-align: center;">
41 |   <img src="image.png" alt="Image" width="500"/>
42 | </div>
43 | 
44 | - **cookies.txt:** You will find the file `cookies.txt` inside the project directory. Make sure `cookies.txt` contains data that matches the format expected by the script. Here are examples of file formats:
45 | 
46 |   ```bash
47 |     your_cookie_1
48 |     your_cookie_2
49 |   ```
50 | - **proxy.txt:** You will find the file `proxy.txt` inside the project directory. Make sure `proxy.txt` contains data that matches the format expected by the script. Here are examples of file formats:
51 |   ```bash
52 |     ip:port # Default Protcol HTTP.
53 |     protocol://ip:port
54 |     protocol://user:pass@ip:port
55 |   ```
56 | 
57 | ## Run
58 | 
59 | ```bash
60 | python bot.py #or python3 bot.py
61 | ```
62 | 
63 | ## Buy Me a Coffee
64 | 
65 | - **EVM:** 0xe3c9ef9a39e9eb0582e5b147026cae524338521a
66 | - **TON:** UQBEFv58DC4FUrGqinBB5PAQS7TzXSm5c1Fn6nkiet8kmehB
67 | - **SOL:** E1xkaJYmAFEj28NPHKhjbf7GcvfdjKdvXju8d8AeSunf
68 | - **SUI:** 0xa03726ecbbe00b31df6a61d7a59d02a7eedc39fe269532ceab97852a04cf3347
69 | 
70 | Thank you for visiting this repository, don't forget to contribute in the form of follows and stars.
71 | If you have questions, find an issue, or have suggestions for improvement, feel free to contact me or open an *issue* in this GitHub repository.
72 | 
73 | **vonssy**


--------------------------------------------------------------------------------
/bot.py:
--------------------------------------------------------------------------------
  1 | from aiohttp import (
  2 |     ClientResponseError,
  3 |     ClientSession,
  4 |     ClientTimeout,
  5 |     BasicAuth
  6 | )
  7 | from aiohttp_socks import ProxyConnector
  8 | from fake_useragent import FakeUserAgent
  9 | from datetime import datetime
 10 | from colorama import *
 11 | import asyncio, json, re, os, pytz
 12 | 
 13 | wib = pytz.timezone('Asia/Jakarta')
 14 | 
 15 | class Goblin:
 16 |     def __init__(self) -> None:
 17 |         self.headers = {
 18 |             "Accept": "application/json, text/plain, */*",
 19 |             "Accept-Language": "id-ID,id;q=0.9,en-US;q=0.8,en;q=0.7",
 20 |             "Origin": "https://www.goblin.meme",
 21 |             "Referer": "https://www.goblin.meme/",
 22 |             "Sec-Fetch-Dest": "empty",
 23 |             "Sec-Fetch-Mode": "cors",
 24 |             "Sec-Fetch-Site": "same-origin",
 25 |             "User-Agent": FakeUserAgent().random
 26 |         }
 27 |         self.BASE_API = "https://www.goblin.meme/api"
 28 |         self.proxies = []
 29 |         self.proxy_index = 0
 30 |         self.account_proxies = {}
 31 | 
 32 |     def clear_terminal(self):
 33 |         os.system('cls' if os.name == 'nt' else 'clear')
 34 | 
 35 |     def log(self, message):
 36 |         print(
 37 |             f"{Fore.CYAN + Style.BRIGHT}[ {datetime.now().astimezone(wib).strftime('%x %X %Z')} ]{Style.RESET_ALL}"
 38 |             f"{Fore.WHITE + Style.BRIGHT} | {Style.RESET_ALL}{message}",
 39 |             flush=True
 40 |         )
 41 | 
 42 |     def welcome(self):
 43 |         print(
 44 |             f"""
 45 |         {Fore.GREEN + Style.BRIGHT}Goblin Meme {Fore.BLUE + Style.BRIGHT}Auto BOT
 46 |             """
 47 |             f"""
 48 |         {Fore.GREEN + Style.BRIGHT}Rey? {Fore.YELLOW + Style.BRIGHT}<INI WATERMARK>
 49 |             """
 50 |         )
 51 | 
 52 |     def format_seconds(self, seconds):
 53 |         hours, remainder = divmod(seconds, 3600)
 54 |         minutes, seconds = divmod(remainder, 60)
 55 |         return f"{int(hours):02}:{int(minutes):02}:{int(seconds):02}"
 56 |     
 57 |     async def load_proxies(self, use_proxy_choice: int):
 58 |         filename = "proxy.txt"
 59 |         try:
 60 |             if use_proxy_choice == 1:
 61 |                 async with ClientSession(timeout=ClientTimeout(total=30)) as session:
 62 |                     async with session.get("https://raw.githubusercontent.com/monosans/proxy-list/refs/heads/main/proxies/all.txt") as response:
 63 |                         response.raise_for_status()
 64 |                         content = await response.text()
 65 |                         with open(filename, 'w') as f:
 66 |                             f.write(content)
 67 |                         self.proxies = [line.strip() for line in content.splitlines() if line.strip()]
 68 |             else:
 69 |                 if not os.path.exists(filename):
 70 |                     self.log(f"{Fore.RED + Style.BRIGHT}File {filename} Not Found.{Style.RESET_ALL}")
 71 |                     return
 72 |                 with open(filename, 'r') as f:
 73 |                     self.proxies = [line.strip() for line in f.read().splitlines() if line.strip()]
 74 |             
 75 |             if not self.proxies:
 76 |                 self.log(f"{Fore.RED + Style.BRIGHT}No Proxies Found.{Style.RESET_ALL}")
 77 |                 return
 78 | 
 79 |             self.log(
 80 |                 f"{Fore.GREEN + Style.BRIGHT}Proxies Total  : {Style.RESET_ALL}"
 81 |                 f"{Fore.WHITE + Style.BRIGHT}{len(self.proxies)}{Style.RESET_ALL}"
 82 |             )
 83 |         
 84 |         except Exception as e:
 85 |             self.log(f"{Fore.RED + Style.BRIGHT}Failed To Load Proxies: {e}{Style.RESET_ALL}")
 86 |             self.proxies = []
 87 | 
 88 |     def check_proxy_schemes(self, proxies):
 89 |         schemes = ["http://", "https://", "socks4://", "socks5://"]
 90 |         if any(proxies.startswith(scheme) for scheme in schemes):
 91 |             return proxies
 92 |         return f"http://{proxies}"
 93 | 
 94 |     def get_next_proxy_for_account(self, account):
 95 |         if account not in self.account_proxies:
 96 |             if not self.proxies:
 97 |                 return None
 98 |             proxy = self.check_proxy_schemes(self.proxies[self.proxy_index])
 99 |             self.account_proxies[account] = proxy
100 |             self.proxy_index = (self.proxy_index + 1) % len(self.proxies)
101 |         return self.account_proxies[account]
102 | 
103 |     def rotate_proxy_for_account(self, account):
104 |         if not self.proxies:
105 |             return None
106 |         proxy = self.check_proxy_schemes(self.proxies[self.proxy_index])
107 |         self.account_proxies[account] = proxy
108 |         self.proxy_index = (self.proxy_index + 1) % len(self.proxies)
109 |         return proxy
110 |     
111 |     def build_proxy_config(self, proxy=None):
112 |         if not proxy:
113 |             return None, None, None
114 | 
115 |         if proxy.startswith("socks"):
116 |             connector = ProxyConnector.from_url(proxy)
117 |             return connector, None, None
118 | 
119 |         elif proxy.startswith("http"):
120 |             match = re.match(r"http://(.*?):(.*?)@(.*)", proxy)
121 |             if match:
122 |                 username, password, host_port = match.groups()
123 |                 clean_url = f"http://{host_port}"
124 |                 auth = BasicAuth(username, password)
125 |                 return None, clean_url, auth
126 |             else:
127 |                 return None, proxy, None
128 | 
129 |         raise Exception("Unsupported Proxy Type.")
130 | 
131 |     def print_question(self):
132 |         while True:
133 |             try:
134 |                 print(f"{Fore.WHITE + Style.BRIGHT}1. Run With Free Proxyscrape Proxy{Style.RESET_ALL}")
135 |                 print(f"{Fore.WHITE + Style.BRIGHT}2. Run With Private Proxy{Style.RESET_ALL}")
136 |                 print(f"{Fore.WHITE + Style.BRIGHT}3. Run Without Proxy{Style.RESET_ALL}")
137 |                 choose = int(input(f"{Fore.BLUE + Style.BRIGHT}Choose [1/2/3] -> {Style.RESET_ALL}").strip())
138 | 
139 |                 if choose in [1, 2, 3]:
140 |                     proxy_type = (
141 |                         "With Free Proxyscrape" if choose == 1 else 
142 |                         "With Private" if choose == 2 else 
143 |                         "Without"
144 |                     )
145 |                     print(f"{Fore.GREEN + Style.BRIGHT}Run {proxy_type} Proxy Selected.{Style.RESET_ALL}")
146 |                     break
147 |                 else:
148 |                     print(f"{Fore.RED + Style.BRIGHT}Please enter either 1, 2 or 3.{Style.RESET_ALL}")
149 |             except ValueError:
150 |                 print(f"{Fore.RED + Style.BRIGHT}Invalid input. Enter a number (1, 2 or 3).{Style.RESET_ALL}")
151 | 
152 |         rotate = False
153 |         if choose in [1, 2]:
154 |             while True:
155 |                 rotate = input(f"{Fore.BLUE + Style.BRIGHT}Rotate Invalid Proxy? [y/n] -> {Style.RESET_ALL}").strip()
156 | 
157 |                 if rotate in ["y", "n"]:
158 |                     rotate = rotate == "y"
159 |                     break
160 |                 else:
161 |                     print(f"{Fore.RED + Style.BRIGHT}Invalid input. Enter 'y' or 'n'.{Style.RESET_ALL}")
162 | 
163 |         return choose, rotate
164 |     
165 |     async def check_connection(self, proxy_url=None):
166 |         connector, proxy, proxy_auth = self.build_proxy_config(proxy_url)
167 |         try:
168 |             async with ClientSession(connector=connector, timeout=ClientTimeout(total=30)) as session:
169 |                 async with session.get(url="https://api.ipify.org?format=json", proxy=proxy, proxy_auth=proxy_auth) as response:
170 |                     response.raise_for_status()
171 |                     return True
172 |         except (Exception, ClientResponseError) as e:
173 |             self.log(
174 |                 f"{Fore.CYAN+Style.BRIGHT}Status :{Style.RESET_ALL}"
175 |                 f"{Fore.RED+Style.BRIGHT} Connection Not 200 OK {Style.RESET_ALL}"
176 |                 f"{Fore.MAGENTA+Style.BRIGHT}-{Style.RESET_ALL}"
177 |                 f"{Fore.YELLOW+Style.BRIGHT} {str(e)} {Style.RESET_ALL}"
178 |             )
179 |         
180 |         return None
181 |     
182 |     async def auth_session(self, cookie: str, proxy_url=None, retries=5):
183 |         url = f"{self.BASE_API}/auth/session"
184 |         headers = {
185 |             **self.headers,
186 |             "Cookie": cookie
187 |         }
188 |         await asyncio.sleep(3)
189 |         for attempt in range(retries):
190 |             connector, proxy, proxy_auth = self.build_proxy_config(proxy_url)
191 |             try:
192 |                 async with ClientSession(connector=connector, timeout=ClientTimeout(total=60)) as session:
193 |                     async with session.get(url=url, headers=headers, proxy=proxy, proxy_auth=proxy_auth) as response:
194 |                         response.raise_for_status()
195 |                         return await response.json()
196 |             except (Exception, ClientResponseError) as e:
197 |                 if attempt < retries - 1:
198 |                     await asyncio.sleep(5)
199 |                     continue
200 |                 return None
201 |     
202 |     async def box_lists(self, cookie: str, proxy_url=None, retries=5):
203 |         url = f"{self.BASE_API}/box"
204 |         headers = {
205 |             **self.headers,
206 |             "Cookie": cookie
207 |         }
208 |         await asyncio.sleep(3)
209 |         for attempt in range(retries):
210 |             connector, proxy, proxy_auth = self.build_proxy_config(proxy_url)
211 |             try:
212 |                 async with ClientSession(connector=connector, timeout=ClientTimeout(total=60)) as session:
213 |                     async with session.get(url=url, headers=headers, proxy=proxy, proxy_auth=proxy_auth) as response:
214 |                         response.raise_for_status()
215 |                         return await response.json()
216 |             except (Exception, ClientResponseError) as e:
217 |                 if attempt < retries - 1:
218 |                     await asyncio.sleep(5)
219 |                     continue
220 |                 return None
221 |     
222 |     async def box_data(self, cookie: str, box_id: str, proxy_url=None, retries=5):
223 |         url = f"{self.BASE_API}/box/{box_id}"
224 |         headers = {
225 |             **self.headers,
226 |             "Cookie": cookie
227 |         }
228 |         await asyncio.sleep(3)
229 |         for attempt in range(retries):
230 |             connector, proxy, proxy_auth = self.build_proxy_config(proxy_url)
231 |             try:
232 |                 async with ClientSession(connector=connector, timeout=ClientTimeout(total=60)) as session:
233 |                     async with session.get(url=url, headers=headers, proxy=proxy, proxy_auth=proxy_auth) as response:
234 |                         response.raise_for_status()
235 |                         return await response.json()
236 |             except (Exception, ClientResponseError) as e:
237 |                 if attempt < retries - 1:
238 |                     await asyncio.sleep(5)
239 |                     continue
240 |                 return None
241 |     
242 |     async def start_mining(self, cookie: str, box_id: str, proxy_url=None, retries=5):
243 |         url = f"{self.BASE_API}/box/{box_id}/start"
244 |         headers = {
245 |             **self.headers,
246 |             "Content-Length": "2",
247 |             "Content-Type": "application/json",
248 |             "Cookie": cookie
249 |         }
250 |         await asyncio.sleep(3)
251 |         for attempt in range(retries):
252 |             connector, proxy, proxy_auth = self.build_proxy_config(proxy_url)
253 |             try:
254 |                 async with ClientSession(connector=connector, timeout=ClientTimeout(total=60)) as session:
255 |                     async with session.post(url=url, headers=headers, json={}, proxy=proxy, proxy_auth=proxy_auth) as response:
256 |                         if response.status == 400:
257 |                             return None
258 |                         response.raise_for_status()
259 |                         return await response.json()
260 |             except (Exception, ClientResponseError) as e:
261 |                 if attempt < retries - 1:
262 |                     await asyncio.sleep(5)
263 |                     continue
264 |                 return None
265 |     
266 |     async def open_box(self, cookie: str, box_id: str, proxy_url=None, retries=5):
267 |         url = f"{self.BASE_API}/box/{box_id}/claim"
268 |         headers = {
269 |             **self.headers,
270 |             "Content-Length": "2",
271 |             "Content-Type": "application/json",
272 |             "Cookie": cookie
273 |         }
274 |         await asyncio.sleep(3)
275 |         for attempt in range(retries):
276 |             connector, proxy, proxy_auth = self.build_proxy_config(proxy_url)
277 |             try:
278 |                 async with ClientSession(connector=connector, timeout=ClientTimeout(total=60)) as session:
279 |                     async with session.post(url=url, headers=headers, json={}, proxy=proxy, proxy_auth=proxy_auth) as response:
280 |                         response.raise_for_status()
281 |                         return await response.json()
282 |             except (Exception, ClientResponseError) as e:
283 |                 if attempt < retries - 1:
284 |                     await asyncio.sleep(5)
285 |                     continue
286 |                 return None
287 |     
288 |     async def complete_mission(self, cookie: str, box_id: str, mission_url: str, proxy_url=None, retries=5):
289 |         url = f"{self.BASE_API}/box/{box_id}/mission"
290 |         data = json.dumps({"url":mission_url})
291 |         headers = {
292 |             **self.headers,
293 |             "Content-Length": str(len(data)),
294 |             "Content-Type": "application/json",
295 |             "Cookie": cookie
296 |         }
297 |         await asyncio.sleep(3)
298 |         for attempt in range(retries):
299 |             connector, proxy, proxy_auth = self.build_proxy_config(proxy_url)
300 |             try:
301 |                 async with ClientSession(connector=connector, timeout=ClientTimeout(total=60)) as session:
302 |                     async with session.post(url=url, headers=headers, data=data, proxy=proxy, proxy_auth=proxy_auth) as response:
303 |                         response.raise_for_status()
304 |                         return await response.json()
305 |             except (Exception, ClientResponseError) as e:
306 |                 if attempt < retries - 1:
307 |                     await asyncio.sleep(5)
308 |                     continue
309 |                 return None
310 | 
311 |     async def process_check_connection(self, cookie: str, use_proxy: bool, rotate_proxy: bool):
312 |         while True:
313 |             proxy = self.get_next_proxy_for_account(cookie) if use_proxy else None
314 |             self.log(
315 |                 f"{Fore.CYAN + Style.BRIGHT}Proxy  :{Style.RESET_ALL}"
316 |                 f"{Fore.WHITE + Style.BRIGHT} {proxy} {Style.RESET_ALL}"
317 |             )
318 | 
319 |             is_valid = await self.check_connection(proxy)
320 |             if is_valid:
321 |                 return True
322 |             
323 |             if rotate_proxy:
324 |                 proxy = self.rotate_proxy_for_account(cookie)
325 |                 continue
326 | 
327 |             return False
328 |         
329 |     async def process_accounts(self, cookie: str, use_proxy: bool, rotate_proxy: bool):
330 |         is_valid = await self.process_check_connection(cookie, use_proxy, rotate_proxy)
331 |         if is_valid:
332 |             proxy = self.get_next_proxy_for_account(cookie) if use_proxy else None
333 |             
334 |             username = "N/A"
335 |             balance = "N/A"
336 | 
337 |             session = await self.auth_session(cookie, proxy)
338 |             if session:
339 |                 username = session.get("user", {}).get("xUsername", "N/A")
340 |                 balance = session.get("user", {}).get("goblinPoints", 0)
341 | 
342 |             self.log(
343 |                 f"{Fore.CYAN + Style.BRIGHT}Handler:{Style.RESET_ALL}"
344 |                 f"{Fore.WHITE + Style.BRIGHT} {username} {Style.RESET_ALL}"
345 |             )
346 |             self.log(
347 |                 f"{Fore.CYAN + Style.BRIGHT}Balance:{Style.RESET_ALL}"
348 |                 f"{Fore.WHITE + Style.BRIGHT} {balance} PTS {Style.RESET_ALL}"
349 |             )
350 |             
351 |             box_lists = await self.box_lists(cookie, proxy)
352 |             if not box_lists:
353 |                 self.log(
354 |                     f"{Fore.CYAN + Style.BRIGHT}Boxes  :{Style.RESET_ALL}"
355 |                     f"{Fore.RED + Style.BRIGHT} GET Available Box Failed {Style.RESET_ALL}"
356 |                 )
357 |                 return
358 |             
359 |             boxes = box_lists["boxes"]
360 |             
361 |             self.log(
362 |                 f"{Fore.CYAN + Style.BRIGHT}Boxes  :{Style.RESET_ALL}"
363 |                 f"{Fore.GREEN + Style.BRIGHT} Available {Style.RESET_ALL}"
364 |                 f"{Fore.WHITE + Style.BRIGHT}{len(boxes)}{Style.RESET_ALL}"
365 |             )
366 | 
367 |             for box in boxes:
368 |                 if box:
369 |                     box_id = box["_id"]
370 |                     box_name = box["name"]
371 |                     is_active = box["active"]
372 | 
373 |                     if not is_active:
374 |                         self.log(
375 |                             f"{Fore.GREEN + Style.BRIGHT}   ●{Style.RESET_ALL}"
376 |                             f"{Fore.BLUE + Style.BRIGHT} {box_name} {Style.RESET_ALL}"
377 |                             f"{Fore.YELLOW + Style.BRIGHT}Inactive{Style.RESET_ALL}"
378 |                         )
379 |                         continue
380 | 
381 |                     self.log(
382 |                         f"{Fore.GREEN + Style.BRIGHT}   ●{Style.RESET_ALL}"
383 |                         f"{Fore.BLUE + Style.BRIGHT} {box_name} {Style.RESET_ALL}"
384 |                         f"{Fore.GREEN + Style.BRIGHT}Active{Style.RESET_ALL}"
385 |                     )
386 | 
387 |                     data = await self.box_data(cookie, box_id, proxy)
388 |                     if not data:
389 |                         self.log(
390 |                             f"{Fore.MAGENTA + Style.BRIGHT}     >{Style.RESET_ALL}"
391 |                             f"{Fore.RED + Style.BRIGHT} GET Status Box Failed {Style.RESET_ALL}"
392 |                         )
393 |                         continue
394 | 
395 |                     mission_url = data["missionUrl"]
396 |                     mission_desc = data["missionDesc"]
397 |                     is_completed = data["missionCompleted"]
398 |                     is_hasbox = data["hasBox"]
399 |                     is_ready = data["isReady"]
400 |                     is_opened = data["opened"]
401 | 
402 |                     if not is_hasbox:
403 |                         self.log(
404 |                             f"{Fore.MAGENTA + Style.BRIGHT}     >{Style.RESET_ALL}"
405 |                             f"{Fore.CYAN + Style.BRIGHT} Has Box : {Style.RESET_ALL}"
406 |                             f"{Fore.RED + Style.BRIGHT}False{Style.RESET_ALL}"
407 |                             f"{Fore.MAGENTA + Style.BRIGHT} - {Style.RESET_ALL}"
408 |                             f"{Fore.YELLOW + Style.BRIGHT}Starting Mining...{Style.RESET_ALL}"
409 |                         )
410 | 
411 |                         start = await self.start_mining(cookie, box_id, proxy)
412 |                         if start and start.get("message") == "Box mining started":
413 |                             self.log(
414 |                                 f"{Fore.MAGENTA + Style.BRIGHT}     >{Style.RESET_ALL}"
415 |                                 f"{Fore.CYAN + Style.BRIGHT} Status  : {Style.RESET_ALL}"
416 |                                 f"{Fore.GREEN + Style.BRIGHT}Success{Style.RESET_ALL}"
417 |                             )
418 |                         else:
419 |                             self.log(
420 |                                 f"{Fore.MAGENTA + Style.BRIGHT}     >{Style.RESET_ALL}"
421 |                                 f"{Fore.CYAN + Style.BRIGHT} Status  : {Style.RESET_ALL}"
422 |                                 f"{Fore.RED + Style.BRIGHT}Failed or Already Have an Active Box Mining{Style.RESET_ALL}"
423 |                             )
424 |                         continue
425 | 
426 |                     self.log(
427 |                         f"{Fore.MAGENTA + Style.BRIGHT}     >{Style.RESET_ALL}"
428 |                         f"{Fore.CYAN + Style.BRIGHT} Has Box : {Style.RESET_ALL}"
429 |                         f"{Fore.GREEN + Style.BRIGHT}True{Style.RESET_ALL}"
430 |                     )
431 | 
432 |                     if not is_ready:
433 |                         self.log(
434 |                             f"{Fore.MAGENTA + Style.BRIGHT}     >{Style.RESET_ALL}"
435 |                             f"{Fore.CYAN + Style.BRIGHT} Is Ready: {Style.RESET_ALL}"
436 |                             f"{Fore.YELLOW + Style.BRIGHT}Not Yet{Style.RESET_ALL}"
437 |                         )
438 |                         continue
439 | 
440 |                     self.log(
441 |                         f"{Fore.MAGENTA + Style.BRIGHT}     >{Style.RESET_ALL}"
442 |                         f"{Fore.CYAN + Style.BRIGHT} Is Ready: {Style.RESET_ALL}"
443 |                         f"{Fore.GREEN + Style.BRIGHT}True{Style.RESET_ALL}"
444 |                     )
445 | 
446 |                     if not is_completed:
447 |                         self.log(
448 |                             f"{Fore.MAGENTA + Style.BRIGHT}     >{Style.RESET_ALL}"
449 |                             f"{Fore.CYAN + Style.BRIGHT} Mission : {Style.RESET_ALL}"
450 |                             f"{Fore.WHITE + Style.BRIGHT}{mission_desc}{Style.RESET_ALL}"
451 |                             f"{Fore.RED + Style.BRIGHT} Uncomplete {Style.RESET_ALL}"
452 |                             f"{Fore.MAGENTA + Style.BRIGHT}-{Style.RESET_ALL}"
453 |                             f"{Fore.YELLOW + Style.BRIGHT} Completing Mission... {Style.RESET_ALL}"
454 |                         )
455 | 
456 |                         complete = await self.complete_mission(cookie, box_id, mission_url, proxy)
457 |                         if complete:
458 |                             self.log(
459 |                                 f"{Fore.MAGENTA + Style.BRIGHT}     >{Style.RESET_ALL}"
460 |                                 f"{Fore.CYAN + Style.BRIGHT} Status  : {Style.RESET_ALL}"
461 |                                 f"{Fore.GREEN + Style.BRIGHT}Completed{Style.RESET_ALL}"
462 |                             )
463 | 
464 |                             self.log(
465 |                                 f"{Fore.MAGENTA + Style.BRIGHT}     >{Style.RESET_ALL}"
466 |                                 f"{Fore.YELLOW + Style.BRIGHT} Opening Box... {Style.RESET_ALL}"
467 |                             )
468 | 
469 |                             open = await self.open_box(cookie, box_id, proxy)
470 |                             if open and open.get("message") == "Box opened! Prize credited.":
471 |                                 reward = open["prizeAmount"]
472 | 
473 |                                 self.log(
474 |                                     f"{Fore.MAGENTA + Style.BRIGHT}     >{Style.RESET_ALL}"
475 |                                     f"{Fore.CYAN + Style.BRIGHT} Status  : {Style.RESET_ALL}"
476 |                                     f"{Fore.GREEN + Style.BRIGHT}Success{Style.RESET_ALL}"
477 |                                 )
478 |                                 self.log(
479 |                                     f"{Fore.MAGENTA + Style.BRIGHT}     >{Style.RESET_ALL}"
480 |                                     f"{Fore.CYAN + Style.BRIGHT} Reward  : {Style.RESET_ALL}"
481 |                                     f"{Fore.WHITE + Style.BRIGHT}{reward} PTS{Style.RESET_ALL}"
482 |                                 )
483 | 
484 |                                 self.log(
485 |                                     f"{Fore.MAGENTA + Style.BRIGHT}     >{Style.RESET_ALL}"
486 |                                     f"{Fore.YELLOW + Style.BRIGHT} Starting Mining... {Style.RESET_ALL}"
487 |                                 )
488 | 
489 |                                 start = await self.start_mining(cookie, box_id, proxy)
490 |                                 if start and start.get("message") == "Box mining started":
491 |                                     self.log(
492 |                                         f"{Fore.MAGENTA + Style.BRIGHT}     >{Style.RESET_ALL}"
493 |                                         f"{Fore.CYAN + Style.BRIGHT} Status  : {Style.RESET_ALL}"
494 |                                         f"{Fore.GREEN + Style.BRIGHT}Success{Style.RESET_ALL}"
495 |                                     )
496 |                                 else:
497 |                                     self.log(
498 |                                         f"{Fore.MAGENTA + Style.BRIGHT}     >{Style.RESET_ALL}"
499 |                                         f"{Fore.CYAN + Style.BRIGHT} Status  : {Style.RESET_ALL}"
500 |                                         f"{Fore.RED + Style.BRIGHT}Failed or Already Have an Active Box Mining{Style.RESET_ALL}"
501 |                                     )
502 | 
503 |                             else:
504 |                                 self.log(
505 |                                     f"{Fore.MAGENTA + Style.BRIGHT}     >{Style.RESET_ALL}"
506 |                                     f"{Fore.CYAN + Style.BRIGHT} Status  : {Style.RESET_ALL}"
507 |                                     f"{Fore.RED + Style.BRIGHT}Failed{Style.RESET_ALL}"
508 |                                 )
509 | 
510 |                         else:
511 |                             self.log(
512 |                                 f"{Fore.MAGENTA + Style.BRIGHT}     >{Style.RESET_ALL}"
513 |                                 f"{Fore.CYAN + Style.BRIGHT} Status  : {Style.RESET_ALL}"
514 |                                 f"{Fore.RED + Style.BRIGHT}Not Complete{Style.RESET_ALL}"
515 |                             )
516 |                         continue
517 | 
518 |                     self.log(
519 |                         f"{Fore.MAGENTA + Style.BRIGHT}     >{Style.RESET_ALL}"
520 |                         f"{Fore.CYAN + Style.BRIGHT} Mission : {Style.RESET_ALL}"
521 |                         f"{Fore.WHITE + Style.BRIGHT}{mission_desc}{Style.RESET_ALL}"
522 |                         f"{Fore.RED + Style.BRIGHT} Completed {Style.RESET_ALL}"
523 |                     )
524 | 
525 |                     if not is_opened:
526 |                         self.log(
527 |                             f"{Fore.MAGENTA + Style.BRIGHT}     >{Style.RESET_ALL}"
528 |                             f"{Fore.CYAN + Style.BRIGHT} Opened  : {Style.RESET_ALL}"
529 |                             f"{Fore.RED + Style.BRIGHT}False{Style.RESET_ALL}"
530 |                             f"{Fore.MAGENTA + Style.BRIGHT} - {Style.RESET_ALL}"
531 |                             f"{Fore.YELLOW + Style.BRIGHT}Opening Box...{Style.RESET_ALL}"
532 |                         )
533 | 
534 |                         open = await self.open_box(cookie, box_id, proxy)
535 |                         if open and open.get("message") == "Box opened! Prize credited.":
536 |                             reward = open["prizeAmount"]
537 | 
538 |                             self.log(
539 |                                 f"{Fore.MAGENTA + Style.BRIGHT}     >{Style.RESET_ALL}"
540 |                                 f"{Fore.CYAN + Style.BRIGHT} Status  : {Style.RESET_ALL}"
541 |                                 f"{Fore.GREEN + Style.BRIGHT}Success{Style.RESET_ALL}"
542 |                             )
543 |                             self.log(
544 |                                 f"{Fore.MAGENTA + Style.BRIGHT}     >{Style.RESET_ALL}"
545 |                                 f"{Fore.CYAN + Style.BRIGHT} Reward  : {Style.RESET_ALL}"
546 |                                 f"{Fore.WHITE + Style.BRIGHT}{reward} PTS{Style.RESET_ALL}"
547 |                             )
548 | 
549 |                             self.log(
550 |                                 f"{Fore.MAGENTA + Style.BRIGHT}     >{Style.RESET_ALL}"
551 |                                 f"{Fore.YELLOW + Style.BRIGHT} Starting Mining... {Style.RESET_ALL}"
552 |                             )
553 | 
554 |                             start = await self.start_mining(cookie, box_id, proxy)
555 |                             if start and start.get("message") == "Box mining started":
556 |                                 self.log(
557 |                                     f"{Fore.MAGENTA + Style.BRIGHT}     >{Style.RESET_ALL}"
558 |                                     f"{Fore.CYAN + Style.BRIGHT} Status  : {Style.RESET_ALL}"
559 |                                     f"{Fore.GREEN + Style.BRIGHT}Success{Style.RESET_ALL}"
560 |                                 )
561 |                             else:
562 |                                 self.log(
563 |                                     f"{Fore.MAGENTA + Style.BRIGHT}     >{Style.RESET_ALL}"
564 |                                     f"{Fore.CYAN + Style.BRIGHT} Status  : {Style.RESET_ALL}"
565 |                                     f"{Fore.RED + Style.BRIGHT}Failed{Style.RESET_ALL}"
566 |                                 )
567 | 
568 |                         else:
569 |                             self.log(
570 |                                 f"{Fore.MAGENTA + Style.BRIGHT}     >{Style.RESET_ALL}"
571 |                                 f"{Fore.CYAN + Style.BRIGHT} Status  : {Style.RESET_ALL}"
572 |                                 f"{Fore.RED + Style.BRIGHT}Failed{Style.RESET_ALL}"
573 |                             )
574 | 
575 |     async def main(self):
576 |         try:
577 |             with open('cookies.txt', 'r') as file:
578 |                 cookies = [line.strip() for line in file if line.strip()]
579 | 
580 |             use_proxy_choice, rotate_proxy = self.print_question()
581 | 
582 |             use_proxy = False
583 |             if use_proxy_choice in [1, 2]:
584 |                 use_proxy = True
585 | 
586 |             while True:
587 |                 self.clear_terminal()
588 |                 self.welcome()
589 |                 self.log(
590 |                     f"{Fore.GREEN + Style.BRIGHT}Account's Total: {Style.RESET_ALL}"
591 |                     f"{Fore.WHITE + Style.BRIGHT}{len(cookies)}{Style.RESET_ALL}"
592 |                 )
593 | 
594 |                 if use_proxy:
595 |                     await self.load_proxies(use_proxy_choice)
596 | 
597 |                 separator = "=" * 25
598 |                 for idx, cookie in enumerate(cookies, start=1):
599 |                     if cookie:
600 |                         self.log(
601 |                             f"{Fore.CYAN + Style.BRIGHT}{separator}[{Style.RESET_ALL}"
602 |                             f"{Fore.WHITE + Style.BRIGHT} {idx} {Style.RESET_ALL}"
603 |                             f"{Fore.CYAN + Style.BRIGHT}Of{Style.RESET_ALL}"
604 |                             f"{Fore.WHITE + Style.BRIGHT} {len(cookies)} {Style.RESET_ALL}"
605 |                             f"{Fore.CYAN + Style.BRIGHT}]{separator}{Style.RESET_ALL}"
606 |                         )
607 |                         
608 |                         await self.process_accounts(cookie, use_proxy, rotate_proxy)
609 |                         await asyncio.sleep(3)
610 | 
611 |                 self.log(f"{Fore.CYAN + Style.BRIGHT}={Style.RESET_ALL}"*60)
612 |                 
613 |                 delay = 24 * 60 * 60
614 |                 while delay > 0:
615 |                     formatted_time = self.format_seconds(delay)
616 |                     print(
617 |                         f"{Fore.CYAN+Style.BRIGHT}[ Wait for{Style.RESET_ALL}"
618 |                         f"{Fore.WHITE+Style.BRIGHT} {formatted_time} {Style.RESET_ALL}"
619 |                         f"{Fore.CYAN+Style.BRIGHT}... ]{Style.RESET_ALL}"
620 |                         f"{Fore.WHITE+Style.BRIGHT} | {Style.RESET_ALL}"
621 |                         f"{Fore.BLUE+Style.BRIGHT}All Accounts Have Been Processed...{Style.RESET_ALL}",
622 |                         end="\r",
623 |                         flush=True
624 |                     )
625 |                     await asyncio.sleep(1)
626 |                     delay -= 1
627 | 
628 |         except FileNotFoundError:
629 |             self.log(f"{Fore.RED}File 'accounts.txt' Not Found.{Style.RESET_ALL}")
630 |             return
631 |         except Exception as e:
632 |             self.log(f"{Fore.RED+Style.BRIGHT}Error: {e}{Style.RESET_ALL}")
633 |             raise
634 | 
635 | if __name__ == "__main__":
636 |     try:
637 |         bot = Goblin()
638 |         asyncio.run(bot.main())
639 |     except KeyboardInterrupt:
640 |         print(
641 |             f"{Fore.CYAN + Style.BRIGHT}[ {datetime.now().astimezone(wib).strftime('%x %X %Z')} ]{Style.RESET_ALL}"
642 |             f"{Fore.WHITE + Style.BRIGHT} | {Style.RESET_ALL}"
643 |             f"{Fore.RED + Style.BRIGHT}[ EXIT ] Goblin Meme - BOT{Style.RESET_ALL}                                       "                              
644 |         )


--------------------------------------------------------------------------------