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