Upload folder using huggingface_hub

.github/workflows/docker.yml

@@ -0,0 +1,29 @@
+name: Build and Push Docker Image
+
+on:
+ push:
+ branches:
+ - main
+
+jobs:
+ push_to_registry:
+ name: Push Docker image to Docker Hub
+ runs-on: ubuntu-latest
+ permissions:
+ contents: read
+ packages: write
+ steps:
+ - name: Check out the repo
+ uses: actions/checkout@v3
+
+ - name: Login to GitHub Container Registry
+ uses: docker/login-action@v1
+ with:
+ registry: ghcr.io
+ username: ${{ github.actor }}
+ password: ${{ secrets.GITHUB_TOKEN }}
+
+ - name: 'Build Inventory Image'
+ run: |
+ docker build . --tag ghcr.io/orrnobmahmud/moonbixauto:latest
+ docker push ghcr.io/orrnobmahmud/moonbixauto:latest

bot-proxy.py

@@ -0,0 +1,75 @@
+import sys
+
+sys.dont_write_bytecode = True
+
+from orrnob_drops_automation import base
+from core.token import get_token
+from core.info import get_info
+from core.game import process_play_game
+
+import time
+import json
+
+
+class Moonbix:
+ def __init__(self):
+ # Get file directory
+ self.data_file = base.file_path(file_name="data-proxy.json")
+ self.config_file = base.file_path(file_name="config.json")
+
+ # Initialize line
+ self.line = base.create_line(length=50)
+
+ # Initialize banner
+ self.banner = base.create_banner(game_name="Moonbix")
+
+ def main(self):
+ while True:
+ base.clear_terminal()
+ print(self.banner)
+ accounts = json.load(open(self.data_file, "r"))["accounts"]
+ num_acc = len(accounts)
+ base.log(self.line)
+ base.log(f"{base.green}Number of accounts: {base.white}{num_acc}")
+
+ for no, account in enumerate(accounts):
+ base.log(self.line)
+ base.log(f"{base.green}Account number: {base.white}{no+1}/{num_acc}")
+ data = account["acc_info"]
+ proxy_info = account["proxy_info"]
+ parsed_proxy_info = base.parse_proxy_info(proxy_info)
+ if parsed_proxy_info is None:
+ break
+
+ actual_ip = base.check_ip(proxy_info=proxy_info)
+
+ proxies = base.format_proxy(proxy_info=proxy_info)
+
+ try:
+ token = get_token(data=data, proxies=proxies)
+
+ if token:
+
+ get_info(token=token, proxies=proxies)
+
+ process_play_game(token=token, proxies=proxies)
+
+ get_info(token=token, proxies=proxies)
+
+ else:
+ base.log(f"{base.red}Token not found! Please get new query id")
+ except Exception as e:
+ base.log(f"{base.red}Error: {base.white}{e}")
+
+ print()
+ wait_time = 30 * 60
+ base.log(f"{base.yellow}Wait for {int(wait_time/60)} minutes!")
+ time.sleep(wait_time)
+
+
+if __name__ == "__main__":
+ try:
+ moonbix = Moonbix()
+ moonbix.main()
+ except KeyboardInterrupt:
+ sys.exit()

bot.py

@@ -0,0 +1,77 @@
+import sys
+import time
+
+sys.dont_write_bytecode = True
+
+from orrnob_drops_automation import base
+from core.token import get_token
+from core.info import get_info
+from core.game import process_play_game
+
+
+class Moonbix:
+ def __init__(self):
+ # Get file directory
+ self.data_file = base.file_path(file_name="data.txt")
+ self.config_file = base.file_path(file_name="config.json")
+ self.proxy_file = base.file_path(file_name="data.proxy.txt") # Add proxy file path
+
+ # Initialize line
+ self.line = base.create_line(length=50)
+
+ # Initialize banner
+ self.banner = base.create_banner(game_name="Moonbix")
+
+ def display_proxy(self):
+ # Display active proxy details if found
+ try:
+ with open(self.proxy_file, "r") as file:
+ proxy_data = file.read().strip()
+ if proxy_data:
+ base.log(f"{base.green}Active Proxy: {base.white}{proxy_data}")
+ else:
+ base.log(f"{base.red}No active proxy found.")
+ except FileNotFoundError:
+ base.log(f"{base.red}Proxy file not found.")
+
+ def main(self):
+ while True:
+ base.clear_terminal()
+ print(self.banner)
+
+ # Display proxy details
+ self.display_proxy()
+
+ data = open(self.data_file, "r").read().splitlines()
+ num_acc = len(data)
+ base.log(self.line)
+ base.log(f"{base.green}Number of accounts: {base.white}{num_acc}")
+
+ for no, data in enumerate(data):
+ base.log(self.line)
+ base.log(f"{base.green}Account number: {base.white}{no+1}/{num_acc}")
+
+ try:
+ token = get_token(data=data)
+
+ if token:
+ get_info(token=token)
+ process_play_game(token=token)
+ get_info(token=token)
+ else:
+ base.log(f"{base.red}Token Expired! Please get new query id")
+ except Exception as e:
+ base.log(f"{base.red}Error: {base.white}{e}")
+
+ print()
+ wait_time = 30 * 60
+ base.log(f"{base.yellow}Wait for {int(wait_time / 60)} minutes!")
+ time.sleep(wait_time)
+
+
+if __name__ == "__main__":
+ try:
+ moonbix = Moonbix()
+ moonbix.main()
+ except KeyboardInterrupt:
+ sys.exit()

compose.yml

@@ -0,0 +1,5 @@
+services:
+ app:
+ image: ghcr.io/orrnobmahmud/moonbixauto
+ volumes:
+ - ./data.txt:/app/moonbixauto/data.txt

config.json

@@ -0,0 +1 @@
+

core/combination.py

@@ -0,0 +1,89 @@
+import random
+import time
+import base64
+from Crypto.Cipher import AES
+from Crypto.Random import get_random_bytes
+
+
+def encrypt(text, key):
+ iv = get_random_bytes(12)
+ iv_base64 = base64.b64encode(iv).decode("utf-8")
+ cipher = AES.new(key, AES.MODE_CBC, iv_base64[:16].encode("utf-8"))
+
+ def pad(s):
+ block_size = AES.block_size
+ return s + (block_size - len(s) % block_size) * chr(
+ block_size - len(s) % block_size
+ )
+
+ padded_text = pad(text).encode("utf-8")
+ encrypted = cipher.encrypt(padded_text)
+ encrypted_base64 = base64.b64encode(encrypted).decode("utf-8")
+
+ return iv_base64 + encrypted_base64
+
+
+def get_game_data(game_response):
+ start_time = int(time.time() * 1000)
+ end_time = start_time + 45000 # 45 seconds in milliseconds
+ game_tag = game_response["data"]["gameTag"]
+ item_settings = game_response["data"]["cryptoMinerConfig"]["itemSettingList"]
+
+ current_time = start_time
+ score = 100
+ game_events = []
+
+ while current_time < end_time:
+ # Generate random time increment
+ time_increment = random.randint(1500, 2500)
+ current_time += time_increment
+
+ if current_time >= end_time:
+ break
+
+ # Generate random hook positions and angles
+ hook_pos_x = round(random.uniform(75, 275), 3)
+ hook_pos_y = round(random.uniform(199, 251), 3)
+ hook_shot_angle = round(random.uniform(-1, 1), 3)
+ hook_hit_x = round(random.uniform(100, 400), 3)
+ hook_hit_y = round(random.uniform(250, 700), 3)
+
+ # Determine item type, size, and points
+ item_type, item_size, points = 0, 0, 0
+ random_value = random.random()
+
+ if random_value < 0.6:
+ # Select a reward item
+ reward_items = [item for item in item_settings if item["type"] == "REWARD"]
+ selected_reward = random.choice(reward_items)
+ item_type = 1
+ item_size = selected_reward["size"]
+ points = min(selected_reward["rewardValueList"][0], 10)
+ score = min(score + points, 200)
+ elif random_value < 0.8:
+ # Select a trap item
+ trap_items = [item for item in item_settings if item["type"] == "TRAP"]
+ selected_trap = random.choice(trap_items)
+ item_type = 1
+ item_size = selected_trap["size"]
+ points = min(abs(selected_trap["rewardValueList"][0]), 20)
+ score = max(100, score - points)
+ else:
+ # Select a bonus item
+ bonus_item = next(
+ (item for item in item_settings if item["type"] == "BONUS"), None
+ )
+ if bonus_item:
+ item_type = 2
+ item_size = bonus_item["size"]
+ points = min(bonus_item["rewardValueList"][0], 15)
+ score = min(score + points, 200)
+
+ # Create event data string
+ event_data = f"{current_time}|{hook_pos_x}|{hook_pos_y}|{hook_shot_angle}|{hook_hit_x}|{hook_hit_y}|{item_type}|{item_size}|{points}"
+ game_events.append(event_data)
+
+ payload = ";".join(game_events)
+ encrypted_payload = encrypt(payload, game_tag.encode("utf-8"))
+
+ return encrypted_payload, score

core/game.py

@@ -0,0 +1,106 @@
+import requests
+import time
+import threading
+
+from orrnob_drops_automation import base
+from core.headers import headers
+from core.info import get_info
+from core.combination import get_game_data
+
+
+def start_game(token, proxies=None):
+ url = "https://www.binance.com/bapi/growth/v1/friendly/growth-paas/mini-app-activity/third-party/game/start"
+ payload = {"resourceId": 2056}
+
+ try:
+ response = requests.post(
+ url=url,
+ headers=headers(token=token),
+ json=payload,
+ proxies=proxies,
+ timeout=20,
+ )
+ data = response.json()
+ return data
+ except Exception as e:
+ base.log(f"{base.white}Error starting game: {e}")
+ return None
+
+
+def complete_game(token, payload, point, proxies=None):
+ url = "https://www.binance.com/bapi/growth/v1/friendly/growth-paas/mini-app-activity/third-party/game/complete"
+ payload = {
+ "resourceId": 2056,
+ "payload": payload,
+ "log": point,
+ }
+
+ try:
+ response = requests.post(
+ url=url,
+ headers=headers(token=token),
+ json=payload,
+ proxies=proxies,
+ timeout=20,
+ )
+ data = response.json()
+ status = data["success"]
+ return status
+ except Exception as e:
+ base.log(f"{base.white}Error completing game: {e}")
+ return None
+
+
+def loading_animation(seconds):
+ animation = "|/-\\"
+ for i in range(seconds):
+ print(f"\r{base.yellow}Playing... {animation[i % len(animation)]}", end="")
+ time.sleep(1)
+ print() # Move to the next line after loading
+
+
+def process_play_game(token, proxies=None):
+ while True:
+ start_game_data = start_game(token=token, proxies=proxies)
+ 
+ if start_game_data is None:
+ base.log(f"{base.white}Auto Play Game: {base.red}Failed to start the game")
+ break
+
+ start_game_code = start_game_data.get("code")
+
+ if start_game_code == "000000":
+ payload, point = get_game_data(game_response=start_game_data)
+ if payload:
+ base.log(f"{base.yellow}Playing for 45 seconds...")
+
+ # Create and start the loading animation thread
+ loading_thread = threading.Thread(target=loading_animation, args=(45,))
+ loading_thread.start()
+
+ # Wait for the game to be played
+ time.sleep(45) # Simulating game play time
+ 
+ # Wait for the loading animation to finish
+ loading_thread.join()
+
+ complete_game_status = complete_game(
+ token=token, payload=payload, point=point, proxies=proxies
+ )
+ if complete_game_status:
+ base.log(f"{base.white}Auto Play Game: {base.green}Success")
+ get_info(token=token, proxies=proxies)
+ time.sleep(1)
+ else:
+ base.log(f"{base.white}Auto Play Game: {base.red}Fail")
+ break
+ else:
+ base.log(f"{base.white}Auto Play Game: {base.red}Fail")
+ break
+ elif start_game_code == "116002":
+ base.log(f"{base.white}Auto Play Game: {base.red}No ticket left to play")
+ break
+ else:
+ error_message = start_game_data.get("messageDetail", "Unknown error")
+ base.log(f"{base.white}Auto Play Game: {base.red}Error - {error_message}")
+ break

core/headers.py

@@ -0,0 +1,10 @@
+def headers(token=None):
+ headers = {
+ "Accept": "application/json, text/plain, */*",
+ "Origin": "https://www.binance.com",
+ "Referer": "https://www.binance.com/en/game/tg/moon-bix",
+ "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36",
+ }
+ if token:
+ headers["X-Growth-Token"] = token
+ return headers

core/info.py

@@ -0,0 +1,37 @@
+import requests
+
+from orrnob_drops_automation import base
+from core.headers import headers
+
+
+def get_info(token, proxies=None):
+ url = "https://www.binance.com/bapi/growth/v1/friendly/growth-paas/mini-app-activity/third-party/user/user-info"
+ payload = {"resourceId": 2056}
+
+ try:
+ response = requests.post(
+ url=url,
+ headers=headers(token=token),
+ json=payload,
+ proxies=proxies,
+ timeout=20,
+ )
+ data = response.json()
+ total_grade = data["data"]["metaInfo"]["totalGrade"]
+ total_ref_grade = data["data"]["metaInfo"]["referralTotalGrade"]
+ if total_ref_grade:
+ balance = total_grade + total_ref_grade
+ else:
+ balance = total_grade
+ total_attempts = data["data"]["metaInfo"]["totalAttempts"]
+ consumed_attempts = data["data"]["metaInfo"]["consumedAttempts"]
+ attempts_left = total_attempts - consumed_attempts
+ is_countdown = data["data"]["metaInfo"]["attemptRefreshCountDownTime"]
+
+ base.log(
+ f"{base.green}Balance: {base.white}{balance:,} - {base.green}Tickets Left: {base.white}{attempts_left}"
+ )
+
+ return attempts_left, is_countdown
+ except:
+ return None, None

core/token.py

@@ -0,0 +1,19 @@
+import requests
+
+from orrnob_drops_automation import base
+from core.headers import headers
+
+
+def get_token(data, proxies=None):
+ url = "https://www.binance.com/bapi/growth/v1/friendly/growth-paas/third-party/access/accessToken"
+ payload = {"queryString": data, "socialType": "telegram"}
+
+ try:
+ response = requests.post(
+ url=url, headers=headers(), json=payload, proxies=proxies, timeout=20
+ )
+ data = response.json()
+ token = data["data"]["accessToken"]
+ return token
+ except:
+ return None

data-proxy.json

@@ -0,0 +1,12 @@
+{
+ "accounts": [
+ {
+ "acc_info": "",
+ "proxy_info": "http://user:pass@ip:port"
+ },
+ {
+ "acc_info": "",
+ "proxy_info": "http://user:pass@ip:port"
+ }
+ ]
+}

data.txt

@@ -0,0 +1 @@
+query data here

requirements.txt

@@ -0,0 +1,2 @@
+orrnob-drops-automation==0.1.6
+pycryptodome