feat: add user endpoints

pyproject.toml

@@ -4,14 +4,14 @@ version = "0.1.0"
 description = "Admin service for legal entities and B2B operations"
 requires-python = "==3.12.*"
 dependencies = [
-    "acryl-datahub>=1.5.0.19",
-    "acryl-sqlglot>=25.25.2.dev9",
-    "aiobotocore>=2.21.0",
+    "acryl-datahub==1.5.0.19",
+    "acryl-sqlglot==25.25.2.dev9",
+    "aiobotocore==2.21.0",
     "apscheduler==3.11.2",
     "asyncpg==0.31.0",
     "bcrypt==5.0.0",
-    "bip-utils>=2.9.3",
-    "cryptography>=44.0.0",
+    "bip-utils==2.9.3",
+    "cryptography==44.0.0",
     "dotenv==0.9.9",
     "fastapi==0.128.7",
     "granian==2.6.1",
@@ -19,7 +19,7 @@ dependencies = [
     "orjson==3.11.7",
     "pydantic-settings==2.12.0",
     "python-jose==3.5.0",
-    "python-multipart>=0.0.20",
+    "python-multipart==0.0.20",
     "python-ulid==3.1.0",
     "redis==7.2.0",
     "sqlalchemy==2.0.46",

src/application/abstractions/i_unit_of_work.py

@@ -6,10 +6,10 @@ from src.application.abstractions.repositories import (
     IAdminSessionRepository,
     IAdminUserRepository,
     ILegalEntityRepository,
-    IOrganizationDocumentRepository,
     IOrganizationWalletRepository,
     IPurchaseRequestRepository,
     IUserRepository,
+    IWalletRepository,
 )
 
 
@@ -37,7 +37,7 @@ class IUnitOfWork(Protocol):
     def organization_wallet_repository(self) -> IOrganizationWalletRepository: ...
 
     @property
-    def organization_document_repository(self) -> IOrganizationDocumentRepository: ...
+    def purchase_request_repository(self) -> IPurchaseRequestRepository: ...
 
     @property
-    def purchase_request_repository(self) -> IPurchaseRequestRepository: ...
+    def wallet_repository(self) -> IWalletRepository: ...

src/application/abstractions/repositories/__init__.py

@@ -3,5 +3,5 @@ from src.application.abstractions.repositories.i_admin_user_repository import IA
 from src.application.abstractions.repositories.i_admin_session_repository import IAdminSessionRepository
 from src.application.abstractions.repositories.i_legal_entity_repository import ILegalEntityRepository
 from src.application.abstractions.repositories.i_organization_wallet_repository import IOrganizationWalletRepository
-from src.application.abstractions.repositories.i_organization_document_repository import IOrganizationDocumentRepository
 from src.application.abstractions.repositories.i_purchase_request_repository import IPurchaseRequestRepository
+from src.application.abstractions.repositories.i_wallets_repository import IWalletRepository

src/application/abstractions/repositories/i_legal_entity_repository.py

@@ -32,7 +32,7 @@ class ILegalEntityRepository(ABC):
         raise NotImplementedError
 
     @abstractmethod
-    async def list_all(self, *, limit: int, offset: int) -> list[LegalEntityEntity]:
+    async def list_all(self, *, limit: int, offset: int, search: str | None = None) -> list[LegalEntityEntity]:
         raise NotImplementedError
 
     @abstractmethod
@@ -49,5 +49,13 @@ class ILegalEntityRepository(ABC):
         raise NotImplementedError
 
     @abstractmethod
-    async def count_all(self) -> int:
+    async def get_document_s3_key(self, organization_id: str, document_type: str) -> str | None:
+        raise NotImplementedError
+
+    @abstractmethod
+    async def set_document_s3_key(self, organization_id: str, document_type: str, s3_key: str) -> LegalEntityEntity:
+        raise NotImplementedError
+
+    @abstractmethod
+    async def count_all(self, *, search: str | None = None) -> int:
         raise NotImplementedError

src/application/abstractions/repositories/i_organization_document_repository.py

@@ -1,17 +0,0 @@
-from abc import ABC, abstractmethod
-
-from src.application.domain.entities.organization import OrganizationDocumentEntity
-
-
-class IOrganizationDocumentRepository(ABC):
-    @abstractmethod
-    async def create(self, document: OrganizationDocumentEntity) -> OrganizationDocumentEntity:
-        raise NotImplementedError
-
-    @abstractmethod
-    async def get_by_id(self, document_id: str) -> OrganizationDocumentEntity:
-        raise NotImplementedError
-
-    @abstractmethod
-    async def list_by_organization(self, organization_id: str) -> list[OrganizationDocumentEntity]:
-        raise NotImplementedError

src/application/abstractions/repositories/i_purchase_request_repository.py

@@ -5,6 +5,10 @@ from src.application.domain.entities.organization import PurchaseRequestEntity
 
 
 class IPurchaseRequestRepository(ABC):
+    @abstractmethod
+    async def create(self, values: dict[str, Any]) -> PurchaseRequestEntity:
+        raise NotImplementedError
+
     @abstractmethod
     async def get_by_id(self, request_id: str) -> PurchaseRequestEntity:
         raise NotImplementedError

src/application/abstractions/repositories/i_user_repository.py

@@ -18,6 +18,14 @@ class IUserRepository(ABC):
         kyc_verified_at: datetime,
     ) -> UserEntity:
         raise NotImplementedError
+    
+    @abstractmethod
+    async def list_all(self, *, limit: int, offset: int, search: str | None = None) -> list[UserEntity]:
+        raise NotImplementedError
+    
+    @abstractmethod
+    async def get_by_id(self, user_id: str) -> UserEntity:
+        raise NotImplementedError
 
     @abstractmethod
     async def get_user_by_email(self, email: str) -> UserEntity:
@@ -26,19 +34,19 @@ class IUserRepository(ABC):
     @abstractmethod
     async def exists_by_email(self, email: str) -> bool:
         raise NotImplementedError
-    
+
     @abstractmethod
     async def search_individuals(self, *, query: str, limit: int, offset: int) -> list[PartySearchEntity]:
         raise NotImplementedError
-    
+
     @abstractmethod
     async def count_individuals(self, *, query: str) -> int:
         raise NotImplementedError
-    
-    @abstractmethod
-    async def get_password_hash(self, user_id: str) -> str:
-        raise NotImplementedError
 
+    @abstractmethod
+    async def count_all(self, *, search: str) -> int:
+        raise NotImplementedError
+    
     @abstractmethod
     async def set_password(self, user_id: str, password_hash: str) -> UserEntity:
         raise NotImplementedError

src/application/abstractions/repositories/i_wallets_repository.py

@@ -0,0 +1,14 @@
+from abc import ABC, abstractmethod
+
+from src.application.domain.entities.user import WalletEntity
+
+
+class IWalletRepository(ABC):
+
+    @abstractmethod
+    async def list_by_user(self, user_id: str) -> list[WalletEntity]:
+        raise NotImplementedError
+
+    @abstractmethod
+    async def exists_for_user(self, user_id: str) -> bool:
+        raise NotImplementedError

src/application/commands/__init__.py

@@ -1,8 +1,11 @@
+from src.application.commands.admin_login import AdminLoginCommand
+from src.application.commands.admin_logout import AdminLogoutCommand
 from src.application.commands.admin_jwt_refresh import AdminJwtRefreshCommand
 from src.application.commands.get_admin_me import GetAdminMeCommand
 from src.application.commands.create_organization import CreateOrganizationCommand
 from src.application.commands.create_organization_wallets import CreateOrganizationWalletsCommand
 from src.application.commands.put_organization_document import PutOrganizationDocumentCommand
+from src.application.commands.set_password import SetPasswordCommand
 from src.application.commands.organization_commands import (
     ListOrganizationsCommand,
     GetOrganizationCommand,
@@ -19,12 +22,22 @@ from src.application.commands.organization_wallet_commands import (
     ListOrganizationWalletsCommand,
 )
 from src.application.commands.purchase_request_commands import (
+    CreatePurchaseRequestCommand,
     ListPurchaseRequestsCommand,
     GetPurchaseRequestCommand,
     UpdatePurchaseRequestCommand,
     UpdatePurchaseRequestStatusCommand,
     SetPurchaseRequestQuoteCommand,
 )
+from src.application.commands.user_commands import (
+    ListUsersCommand,
+    GetUserCommand,
+)
+from src.application.commands.user_wallet_commands import (
+    GetUserMnemonicCommand,
+    GetUserSecretKeysCommand,
+    ListUserWalletsCommand,
+)
 
 __all__ = [
     'AdminLoginCommand',
@@ -38,6 +51,7 @@ __all__ = [
     'GetOrganizationCommand',
     'SearchPartiesCommand',
     'UpdateOrganizationCommand',
+    'CreatePurchaseRequestCommand',
     'ListPurchaseRequestsCommand',
     'GetPurchaseRequestCommand',
     'UpdatePurchaseRequestCommand',
@@ -48,4 +62,10 @@ __all__ = [
     'ListOrganizationWalletsCommand',
     'GetOrganizationMnemonicCommand',
     'GetOrganizationSecretKeysCommand',
-]
+    'SetPasswordCommand',
+    'ListUsersCommand',
+    'GetUserCommand',
+    'ListUserWalletsCommand',
+    'GetUserMnemonicCommand',
+    'GetUserSecretKeysCommand',
+]

src/application/commands/create_organization_wallets.py

@@ -4,7 +4,10 @@ from ulid import ULID
 
 from src.application.abstractions import IUnitOfWork
 from src.application.contracts import ILogger
-from src.application.domain.entities.organization import OrganizationWalletEntity
+from src.application.domain.entities.organization import (
+    CreateOrganizationWalletsResult,
+    OrganizationWalletEntity,
+)
 from src.application.domain.exceptions import ApplicationException
 from src.infrastructure.crypto.wallet_crypto import (
     ALL_CHAINS,
@@ -22,7 +25,7 @@ class CreateOrganizationWalletsCommand:
         self._logger = logger
 
     @transactional
-    async def __call__(self, *, organization_id: str) -> list[OrganizationWalletEntity]:
+    async def __call__(self, *, organization_id: str) -> CreateOrganizationWalletsResult:
         if not is_crypto_ready():
             raise ApplicationException(status_code=503, message='Crypto service not ready')
 
@@ -35,6 +38,7 @@ class CreateOrganizationWalletsCommand:
 
         mnemonic = generate_mnemonic()
         derived = derive_all_addresses(mnemonic)
+        plaintext_mnemonic = mnemonic
         blob = encrypt_mnemonic(mnemonic)
         mnemonic = ''
 
@@ -53,4 +57,4 @@ class CreateOrganizationWalletsCommand:
         ]
         saved = await self._unit_of_work.organization_wallet_repository.create_many(wallets)
         self._logger.info(f'Wallets created for organization_id={organization_id} chains={len(saved)}')
-        return saved
+        return CreateOrganizationWalletsResult(wallets=saved, mnemonic=plaintext_mnemonic)

src/application/commands/organization_commands.py

@@ -4,7 +4,8 @@ from typing import Any
 
 from src.application.abstractions import IUnitOfWork
 from src.application.contracts import ILogger
-from src.application.domain.entities.organization import LegalEntityEntity
+from src.application.domain.entities.organization import LegalEntityEntity, PartySearchEntity
+from src.application.domain.enums.account_type import AccountType
 from src.infrastructure.database.decorators import transactional
 
 
@@ -14,12 +15,65 @@ class ListOrganizationsCommand:
         self._logger = logger
 
     @transactional
-    async def __call__(self, *, limit: int = 50, offset: int = 0) -> tuple[list[LegalEntityEntity], int]:
-        items = await self._unit_of_work.legal_entity_repository.list_all(limit=limit, offset=offset)
-        total = await self._unit_of_work.legal_entity_repository.count_all()
+    async def __call__(
+        self,
+        *,
+        limit: int = 50,
+        offset: int = 0,
+        search: str | None = None,
+    ) -> tuple[list[LegalEntityEntity], int]:
+        items = await self._unit_of_work.legal_entity_repository.list_all(
+            limit=limit,
+            offset=offset,
+            search=search,
+        )
+        total = await self._unit_of_work.legal_entity_repository.count_all(search=search)
         return items, total
 
 
+class SearchPartiesCommand:
+    def __init__(self, unit_of_work: IUnitOfWork, logger: ILogger):
+        self._unit_of_work = unit_of_work
+        self._logger = logger
+
+    @transactional
+    async def __call__(self, *, query: str, limit: int = 50, offset: int = 0) -> tuple[list[PartySearchEntity], int]:
+        query = query.strip()
+        if not query:
+            return [], 0
+
+        fetch_limit = limit + offset
+        legal_items = await self._unit_of_work.legal_entity_repository.list_all(
+            limit=fetch_limit,
+            offset=0,
+            search=query,
+        )
+        individual_items = await self._unit_of_work.user_repository.search_individuals(
+            query=query,
+            limit=fetch_limit,
+            offset=0,
+        )
+        legal_total = await self._unit_of_work.legal_entity_repository.count_all(search=query)
+        individual_total = await self._unit_of_work.user_repository.count_individuals(query=query)
+        items = [self._legal_to_search_entity(item) for item in legal_items] + individual_items
+        items.sort(key=lambda item: item.created_at.timestamp() if item.created_at else 0, reverse=True)
+        return items[offset:offset + limit], legal_total + individual_total
+
+    def _legal_to_search_entity(self, item: LegalEntityEntity) -> PartySearchEntity:
+        return PartySearchEntity(
+            id=item.id,
+            account_type=AccountType.LEGAL_ENTITY,
+            user_id=item.user_id,
+            email=None,
+            name=item.name,
+            inn=item.inn,
+            phone=item.contact_phone,
+            status=item.status,
+            kyc_verified=item.kyc_verified,
+            created_at=item.created_at,
+        )
+
+
 class GetOrganizationCommand:
     def __init__(self, unit_of_work: IUnitOfWork, logger: ILogger):
         self._unit_of_work = unit_of_work

src/application/commands/organization_document_commands.py

@@ -2,9 +2,11 @@ from __future__ import annotations
 
 from src.application.abstractions import IUnitOfWork
 from src.application.contracts import ILogger
-from src.application.domain.entities.organization import OrganizationDocumentEntity
+from src.application.domain.entities.organization import OrganizationDocumentSlot
 from src.application.domain.exceptions import ApplicationException
+from src.application.domain.organization_documents import ORGANIZATION_DOCUMENT_TYPES
 from src.infrastructure.database.decorators import transactional
+from src.infrastructure.storage.s3_documents_service import S3DocumentsService
 
 
 class ListOrganizationDocumentsCommand:
@@ -13,9 +15,20 @@ class ListOrganizationDocumentsCommand:
         self._logger = logger
 
     @transactional
-    async def __call__(self, organization_id: str) -> list[OrganizationDocumentEntity]:
-        await self._unit_of_work.legal_entity_repository.get_by_id(organization_id)
-        return await self._unit_of_work.organization_document_repository.list_by_organization(organization_id)
+    async def __call__(self, organization_id: str) -> list[OrganizationDocumentSlot]:
+        org = await self._unit_of_work.legal_entity_repository.get_by_id(organization_id)
+        slots: list[OrganizationDocumentSlot] = []
+        for document_type in ORGANIZATION_DOCUMENT_TYPES:
+            s3_key = org.document_s3_keys.get(document_type)
+            slots.append(
+                OrganizationDocumentSlot(
+                    organization_id=organization_id,
+                    document_type=document_type,
+                    s3_key=s3_key,
+                    file_name=S3DocumentsService.file_name_from_key(s3_key) if s3_key else None,
+                )
+            )
+        return slots
 
 
 class GetOrganizationDocumentCommand:
@@ -24,8 +37,18 @@ class GetOrganizationDocumentCommand:
         self._logger = logger
 
     @transactional
-    async def __call__(self, organization_id: str, document_id: str) -> OrganizationDocumentEntity:
-        doc = await self._unit_of_work.organization_document_repository.get_by_id(document_id)
-        if doc.organization_id != organization_id:
-            raise ApplicationException(status_code=404, message='Document not found')
-        return doc
+    async def __call__(self, organization_id: str, document_type: str) -> OrganizationDocumentSlot:
+        if document_type not in ORGANIZATION_DOCUMENT_TYPES:
+            raise ApplicationException(status_code=400, message='Invalid document type')
+
+        org = await self._unit_of_work.legal_entity_repository.get_by_id(organization_id)
+        s3_key = org.document_s3_keys.get(document_type)
+        if not s3_key:
+            raise ApplicationException(status_code=404, message='Document not uploaded')
+
+        return OrganizationDocumentSlot(
+            organization_id=organization_id,
+            document_type=document_type,
+            s3_key=s3_key,
+            file_name=S3DocumentsService.file_name_from_key(s3_key),
+        )

src/application/commands/organization_wallet_commands.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+from src.application.abstractions import IUnitOfWork
+from src.application.contracts import ILogger
+from src.application.domain.entities.organization import LegalEntityEntity, OrganizationWalletEntity
+from src.application.domain.exceptions import ApplicationException
+from src.infrastructure.crypto.wallet_crypto import (
+    DerivedSecretKey,
+    decrypt_mnemonic,
+    derive_all_private_keys,
+    is_crypto_ready,
+)
+from src.infrastructure.database.decorators import transactional
+
+
+class ListOrganizationWalletsCommand:
+    def __init__(self, unit_of_work: IUnitOfWork, logger: ILogger):
+        self._unit_of_work = unit_of_work
+        self._logger = logger
+
+    @transactional
+    async def __call__(self, organization_id: str) -> list[OrganizationWalletEntity]:
+        await self._unit_of_work.legal_entity_repository.get_by_id(organization_id)
+        return await self._unit_of_work.organization_wallet_repository.list_by_organization(organization_id)
+
+
+class GetOrganizationMnemonicCommand:
+    def __init__(self, unit_of_work: IUnitOfWork, logger: ILogger):
+        self._unit_of_work = unit_of_work
+        self._logger = logger
+
+    @transactional
+    async def __call__(self, organization_id: str) -> str:
+        org = await self._require_wallets_org(organization_id)
+        if not is_crypto_ready():
+            raise ApplicationException(status_code=503, message='Crypto service not ready')
+        return decrypt_mnemonic(org.encrypted_mnemonic or '')
+
+    async def _require_wallets_org(self, organization_id: str) -> LegalEntityEntity:
+        org = await self._unit_of_work.legal_entity_repository.get_by_id(organization_id)
+        if not org.encrypted_mnemonic:
+            raise ApplicationException(status_code=404, message='Wallets not created for organization')
+        return org
+
+
+class GetOrganizationSecretKeysCommand:
+    def __init__(self, unit_of_work: IUnitOfWork, logger: ILogger):
+        self._unit_of_work = unit_of_work
+        self._logger = logger
+
+    @transactional
+    async def __call__(self, organization_id: str) -> list[DerivedSecretKey]:
+        org = await self._require_wallets_org(organization_id)
+        if not is_crypto_ready():
+            raise ApplicationException(status_code=503, message='Crypto service not ready')
+        mnemonic = decrypt_mnemonic(org.encrypted_mnemonic or '')
+        return derive_all_private_keys(mnemonic)
+
+    async def _require_wallets_org(self, organization_id: str) -> LegalEntityEntity:
+        org = await self._unit_of_work.legal_entity_repository.get_by_id(organization_id)
+        if not org.encrypted_mnemonic:
+            raise ApplicationException(status_code=404, message='Wallets not created for organization')
+        return org

src/application/commands/purchase_request_commands.py

@@ -54,6 +54,54 @@ class GetPurchaseRequestCommand:
         return await self._unit_of_work.purchase_request_repository.get_by_id(request_id)
 
 
+class CreatePurchaseRequestCommand:
+    def __init__(self, unit_of_work: IUnitOfWork, logger: ILogger):
+        self._unit_of_work = unit_of_work
+        self._logger = logger
+
+    @transactional
+    async def __call__(
+        self,
+        *,
+        organization_id: str,
+        usdt_amount: Decimal,
+        status: str = 'submitted',
+        rub_amount: Decimal | None = None,
+        exchange_rate: Decimal | None = None,
+        service_fee_percent: Decimal | None = None,
+        comment: str | None = None,
+        admin_comment: str | None = None,
+        target_wallet_chain: str | None = 'ETH',
+        target_wallet_address: str | None = None,
+        tx_hash: str | None = None,
+        assigned_to: str | None = None,
+    ) -> PurchaseRequestEntity:
+        if status not in VALID_STATUSES:
+            raise ApplicationException(status_code=400, message='Invalid status')
+
+        await self._unit_of_work.legal_entity_repository.get_by_id(organization_id)
+        values: dict[str, Any] = {
+            'organization_id': organization_id,
+            'status': status,
+            'usdt_amount': usdt_amount,
+            'rub_amount': rub_amount,
+            'exchange_rate': exchange_rate,
+            'service_fee_percent': service_fee_percent,
+            'comment': comment,
+            'admin_comment': admin_comment,
+            'target_wallet_chain': target_wallet_chain,
+            'target_wallet_address': target_wallet_address,
+            'tx_hash': tx_hash,
+            'assigned_to': assigned_to,
+        }
+        if status == 'completed':
+            values['completed_at'] = datetime.now(timezone.utc)
+
+        created = await self._unit_of_work.purchase_request_repository.create(values)
+        self._logger.info(f'Purchase request created id={created.id} org={organization_id}')
+        return created
+
+
 class UpdatePurchaseRequestStatusCommand:
     def __init__(self, unit_of_work: IUnitOfWork, logger: ILogger):
         self._unit_of_work = unit_of_work
@@ -81,10 +129,46 @@ class UpdatePurchaseRequestStatusCommand:
             values['tx_hash'] = tx_hash
         if status == 'completed':
             values['completed_at'] = datetime.now(timezone.utc)
+        else:
+            values['completed_at'] = None
 
         return await self._unit_of_work.purchase_request_repository.update(request_id, values=values)
 
 
+class UpdatePurchaseRequestCommand:
+    ALLOWED_FIELDS = frozenset({
+        'status',
+        'usdt_amount',
+        'rub_amount',
+        'exchange_rate',
+        'service_fee_percent',
+        'comment',
+        'admin_comment',
+        'target_wallet_chain',
+        'target_wallet_address',
+        'tx_hash',
+        'assigned_to',
+    })
+
+    def __init__(self, unit_of_work: IUnitOfWork, logger: ILogger):
+        self._unit_of_work = unit_of_work
+        self._logger = logger
+
+    @transactional
+    async def __call__(self, request_id: str, *, values: dict[str, Any]) -> PurchaseRequestEntity:
+        filtered = {k: v for k, v in values.items() if k in self.ALLOWED_FIELDS}
+        status = filtered.get('status')
+        if status is not None:
+            if status not in VALID_STATUSES:
+                raise ApplicationException(status_code=400, message='Invalid status')
+            if status == 'completed':
+                filtered['completed_at'] = datetime.now(timezone.utc)
+            else:
+                filtered['completed_at'] = None
+
+        return await self._unit_of_work.purchase_request_repository.update(request_id, values=filtered)
+
+
 class SetPurchaseRequestQuoteCommand:
     def __init__(self, unit_of_work: IUnitOfWork, logger: ILogger):
         self._unit_of_work = unit_of_work

src/application/commands/put_organization_document.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+from src.application.abstractions import IUnitOfWork
+from src.application.contracts import ILogger
+from src.application.domain.entities.organization import OrganizationDocumentSlot
+from src.application.domain.exceptions import ApplicationException
+from src.application.domain.organization_documents import ORGANIZATION_DOCUMENT_TYPES
+from src.infrastructure.database.decorators import transactional
+from src.infrastructure.storage.s3_documents_service import S3DocumentsService
+
+
+class PutOrganizationDocumentCommand:
+    def __init__(
+        self,
+        unit_of_work: IUnitOfWork,
+        s3_service: S3DocumentsService,
+        logger: ILogger,
+    ):
+        self._unit_of_work = unit_of_work
+        self._s3 = s3_service
+        self._logger = logger
+
+    @transactional
+    async def __call__(
+        self,
+        *,
+        organization_id: str,
+        document_type: str,
+        file_name: str,
+        content_type: str,
+        body: bytes,
+    ) -> OrganizationDocumentSlot:
+        if document_type not in ORGANIZATION_DOCUMENT_TYPES:
+            raise ApplicationException(status_code=400, message='Invalid document type')
+
+        if not body:
+            raise ApplicationException(status_code=400, message='File is empty')
+
+        await self._unit_of_work.legal_entity_repository.get_by_id(organization_id)
+        old_s3_key = await self._unit_of_work.legal_entity_repository.get_document_s3_key(
+            organization_id,
+            document_type,
+        )
+
+        new_s3_key = self._s3.build_object_key(organization_id, document_type, file_name)
+        await self._s3.upload_bytes(key=new_s3_key, body=body, content_type=content_type)
+
+        try:
+            await self._unit_of_work.legal_entity_repository.set_document_s3_key(
+                organization_id,
+                document_type,
+                new_s3_key,
+            )
+            await self._unit_of_work.commit()
+        except Exception:
+            await self._unit_of_work.rollback()
+            await self._s3.delete_object(key=new_s3_key)
+            raise
+
+        if old_s3_key and old_s3_key != new_s3_key:
+            await self._s3.delete_object(key=old_s3_key)
+
+        self._logger.info(
+            f'Document uploaded org={organization_id} type={document_type} key={new_s3_key}'
+        )
+        return OrganizationDocumentSlot(
+            organization_id=organization_id,
+            document_type=document_type,
+            s3_key=new_s3_key,
+            file_name=self._s3.file_name_from_key(new_s3_key),
+            content_type=content_type,
+            file_size_bytes=len(body),
+        )

src/application/commands/set_password.py

@@ -16,16 +16,14 @@ class SetPasswordCommand:
         self._logger = logger
 
     @transactional
-    async def __call__(self, email: str, password: str) -> bool:
+    async def __call__(self, user_id: str, password: str) -> bool:
         try:
-            user = await self._unit_of_work.user_repository.get_user_by_email(email)
-
-            password_hash = self._hash_service.hash_password(password)
+            password_hash = await self._hash_service.hash(password)
             await self._unit_of_work.user_repository.set_password(
-                user_id=user.id,
+                user_id=user_id,
                 password_hash=password_hash,
             )
-            self._logger.info(f'Set password for user {user.id}')
+            self._logger.info(f'Set password for user {user_id}')
             return True
         except ApplicationException:
             raise

src/application/commands/upload_organization_document.py

@@ -1,62 +0,0 @@
-from __future__ import annotations
-
-from ulid import ULID
-
-from src.application.abstractions import IUnitOfWork
-from src.application.contracts import ILogger
-from src.application.domain.entities.organization import OrganizationDocumentEntity
-from src.application.domain.exceptions import ApplicationException
-from src.infrastructure.database.decorators import transactional
-from src.infrastructure.storage.s3_documents_service import S3DocumentsService
-
-
-ALLOWED_DOCUMENT_TYPES = frozenset({
-    'charter', 'inn_certificate', 'ogrn_certificate',
-    'bank_details', 'kyc_representative', 'power_of_attorney', 'other',
-})
-
-
-class UploadOrganizationDocumentCommand:
-    def __init__(
-        self,
-        unit_of_work: IUnitOfWork,
-        s3_service: S3DocumentsService,
-        logger: ILogger,
-    ):
-        self._unit_of_work = unit_of_work
-        self._s3 = s3_service
-        self._logger = logger
-
-    @transactional
-    async def __call__(
-        self,
-        *,
-        organization_id: str,
-        admin_user_id: str,
-        document_type: str,
-        file_name: str,
-        content_type: str,
-        body: bytes,
-    ) -> OrganizationDocumentEntity:
-        if document_type not in ALLOWED_DOCUMENT_TYPES:
-            raise ApplicationException(status_code=400, message='Invalid document type')
-
-        await self._unit_of_work.legal_entity_repository.get_by_id(organization_id)
-
-        document_id = str(ULID())
-        s3_key = self._s3.build_object_key(organization_id, document_id, file_name)
-        await self._s3.upload_bytes(key=s3_key, body=body, content_type=content_type)
-
-        entity = OrganizationDocumentEntity(
-            id=document_id,
-            organization_id=organization_id,
-            document_type=document_type,
-            file_name=file_name,
-            s3_key=s3_key,
-            content_type=content_type,
-            file_size_bytes=len(body),
-            uploaded_by=admin_user_id,
-        )
-        saved = await self._unit_of_work.organization_document_repository.create(entity)
-        self._logger.info(f'Document uploaded id={saved.id} org={organization_id}')
-        return saved

src/application/commands/user_commands.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from typing import Any
+
+from src.application.abstractions import IUnitOfWork
+from src.application.contracts import ILogger
+from src.application.domain.entities.organization import PartySearchEntity
+from src.application.domain.entities.user import UserEntity
+from src.application.domain.enums.account_type import AccountType
+from src.infrastructure.database.decorators import transactional
+
+
+class ListUsersCommand:
+    def __init__(self, unit_of_work: IUnitOfWork, logger: ILogger):
+        self._unit_of_work = unit_of_work
+        self._logger = logger
+
+    @transactional
+    async def __call__(
+        self,
+        *,
+        limit: int = 50,
+        offset: int = 0,
+        search: str | None = None,
+    ) -> tuple[list[UserEntity], int]:
+        items = await self._unit_of_work.user_repository.list_all(
+            limit=limit,
+            offset=offset,
+            search=search,
+        )
+        total = await self._unit_of_work.user_repository.count_all(search=search)
+        return items, total
+
+
+class GetUserCommand:
+    def __init__(self, unit_of_work: IUnitOfWork, logger: ILogger):
+        self._unit_of_work = unit_of_work
+        self._logger = logger
+
+    @transactional
+    async def __call__(self, user_id: str) -> UserEntity:
+        return await self._unit_of_work.user_repository.get_by_id(user_id)

src/application/commands/user_wallet_commands.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+from src.application.abstractions import IUnitOfWork
+from src.application.contracts import ILogger
+from src.application.domain.entities.user import UserEntity, WalletEntity
+from src.application.domain.exceptions import ApplicationException
+from src.infrastructure.crypto.wallet_crypto import (
+    DerivedSecretKey,
+    decrypt_mnemonic,
+    derive_all_private_keys,
+    is_crypto_ready,
+)
+from src.infrastructure.database.decorators import transactional
+
+
+class ListUserWalletsCommand:
+    def __init__(self, unit_of_work: IUnitOfWork, logger: ILogger):
+        self._unit_of_work = unit_of_work
+        self._logger = logger
+
+    @transactional
+    async def __call__(self, user_id: str) -> list[WalletEntity]:
+        await self._unit_of_work.user_repository.get_by_id(user_id)
+        return await self._unit_of_work.wallet_repository.list_by_user(user_id)
+
+
+class GetUserMnemonicCommand:
+    def __init__(self, unit_of_work: IUnitOfWork, logger: ILogger):
+        self._unit_of_work = unit_of_work
+        self._logger = logger
+
+    @transactional
+    async def __call__(self, user_id: str) -> str:
+        user = await self._require_wallets_user(user_id)
+        if not is_crypto_ready():
+            raise ApplicationException(status_code=503, message='Crypto service not ready')
+        return decrypt_mnemonic(user.encrypted_mnemonic or '')
+
+    async def _require_wallets_user(self, user_id: str) -> UserEntity:
+        user = await self._unit_of_work.user_repository.get_by_id(user_id)
+        if not user.encrypted_mnemonic:
+            raise ApplicationException(status_code=404, message='Wallets not created for user')
+        return user
+
+
+class GetUserSecretKeysCommand:
+    def __init__(self, unit_of_work: IUnitOfWork, logger: ILogger):
+        self._unit_of_work = unit_of_work
+        self._logger = logger
+
+    @transactional
+    async def __call__(self, user_id: str) -> list[DerivedSecretKey]:
+        user = await self._require_wallets_user(user_id)
+        if not is_crypto_ready():
+            raise ApplicationException(status_code=503, message='Crypto service not ready')
+        mnemonic = decrypt_mnemonic(user.encrypted_mnemonic or '')
+        return derive_all_private_keys(mnemonic)
+
+    async def _require_wallets_user(self, user_id: str) -> UserEntity:
+        user = await self._unit_of_work.user_repository.get_by_id(user_id)
+        if not user.encrypted_mnemonic:
+            raise ApplicationException(status_code=404, message='Wallets not created for user')
+        return user

src/application/domain/entities/organization.py

@@ -24,6 +24,7 @@ class LegalEntityEntity:
     kyc_verified: bool
     kyc_verified_at: datetime | None
     encrypted_mnemonic: str | None
+    document_s3_keys: dict[str, str | None]
     created_by: str | None
     created_at: datetime | None = None
     updated_at: datetime | None = None
@@ -40,15 +41,32 @@ class OrganizationWalletEntity:
 
 
 @dataclass
-class OrganizationDocumentEntity:
-    id: str
+class CreateOrganizationWalletsResult:
+    wallets: list[OrganizationWalletEntity]
+    mnemonic: str
+
+
+@dataclass
+class OrganizationDocumentSlot:
     organization_id: str
     document_type: str
-    file_name: str
-    s3_key: str
-    content_type: str
-    file_size_bytes: int
-    uploaded_by: str | None
+    s3_key: str | None
+    file_name: str | None = None
+    content_type: str | None = None
+    file_size_bytes: int | None = None
+
+
+@dataclass
+class PartySearchEntity:
+    id: str
+    account_type: str
+    user_id: str
+    email: str | None
+    name: str | None
+    inn: str | None
+    phone: str | None
+    status: str | None = None
+    kyc_verified: bool | None = None
     created_at: datetime | None = None
 
 

src/application/domain/entities/user.py

@@ -32,3 +32,12 @@ class UserEntity:
     account_type: str | None = None
     provisioned_by: str | None = None
     provisioned_at: datetime | None = None
+
+@dataclass
+class WalletEntity:
+    id: str
+    user_id: str
+    chain: str
+    address: str
+    derivation_path: str
+    created_at: datetime | None = None

src/application/domain/organization_documents.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+ORGANIZATION_DOCUMENT_TYPES: tuple[str, ...] = (
+    'charter',
+    'inn_certificate',
+    'ogrn_certificate',
+    'bank_details',
+    'kyc_representative',
+    'power_of_attorney',
+    'other',
+)
+
+DOCUMENT_TYPE_TO_COLUMN: dict[str, str] = {
+    'charter': 'charter_s3_key',
+    'inn_certificate': 'inn_certificate_s3_key',
+    'ogrn_certificate': 'ogrn_certificate_s3_key',
+    'bank_details': 'bank_details_document_s3_key',
+    'kyc_representative': 'kyc_representative_s3_key',
+    'power_of_attorney': 'power_of_attorney_s3_key',
+    'other': 'other_document_s3_key',
+}
+
+DOCUMENT_TYPE_URL_SLUGS: dict[str, str] = {
+    'charter': 'charter',
+    'inn_certificate': 'inn-certificate',
+    'ogrn_certificate': 'ogrn-certificate',
+    'bank_details': 'bank-details',
+    'kyc_representative': 'kyc-representative',
+    'power_of_attorney': 'power-of-attorney',
+    'other': 'other',
+}
+
+URL_SLUG_TO_DOCUMENT_TYPE: dict[str, str] = {
+    slug: document_type for document_type, slug in DOCUMENT_TYPE_URL_SLUGS.items()
+}

src/infrastructure/config/settings.py

@@ -81,7 +81,7 @@ class Settings(BaseSettings):
     RATE_LIMIT_WINDOW: int = 60
 
     LOG_LEVEL: Literal['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'] = 'INFO'
-    LOG_FORMAT: Literal['JSON', 'TEXT'] = 'TEXT'
+    LOG_FORMAT: Literal['JSON', 'TEXT'] = 'JSON'
 
     @field_validator('VAULT_ADDR', mode='before')
     @classmethod

src/infrastructure/crypto/wallet_crypto.py

@@ -43,6 +43,14 @@ class DerivedWallet:
     derivation_path: str
 
 
+@dataclass(frozen=True)
+class DerivedSecretKey:
+    chain: str
+    address: str
+    derivation_path: str
+    private_key: str
+
+
 class CryptoNotReadyError(RuntimeError):
     pass
 
@@ -151,6 +159,87 @@ def derive_all_addresses(mnemonic: str) -> list[DerivedWallet]:
     ]
 
 
+def derive_all_private_keys(mnemonic: str) -> list[DerivedSecretKey]:
+    seed_bytes = Bip39SeedGenerator(mnemonic).Generate()
+
+    eth_ctx = Bip44.FromSeed(seed_bytes, Bip44Coins.ETHEREUM)
+    eth_node = (
+        eth_ctx.Purpose()
+        .Coin()
+        .Account(0)
+        .Change(Bip44Changes.CHAIN_EXT)
+        .AddressIndex(0)
+    )
+    eth_addr = eth_node.PublicKey().ToAddress()
+    eth_pk = eth_node.PrivateKey().Raw().ToHex()
+
+    btc_ctx = Bip84.FromSeed(seed_bytes, Bip84Coins.BITCOIN)
+    btc_node = (
+        btc_ctx.Purpose()
+        .Coin()
+        .Account(0)
+        .Change(Bip44Changes.CHAIN_EXT)
+        .AddressIndex(0)
+    )
+    btc_addr = btc_node.PublicKey().ToAddress()
+    btc_pk = btc_node.PrivateKey().Raw().ToHex()
+
+    trx_ctx = Bip44.FromSeed(seed_bytes, Bip44Coins.TRON)
+    trx_node = (
+        trx_ctx.Purpose()
+        .Coin()
+        .Account(0)
+        .Change(Bip44Changes.CHAIN_EXT)
+        .AddressIndex(0)
+    )
+    trx_addr = trx_node.PublicKey().ToAddress()
+    trx_pk = trx_node.PrivateKey().Raw().ToHex()
+
+    sol_ctx = Bip44.FromSeed(seed_bytes, Bip44Coins.SOLANA)
+    sol_node = (
+        sol_ctx.Purpose()
+        .Coin()
+        .Account(0)
+        .Change(Bip44Changes.CHAIN_EXT)
+        .AddressIndex(0)
+    )
+    sol_addr = sol_node.PublicKey().ToAddress()
+    sol_pk = sol_node.PrivateKey().Raw().ToHex()
+
+    return [
+        DerivedSecretKey(
+            chain='ETH',
+            address=eth_addr,
+            derivation_path=DERIVATION_PATHS['ETH'],
+            private_key=eth_pk,
+        ),
+        DerivedSecretKey(
+            chain='BSC',
+            address=eth_addr,
+            derivation_path=DERIVATION_PATHS['BSC'],
+            private_key=eth_pk,
+        ),
+        DerivedSecretKey(
+            chain='BTC',
+            address=btc_addr,
+            derivation_path=DERIVATION_PATHS['BTC'],
+            private_key=btc_pk,
+        ),
+        DerivedSecretKey(
+            chain='TRX',
+            address=trx_addr,
+            derivation_path=DERIVATION_PATHS['TRX'],
+            private_key=trx_pk,
+        ),
+        DerivedSecretKey(
+            chain='SOL',
+            address=sol_addr,
+            derivation_path=DERIVATION_PATHS['SOL'],
+            private_key=sol_pk,
+        ),
+    ]
+
+
 def encrypt_mnemonic(plaintext: str) -> str:
     if _master_key is None:
         raise CryptoNotReadyError('Crypto service not ready')

src/infrastructure/database/models/__init__.py

@@ -4,8 +4,8 @@ from src.infrastructure.database.models.admin_user import AdminUserModel
 from src.infrastructure.database.models.admin_session import AdminSessionModel
 from src.infrastructure.database.models.legal_entity import LegalEntityModel
 from src.infrastructure.database.models.organization_wallet import OrganizationWalletModel
-from src.infrastructure.database.models.organization_document import OrganizationDocumentModel
 from src.infrastructure.database.models.purchase_request import PurchaseRequestModel
+from src.infrastructure.database.models.wallets import WalletModel
 
 __all__ = [
     'Base',
@@ -14,6 +14,6 @@ __all__ = [
     'AdminSessionModel',
     'LegalEntityModel',
     'OrganizationWalletModel',
-    'OrganizationDocumentModel',
     'PurchaseRequestModel',
+    'WalletModel',
 ]

src/infrastructure/database/models/legal_entity.py

@@ -35,6 +35,13 @@ class LegalEntityModel(Base, UlidPrimaryKeyMixin, AuditTimestampsMixin):
     kyc_verified: Mapped[bool] = mapped_column(Boolean, nullable=False, server_default='true', default=True)
     kyc_verified_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True), nullable=True)
     encrypted_mnemonic: Mapped[str | None] = mapped_column(Text, nullable=True)
+    charter_s3_key: Mapped[str | None] = mapped_column(String(1024), nullable=True)
+    inn_certificate_s3_key: Mapped[str | None] = mapped_column(String(1024), nullable=True)
+    ogrn_certificate_s3_key: Mapped[str | None] = mapped_column(String(1024), nullable=True)
+    bank_details_document_s3_key: Mapped[str | None] = mapped_column(String(1024), nullable=True)
+    kyc_representative_s3_key: Mapped[str | None] = mapped_column(String(1024), nullable=True)
+    power_of_attorney_s3_key: Mapped[str | None] = mapped_column(String(1024), nullable=True)
+    other_document_s3_key: Mapped[str | None] = mapped_column(String(1024), nullable=True)
     created_by: Mapped[str | None] = mapped_column(
         String(26),
         ForeignKey('admin_users.id'),

src/infrastructure/database/models/organization_document.py

@@ -1,35 +0,0 @@
-from __future__ import annotations
-
-from datetime import datetime
-
-from sqlalchemy import BigInteger, DateTime, ForeignKey, String, func
-from sqlalchemy.orm import Mapped, mapped_column
-
-from src.infrastructure.database.models.base import Base
-from src.infrastructure.database.models.mixins import UlidPrimaryKeyMixin
-
-
-class OrganizationDocumentModel(Base, UlidPrimaryKeyMixin):
-    __tablename__ = 'organization_documents'
-
-    organization_id: Mapped[str] = mapped_column(
-        String(26),
-        ForeignKey('legal_entities.id', ondelete='RESTRICT'),
-        nullable=False,
-        index=True,
-    )
-    document_type: Mapped[str] = mapped_column(String(64), nullable=False)
-    file_name: Mapped[str] = mapped_column(String(512), nullable=False)
-    s3_key: Mapped[str] = mapped_column(String(1024), nullable=False)
-    content_type: Mapped[str] = mapped_column(String(128), nullable=False)
-    file_size_bytes: Mapped[int] = mapped_column(BigInteger, nullable=False)
-    uploaded_by: Mapped[str | None] = mapped_column(
-        String(26),
-        ForeignKey('admin_users.id'),
-        nullable=True,
-    )
-    created_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True),
-        nullable=False,
-        server_default=func.now(),
-    )

src/infrastructure/database/models/wallets.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from datetime import datetime
+
+from sqlalchemy import DateTime, ForeignKey, String, func
+from sqlalchemy.orm import Mapped, mapped_column
+
+from src.infrastructure.database.models.base import Base
+from src.infrastructure.database.models.mixins import UlidPrimaryKeyMixin
+
+
+class WalletModel(Base, UlidPrimaryKeyMixin):
+    __tablename__ = 'wallets'
+
+    user_id: Mapped[str] = mapped_column(
+        String(26),
+        ForeignKey('users.id', ondelete='RESTRICT'),
+        nullable=False,
+        index=True,
+    )
+    chain: Mapped[str] = mapped_column(String(16), nullable=False)
+    address: Mapped[str] = mapped_column(String(128), nullable=False, index=True)
+    derivation_path: Mapped[str] = mapped_column(String(64), nullable=False)
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True),
+        nullable=False,
+        server_default=func.now(),
+    )

src/infrastructure/database/repositories/__init__.py

@@ -3,8 +3,8 @@ from src.infrastructure.database.repositories.admin_session_repository import Ad
 from src.infrastructure.database.repositories.user_repository import UserRepository
 from src.infrastructure.database.repositories.legal_entity_repository import LegalEntityRepository
 from src.infrastructure.database.repositories.organization_wallet_repository import OrganizationWalletRepository
-from src.infrastructure.database.repositories.organization_document_repository import OrganizationDocumentRepository
 from src.infrastructure.database.repositories.purchase_request_repository import PurchaseRequestRepository
+from src.infrastructure.database.repositories.wallets_repository import WalletRepository
 
 __all__ = [
     'AdminUserRepository',
@@ -12,6 +12,6 @@ __all__ = [
     'UserRepository',
     'LegalEntityRepository',
     'OrganizationWalletRepository',
-    'OrganizationDocumentRepository',
     'PurchaseRequestRepository',
+    'WalletRepository',
 ]

src/infrastructure/database/repositories/legal_entity_repository.py

@@ -2,8 +2,7 @@ from __future__ import annotations
 
 from typing import Any
 
-from fastapi import status
-from sqlalchemy import func, select, update
+from sqlalchemy import func, or_, select, update
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.exc import IntegrityError, SQLAlchemyError
 
@@ -11,7 +10,8 @@ from src.application.abstractions.repositories import ILegalEntityRepository
 from src.application.contracts import ILogger
 from src.application.domain.entities.organization import LegalEntityEntity
 from src.application.domain.exceptions import ApplicationException
-from src.infrastructure.database.models import LegalEntityModel
+from src.application.domain.organization_documents import DOCUMENT_TYPE_TO_COLUMN, ORGANIZATION_DOCUMENT_TYPES
+from src.infrastructure.database.models import LegalEntityModel, UserModel
 
 
 class LegalEntityRepository(ILegalEntityRepository):
@@ -19,6 +19,12 @@ class LegalEntityRepository(ILegalEntityRepository):
         self._session = session
         self._logger = logger
 
+    def _document_s3_keys_from_model(self, m: LegalEntityModel) -> dict[str, str | None]:
+        return {
+            document_type: getattr(m, DOCUMENT_TYPE_TO_COLUMN[document_type])
+            for document_type in ORGANIZATION_DOCUMENT_TYPES
+        }
+
     def _to_entity(self, m: LegalEntityModel) -> LegalEntityEntity:
         return LegalEntityEntity(
             id=m.id,
@@ -37,11 +43,43 @@ class LegalEntityRepository(ILegalEntityRepository):
             kyc_verified=m.kyc_verified,
             kyc_verified_at=m.kyc_verified_at,
             encrypted_mnemonic=m.encrypted_mnemonic,
+            document_s3_keys=self._document_s3_keys_from_model(m),
             created_by=m.created_by,
             created_at=m.created_at,
             updated_at=m.updated_at,
         )
 
+    def _search_filter(self, search: str | None):
+        if not search or not search.strip():
+            return None
+
+        pattern = f'%{search.strip()}%'
+        full_name = func.concat_ws(
+            ' ',
+            UserModel.last_name,
+            UserModel.first_name,
+            UserModel.middle_name,
+        )
+        return or_(
+            LegalEntityModel.id.ilike(pattern),
+            LegalEntityModel.name.ilike(pattern),
+            LegalEntityModel.short_name.ilike(pattern),
+            LegalEntityModel.inn.ilike(pattern),
+            LegalEntityModel.ogrn.ilike(pattern),
+            LegalEntityModel.kpp.ilike(pattern),
+            LegalEntityModel.legal_address.ilike(pattern),
+            LegalEntityModel.actual_address.ilike(pattern),
+            LegalEntityModel.contact_person.ilike(pattern),
+            LegalEntityModel.contact_phone.ilike(pattern),
+            UserModel.email.ilike(pattern),
+            UserModel.last_name.ilike(pattern),
+            UserModel.first_name.ilike(pattern),
+            UserModel.middle_name.ilike(pattern),
+            UserModel.phone.ilike(pattern),
+            UserModel.inn.ilike(pattern),
+            full_name.ilike(pattern),
+        )
+
     async def create(
         self,
         *,
@@ -95,14 +133,37 @@ class LegalEntityRepository(ILegalEntityRepository):
             raise ApplicationException(status_code=404, message='Organization not found')
         return self._to_entity(m)
 
-    async def list_all(self, *, limit: int, offset: int) -> list[LegalEntityEntity]:
-        res = await self._session.execute(
-            select(LegalEntityModel).order_by(LegalEntityModel.created_at.desc()).limit(limit).offset(offset)
+    async def list_all(
+        self,
+        *,
+        limit: int,
+        offset: int,
+        search: str | None = None,
+    ) -> list[LegalEntityEntity]:
+        stmt = (
+            select(LegalEntityModel)
+            .join(UserModel, UserModel.id == LegalEntityModel.user_id)
+            .where(UserModel.is_deleted.is_(False))
+            .order_by(LegalEntityModel.created_at.desc())
+            .limit(limit)
+            .offset(offset)
         )
+        search_filter = self._search_filter(search)
+        if search_filter is not None:
+            stmt = stmt.where(search_filter)
+        res = await self._session.execute(stmt)
         return [self._to_entity(m) for m in res.scalars().all()]
 
-    async def count_all(self) -> int:
-        res = await self._session.execute(select(func.count()).select_from(LegalEntityModel))
+    async def count_all(self, *, search: str | None = None) -> int:
+        stmt = (
+            select(func.count(LegalEntityModel.id))
+            .join(UserModel, UserModel.id == LegalEntityModel.user_id)
+            .where(UserModel.is_deleted.is_(False))
+        )
+        search_filter = self._search_filter(search)
+        if search_filter is not None:
+            stmt = stmt.where(search_filter)
+        res = await self._session.execute(stmt)
         return int(res.scalar_one())
 
     async def update(self, organization_id: str, *, values: dict[str, Any]) -> LegalEntityEntity:
@@ -121,3 +182,19 @@ class LegalEntityRepository(ILegalEntityRepository):
             .values(encrypted_mnemonic=encrypted_mnemonic)
         )
         await self._session.flush()
+
+    async def get_document_s3_key(self, organization_id: str, document_type: str) -> str | None:
+        org = await self.get_by_id(organization_id)
+        return org.document_s3_keys.get(document_type)
+
+    async def set_document_s3_key(self, organization_id: str, document_type: str, s3_key: str) -> LegalEntityEntity:
+        column = DOCUMENT_TYPE_TO_COLUMN.get(document_type)
+        if column is None:
+            raise ApplicationException(status_code=400, message='Invalid document type')
+        await self._session.execute(
+            update(LegalEntityModel)
+            .where(LegalEntityModel.id == organization_id)
+            .values(**{column: s3_key})
+        )
+        await self._session.flush()
+        return await self.get_by_id(organization_id)

src/infrastructure/database/repositories/organization_document_repository.py

@@ -1,66 +0,0 @@
-from __future__ import annotations
-
-from sqlalchemy import select
-from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy.exc import SQLAlchemyError
-
-from src.application.abstractions.repositories import IOrganizationDocumentRepository
-from src.application.contracts import ILogger
-from src.application.domain.entities.organization import OrganizationDocumentEntity
-from src.application.domain.exceptions import ApplicationException
-from src.infrastructure.database.models import OrganizationDocumentModel
-
-
-class OrganizationDocumentRepository(IOrganizationDocumentRepository):
-    def __init__(self, session: AsyncSession, logger: ILogger):
-        self._session = session
-        self._logger = logger
-
-    def _to_entity(self, m: OrganizationDocumentModel) -> OrganizationDocumentEntity:
-        return OrganizationDocumentEntity(
-            id=m.id,
-            organization_id=m.organization_id,
-            document_type=m.document_type,
-            file_name=m.file_name,
-            s3_key=m.s3_key,
-            content_type=m.content_type,
-            file_size_bytes=m.file_size_bytes,
-            uploaded_by=m.uploaded_by,
-            created_at=m.created_at,
-        )
-
-    async def create(self, document: OrganizationDocumentEntity) -> OrganizationDocumentEntity:
-        model = OrganizationDocumentModel(
-            id=document.id,
-            organization_id=document.organization_id,
-            document_type=document.document_type,
-            file_name=document.file_name,
-            s3_key=document.s3_key,
-            content_type=document.content_type,
-            file_size_bytes=document.file_size_bytes,
-            uploaded_by=document.uploaded_by,
-        )
-        self._session.add(model)
-        try:
-            await self._session.flush()
-            return self._to_entity(model)
-        except SQLAlchemyError as exc:
-            self._logger.exception(str(exc))
-            raise ApplicationException(status_code=500, message='Database error')
-
-    async def get_by_id(self, document_id: str) -> OrganizationDocumentEntity:
-        res = await self._session.execute(
-            select(OrganizationDocumentModel).where(OrganizationDocumentModel.id == document_id)
-        )
-        m = res.scalar_one_or_none()
-        if m is None:
-            raise ApplicationException(status_code=404, message='Document not found')
-        return self._to_entity(m)
-
-    async def list_by_organization(self, organization_id: str) -> list[OrganizationDocumentEntity]:
-        res = await self._session.execute(
-            select(OrganizationDocumentModel)
-            .where(OrganizationDocumentModel.organization_id == organization_id)
-            .order_by(OrganizationDocumentModel.created_at.desc())
-        )
-        return [self._to_entity(m) for m in res.scalars().all()]

src/infrastructure/database/repositories/purchase_request_repository.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from typing import Any
 
+from ulid import ULID
 from sqlalchemy import func, select, update
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.exc import SQLAlchemyError
@@ -45,6 +46,16 @@ class PurchaseRequestRepository(IPurchaseRequestRepository):
             stmt = stmt.where(PurchaseRequestModel.organization_id == organization_id)
         return stmt
 
+    async def create(self, values: dict[str, Any]) -> PurchaseRequestEntity:
+        model = PurchaseRequestModel(id=str(ULID()), **values)
+        self._session.add(model)
+        try:
+            await self._session.flush()
+            return self._to_entity(model)
+        except SQLAlchemyError as exc:
+            self._logger.exception(str(exc))
+            raise ApplicationException(status_code=500, message='Database error')
+
     async def get_by_id(self, request_id: str) -> PurchaseRequestEntity:
         res = await self._session.execute(select(PurchaseRequestModel).where(PurchaseRequestModel.id == request_id))
         m = res.scalar_one_or_none()

src/infrastructure/database/repositories/user_repository.py

@@ -3,13 +3,14 @@ from __future__ import annotations
 from datetime import datetime
 
 from fastapi import status
-from sqlalchemy import select
+from sqlalchemy import func, or_, select
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.exc import IntegrityError, SQLAlchemyError
 
 from src.application.abstractions.repositories import IUserRepository
 from src.application.contracts import ILogger
 from src.application.domain.entities import UserEntity
+from src.application.domain.entities.organization import PartySearchEntity
 from src.application.domain.enums.account_type import AccountType
 from src.application.domain.exceptions import InternalServerException, ApplicationException
 from src.infrastructure.database.models import UserModel
@@ -44,6 +45,16 @@ class UserRepository(IUserRepository):
             provisioned_by=user.provisioned_by,
             provisioned_at=user.provisioned_at,
         )
+    
+    async def get_by_id(self, user_id: str) -> UserEntity:
+        try:
+            user = await self._get_user(user_id)
+            return self._to_entity(user)
+        except ApplicationException:
+            raise
+        except SQLAlchemyError as exception:
+            self._logger.exception(str(exception))
+            raise InternalServerException(message=f'Database error: {str(exception)}')
 
     async def create_legal_entity_user(
         self,
@@ -73,10 +84,25 @@ class UserRepository(IUserRepository):
         except SQLAlchemyError as exc:
             self._logger.exception(str(exc))
             raise ApplicationException(status_code=500, message='Database error')
-    
+        
+    async def _get_user(self, user_id: str) -> UserModel:
+        stmt = (
+            select(UserModel)
+            .where(
+                UserModel.id == user_id,
+                UserModel.is_deleted.is_(False),
+            )
+        )
+        result = await self._session.execute(stmt)
+        user: UserModel | None = result.scalar_one_or_none()
+        if user is None:
+            self._logger.warning(f'User not found with user_id {user_id}')
+            raise ApplicationException(status_code=404, message='User not found')
+        return user
+
     async def _update_field(self, user_id: str, **fields: object) -> UserEntity:
         try:
-            user = await self._get_active_user(user_id)
+            user = await self._get_user(user_id)
             for key, value in fields.items():
                 setattr(user, key, value)
             await self._session.flush()
@@ -109,3 +135,115 @@ class UserRepository(IUserRepository):
         stmt = select(UserModel.id).where(UserModel.email == email, UserModel.is_deleted.is_(False)).limit(1)
         result = await self._session.execute(stmt)
         return result.scalar_one_or_none() is not None
+    
+    def _search_filter(self, search: str | None):
+        if not search or not search.strip():
+            return None
+
+        pattern = f'%{search.strip()}%'
+        return or_(
+            UserModel.id.ilike(pattern),
+            UserModel.email.ilike(pattern),
+            UserModel.last_name.ilike(pattern),
+            UserModel.first_name.ilike(pattern),
+            UserModel.middle_name.ilike(pattern),
+            UserModel.phone.ilike(pattern),
+            UserModel.inn.ilike(pattern),
+        )
+    
+    async def list_all(
+        self,
+        *,
+        limit: int,
+        offset: int,
+        search: str | None = None,
+    ) -> list[UserEntity]:
+        stmt = (
+            select(UserModel)
+            .where(UserModel.is_deleted.is_(False))
+            .order_by(UserModel.created_at.desc())
+            .limit(limit)
+            .offset(offset)
+        )
+        search_filter = self._search_filter(search)
+        if search_filter is not None:
+            stmt = stmt.where(search_filter)
+        res = await self._session.execute(stmt)
+        return [self._to_entity(m) for m in res.scalars().all()]
+
+    def _individual_search_filter(self, query: str):
+        pattern = f'%{query.strip()}%'
+        full_name = func.concat_ws(
+            ' ',
+            UserModel.last_name,
+            UserModel.first_name,
+            UserModel.middle_name,
+        )
+        return or_(
+            UserModel.id.ilike(pattern),
+            UserModel.email.ilike(pattern),
+            UserModel.last_name.ilike(pattern),
+            UserModel.first_name.ilike(pattern),
+            UserModel.middle_name.ilike(pattern),
+            UserModel.phone.ilike(pattern),
+            UserModel.passport_data.ilike(pattern),
+            UserModel.inn.ilike(pattern),
+            UserModel.erc20.ilike(pattern),
+            full_name.ilike(pattern),
+        )
+
+    def _to_search_entity(self, user: UserModel) -> PartySearchEntity:
+        name = ' '.join(
+            part for part in (user.last_name, user.first_name, user.middle_name)
+            if part
+        ) or None
+        return PartySearchEntity(
+            id=user.id,
+            account_type=user.account_type,
+            user_id=user.id,
+            email=user.email,
+            name=name,
+            inn=user.inn,
+            phone=user.phone,
+            status=None,
+            kyc_verified=user.kyc_verified,
+            created_at=user.created_at,
+        )
+
+    async def search_individuals(self, *, query: str, limit: int, offset: int) -> list[PartySearchEntity]:
+        stmt = (
+            select(UserModel)
+            .where(
+                UserModel.is_deleted.is_(False),
+                UserModel.account_type == AccountType.INDIVIDUAL,
+                self._individual_search_filter(query),
+            )
+            .order_by(UserModel.created_at.desc())
+            .limit(limit)
+            .offset(offset)
+        )
+        result = await self._session.execute(stmt)
+        return [self._to_search_entity(user) for user in result.scalars().all()]
+
+    async def count_individuals(self, *, query: str) -> int:
+        stmt = (
+            select(func.count(UserModel.id))
+            .where(
+                UserModel.is_deleted.is_(False),
+                UserModel.account_type == AccountType.INDIVIDUAL,
+                self._individual_search_filter(query),
+            )
+        )
+        result = await self._session.execute(stmt)
+        return int(result.scalar_one())
+    
+    async def count_all(self, *, search: str | None = None) -> int:
+        stmt = (
+            select(func.count(UserModel.id))
+            .where(UserModel.is_deleted.is_(False))
+        )
+        search_filter = self._search_filter(search)
+        if search_filter is not None:
+            stmt = stmt.where(search_filter)
+        res = await self._session.execute(stmt)
+        return int(res.scalar_one())

src/infrastructure/database/repositories/wallets_repository.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.exc import IntegrityError, SQLAlchemyError
+
+from src.application.abstractions.repositories import IWalletRepository
+from src.application.contracts import ILogger
+from src.application.domain.entities.user import WalletEntity
+from src.application.domain.exceptions import ApplicationException
+from src.infrastructure.database.models import WalletModel
+
+
+class WalletRepository(IWalletRepository):
+    def __init__(self, session: AsyncSession, logger: ILogger):
+        self._session = session
+        self._logger = logger
+
+    def _to_entity(self, m: WalletModel) -> WalletEntity:
+        return WalletEntity(
+            id=m.id,
+            user_id=m.user_id,
+            chain=m.chain,
+            address=m.address,
+            derivation_path=m.derivation_path,
+            created_at=m.created_at,
+        )
+
+    async def list_by_user(self, user_id: str) -> list[WalletEntity]:
+        res = await self._session.execute(
+            select(WalletModel)
+            .where(WalletModel.user_id == user_id)
+            .order_by(WalletModel.chain)
+        )
+        return [self._to_entity(m) for m in res.scalars().all()]
+
+    async def exists_for_user(self, user_id: str) -> bool:
+        res = await self._session.execute(
+            select(WalletModel.id)
+            .where(WalletModel.user_id == user_id)
+            .limit(1)
+        )
+        return res.scalar_one_or_none() is not None

src/infrastructure/database/unit_of_work.py

@@ -5,10 +5,10 @@ from src.application.abstractions.repositories import (
     IAdminSessionRepository,
     IAdminUserRepository,
     ILegalEntityRepository,
-    IOrganizationDocumentRepository,
     IOrganizationWalletRepository,
     IPurchaseRequestRepository,
     IUserRepository,
+    IWalletRepository,
 )
 from src.application.contracts import ILogger
 from src.application.domain.exceptions import RefreshConcurrentException
@@ -16,10 +16,10 @@ from src.infrastructure.database.repositories import (
     AdminSessionRepository,
     AdminUserRepository,
     LegalEntityRepository,
-    OrganizationDocumentRepository,
     OrganizationWalletRepository,
     PurchaseRequestRepository,
     UserRepository,
+    WalletRepository,
 )
 
 
@@ -32,8 +32,8 @@ class UnitOfWork(IUnitOfWork):
         self._admin_session_repository: IAdminSessionRepository | None = None
         self._legal_entity_repository: ILegalEntityRepository | None = None
         self._organization_wallet_repository: IOrganizationWalletRepository | None = None
-        self._organization_document_repository: IOrganizationDocumentRepository | None = None
         self._purchase_request_repository: IPurchaseRequestRepository | None = None
+        self._wallet_repository: IWalletRepository | None = None
         self._logger: ILogger = logger
 
     async def __aenter__(self):
@@ -87,14 +87,14 @@ class UnitOfWork(IUnitOfWork):
                 session=self._session, logger=self._logger
             )
         return self._organization_wallet_repository
-
+    
     @property
-    def organization_document_repository(self) -> IOrganizationDocumentRepository:
-        if self._organization_document_repository is None:
-            self._organization_document_repository = OrganizationDocumentRepository(
+    def wallet_repository(self) -> IWalletRepository:
+        if self._wallet_repository is None:
+            self._wallet_repository = WalletRepository(
                 session=self._session, logger=self._logger
             )
-        return self._organization_document_repository
+        return self._wallet_repository
 
     @property
     def purchase_request_repository(self) -> IPurchaseRequestRepository:

src/infrastructure/storage/s3_documents_service.py

@@ -23,9 +23,13 @@ class S3DocumentsService:
         self._key_prefix = key_prefix.strip('/')
         self._presigned_ttl_seconds = presigned_ttl_seconds
 
-    def build_object_key(self, organization_id: str, document_id: str, file_name: str) -> str:
+    @staticmethod
+    def file_name_from_key(key: str) -> str:
+        return key.rsplit('/', 1)[-1]
+
+    def build_object_key(self, organization_id: str, document_type: str, file_name: str) -> str:
         safe_name = file_name.replace('/', '_').replace('\\', '_')
-        return f'{self._key_prefix}/{organization_id}/{document_id}/{safe_name}'
+        return f'{self._key_prefix}/{organization_id}/{document_type}/{safe_name}'
 
     def _client_kwargs(self) -> dict[str, object]:
         kw: dict[str, object] = {'region_name': self._region}

src/presentation/dependencies/commands.py

@@ -7,6 +7,7 @@ from src.application.commands import (
     AdminLoginCommand,
     AdminLogoutCommand,
     AdminJwtRefreshCommand,
+    CreatePurchaseRequestCommand,
     GetAdminMeCommand,
     CreateOrganizationCommand,
     CreateOrganizationWalletsCommand,
@@ -25,6 +26,12 @@ from src.application.commands import (
     UpdatePurchaseRequestCommand,
     UpdatePurchaseRequestStatusCommand,
     PutOrganizationDocumentCommand,
+    SetPasswordCommand,
+    ListUsersCommand,
+    GetUserCommand,
+    ListUserWalletsCommand,
+    GetUserMnemonicCommand,
+    GetUserSecretKeysCommand,
 )
 from src.application.contracts import IHashService, IJwtService, ILogger
 from src.infrastructure.config import settings
@@ -173,6 +180,13 @@ def get_list_purchase_requests_command(
     return ListPurchaseRequestsCommand(uow, logger)
 
 
+def get_create_purchase_request_command(
+    uow: IUnitOfWork = Depends(get_unit_of_work),
+    logger: ILogger = Depends(get_logger),
+) -> CreatePurchaseRequestCommand:
+    return CreatePurchaseRequestCommand(uow, logger)
+
+
 def get_get_purchase_request_command(
     uow: IUnitOfWork = Depends(get_unit_of_work),
     logger: ILogger = Depends(get_logger),
@@ -199,3 +213,40 @@ def get_set_purchase_request_quote_command(
     logger: ILogger = Depends(get_logger),
 ) -> SetPurchaseRequestQuoteCommand:
     return SetPurchaseRequestQuoteCommand(uow, logger)
+
+def get_set_password_command(
+    uow: IUnitOfWork = Depends(get_unit_of_work),
+    hash_service: IHashService = Depends(get_hash_service),
+    logger: ILogger = Depends(get_logger),
+) -> SetPasswordCommand:
+    return SetPasswordCommand(uow, hash_service, logger)
+
+def get_list_users_command(
+    uow: IUnitOfWork = Depends(get_unit_of_work),
+    logger: ILogger = Depends(get_logger),
+) -> ListUsersCommand:
+    return ListUsersCommand(uow, logger)
+
+def get_get_user_command(
+    uow: IUnitOfWork = Depends(get_unit_of_work),
+    logger: ILogger = Depends(get_logger),
+) -> GetUserCommand:
+    return GetUserCommand(uow, logger)
+
+def get_list_user_wallets_command(
+    uow: IUnitOfWork = Depends(get_unit_of_work),
+    logger: ILogger = Depends(get_logger),
+) -> ListUserWalletsCommand:
+    return ListUserWalletsCommand(uow, logger)
+
+def get_get_user_mnemonic_command(
+    uow: IUnitOfWork = Depends(get_unit_of_work),
+    logger: ILogger = Depends(get_logger),
+) -> GetUserMnemonicCommand:
+    return GetUserMnemonicCommand(uow, logger)
+
+def get_get_user_secret_keys_command(
+    uow: IUnitOfWork = Depends(get_unit_of_work),
+    logger: ILogger = Depends(get_logger),
+) -> GetUserSecretKeysCommand:
+    return GetUserSecretKeysCommand(uow, logger)

src/presentation/routing/documents.py

@@ -1,17 +1,17 @@
-from fastapi import APIRouter, Depends, File, Form, UploadFile, status
+from fastapi import APIRouter, Depends, File, UploadFile
 
 from src.application.commands import (
     GetOrganizationDocumentCommand,
     ListOrganizationDocumentsCommand,
-    UploadOrganizationDocumentCommand,
+    PutOrganizationDocumentCommand,
 )
 from src.application.domain.dto import AdminAuthContext
 from src.presentation.decorators.admin_auth import require_admin_access, require_admin_role
 from src.presentation.dependencies.commands import (
     get_get_organization_document_command,
     get_list_organization_documents_command,
+    get_put_organization_document_command,
     get_s3_documents_service,
-    get_upload_organization_document_command,
 )
 from src.infrastructure.storage.s3_documents_service import S3DocumentsService
 from src.presentation.schemas.mappers import document_to_response
@@ -20,6 +20,12 @@ from src.presentation.schemas.organization import DocumentResponse
 documents_router = APIRouter(prefix='/organizations/{organization_id}/documents', tags=['documents'])
 
 
+async def _document_download_url(s3: S3DocumentsService, s3_key: str | None) -> str | None:
+    if not s3_key:
+        return None
+    return await s3.generate_presigned_download_url(key=s3_key)
+
+
 @documents_router.get('', response_model=list[DocumentResponse])
 async def list_documents(
     organization_id: str,
@@ -30,41 +36,226 @@ async def list_documents(
     docs = await command(organization_id)
     result: list[DocumentResponse] = []
     for doc in docs:
-        url = await s3.generate_presigned_download_url(key=doc.s3_key)
+        url = await _document_download_url(s3, doc.s3_key)
         result.append(document_to_response(doc, download_url=url))
     return result
 
 
-@documents_router.post('', response_model=DocumentResponse, status_code=status.HTTP_201_CREATED)
-async def upload_document(
+async def _put_document(
+    *,
     organization_id: str,
-    document_type: str = Form(...),
-    file: UploadFile = File(...),
-    auth: AdminAuthContext = Depends(require_admin_role('compliance', 'superadmin')),
-    command: UploadOrganizationDocumentCommand = Depends(get_upload_organization_document_command),
-    s3: S3DocumentsService = Depends(get_s3_documents_service),
-):
+    document_type: str,
+    file: UploadFile,
+    command: PutOrganizationDocumentCommand,
+    s3: S3DocumentsService,
+) -> DocumentResponse:
     body = await file.read()
     saved = await command(
         organization_id=organization_id,
-        admin_user_id=auth.admin_user_id,
         document_type=document_type,
         file_name=file.filename or 'document',
         content_type=file.content_type or 'application/octet-stream',
         body=body,
     )
-    url = await s3.generate_presigned_download_url(key=saved.s3_key)
+    url = await _document_download_url(s3, saved.s3_key)
     return document_to_response(saved, download_url=url)
 
 
-@documents_router.get('/{document_id}', response_model=DocumentResponse)
-async def get_document(
+@documents_router.put('/charter', response_model=DocumentResponse)
+async def put_charter_document(
+    organization_id: str,
+    file: UploadFile = File(...),
+    auth: AdminAuthContext = Depends(require_admin_role('compliance', 'superadmin')),
+    command: PutOrganizationDocumentCommand = Depends(get_put_organization_document_command),
+    s3: S3DocumentsService = Depends(get_s3_documents_service),
+):
+    return await _put_document(
+        organization_id=organization_id,
+        document_type='charter',
+        file=file,
+        command=command,
+        s3=s3,
+    )
+
+
+@documents_router.put('/inn-certificate', response_model=DocumentResponse)
+async def put_inn_certificate_document(
+    organization_id: str,
+    file: UploadFile = File(...),
+    auth: AdminAuthContext = Depends(require_admin_role('compliance', 'superadmin')),
+    command: PutOrganizationDocumentCommand = Depends(get_put_organization_document_command),
+    s3: S3DocumentsService = Depends(get_s3_documents_service),
+):
+    return await _put_document(
+        organization_id=organization_id,
+        document_type='inn_certificate',
+        file=file,
+        command=command,
+        s3=s3,
+    )
+
+
+@documents_router.put('/ogrn-certificate', response_model=DocumentResponse)
+async def put_ogrn_certificate_document(
+    organization_id: str,
+    file: UploadFile = File(...),
+    auth: AdminAuthContext = Depends(require_admin_role('compliance', 'superadmin')),
+    command: PutOrganizationDocumentCommand = Depends(get_put_organization_document_command),
+    s3: S3DocumentsService = Depends(get_s3_documents_service),
+):
+    return await _put_document(
+        organization_id=organization_id,
+        document_type='ogrn_certificate',
+        file=file,
+        command=command,
+        s3=s3,
+    )
+
+
+@documents_router.put('/bank-details', response_model=DocumentResponse)
+async def put_bank_details_document(
+    organization_id: str,
+    file: UploadFile = File(...),
+    auth: AdminAuthContext = Depends(require_admin_role('compliance', 'superadmin')),
+    command: PutOrganizationDocumentCommand = Depends(get_put_organization_document_command),
+    s3: S3DocumentsService = Depends(get_s3_documents_service),
+):
+    return await _put_document(
+        organization_id=organization_id,
+        document_type='bank_details',
+        file=file,
+        command=command,
+        s3=s3,
+    )
+
+
+@documents_router.put('/kyc-representative', response_model=DocumentResponse)
+async def put_kyc_representative_document(
+    organization_id: str,
+    file: UploadFile = File(...),
+    auth: AdminAuthContext = Depends(require_admin_role('compliance', 'superadmin')),
+    command: PutOrganizationDocumentCommand = Depends(get_put_organization_document_command),
+    s3: S3DocumentsService = Depends(get_s3_documents_service),
+):
+    return await _put_document(
+        organization_id=organization_id,
+        document_type='kyc_representative',
+        file=file,
+        command=command,
+        s3=s3,
+    )
+
+
+@documents_router.put('/power-of-attorney', response_model=DocumentResponse)
+async def put_power_of_attorney_document(
+    organization_id: str,
+    file: UploadFile = File(...),
+    auth: AdminAuthContext = Depends(require_admin_role('compliance', 'superadmin')),
+    command: PutOrganizationDocumentCommand = Depends(get_put_organization_document_command),
+    s3: S3DocumentsService = Depends(get_s3_documents_service),
+):
+    return await _put_document(
+        organization_id=organization_id,
+        document_type='power_of_attorney',
+        file=file,
+        command=command,
+        s3=s3,
+    )
+
+
+@documents_router.put('/other', response_model=DocumentResponse)
+async def put_other_document(
+    organization_id: str,
+    file: UploadFile = File(...),
+    auth: AdminAuthContext = Depends(require_admin_role('compliance', 'superadmin')),
+    command: PutOrganizationDocumentCommand = Depends(get_put_organization_document_command),
+    s3: S3DocumentsService = Depends(get_s3_documents_service),
+):
+    return await _put_document(
+        organization_id=organization_id,
+        document_type='other',
+        file=file,
+        command=command,
+        s3=s3,
+    )
+
+
+@documents_router.get('/charter', response_model=DocumentResponse)
+async def get_charter_document(
     organization_id: str,
-    document_id: str,
     auth: AdminAuthContext = Depends(require_admin_access),
     command: GetOrganizationDocumentCommand = Depends(get_get_organization_document_command),
     s3: S3DocumentsService = Depends(get_s3_documents_service),
 ):
-    doc = await command(organization_id, document_id)
-    url = await s3.generate_presigned_download_url(key=doc.s3_key)
+    return await _get_document(organization_id, 'charter', command, s3)
+
+
+@documents_router.get('/inn-certificate', response_model=DocumentResponse)
+async def get_inn_certificate_document(
+    organization_id: str,
+    auth: AdminAuthContext = Depends(require_admin_access),
+    command: GetOrganizationDocumentCommand = Depends(get_get_organization_document_command),
+    s3: S3DocumentsService = Depends(get_s3_documents_service),
+):
+    return await _get_document(organization_id, 'inn_certificate', command, s3)
+
+
+@documents_router.get('/ogrn-certificate', response_model=DocumentResponse)
+async def get_ogrn_certificate_document(
+    organization_id: str,
+    auth: AdminAuthContext = Depends(require_admin_access),
+    command: GetOrganizationDocumentCommand = Depends(get_get_organization_document_command),
+    s3: S3DocumentsService = Depends(get_s3_documents_service),
+):
+    return await _get_document(organization_id, 'ogrn_certificate', command, s3)
+
+
+@documents_router.get('/bank-details', response_model=DocumentResponse)
+async def get_bank_details_document(
+    organization_id: str,
+    auth: AdminAuthContext = Depends(require_admin_access),
+    command: GetOrganizationDocumentCommand = Depends(get_get_organization_document_command),
+    s3: S3DocumentsService = Depends(get_s3_documents_service),
+):
+    return await _get_document(organization_id, 'bank_details', command, s3)
+
+
+@documents_router.get('/kyc-representative', response_model=DocumentResponse)
+async def get_kyc_representative_document(
+    organization_id: str,
+    auth: AdminAuthContext = Depends(require_admin_access),
+    command: GetOrganizationDocumentCommand = Depends(get_get_organization_document_command),
+    s3: S3DocumentsService = Depends(get_s3_documents_service),
+):
+    return await _get_document(organization_id, 'kyc_representative', command, s3)
+
+
+@documents_router.get('/power-of-attorney', response_model=DocumentResponse)
+async def get_power_of_attorney_document(
+    organization_id: str,
+    auth: AdminAuthContext = Depends(require_admin_access),
+    command: GetOrganizationDocumentCommand = Depends(get_get_organization_document_command),
+    s3: S3DocumentsService = Depends(get_s3_documents_service),
+):
+    return await _get_document(organization_id, 'power_of_attorney', command, s3)
+
+
+@documents_router.get('/other', response_model=DocumentResponse)
+async def get_other_document(
+    organization_id: str,
+    auth: AdminAuthContext = Depends(require_admin_access),
+    command: GetOrganizationDocumentCommand = Depends(get_get_organization_document_command),
+    s3: S3DocumentsService = Depends(get_s3_documents_service),
+):
+    return await _get_document(organization_id, 'other', command, s3)
+
+
+async def _get_document(
+    organization_id: str,
+    document_type: str,
+    command: GetOrganizationDocumentCommand,
+    s3: S3DocumentsService,
+) -> DocumentResponse:
+    doc = await command(organization_id, document_type)
+    url = await _document_download_url(s3, doc.s3_key)
     return document_to_response(doc, download_url=url)

src/presentation/routing/organizations.py

@@ -4,7 +4,11 @@ from src.application.commands import (
     CreateOrganizationCommand,
     CreateOrganizationWalletsCommand,
     GetOrganizationCommand,
+    GetOrganizationMnemonicCommand,
+    GetOrganizationSecretKeysCommand,
+    ListOrganizationWalletsCommand,
     ListOrganizationsCommand,
+    SearchPartiesCommand,
     UpdateOrganizationCommand,
 )
 from src.application.domain.dto import AdminAuthContext
@@ -13,15 +17,36 @@ from src.presentation.dependencies.commands import (
     get_create_organization_command,
     get_create_organization_wallets_command,
     get_get_organization_command,
+    get_get_organization_mnemonic_command,
+    get_get_organization_secret_keys_command,
+    get_list_organization_wallets_command,
     get_list_organizations_command,
+    get_search_parties_command,
     get_update_organization_command,
 )
-from src.presentation.schemas.mappers import organization_to_response, wallet_to_response
+from src.presentation.schemas.mappers import (
+    create_wallets_to_response,
+    mnemonic_to_response,
+    organization_to_response,
+    party_search_to_response,
+    secret_key_to_response,
+    wallet_to_response,
+)
 from src.presentation.schemas.organization import (
     CreateOrganizationRequest,
     OrganizationListResponse,
+    DocumentResponse,
     OrganizationResponse,
     UpdateOrganizationRequest,
+)
+from src.presentation.schemas.entity import (
+    CreateWalletsResponse,
+    MnemonicResponse,
+    PartySearchResponse,
+    PartySearchListResponse,
+    PurchaseRequestResponse,
+    PurchaseRequestListResponse,
+    SecretKeyResponse,
     WalletResponse,
 )
 
@@ -32,10 +57,11 @@ organizations_router = APIRouter(prefix='/organizations', tags=['organizations']
 async def list_organizations(
     limit: int = Query(default=50, ge=1, le=200),
     offset: int = Query(default=0, ge=0),
+    q: str | None = Query(default=None, min_length=1, max_length=255),
     auth: AdminAuthContext = Depends(require_admin_access),
     command: ListOrganizationsCommand = Depends(get_list_organizations_command),
 ):
-    items, total = await command(limit=limit, offset=offset)
+    items, total = await command(limit=limit, offset=offset, search=q)
     return OrganizationListResponse(
         items=[organization_to_response(x) for x in items],
         total=total,
@@ -67,6 +93,21 @@ async def create_organization(
     return organization_to_response(org)
 
 
+@organizations_router.get('/search', response_model=PartySearchListResponse)
+async def search_parties(
+    q: str = Query(min_length=1, max_length=255),
+    limit: int = Query(default=50, ge=1, le=200),
+    offset: int = Query(default=0, ge=0),
+    auth: AdminAuthContext = Depends(require_admin_access),
+    command: SearchPartiesCommand = Depends(get_search_parties_command),
+):
+    items, total = await command(query=q, limit=limit, offset=offset)
+    return PartySearchListResponse(
+        items=[party_search_to_response(x) for x in items],
+        total=total,
+    )
+
+
 @organizations_router.get('/{organization_id}', response_model=OrganizationResponse)
 async def get_organization(
     organization_id: str,
@@ -88,9 +129,47 @@ async def update_organization(
     return organization_to_response(org)
 
 
+@organizations_router.get('/{organization_id}/wallets', response_model=list[WalletResponse])
+async def list_organization_wallets(
+    organization_id: str,
+    auth: AdminAuthContext = Depends(require_admin_access),
+    command: ListOrganizationWalletsCommand = Depends(get_list_organization_wallets_command),
+):
+    wallets = await command(organization_id)
+    return [wallet_to_response(w) for w in wallets]
+
+
+@organizations_router.get('/{organization_id}/wallets/mnemonic', response_model=MnemonicResponse)
+async def get_organization_mnemonic(
+    organization_id: str,
+    auth: AdminAuthContext = Depends(require_admin_role('compliance', 'superadmin')),
+    command: GetOrganizationMnemonicCommand = Depends(get_get_organization_mnemonic_command),
+):
+    mnemonic = await command(organization_id)
+    return mnemonic_to_response(mnemonic)
+
+
+@organizations_router.get('/{organization_id}/wallets/secret-keys', response_model=list[SecretKeyResponse])
+async def get_organization_secret_keys(
+    organization_id: str,
+    auth: AdminAuthContext = Depends(require_admin_role('compliance', 'superadmin')),
+    command: GetOrganizationSecretKeysCommand = Depends(get_get_organization_secret_keys_command),
+):
+    keys = await command(organization_id)
+    return [
+        secret_key_to_response(
+            chain=k.chain,
+            address=k.address,
+            derivation_path=k.derivation_path,
+            private_key=k.private_key,
+        )
+        for k in keys
+    ]
+
+
 @organizations_router.post(
     '/{organization_id}/wallets/create',
-    response_model=list[WalletResponse],
+    response_model=CreateWalletsResponse,
     status_code=status.HTTP_201_CREATED,
 )
 async def create_organization_wallets(
@@ -98,5 +177,5 @@ async def create_organization_wallets(
     auth: AdminAuthContext = Depends(require_admin_role('compliance', 'superadmin')),
     command: CreateOrganizationWalletsCommand = Depends(get_create_organization_wallets_command),
 ):
-    wallets = await command(organization_id=organization_id)
-    return [wallet_to_response(w) for w in wallets]
+    result = await command(organization_id=organization_id)
+    return create_wallets_to_response(wallets=result.wallets, mnemonic=result.mnemonic)

src/presentation/routing/purchase_requests.py

@@ -1,24 +1,30 @@
 from fastapi import APIRouter, Depends, Query, status
 
 from src.application.commands import (
+    CreatePurchaseRequestCommand,
     GetPurchaseRequestCommand,
     ListPurchaseRequestsCommand,
     SetPurchaseRequestQuoteCommand,
+    UpdatePurchaseRequestCommand,
     UpdatePurchaseRequestStatusCommand,
 )
 from src.application.domain.dto import AdminAuthContext
 from src.presentation.decorators.admin_auth import require_admin_access, require_admin_role
 from src.presentation.dependencies.commands import (
+    get_create_purchase_request_command,
     get_get_purchase_request_command,
     get_list_purchase_requests_command,
     get_set_purchase_request_quote_command,
+    get_update_purchase_request_command,
     get_update_purchase_request_status_command,
 )
 from src.presentation.schemas.mappers import purchase_request_to_response
-from src.presentation.schemas.organization import (
+from src.presentation.schemas.entity import (
+    CreatePurchaseRequestBody,
     PurchaseRequestListResponse,
     PurchaseRequestResponse,
     SetPurchaseRequestQuoteBody,
+    UpdatePurchaseRequestBody,
     UpdatePurchaseRequestStatusBody,
 )
 
@@ -46,6 +52,29 @@ async def list_purchase_requests(
     )
 
 
+@purchase_requests_router.post('', response_model=PurchaseRequestResponse, status_code=status.HTTP_201_CREATED)
+async def create_purchase_request(
+    body: CreatePurchaseRequestBody,
+    auth: AdminAuthContext = Depends(require_admin_role('compliance', 'superadmin')),
+    command: CreatePurchaseRequestCommand = Depends(get_create_purchase_request_command),
+):
+    item = await command(
+        organization_id=body.organization_id,
+        usdt_amount=body.usdt_amount,
+        status=body.status,
+        rub_amount=body.rub_amount,
+        exchange_rate=body.exchange_rate,
+        service_fee_percent=body.service_fee_percent,
+        comment=body.comment,
+        admin_comment=body.admin_comment,
+        target_wallet_chain=body.target_wallet_chain,
+        target_wallet_address=body.target_wallet_address,
+        tx_hash=body.tx_hash,
+        assigned_to=body.assigned_to,
+    )
+    return purchase_request_to_response(item)
+
+
 @purchase_requests_router.get('/{request_id}', response_model=PurchaseRequestResponse)
 async def get_purchase_request(
     request_id: str,
@@ -56,6 +85,17 @@ async def get_purchase_request(
     return purchase_request_to_response(item)
 
 
+@purchase_requests_router.patch('/{request_id}', response_model=PurchaseRequestResponse)
+async def update_purchase_request(
+    request_id: str,
+    body: UpdatePurchaseRequestBody,
+    auth: AdminAuthContext = Depends(require_admin_role('compliance', 'superadmin')),
+    command: UpdatePurchaseRequestCommand = Depends(get_update_purchase_request_command),
+):
+    item = await command(request_id, values=body.model_dump(exclude_unset=True))
+    return purchase_request_to_response(item)
+
+
 @purchase_requests_router.patch('/{request_id}/status', response_model=PurchaseRequestResponse)
 async def update_purchase_request_status(
     request_id: str,

src/presentation/routing/users.py

@@ -1,17 +1,116 @@
-from fastapi import APIRouter, Depends, Request
+from fastapi import APIRouter, Depends, Request, Query, status
 from fastapi.responses import ORJSONResponse
 from starlette import status
-from src.presentation.dependencies.commands import get_set_password_command
+
+from src.application.domain.dto import AdminAuthContext
+from src.presentation.decorators.admin_auth import require_admin_access, require_admin_role
+from src.presentation.dependencies.commands import (
+    get_set_password_command,
+    get_list_users_command,
+    get_get_user_command,
+    get_list_user_wallets_command,
+    get_get_user_mnemonic_command,
+    get_get_user_secret_keys_command,
+)
+from src.presentation.schemas.mappers import (
+    mnemonic_to_response,
+    user_to_response,
+    party_search_to_response,
+    secret_key_to_response,
+    wallet_to_response,
+)
+from src.presentation.schemas.user import (
+    UserResponse,
+    UserListResponse,
+)
+from src.presentation.schemas.entity import (
+    PartySearchResponse,
+    MnemonicResponse,
+    PartySearchListResponse,
+    SecretKeyResponse,
+    WalletResponse,
+)
 from src.application.commands.set_password import SetPasswordCommand
-from presentation.schemas.password import SetPasswordRequest
+from src.application.commands.user_commands import (
+    ListUsersCommand,
+    GetUserCommand,
+)
+from src.application.commands.user_wallet_commands import (
+    ListUserWalletsCommand,
+    GetUserMnemonicCommand,
+    GetUserSecretKeysCommand
+)
+from src.presentation.schemas.password import SetPasswordRequest
 
 users_router = APIRouter(prefix='/users', tags=['users'])
 
-@users_router.patch(path='/password', response_class=ORJSONResponse, status_code=status.HTTP_200_OK)
+@users_router.get('', response_model=UserListResponse)
+async def list_users(
+    limit: int = Query(default=50, ge=1, le=200),
+    offset: int = Query(default=0, ge=0),
+    q: str | None = Query(default=None, min_length=1, max_length=255),
+    auth: AdminAuthContext = Depends(require_admin_access),
+    command: ListUsersCommand = Depends(get_list_users_command),
+):
+    items, total = await command(limit=limit, offset=offset, search=q)
+    return UserListResponse(
+        items=[user_to_response(x) for x in items],
+        total=total,
+    )
+
+@users_router.get('/{user_id}', response_model=UserResponse)
+async def get_user(
+    user_id: str,
+    auth: AdminAuthContext = Depends(require_admin_access),
+    command: GetUserCommand = Depends(get_get_user_command),
+):
+    user = await command(user_id)
+    return user_to_response(user)
+
+@users_router.get('/{user_id}/wallets', response_model=list[WalletResponse])
+async def list_user_wallets(
+    user_id: str,
+    auth: AdminAuthContext = Depends(require_admin_access),
+    command: ListUserWalletsCommand = Depends(get_list_user_wallets_command),
+):
+    wallets = await command(user_id)
+    return [wallet_to_response(w) for w in wallets]
+
+
+@users_router.get('/{user_id}/wallets/mnemonic', response_model=MnemonicResponse)
+async def get_user_mnemonic(
+    user_id: str,
+    auth: AdminAuthContext = Depends(require_admin_role('compliance', 'superadmin')),
+    command: GetUserMnemonicCommand = Depends(get_get_user_mnemonic_command),
+):
+    mnemonic = await command(user_id)
+    return mnemonic_to_response(mnemonic)
+
+
+@users_router.get('/{user_id}/wallets/secret-keys', response_model=list[SecretKeyResponse])
+async def get_user_secret_keys(
+    user_id: str,
+    auth: AdminAuthContext = Depends(require_admin_role('compliance', 'superadmin')),
+    command: GetUserSecretKeysCommand = Depends(get_get_user_secret_keys_command),
+):
+    keys = await command(user_id)
+    return [
+        secret_key_to_response(
+            chain=k.chain,
+            address=k.address,
+            derivation_path=k.derivation_path,
+            private_key=k.private_key,
+        )
+        for k in keys
+    ]
+
+@users_router.patch(path='/{user_id}/set_password', response_class=ORJSONResponse, status_code=status.HTTP_200_OK)
 async def set_password(
-    request: Request,
+    user_id: str,
+    request: Request, 
     body: SetPasswordRequest,
+    auth: AdminAuthContext = Depends(require_admin_role('compliance', 'superadmin')),
     command: SetPasswordCommand = Depends(get_set_password_command),
 ):
-    await command(email=body.email, password=body.password)
+    await command(user_id=user_id, password=body.password)
     return ORJSONResponse(content={'message': 'Password updated successfully'})

src/presentation/schemas/entity.py

@@ -0,0 +1,115 @@
+from __future__ import annotations
+
+from decimal import Decimal
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+class PartySearchResponse(BaseModel):
+    id: str
+    account_type: str
+    user_id: str
+    email: str | None
+    name: str | None
+    inn: str | None
+    phone: str | None
+    status: str | None
+    kyc_verified: bool | None
+    created_at: str | None
+
+
+class PartySearchListResponse(BaseModel):
+    items: list[PartySearchResponse]
+    total: int
+
+
+class WalletResponse(BaseModel):
+    id: str
+    chain: str
+    address: str
+    derivation_path: str
+    created_at: str | None
+
+
+class CreateWalletsResponse(BaseModel):
+    wallets: list[WalletResponse]
+    mnemonic: str
+
+
+class MnemonicResponse(BaseModel):
+    mnemonic: str
+
+
+class SecretKeyResponse(BaseModel):
+    chain: str
+    address: str
+    derivation_path: str
+    private_key: str
+
+
+class CreatePurchaseRequestBody(BaseModel):
+    organization_id: str
+    usdt_amount: Decimal = Field(gt=0)
+    status: str = 'submitted'
+    rub_amount: Decimal | None = Field(default=None, gt=0)
+    exchange_rate: Decimal | None = Field(default=None, gt=0)
+    service_fee_percent: Decimal | None = Field(default=None, ge=0)
+    comment: str | None = None
+    admin_comment: str | None = None
+    target_wallet_chain: str | None = Field(default='ETH', max_length=16)
+    target_wallet_address: str | None = Field(default=None, max_length=128)
+    tx_hash: str | None = Field(default=None, max_length=128)
+    assigned_to: str | None = None
+
+
+class UpdatePurchaseRequestStatusBody(BaseModel):
+    status: str
+    admin_comment: str | None = None
+    assigned_to: str | None = None
+    tx_hash: str | None = None
+
+
+class UpdatePurchaseRequestBody(BaseModel):
+    status: str | None = None
+    usdt_amount: Decimal | None = Field(default=None, gt=0)
+    rub_amount: Decimal | None = Field(default=None, gt=0)
+    exchange_rate: Decimal | None = Field(default=None, gt=0)
+    service_fee_percent: Decimal | None = Field(default=None, ge=0)
+    comment: str | None = None
+    admin_comment: str | None = None
+    target_wallet_chain: str | None = Field(default=None, max_length=16)
+    target_wallet_address: str | None = Field(default=None, max_length=128)
+    tx_hash: str | None = Field(default=None, max_length=128)
+    assigned_to: str | None = None
+
+
+class SetPurchaseRequestQuoteBody(BaseModel):
+    rub_amount: Decimal = Field(gt=0)
+    exchange_rate: Decimal = Field(gt=0)
+    service_fee_percent: Decimal | None = None
+    admin_comment: str | None = None
+
+
+class PurchaseRequestResponse(BaseModel):
+    id: str
+    organization_id: str
+    status: str
+    usdt_amount: str
+    rub_amount: str | None
+    exchange_rate: str | None
+    service_fee_percent: str | None
+    comment: str | None
+    admin_comment: str | None
+    target_wallet_chain: str | None
+    target_wallet_address: str | None
+    tx_hash: str | None
+    assigned_to: str | None
+    created_at: str | None
+    updated_at: str | None
+    completed_at: str | None
+
+
+class PurchaseRequestListResponse(BaseModel):
+    items: list[PurchaseRequestResponse]
+    total: int

src/presentation/schemas/mappers.py

@@ -2,14 +2,27 @@ from __future__ import annotations
 
 from src.application.domain.entities.organization import (
     LegalEntityEntity,
-    OrganizationDocumentEntity,
+    OrganizationDocumentSlot,
     OrganizationWalletEntity,
+    PartySearchEntity,
     PurchaseRequestEntity,
 )
+from src.application.domain.entities.user import (
+    UserEntity,
+)
+from src.presentation.schemas.user import (
+    UserResponse,
+)
 from src.presentation.schemas.organization import (
     DocumentResponse,
     OrganizationResponse,
+)
+from src.presentation.schemas.entity import (
+    CreateWalletsResponse,
+    MnemonicResponse,
+    PartySearchResponse,
     PurchaseRequestResponse,
+    SecretKeyResponse,
     WalletResponse,
 )
 
@@ -38,6 +51,21 @@ def organization_to_response(entity: LegalEntityEntity) -> OrganizationResponse:
     )
 
 
+def party_search_to_response(entity: PartySearchEntity) -> PartySearchResponse:
+    return PartySearchResponse(
+        id=entity.id,
+        account_type=entity.account_type,
+        user_id=entity.user_id,
+        email=entity.email,
+        name=entity.name,
+        inn=entity.inn,
+        phone=entity.phone,
+        status=entity.status,
+        kyc_verified=entity.kyc_verified,
+        created_at=entity.created_at.isoformat() if entity.created_at else None,
+    )
+
+
 def wallet_to_response(entity: OrganizationWalletEntity) -> WalletResponse:
     return WalletResponse(
         id=entity.id,
@@ -48,20 +76,44 @@ def wallet_to_response(entity: OrganizationWalletEntity) -> WalletResponse:
     )
 
 
+def create_wallets_to_response(*, wallets: list[OrganizationWalletEntity], mnemonic: str) -> CreateWalletsResponse:
+    return CreateWalletsResponse(
+        wallets=[wallet_to_response(w) for w in wallets],
+        mnemonic=mnemonic,
+    )
+
+
+def mnemonic_to_response(mnemonic: str) -> MnemonicResponse:
+    return MnemonicResponse(mnemonic=mnemonic)
+
+
+def secret_key_to_response(
+    *,
+    chain: str,
+    address: str,
+    derivation_path: str,
+    private_key: str,
+) -> SecretKeyResponse:
+    return SecretKeyResponse(
+        chain=chain,
+        address=address,
+        derivation_path=derivation_path,
+        private_key=private_key,
+    )
+
+
 def document_to_response(
-    entity: OrganizationDocumentEntity,
+    entity: OrganizationDocumentSlot,
     *,
     download_url: str | None = None,
 ) -> DocumentResponse:
     return DocumentResponse(
-        id=entity.id,
         organization_id=entity.organization_id,
         document_type=entity.document_type,
+        s3_key=entity.s3_key,
         file_name=entity.file_name,
         content_type=entity.content_type,
         file_size_bytes=entity.file_size_bytes,
-        uploaded_by=entity.uploaded_by,
-        created_at=entity.created_at.isoformat() if entity.created_at else None,
         download_url=download_url,
     )
 
@@ -85,3 +137,23 @@ def purchase_request_to_response(entity: PurchaseRequestEntity) -> PurchaseReque
         updated_at=entity.updated_at.isoformat() if entity.updated_at else None,
         completed_at=entity.completed_at.isoformat() if entity.completed_at else None,
     )
+
+def user_to_response(entity: UserEntity) -> UserResponse:
+    return UserResponse(
+        id=entity.id,
+        email=entity.email,
+        first_name=entity.first_name,
+        middle_name=entity.middle_name,
+        last_name=entity.last_name,
+        birth_date=entity.birth_date,
+        phone=entity.phone,
+        passport_data=entity.passport_data,
+        inn=entity.inn,
+        avatar_link=entity.avatar_link,
+        account_type=entity.account_type,
+        kyc_verified=entity.kyc_verified,
+        is_deleted=entity.is_deleted,
+        created_at=entity.created_at.isoformat() if entity.created_at else None,
+        updated_at=entity.updated_at.isoformat() if entity.updated_at else None,
+        kyc_verified_at=entity.kyc_verified_at.isoformat() if entity.kyc_verified_at else None,
+    )

src/presentation/schemas/organization.py

@@ -62,59 +62,11 @@ class OrganizationListResponse(BaseModel):
     total: int
 
 
-class WalletResponse(BaseModel):
-    id: str
-    chain: str
-    address: str
-    derivation_path: str
-    created_at: str | None
-
-
 class DocumentResponse(BaseModel):
-    id: str
     organization_id: str
     document_type: str
-    file_name: str
-    content_type: str
-    file_size_bytes: int
-    uploaded_by: str | None
-    created_at: str | None
+    s3_key: str | None
+    file_name: str | None
+    content_type: str | None = None
+    file_size_bytes: int | None = None
     download_url: str | None = None
-
-
-class UpdatePurchaseRequestStatusBody(BaseModel):
-    status: str
-    admin_comment: str | None = None
-    assigned_to: str | None = None
-    tx_hash: str | None = None
-
-
-class SetPurchaseRequestQuoteBody(BaseModel):
-    rub_amount: Decimal = Field(gt=0)
-    exchange_rate: Decimal = Field(gt=0)
-    service_fee_percent: Decimal | None = None
-    admin_comment: str | None = None
-
-
-class PurchaseRequestResponse(BaseModel):
-    id: str
-    organization_id: str
-    status: str
-    usdt_amount: str
-    rub_amount: str | None
-    exchange_rate: str | None
-    service_fee_percent: str | None
-    comment: str | None
-    admin_comment: str | None
-    target_wallet_chain: str | None
-    target_wallet_address: str | None
-    tx_hash: str | None
-    assigned_to: str | None
-    created_at: str | None
-    updated_at: str | None
-    completed_at: str | None
-
-
-class PurchaseRequestListResponse(BaseModel):
-    items: list[PurchaseRequestResponse]
-    total: int

src/presentation/schemas/password.py

@@ -4,7 +4,6 @@ from src.application.domain.password_policy import validate_password_strength
 
 
 class SetPasswordRequest(BaseModel):
-    email: str
     password: str
 
     @field_validator('password')

src/presentation/schemas/user.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from decimal import Decimal
+from typing import Any
+
+from datetime import date, datetime
+
+from pydantic import BaseModel, Field
+
+
+class UserResponse(BaseModel):
+    id: str | None = Field(None, description='Идентификатор пользователя')
+    email: str | None = Field(None, description='Email')
+    first_name: str | None = Field(None, description='Имя')
+    middle_name: str | None = Field(None, description='Отчество')
+    last_name: str | None = Field(None, description='Фамилия')
+    birth_date: date | None = Field(None, description='Дата рождения')
+    phone: str | None = Field(None, description='Телефон')
+    passport_data: str | None = Field(None, description='Паспортные данные')
+    inn: str | None = Field(None, description='ИНН')
+    avatar_link: str | None = Field(None, description='HTTPS-ссылка на текущий аватар в хранилище')
+    account_type: str | None = Field(None, description='Тип аккаунта')
+    kyc_verified: bool | None = Field(None, description='Признак пройденного KYC')
+    is_deleted: bool | None = Field(None, description='Удалён ли аккаунт')
+    created_at: datetime | None = Field(None, description='Время создания записи')
+    updated_at: datetime | None = Field(None, description='Время последнего обновления')
+    kyc_verified_at: datetime | None = Field(None, description='Время подтверждения KYC')
+
+
+class UserListResponse(BaseModel):
+    items: list[UserResponse]
+    total: int