aioshad 1.0.0__tar.gz

aioshad-1.0.0/CHANGELOG.md

@@ -0,0 +1,15 @@
+# Changelog
+
+## 1.0.0
+
+- Async account/client core based on the provided Shad protocol implementation.
+- HTTP/2 transport with host failover, retry/backoff and local rate limiting.
+- Persistent sessions with optional AES-GCM encrypted storage and file permissions.
+- Message dispatcher with duplicate-update suppression and sync/async handler support.
+- Message, chat and user models with reply/edit/delete helpers.
+- File/photo upload helpers and voice-chat methods from the base protocol.
+- Profile manager for first name, last name and bio.
+- Presence time-name scheduler using account profile updates.
+- Auto-responder and managed background scheduler.
+- Extended filters and generic authenticated RPC access through `Client.invoke()`.
+- Examples and unit tests.

aioshad-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) aioshad contributors
+
+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.

aioshad-1.0.0/MANIFEST.in

@@ -0,0 +1,7 @@
+include README.md
+include LICENSE
+include CHANGELOG.md
+include requirements.txt
+recursive-include aioshad *.py py.typed
+recursive-include examples *.py
+recursive-include tests *.py

aioshad-1.0.0/PKG-INFO

@@ -0,0 +1,184 @@
+Metadata-Version: 2.4
+Name: aioshad
+Version: 1.0.0
+Summary: Advanced asynchronous Python client/userbot library for a Shad account
+Author: aioshad contributors
+License: MIT
+Keywords: shad,messenger,userbot,asyncio,python,account-client
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Framework :: AsyncIO
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: h2>=4.0.0
+Requires-Dist: cryptography>=42.0.0
+Requires-Dist: Pillow>=10.0.0
+Dynamic: license-file
+Dynamic: requires-python
+
+# aioshad 1.0.0
+
+کتابخانهٔ asynchronous برای ساخت **custom client / self account** روی شاد. این پروژه یک Bot API جداگانه نیست؛ session به حسابی تعلق دارد که با آن login شده است.
+
+> نکتهٔ compatibility: بخش transport و payloadهای شاد بر پایهٔ ساختار موجود در پروژهٔ `shadism` ارائه‌شده و APIهای مشاهده‌شدهٔ وب شاد ساخته شده‌اند. چون endpointها و payloadهای رسمی شاد عمومی و ثابت نیستند، قابلیت‌هایی که payload دقیق‌شان مستند نیستند به‌صورت `client.invoke()` در دسترس‌اند و حدس زده نشده‌اند.
+
+## نصب
+
+```bash
+pip install -e .
+```
+
+## ورود اکانت
+
+```python
+import asyncio
+from aioshad import Client
+
+app = Client("0937xxxxxxxx", session_directory="./sessions")
+
+async def main():
+    await app.start()
+
+asyncio.run(main())
+```
+
+در اجرای اول کد OTP از شما درخواست می‌شود و session ذخیره می‌شود.
+
+برای رمزنگاری session:
+
+```bash
+export AIOSHAD_SESSION_KEY="یک-راز-32-بایتی-یا-عبارت-قوی"
+```
+
+## پیام و handler
+
+```python
+from aioshad import Client, filters
+
+app = Client("0937xxxxxxxx", session_directory="./sessions")
+
+@app.on_message(filters.command("ping"))
+async def ping(message):
+    await message.reply("pong")
+
+@app.on_message(filters.private & filters.text)
+async def private_text(message):
+    print(message.text)
+
+asyncio.run(app.start())
+```
+
+handlerهای sync و async هر دو پشتیبانی می‌شوند.
+
+## امکانات حساب
+
+### تایم کنار نام
+
+این قابلیت واقعاً `updateProfile` را روی **همان حساب session** اجرا می‌کند:
+
+```python
+from aioshad import Client, TimeName
+
+app = Client("0937xxxxxxxx", session_directory="./sessions")
+
+async def main():
+    await app.connect()
+    await app.presence.start_time_name(
+        TimeName(
+            format="⏰ {time}",
+            timezone="Asia/Tehran",
+            interval=60,
+        )
+    )
+    await app.start_in_background()
+    await app.run_until_disconnected()
+
+asyncio.run(main())
+```
+
+Placeholders: `{time}`, `{time_12}`, `{date}`, `{day}`, `{timestamp}`.
+
+### پروفایل
+
+```python
+await app.profile.set_name("AioShad")
+await app.profile.set_last_name("Client")
+await app.profile.set_bio("Powered by aioshad")
+```
+
+### پاسخ خودکار حساب
+
+```python
+app.autoreply.add("سلام", "سلام، در خدمتم.")
+app.autoreply.set_default("پیامت دریافت شد.")
+await app.autoreply.enable()
+```
+
+### زمان‌بندی داخلی
+
+```python
+async def task():
+    await app.send_message("g0...", "پیام زمان‌بندی‌شده")
+
+app.scheduler.every(60, task)
+```
+
+حداقل فاصلهٔ scheduler پنج ثانیه است.
+
+## APIهای اصلی
+
+- `send_message`, `edit_message`, `delete_message(s)`
+- `reply`, `reply_photo`, `reply_file`
+- `upload_file`, `send_photo`, `send_file`
+- `get_me`, `get_user_info`
+- `get_chats`, `get_chat_info`, `get_chat_info_by_username`
+- `get_messages`, `get_chat_history`
+- `get_chats_updates`, `get_messages_updates`
+- login/session/device management
+- voice chat methods موجود در پروتکل پایه
+- `block_user` / `unblock_user`
+- فیلترهای command/regex/private/group/channel/reply/edited/author/chat/media/text
+- `&`, `|`, `~` برای ترکیب فیلترها
+- host failover
+- HTTP/2
+- retry/backoff
+- local rate limiting
+- duplicate-update suppression
+- encrypted session storage
+- graceful shutdown
+
+## RPC خام
+
+برای متدهای پروتکل که هنوز payload قطعی آن‌ها مشخص نیست:
+
+```python
+result = await app.invoke(
+    "METHOD_NAME",
+    some_parameter="value",
+)
+```
+
+این قسمت عمداً generic است تا بدون جعل payload جدید، آدرس هر API واقعی را بتوانید به کتابخانه اضافه کنید.
+
+## معماری
+
+```text
+Client
+├── Methods / RPC
+├── Transport (HTTP/2 + failover + rate limit)
+├── Session (optional AES-GCM storage)
+├── Dispatcher / Filters
+├── ProfileManager
+├── PresenceManager / TimeName
+├── AutoResponder
+└── Scheduler
+```
+
+## وضعیت تست
+
+قبل از release این پروژه تست‌های unit برای session encryption، filters، rate limiting و models دارد. تست زندهٔ شبکه به‌صورت پیش‌فرض اجرا نمی‌شود، چون نیازمند یک حساب شاد و endpointهای فعال است.

aioshad-1.0.0/README.md

@@ -0,0 +1,161 @@
+# aioshad 1.0.0
+
+کتابخانهٔ asynchronous برای ساخت **custom client / self account** روی شاد. این پروژه یک Bot API جداگانه نیست؛ session به حسابی تعلق دارد که با آن login شده است.
+
+> نکتهٔ compatibility: بخش transport و payloadهای شاد بر پایهٔ ساختار موجود در پروژهٔ `shadism` ارائه‌شده و APIهای مشاهده‌شدهٔ وب شاد ساخته شده‌اند. چون endpointها و payloadهای رسمی شاد عمومی و ثابت نیستند، قابلیت‌هایی که payload دقیق‌شان مستند نیستند به‌صورت `client.invoke()` در دسترس‌اند و حدس زده نشده‌اند.
+
+## نصب
+
+```bash
+pip install -e .
+```
+
+## ورود اکانت
+
+```python
+import asyncio
+from aioshad import Client
+
+app = Client("0937xxxxxxxx", session_directory="./sessions")
+
+async def main():
+    await app.start()
+
+asyncio.run(main())
+```
+
+در اجرای اول کد OTP از شما درخواست می‌شود و session ذخیره می‌شود.
+
+برای رمزنگاری session:
+
+```bash
+export AIOSHAD_SESSION_KEY="یک-راز-32-بایتی-یا-عبارت-قوی"
+```
+
+## پیام و handler
+
+```python
+from aioshad import Client, filters
+
+app = Client("0937xxxxxxxx", session_directory="./sessions")
+
+@app.on_message(filters.command("ping"))
+async def ping(message):
+    await message.reply("pong")
+
+@app.on_message(filters.private & filters.text)
+async def private_text(message):
+    print(message.text)
+
+asyncio.run(app.start())
+```
+
+handlerهای sync و async هر دو پشتیبانی می‌شوند.
+
+## امکانات حساب
+
+### تایم کنار نام
+
+این قابلیت واقعاً `updateProfile` را روی **همان حساب session** اجرا می‌کند:
+
+```python
+from aioshad import Client, TimeName
+
+app = Client("0937xxxxxxxx", session_directory="./sessions")
+
+async def main():
+    await app.connect()
+    await app.presence.start_time_name(
+        TimeName(
+            format="⏰ {time}",
+            timezone="Asia/Tehran",
+            interval=60,
+        )
+    )
+    await app.start_in_background()
+    await app.run_until_disconnected()
+
+asyncio.run(main())
+```
+
+Placeholders: `{time}`, `{time_12}`, `{date}`, `{day}`, `{timestamp}`.
+
+### پروفایل
+
+```python
+await app.profile.set_name("AioShad")
+await app.profile.set_last_name("Client")
+await app.profile.set_bio("Powered by aioshad")
+```
+
+### پاسخ خودکار حساب
+
+```python
+app.autoreply.add("سلام", "سلام، در خدمتم.")
+app.autoreply.set_default("پیامت دریافت شد.")
+await app.autoreply.enable()
+```
+
+### زمان‌بندی داخلی
+
+```python
+async def task():
+    await app.send_message("g0...", "پیام زمان‌بندی‌شده")
+
+app.scheduler.every(60, task)
+```
+
+حداقل فاصلهٔ scheduler پنج ثانیه است.
+
+## APIهای اصلی
+
+- `send_message`, `edit_message`, `delete_message(s)`
+- `reply`, `reply_photo`, `reply_file`
+- `upload_file`, `send_photo`, `send_file`
+- `get_me`, `get_user_info`
+- `get_chats`, `get_chat_info`, `get_chat_info_by_username`
+- `get_messages`, `get_chat_history`
+- `get_chats_updates`, `get_messages_updates`
+- login/session/device management
+- voice chat methods موجود در پروتکل پایه
+- `block_user` / `unblock_user`
+- فیلترهای command/regex/private/group/channel/reply/edited/author/chat/media/text
+- `&`, `|`, `~` برای ترکیب فیلترها
+- host failover
+- HTTP/2
+- retry/backoff
+- local rate limiting
+- duplicate-update suppression
+- encrypted session storage
+- graceful shutdown
+
+## RPC خام
+
+برای متدهای پروتکل که هنوز payload قطعی آن‌ها مشخص نیست:
+
+```python
+result = await app.invoke(
+    "METHOD_NAME",
+    some_parameter="value",
+)
+```
+
+این قسمت عمداً generic است تا بدون جعل payload جدید، آدرس هر API واقعی را بتوانید به کتابخانه اضافه کنید.
+
+## معماری
+
+```text
+Client
+├── Methods / RPC
+├── Transport (HTTP/2 + failover + rate limit)
+├── Session (optional AES-GCM storage)
+├── Dispatcher / Filters
+├── ProfileManager
+├── PresenceManager / TimeName
+├── AutoResponder
+└── Scheduler
+```
+
+## وضعیت تست
+
+قبل از release این پروژه تست‌های unit برای session encryption، filters، rate limiting و models دارد. تست زندهٔ شبکه به‌صورت پیش‌فرض اجرا نمی‌شود، چون نیازمند یک حساب شاد و endpointهای فعال است.

aioshad-1.0.0/aioshad/__init__.py

@@ -0,0 +1,25 @@
+from aioshad.client import Client
+from aioshad.config import ClientConfig
+from aioshad.errors import (
+    AioShadError,
+    AuthenticationError,
+    InvalidSessionError,
+    RPCError,
+    RateLimitError,
+    UnsupportedMethodError,
+)
+from aioshad.features import AutoResponder, PresenceManager, ProfileManager, Scheduler, TimeName
+from aioshad.types.chat import Chat
+from aioshad.types.message import Message
+from aioshad.types.user import User
+from aioshad import filters
+
+__all__ = [
+    "Client", "ClientConfig", "Message", "User", "Chat", "filters",
+    "TimeName", "ProfileManager", "PresenceManager", "AutoResponder", "Scheduler",
+    "AioShadError", "AuthenticationError", "InvalidSessionError", "RPCError",
+    "RateLimitError", "UnsupportedMethodError",
+]
+
+__version__ = "1.0.0"
+__author__ = "aioshad contributors"

aioshad-1.0.0/aioshad/client.py

@@ -0,0 +1,270 @@
+from __future__ import annotations
+
+import asyncio
+import inspect
+import logging
+import signal
+from pathlib import Path
+from typing import Any, Callable, Dict, List, Optional, Tuple, Union
+
+from aioshad.config import ClientConfig
+from aioshad.dispatcher import Dispatcher, MessageHandler
+from aioshad.features import AutoResponder, PresenceManager, ProfileManager, Scheduler
+from aioshad.filters import Filter, ensure_filter
+from aioshad.methods import Methods
+from aioshad.network import Transport
+from aioshad.session import Session, SessionStorage
+from aioshad.types.chat import Chat
+from aioshad.types.message import Message
+from aioshad.types.user import User
+
+logger = logging.getLogger("aioshad.client")
+
+
+class Client:
+    """Async client for a Shad account (custom client/userbot).
+
+    The client operates with the authenticated account session; it is not a
+    separate bot identity. High-level account features live in ``profile``,
+    ``presence`` and ``autoreply``.
+    """
+
+    def __init__(
+        self,
+        phone_number: str,
+        session_directory: str = ".",
+        messenger_host: Optional[str] = None,
+        *,
+        config: Optional[ClientConfig] = None,
+        session_encryption_key: Optional[str] = None,
+    ) -> None:
+        self.phone_number = phone_number
+        self.config = config or ClientConfig(messenger_host=messenger_host)
+        self._storage = SessionStorage(
+            phone_number,
+            directory=session_directory,
+            encryption_key=session_encryption_key,
+        )
+        self.session: Session = self._storage.load(phone_number)
+        if messenger_host:
+            self.session.messenger_host = messenger_host
+        elif self.config.messenger_host:
+            self.session.messenger_host = self.config.messenger_host
+
+        self._pending_handlers: List[Tuple[MessageHandler, Optional[Filter]]] = []
+        self._transport: Optional[Transport] = None
+        self._methods: Optional[Methods] = None
+        self._dispatcher: Optional[Dispatcher] = None
+        self._started = False
+
+        self.profile = ProfileManager(self)
+        self.presence = PresenceManager(self)
+        self.autoreply = AutoResponder(self)
+        self.scheduler = Scheduler()
+
+    @property
+    def transport(self) -> Transport:
+        if self._transport is None:
+            raise RuntimeError("Client is not connected. Call await client.connect() first.")
+        return self._transport
+
+    @property
+    def methods(self) -> Methods:
+        if self._methods is None:
+            raise RuntimeError("Client is not connected. Call await client.connect() first.")
+        return self._methods
+
+    @property
+    def is_connected(self) -> bool:
+        return self._transport is not None and not self._transport.is_closed
+
+    def _bootstrap(self) -> None:
+        self._transport = Transport(self.session, self.config)
+        self._methods = Methods(self.session, self._transport, self._storage, client=self)
+        self._dispatcher = Dispatcher(
+            self,
+            poll_interval=self.config.poll_interval,
+            max_errors=self.config.max_consecutive_errors,
+        )
+        for handler, filter_obj in self._pending_handlers:
+            self._dispatcher.register_handler(handler, filter_obj=filter_obj)
+        self._pending_handlers.clear()
+
+    async def connect(self) -> "Client":
+        if self._transport is None:
+            self._bootstrap()
+        methods = self.methods
+        if not self.session.has_auth():
+            logger.info("No active session found; starting account login flow.")
+            await methods.login_flow(self.phone_number)
+        else:
+            try:
+                await methods.register_device()
+            except Exception as exc:
+                if "INVALID_AUTH" in str(exc):
+                    logger.warning("Stored session is invalid; starting login flow.")
+                    self._clear_auth()
+                    await methods.login_flow(self.phone_number)
+                else:
+                    logger.debug("Device registration check: %s", exc)
+        return self
+
+    def _clear_auth(self) -> None:
+        self.session.auth = ""
+        self.session.decode_auth = ""
+        self.session.private_key_pem = ""
+        self.session.key_hex = ""
+        self.session.iv_hex = ""
+        self.session.tmp_session = ""
+        self._storage.save(self.session)
+
+    async def start(self) -> None:
+        await self.connect()
+        if self._dispatcher is not None:
+            self._dispatcher.start()
+        self._started = True
+        await self._idle()
+
+    async def start_in_background(self) -> None:
+        await self.connect()
+        if self._dispatcher is not None:
+            self._dispatcher.start()
+        self._started = True
+
+    async def run_until_disconnected(self) -> None:
+        await self.start()
+
+    async def _idle(self) -> None:
+        while self._dispatcher is not None and self._dispatcher._running:
+            await asyncio.sleep(1.0)
+
+    async def stop(self) -> None:
+        await self.presence.close()
+        await self.scheduler.cancel_all()
+        if self._dispatcher:
+            await self._dispatcher.stop()
+        if self._transport:
+            await self._transport.close()
+        self._storage.save(self.session)
+        self._started = False
+
+    def on_message(
+        self,
+        filters_or_func: Optional[Union[Filter, Callable[..., Any], MessageHandler]] = None,
+    ) -> Any:
+        if inspect.iscoroutinefunction(filters_or_func) or (
+            callable(filters_or_func) and not isinstance(filters_or_func, Filter)
+            and not isinstance(filters_or_func, (str, bytes))
+            and len(inspect.signature(filters_or_func).parameters) == 1
+        ):
+            func = filters_or_func
+            self._register_message_handler(func, filter_obj=None)
+            return func
+
+        filter_obj: Optional[Filter] = None
+        if filters_or_func is not None:
+            filter_obj = ensure_filter(filters_or_func)
+
+        def decorator(func: MessageHandler) -> MessageHandler:
+            self._register_message_handler(func, filter_obj=filter_obj)
+            return func
+
+        return decorator
+
+    def _register_message_handler(self, func: MessageHandler, filter_obj: Optional[Filter] = None) -> None:
+        if self._dispatcher is not None:
+            self._dispatcher.register_handler(func, filter_obj=filter_obj)
+        else:
+            self._pending_handlers.append((func, filter_obj))
+
+    def remove_handler(self, handler: MessageHandler) -> int:
+        if self._dispatcher is None:
+            before = len(self._pending_handlers)
+            self._pending_handlers = [item for item in self._pending_handlers if item[0] is not handler]
+            return before - len(self._pending_handlers)
+        return self._dispatcher.unregister_handler(handler)
+
+    async def send_message(self, object_guid: str, text: str = "", reply_to_message_id: Optional[str] = None, file_inline: Optional[Dict[str, Any]] = None) -> Message:
+        return await self.methods.send_message(object_guid, text, reply_to_message_id, file_inline)
+
+    async def edit_message(self, object_guid: str, message_id: str, text: str) -> Message:
+        return await self.methods.edit_message(object_guid, message_id, text)
+
+    async def delete_messages(self, object_guid: str, message_ids: Union[str, int, List[Union[str, int]]], delete_type: str = "Global") -> Dict[str, Any]:
+        return await self.methods.delete_messages(object_guid, message_ids, delete_type)
+
+    async def delete_message(self, object_guid: str, message_id: Union[str, int], delete_type: str = "Global") -> Dict[str, Any]:
+        return await self.methods.delete_message(object_guid, message_id, delete_type)
+
+    async def upload_file(self, file: Union[str, bytes, Path], file_name: Optional[str] = None, mime: Optional[str] = None, chunk_size: Optional[int] = None) -> Dict[str, Any]:
+        return await self.methods.upload_file(file, file_name, mime, chunk_size or self.config.upload_chunk_size)
+
+    async def send_photo(self, object_guid: str, photo: Union[str, bytes, Path], caption: Optional[str] = None, reply_to_message_id: Optional[str] = None, file_name: Optional[str] = None) -> Message:
+        return await self.methods.send_photo(object_guid, photo, caption, reply_to_message_id, file_name)
+
+    async def send_file(self, object_guid: str, file: Union[str, bytes, Path], file_name: Optional[str] = None, mime: Optional[str] = None, caption: Optional[str] = None, reply_to_message_id: Optional[str] = None) -> Message:
+        return await self.methods.send_file(object_guid, file, file_name, mime, caption, reply_to_message_id)
+
+    async def get_user_info(self, user_guid: Optional[str] = None) -> User:
+        return await self.methods.get_user_info(user_guid)
+
+    async def get_me(self) -> User:
+        return await self.get_user_info()
+
+    async def update_profile(self, first_name: Optional[str] = None, last_name: Optional[str] = None, bio: Optional[str] = None) -> bool:
+        return await self.methods.update_profile(first_name, last_name, bio)
+
+    async def get_chats(self, start_id: Optional[str] = None) -> Dict[str, Any]:
+        return await self.methods.get_chats(start_id)
+
+    async def get_messages(self, object_guid: str, limit: int = 50, sort: str = "FromMax", max_id: Optional[str] = None, min_id: Optional[str] = None) -> Dict[str, Any]:
+        return await self.methods.get_messages(object_guid, limit, sort, max_id, min_id)
+
+    async def get_chats_updates(self, state: Optional[int] = None) -> Dict[str, Any]:
+        return await self.methods.get_chats_updates(state)
+
+    async def get_messages_updates(self, object_guid: str, state: Optional[int] = None) -> Dict[str, Any]:
+        return await self.methods.get_messages_updates(object_guid, state)
+
+    async def get_chat_history(self, object_guid: Optional[str] = None, limit: int = 50, max_id: Optional[str] = None, min_id: Optional[str] = None, sort: str = "FromMax", guid: Optional[str] = None, state: Optional[int] = None) -> List[Message]:
+        return await self.methods.get_chat_history(object_guid, limit, max_id, min_id, sort, guid, state)
+
+    async def register_device(self) -> Dict[str, Any]:
+        return await self.methods.register_device()
+
+    async def get_chat_info(self, object_guid: str) -> Chat:
+        return await self.methods.get_chat_info(object_guid)
+
+    async def get_chat_info_by_username(self, username: str) -> Chat:
+        return await self.methods.get_chat_info_by_username(username)
+
+    async def join_voice_chat(self, chat_guid: str, voice_chat_id: Optional[str] = None, sdp_offer_data: str = "") -> Dict[str, Any]:
+        return await self.methods.join_voice_chat(chat_guid, voice_chat_id, sdp_offer_data)
+
+    async def leave_voice_chat(self, chat_guid: str, voice_chat_id: Optional[str] = None) -> Dict[str, Any]:
+        return await self.methods.leave_voice_chat(chat_guid, voice_chat_id)
+
+    async def get_voice_chat_participants(self, chat_guid: str, voice_chat_id: Optional[str] = None) -> Dict[str, Any]:
+        return await self.methods.get_voice_chat_participants(chat_guid, voice_chat_id)
+
+    async def create_voice_chat(self, chat_guid: str) -> Dict[str, Any]:
+        return await self.methods.create_voice_chat(chat_guid)
+
+    async def discard_voice_chat(self, chat_guid: str, voice_chat_id: Optional[str] = None) -> Dict[str, Any]:
+        return await self.methods.discard_voice_chat(chat_guid, voice_chat_id)
+
+    async def set_voice_chat_state(self, chat_guid: str, voice_chat_id: str, activity: str = "Speaking", participant_object_guid: Optional[str] = None) -> Dict[str, Any]:
+        return await self.methods.set_voice_chat_state(chat_guid, voice_chat_id, activity, participant_object_guid)
+
+    async def invoke(self, method: str, **input_data: Any) -> Dict[str, Any]:
+        """Call an authenticated Shad RPC method not yet wrapped by a helper."""
+        return await self.transport.send_authenticated(method, input_data)
+
+    async def block_user(self, user_guid: str) -> Dict[str, Any]:
+        return await self.invoke("setBlockUser", action="Block", user_guid=user_guid)
+
+    async def unblock_user(self, user_guid: str) -> Dict[str, Any]:
+        return await self.invoke("setBlockUser", action="Unblock", user_guid=user_guid)
+
+    def set_messenger_host(self, host: str) -> None:
+        self.session.messenger_host = host