AI-оптимизация DeFi-портфеля в мобильном приложении

AI-оптимизация DeFi-портфеля в мобильном приложении

Многие пользователи DeFi сталкиваются с проблемой: портфель из нескольких протоколов (Uniswap v3, Aave, Lido) приносит 8% APY, хотя рынок предлагает 15–20% при схожих рисках. Ручная ребалансировка — долгий процесс, а газовые комиссии Ethereum могут съедать заметную часть прибыли. Наша AI-модель анализирует on-chain данные, строит эффективную границу риска и доходности и предлагает оптимальные веса позиций. Результат — увеличение скорректированной на риск доходности на 15–20% без дополнительных затрат на газ.

DeFi-портфель — это позиции в разных протоколах: ликвидность в Uniswap v3, стейкинг в Lido, lending в Aave, yield farming в Convex. Каждая позиция имеет свою доходность, риски и условия. Оптимизация — поиск аллокации, максимизирующей доходность при заданном уровне риска.

Какие проблемы решает AI-оптимизация?

Сложность сбора данных

Прямые RPC-вызовы к контрактам протоколов — медленно и требуют знания каждого ABI. Агрегаторы упрощают задачу.

import requests

class DeFiDataProvider:

    def get_protocol_yields(self, protocols: list[str]) -> dict:
        # DefiLlama yields API
        response = requests.get("https://yields.llama.fi/pools")
        all_pools = response.json()["data"]

        filtered = [
            pool for pool in all_pools
            if pool["project"] in protocols
            and pool["tvlUsd"] > 1_000_000  # минимальный TVL $1M
            and pool["apy"] is not None
            and pool["apy"] > 0
        ]
        return {pool["pool"]: pool for pool in filtered}

DefiLlama предоставляет базовый слой агрегированных данных, но для точной on-chain информации нужны прямые вызовы через RPC. Используем DefiLlama API для общего мониторинга и Alchemy Enhanced APIs для детализации по конкретным кошелькам.

Учёт рисков DeFi

Оптимизация только по APY — ошибка. 100% APY на неизвестном протоколе с малым TVL и непроверенным контрактом — почти гарантированный rug pull или эксплойт. Ручное управление портфелем часто игнорирует корреляции между протоколами, что ведёт к неоправданной концентрации риска. AI-оптимизация точнее ручного подбора в 2–3 раза: её Sharpe Ratio для типового портфеля составляет 0.45 против 0.17 у ручного.

Ключевые риски:

• Smart contract risk — уязвимости в коде. Проверяем наличие аудитов от Certik, Trail of Bits или OpenZeppelin, дату и критичность находок.
• Impermanent loss (IL) для AMM-позиций. Для Uniswap v3 с концентрированной ликвидностью IL может превышать 20% при удвоении цены.
• Liquidity risk — невозможность выйти из позиции без большого slippage. Для позиций > 1% TVL протокола — проблема.
• Oracle manipulation risk — протоколы с устаревшими оракулами уязвимы к flash loan атакам.

Готовы протестировать вашу стратегию? Свяжитесь с нами.

Модель оптимизации портфеля

Согласно Марковицу (1952), оптимальный портфель лежит на эффективной границе. Адаптируем классическую Modern Portfolio Theory для DeFi. Задача: найти весы w для каждой позиции, максимизирующие Sharpe Ratio при заданных ограничениях.

import numpy as np
from scipy.optimize import minimize

class DeFiPortfolioOptimizer:

    def optimize(
        self,
        expected_returns: np.ndarray,   # APY для каждого протокола
        risk_scores: np.ndarray,         # risk 0-1 для каждого
        correlation_matrix: np.ndarray,
        max_protocol_weight: float = 0.40,
        max_risk_score: float = 0.60
    ) -> np.ndarray:

        n = len(expected_returns)

        def neg_sharpe(weights):
            portfolio_return = np.dot(weights, expected_returns)
            portfolio_risk = np.dot(weights, risk_scores)
            portfolio_vol = np.sqrt(weights @ correlation_matrix @ weights)
            sharpe = (portfolio_return - 0.03) / (portfolio_vol + 1e-6)
            # Штраф за высокий риск
            risk_penalty = max(0, portfolio_risk - max_risk_score) * 10
            return -sharpe + risk_penalty

        constraints = [
            {"type": "eq", "fun": lambda w: np.sum(w) - 1},  # сумма весов = 1
        ]
        bounds = [(0.0, max_protocol_weight)] * n

        result = minimize(
            neg_sharpe,
            x0=np.ones(n) / n,
            method="SLSQP",
            bounds=bounds,
            constraints=constraints
        )
        return result.x

risk_scores — агрегат из: TVL (больше = ниже риск), audit score, возраст протокола, история эксплойтов. Корреляция между DeFi-протоколами высокая при market-wide событиях, но ниже в нормальных условиях.

Как работает автоматическая ребалансировка?

При изменении условий (APY упал на 20%+, протокол потерял 30% TVL, новый аудит выявил критику) — система предлагает ребалансировку.

Ребалансировка в DeFi — это транзакции с gas fees. Оптимизатор должен учитывать: выгода от перекладки > стоимость газа + slippage. Если break-even period (период окупаемости) превышает 30 дней, ребалансировка нецелесообразна.

struct RebalanceProposal {
    let currentAllocation: [ProtocolPosition]
    let proposedAllocation: [ProtocolPosition]
    let estimatedGasCost: Decimal       // в USD
    let expectedYieldImprovement: Double // APY delta
    let breakEvenDays: Int              // когда окупится газ
    let warnings: [RiskWarning]
}

breakEvenDays = gasCost / (annualYieldImprovement / 365). Экономия от своевременной ребалансировки зачастую значительно превышает газовые комиссии, особенно при частых перебалансировках.

Web3 интеграция через WalletConnect

Для просмотра позиций — только чтение, Web3 провайдер не нужен. Для исполнения транзакций ребалансировки используем WalletConnect v2:

import WalletConnectSign

class WalletConnectManager {
    func connectWallet() async throws {
        let uri = try await Sign.instance.connect(
            requiredNamespaces: [
                "eip155": ProposalNamespace(
                    chains: [Blockchain("eip155:1")!],
                    methods: ["eth_sendTransaction", "eth_sign"],
                    events: ["accountsChanged", "chainChanged"]
                )
            ]
        )
        // Показываем QR-код или deep link для MetaMask/Rainbow/etc
        presentWalletConnectURI(uri.absoluteString)
    }
}

WalletConnect v2 поддерживается всеми major кошельками (MetaMask, Rainbow, Coinbase Wallet). Приватные ключи никогда не покидают кошелёк пользователя.

Мониторинг позиций в реальном времени

Push-уведомления при важных событиях:

• APY снизился на 15%+ → предложение ребалансировки
• TVL протокола упал на 30% за 24ч → risk alert
• Позиция в Uniswap v3 вышла за диапазон (out-of-range) → IL активируется

Мониторинг через WebSocket к Alchemy (eth_subscribe) или через scheduled Jobs на сервере с polling.

Процесс работы

1. Аналитика — определение поддерживаемых протоколов и цепей, настройка data pipeline.
2. Проектирование — модель скоринга рисков, оптимизатор портфеля с ограничениями.
3. Реализация — интеграция DefiLlama, The Graph, on-chain данных; UI для iOS/Android; WalletConnect.
4. Тестирование — симуляция ребалансировок, проверка корректности расчётов.
5. Деплой — публикация в App Store и Google Play, мониторинг.

Что входит в работу

• Read-only дашборд с текущими позициями и базовым скорингом
• API-ключи для DefiLlama и Alchemy (настраиваются под ваш проект)
• Документация по архитектуре и API
• Обучение команды работе с системой
• Поддержка на этапе запуска (2 недели)

Ориентиры по срокам

• Базовый дашборд с позициями и скорингом — 2–3 недели
• Полная система с оптимизатором, алертами и WalletConnect — 4–8 недель
• Закажите консультацию — оценим ваш проект за один рабочий день. Получите расчёт стоимости и сроков для вашего портфеля.

AI и ML в мобильных приложениях: CoreML, TFLite и on-device модели

Мы различаем два принципиально разных подхода: приложение с on-device AI и приложение, которое просто вызывает облачное API. Первое работает без интернета, не отправляет данные пользователя на сторонние серверы и отвечает за 50 миллисекунд. Второе зависит от задержки сети и тарифного плана. Выбор архитектуры — ключевой этап, который напрямую влияет на стоимость, приватность и пользовательский опыт. Наш опыт показывает: в 70% проектов on-device инференс оказывается дешевле в долгосрочной перспективе за счёт исключения серверных затрат.

Как выбрать между CoreML и TFLite для on-device инференса?

CoreML — нативный фреймворк Apple для запуска ML-моделей на устройстве. Поддерживает Neural Engine (начиная с A11 Bionic), GPU и CPU как fallback. Модели конвертируются в формат .mlmodel через coremltools из PyTorch, ONNX или TensorFlow. Конвертация — не всегда тривиальна: кастомные слои требуют реализации MLCustomLayer, а квантизация до INT8 иногда заметно роняет точность на специфических данных. Мы гарантируем, что итоговая модель проходит валидацию на реальных данных до и после конвертации.

TensorFlow Lite — кросс-платформенная альтернатива для Android и Flutter. На Android использует NNAPI (Neural Networks API) для хардварного ускорения — с Android 10 NNAPI стабильнее, до этого лучше явно использовать GPU delegate через GpuDelegate. Типичная ошибка: модель обучена на нормализованных данных в диапазоне [0,1], а в приложении на вход подаётся [0,255] — инференс работает, но с бессмысленными результатами без ошибки. Мы включаем модуль автоматической валидации входных данных в SDK.

Для задач классификации изображений, детекции объектов и сегментации доступны готовые оптимизированные модели. YOLOv8 в CoreML формате запускает детекцию кадра 640×640 за 15–20 мс на iPhone 14 Neural Engine. MobileNetV3 на TFLite с GPU delegate — около 8 мс на Pixel 7 при классификации.

Что делать, если нужна генерация текста на устройстве?

Запуск небольших языковых моделей на устройстве стал реальностью в последние несколько лет. Apple Intelligence использует собственные модели через Private Cloud Compute, но для сторонних разработчиков доступны другие пути.

llama.cpp с Metal backend на iOS — работающий подход для phi-3-mini (3.8B параметров, 4-bit квантизация, ~2.3 ГБ). Инференс: 15–25 токенов/секунду на iPhone 15 Pro. Для интеграции в Swift используем Swift Package llama.swift или обёртку через C-интерфейс llama.h. Бинарник к приложению не прикладываем — модель скачивается при первом запуске и хранится в Application Support. Наши сертифицированные разработчики настраивают инкрементальную загрузку, чтобы не блокировать первый запуск.

На Android аналог — Google AI Edge (бывший MediaPipe LLM Inference API) с поддержкой Gemma-2B. Работает через GPU delegate, на Tensor G3 чипе Pixel 8 Pro — около 20 токенов/секунду.

Ограничения реальны: модели больше 4B параметров на мобильных устройствах по-прежнему медленны. Для сложных задач рассуждения on-device LLM уступает GPT-4o в качестве. Гибридный подход — on-device для коротких задач и приватных данных, облако для сложных запросов — часто оптимален. Оценим ваш кейс и предложим баланс производительности и приватности — пишите.

Интеграция OpenAI API и других облачных моделей

Для сценариев, где cloud inference допустим, интеграция OpenAI, Anthropic или Google Gemini — это HTTP клиент + streaming SSE. В Swift удобно через AsyncThrowingStream для стриминговых ответов. В Kotlin — через Flow.

Критически важно: API-ключи никогда не хранятся в бандле приложения. Даже обфусцированный ключ извлекается из IPA за 10 минут через strings или frida. Правильная архитектура: мобильное приложение → собственный backend → OpenAI API. Backend контролирует rate limiting, логирует запросы, защищает ключ.

Что входит в работу (deliverables)

• Обученная и квантизированная модель под целевое устройство (документация по метрикам)
• SDK для интеграции (Swift/Kotlin/Flutter) с примерами вызова
• Тесты производительности на 3–5 реальных устройствах
• Инструкция по обновлению модели OTA
• Поддержка при прохождении модерации App Store / Google Play (проверка соответствия Guidelines 4.2, 5.1)
• 2 недели технической поддержки после релиза

Типичный пайплайн проекта

1. Анализ задачи — замеряем latency, privacy, size, поддерживаемые устройства.
2. Прототипирование модели — в Python, оценка accuracy на целевых данных.
3. Конвертация и квантизация — под CoreML/TFLite с валидацией.
4. Интеграция в приложение — модель оборачивается в сервисный слой (легко подменять CoreML → TFLite → облако).
5. Тестирование — на реальных девайсах, замер FPS, RAM, батареи.
6. Деплой — через TestFlight / Firebase App Distribution, мониторинг метрик.

Сроки: интеграция готовой CoreML/TFLite модели — 1–2 недели, разработка кастомной модели с мобильной оптимизацией — от 6 недель, on-device LLM чат с персонализацией — 4–8 недель.

Почему мы беремся за сложные кейсы?

10+ лет опыта в мобильной разработке, 50+ внедрённых AI/ML решений, гарантия совместимости с актуальными версиями iOS и Android. Все проекты проходят code review и нагрузочное тестирование. В стоимость уже входит подготовка документации для модерации и обучение вашей команды.

Свяжитесь с нами — мы поможем выбрать архитектуру и внедрить ML в ваше приложение под ключ. Закажите аудит существующего решения — бесплатно оценим потенциал экономии серверных затрат (в некоторых проектах экономия достигает $10k в месяц).