ENINCA API – Cookbook

Collection de snippets prêts à l’emploi : VaR Monte Carlo, diagnostics PRNG, RNG gaming, VDF, imagerie et radar. Chaque exemple suppose que votre clé API est disponible dans l’environnement.

Initialisation

Préchargez l’URL de base et la clé API dans votre shell avant d’appeler l’API.

La clé publique cryptovar-demo est partagée (30 requêtes/minute agrégées). Utilisez votre clé professionnelle pour lever cette limite.

export API_KEY="cryptovar-demo"
export BASE_URL="https://api.eninca.com/api"
export API_KEY="votre_cle_api"
export BASE_URL="https://api.eninca.com/api"

Les commandes suivantes réutilisent ces variables.

VaR Monte Carlo — moteurs disponibles

Paramètres communs : S0 (notionnel), sigma (vol annualisée), T (horizon), N (scénarios, limité à 200 000 sur l’API démo), alpha (quantile), seed.

Seed & replay

Black-Scholes

Desk cash equities : calcule une VaR 99 % sur un portefeuille spot S0=1 000 000, volatilité annualisée σ=18 %, horizon T=1 an avec N=40 000 scénarios.

curl -sS -X POST "$BASE_URL/var/mc" \
  -H "x-api-key: $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
        "S0": 1000000,
        "sigma": 0.18,
        "T": 1.0,
        "N": 40000,
        "alpha": 0.99,
        "seed": 123456,
        "engine": "black_scholes"
      }'

Paramètres spécifiques : aucun paramètre additionnel (formule fermée standard).

Réponse attendue :

{
  "var": 350424.0662330851,
  "audit": {
    "seed": 123456,
    "engine": "black_scholes",
    "engine_params": {},
    "mean": -1737.971857816653,
    "std": 181419.963681516,
    "quantiles": {
      "0.01": -493851.37606559286,
      "0.05": -326300.0455701294,
      "0.50": 14588.75559648202,
      "0.95": 267761.5771606543,
      "0.99": 350424.0662330851
    }
  },
  "audit_proof": "83b281ee25695288180e817ba0b5e72a1b40843165199de640d23f39bf50f25b"
}

Champs de sortie :

Black-Scholes Markov (PRNG certifié)

Équipe conformité : sécurise les replays 99 % avec antithetic=true, une quantisation q=64 et un diagnostic renforcé diagnostic_n=2048 sur N=40 000 scénarios.

curl -sS -X POST "$BASE_URL/var/mc" \
  -H "x-api-key: $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
        "S0": 1000000,
        "sigma": 0.18,
        "T": 1.0,
        "N": 40000,
        "alpha": 0.99,
        "seed": 123456,
        "engine": "black_scholes_markov",
        "engine_params": {"q": 64, "antithetic": true, "diagnostic_n": 2048}
      }'

Ici q=64 contrôle la quantisation interne (précision des classes Markov), antithetic=true active les variates antithétiques, et diagnostic_n=2048 fixe la taille d’échantillon utilisée pour les tests χ² / spectral gap.

Réponse attendue :

{
  "var": 351356.09813849744,
  "audit": {
    "seed": 123456,
    "engine": "black_scholes_markov",
    "engine_params": {
      "q": 64,
      "antithetic": true,
      "diagnostic_n": 2048
    },
    "mean": -1123.8535212268032,
    "std": 181619.48458939727,
    "quantiles": {
      "0.01": -492003.1686996106,
      "0.05": -326567.74720318796,
      "0.50": 14332.879360908526,
      "0.95": 269491.284221378,
      "0.99": 351356.09813849744
    },
    "engine_diagnostics": {
      "chi2": 23.5,
      "p_value": 0.8307172012328028,
      "pslr": 0.19646572716373334,
      "islr": 25.972137362049434,
      "spectral_gap": 0.6153855595617124,
      "uniform_invariance_sup": 0.00532099000833988,
      "tv_bound": 0.054515078822090224,
      "bridge_gap": 0.0,
      "visited_classes": 64,
      "expected_classes": 2,
      "generator": {
        "seed": 211382627,
        "a": 5,
        "b": 3,
        "m": 2147483647,
        "q": 64,
        "lag": 1,
        "antithetic": true
      }
    }
  },
  "audit_proof": "329027dc253627f688e655c94b04fc4bc08a55067f8183e92aa8efdf74e9e93c"
}

Benchmark précision : sur le script python3 scripts/compare_var_precision.py --sizes 10000 20000 40000 --q 64 --diagnostic-n 2048, le moteur Markov réduit l’erreur absolue moyenne d’environ 20 % par rapport au classique.

N Classique – |ΔVaR| moyen Markov – |ΔVaR| moyen Gain
10 000≈0.415≈0.260≈ −37 %
20 000≈0.332≈0.238≈ −28 %
40 000≈0.274≈0.249≈ −9 %

En pratique, N peut être abaissé d’environ 20 % (p.ex. 32 k au lieu de 40 k) tout en restant dans la même tolérance de VaR grâce aux diagnostics Markov (q=64, diagnostic_n=2048).

Champs de sortie :

Heston

Desk volatilité actions : couvre un portefeuille de S0=1 000 000 EUR avec variance stochastique (κ=1.4, θ=6 %, ξ=35 %, ρ=-0.65) sur N=20 000 trajectoires.

curl -sS -X POST "$BASE_URL/var/mc" \
  -H "x-api-key: $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
        "S0": 1000000,
        "sigma": 0.25,
        "T": 1.0,
        "N": 20000,
        "alpha": 0.99,
        "seed": 202401,
        "engine": "heston",
        "engine_params": {"kappa": 1.4, "theta": 0.06, "xi": 0.35, "rho": -0.65}
      }'

Paramètres spécifiques : kappa (vitesse de retour de la variance), theta (variance de long terme), xi (volatilité de la variance), rho (corrélation prix/variance).

Réponse attendue :

{
  "var": 601348.9025327892,
  "audit": {
    "seed": 202401,
    "engine": "heston",
    "engine_params": {
      "kappa": 1.4,
      "theta": 0.06,
      "xi": 0.35,
      "rho": -0.65
    },
    "mean": 108360.35064245,
    "std": 207637.59317914356,
    "quantiles": {
      "0.01": -364721.80886256514,
      "0.05": -218335.9013990688,
      "0.50": 100971.47098496539,
      "0.95": 460852.39573097834,
      "0.99": 601348.9025327892
    }
  },
  "audit_proof": "3f044b00ef094bbfcfea5a9dcea100d98303ccb08b0eb3aa6d7e44615ade5442"
}

Champs de sortie :

SABR

Trader taux vanilles : gère un swaption book S0=5 000 000 avec paramètres α=0.2, β=0.5, ρ=-0.3, ν=0.4 et quantile 97,5 %.

curl -sS -X POST "$BASE_URL/var/mc" \
  -H "x-api-key: $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
        "S0": 5000000,
        "sigma": 0.15,
        "T": 1.0,
        "N": 30000,
        "alpha": 0.975,
        "seed": 424242,
        "engine": "sabr",
        "engine_params": {"alpha": 0.2, "beta": 0.5, "rho": -0.3, "nu": 0.4}
      }'

Paramètres spécifiques : alpha (vol init.), beta (élasticité), rho (corrélation), nu (volatilité de la vol).

Réponse attendue :

{
  "var": 99481.92113135997,
  "audit": {
    "seed": 424242,
    "engine": "sabr",
    "engine_params": {
      "alpha": 0.2,
      "beta": 0.5,
      "rho": -0.3,
      "nu": 0.4
    },
    "mean": 98491.23129911872,
    "std": 458.3354896736675,
    "quantiles": {
      "0.01": 97500.4876989732,
      "0.05": 97798.3131545994,
      "0.50": 98463.19250958366,
      "0.95": 99275.7079056913,
      "0.99": 99751.12112795153
    }
  },
  "audit_proof": "8b2abcfe8e7d39f9fdd65f2659568790eda713f454847d6f10ebb9bf2afc0e77"
}

Champs de sortie :

Local Vol

Structurer equity exotiques : modélise une surface locale avec γ=0.5 sur un notionnel S0=2 000 000, σ=22 %, N=25 000.

curl -sS -X POST "$BASE_URL/var/mc" \
  -H "x-api-key: $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
        "S0": 2000000,
        "sigma": 0.22,
        "T": 1.0,
        "N": 25000,
        "alpha": 0.99,
        "seed": 515151,
        "engine": "local_vol",
        "engine_params": {"gamma": 0.5}
      }'

Paramètres spécifiques : gamma contrôle la fonction de volatilité locale $\sigma(S)=\sigma_0 (S/S_0)^\gamma$.

Réponse attendue :

{
  "var": 759989.4400604449,
  "audit": {
    "seed": 515151,
    "engine": "local_vol",
    "engine_params": {
      "gamma": 0.5
    },
    "mean": -663.6224020187315,
    "std": 456838.1149873902,
    "quantiles": {
      "0.01": -1405121.3487123493,
      "0.05": -840835.7240957285,
      "0.50": 69938.15062889375,
      "0.95": 601255.1156281645,
      "0.99": 759989.4400604449
    }
  },
  "audit_proof": "9de28a813787cb5445f2efc6fe2171573669cff19f570ff61e6c5c44a615ac5a"
}

Champs de sortie :

Hull-White

Desk obligations : projette un portefeuille taux S0=10 000 000 avec paramètres a=0.1 et σ_r=1 % sur N=20 000 trajectoires.

curl -sS -X POST "$BASE_URL/var/mc" \
  -H "x-api-key: $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
        "S0": 10000000,
        "sigma": 0.01,
        "T": 1.0,
        "N": 20000,
        "alpha": 0.99,
        "seed": 606060,
        "engine": "hull_white",
        "engine_params": {"a": 0.1, "sigma_r": 0.01}
      }'

Paramètres spécifiques : a (vitesse de retour du taux court), sigma_r (volatilité du taux court).

Réponse attendue :

{
  "var": 53627.34857243219,
  "audit": {
    "seed": 606060,
    "engine": "hull_white",
    "engine_params": {
      "a": 0.1,
      "sigma_r": 0.01
    },
    "mean": 1526.6521350484334,
    "std": 24857.366934926,
    "quantiles": {
      "0.01": -40109.34394158639,
      "0.05": -20677.94884147925,
      "0.50": 997.4731416637293,
      "0.95": 29434.186385386198,
      "0.99": 40109.34394158639
    }
  },
  "audit_proof": "691fbe445d3586eeacc81cf1c2f6fefe55d7b4e8aaa7f7888bb9b1920615c9ff"
}

Champs de sortie :

Libor Market Model

Banque de marché multi-tenors : simule une couronne de swaps S0=5 000 000 avec factors=3 pour un VaR 99 %.

curl -sS -X POST "$BASE_URL/var/mc" \
  -H "x-api-key: $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
        "S0": 5000000,
        "sigma": 0.12,
        "T": 1.0,
        "N": 30000,
        "alpha": 0.99,
        "seed": 707070,
        "engine": "libor_market_model",
        "engine_params": {"factors": 3}
      }'

Paramètres spécifiques : factors (dimension du modèle LMM).

Réponse attendue :

{
  "var": 896636.9895985333,
  "audit": {
    "seed": 707070,
    "engine": "libor_market_model",
    "engine_params": {
      "factors": 3
    },
    "mean": 18630.692549497377,
    "std": 410846.573414748,
    "quantiles": {
      "0.01": -1023510.0079624152,
      "0.05": -679094.5085008364,
      "0.50": 33634.7769531752,
      "0.95": 662738.6638796977,
      "0.99": 896636.9895985333
    }
  },
  "audit_proof": "195c6e6c07a373b135cdcc622afb04c1f0bac87c73a91e9a46170bbdbe741558"
}

Champs de sortie :

Copula Crédit

Gestionnaire portefeuille crédit : suit n_names=50 noms avec corrélation ρ=0.3, LGD=60 %, intensité λ=2 % sur N=50 000 scénarios.

curl -sS -X POST "$BASE_URL/var/mc" \
  -H "x-api-key: $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
        "S0": 3000000,
        "sigma": 0.05,
        "T": 1.0,
        "N": 50000,
        "alpha": 0.99,
        "seed": 818181,
        "engine": "copula_credit",
        "engine_params": {"n_names": 50, "rho": 0.3, "lgd": 0.6, "hazard": 0.02}
      }'

Paramètres spécifiques : n_names (nombre d'entités), rho (corrélation systémique), lgd (loss given default), hazard (intensité annuelle de défaut).

Réponse attendue :

{
  "var": 779128.9299999997,
  "audit": {
    "seed": 818181,
    "engine": "copula_credit",
    "engine_params": {
      "n_names": 50,
      "rho": 0.3,
      "lgd": 0.6,
      "hazard": 0.02
    },
    "mean": 360000.0,
    "std": 175756.54968832052,
    "quantiles": {
      "0.01": 589278.96,
      "0.05": 636271.9200000002,
      "0.50": 360000.0,
      "0.95": 618000.0,
      "0.99": 779128.9299999997
    }
  },
  "audit_proof": "bf1f79940806e48d8f2e7b3ffb3bc23ac4dfdcaf67e5d0bdcb1c31d4bb4ddbf3"
}

Champs de sortie :

Jump Diffusion

Desk commodities : gère des sauts rares avec λ=0.5, amplitude moyenne -10 %, écart-type 20 % sur un notionnel S0=1.5 M.

curl -sS -X POST "$BASE_URL/var/mc" \
  -H "x-api-key: $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
        "S0": 1500000,
        "sigma": 0.2,
        "T": 1.0,
        "N": 25000,
        "alpha": 0.99,
        "seed": 929292,
        "engine": "jump_diffusion",
        "engine_params": {"lambda": 0.5, "jump_mean": -0.1, "jump_std": 0.2}
      }'

Paramètres spécifiques : lambda (intensité des sauts), jump_mean (moyenne), jump_std (dispersion des sauts).

Réponse attendue :

{
  "var": 662043.9949413682,
  "audit": {
    "seed": 929292,
    "engine": "jump_diffusion",
    "engine_params": {
      "lambda": 0.5,
      "jump_mean": -0.1,
      "jump_std": 0.2
    },
    "mean": -10008.966523921632,
    "std": 334783.39821177046,
    "quantiles": {
      "0.01": -744350.3619379814,
      "0.05": -454836.2867878163,
      "0.50": 19043.335029952188,
      "0.95": 481886.4545133677,
      "0.99": 662043.9949413682
    }
  },
  "audit_proof": "1a86aef2f1430c6df5b35df7d5f4ba290d7d24c5dd4aaa672883852dcf33389c"
}

Champs de sortie :

Variance Gamma

Desk produits structurés : capture les queues épaisses avec θ=0, ν=0.2, κ=0.1 sur S0=1.5 M, N=25 000.

curl -sS -X POST "$BASE_URL/var/mc" \
  -H "x-api-key: $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
        "S0": 1500000,
        "sigma": 0.18,
        "T": 1.0,
        "N": 25000,
        "alpha": 0.99,
        "seed": 939393,
        "engine": "variance_gamma",
        "engine_params": {"theta": 0.0, "nu": 0.2, "kappa": 0.1}
      }'

Paramètres spécifiques : theta (drift gamma), nu (paramètre de variance), kappa (ajustement du drift).

Réponse attendue :

{
  "var": 641730.842942123,
  "audit": {
    "seed": 939393,
    "engine": "variance_gamma",
    "engine_params": {
      "theta": 0.0,
      "nu": 0.2,
      "kappa": 0.1
    },
    "mean": -4503.82233998613,
    "std": 334052.78478343786,
    "quantiles": {
      "0.01": -724168.9289604573,
      "0.05": -450618.8859471118,
      "0.50": 19816.394248092446,
      "0.95": 472304.7089440776,
      "0.99": 641730.842942123
    }
  },
  "audit_proof": "5b6421b601e94d8f840d1754f982e3932a3d4cd6dbd2163707a4d7502f52de73"
}

Champs de sortie :

Bates

Equipe cross-asset : combine volatilité stochastique (κ=1.2, θ=6 %, ξ=25 %, ρ=-0.6) et sauts λ=0.4 pour un book S0=1.5 M.

curl -sS -X POST "$BASE_URL/var/mc" \
  -H "x-api-key: $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
        "S0": 1500000,
        "sigma": 0.22,
        "T": 1.0,
        "N": 25000,
        "alpha": 0.99,
        "seed": 949494,
        "engine": "bates",
        "engine_params": {"kappa": 1.2, "theta": 0.06, "xi": 0.25, "rho": -0.6, "lambda": 0.4}
      }'

Paramètres spécifiques : paramètres Heston plus lambda (intensité des sauts), ainsi que jump_mean/jump_std si spécifiés.

Réponse attendue :

{
  "var": 686586.4333305618,
  "audit": {
    "seed": 949494,
    "engine": "bates",
    "engine_params": {
      "kappa": 1.2,
      "theta": 0.06,
      "xi": 0.25,
      "rho": -0.6,
      "lambda": 0.4
    },
    "mean": 3660.024924368535,
    "std": 346795.59681423457,
    "quantiles": {
      "0.01": -734689.4723485397,
      "0.05": -449872.7146273084,
      "0.50": 17105.170038173943,
      "0.95": 492427.89036529406,
      "0.99": 686586.4333305618
    }
  },
  "audit_proof": "d828d9a416ef3d24df89a679e3fb2b37a20f424d5e5a0226de39cdf7aed5301b"
}

Champs de sortie :

XVA

Desk trésorerie/XVA : agrège une exposition log-normale σ=30 %, spread de financement 1 %, probabilité de défaut 2 %, LGD=60 % sur N=50 000 scénarios.

curl -sS -X POST "$BASE_URL/var/mc" \
  -H "x-api-key: $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
        "S0": 5000000,
        "sigma": 0.0,
        "T": 1.0,
        "N": 50000,
        "alpha": 0.99,
        "seed": 959595,
        "engine": "xva",
        "engine_params": {
          "exposure_sigma": 0.3,
          "funding_spread": 0.01,
          "default_prob": 0.02,
          "lgd": 0.6
        }
      }'

Paramètres spécifiques : exposure_sigma (dispersion log-normale), funding_spread (spread de financement), default_prob (probabilité annuelle de défaut), lgd (loss given default).

Réponse attendue :

{
  "var": 214876.53011844762,
  "audit": {
    "seed": 959595,
    "engine": "xva",
    "engine_params": {
      "exposure_sigma": 0.3,
      "funding_spread": 0.01,
      "default_prob": 0.02,
      "lgd": 0.6
    },
    "mean": 48732.11457233106,
    "std": 83542.6612034427,
    "quantiles": {
      "0.01": -125306.11458390156,
      "0.05": -83412.77592050492,
      "0.50": 47350.90815922681,
      "0.95": 182215.8442608678,
      "0.99": 214876.53011844762
    }
  },
  "audit_proof": "a3f92cb7539864f9955fb15d3bc8c0fb6b54d09b5cf239541db46f327f4f2c18"
}

Champs de sortie :

Rejeu / audit

curl -sS -X POST "$BASE_URL/var/mc/verify" \
  -H "x-api-key: $API_KEY" \
  -H "Content-Type: application/json" \
  -d @run.json

Pour construire la preuve audit_proof, la requête et la réponse sont sérialisées en JSON canonicalisé (clés triées, flottants avec format fixe) avant d’être hachées en SHA-256.

Latence de référence (démo API)

Mesures curl -w "%{time_total}" réalisées sur l’API publique (cryptovar-demo, quota 30 requêtes/minute) depuis un Mac mini M2, en reprenant les charges ci-dessus (seed=123456). Valeurs arrondies au milliseconde.

Moteur 10 000 scénarios 40 000 scénarios Observations
black_scholes≈74 ms≈81 msBaseline fermée, aucun diagnostic additionnel.
black_scholes_markov≈94 ms≈121 msDiagnostics Markov (q=64, diagnostic_n=2048) ajoutent ~30 ms mais permettent de réduire N (~−20 % pour précision équivalente).
heston≈158 ms≈327 ms96 pas d’Euler par trajectoire, variance stochastique.
sabr≈117 ms≈219 msVolatilité stochastique (β=0.5) avec intégration explicite.
local_vol≈99 ms≈198 msSurface locale γ=0.5, cadence proche d’Heston sans variance stochastique.
hull_white≈98 ms≈155 msSchéma taux court mono-factoriel (64 pas).
libor_market_model≈102 ms≈194 msTrois facteurs, intégration log-normale.
copula_credit≈94 ms≈169 msPortefeuille 50 noms, tirages Bernoulli corrélés.
jump_diffusion≈69 ms≈79 msProcessus de Merton (λ=0.5) : surcoût marginal vs Black-Scholes.
variance_gamma≈77 ms≈84 msProcessus gamma variance, coût proche du diffusif pur.
bates≈205 ms≈480 msHeston + sauts : modèle le plus coûteux du panel.
xva≈70 ms≈83 msExpositions log-normales + défaut binomial.

Rejouez le benchmark : curl -s -w "%{http_code} %{time_total}" -o out.json -X POST ... puis testez N=10 000 et N=40 000. Les temps incluent la latence réseau ; en on-premise, le calcul pur est ~20 % plus rapide.

Diagnostics PRNG & RNG Gaming

Tests statistiques (sans Markov)

Analyse rapide d'une séquence fournie : χ², PSLR/ISLR et périodogramme.

curl -sS -X POST "$BASE_URL/prng/metrics" \
  -H "x-api-key: $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
        "sequence": [0.12,0.23,0.34,0.45,0.56,0.67,0.78,0.89],
        "bins": 32,
        "include_periodogram": true
      }'

Réponse attendue :

{
  "chi2": 24.0,
  "p_value": 0.8108844817464183,
  "pslr": 0.625,
  "islr": 2.2976190476190483,
  "periodogram": [
    1.5407439555097887e-33,
    0.1652479364188578,
    0.048400000000000006,
    0.0283520635811422,
    0.024199999999999996
  ]
}

Champs de sortie :

Analyse Markov (générateur affine)

Vérifie la chaîne affine (spectre, invariance uniforme, classes visitées).

curl -sS -X POST "$BASE_URL/prng/markov" \
  -H "x-api-key: $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"seed": 987654321, "q": 64, "n": 4096, "lag": 1}'

Le flux diagnostic_n est prélevé séparément (aucun impact sur la VaR) et renvoie : χ²/p-value, PSLR/ISLR, spectral_gap, uniform_invariance_sup, tv_bound, bridge_gap, visited_classes et expected_classes.

Réponse attendue :

{
  "spectral_gap": 0.6850885210799296,
  "uniform_invariance_sup": 0.004438745269496551,
  "tv_bound": 0.04943530820928698,
  "bridge_gap": 0.0,
  "visited_classes": 64,
  "expected_classes": 2,
  "column_sums": [71.0, 74.0, 60.0, …, 77.0, 71.0],
  "transition": [[0.18309859154929578, 0.0, …], …]
}

Les ellipses signalent des vecteurs tronqués pour lisibilité ; la réponse API complète conserve tous les coefficients.

Champs de sortie :

Certification RNG hash pour gaming

curl -sS -X POST "$BASE_URL/gaming/prng/certify" \
  -H "x-api-key: $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
        "seed": 1337,
        "length": 512,
        "engine": "hash",
        "hash_digest": "sha512",
        "include_metrics": true
      }'

La réponse inclut le sequence_sample, les métriques (χ², PSLR/ISLR) et audit_proof.

VDF – Calcul & Vérification

Génération

curl -sS -X POST "$BASE_URL/vdf/compute" \
  -H "x-api-key: $API_KEY" -H "Content-Type: application/json" \
  -d '{"seed": 20240315, "iterations": 4096}' | tee vdf_out.json

Construire le bundle verify

jq -n --argfile r vdf_out.json '{
  seed: 20240315,
  iterations: 4096,
  result: $r.result,
  proof: $r.proof
}' > vdf_verify.json

Vérification

curl -sS -X POST "$BASE_URL/vdf/verify" \
  -H "x-api-key: $API_KEY" -H "Content-Type: application/json" \
  -d @vdf_verify.json

Reprenez result et proof depuis la génération précédente : aucun placeholder vide ne sera accepté côté verify.

Imagerie – Reconstruction Tikhonov

Script Python qui envoie un patch 8×8 partiellement échantillonné et affiche la reconstruction.

python3 - <<'PY'
import numpy as np
import requests
import os

BASE_URL = os.environ.get("BASE_URL", "https://api.eninca.com/api")
headers = {"x-api-key": os.environ["API_KEY"], "Content-Type": "application/json"}

image = np.random.default_rng(0).random((8, 8)).tolist()
mask = [[1.0 if (i + j) % 2 == 0 else 0.0 for j in range(8)] for i in range(8)]
payload = {"image": image, "mask": mask, "lam": 0.05}

resp = requests.post(f"{BASE_URL}/imaging/tikhonov", json=payload, headers=headers, timeout=30)
resp.raise_for_status()
print(resp.json())
PY

Radar – PSLR / ISLR

curl -sS -X POST "$BASE_URL/radar/metrics" \
  -H "x-api-key: $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
        "pulse_train": [
          1,0,0,0, 0.8,0,0,0,
          1,0,0,0, 0.9,0,0,0
        ]
      }'

Retourne les ratios PSLR/ISLR et les premiers coefficients du périodogramme.

Réponse attendue :

{
  "pslr": 0.7207299445916647,
  "islr": 3.4576005781739356,
  "periodogram": [
    3.0814879110195774e-33,
    0.0006249999999999984,
    0.0056250000000000015,
    0.0006249999999999984,
    0.8556250000000001,
    0.0006249999999999984,
    0.0056250000000000015,
    0.0006249999999999984,
    0.8556250000000001
  ]
}

Champs de sortie :

Schedules d'exécution

Analyse ACF / spectre

curl -sS -X POST "$BASE_URL/var/schedule" \
  -H "x-api-key: $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
        "series": [1.5, 1.7, 1.4, 1.6, 1.8, 1.9, 1.3, 1.2, 1.5, 1.6, 1.4, 1.3],
        "max_lag": 6
      }'

Réponse attendue :

{
  "acf": [
    1.0,
    0.2074944071588368,
    -0.41387024608501116,
    -0.1728187919463088,
    0.37360178970917224,
    0.030760626398210377,
    -0.3255033557046979
  ],
  "periodogram": [
    3.697785493223493e-32,
    0.05620405310722573,
    0.03583333333333335,
    0.14166666666666664,
    0.0008333333333333266,
    0.007129280226107558,
    0.013333333333333343
  ],
  "audit_proof": "e5e573f2caf9a844a40bc7265322abe3848ab7372aafdd7935a75b4fb99f127c"
}

Champs de sortie :

Rejeu d'audit

curl -sS -X POST "$BASE_URL/var/schedule/verify" \
  -H "x-api-key: $API_KEY" \
  -H "Content-Type: application/json" \
  -d @schedule_run.json

MCP adapter (Claude, Cursor, IA)

Exposez CryptoVar dans vos copilotes MCP en local ou via l'instance hébergée wss://api.eninca.com/mcp.

1. Connexion distante (API Eninca)

URLwss://api.eninca.com/mcp
AuthEntête x-api-key: VOTRE_CLE_API
TransportWebSocket TLS (port 443)
Sub-protocolemodelcontextprotocol.2024-05-01

Test en ligne de commande

API_KEY=<votre_cle> npx wscat -c "wss://api.eninca.com/mcp" \
  -H "x-api-key: $API_KEY" -s "modelcontextprotocol.2024-05-01" \
  -x '{"type":"session.create","client":{"name":"wscat","version":"1.0"}}' \
  -x '{"type":"tool.call","id":"var-demo","tool":"var.mc","arguments":{
    "S0":1000000,
    "mu":0.01,
    "sigma":0.18,
    "T":1,
    "N":10000,
    "alpha":0.99,
    "seed":20251026,
    "engine":"black_scholes"
  }}' | jq 'select(.type=="tool.result")'

Réponse attendue (via jq) :

{
  "type": "tool.result",
  "id": "var-demo",
  "content": {
    "var": 340361.35019209306,
    "audit": {
      "seed": 20251026,
      "engine": "black_scholes",
      "engine_params": {},
      "mean": -11468.01141331646,
      "std": 182911.08309257927,
      "quantiles": {
        "0.01": -510235.5098266803,
        "0.05": -334630.5431949785,
        "0.50": 5026.830476838164,
        "0.95": 257935.420783673,
        "0.99": 340361.35019209306
      }
    },
    "audit_proof": "a5a9dda856935a8a59d6ac81adfd8f938d273f2e86b86824c5d5bcbeed3d8560"
  }
}

Claude

  1. Settings → Tools → Add MCP server.
  2. Nom : cryptovar.
  3. URL : wss://api.eninca.com/mcp.
  4. Headers : x-api-key: VOTRE_CLE_API.
  5. Sauvegarder.

Cursor

  1. Settings → Features → MCP Servers → Add.
  2. URL : wss://api.eninca.com/mcp.
  3. Auth headers : x-api-key: VOTRE_CLE_API.
  4. Cocher « Reconnect automatically ».

🧭 Configurer Cursor pour ENINCA MCP

Cursor supporte nativement MCP afin d’interagir directement avec les outils certifiés ENINCA.

⚙️ 1. Activer MCP
  1. Ouvrez Cursor → Settings → Features → MCP Servers.
  2. Cliquez sur Add, puis choisissez Edit configuration file.
  3. Collez la configuration suivante :
{
  "mcpServers": {
    "cryptovar": {
      "transport": "websocket",
      "url": "wss://api.eninca.com/mcp",
      "headers": {
        "x-api-key": "cryptovar-demo"
      }
    }
  }
}

Remplacez cryptovar-demo par votre clé professionnelle. Pour un test local, utilisez ws://127.0.0.1:8700/mcp et supprimez le bloc headers.

🧩 2. Vérifier la connexion
  1. Relancez Cursor.
  2. Ouvrez le panneau Tools.
  3. Vérifiez l’entrée MCP Server: cryptovar avec les outils var.mc, var.mc.verify, radar.metrics, prng.metrics, vdf.compute, etc.
💬 3. Tester un outil ENINCA

Dans le chat Cursor, appelez var.mc avec :

Réponse attendue :

{
  "var": 340361.35,
  "audit.seed": 20251026,
  "audit_proof": "a5a9dda856935a8a59d6ac81adfd8f938d273f2e86b86824c5d5bcbeed3d8560"
}

Enchaînez avec var.mc.verify (mêmes paramètres, plus var, audit et audit_proof). Résultat :

{
  "verify.valid": true
}

2. Mode local (développement hors-ligne)

python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
uvicorn modules.mcp.src.server:app --host 127.0.0.1 --port 8700 --reload

Configurez alors le copilote sur ws://127.0.0.1:8700/mcp (sans entête).

4. Exemple de prompt (VaR + /verify)

<risk manager>
Demande à CryptoVar de calculer une VaR 99% Heston sur 1 000 000 EUR
(sigma 22%, T 0.5, 30k scénarios, seed 20250311) et de produire le bundle /verify.

<assistant>
- Appel cryptovar.var_mc … ✅
- Appel cryptovar.var_mc_verify … ✅

Résultat :
- VaR : 128 450,73 EUR
- audit_proof : b21c…
- verify.valid : true

Depuis la même interface, l’assistant peut enchaîner sur cryptovar.prng_metrics, cryptovar.vdf_compute, ou tout autre outil disponible.

🧠 Exemples d’interactions IA (MCP ENINCA)

1️⃣ VaR certifiée Black-Scholes

Prompt : « Utilise le serveur cryptovar et appelle var.mc avec S0=1_000_000, mu=0.01, sigma=0.18, T=1, N=10_000, alpha=0.99, seed=20251026, engine="black_scholes". Retourne var, audit.seed et audit_proof. »

{
  "var": 340361.35,
  "audit": {
    "seed": 20251026,
    "engine": "black_scholes",
    "engine_params": {},
    "mean": -11468.01,
    "std": 182911.08,
    "quantiles": {
      "0.01": -510235.50,
      "0.05": -334630.54,
      "0.50": 5026.83,
      "0.95": 257935.42,
      "0.99": 340361.35
    }
  },
  "audit_proof": "a5a9dda856935a8a59d6ac81adfd8f938d273f2e86b86824c5d5bcbeed3d8560"
}

Preuve validée : la même requête via var.mc.verify retourne {"verify.valid": true}, confirmant la reproductibilité.

3️⃣ VaR certifiée Black-Scholes Markov

Prompt : « Appelle var.mc avec :

{
  "engine": "black_scholes_markov",
  "S0": 1_000_000,
  "mu": 0.01,
  "sigma": 0.18,
  "T": 1,
  "N": 10_000,
  "alpha": 0.99,
  "seed": 20251026,
  "engine_params": {
    "q": 32,
    "lag": 1,
    "diagnostic_n": 512,
    "antithetic": true,
    "include_metrics": true,
    "a": 16807,
    "b": 0,
    "m": 2147483647
  }
}

Résultat :

{
  "var": 342248.26,
  "audit": {
    "seed": 20251026,
    "engine": "black_scholes_markov",
    "mean": -10483.30,
    "std": 183069.83,
    "quantiles": {
      "0.01": -509015.93,
      "0.05": -340013.56,
      "0.50": 5462.05,
      "0.95": 263684.80,
      "0.99": 342248.26
    },
    "engine_diagnostics": {
      "chi2": 17.375,
      "p_value": 0.2966,
      "spectral_gap": 0.7543,
      "uniform_invariance_sup": 0.0216,
      "visited_classes": 32
    }
  },
  "audit_proof": "cd8130569579ec5109f4099488984ee159e6835a4162164fd1d16ab4a6011965"
}

Les diagnostics valident le générateur (p-value ≈ 0.30, spectral_gap ≈ 0.75). Une vérification via var.mc.verify renvoie {"verify.valid": true} et confirme la preuve.

Notebook Google Colab

Copiez ce bloc dans un notebook Colab pour enchaîner automatiquement les cinq étapes :

import json
import requests

API_KEY = "cryptovar-demo"
BASE_URL = "https://api.eninca.com/api"
headers = {"x-api-key": API_KEY, "Content-Type": "application/json"}

# 1. Préparer les paramètres (bundle Risk)
params = {
    "S0": 1_000_000,
    "sigma": 0.18,
    "T": 1.0,
    "N": 40_000,
    "alpha": 0.99,
    "seed": 123456,
    "engine": "black_scholes_markov",
}
with open("params.json", "w") as f:
    json.dump(params, f, indent=2)

# 2. Calculer la VaR et enregistrer la sortie
resp = requests.post(f"{BASE_URL}/var/mc", headers=headers, json=params)
resp.raise_for_status()
result = resp.json()
with open("result.json", "w") as f:
    json.dump(result, f, indent=2)
print("VaR:", result["var"])

# 3. Construire le bundle verify
bundle = {
    "parameters": params,
    "var": result["var"],
    "audit": result["audit"],
    "audit_proof": result["audit_proof"],
}
with open("verify.json", "w") as f:
    json.dump(bundle, f, indent=2)

# 4. Vérifier la preuve indépendamment
verify = requests.post(f"{BASE_URL}/var/mc/verify", headers=headers, json=bundle)
verify.raise_for_status()
print("verify:", verify.json())

# 5. Inspecter le bundle archivé
print(json.dumps(bundle, indent=2))

Conseils