diff --git a/AGENTS.md b/AGENTS.md index 7395863..5da79ad 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -20,7 +20,7 @@ Dépendance JitPack (voir le README) : com.github.Technas-Organization technas-pay-java - v0.1.1 + v0.2.0 ``` @@ -41,6 +41,7 @@ Dépendance JitPack (voir le README) : | Numéro de reversement (administrateur) | `pay.getPayoutNetworks("TG")`, `pay.setPayoutDestination("TG", "moov_tg", "+228…", "Nom")` | | Payer par carte | `.method("card").amount(new BigDecimal("12.50")).currency("EUR")` après `pay.getCardAccount().canAcceptPayments()` | | Ouvrir le compte carte | `pay.startCardOnboarding(returnUrl, refreshUrl, "TG", null, null)`, rediriger le RESPONSABLE vers `url()` | +| Seuil d'identité (marchand) | `pay.getAccountKyc()` : `stage()`, `collectedXof()`, `thresholdXof()`, `deadline()`, `consoleUrl()` ; avis `onKycRequired` (`event.kyc()`) | | Tableau de bord carte | `pay.getCardDashboardLink()` (le responsable s'y connecte avec ses identifiants) | | Tester la route d'avis | `pay.createTestWebhook("payment.completed", "42-1", BigDecimal.valueOf(5000), "XOF")` (corps et en-tête) | | Jouer le payeur en test | `pay.simulateTestPayment(id, "completed" \| "failed" \| "expired")` | @@ -179,6 +180,15 @@ Ce n'est PAS le même parcours que le mobile money. Ne le proposez que si l'util - N'appelez jamais `refund` pour un remboursement déjà fait à la main : le client serait remboursé deux fois. - **Total remboursé** : `payment.refundedAmount()` additionne les deux sortes. +## Seuil d'identité + +- **La règle** : en réel, un compte sans pièce d'identité vérifiée voit ses NOUVEAUX paiements mobile money refusés (`kyc_required`, 409) au-delà d'un montant encaissé en cumul ou d'un nombre de jours après son premier paiement réel encaissé (aujourd'hui 1 000 000 F CFA ou 30 jours). +- **Les chiffres viennent de l'API** : `pay.getAccountKyc()` (`thresholdXof()`, `graceDays()`, `collectedXof()`, `deadline()`). Ne les écrivez jamais en dur. +- **Rien de ce qui existe n'est bloqué** : paiement en cours, remboursement, reversement, lecture. La carte n'est pas concernée. +- **Montrez l'état au MARCHAND** (réglages, tableau de bord), jamais au client final. `stage()` vaut `ok`, `soon` (préavis), `blocked`, `verified` ou `not_applicable`. +- **Branchez `onKycRequired`** : l'avis `account.kyc_required` arrive à 80 % du seuil (`reason` `amount_80`), 7 jours avant l'échéance (`deadline_7d`), puis au premier refus (`blocked`). Prévenez le responsable avec le lien `event.kyc().consoleUrl()`, où il dépose sa pièce. +- **Sur `kyc_required`** : proposez la carte, ou dites au client que le paiement mobile money n'est pas disponible pour le moment. Ne réessayez pas. + ## Erreurs - `card_account_not_ready` (409) : paiement par carte demandé sans compte carte actif. Voir « Paiement par carte ». @@ -201,6 +211,8 @@ Ce n'est PAS le même parcours que le mobile money. Ne le proposez que si l'util | `fx_mode_unavailable`, `fx_channel_unavailable` | Mode `converted` pas ouvert : proposer `local` (avec l'accord de l'utilisateur sur le risque) ou rester en `none` | | `quote_expired` | Le client rechoisit son pays sur la page, rien à faire côté code | | `reference_conflict` | Même référence, autres valeurs : ne pas réutiliser la référence | +| `kyc_required` | Pièce d'identité à déposer : `e.details().get("consoleUrl")`, `reason` (`amount` ou `duration`). Proposer la carte ; ne pas réessayer | +| `contract_required` | Le responsable doit accepter le contrat dans la console (`e.details().get("version")`) ; ne pas réessayer | | `payment_in_progress` | Réessayer dans une minute, même appel | | `payment_not_found`, `refund_not_found` | Mauvais identifiant ou autre compte | | `payment_expired` | Cette référence est un essai expiré : nouveau paiement avec une NOUVELLE référence, jamais le même appel | diff --git a/CHANGELOG.md b/CHANGELOG.md index 97c453a..4bb33bd 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,9 @@ # Journal +## 0.2.0 (15/11/2026) + +Seuil d'identité : `getAccountKyc()` (`GET /v1/account/kyc`), avis `account.kyc_required` (`onKycRequired`, `event.kyc()`), précisions `consoleUrl` (`kyc_required`) et `version` (`contract_required`) dans `details()`. + ## 0.1.1 (15/11/2026) Installation par JitPack réparée (Maven épinglé par le wrapper). Aucun changement de code. diff --git a/README.md b/README.md index 812b446..2a24651 100644 --- a/README.md +++ b/README.md @@ -24,7 +24,7 @@ Maven : com.github.Technas-Organization technas-pay-java - v0.1.1 + v0.2.0 ``` @@ -32,7 +32,7 @@ Gradle (Kotlin) : ```kotlin repositories { maven("https://jitpack.io") } -dependencies { implementation("com.github.Technas-Organization:technas-pay-java:v0.1.1") } +dependencies { implementation("com.github.Technas-Organization:technas-pay-java:v0.2.0") } ``` Technas vous remet **un secret**. Mettez-le dans les variables d'environnement du serveur : @@ -83,7 +83,7 @@ ResponseEntity> webhook(@RequestBody String raw, // } ``` -Fonctions disponibles : `onCompleted`, `onFailed` (pas définitif), `onExpired` (définitif), `onRefund`, `onTopUp`, `onPayoutDestination`, `onBalanceConverted`, `onFxModeUpdated`, `onCardAccountUpdated`. Une exception dans votre fonction doit remonter : Technas relivrera. +Fonctions disponibles : `onCompleted`, `onFailed` (pas définitif), `onExpired` (définitif), `onRefund`, `onTopUp`, `onPayoutDestination`, `onBalanceConverted`, `onFxModeUpdated`, `onCardAccountUpdated`, `onKycRequired`. Une exception dans votre fonction doit remonter : Technas relivrera. Kotlin : @@ -141,6 +141,7 @@ Exemples complets, compilés en CI : [`examples/spring-boot`](examples/spring-bo | `setCountryRules(allowed, excluded)` | Où vous vendez | | `getPayoutNetworks(country)`, `getPayoutDestination()`, `setPayoutDestination(...)` | Numéro de reversement | | `startCardOnboarding(...)`, `getCardAccount()`, `getCardDashboardLink()` | Compte carte et son tableau de bord | +| `getAccountKyc()` | Seuil d'identité : encaissé, seuil, échéance, lien de la console | | `verifyWebhook(raw, sig)`, `handleWebhook(...)`, `createTestWebhook(...)` | Avis signés | | `simulateTestPayment(id, "completed" \| "failed" \| "expired")` | Jouer le payeur en test | @@ -160,6 +161,10 @@ try { Codes et conduite à tenir : [AGENTS.md](AGENTS.md#erreurs). +## Seuil d'identité + +En réel, un compte sans pièce d'identité vérifiée voit ses NOUVEAUX paiements mobile money refusés (`kyc_required`) au-delà d'un montant encaissé ou d'un nombre de jours après son premier paiement réel (aujourd'hui 1 000 000 F CFA ou 30 jours : lisez-les dans `getAccountKyc()`, ne les écrivez pas en dur). Rien de ce qui existe n'est bloqué, et la carte n'est pas concernée. `getAccountKyc()` donne l'état à montrer au marchand ; l'avis `account.kyc_required` (`onKycRequired`, contenu `event.kyc()`) arrive à 80 % du seuil, 7 jours avant l'échéance, puis au premier refus. Le responsable dépose sa pièce dans la console (`consoleUrl()`). + ## La règle de relance **Une référence = un essai.** `failed` n'est pas définitif : le client peut encore payer sur la même page pendant une heure. Ne relancez qu'après `payment.expired`, avec une nouvelle référence. diff --git a/examples/kotlin-spring/pom.xml b/examples/kotlin-spring/pom.xml index fa6e0d9..1f68966 100644 --- a/examples/kotlin-spring/pom.xml +++ b/examples/kotlin-spring/pom.xml @@ -28,7 +28,7 @@ fr.technas technas-pay - 0.1.1 + 0.2.0 diff --git a/examples/spring-boot/pom.xml b/examples/spring-boot/pom.xml index 975a14d..25e0ea8 100644 --- a/examples/spring-boot/pom.xml +++ b/examples/spring-boot/pom.xml @@ -23,7 +23,7 @@ fr.technas technas-pay - 0.1.1 + 0.2.0 diff --git a/llms.txt b/llms.txt index b545889..4e5f4b7 100644 --- a/llms.txt +++ b/llms.txt @@ -1,6 +1,6 @@ # technas-pay-java (Java, Kotlin) -> SDK Java 17+ et Kotlin (côté serveur : Spring Boot, Quarkus, Micronaut, Ktor) pour encaisser du mobile money en Afrique et des paiements par carte via Technas Pay, rembourser et recharger son solde. Une dépendance (jackson-databind). Montant seul, en F CFA : la devise (XOF ou XAF) suit le pays du client. Installation depuis GitHub par JitPack : com.github.Technas-Organization:technas-pay-java:v0.1.1. +> SDK Java 17+ et Kotlin (côté serveur : Spring Boot, Quarkus, Micronaut, Ktor) pour encaisser du mobile money en Afrique et des paiements par carte via Technas Pay, rembourser et recharger son solde. Une dépendance (jackson-databind). Montant seul, en F CFA : la devise (XOF ou XAF) suit le pays du client. Installation depuis GitHub par JitPack : com.github.Technas-Organization:technas-pay-java:v0.2.0. Agents de code : lisez d'abord AGENTS.md. diff --git a/pom.xml b/pom.xml index eb84d8f..3f3a279 100644 --- a/pom.xml +++ b/pom.xml @@ -4,7 +4,7 @@ 4.0.0 fr.technas technas-pay - 0.1.1 + 0.2.0 Technas Pay Encaisser du mobile money et des paiements par carte via Technas Pay depuis Java ou Kotlin (Spring Boot, Jakarta Servlet). https://github.com/Technas-Organization/technas-pay-java diff --git a/src/main/java/fr/technas/pay/TechnasPay.java b/src/main/java/fr/technas/pay/TechnasPay.java index 4157f2d..0ee3704 100644 --- a/src/main/java/fr/technas/pay/TechnasPay.java +++ b/src/main/java/fr/technas/pay/TechnasPay.java @@ -9,6 +9,7 @@ import fr.technas.pay.http.JdkTransport; import fr.technas.pay.http.Transport; import fr.technas.pay.internal.Json; +import fr.technas.pay.model.AccountKyc; import fr.technas.pay.model.CardAccount; import fr.technas.pay.model.CardOnboardingLink; import fr.technas.pay.model.Customer; @@ -49,7 +50,7 @@ * } */ public final class TechnasPay { - public static final String VERSION = "0.1.1"; + public static final String VERSION = "0.2.0"; public static final String DEFAULT_BASE_URL = "https://pay-api.technas.fr"; public static final String SECRET_ENV = "TECHNAS_PAY_SECRET"; private static final Pattern SECRET = Pattern.compile("^tps_(live|test)_([\\x21-\\x2d\\x2f-\\x7e]+)\\.([\\x21-\\x2d\\x2f-\\x7e]+)$"); // ASCII imprimable sans « . » @@ -152,7 +153,7 @@ private static TechnasPayException fromResponse(int status, JsonNode d) { details.put(k[1], n); } } - for (String[] k : new String[][] {{"currency", "currency"}, {"reason", "reason"}, {"risk", "risk"}, {"account_status", "accountStatus"}}) { + for (String[] k : new String[][] {{"currency", "currency"}, {"reason", "reason"}, {"risk", "risk"}, {"account_status", "accountStatus"}, {"console_url", "consoleUrl"}, {"version", "version"}}) { String v = Json.nstr(d, k[0]); if (v != null) { details.put(k[1], v); @@ -442,6 +443,16 @@ public String getCardDashboardLink() { return Json.str(call("POST", "/v1/card/dashboard-link", Json.object()), "url"); } + // --- Seuil d'identité ---------------------------------------------------------------------- + + /** + * Où en est le seuil d'identité du compte : encaissé, seuil, échéance, et la console où + * déposer la pièce. Le même état que la console et que l'avis {@code account.kyc_required}. + */ + public AccountKyc getAccountKyc() { + return AccountKyc.fromJson(call("GET", "/v1/account/kyc", null)); + } + // --- Avis signés --------------------------------------------------------------------------- /** Vérifie la signature sur le corps BRUT et rend l'événement. Lève {@link WebhookVerificationException} (répondez 400). */ diff --git a/src/main/java/fr/technas/pay/TechnasPayException.java b/src/main/java/fr/technas/pay/TechnasPayException.java index 6100816..d4af309 100644 --- a/src/main/java/fr/technas/pay/TechnasPayException.java +++ b/src/main/java/fr/technas/pay/TechnasPayException.java @@ -41,7 +41,8 @@ public int status() { /** * Précisions selon le code : {@code missingAmount} et {@code currency} ({@code insufficient_balance}), - * {@code refundableAmount}, {@code reason}, {@code risk}, {@code accountStatus}. + * {@code refundableAmount}, {@code reason}, {@code risk}, {@code accountStatus}, {@code consoleUrl} + * ({@code kyc_required}), {@code version} ({@code contract_required}). */ public Map details() { return Map.copyOf(details); diff --git a/src/main/java/fr/technas/pay/model/AccountKyc.java b/src/main/java/fr/technas/pay/model/AccountKyc.java new file mode 100644 index 0000000..48cdc56 --- /dev/null +++ b/src/main/java/fr/technas/pay/model/AccountKyc.java @@ -0,0 +1,37 @@ +package fr.technas.pay.model; + +import com.fasterxml.jackson.databind.JsonNode; +import fr.technas.pay.internal.Json; +import java.math.BigDecimal; + +/** + * Le seuil d'identité du compte ({@code GET /v1/account/kyc}). En réel, un compte sans pièce + * vérifiée voit ses NOUVEAUX paiements mobile money refusés ({@code kyc_required}) au-delà de + * {@code thresholdXof} F CFA encaissés ou de {@code graceDays} jours après son premier paiement réel. + * Rien de ce qui existe n'est bloqué ; la carte n'est pas concernée. Montrez-le au MARCHAND, + * jamais au client final. Les chiffres viennent de l'API : ne les écrivez pas en dur. + * + * @param stage {@code ok}, {@code soon} (préavis), {@code blocked}, {@code verified}, {@code not_applicable} + * @param level {@code none}, {@code identity}, {@code business} + * @param reason {@code amount}, {@code duration}, ou {@code null} tant que rien n'est bloqué + * @param consoleUrl où le responsable dépose sa pièce + */ +public record AccountKyc( + boolean applies, String stage, String level, Integer daysElapsed, BigDecimal warnFromXof, String warnFromDate, + BigDecimal collectedXof, BigDecimal thresholdXof, Integer graceDays, String firstCollectedAt, String deadline, + String waiverUntil, boolean blocked, String reason, String consoleUrl) { + + public static AccountKyc fromJson(JsonNode r) { + return new AccountKyc( + Json.bool(r, "applies"), Json.str(r, "stage"), Json.str(r, "level"), integer(r, "days_elapsed"), + Json.num(r, "warn_from_xof"), Json.nstr(r, "warn_from_date"), Json.num(r, "collected_xof"), + Json.num(r, "threshold_xof"), integer(r, "grace_days"), Json.nstr(r, "first_collected_at"), + Json.nstr(r, "deadline"), Json.nstr(r, "waiver_until"), Json.bool(r, "blocked"), Json.nstr(r, "reason"), + Json.nstr(r, "console_url")); + } + + static Integer integer(JsonNode r, String k) { + BigDecimal v = Json.nnum(r, k); + return v == null ? null : v.intValue(); + } +} diff --git a/src/main/java/fr/technas/pay/model/KycNotice.java b/src/main/java/fr/technas/pay/model/KycNotice.java new file mode 100644 index 0000000..b2031aa --- /dev/null +++ b/src/main/java/fr/technas/pay/model/KycNotice.java @@ -0,0 +1,20 @@ +package fr.technas.pay.model; + +import com.fasterxml.jackson.databind.JsonNode; +import fr.technas.pay.internal.Json; +import java.math.BigDecimal; + +/** + * Contenu de l'avis {@code account.kyc_required} : envoyé à 80 % du seuil, 7 jours avant + * l'échéance, puis au premier refus. Prévenez le responsable du compte. + * + * @param reason {@code amount_80}, {@code deadline_7d} ou {@code blocked} + */ +public record KycNotice(String reason, BigDecimal collectedXof, BigDecimal thresholdXof, String deadline, boolean blocked, + String consoleUrl) { + + public static KycNotice fromJson(JsonNode r) { + return new KycNotice(Json.str(r, "reason"), Json.num(r, "collected_xof"), Json.num(r, "threshold_xof"), + Json.nstr(r, "deadline"), Json.bool(r, "blocked"), Json.nstr(r, "console_url")); + } +} diff --git a/src/main/java/fr/technas/pay/webhook/Event.java b/src/main/java/fr/technas/pay/webhook/Event.java index 6243fc6..7bc0a33 100644 --- a/src/main/java/fr/technas/pay/webhook/Event.java +++ b/src/main/java/fr/technas/pay/webhook/Event.java @@ -3,6 +3,7 @@ import com.fasterxml.jackson.databind.JsonNode; import fr.technas.pay.internal.Json; import fr.technas.pay.model.CardAccount; +import fr.technas.pay.model.KycNotice; import fr.technas.pay.model.Payment; import fr.technas.pay.model.Refund; import java.util.Map; @@ -13,7 +14,7 @@ * doublon. */ public record Event(String id, String type, String createdAt, Map data, - Payment payment, Refund refund, CardAccount cardAccount) { + Payment payment, Refund refund, CardAccount cardAccount, KycNotice kyc) { static Event parse(JsonNode raw) { if (raw == null || !raw.isObject() || Json.nstr(raw, "id") == null || Json.nstr(raw, "type") == null @@ -25,6 +26,7 @@ static Event parse(JsonNode raw) { Payment payment = null; Refund refund = null; CardAccount card = null; + KycNotice kyc = null; switch (type) { case "payment.completed", "payment.failed", "payment.expired" -> { if (Json.nstr(d, "id") == null) { @@ -34,10 +36,11 @@ static Event parse(JsonNode raw) { } case "refund.completed", "refund.failed", "refund.recorded" -> refund = Refund.fromJson(d); case "card_account.updated" -> card = CardAccount.fromJson(d); + case "account.kyc_required" -> kyc = KycNotice.fromJson(d); default -> { // payout_destination.*, balance.*, fx_mode.updated, types inconnus : `data`. } } - return new Event(Json.str(raw, "id"), type, Json.nstr(raw, "created_at"), Json.map(raw, "data"), payment, refund, card); + return new Event(Json.str(raw, "id"), type, Json.nstr(raw, "created_at"), Json.map(raw, "data"), payment, refund, card, kyc); } } diff --git a/src/main/java/fr/technas/pay/webhook/WebhookHandlers.java b/src/main/java/fr/technas/pay/webhook/WebhookHandlers.java index 98c6ed8..9f0e647 100644 --- a/src/main/java/fr/technas/pay/webhook/WebhookHandlers.java +++ b/src/main/java/fr/technas/pay/webhook/WebhookHandlers.java @@ -23,6 +23,7 @@ public final class WebhookHandlers { private final Consumer onBalanceConverted; private final Consumer onFxModeUpdated; private final Consumer onCardAccountUpdated; + private final Consumer onKycRequired; private WebhookHandlers(Builder b) { onCompleted = b.onCompleted; @@ -34,6 +35,7 @@ private WebhookHandlers(Builder b) { onBalanceConverted = b.onBalanceConverted; onFxModeUpdated = b.onFxModeUpdated; onCardAccountUpdated = b.onCardAccountUpdated; + onKycRequired = b.onKycRequired; } public static Builder builder() { @@ -69,6 +71,9 @@ public Consumer forType(String type) { if ("card_account.updated".equals(type)) { return onCardAccountUpdated; } + if ("account.kyc_required".equals(type)) { + return onKycRequired; + } return null; } @@ -82,6 +87,7 @@ public static final class Builder { private Consumer onBalanceConverted; private Consumer onFxModeUpdated; private Consumer onCardAccountUpdated; + private Consumer onKycRequired; private Builder() { } @@ -136,6 +142,12 @@ public Builder onCardAccountUpdated(Consumer f) { return this; } + /** Seuil d'identité ({@code event.kyc()}) : prévenez le responsable, lien {@code consoleUrl()}. */ + public Builder onKycRequired(Consumer f) { + onKycRequired = f; + return this; + } + public WebhookHandlers build() { return new WebhookHandlers(this); } diff --git a/src/test/java/fr/technas/pay/SeuilKycTest.java b/src/test/java/fr/technas/pay/SeuilKycTest.java new file mode 100644 index 0000000..d49587d --- /dev/null +++ b/src/test/java/fr/technas/pay/SeuilKycTest.java @@ -0,0 +1,118 @@ +package fr.technas.pay; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import fr.technas.pay.model.AccountKyc; +import fr.technas.pay.model.KycNotice; +import fr.technas.pay.model.PaymentRequest; +import fr.technas.pay.webhook.Signature; +import fr.technas.pay.webhook.WebhookHandlers; +import java.math.BigDecimal; +import java.util.ArrayList; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import org.junit.jupiter.api.Test; + +/** Le seuil d'identité : GET /v1/account/kyc, l'avis account.kyc_required, le refus 409 kyc_required. */ +class SeuilKycTest { + static TechnasPay pay(FakeTransport t) { + return ClientTest.pay(t); + } + + @Test + void etatDuSeuilLuEnEntier() { + Map r = new LinkedHashMap<>(); + r.put("applies", true); + r.put("stage", "soon"); + r.put("level", "none"); + r.put("days_elapsed", 24); + r.put("warn_from_xof", 800000); + r.put("warn_from_date", "2026-11-28T00:00:00+00:00"); + r.put("collected_xof", 850000); + r.put("threshold_xof", 1000000); + r.put("grace_days", 30); + r.put("first_collected_at", "2026-11-05T10:00:00+00:00"); + r.put("deadline", "2026-12-05T10:00:00+00:00"); + r.put("waiver_until", null); + r.put("blocked", false); + r.put("reason", null); + r.put("console_url", "https://console.pay.technas.fr/identite"); + FakeTransport t = new FakeTransport().reply(200, r); + AccountKyc k = pay(t).getAccountKyc(); + assertEquals("GET", t.calls.get(0).method()); + assertEquals("https://gw.test/v1/account/kyc", t.calls.get(0).url()); + assertEquals("Bearer " + ClientTest.API_KEY, t.calls.get(0).headers().get("Authorization")); + assertTrue(k.applies()); + assertEquals("soon", k.stage()); + assertEquals("none", k.level()); + assertEquals(24, k.daysElapsed()); + assertEquals(0, new BigDecimal("850000").compareTo(k.collectedXof())); + assertEquals(0, new BigDecimal("1000000").compareTo(k.thresholdXof())); + assertEquals(0, new BigDecimal("800000").compareTo(k.warnFromXof())); + assertEquals(30, k.graceDays()); + assertEquals("2026-12-05T10:00:00+00:00", k.deadline()); + assertNull(k.waiverUntil()); + assertNull(k.reason()); + assertFalse(k.blocked()); + assertEquals("https://console.pay.technas.fr/identite", k.consoleUrl()); + } + + @Test + void compteHorsSeuilEtValeursInconnues() { + FakeTransport t = new FakeTransport().reply(200, Map.of("applies", false, "stage", "nouvelle_etape", "level", "business", + "blocked", false, "console_url", "https://c")); + AccountKyc k = pay(t).getAccountKyc(); + assertFalse(k.applies()); + assertEquals("nouvelle_etape", k.stage()); + assertNull(k.daysElapsed()); + assertNull(k.graceDays()); + assertNull(k.deadline()); + } + + @Test + void avisSigneAppelleOnKycRequired() { + TechnasPay pay = pay(new FakeTransport()); + List seen = new ArrayList<>(); + String body = "{\"id\":\"e\",\"type\":\"account.kyc_required\",\"created_at\":\"x\",\"data\":{\"reason\":\"amount_80\"," + + "\"collected_xof\":800000,\"threshold_xof\":1000000,\"deadline\":\"2026-12-05T10:00:00+00:00\",\"blocked\":false," + + "\"console_url\":\"https://c\"}}"; + var r = pay.handleWebhook(body, Signature.sign(body, ClientTest.WEBHOOK_SECRET), + WebhookHandlers.builder().onKycRequired(e -> seen.add(e.kyc())).build()); + assertEquals(200, r.status()); + assertEquals(1, seen.size()); + assertEquals("amount_80", seen.get(0).reason()); + assertEquals(0, new BigDecimal("800000").compareTo(seen.get(0).collectedXof())); + assertEquals("https://c", seen.get(0).consoleUrl()); + assertFalse(seen.get(0).blocked()); + assertNull(r.event().payment()); + } + + @Test + void refusKycRequiredAvecSesPrecisions() { + Map refus = new LinkedHashMap<>(); + refus.put("code", "kyc_required"); + refus.put("message", "Identity verification is required"); + refus.put("console_url", "https://c"); + refus.put("reason", "amount"); + Map contrat = new LinkedHashMap<>(); + contrat.put("code", "contract_required"); + contrat.put("message", "Accept the agreement"); + contrat.put("version", "2026-11"); + FakeTransport t = new FakeTransport().reply(409, refus).reply(409, contrat); + TechnasPay pay = pay(t); + PaymentRequest req = ClientTest.req("42-1").build(); + TechnasPayException e = assertThrows(TechnasPayException.class, () -> pay.askForPayment(req)); + assertEquals("kyc_required", e.code()); + assertEquals("https://c", e.details().get("consoleUrl")); + assertEquals("amount", e.details().get("reason")); + assertFalse(e.retryable()); + TechnasPayException c = assertThrows(TechnasPayException.class, () -> pay.askForPayment(req)); + assertEquals("contract_required", c.code()); + assertEquals("2026-11", c.details().get("version")); + } +}