Program.cs

// Клиент API AML-скоринга Atlorium — скрининг криптокошелька по адресу и сети.
//
// Запуск (работает сразу, без регистрации — на демо-ключе):
//     dotnet run
//     dotnet run -- 0x26a5919cd0392df875a53873b0323c42094bb216 ETH
//
// Боевой ключ: получить на https://atlorium.com и положить в переменную окружения
// ATLORIUM_API_KEY. Код при этом не меняется.

using System.Globalization;
using System.Net;
using System.Net.Http.Headers;
using System.Net.Http.Json;
using System.Text.Json;
using System.Text.Json.Serialization;

// Публичный демо-ключ. С ним API отвечает правдоподобными МОКАМИ (не реальными
// данными) — чтобы можно было встроить и протестировать интеграцию до оплаты.
// Ответы детерминированы: один и тот же запрос всегда даёт один и тот же результат,
// поэтому на них можно писать стабильные тесты.
const string SandboxKey = "ak_sandbox_demo_mockdata_v1";

var apiKey = Environment.GetEnvironmentVariable("ATLORIUM_API_KEY") ?? SandboxKey;
var baseUrl = Environment.GetEnvironmentVariable("ATLORIUM_BASE_URL") ?? "https://atlorium.com";

using var http = new HttpClient
{
    BaseAddress = new Uri(baseUrl),
    Timeout = TimeSpan.FromSeconds(60),
};
http.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", apiKey);
http.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));

var client = new AmlClient(http);

if (apiKey == SandboxKey)
{
    Console.WriteLine("Демо-ключ: ответы сгенерированы (моки), не реальные данные.\n");
}

var wallet = args.Length > 0 ? args[0] : "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa";
var blockchain = args.Length > 1 ? args[1] : "BTC";

ScreeningResult result;
try
{
    result = await client.ScreenWalletAsync(wallet, blockchain);
}
catch (AtloriumException error)
{
    Console.Error.WriteLine($"Ошибка: {error.Message}");
    return 1;
}

Console.WriteLine($"{result.Blockchain} {result.WalletAddress}");
Console.WriteLine($"  Риск-балл: {result.RiskScore}/100 · severity: {result.Severity} · статус: {result.Status}");

if (!string.IsNullOrEmpty(result.Summary))
{
    Console.WriteLine($"  Резюме: {result.Summary}");
}

Console.WriteLine($"  Санкции: {Report.YesNo(result.SanctionsHit)} · PEP: {Report.YesNo(result.PepCounterparty)}");
Console.WriteLine($"  Оборот: {Report.Money(result.TotalValueUsd)} · комиссии: {Report.Money(result.FeeUsd)}");

Report.PrintExposures("Источники средств", result.SourceOfFunds);
Report.PrintExposures("Назначение средств", result.DestinationOfFunds);

if (result.CounterpartyConnections.Count > 0)
{
    Console.WriteLine("  Контрагенты:");
    foreach (var counterparty in result.CounterpartyConnections)
    {
        Console.WriteLine(
            $"    {Report.OrDash(counterparty.EntityName)} · {Report.OrDash(counterparty.EntityType)}"
            + $" · риск {Report.OrDash(counterparty.RiskLevel)} · {Report.Percent(counterparty.Percentage)}");
    }
}

var gate = ComplianceGate.Evaluate(result);
Console.WriteLine($"\nКОМПЛАЕНС-ГЕЙТ: {gate.Decision}");
foreach (var factor in gate.Factors)
{
    Console.WriteLine($"  {factor}");
}

return 0;

// ── Клиент ───────────────────────────────────────────────────────────────────

/// <summary>Ошибка API: HTTP-код разложен в человекочитаемую причину.</summary>
public sealed class AtloriumException(HttpStatusCode status, string body)
    : Exception($"HTTP {(int)status}: {Explain(status)}. Ответ сервера: {body[..Math.Min(200, body.Length)]}")
{
    public HttpStatusCode Status { get; } = status;

    private static string Explain(HttpStatusCode status) => (int)status switch
    {
        400 => "Адрес или сеть не указаны либо имеют неверный формат (неподдерживаемая сеть, некорректный адрес)",
        401 => "API-ключ отсутствует, просрочен или недействителен",
        402 => "Недостаточно кредитов на балансе — пополните на https://atlorium.com",
        404 => "Объект не найден",
        429 => "Превышен лимит запросов — повторите позже",
        503 => "Сервис AML-скоринга временно недоступен (за сбой на своей стороне мы не списываем деньги)",
        _ => "Неизвестная ошибка",
    };
}

public sealed class AmlClient(HttpClient http)
{
    private static readonly JsonSerializerOptions JsonOptions = new(JsonSerializerDefaults.Web);

    /// <summary>
    /// AML-скрининг кошелька: балл риска 0–100, санкции и PEP, источники и назначение
    /// средств, контрагенты.
    /// </summary>
    /// <remarks>
    /// Это POST с JSON-телом, а не GET: адрес и сеть уходят в теле запроса.
    /// Тарифицируется только успешный скрининг — неверный ввод и недоступность
    /// источника денег не списывают.
    /// </remarks>
    public async Task<ScreeningResult> ScreenWalletAsync(string walletAddress, string blockchain)
    {
        var payload = new ScreeningRequest(walletAddress, blockchain);

        using var response = await http.PostAsJsonAsync("/api/aml/screen", payload, JsonOptions);
        await EnsureSuccessAsync(response);

        return await response.Content.ReadFromJsonAsync<ScreeningResult>(JsonOptions)
               ?? throw new InvalidOperationException("Пустой ответ API.");
    }

    /// <summary>
    /// Проверка ФОРМАТА адреса и поддержки сети — без обращения к блокчейну.
    /// Отвечает на вопрос «можно ли вообще скринить такую пару адрес+сеть»,
    /// а не «существует ли этот адрес».
    /// </summary>
    public async Task<ValidationResult> ValidateWalletAsync(string walletAddress, string blockchain)
    {
        var path = $"/api/aml/validate?walletAddress={Uri.EscapeDataString(walletAddress)}"
                   + $"&blockchain={Uri.EscapeDataString(blockchain)}";

        using var response = await http.GetAsync(path);
        await EnsureSuccessAsync(response);

        return await response.Content.ReadFromJsonAsync<ValidationResult>(JsonOptions)
               ?? throw new InvalidOperationException("Пустой ответ API.");
    }

    private static async Task EnsureSuccessAsync(HttpResponseMessage response)
    {
        if (!response.IsSuccessStatusCode)
        {
            throw new AtloriumException(response.StatusCode, await response.Content.ReadAsStringAsync());
        }
    }
}

// ── Модель запроса и ответа ──────────────────────────────────────────────────

public sealed record ScreeningRequest(
    [property: JsonPropertyName("walletAddress")] string WalletAddress,
    [property: JsonPropertyName("blockchain")] string Blockchain);

/// <summary>Источник или назначение средств: доля, категория, контрагент.</summary>
public sealed record FundExposure
{
    public string? Category { get; init; }
    public double Percentage { get; init; }
    public decimal? AmountUsd { get; init; }
    public string? EntityName { get; init; }
    public string? EntityType { get; init; }
    public string? EntitySubtype { get; init; }
    public int? Hops { get; init; }
    public string? Description { get; init; }
    public bool IsDirect { get; init; }

    /// <summary>incoming — откуда пришли средства, outgoing — куда ушли.</summary>
    public string? ExposureDirection { get; init; }

    /// <summary>direct — прямая связь, indirect — через промежуточные кошельки.</summary>
    public string? ExposureType { get; init; }

    public string? Country { get; init; }
}

/// <summary>Контрагент, с которым кошелёк обменивался средствами.</summary>
public sealed record Counterparty
{
    public string? EntityName { get; init; }
    public string? EntityType { get; init; }
    public string? EntitySubtype { get; init; }
    public string? RiskLevel { get; init; }
    public IReadOnlyList<string> Categories { get; init; } = [];
    public decimal? ReceivedUsd { get; init; }
    public decimal? SentUsd { get; init; }
    public double Percentage { get; init; }
    public bool IsDirect { get; init; }
    public string? Country { get; init; }
}

/// <summary>Карточка AML-скрининга кошелька.</summary>
public sealed record ScreeningResult
{
    public string WalletAddress { get; init; } = "";
    public string Blockchain { get; init; } = "";
    public string ScreeningType { get; init; } = "";

    /// <summary>Балл риска 0–100: 0 — чисто, 100 — максимальный риск.</summary>
    public int RiskScore { get; init; }

    /// <summary>LOW / MEDIUM / HIGH / CRITICAL — словесная градация балла.</summary>
    public string Severity { get; init; } = "";

    public string Status { get; init; } = "";
    public string? Summary { get; init; }
    public string? DominantRiskCategory { get; init; }

    /// <summary>Совпадение с санкционными списками.</summary>
    public bool SanctionsHit { get; init; }

    /// <summary>Среди контрагентов есть публичное должностное лицо (PEP).</summary>
    public bool PepCounterparty { get; init; }

    public decimal? TotalValueUsd { get; init; }
    public decimal? FeeUsd { get; init; }

    public IReadOnlyList<FundExposure> SourceOfFunds { get; init; } = [];
    public IReadOnlyList<FundExposure> DestinationOfFunds { get; init; } = [];
    public IReadOnlyList<Counterparty> CounterpartyConnections { get; init; } = [];

    public long ElapsedMs { get; init; }
}

/// <summary>Результат проверки формата адреса и поддержки сети.</summary>
public sealed record ValidationResult
{
    public string NormalizedAddress { get; init; } = "";
    public string NormalizedBlockchain { get; init; } = "";
    public bool IsValid { get; init; }
    public string Message { get; init; } = "";
}

// ── Применение данных: комплаенс-гейт перед выводом или зачислением средств ───
// Карточка скрининга сама по себе — просто JSON. Ценность появляется, когда по ней
// принимают решение. Ниже — гейт из трёх исходов: ALLOW / REVIEW / BLOCK.

/// <summary>Исход комплаенс-гейта. Порядок важен: чем дальше, тем строже.</summary>
public enum Decision
{
    ALLOW,
    REVIEW,
    BLOCK,
}

/// <summary>Решение комплаенс-гейта и факторы, которые на него повлияли.</summary>
public sealed class GateResult
{
    public Decision Decision { get; private set; } = Decision.ALLOW;

    public List<string> Factors { get; } = [];

    /// <summary>Решение может только ужесточаться: ALLOW → REVIEW → BLOCK.</summary>
    public void Escalate(Decision next)
    {
        if (next > Decision)
        {
            Decision = next;
        }
    }
}

public static class ComplianceGate
{
    // ВНИМАНИЕ: пороги ниже — отправная точка, а не универсальная истина.
    // Настраивайте их под свою риск-политику, юрисдикцию и аппетит к риску.
    private const int ScoreBlock = 75;             // балл >= этого — блокируем
    private const int ScoreReview = 40;            // балл >= этого — на ручную проверку
    private const double ExposureAlertPct = 5.0;   // доля средств из «плохой» категории — уже сигнал

    /// <summary>
    /// Категории источников/назначения средств, которые сами по себе поднимают флаг.
    /// Сравнение по подстроке — коды категорий у провайдеров различаются в написании.
    /// </summary>
    private static readonly string[] HighRiskCategoryKeywords =
    [
        "sanction", "mixer", "tumbler", "darknet", "ransomware",
        "stolen", "scam", "fraud", "terror", "illicit", "hack", "phishing",
    ];

    /// <summary>Пропустить операцию, отправить на ручную проверку или заблокировать.</summary>
    public static GateResult Evaluate(ScreeningResult result)
    {
        var gate = new GateResult();

        // 1. Санкции — безусловный стоп. Никакой низкий балл это не перевешивает.
        if (result.SanctionsHit)
        {
            gate.Escalate(Decision.BLOCK);
            gate.Factors.Add("[!] Санкционное совпадение — блокировка безусловна");
        }
        else
        {
            gate.Factors.Add("[+] Санкционных совпадений нет");
        }

        // 2. Публичное должностное лицо (PEP) среди контрагентов — тоже безусловный стоп:
        //    такие операции требуют отдельного решения комплаенс-офицера, а не автомата.
        if (result.PepCounterparty)
        {
            gate.Escalate(Decision.BLOCK);
            gate.Factors.Add("[!] Контрагент из списка PEP — блокировка безусловна");
        }
        else
        {
            gate.Factors.Add("[+] PEP-контрагентов нет");
        }

        // 3. Балл риска 0–100.
        if (result.RiskScore >= ScoreBlock)
        {
            gate.Escalate(Decision.BLOCK);
            gate.Factors.Add(
                $"[!] Риск-балл {result.RiskScore} >= порога блокировки {ScoreBlock} (severity {result.Severity})");
        }
        else if (result.RiskScore >= ScoreReview)
        {
            gate.Escalate(Decision.REVIEW);
            gate.Factors.Add(
                $"[?] Риск-балл {result.RiskScore} в диапазоне ручной проверки {ScoreReview}–{ScoreBlock - 1}");
        }
        else
        {
            gate.Factors.Add($"[+] Риск-балл {result.RiskScore} ниже порога ручной проверки ({ScoreReview})");
        }

        // 4. Экспозиция на токсичные категории: миксеры, даркнет, вымогатели, краденое.
        //    Балл может быть умеренным, а вот прямая связь с миксером — нет.
        var exposures = result.SourceOfFunds.Concat(result.DestinationOfFunds);
        foreach (var exposure in exposures)
        {
            if (IsHighRiskCategory(exposure.Category) && exposure.Percentage >= ExposureAlertPct)
            {
                gate.Escalate(Decision.REVIEW);
                gate.Factors.Add(
                    $"[?] Экспозиция {Report.Percent(exposure.Percentage)} на категорию «{exposure.Category}»"
                    + $" ({exposure.EntityName ?? "контрагент не назван"})");
            }
        }

        if (!string.IsNullOrEmpty(result.DominantRiskCategory))
        {
            gate.Factors.Add($"[i] Доминирующая категория риска: {result.DominantRiskCategory}");
        }

        return gate;
    }

    private static bool IsHighRiskCategory(string? category)
    {
        var lowered = (category ?? string.Empty).ToLowerInvariant();
        return HighRiskCategoryKeywords.Any(lowered.Contains);
    }
}

// ── Печать отчёта ────────────────────────────────────────────────────────────

public static class Report
{
    private static readonly NumberFormatInfo MoneyFormat = new()
    {
        NumberGroupSeparator = " ",
        NumberDecimalSeparator = ".",
    };

    public static string Money(decimal? value) =>
        value is null ? "н/д" : "$" + value.Value.ToString("N2", MoneyFormat);

    public static string Percent(double value) =>
        value.ToString("F1", CultureInfo.InvariantCulture) + "%";

    public static string OrDash(string? value) => string.IsNullOrEmpty(value) ? "—" : value;

    public static string YesNo(bool value) => value ? "ДА" : "нет";

    public static void PrintExposures(string title, IReadOnlyList<FundExposure> exposures)
    {
        if (exposures.Count == 0)
        {
            return;
        }

        Console.WriteLine($"  {title}:");
        foreach (var exposure in exposures)
        {
            var parts = new List<string>
            {
                Percent(exposure.Percentage),
                OrDash(exposure.Category),
                OrDash(exposure.EntityName),
            };

            if (!string.IsNullOrEmpty(exposure.Description))
            {
                parts.Add(exposure.Description);
            }
            if (!string.IsNullOrEmpty(exposure.Country))
            {
                parts.Add(exposure.Country);
            }

            Console.WriteLine("    " + string.Join(" · ", parts));
        }
    }
}