rbr-api-fork 0.7.1__tar.gz

rbr_api_fork-0.7.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 VWH
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

rbr_api_fork-0.7.1/PKG-INFO

@@ -0,0 +1,171 @@
+Metadata-Version: 2.4
+Name: rbr-api-fork
+Version: 0.7.1
+Summary: Unofficial Python Client for Rocket Bot Royale Game API
+Author-email: VWH <vwhe@proton.me>
+Project-URL: Homepage, https://github.com/arenaslucas/rbr-api
+Project-URL: Issues, https://github.com/arenaslucas/rbr-api/issues
+Keywords: Rocket Bot Royale,game API,Unofficial API,Python library
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests
+Dynamic: license-file
+
+# Unofficial Client for RocketBotRoyale Game API
+
+[![Downloads](https://static.pepy.tech/badge/rbrapi)](https://pepy.tech/project/rbrapi)
+
+**⚠️️ For Educational Use Only!**
+
+This is an unofficial Python client for the Rocket Bot Royale game API. It allows users to interact with the game API, including authenticating, retrieving account details, collecting timed bonuses, sending friend requests, and purchasing crates.
+
+## Installation
+
+Install the package using pip:
+
+```
+pip install -U rbrapi
+```
+
+## Usage
+
+### Initialization
+
+Initialize a `RocketBotRoyale` instance with an email and password:
+
+```python
+from rbrapi import RocketBotRoyale
+from rbrapi.errors import AuthenticationError
+
+# Initialize with email and password
+client = RocketBotRoyale(email="email@example.com", password="your_password")
+```
+
+### Authentication
+
+Authenticate with the RocketBotRoyale API using provided credentials:
+
+> **Note:** It auto-authenticates when `RocketBotRoyale` is initialized. Use this only for regenerating the session token.
+
+```python
+try:
+    client.authenticate()
+    print("Authentication successful!")
+except AuthenticationError as e:
+    print(f"Authentication failed: {e}")
+```
+
+### Account Details
+
+Retrieve account details:
+
+```python
+try:
+    account_details = client.account()
+    print(f"Account ID: {account_details.custom_id}")
+    print(f"Username: {account_details.user["username"]}")
+    print(f"Gems: {account_details.wallet["gems"]}")
+    print(f"Coins: {account_details.wallet["coins"]}")
+except AuthenticationError as e:
+    print(f"Authentication failed: {e}")
+```
+
+### Collect Timed Bonus
+
+Collect a timed bonus:
+
+```python
+from rbrapi.errors import CollectTimedBonusError
+
+try:
+    success = client.collect_timed_bonus()
+    if success:
+        print("Timed bonus collected successfully!")
+    else:
+        print("Failed to collect timed bonus.")
+except AuthenticationError as e:
+    print(f"Authentication failed: {e}")
+except CollectTimedBonusError as e:
+    print(f"Failed to collect timed bonus: {e}")
+```
+
+### Send Friend Request
+
+Send a friend request to another user:
+
+```python
+from rbrapi.errors import FriendRequestError
+
+friend_code = "c2829d50"
+
+try:
+    success = client.send_friend_request(friend_code)
+    if success:
+        print("Friend request sent successfully!")
+    else:
+        print("Failed to send friend request.")
+except AuthenticationError as e:
+    print(f"Authentication failed: {e}")
+except FriendRequestError as e:
+    print(f"Failed to send friend request: {e}")
+```
+
+### Convert Friend Code to User ID
+
+Convert a friend's code to their user ID:
+
+```python
+from rbrapi.errors import AuthenticationError, userNotExistError
+
+friend_code = "c2829d50"
+
+try:
+    user_id = client.friend_code_to_id(friend_code)
+    print(f"User ID: {user_id}")
+except AuthenticationError as e:
+    print(f"Authentication failed: {e}")
+except userNotExistError as e:
+    print(f"User does not exist: {e}")
+```
+
+### Purchase Crate
+
+Purchase a crate (regular or elite):
+
+```python
+from rbrapi.errors import LootBoxError
+
+try:
+    crate_details = client.buy_crate(elite=False)  # Set elite=True for elite crate
+    print("Crate purchased successfully!")
+    print(f"Crate details: {crate_details}")
+except AuthenticationError as e:
+    print(f"Authentication failed: {e}")
+except LootBoxError as e:
+    print(f"Failed to purchase crate: {e}")
+```
+
+### Sign Up New User
+
+Make a new account with the RocketBotRoyale API:
+
+```python
+from rbrapi.errors import SignUpError
+
+email = "new_user@example.com"
+password = "new_password"
+username = "new_username"
+
+try:
+    success = RocketBotRoyale.signup(email, password, username)
+    if success:
+        print(f"User {username} signed up successfully!")
+    else:
+        print("Failed to sign up user.")
+except SignUpError as e:
+    print(f"Failed to sign up user: {e}")
+```

rbr_api_fork-0.7.1/README.md

@@ -0,0 +1,154 @@
+# Unofficial Client for RocketBotRoyale Game API
+
+[![Downloads](https://static.pepy.tech/badge/rbrapi)](https://pepy.tech/project/rbrapi)
+
+**⚠️️ For Educational Use Only!**
+
+This is an unofficial Python client for the Rocket Bot Royale game API. It allows users to interact with the game API, including authenticating, retrieving account details, collecting timed bonuses, sending friend requests, and purchasing crates.
+
+## Installation
+
+Install the package using pip:
+
+```
+pip install -U rbrapi
+```
+
+## Usage
+
+### Initialization
+
+Initialize a `RocketBotRoyale` instance with an email and password:
+
+```python
+from rbrapi import RocketBotRoyale
+from rbrapi.errors import AuthenticationError
+
+# Initialize with email and password
+client = RocketBotRoyale(email="email@example.com", password="your_password")
+```
+
+### Authentication
+
+Authenticate with the RocketBotRoyale API using provided credentials:
+
+> **Note:** It auto-authenticates when `RocketBotRoyale` is initialized. Use this only for regenerating the session token.
+
+```python
+try:
+    client.authenticate()
+    print("Authentication successful!")
+except AuthenticationError as e:
+    print(f"Authentication failed: {e}")
+```
+
+### Account Details
+
+Retrieve account details:
+
+```python
+try:
+    account_details = client.account()
+    print(f"Account ID: {account_details.custom_id}")
+    print(f"Username: {account_details.user["username"]}")
+    print(f"Gems: {account_details.wallet["gems"]}")
+    print(f"Coins: {account_details.wallet["coins"]}")
+except AuthenticationError as e:
+    print(f"Authentication failed: {e}")
+```
+
+### Collect Timed Bonus
+
+Collect a timed bonus:
+
+```python
+from rbrapi.errors import CollectTimedBonusError
+
+try:
+    success = client.collect_timed_bonus()
+    if success:
+        print("Timed bonus collected successfully!")
+    else:
+        print("Failed to collect timed bonus.")
+except AuthenticationError as e:
+    print(f"Authentication failed: {e}")
+except CollectTimedBonusError as e:
+    print(f"Failed to collect timed bonus: {e}")
+```
+
+### Send Friend Request
+
+Send a friend request to another user:
+
+```python
+from rbrapi.errors import FriendRequestError
+
+friend_code = "c2829d50"
+
+try:
+    success = client.send_friend_request(friend_code)
+    if success:
+        print("Friend request sent successfully!")
+    else:
+        print("Failed to send friend request.")
+except AuthenticationError as e:
+    print(f"Authentication failed: {e}")
+except FriendRequestError as e:
+    print(f"Failed to send friend request: {e}")
+```
+
+### Convert Friend Code to User ID
+
+Convert a friend's code to their user ID:
+
+```python
+from rbrapi.errors import AuthenticationError, userNotExistError
+
+friend_code = "c2829d50"
+
+try:
+    user_id = client.friend_code_to_id(friend_code)
+    print(f"User ID: {user_id}")
+except AuthenticationError as e:
+    print(f"Authentication failed: {e}")
+except userNotExistError as e:
+    print(f"User does not exist: {e}")
+```
+
+### Purchase Crate
+
+Purchase a crate (regular or elite):
+
+```python
+from rbrapi.errors import LootBoxError
+
+try:
+    crate_details = client.buy_crate(elite=False)  # Set elite=True for elite crate
+    print("Crate purchased successfully!")
+    print(f"Crate details: {crate_details}")
+except AuthenticationError as e:
+    print(f"Authentication failed: {e}")
+except LootBoxError as e:
+    print(f"Failed to purchase crate: {e}")
+```
+
+### Sign Up New User
+
+Make a new account with the RocketBotRoyale API:
+
+```python
+from rbrapi.errors import SignUpError
+
+email = "new_user@example.com"
+password = "new_password"
+username = "new_username"
+
+try:
+    success = RocketBotRoyale.signup(email, password, username)
+    if success:
+        print(f"User {username} signed up successfully!")
+    else:
+        print("Failed to sign up user.")
+except SignUpError as e:
+    print(f"Failed to sign up user: {e}")
+```

rbr_api_fork-0.7.1/pyproject.toml

@@ -0,0 +1,39 @@
+[project]
+
+name = "rbr-api-fork"
+version = "0.7.1"
+
+authors = [
+  { name="VWH", email="vwhe@proton.me" },
+]
+
+description = "Unofficial Python Client for Rocket Bot Royale Game API"
+readme = "README.md"
+requires-python = ">=3.8"
+
+keywords = [
+    "Rocket Bot Royale",
+    "game API",
+    "Unofficial API",
+    "Python library",
+]
+
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+
+dependencies = [
+  "requests",
+]
+
+[project.urls]
+Homepage = "https://github.com/arenaslucas/rbr-api"
+Issues = "https://github.com/arenaslucas/rbr-api/issues"
+
+[tool.setuptools]
+include-package-data = false
+
+[tool.setuptools.packages.find]
+exclude = ["examples"]

rbr_api_fork-0.7.1/rbr_api_fork.egg-info/PKG-INFO

@@ -0,0 +1,171 @@
+Metadata-Version: 2.4
+Name: rbr-api-fork
+Version: 0.7.1
+Summary: Unofficial Python Client for Rocket Bot Royale Game API
+Author-email: VWH <vwhe@proton.me>
+Project-URL: Homepage, https://github.com/arenaslucas/rbr-api
+Project-URL: Issues, https://github.com/arenaslucas/rbr-api/issues
+Keywords: Rocket Bot Royale,game API,Unofficial API,Python library
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests
+Dynamic: license-file
+
+# Unofficial Client for RocketBotRoyale Game API
+
+[![Downloads](https://static.pepy.tech/badge/rbrapi)](https://pepy.tech/project/rbrapi)
+
+**⚠️️ For Educational Use Only!**
+
+This is an unofficial Python client for the Rocket Bot Royale game API. It allows users to interact with the game API, including authenticating, retrieving account details, collecting timed bonuses, sending friend requests, and purchasing crates.
+
+## Installation
+
+Install the package using pip:
+
+```
+pip install -U rbrapi
+```
+
+## Usage
+
+### Initialization
+
+Initialize a `RocketBotRoyale` instance with an email and password:
+
+```python
+from rbrapi import RocketBotRoyale
+from rbrapi.errors import AuthenticationError
+
+# Initialize with email and password
+client = RocketBotRoyale(email="email@example.com", password="your_password")
+```
+
+### Authentication
+
+Authenticate with the RocketBotRoyale API using provided credentials:
+
+> **Note:** It auto-authenticates when `RocketBotRoyale` is initialized. Use this only for regenerating the session token.
+
+```python
+try:
+    client.authenticate()
+    print("Authentication successful!")
+except AuthenticationError as e:
+    print(f"Authentication failed: {e}")
+```
+
+### Account Details
+
+Retrieve account details:
+
+```python
+try:
+    account_details = client.account()
+    print(f"Account ID: {account_details.custom_id}")
+    print(f"Username: {account_details.user["username"]}")
+    print(f"Gems: {account_details.wallet["gems"]}")
+    print(f"Coins: {account_details.wallet["coins"]}")
+except AuthenticationError as e:
+    print(f"Authentication failed: {e}")
+```
+
+### Collect Timed Bonus
+
+Collect a timed bonus:
+
+```python
+from rbrapi.errors import CollectTimedBonusError
+
+try:
+    success = client.collect_timed_bonus()
+    if success:
+        print("Timed bonus collected successfully!")
+    else:
+        print("Failed to collect timed bonus.")
+except AuthenticationError as e:
+    print(f"Authentication failed: {e}")
+except CollectTimedBonusError as e:
+    print(f"Failed to collect timed bonus: {e}")
+```
+
+### Send Friend Request
+
+Send a friend request to another user:
+
+```python
+from rbrapi.errors import FriendRequestError
+
+friend_code = "c2829d50"
+
+try:
+    success = client.send_friend_request(friend_code)
+    if success:
+        print("Friend request sent successfully!")
+    else:
+        print("Failed to send friend request.")
+except AuthenticationError as e:
+    print(f"Authentication failed: {e}")
+except FriendRequestError as e:
+    print(f"Failed to send friend request: {e}")
+```
+
+### Convert Friend Code to User ID
+
+Convert a friend's code to their user ID:
+
+```python
+from rbrapi.errors import AuthenticationError, userNotExistError
+
+friend_code = "c2829d50"
+
+try:
+    user_id = client.friend_code_to_id(friend_code)
+    print(f"User ID: {user_id}")
+except AuthenticationError as e:
+    print(f"Authentication failed: {e}")
+except userNotExistError as e:
+    print(f"User does not exist: {e}")
+```
+
+### Purchase Crate
+
+Purchase a crate (regular or elite):
+
+```python
+from rbrapi.errors import LootBoxError
+
+try:
+    crate_details = client.buy_crate(elite=False)  # Set elite=True for elite crate
+    print("Crate purchased successfully!")
+    print(f"Crate details: {crate_details}")
+except AuthenticationError as e:
+    print(f"Authentication failed: {e}")
+except LootBoxError as e:
+    print(f"Failed to purchase crate: {e}")
+```
+
+### Sign Up New User
+
+Make a new account with the RocketBotRoyale API:
+
+```python
+from rbrapi.errors import SignUpError
+
+email = "new_user@example.com"
+password = "new_password"
+username = "new_username"
+
+try:
+    success = RocketBotRoyale.signup(email, password, username)
+    if success:
+        print(f"User {username} signed up successfully!")
+    else:
+        print("Failed to sign up user.")
+except SignUpError as e:
+    print(f"Failed to sign up user: {e}")
+```

rbr_api_fork-0.7.1/rbr_api_fork.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+rbr_api_fork.egg-info/PKG-INFO
+rbr_api_fork.egg-info/SOURCES.txt
+rbr_api_fork.egg-info/dependency_links.txt
+rbr_api_fork.egg-info/requires.txt
+rbr_api_fork.egg-info/top_level.txt
+rbrapi/__init__.py
+rbrapi/errors.py
+rbrapi/session.py
+rbrapi/types.py

rbr_api_fork-0.7.1/rbr_api_fork.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

rbr_api_fork-0.7.1/rbr_api_fork.egg-info/requires.txt

@@ -0,0 +1 @@
+requests

rbr_api_fork-0.7.1/rbr_api_fork.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+dist
+rbrapi

rbr_api_fork-0.7.1/rbrapi/__init__.py

@@ -0,0 +1,327 @@
+from __future__ import annotations
+
+__version__ = "0.7.1"
+
+from json import loads
+from typing import Optional, Self
+from uuid import uuid4
+
+from .errors import (
+    AuthenticationError,
+    CollectTimedBonusError,
+    FriendRequestError,
+    LootBoxError,
+    SignUpError,
+    UnknownUserError,
+)
+from .session import make_request
+from .types import (
+    AccountResponse,
+    AuthenticateResponse,
+    LootBoxResponses,
+    SignUpResponse,
+)
+
+CLIENT_VERSION = "9999999999"  # will never raise an AuthenticationError for having an older client version
+BASE_URL = "https://dev-nakama.winterpixel.io/v2"
+BASE_HEADERS = {
+    "accept": "application/json",
+    "authorization": "Basic OTAyaXViZGFmOWgyZTlocXBldzBmYjlhZWIzOTo=",
+    "origin": "https://rocketbotroyale2.winterpixel.io",
+    "referer": "https://rocketbotroyale2.winterpixel.io/",
+    "user-agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36",
+    "content-type": "application/json",
+}
+
+
+class RocketBotRoyale:
+    def __init__(self: Self, email: str, password: str) -> None:
+        """
+        Initialize RocketBotRoyale instance with email and password.
+
+        Args:
+            email (str): The account email.
+            password (str): The account password.
+        """
+
+        self.email = email
+        self.password = password
+        self.token: Optional[str] = None
+        self.authenticate()
+
+    def authenticate(self: Self, timeout: Optional[int] = None) -> AuthenticateResponse:
+        """
+        Authenticate the user.
+
+        Args:
+            timeout (int, optional): Timeout for the request in seconds.
+
+        Returns:
+            AuthenticateResponse: Response object containing authentication details.
+
+        Raises:
+            AuthenticationError: If authentication fails.
+        """
+
+        data = {
+            "email": self.email,
+            "password": self.password,
+            "vars": {"client_version": CLIENT_VERSION},
+        }
+
+        response = make_request(
+            f"{BASE_URL}/account/authenticate/email?create=false&",
+            headers=BASE_HEADERS,
+            json=data,
+            timeout=timeout,
+            error_if_not_ok=AuthenticationError,
+        )
+
+        response_data = AuthenticateResponse.from_dict(response)
+        self.token = response_data.token
+
+        return response_data
+
+    def account(self: Self, timeout: Optional[int] = None) -> AccountResponse:
+        """
+        Retrieve account details for the authenticated user.
+
+        Args:
+            timeout (int, optional): Timeout for the request in seconds.
+
+        Returns:
+            AccountResponse: Response object containing account details.
+
+        Raises:
+            AuthenticationError: If authentication token is missing or invalid.
+        """
+
+        if not self.token:
+            raise AuthenticationError("Token not found or user is unauthenticated")
+
+        response = make_request(
+            method="GET",
+            url=f"{BASE_URL}/account",
+            headers={**BASE_HEADERS, "authorization": f"Bearer {self.token}"},
+            timeout=timeout,
+        )
+
+        return AccountResponse.from_dict(response)
+
+    def collect_timed_bonus(self: Self, timeout: Optional[int] = None) -> bool:
+        """
+        Collect timed bonus.
+
+        Args:
+            timeout (int, optional): Timeout for the request in seconds.
+
+        Returns:
+            bool: True if timed bonus collection was successful.
+
+        Raises:
+            AuthenticationError: If authentication token is missing or invalid.
+            CollectTimedBonusError: If collecting timed bonus fails.
+        """
+        if not self.token:
+            raise AuthenticationError("Token not found or user is unauthenticated")
+
+        data = '"{}"'
+        make_request(
+            f"{BASE_URL}/rpc/collect_timed_bonus",
+            headers={
+                **BASE_HEADERS,
+                "authorization": f"Bearer {self.token}",
+                "content-type": "application/x-www-form-urlencoded",
+            },
+            data=data,
+            error_if_not_ok=CollectTimedBonusError,
+            timeout=timeout,
+        )
+
+        return True
+
+    def send_friend_request(
+        self: Self, friend_code: str, timeout: Optional[int] = None
+    ) -> bool:
+        """
+        Send a friend request.
+
+        Args:
+            friend_code (str): The friend code of the user to send the friend request to.
+            timeout (int, optional): Timeout for the request in seconds.
+
+        Returns:
+            bool: True if the friend request was sent successfully.
+
+        Raises:
+            AuthenticationError: If authentication token is missing or invalid.
+            FriendRequestError: If sending the friend request fails.
+        """
+
+        if not self.token:
+            raise AuthenticationError("Token not found or user is unauthenticated")
+
+        data = '"{\\"friend_code\\":\\"' + friend_code + '\\"}"'
+        make_request(
+            f"{BASE_URL}/rpc/winterpixel_query_user_id_for_friend_code",
+            headers={
+                **BASE_HEADERS,
+                "authorization": f"Bearer {self.token}",
+                "content-type": "application/x-www-form-urlencoded",
+            },
+            data=data,
+            error_if_not_ok=FriendRequestError,
+            timeout=timeout,
+        )
+
+        return True
+
+    def buy_crate(
+        self: Self, *, elite: bool = False, timeout: Optional[int] = None
+    ) -> LootBoxResponses:
+        """
+        Purchase a crate.
+
+        Args:
+            elite (bool, optional): Indicates if the crate to be bought is elite. Defaults to False.
+            timeout (int, optional): Timeout for the request in seconds.
+
+        Returns:
+            LootBoxResponses: Response object containing details of the purchased crate.
+
+        Raises:
+            AuthenticationError: If authentication token is missing or invalid.
+            LootBoxError: If purchasing the crate fails.
+        """
+
+        if not self.token:
+            raise AuthenticationError("Token not found or user is unauthenticated")
+
+        data = f'"{{\\"unique\\":{"true" if elite else "false"}}}"'
+        response = make_request(
+            f"{BASE_URL}/rpc/tankkings_consume_lootbox",
+            headers={
+                **BASE_HEADERS,
+                "authorization": f"Bearer {self.token}",
+                "content-type": "application/json",
+            },
+            data=data,
+            error_if_not_ok=LootBoxError,
+            timeout=timeout,
+        )
+
+        payload = response.get("payload")
+
+        if isinstance(payload, str):
+            payload = loads(payload)
+
+        if payload:
+            return LootBoxResponses.from_dict(payload)
+
+        raise LootBoxError(response.get("message", "Unable to buy crate"))
+
+    def friend_code_to_id(
+        self: Self, friend_code: str, timeout: Optional[int] = None
+    ) -> str:
+        """
+        Convert a friend code to a user ID.
+
+        Args:
+            friend_code (str): The friend code to be converted to a user ID.
+            timeout (int, optional): Timeout for the request in seconds.
+
+        Returns:
+            str: The user ID corresponding to the given friend code.
+
+        Raises:
+            AuthenticationError: If authentication token is missing or invalid.
+            userNotExistError: If the user with the given friend code does not exist or if the request fails.
+        """
+
+        if not self.token:
+            raise AuthenticationError("Token not found or user is unauthenticated")
+
+        data = '"{\\"friend_code\\":\\"' + friend_code + '\\"}"'
+        response = make_request(
+            f"{BASE_URL}/rpc/winterpixel_query_user_id_for_friend_code",
+            headers={
+                **BASE_HEADERS,
+                "authorization": f"Bearer {self.token}",
+                "content-type": "application/json",
+            },
+            data=data,
+            error_if_not_ok=UnknownUserError,
+            timeout=timeout,
+        )
+
+        payload = response.get("payload")
+
+        if isinstance(payload, str):
+            payload = loads(payload)
+
+        if payload and payload.get("user_id"):
+            return payload.get("user_id")
+
+        raise UnknownUserError(response.get("message", "Unable to get user id"))
+
+    @staticmethod
+    def signup(
+        email: str, password: str, username: str, timeout: Optional[int] = None
+    ) -> bool:
+        """
+        Sign up a new user.
+
+        Args:
+            email (str): New account email.
+            password (str): New account password.
+            username (str): Display name for the new account.
+            timeout (int, optional): Timeout for the request in seconds.
+
+        Returns:
+            bool: True if signup was successful.
+
+        Raises:
+            SignUpError: If signup fails.
+        """
+
+        data = (
+            '"{\\"display_name\\":\\"'
+            + username
+            + '\\",\\"email\\":\\"'
+            + email
+            + '\\",\\"password\\":\\"'
+            + password
+            + '\\"}"'
+        )
+
+        temp_account = RocketBotRoyale.__custom_account()
+        make_request(
+            f"{BASE_URL}/rpc/winterpixel_signup",
+            headers={
+                **BASE_HEADERS,
+                "authorization": f"Bearer {temp_account.token}",
+                "content-type": "application/x-www-form-urlencoded",
+            },
+            data=data,
+            error_if_not_ok=SignUpError,
+            timeout=timeout,
+        )
+
+        return True
+
+    @staticmethod
+    def __custom_account(timeout: Optional[int] = None) -> SignUpResponse:
+        data = {
+            "id": f"{uuid4()}",
+            "vars": {"client_version": CLIENT_VERSION, "platform": "HTML5"},
+        }
+
+        response = make_request(
+            f"{BASE_URL}/account/authenticate/custom?create=true&",
+            headers=BASE_HEADERS,
+            json=data,
+            error_if_not_ok=AuthenticationError,
+            timeout=timeout,
+        )
+
+        return SignUpResponse.from_dict(response)

rbr_api_fork-0.7.1/rbrapi/errors.py

@@ -0,0 +1,46 @@
+class AuthenticationError(Exception):
+    """
+    Exception raised for errors in the authentication process.
+    """
+
+    pass
+
+
+class SignUpError(Exception):
+    """
+    Exception raised for errors during the sign-up process.
+    """
+
+    pass
+
+
+class CollectTimedBonusError(Exception):
+    """
+    Exception raised for errors in collecting the timed bonus.
+    """
+
+    pass
+
+
+class FriendRequestError(Exception):
+    """
+    Exception raised for errors in sending a friend request.
+    """
+
+    pass
+
+
+class LootBoxError(Exception):
+    """
+    Exception raised for errors in purchasing a loot box.
+    """
+
+    pass
+
+
+class UnknownUserError(Exception):
+    """
+    Exception raised for errors in sending a query to find a user.
+    """
+
+    pass

rbr_api_fork-0.7.1/rbrapi/session.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+from datetime import UTC, datetime
+from threading import local
+from typing import Any, Optional
+
+import requests
+
+# Session time-to-live in seconds
+SESSION_TIME_TO_LIVE = 600
+
+# Thread-local storage for session and creation time
+thread_local = local()
+
+
+def get_session(*, reset: bool = False) -> requests.sessions.Session:
+    """Return or create a requests session, reset if expired."""
+    if not hasattr(thread_local, "session") or reset:
+        thread_local.session = requests.sessions.Session()
+        thread_local.creation_time = datetime.now(tz=UTC)
+
+    if (
+        SESSION_TIME_TO_LIVE
+        and (datetime.now(tz=UTC) - thread_local.creation_time).total_seconds()
+        > SESSION_TIME_TO_LIVE
+    ):
+        thread_local.session = requests.sessions.Session()
+        thread_local.creation_time = datetime.now(tz=UTC)
+
+    return thread_local.session
+
+
+def make_request(
+    url: str,
+    headers: Optional[dict[str, str]] = None,
+    json: Optional[dict[str, Any]] = None,
+    data: Optional[str] = None,
+    timeout: Optional[int] = 60,
+    method: str = "POST",
+    error_if_not_ok: Optional[Exception] = None,
+) -> dict[str, Any]:
+    session = get_session()
+
+    if method == "POST":
+        response = session.post(
+            url,
+            timeout=timeout,
+            headers=headers,
+            json=json,
+            data=data,
+        )
+    else:
+        response = session.get(
+            url,
+            timeout=timeout,
+            headers=headers,
+            json=json,
+            data=data,
+        )
+
+    if error_if_not_ok and not response.ok:
+        raise error_if_not_ok(response.json().get("message", "Unkown"))
+
+    return response.json()

rbr_api_fork-0.7.1/rbrapi/types.py

@@ -0,0 +1,195 @@
+from __future__ import annotations
+
+from json import dumps, loads
+from typing import Any, Self, TypedDict
+
+
+class APIResponse:
+    def __init__(self: Self, **kwargs: Any) -> None:
+        for key, value in kwargs.items():
+            setattr(self, key, value)
+
+    def __str__(self: Self) -> str:
+        return dumps(
+            {
+                "_": self.__class__.__name__,
+                **{
+                    attr: (getattr(self, attr))
+                    for attr in filter(lambda x: not x.startswith("_"), self.__dict__)
+                    if getattr(self, attr) is not None
+                },
+            },
+            ensure_ascii=False,
+            indent=2,
+        )
+
+    @classmethod
+    def from_dict(cls: type[Self], data: dict[str, str]) -> Self:
+        return cls(**data)
+
+
+class AuthenticateResponse(APIResponse):
+    token: str
+    refresh_token: str
+
+    def __init__(self: Self, *, token: str, refresh_token: str) -> None:
+        super().__init__(token=token, refresh_token=refresh_token)
+
+
+class SignUpResponse(APIResponse):
+    token: str
+    refresh_token: str
+    created: bool
+
+    def __init__(self: Self, *, token: str, refresh_token: str, created: bool) -> None:
+        super().__init__(token=token, refresh_token=refresh_token, created=created)
+
+
+class ProgressResponse(TypedDict):
+    xp: int
+    level: int
+
+
+class GoalResponse(TypedDict):
+    count: int
+    goal_id: str
+    unlocked_time: int
+
+
+class Goal(TypedDict):
+    goal_id: str
+    unlocked_time: int
+    count: int
+
+
+class UserStats(
+    TypedDict(
+        "UserStats",
+        {"5_kills": int, "triple-shots_used": int, "kills_using_triple-shot": int},
+    ),
+):
+    top_5: int
+    deaths: int
+    assists: int
+    snipers: int
+    bot_kills: int
+    games_won: int
+    yardsales: int
+    dunk_tanks: int
+    flaks_used: int
+    mines_used: int
+    nukes_used: int
+    squads_won: int
+    two_birdss: int
+    coins_found: int
+    drills_used: int
+    total_kills: int
+    double_kills: int
+    first_bloods: int
+    games_played: int
+    homings_used: int
+    player_kills: int
+    poisons_used: int
+    shields_used: int
+    triple_kills: int
+    grenades_used: int
+    meters_driven: float
+    squads_played: int
+    missiles_fired: int
+    beachball_shots: int
+    whirlwinds_used: int
+    crates_collected: int
+    kills_using_flak: int
+    kills_using_mine: int
+    kills_using_nuke: int
+    most_total_kills: int
+    blocks_using_proj: int
+    most_player_kills: int
+    kills_using_homing: int
+    kills_using_poison: int
+    kills_using_shield: int
+    longest_killstreak: int
+    blocks_using_shield: int
+    kills_using_grenade: int
+
+
+class UserProgress(TypedDict):
+    xp: int
+    level: int
+
+
+class UserMetadata(TypedDict):
+    friend_code: str
+    is_guest: bool
+
+    skin: str
+    badge: str
+    trail: str
+    parachute: str
+
+    last_coins: int
+    last_points: int
+    timed_bonus_last_collect: int
+    results_rewarded_video_last_collect: int
+
+    progress: UserProgress
+    awards_seen: int
+    goals: list[Goal]
+    stats: UserStats
+
+
+class UserResponse(TypedDict):
+    id: str
+    username: str
+    display_name: str
+    lang_tag: str
+    metadata: UserMetadata
+    online: bool
+    create_time: str
+    update_time: str
+    progress: ProgressResponse
+    goals: list[GoalResponse]
+
+
+class Wallet(TypedDict):
+    coins: int
+    gems: int
+
+
+class AccountResponse(APIResponse):
+    user: UserResponse
+    wallet: Wallet
+    email: str
+    devices: list[dict[str, str]]
+    custom_id: str | None  # Optional field, new in API
+
+    def __init__(
+        self: Self,
+        *,
+        user: UserResponse,
+        wallet: str,
+        email: str,
+        devices: list[dict[str, str]],
+        custom_id: str | None = None,
+    ) -> None:
+        # Safely load user["metadata"] and wallet JSON
+        if isinstance(user.get("metadata"), str):
+            user["metadata"] = loads(user["metadata"])
+        if isinstance(wallet, str):
+            wallet = loads(wallet)
+
+        super().__init__(
+            user=user,
+            wallet=wallet,
+            email=email,
+            devices=devices,
+            custom_id=custom_id,  # include new key
+        )
+
+
+class LootBoxResponses(APIResponse):
+    award_id: str
+    is_new: bool
+
+    def __init__(self: Self, *, award_id: str, is_new: bool) -> None:
+        super().__init__(award_id=award_id, is_new=is_new)

rbr_api_fork-0.7.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+