Разработка системы учета позиций фонда

Разработка системы учёта позиций фонда

Учёт позиций крипто-фонда — это не «посмотрел баланс на etherscan». Это многомерная задача: позиции распределены по десяткам кошельков и нескольким блокчейнам, значительная часть заблокирована в DeFi-протоколах, стоимость деривативных позиций меняется нелинейно, и всё это нужно агрегировать в реальном времени с корректным расчётом P&L и учётом исторической стоимости для налоговой отчётности.

Готовые решения типа Zapper или DeBank хороши для физических лиц. Для фонда с кастодиальными требованиями, аудитом и собственной методологией расчёта — нужна кастомная система.

Архитектура системы

Система состоит из четырёх слоёв:

Data Layer:    Blockchain Nodes / RPC Providers
               ↓
Indexing:      Position Fetchers (per protocol)
               ↓
Accounting:    Valuation Engine + P&L Calculator
               ↓
Reporting:     API + Dashboard + Audit Export

Data Layer: источники данных

Для каждой позиции нужны разные источники:

Spot holdings (токены на кошельках): eth_call к ERC-20 balanceOf или агрегация через Moralis/Alchemy getTokenBalances. Для мультичейн — параллельные запросы к каждой цепочке.

DeFi positions — самая сложная часть. У каждого протокола своя модель:

Locked/vested positions: vesting контракты, gauge locks (Curve/Velodrome veNFT), staking с lockup. Эти позиции имеют будущую стоимость с временным дисконтом — нужно решить, как учитывать их в NAV.

Position Fetcher: уровень абстракции

Каждый протокол реализует интерфейс PositionFetcher:

interface Position {
    protocol: string
    chain: string
    type: 'spot' | 'lp' | 'lending' | 'borrowing' | 'staking' | 'perp'
    tokens: TokenAmount[]    // составляющие позиции
    valueUsd: Decimal        // текущая стоимость
    metadata: Record<string, unknown>
}

interface PositionFetcher {
    protocol: string
    chains: string[]
    fetch(wallet: string, blockNumber?: number): Promise<Position[]>
}

Пример fetcher для Uniswap V3:

class UniswapV3Fetcher implements PositionFetcher {
    protocol = 'uniswap-v3'
    chains = ['ethereum', 'arbitrum', 'optimism', 'polygon', 'base']

    async fetch(wallet: string, blockNumber?: number): Promise<Position[]> {
        const nfpm = new ethers.Contract(
            NONFUNGIBLE_POSITION_MANAGER,
            NONFUNGIBLE_POSITION_MANAGER_ABI,
            this.provider
        )
        const overrides = blockNumber ? { blockTag: blockNumber } : {}

        // Получение всех LP NFT через Transfer events (от genesis до сейчас)
        const balance = await nfpm.balanceOf(wallet, overrides)
        const tokenIds = await Promise.all(
            Array.from({ length: Number(balance) }, (_, i) =>
                nfpm.tokenOfOwnerByIndex(wallet, i, overrides)
            )
        )

        const positions = await Promise.all(
            tokenIds.map(async (id) => {
                const pos = await nfpm.positions(id, overrides)
                return this.decodePosition(id, pos, wallet, blockNumber)
            })
        )

        return positions.filter(p => p.tokens[0].amount > 0n || p.tokens[1].amount > 0n)
    }

    private async decodePosition(
        tokenId: bigint,
        pos: UniswapV3PositionStruct,
        wallet: string,
        blockNumber?: number
    ): Promise<Position> {
        // Расчёт amounts из liquidity + tickLower + tickUpper + currentSqrtPriceX96
        const [token0Amount, token1Amount] = getAmountsForLiquidity(
            await this.getCurrentSqrtPrice(pos.poolAddress, blockNumber),
            pos.tickLower,
            pos.tickUpper,
            pos.liquidity
        )

        // Накопленные fees (unclaimed)
        const [fees0, fees1] = await this.getUnclaimedFees(tokenId, blockNumber)

        return {
            protocol: 'uniswap-v3',
            chain: this.chain,
            type: 'lp',
            tokens: [
                { token: pos.token0, amount: token0Amount + fees0 },
                { token: pos.token1, amount: token1Amount + fees1 },
            ],
            valueUsd: await this.calculateUsdValue(pos.token0, token0Amount, pos.token1, token1Amount),
            metadata: { tokenId: tokenId.toString(), fee: pos.fee, tickRange: [pos.tickLower, pos.tickUpper] },
        }
    }
}

Оценка стоимости (Valuation Engine)

Источники цен

Для accurate valuation нужна иерархия источников цен:

1. DEX on-chain price (Uniswap V3 TWAP) — манипулируемо при коротком окне, надёжно при 30-минутном TWAP
2. CEX агрегатор (CoinGecko, CoinMarketCap API) — задержка до 5 минут, нет для exotics
3. Pyth Network / Chainlink — on-chain oracle, для позиций которые и так on-chain
4. Manual pricing — для илликвидных токенов, OTC позиций

class ValuationEngine {
    private priceCache = new Map<string, { price: Decimal; timestamp: number }>()

    async getPrice(tokenAddress: string, chain: string): Promise<Decimal> {
        const cacheKey = `${chain}:${tokenAddress}`
        const cached = this.priceCache.get(cacheKey)

        // Кеш 60 секунд для активных рыночных часов
        if (cached && Date.now() - cached.timestamp < 60_000) {
            return cached.price
        }

        const price = await this.fetchPriceWithFallback(tokenAddress, chain)
        this.priceCache.set(cacheKey, { price, timestamp: Date.now() })
        return price
    }

    private async fetchPriceWithFallback(token: string, chain: string): Promise<Decimal> {
        // 1. Попытка получить цену из Uniswap V3 TWAP (30 min)
        try {
            return await this.getUniswapTWAP(token, chain, 1800)
        } catch {}

        // 2. CoinGecko API
        try {
            return await this.getCoinGeckoPrice(token, chain)
        } catch {}

        // 3. Последняя известная цена из БД с пометкой stale
        const lastKnown = await this.db.getLastKnownPrice(token, chain)
        if (lastKnown) {
            this.emitAlert(`STALE_PRICE: ${token} on ${chain}`)
            return lastKnown.price
        }

        throw new Error(`Cannot price token ${token} on ${chain}`)
    }
}

Rebasing tokens

Особый случай — rebasing токены: stETH, aUSDC, aETH. Их баланс меняется каждый блок без Transfer событий. Нужно либо учитывать реальный баланс через balanceOf вместо Transfer-based accounting, либо конвертировать в wrapped версию (wstETH вместо stETH).

P&L расчёт и cost basis

Для налоговой отчётности и performance reporting нужно отслеживать историческую стоимость позиций. Два основных метода:

FIFO (First In, First Out) — для каждой продажи берём стоимость самой ранней купленной порции. Требует полной истории приобретений.

Average Cost Basis — средняя стоимость всех купленных токенов. Проще в расчёте, менее выгоден налогово в растущем рынке.

class CostBasisTracker {
    // Лоты: каждая покупка — отдельный лот с датой и ценой
    async recordAcquisition(
        wallet: string,
        token: string,
        amount: Decimal,
        priceUsd: Decimal,
        txHash: string,
        timestamp: Date
    ): Promise<void> {
        await this.db.query(`
            INSERT INTO cost_basis_lots
                (wallet, token, amount, price_usd, cost_basis_usd, acquired_at, tx_hash)
            VALUES ($1, $2, $3, $4, $3 * $4, $5, $6)
        `, [wallet, token, amount, priceUsd, timestamp, txHash])
    }

    async calculateRealizedPnl(
        wallet: string,
        token: string,
        soldAmount: Decimal,
        soldPriceUsd: Decimal
    ): Promise<{ realizedPnl: Decimal; costBasis: Decimal }> {
        // FIFO: берём лоты в порядке приобретения
        const lots = await this.db.query(`
            SELECT id, amount, price_usd
            FROM cost_basis_lots
            WHERE wallet = $1 AND token = $2 AND remaining_amount > 0
            ORDER BY acquired_at ASC
        `, [wallet, token])

        let remaining = soldAmount
        let totalCostBasis = new Decimal(0)

        for (const lot of lots.rows) {
            if (remaining.lte(0)) break
            const consumed = Decimal.min(remaining, new Decimal(lot.remaining_amount))
            totalCostBasis = totalCostBasis.plus(consumed.mul(lot.price_usd))
            remaining = remaining.minus(consumed)
            await this.updateLotRemainder(lot.id, consumed)
        }

        const proceeds = soldAmount.mul(soldPriceUsd)
        return {
            realizedPnl: proceeds.minus(totalCostBasis),
            costBasis: totalCostBasis,
        }
    }
}

Snapshot и исторический NAV

Для аудита и investor reporting нужны исторические snapshots. Система должна уметь воспроизвести портфель на любую историческую дату:

CREATE TABLE portfolio_snapshots (
    id              BIGSERIAL PRIMARY KEY,
    snapshot_at     TIMESTAMPTZ NOT NULL,
    wallet          VARCHAR(42) NOT NULL,
    block_number    BIGINT NOT NULL,  -- anchor к конкретному блоку
    total_value_usd NUMERIC(20, 6) NOT NULL,
    positions       JSONB NOT NULL,   -- сериализованный список позиций
    prices_used     JSONB NOT NULL    -- цены, использованные для оценки
);

-- Индекс для быстрого поиска NAV за период
CREATE INDEX idx_snapshots_wallet_time
ON portfolio_snapshots (wallet, snapshot_at DESC);

Snapshot по историческому блоку требует архивной ноды (или провайдера с архивным доступом). Alchemy и QuickNode предоставляют историческое состояние через eth_call с blockTag.

Алерты и операционный мониторинг

Система учёта позиций без алертов — это система, которую перестают проверять. Обязательные триггеры:

• Изменение позиции > N% за 15 минут (неожиданная активность)
• Цена токена недоступна более 5 минут (STALE_PRICE)
• Расхождение между on-chain балансом и учётным > 0.1%
• Ликвидация позиции в lending протоколе
• Uniswap V3 позиция вышла за пределы диапазона (out of range LP)

Стек: Node.js / Go бэкенд, PostgreSQL с TimescaleDB, Redis для кеша цен, Grafana дашборд, PagerDuty для критических алертов. Архивный RPC через Alchemy/QuickNode для исторических данных.