315 lines
14 KiB
C#
315 lines
14 KiB
C#
using System.Text.Json;
|
|
using Predictalytics.Domain.Entities;
|
|
using Predictalytics.Domain.Enums;
|
|
using Predictalytics.Domain.Interfaces;
|
|
using Predictalytics.Infrastructure.Logging;
|
|
using Microsoft.Extensions.Logging;
|
|
|
|
namespace Predictalytics.Infrastructure.Providers.Polymarket;
|
|
|
|
/// <summary>
|
|
/// Full implementation of IPlatformProvider for Polymarket.
|
|
/// All log entries include Platform=Polymarket for log-file routing.
|
|
/// </summary>
|
|
public class PolymarketProvider : IPlatformProvider
|
|
{
|
|
private readonly PolymarketApiClient _api;
|
|
private readonly ILogger<PolymarketProvider> _logger;
|
|
|
|
public PlatformType Platform => PlatformType.Polymarket;
|
|
public string PlatformName => "Polymarket";
|
|
public bool IsImplemented => true;
|
|
|
|
public PolymarketProvider(PolymarketApiClient api, ILogger<PolymarketProvider> logger)
|
|
{ _api = api; _logger = logger; }
|
|
|
|
public async Task<IReadOnlyList<Trade>> GetTraderTradesAsync(string platformUserId, int limit = 1000, CancellationToken ct = default)
|
|
{
|
|
using var _ = PlatformLogContext.Push(PlatformName);
|
|
_logger.LogDebug("Fetching trades for {Wallet} (limit={Limit})", platformUserId, limit);
|
|
var raw = await _api.GetTradesAsync(platformUserId, limit, ct);
|
|
_logger.LogInformation("Fetched {Count} trades for {Wallet}", raw.Count, platformUserId);
|
|
|
|
var mappedTrades = raw.Select(r =>
|
|
{
|
|
var wallet = r.User ?? r.ProxyWallet ?? "";
|
|
var side = MapTradeSide(r);
|
|
var sideStr = side.ToString().ToUpperInvariant();
|
|
// Compact format: {txHash}_{assetId}_{side} — no wallet in ID to reduce index size.
|
|
// Wallet passed transiently via TransientWallet [NotMapped] for MarketHistoryWorker.
|
|
return new Trade
|
|
{
|
|
Platform = PlatformType.Polymarket,
|
|
PlatformTradeId = string.IsNullOrEmpty(r.TransactionHash)
|
|
? $"{r.Timestamp}_{r.Asset}_{sideStr}"
|
|
: $"{r.TransactionHash}_{r.Asset}_{sideStr}",
|
|
MarketId = r.ConditionId ?? "",
|
|
AssetId = r.Asset ?? "",
|
|
Outcome = r.Outcome ?? "",
|
|
Side = side,
|
|
Price = (decimal)r.Price,
|
|
Size = (decimal)r.Size,
|
|
Amount = (decimal)(r.Price * r.Size),
|
|
ExecutedAt = DateTimeOffset.FromUnixTimeSeconds(r.Timestamp).UtcDateTime,
|
|
TransactionHash = r.TransactionHash,
|
|
TraderId = 0,
|
|
TransientWallet = wallet,
|
|
};
|
|
}).ToList();
|
|
|
|
return mappedTrades.GroupBy(t => t.PlatformTradeId).Select(g => g.First()).ToList();
|
|
}
|
|
|
|
|
|
public async Task<IReadOnlyList<Trade>> GetMarketTradesAsync(string platformMarketId, int limit = 1000, CancellationToken ct = default)
|
|
{
|
|
var raw = await _api.GetMarketTradesAsync(platformMarketId, limit, ct);
|
|
_logger.LogInformation("Fetched {Count} trades for Market {Market} (limit={Limit})", raw.Count, platformMarketId, limit);
|
|
|
|
var mappedTrades = raw.Select(r =>
|
|
{
|
|
var wallet = !string.IsNullOrEmpty(r.User) ? r.User : (r.ProxyWallet ?? "");
|
|
var side = MapTradeSide(r);
|
|
var sideStr = side.ToString().ToUpperInvariant();
|
|
return new Trade
|
|
{
|
|
Platform = PlatformType.Polymarket,
|
|
PlatformTradeId = string.IsNullOrEmpty(r.TransactionHash)
|
|
? $"{r.Timestamp}_{r.Asset}_{sideStr}"
|
|
: $"{r.TransactionHash}_{r.Asset}_{sideStr}",
|
|
MarketId = r.ConditionId ?? "",
|
|
AssetId = r.Asset ?? "",
|
|
Outcome = r.Outcome ?? "",
|
|
Side = side,
|
|
Price = (decimal)r.Price,
|
|
Size = (decimal)r.Size,
|
|
Amount = (decimal)(r.Price * r.Size),
|
|
ExecutedAt = DateTimeOffset.FromUnixTimeSeconds(r.Timestamp).UtcDateTime,
|
|
TransactionHash = r.TransactionHash,
|
|
TraderId = 0,
|
|
TransientWallet = wallet,
|
|
};
|
|
}).ToList();
|
|
|
|
return mappedTrades.GroupBy(t => t.PlatformTradeId).Select(g => g.First()).ToList();
|
|
}
|
|
|
|
public async Task<IReadOnlyList<TraderPositionInfo>> GetTraderPositionsAsync(string platformUserId, CancellationToken ct = default)
|
|
{
|
|
using var _ = PlatformLogContext.Push(PlatformName);
|
|
_logger.LogDebug("Fetching positions for {Wallet}", platformUserId);
|
|
var raw = await _api.GetPositionsAsync(platformUserId, ct);
|
|
_logger.LogInformation("Fetched {Count} positions for {Wallet}", raw.Count, platformUserId);
|
|
|
|
return raw.Select(r => new TraderPositionInfo(
|
|
platformUserId, r.Market, r.Question, r.Outcome,
|
|
(decimal)r.Size, (decimal)r.AvgPrice,
|
|
(decimal)r.CurrentValue, (decimal)r.PercentPnl
|
|
)).ToList();
|
|
}
|
|
|
|
public async Task<IReadOnlyList<DiscoveredTrader>> DiscoverTradersAsync(int limit = 50, CancellationToken ct = default)
|
|
{
|
|
using var _ = PlatformLogContext.Push(PlatformName);
|
|
_logger.LogInformation("Running trader discovery via v1/leaderboard (limit={Limit})...", limit);
|
|
var leaderboard = await _api.GetLeaderboardAsync(limit, ct: ct);
|
|
_logger.LogInformation("Discovery returned {Count} traders from leaderboard", leaderboard.Count);
|
|
|
|
return leaderboard.Select(e => new DiscoveredTrader(
|
|
e.ProxyWallet,
|
|
string.IsNullOrEmpty(e.UserName) ? e.ProxyWallet[..10] + "..." : e.UserName,
|
|
(decimal)e.Vol,
|
|
0, // trade count not in leaderboard API
|
|
0 // win rate computed later from trades
|
|
)).ToList();
|
|
}
|
|
|
|
public async Task<Market?> GetMarketAsync(string platformMarketId, CancellationToken ct = default)
|
|
{
|
|
using var _ = PlatformLogContext.Push(PlatformName);
|
|
_logger.LogDebug("Fetching market {MarketId}", platformMarketId);
|
|
var raw = await _api.GetMarketAsync(platformMarketId, ct);
|
|
if (raw == null)
|
|
{
|
|
_logger.LogWarning("Market {MarketId} not found", platformMarketId);
|
|
return null;
|
|
}
|
|
|
|
_logger.LogInformation("Fetched market: {Question}", raw.Question);
|
|
return MapGammaMarket(raw);
|
|
}
|
|
|
|
public async Task<IReadOnlyList<Market>> GetMarketsAsync(int limit = 100, string? cursor = null, bool includeClosed = false, CancellationToken ct = default)
|
|
{
|
|
using var _ = PlatformLogContext.Push(PlatformName);
|
|
int offset = 0;
|
|
if (!string.IsNullOrEmpty(cursor) && int.TryParse(cursor, out var parsed))
|
|
offset = parsed;
|
|
|
|
_logger.LogInformation("Fetching markets batch (limit={Limit}, offset={Offset}, includeClosed={Closed})", limit, offset, includeClosed);
|
|
var raw = await _api.GetMarketsAsync(limit, offset, includeClosed, ct);
|
|
_logger.LogInformation("Fetched {Count} markets from Gamma API", raw.Count);
|
|
|
|
return raw
|
|
.Where(m => !string.IsNullOrEmpty(m.ConditionId) && !string.IsNullOrEmpty(m.ClobTokenIds))
|
|
.Select(MapGammaMarket)
|
|
.ToList();
|
|
}
|
|
|
|
public async Task<IReadOnlyList<DiscoveredTrader>> GetTopHoldersAsync(string platformMarketId, int limit = 20, CancellationToken ct = default)
|
|
{
|
|
using var _ = PlatformLogContext.Push(PlatformName);
|
|
_logger.LogInformation("Fetching top holders for market {MarketId}", platformMarketId[..12] + "...");
|
|
var holdersGroups = await _api.GetHoldersAsync(platformMarketId, limit, ct);
|
|
|
|
// Flatten all holders across token groups, deduplicate by wallet
|
|
var uniqueHolders = holdersGroups
|
|
.SelectMany(g => g.Holders)
|
|
.GroupBy(h => h.ProxyWallet)
|
|
.Select(g =>
|
|
{
|
|
var first = g.First();
|
|
var totalAmount = g.Sum(h => h.Amount);
|
|
var displayName = !string.IsNullOrEmpty(first.Name) ? first.Name
|
|
: !string.IsNullOrEmpty(first.Pseudonym) ? first.Pseudonym
|
|
: first.ProxyWallet[..10] + "...";
|
|
|
|
return new DiscoveredTrader(
|
|
first.ProxyWallet,
|
|
displayName,
|
|
(decimal)totalAmount,
|
|
0, 0
|
|
);
|
|
})
|
|
.OrderByDescending(d => d.Volume24h)
|
|
.ToList();
|
|
|
|
_logger.LogInformation("Discovered {Count} unique holders from market {MarketId}",
|
|
uniqueHolders.Count, platformMarketId[..12] + "...");
|
|
|
|
return uniqueHolders;
|
|
}
|
|
|
|
// ── Private helpers ──────────────────────────────────────────
|
|
|
|
private Market MapGammaMarket(GammaMarketResponse raw)
|
|
{
|
|
var eventSlug = "";
|
|
if (raw.Events != null && raw.Events.Count > 0 && !string.IsNullOrEmpty(raw.Events[0].Slug))
|
|
{
|
|
eventSlug = raw.Events[0].Slug;
|
|
}
|
|
|
|
var market = new Market
|
|
{
|
|
Platform = PlatformType.Polymarket,
|
|
PlatformMarketId = raw.ConditionId,
|
|
MarketSlug = raw.Slug,
|
|
EventSlug = eventSlug,
|
|
Description = raw.Description,
|
|
ImageUrl = raw.Image,
|
|
Question = raw.Question,
|
|
Category = raw.Category,
|
|
Volume = (decimal)raw.Volume,
|
|
Liquidity = (decimal)raw.Liquidity,
|
|
StartDate = DateTime.TryParse(raw.StartDate, out var sd) ? sd : null,
|
|
EndDate = DateTime.TryParse(raw.EndDate, out var ed) ? ed : null,
|
|
CreatedAt = DateTime.TryParse(raw.CreatedAt, out var cd) ? cd : DateTime.UtcNow,
|
|
DbCreatedAt = DateTime.UtcNow,
|
|
IsResolved = raw.Resolved || raw.Closed, // Prefer resolved flag
|
|
ResolutionOutcome = raw.ResolutionOutcome,
|
|
LastUpdatedAt = DateTime.UtcNow
|
|
};
|
|
|
|
// Parse outcomes, prices, and token IDs from JSON strings
|
|
var outcomeLabels = ParseJsonStringArray(raw.Outcomes);
|
|
var outcomePrices = ParseJsonStringArray(raw.OutcomePrices);
|
|
var tokenIds = ParseJsonStringArray(raw.ClobTokenIds);
|
|
|
|
for (int i = 0; i < outcomeLabels.Count; i++)
|
|
{
|
|
decimal price = 0;
|
|
if (i < outcomePrices.Count)
|
|
decimal.TryParse(outcomePrices[i], System.Globalization.NumberStyles.Any,
|
|
System.Globalization.CultureInfo.InvariantCulture, out price);
|
|
|
|
string tokenId = i < tokenIds.Count ? tokenIds[i] : "";
|
|
|
|
var label = outcomeLabels[i];
|
|
if ((label.Equals("Yes", StringComparison.OrdinalIgnoreCase) || label.Equals("No", StringComparison.OrdinalIgnoreCase))
|
|
&& !string.IsNullOrEmpty(raw.GroupItemTitle))
|
|
{
|
|
label = $"{raw.GroupItemTitle} - {label}";
|
|
}
|
|
|
|
market.Outcomes.Add(new MarketOutcome
|
|
{
|
|
Label = label,
|
|
OutcomeIndex = i,
|
|
TokenId = tokenId,
|
|
CurrentPrice = price
|
|
});
|
|
}
|
|
|
|
return market;
|
|
}
|
|
|
|
private static List<string> ParseJsonStringArray(string? json)
|
|
{
|
|
if (string.IsNullOrEmpty(json)) return [];
|
|
|
|
try
|
|
{
|
|
return JsonSerializer.Deserialize<List<string>>(json) ?? [];
|
|
}
|
|
catch
|
|
{
|
|
return [];
|
|
}
|
|
}
|
|
|
|
private static TradeSide MapTradeSide(PolymarketTradeResponse r)
|
|
{
|
|
// Check Action/Type field first for special operations
|
|
var typeOrAction = !string.IsNullOrEmpty(r.Action) ? r.Action
|
|
: !string.IsNullOrEmpty(r.Type) ? r.Type : "";
|
|
|
|
if (!string.IsNullOrEmpty(typeOrAction))
|
|
{
|
|
if (typeOrAction.Equals("SPLIT", StringComparison.OrdinalIgnoreCase)) return TradeSide.Split;
|
|
if (typeOrAction.Equals("MERGE", StringComparison.OrdinalIgnoreCase)) return TradeSide.Merge;
|
|
if (typeOrAction.Equals("REDEEM", StringComparison.OrdinalIgnoreCase)) return TradeSide.Redeem;
|
|
if (typeOrAction.Equals("ADD_LIQUIDITY", StringComparison.OrdinalIgnoreCase)) return TradeSide.AddLiquidity;
|
|
if (typeOrAction.Equals("REMOVE_LIQUIDITY", StringComparison.OrdinalIgnoreCase)) return TradeSide.RemoveLiquidity;
|
|
// Type field can also contain BUY/SELL directly
|
|
if (typeOrAction.Equals("BUY", StringComparison.OrdinalIgnoreCase)) return TradeSide.Buy;
|
|
if (typeOrAction.Equals("SELL", StringComparison.OrdinalIgnoreCase)) return TradeSide.Sell;
|
|
}
|
|
|
|
// Side field (explicit buy/sell direction)
|
|
if (!string.IsNullOrEmpty(r.Side))
|
|
{
|
|
if (r.Side.Equals("BUY", StringComparison.OrdinalIgnoreCase)) return TradeSide.Buy;
|
|
if (r.Side.Equals("SELL", StringComparison.OrdinalIgnoreCase)) return TradeSide.Sell;
|
|
}
|
|
|
|
return TradeSide.Unknown;
|
|
}
|
|
|
|
public async Task<IReadOnlyList<MarketOutcomePriceSnapshot>> GetPriceHistoryAsync(string tokenId, CancellationToken ct = default)
|
|
{
|
|
using var _ = PlatformLogContext.Push(PlatformName);
|
|
_logger.LogDebug("Fetching price history for CLOB Token {TokenId}", tokenId);
|
|
|
|
var rawHistory = await _api.GetPricesHistoryAsync(tokenId, "6h", ct);
|
|
_logger.LogInformation("Fetched {Count} price history entries for {TokenId}", rawHistory.Count, tokenId);
|
|
|
|
return rawHistory.Select(r => new MarketOutcomePriceSnapshot
|
|
{
|
|
Price = (decimal)r.Price,
|
|
Timestamp = DateTimeOffset.FromUnixTimeSeconds(r.Timestamp).UtcDateTime,
|
|
MarketOutcomeId = 0
|
|
}).ToList();
|
|
}
|
|
}
|