Server definition

Hash: sha256:3a48cd1acb1d22b4f6bc7883cacfec5c84be887c23a67590b79a578c2fe90724
What it is: What a remote MCP server returned when asked what it offers: 9 tools

The blob, as servednamed by its sha256

{
  "instructions": null,
  "tools": [
    {
      "description": "Options-implied expected move around a scheduled event (FOMC/CPI/earnings/etc.). Given spot, ATM implied vol, and days-to-event, returns the 1σ move, the straddle-implied expected ABSOLUTE move (risk-neutral E|ΔS|), and the probability of exceeding move thresholds. Given the vol term structure across the event (ATM IV of the expiry before vs after), it ISOLATES the event's own priced-in move (the Wright event-day technique). Self-checked: the straddle equals a numerical integral of |S_T−S₀|. This is the magnitude that macro calendars (which give only date + impact label) leave out.",
      "inputSchema": {
        "properties": {
          "T": {
            "description": "years (or daysToEvent)",
            "type": "number"
          },
          "atmIv": {
            "description": "ATM IV as a decimal (alternative to atmIvPct)",
            "type": "number"
          },
          "atmIvPct": {
            "description": "ATM IV in % (or atmIv decimal)",
            "type": "number"
          },
          "daysAfter": {
            "description": "days to the after-event expiry",
            "type": "number"
          },
          "daysBefore": {
            "description": "days to the before-event expiry",
            "type": "number"
          },
          "daysToEvent": {
            "description": "days until the event",
            "type": "number"
          },
          "ivAfterPct": {
            "description": "ATM IV (%) of the expiry just AFTER the event",
            "type": "number"
          },
          "ivBeforePct": {
            "description": "ATM IV (%) of the expiry just BEFORE the event",
            "type": "number"
          },
          "spot": {
            "description": "current spot price",
            "type": "number"
          },
          "thresholdsPct": {
            "description": "move thresholds (%) for probability-of-exceeding",
            "type": "array"
          }
        },
        "required": [
          "spot"
        ],
        "type": "object"
      },
      "name": "event_vol",
      "outputSchema": {
        "additionalProperties": true,
        "description": "Options-implied expected move around a scheduled event.",
        "properties": {
          "atmIvPct": {
            "description": "ATM IV used (%)"
          },
          "checks": {
            "description": "Ground-truth self-checks; the result is untrustworthy if any fails.",
            "items": {
              "additionalProperties": true,
              "type": "object"
            },
            "type": "array"
          },
          "eventIsolation": {
            "description": "the event's own priced-in move, isolated from the term structure (when before/after IVs are given)"
          },
          "expectedMove": {
            "description": "1σ move + straddle-implied expected |ΔS| (risk-neutral)"
          },
          "horizonDays": {
            "description": "horizon in days"
          },
          "method": {
            "description": "technique + assumptions used"
          },
          "ok": {
            "description": "false when the engine rejected the input",
            "type": "boolean"
          },
          "probabilityMoveBeyond": {
            "description": "probability of exceeding each move threshold"
          },
          "proof": {
            "additionalProperties": true,
            "description": "Verifiability envelope: echoed inputs, engine codeHash, contentHash of this exact result, self-checks, EIP-712 signature (EAS-ready). Re-run the open engine on `inputs` to reproduce the result byte-for-byte.",
            "properties": {
              "allSelfChecksPass": {
                "description": "true when every ground-truth self-check passed",
                "type": "boolean"
              },
              "codeHash": {
                "description": "build hash of the open-source engine sources (equals GET /build codeHash)",
                "type": "string"
              },
              "contentHash": {
                "description": "hash of this exact result — recompute it to detect tampering",
                "type": "string"
              },
              "engine": {
                "description": "engine id",
                "type": "string"
              }
            },
            "type": "object"
          },
          "spot": {
            "description": "spot the computation is anchored on"
          }
        },
        "type": "object"
      }
    },
    {
      "description": "Deterministic execution-quality / fair-fill verification. Given a completed swap (amountIn, amountOutRealized) plus either the pre-trade pool reserves+fee (constant-product) or a fair reference price, returns how many basis points the fill lost to ADVERSE execution (sandwich/MEV/stale) beyond the unavoidable fee + own price impact. Proves that a fill \"within slippage tolerance\" can still have been robbed. Call after a swap to detect being sandwiched.",
      "inputSchema": {
        "properties": {
          "amountIn": {
            "description": "input amount actually sent",
            "type": "number"
          },
          "amountOutRealized": {
            "description": "output amount actually received",
            "type": "number"
          },
          "fairPrice": {
            "description": "reference mode: fair out-per-in price at submit time",
            "type": "number"
          },
          "feeTier": {
            "description": "pool fee as fraction, e.g. 0.003",
            "type": "number"
          },
          "reserveIn": {
            "description": "pool reserve of input token, pre-trade (constant-product mode)",
            "type": "number"
          },
          "reserveOut": {
            "description": "pool reserve of output token, pre-trade",
            "type": "number"
          },
          "slippageTolerancePct": {
            "description": "the slippage setting used, to demonstrate within-tolerance-yet-robbed",
            "type": "number"
          }
        },
        "required": [
          "amountIn",
          "amountOutRealized"
        ],
        "type": "object"
      },
      "name": "exec_verify",
      "outputSchema": {
        "additionalProperties": true,
        "description": "How much of a swap fill was lost to adverse execution (sandwich/MEV/stale), beyond honest costs.",
        "properties": {
          "adverseExecutionBps": {
            "description": "bps lost to ADVERSE execution beyond the honest cost"
          },
          "adverseValueOut": {
            "description": "value lost to adverse execution, in output-token units"
          },
          "checks": {
            "description": "Ground-truth self-checks; the result is untrustworthy if any fails.",
            "items": {
              "additionalProperties": true,
              "type": "object"
            },
            "type": "array"
          },
          "honestFillPrice": {
            "description": "the fill price an honest execution would have produced"
          },
          "honestOut": {
            "description": "output an honest execution would have delivered"
          },
          "midPrice": {
            "description": "pre-trade mid price"
          },
          "mode": {
            "description": "constant-product or reference-price mode"
          },
          "note": {
            "description": "interpretation guidance"
          },
          "ok": {
            "description": "false when the engine rejected the input",
            "type": "boolean"
          },
          "proof": {
            "additionalProperties": true,
            "description": "Verifiability envelope: echoed inputs, engine codeHash, contentHash of this exact result, self-checks, EIP-712 signature (EAS-ready). Re-run the open engine on `inputs` to reproduce the result byte-for-byte.",
            "properties": {
              "allSelfChecksPass": {
                "description": "true when every ground-truth self-check passed",
                "type": "boolean"
              },
              "codeHash": {
                "description": "build hash of the open-source engine sources (equals GET /build codeHash)",
                "type": "string"
              },
              "contentHash": {
                "description": "hash of this exact result — recompute it to detect tampering",
                "type": "string"
              },
              "engine": {
                "description": "engine id",
                "type": "string"
              }
            },
            "type": "object"
          },
          "realizedFillPrice": {
            "description": "the fill price actually received"
          },
          "unavoidableCostBps": {
            "description": "fee + own price impact — the honest, unavoidable cost (bps)"
          },
          "verdict": {
            "description": "plain-language verdict"
          }
        },
        "type": "object"
      }
    },
    {
      "description": "Forward-looking liquidity-provision risk. Given a realized price ratio (for impermanent loss) and/or a volatility + horizon (for expected divergence / LVR), returns the closed-form IL, the expected −σ²T/8 divergence, and — with a fee APR — the net forecast and breakeven volatility (the vol above which fees no longer cover the bleed). Self-checked: the IL closed form is verified at the token level against explicit constant-product amounts. Call before providing liquidity to see whether the fee yield can plausibly beat the divergence loss.",
      "inputSchema": {
        "properties": {
          "capitalUsd": {
            "description": "position capital in USD — losses are also reported in USD",
            "type": "number"
          },
          "concentrationFactor": {
            "description": "V3 amplifier ≥1 (default 1)",
            "type": "number"
          },
          "feeAprPct": {
            "description": "annualized fee yield estimate",
            "type": "number"
          },
          "horizonPeriods": {
            "description": "periods (default 1)",
            "type": "number"
          },
          "periodsPerYear": {
            "description": "default 365",
            "type": "number"
          },
          "priceRatio": {
            "description": "realized P1/P0 for realized IL",
            "type": "number"
          },
          "volatility": {
            "description": "per-period vol (decimal) for expected divergence",
            "type": "number"
          }
        },
        "type": "object"
      },
      "name": "lp_risk",
      "outputSchema": {
        "additionalProperties": true,
        "description": "Impermanent loss / LVR vs fee yield for a liquidity position.",
        "properties": {
          "checks": {
            "description": "Ground-truth self-checks; the result is untrustworthy if any fails.",
            "items": {
              "additionalProperties": true,
              "type": "object"
            },
            "type": "array"
          },
          "concentrationFactor": {
            "description": "V3 concentration amplifier applied"
          },
          "expectedDivergence": {
            "description": "expected divergence loss / LVR over the horizon (−σ²T/8 law)"
          },
          "feeVsDivergence": {
            "description": "net forecast and breakeven volatility vs the fee APR"
          },
          "model": {
            "description": "model assumptions used"
          },
          "ok": {
            "description": "false when the engine rejected the input",
            "type": "boolean"
          },
          "proof": {
            "additionalProperties": true,
            "description": "Verifiability envelope: echoed inputs, engine codeHash, contentHash of this exact result, self-checks, EIP-712 signature (EAS-ready). Re-run the open engine on `inputs` to reproduce the result byte-for-byte.",
            "properties": {
              "allSelfChecksPass": {
                "description": "true when every ground-truth self-check passed",
                "type": "boolean"
              },
              "codeHash": {
                "description": "build hash of the open-source engine sources (equals GET /build codeHash)",
                "type": "string"
              },
              "contentHash": {
                "description": "hash of this exact result — recompute it to detect tampering",
                "type": "string"
              },
              "engine": {
                "description": "engine id",
                "type": "string"
              }
            },
            "type": "object"
          },
          "realizedIL": {
            "description": "closed-form impermanent loss at the realized price ratio"
          }
        },
        "type": "object"
      }
    },
    {
      "description": "Portfolio greeks (delta/gamma/vega/theta/vanna/volga) + SPAN-style scenario margin for an options book on Black-76. Given a list of legs {type, strike, expiryDays, iv, quantity(signed)} and a forward, returns aggregate greeks, first-order P&L per underlying move, and the worst-case loss over a price×vol grid. Self-checked: analytic greeks are verified against finite-difference derivatives of the repriced book. Call to size an options book's true net risk and margin — not the sum of per-leg notionals.",
      "inputSchema": {
        "properties": {
          "forward": {
            "description": "shared forward price (or set per position)",
            "type": "number"
          },
          "positions": {
            "description": "option legs of the book",
            "items": {
              "properties": {
                "T": {
                  "description": "years (or expiryDays)",
                  "type": "number"
                },
                "expiryDays": {
                  "description": "days to expiry (or pass T in years)",
                  "type": "number"
                },
                "forward": {
                  "description": "per-position forward (else shared)",
                  "type": "number"
                },
                "iv": {
                  "description": "implied vol decimal, e.g. 0.6",
                  "type": "number"
                },
                "quantity": {
                  "description": "signed: + long, − short",
                  "type": "number"
                },
                "strike": {
                  "description": "strike price",
                  "type": "number"
                },
                "type": {
                  "description": "call | put",
                  "enum": [
                    "call",
                    "put"
                  ],
                  "type": "string"
                }
              },
              "required": [
                "type",
                "strike",
                "iv",
                "quantity"
              ],
              "type": "object"
            },
            "type": "array"
          },
          "r": {
            "description": "discount rate, default 0",
            "type": "number"
          },
          "scanRangePct": {
            "description": "SPAN price scan range, default 0.15",
            "type": "number"
          },
          "volShiftVolPts": {
            "description": "SPAN vol shift in vol-points, default 10",
            "type": "number"
          }
        },
        "required": [
          "positions"
        ],
        "type": "object"
      },
      "name": "options_risk",
      "outputSchema": {
        "additionalProperties": true,
        "description": "Aggregate greeks and SPAN-style scenario margin for an options book.",
        "properties": {
          "checks": {
            "description": "Ground-truth self-checks; the result is untrustworthy if any fails.",
            "items": {
              "additionalProperties": true,
              "type": "object"
            },
            "type": "array"
          },
          "greeks": {
            "description": "aggregate delta/gamma/vega/theta/vanna/volga — each verified vs finite differences"
          },
          "model": {
            "description": "Black-76 assumptions used"
          },
          "ok": {
            "description": "false when the engine rejected the input",
            "type": "boolean"
          },
          "pnlPerUnderlyingPctMove": {
            "description": "first-order P&L per % move of the underlying"
          },
          "portfolioValue": {
            "description": "mark-to-model value of the book"
          },
          "positions": {
            "description": "per-leg pricing breakdown"
          },
          "positionsCount": {
            "description": "number of legs priced"
          },
          "proof": {
            "additionalProperties": true,
            "description": "Verifiability envelope: echoed inputs, engine codeHash, contentHash of this exact result, self-checks, EIP-712 signature (EAS-ready). Re-run the open engine on `inputs` to reproduce the result byte-for-byte.",
            "properties": {
              "allSelfChecksPass": {
                "description": "true when every ground-truth self-check passed",
                "type": "boolean"
              },
              "codeHash": {
                "description": "build hash of the open-source engine sources (equals GET /build codeHash)",
                "type": "string"
              },
              "contentHash": {
                "description": "hash of this exact result — recompute it to detect tampering",
                "type": "string"
              },
              "engine": {
                "description": "engine id",
                "type": "string"
              }
            },
            "type": "object"
          },
          "spanMargin": {
            "description": "worst-case loss over the price×vol scenario grid (SPAN-style margin)"
          }
        },
        "type": "object"
      }
    },
    {
      "description": "Deterministic perpetual-futures risk. Given a position (entry, size, margin/leverage, maint-margin/maxLeverage), returns the exact liquidation price, the % adverse move to liquidation, effective leverage, and (if a funding rate is given) the funding drag. Pass a Hyperliquid `symbol` (e.g. BTC) to auto-fill live mark price, funding, and max leverage. Includes a self-check proving the liquidation invariant. Call this BEFORE opening or sizing any leveraged perp position — an agent that knows its true liquidation distance does not get surprise-liquidated.",
      "inputSchema": {
        "properties": {
          "entryPrice": {
            "description": "defaults to live mark if a symbol is given",
            "type": "number"
          },
          "fundingRateHourly": {
            "description": "hourly funding rate (Hyperliquid funds hourly)",
            "type": "number"
          },
          "horizonHours": {
            "description": "horizon for the funding-drag estimate, in hours",
            "type": "number"
          },
          "leverage": {
            "description": "position leverage (alternative to margin)",
            "type": "number"
          },
          "maintMarginRate": {
            "description": "e.g. 0.0125; or pass maxLeverage (mmr = 0.5/maxLeverage)",
            "type": "number"
          },
          "margin": {
            "description": "isolated margin posted (or pass leverage)",
            "type": "number"
          },
          "markPrice": {
            "description": "current mark; distance-to-liq measured from here",
            "type": "number"
          },
          "maxLeverage": {
            "description": "venue max leverage for the asset",
            "type": "number"
          },
          "notional": {
            "description": "position notional in quote/USD",
            "type": "number"
          },
          "side": {
            "description": "long | short (buy | sell are accepted synonyms, as is -1 for short); default long",
            "enum": [
              "long",
              "short",
              "buy",
              "sell",
              "-1"
            ],
            "type": "string"
          },
          "size": {
            "description": "position size in base units (or pass notional)",
            "type": "number"
          },
          "symbol": {
            "description": "perp symbol (e.g. BTC) — auto-fills live markPrice, fundingRateHourly, and the margin source (Hyperliquid notional tiers or dYdX maintenance rate); also defaults entryPrice to the live mark",
            "type": "string"
          },
          "venue": {
            "description": "live-data venue (default hyperliquid). The maths is venue-agnostic — for any other venue omit this and pass maxLeverage/markPrice/fundingRateHourly yourself.",
            "enum": [
              "hyperliquid",
              "dydx"
            ],
            "type": "string"
          }
        },
        "type": "object"
      },
      "name": "perp_gate",
      "outputSchema": {
        "additionalProperties": true,
        "description": "Liquidation risk of one perpetual-futures position.",
        "properties": {
          "checks": {
            "description": "Ground-truth self-checks; the result is untrustworthy if any fails.",
            "items": {
              "additionalProperties": true,
              "type": "object"
            },
            "type": "array"
          },
          "effectiveLeverage": {
            "description": "notional / margin actually run"
          },
          "funding": {
            "description": "funding drag over the horizon (when a funding rate is given)"
          },
          "initialMarginRatePct": {
            "description": "initial margin rate applied (%)"
          },
          "liquidationPrice": {
            "description": "exact price at which the position liquidates"
          },
          "maintenanceMarginRatePct": {
            "description": "maintenance margin rate applied (%)"
          },
          "marginTier": {
            "description": "venue margin tier the notional falls into"
          },
          "model": {
            "description": "model assumptions used"
          },
          "moveToLiquidationPct": {
            "description": "adverse % move (from mark) that triggers liquidation"
          },
          "ok": {
            "description": "false when the engine rejected the input",
            "type": "boolean"
          },
          "proof": {
            "additionalProperties": true,
            "description": "Verifiability envelope: echoed inputs, engine codeHash, contentHash of this exact result, self-checks, EIP-712 signature (EAS-ready). Re-run the open engine on `inputs` to reproduce the result byte-for-byte.",
            "properties": {
              "allSelfChecksPass": {
                "description": "true when every ground-truth self-check passed",
                "type": "boolean"
              },
              "codeHash": {
                "description": "build hash of the open-source engine sources (equals GET /build codeHash)",
                "type": "string"
              },
              "contentHash": {
                "description": "hash of this exact result — recompute it to detect tampering",
                "type": "string"
              },
              "engine": {
                "description": "engine id",
                "type": "string"
              }
            },
            "type": "object"
          }
        },
        "type": "object"
      }
    },
    {
      "description": "Cross-venue portfolio risk. Given positions across venues [{venue, asset|symbol, side, size, entryPrice, margin|leverage, maxLeverage|marginTiers}] — OR just account: a Hyperliquid 0x address, whose FULL live book (positions, margins, account equity, the venue's own liquidation prices) is pulled keylessly — returns TRUE net exposure per underlying, the leg that liquidates FIRST (the binding constraint), concentration (HHI / effective independent bets), and a correlated-crash stress counting how many legs liquidate SIMULTANEOUSLY when the market moves ±X% (correlation→1, the Oct-10-2025 crash regime). Pass Hyperliquid symbols to auto-fill live mark/leverage/margin-tiers. Self-checked (exposure reconciliation, per-leg liquidation invariant, nearest=min, monotone stress, venue-liquidation cross-check). Call to see whether independently-sized bets are secretly ONE bet that blows up together.",
      "inputSchema": {
        "properties": {
          "account": {
            "description": "OR: a Hyperliquid account address (0x…) — the full live book (positions, margins, equity, venue liquidation prices) is pulled keylessly; explicit positions take precedence.",
            "type": "string"
          },
          "betaTier": {
            "description": "beta regime for the factor stress: mild | moderate | severe — cross-event validated tiers (pre-registered). Default = worst-case single-event table; explicit betas override.",
            "enum": [
              "mild",
              "moderate",
              "severe"
            ],
            "type": "string"
          },
          "positions": {
            "description": "legs: {venue, asset|symbol, side long|short, size, entryPrice, markPrice?, margin|leverage, maxLeverage|maintMarginRate|marginTiers}. A Hyperliquid symbol auto-fills live mark/leverage/tiers.",
            "items": {
              "description": "one leg; see the array description for the full field list",
              "properties": {
                "side": {
                  "description": "long | short (buy | sell are accepted synonyms); a negative size also reads as short",
                  "enum": [
                    "long",
                    "short",
                    "buy",
                    "sell"
                  ],
                  "type": "string"
                }
              },
              "type": "object"
            },
            "type": "array"
          },
          "shockScenariosPct": {
            "description": "correlated market moves (%) to stress; default [5,10,20,30]",
            "type": "array"
          }
        },
        "type": "object"
      },
      "name": "portfolio_gate",
      "outputSchema": {
        "additionalProperties": true,
        "description": "Portfolio-level risk across venues: net exposure, binding liquidation, concentration, correlated stress.",
        "properties": {
          "checks": {
            "description": "Ground-truth self-checks; the result is untrustworthy if any fails.",
            "items": {
              "additionalProperties": true,
              "type": "object"
            },
            "type": "array"
          },
          "concentration": {
            "description": "HHI + effective number of independent bets"
          },
          "correlatedShockStress": {
            "description": "per-scenario: how many legs liquidate simultaneously at a correlated ±X% move"
          },
          "model": {
            "description": "model assumptions used"
          },
          "nearestLiquidation": {
            "description": "the leg that liquidates FIRST — the binding constraint"
          },
          "netExposureByAsset": {
            "description": "TRUE net exposure per underlying (longs netted against shorts)"
          },
          "ok": {
            "description": "false when the engine rejected the input",
            "type": "boolean"
          },
          "positions": {
            "description": "per-leg breakdown with each liquidation price"
          },
          "positionsCount": {
            "description": "number of legs analyzed"
          },
          "proof": {
            "additionalProperties": true,
            "description": "Verifiability envelope: echoed inputs, engine codeHash, contentHash of this exact result, self-checks, EIP-712 signature (EAS-ready). Re-run the open engine on `inputs` to reproduce the result byte-for-byte.",
            "properties": {
              "allSelfChecksPass": {
                "description": "true when every ground-truth self-check passed",
                "type": "boolean"
              },
              "codeHash": {
                "description": "build hash of the open-source engine sources (equals GET /build codeHash)",
                "type": "string"
              },
              "contentHash": {
                "description": "hash of this exact result — recompute it to detect tampering",
                "type": "string"
              },
              "engine": {
                "description": "engine id",
                "type": "string"
              }
            },
            "type": "object"
          },
          "totalGrossNotional": {
            "description": "sum of |notional| across legs"
          },
          "totalNetNotional": {
            "description": "net notional after long/short netting"
          }
        },
        "type": "object"
      }
    },
    {
      "description": "Batch the content-hashes from many Quiver proof envelopes into ONE Merkle root plus per-item inclusion proofs, so a single on-chain anchor (your wallet's tx) attests all of them at once. Self-checked for completeness (every item verifies) and soundness (a non-member does not). Use to make a batch of risk computations cheaply and permanently attestable for audit/liability, without a chain write per computation.",
      "inputSchema": {
        "properties": {
          "contentHashes": {
            "description": "alternatively, raw content-hashes",
            "type": "array"
          },
          "items": {
            "description": "proof envelopes (uses proof.contentHash) or raw content-hashes (hex)",
            "type": "array"
          }
        },
        "type": "object"
      },
      "name": "risk_attest",
      "outputSchema": {
        "additionalProperties": true,
        "description": "One Merkle root + inclusion proofs attesting a batch of Quiver computations.",
        "properties": {
          "algorithm": {
            "description": "hash/tree construction used"
          },
          "anchor": {
            "description": "EIP-712 (EAS-ready) attestation payload for the single on-chain anchor"
          },
          "attestations": {
            "description": "per-item inclusion proofs"
          },
          "checks": {
            "description": "Ground-truth self-checks; the result is untrustworthy if any fails.",
            "items": {
              "additionalProperties": true,
              "type": "object"
            },
            "type": "array"
          },
          "duplicateLeaves": {
            "description": "duplicate content-hashes detected in the batch"
          },
          "leafCount": {
            "description": "number of items batched"
          },
          "merkleRoot": {
            "description": "the single root that attests every item"
          },
          "ok": {
            "description": "false when the engine rejected the input",
            "type": "boolean"
          },
          "proof": {
            "additionalProperties": true,
            "description": "Verifiability envelope: echoed inputs, engine codeHash, contentHash of this exact result, self-checks, EIP-712 signature (EAS-ready). Re-run the open engine on `inputs` to reproduce the result byte-for-byte.",
            "properties": {
              "allSelfChecksPass": {
                "description": "true when every ground-truth self-check passed",
                "type": "boolean"
              },
              "codeHash": {
                "description": "build hash of the open-source engine sources (equals GET /build codeHash)",
                "type": "string"
              },
              "contentHash": {
                "description": "hash of this exact result — recompute it to detect tampering",
                "type": "string"
              },
              "engine": {
                "description": "engine id",
                "type": "string"
              }
            },
            "type": "object"
          },
          "verify": {
            "description": "how to verify inclusion against the root"
          }
        },
        "type": "object"
      }
    },
    {
      "description": "Deterministic position sizing (fractional Kelly) + risk-of-ruin. Given an edge — discrete {winProb, winLossRatio} or continuous {expectedReturn, volatility} — and a bankroll, returns the fractional-Kelly size and the probability of ever drawing down to 50/75/90%. The direct antidote to over-betting: full Kelly rides thin edges to ruin; this defaults to quarter-Kelly. Call before sizing ANY position.",
      "inputSchema": {
        "properties": {
          "bankroll": {
            "description": "bankroll in account units — recommended sizes are returned in the same units",
            "type": "number"
          },
          "expectedReturn": {
            "description": "continuous mode: excess return per period (mu)",
            "type": "number"
          },
          "kellyFraction": {
            "description": "fraction of full Kelly to bet (default 0.25)",
            "type": "number"
          },
          "volatility": {
            "description": "continuous mode: volatility per period (sigma)",
            "type": "number"
          },
          "winLossRatio": {
            "description": "discrete mode: net win/loss odds b",
            "type": "number"
          },
          "winProb": {
            "description": "discrete mode: win probability in (0,1)",
            "type": "number"
          }
        },
        "type": "object"
      },
      "name": "size_gate",
      "outputSchema": {
        "additionalProperties": true,
        "description": "Fractional-Kelly position size with drawdown (risk-of-ruin) probabilities.",
        "properties": {
          "checks": {
            "description": "Ground-truth self-checks; the result is untrustworthy if any fails.",
            "items": {
              "additionalProperties": true,
              "type": "object"
            },
            "type": "array"
          },
          "expectedLogGrowth": {
            "description": "expected log-growth rate at the recommended size"
          },
          "fullKellyFraction": {
            "description": "full-Kelly fraction of bankroll (the ruinous ceiling, not the recommendation)"
          },
          "hasEdge": {
            "description": "false when the edge is non-positive (bet nothing)"
          },
          "impliedPortfolioVolPct": {
            "description": "portfolio volatility implied by the recommended size (%)"
          },
          "kellyFractionUsed": {
            "description": "fraction of full Kelly applied (default 0.25)"
          },
          "leverage": {
            "description": "implied leverage of the recommended size"
          },
          "mode": {
            "description": "discrete or continuous"
          },
          "model": {
            "description": "model assumptions used"
          },
          "note": {
            "description": "plain-language guidance"
          },
          "ok": {
            "description": "false when the engine rejected the input",
            "type": "boolean"
          },
          "proof": {
            "additionalProperties": true,
            "description": "Verifiability envelope: echoed inputs, engine codeHash, contentHash of this exact result, self-checks, EIP-712 signature (EAS-ready). Re-run the open engine on `inputs` to reproduce the result byte-for-byte.",
            "properties": {
              "allSelfChecksPass": {
                "description": "true when every ground-truth self-check passed",
                "type": "boolean"
              },
              "codeHash": {
                "description": "build hash of the open-source engine sources (equals GET /build codeHash)",
                "type": "string"
              },
              "contentHash": {
                "description": "hash of this exact result — recompute it to detect tampering",
                "type": "string"
              },
              "engine": {
                "description": "engine id",
                "type": "string"
              }
            },
            "type": "object"
          },
          "recommendedBetFraction": {
            "description": "recommended bet as a fraction of bankroll"
          },
          "recommendedSize": {
            "description": "recommended bet size in bankroll units"
          },
          "riskOfRuin": {
            "description": "probability of ever drawing down to 50/75/90% of bankroll"
          }
        },
        "type": "object"
      }
    },
    {
      "description": "Stablecoin / on-chain treasury risk. Given a book of positions [{asset, amountUsd, apyPct, venue, chain, pegTarget, depegProbAnnual}], returns concentration (Herfindahl by asset/venue/chain + breaches over a limit), depeg stress (explicit scenarios + a worst-single-depeg scan), weighted and risk-adjusted yield. Self-checked: HHI == Σw², weights sum to 1, depeg-loss identity. Call to size a treasury's real risk — issuer/venue/chain concentration and depeg exposure — not just its headline APY.",
      "inputSchema": {
        "properties": {
          "concentrationLimitPct": {
            "description": "flag any single exposure above this (default 25)",
            "type": "number"
          },
          "depegFloor": {
            "description": "worst-single-depeg stress floor (default 0.90)",
            "type": "number"
          },
          "depegScenarios": {
            "description": "[{asset, price}] explicit depeg stresses",
            "type": "array"
          },
          "positions": {
            "description": "treasury holdings",
            "items": {
              "properties": {
                "amountUsd": {
                  "description": "position size in USD",
                  "type": "number"
                },
                "apyPct": {
                  "description": "headline APY (%)",
                  "type": "number"
                },
                "asset": {
                  "description": "stablecoin / asset symbol",
                  "type": "string"
                },
                "chain": {
                  "description": "chain it lives on",
                  "type": "string"
                },
                "depegProbAnnual": {
                  "description": "annualized depeg probability estimate",
                  "type": "number"
                },
                "pegTarget": {
                  "description": "peg price (default 1.0)",
                  "type": "number"
                },
                "venue": {
                  "description": "custodian / protocol holding it",
                  "type": "string"
                }
              },
              "required": [
                "asset",
                "amountUsd"
              ],
              "type": "object"
            },
            "type": "array"
          }
        },
        "required": [
          "positions"
        ],
        "type": "object"
      },
      "name": "treasury_risk",
      "outputSchema": {
        "additionalProperties": true,
        "description": "Concentration, depeg stress, and risk-adjusted yield of a stablecoin treasury.",
        "properties": {
          "checks": {
            "description": "Ground-truth self-checks; the result is untrustworthy if any fails.",
            "items": {
              "additionalProperties": true,
              "type": "object"
            },
            "type": "array"
          },
          "concentration": {
            "description": "Herfindahl (HHI) by asset/venue/chain + limit breaches"
          },
          "depegStress": {
            "description": "explicit depeg scenarios + worst-single-depeg scan"
          },
          "expectedAnnualDepegLossUsd": {
            "description": "expected annual loss from depeg probabilities (USD)"
          },
          "model": {
            "description": "model assumptions used"
          },
          "ok": {
            "description": "false when the engine rejected the input",
            "type": "boolean"
          },
          "proof": {
            "additionalProperties": true,
            "description": "Verifiability envelope: echoed inputs, engine codeHash, contentHash of this exact result, self-checks, EIP-712 signature (EAS-ready). Re-run the open engine on `inputs` to reproduce the result byte-for-byte.",
            "properties": {
              "allSelfChecksPass": {
                "description": "true when every ground-truth self-check passed",
                "type": "boolean"
              },
              "codeHash": {
                "description": "build hash of the open-source engine sources (equals GET /build codeHash)",
                "type": "string"
              },
              "contentHash": {
                "description": "hash of this exact result — recompute it to detect tampering",
                "type": "string"
              },
              "engine": {
                "description": "engine id",
                "type": "string"
              }
            },
            "type": "object"
          },
          "riskAdjustedApyPct": {
            "description": "yield after expected depeg loss (%)"
          },
          "totalUsd": {
            "description": "total treasury size in USD"
          },
          "verdict": {
            "description": "plain-language verdict"
          },
          "weightedApyPct": {
            "description": "holdings-weighted headline APY (%)"
          }
        },
        "type": "object"
      }
    }
  ]
}

Verify it yourself

curl -s https://api.teppi.xyz/v1/evidence/sha256:3a48cd1acb1d22b4f6bc7883cacfec5c84be887c23a67590b79a578c2fe90724 | sha256sum