Server P11c: each request-time product reads only the curves it uses, once per context (G33, D69)

crates/convex-engine/benches/runtime_benchmarks.rs

@@ -166,10 +166,12 @@ fn bench_request_time(c: &mut Criterion) {
     });
     group.bench_function("context_curves_price", |b| {
         b.iter(|| {
-            let context = rt
-                .block_on(engine.request_context(Some(&id), time(0)))
+            let curves = rt
+                .block_on(async {
+                    let mut context = engine.request_context(Some(&id), time(0)).await?;
+                    context.curves_for(&bond).await
+                })
                 .unwrap();
-            let curves = context.curves_for(&bond).unwrap();
             let input = PricingInput::with_mid_price(
                 bond.clone(),
                 settlement,

crates/convex-engine/src/curve_resolution.rs

@@ -18,7 +18,7 @@ use crate::curve_builder::BuiltCurve;
 use crate::telemetry::{observe_curve_build, CurvePath};
 
 /// Why a request could not obtain a curve it needs. Nothing is substituted.
-#[derive(Debug, thiserror::Error)]
+#[derive(Debug, Clone, thiserror::Error)]
 pub enum CurveResolutionError {
     /// The request names no configuration and the runtime runs none.
     #[error("no valuation context: name an activated configuration")]

crates/convex-engine/src/lib.rs

@@ -102,14 +102,28 @@ pub struct PricingCurves {
     pub benchmark: Option<BuiltCurve>,
 }
 
+/// The most curve sets one request context resolves. Each set is the roots a product
+/// path reads from the configuration's roles: a bullet's discount and swap curves, a
+/// callable's discount curve, and a note's discount and FRN reference curves.
+const MAX_CURVE_SETS: usize = 3;
+
+/// One curve set's resolution, kept by its context, failure included.
+type CurveRead =
+    Result<Arc<curve_resolution::ResolvedCurves>, curve_resolution::CurveResolutionError>;
+
 /// The approved valuation context of one request: an activated configuration's exact
-/// pricing version and the curves its roles name, resolved once at the request cutoff.
-/// Government and FRN reference roles are not consumed here, as in snapshot valuation.
+/// pricing version, at the request cutoff. Each product path reads the curves it needs
+/// at first use, and the context keeps every set it resolved, a failed one included, so
+/// a request resolves each set once (D69). The government role is not consumed here, as
+/// in snapshot valuation.
 pub struct RequestContext {
     id: convex_core::contracts::SourceId,
     activation_revision: convex_core::contracts::Version,
     config: ports::storage::BondPricingConfig,
-    resolved: curve_resolution::ResolvedCurves,
+    known_at: convex_core::contracts::UtcTimestamp,
+    curves: Arc<dyn ports::storage::CurveStore>,
+    /// Each curve set read, by its roots, in first-use order.
+    reads: Vec<(Vec<convex_core::ids::CurveId>, CurveRead)>,
 }
 
 impl RequestContext {
@@ -123,27 +137,59 @@ impl RequestContext {
         self.activation_revision
     }
 
-    /// Every consumed (curve, version) pin, roots and dependencies.
-    pub fn pins(&self) -> impl Iterator<Item = (&str, convex_core::contracts::Version)> {
-        self.resolved.pins()
+    /// Every (curve, version) pin the request read, roots and dependencies, each once,
+    /// in first-use order. A set that failed to resolve priced nothing and lists nothing.
+    pub fn pins(&self) -> Vec<(&str, convex_core::contracts::Version)> {
+        let mut pins = Vec::new();
+        for pin in self
+            .reads
+            .iter()
+            .filter_map(|(_, read)| read.as_ref().ok())
+            .flat_map(|resolved| resolved.pins())
+        {
+            if !pins.contains(&pin) {
+                pins.push(pin);
+            }
+        }
+        pins
     }
 
-    /// Curves for `bond`, which the configuration must cover; each curve must fit
-    /// its role and the bond's currency.
-    pub fn curves_for(
-        &self,
+    /// The curves `roots` name, with their dependencies, at the cutoff. A set is
+    /// resolved at its first read and kept, failure included.
+    pub(crate) async fn read(&mut self, roots: &[convex_core::ids::CurveId]) -> CurveRead {
+        if let Some((_, read)) = self.reads.iter().find(|(set, _)| set.as_slice() == roots) {
+            return read.clone();
+        }
+        if self.reads.len() >= MAX_CURVE_SETS {
+            return Err(ports::TraitError::CapacityExceeded.into());
+        }
+        let read = curve_resolution::resolve_curves(self.curves.as_ref(), roots, self.known_at)
+            .await
+            .map(Arc::new);
+        self.reads.push((roots.to_vec(), read.clone()));
+        read
+    }
+
+    /// Curves for a bullet `bond`, which the configuration must cover: its discount
+    /// curve and swap benchmark. Each curve must fit its role and the bond's currency.
+    pub async fn curves_for(
+        &mut self,
         bond: &ports::reference_data::BondReferenceData,
     ) -> Result<PricingCurves, curve_resolution::CurveResolutionError> {
         use curve_resolution::CurveResolutionError;
         if !self.config.applies_to.matches(bond) {
             return Err(CurveResolutionError::NotCovered(self.id.clone()));
         }
+        let roles = &self.config.analytics_curves;
+        let mut roots = vec![roles.discount_curve.clone()];
+        roots.extend(roles.swap_curve.clone());
+        let resolved = self.read(&roots).await?;
         let checked = |id: &convex_core::ids::CurveId, discount: bool| {
-            let native = self.resolved.native(id)?;
+            let native = resolved.native(id)?;
             if !curve_resolution::pricing_role_matches(native.recipe(), discount, bond.currency) {
                 return Err(CurveResolutionError::Role(id.clone()));
             }
-            self.resolved.curve(id)
+            resolved.curve(id)
         };
         let roles = &self.config.analytics_curves;
         Ok(PricingCurves {
@@ -366,10 +412,10 @@ impl PricingEngine {
     }
 
     /// The approved valuation context of a request at `known_at`: the active
-    /// selection of `configuration` (or of the default) and the curves its roles
-    /// name, current at the cutoff. Only an activation approves a configuration;
-    /// a staged version never prices. The configuration is the one active now, and
-    /// the cutoff governs the curve reads.
+    /// selection of `configuration` (or of the default). Only an activation approves a
+    /// configuration; a staged version never prices. The configuration is the one
+    /// active now, and the cutoff governs the curve reads, which each product path
+    /// makes at first use (D69).
     pub async fn request_context(
         &self,
         configuration: Option<&convex_core::contracts::SourceId>,
@@ -396,18 +442,13 @@ impl PricingEngine {
             .active(id)
             .await?
             .ok_or_else(|| CurveResolutionError::NotActivated(id.clone()))?;
-        let config = active.staged.document.pricing;
-        let roles = &config.analytics_curves;
-        let mut roots = vec![roles.discount_curve.clone()];
-        roots.extend(roles.swap_curve.clone());
-        let resolved =
-            curve_resolution::resolve_curves(self.storage.curves.as_ref(), &roots, known_at)
-                .await?;
         Ok(RequestContext {
             id: id.clone(),
             activation_revision: active.activation.revision,
-            config,
-            resolved,
+            config: active.staged.document.pricing,
+            known_at,
+            curves: self.storage.curves.clone(),
+            reads: Vec::new(),
         })
     }
 
@@ -448,7 +489,7 @@ impl PricingEngine {
     /// is stored.
     pub async fn value_request(
         &self,
-        context: &RequestContext,
+        context: &mut RequestContext,
         reference: &ports::reference_repository::ReferenceRecord,
         settlement_date: convex_core::contracts::BusinessDate,
         known_at: convex_core::contracts::UtcTimestamp,
@@ -460,14 +501,7 @@ impl PricingEngine {
             .as_ref()
             .ok_or(RequestValuationError::NoRuntime)?;
         let (snapshot, valuation, curves) = valuer
-            .prepare(
-                &self.storage,
-                context,
-                reference,
-                settlement_date,
-                known_at,
-                mark,
-            )
+            .prepare(context, reference, settlement_date, known_at, mark)
             .await?;
         let invalid = |_| ports::TraitError::InvalidInput("invalid request identity");
         // As the stream names its valuations, by context.

crates/convex-engine/src/request_valuation.rs

@@ -23,7 +23,7 @@ use convex_ports::{
 use rust_decimal::Decimal;
 
 use crate::context::{ValuationContext, ValuationContextSpec, ValuationScenario};
-use crate::curve_resolution::{resolve_curves, CurveResolutionError};
+use crate::curve_resolution::CurveResolutionError;
 use crate::optional_valuation::{product_measures, product_model};
 use crate::runtime::RuntimeServices;
 use crate::snapshot::{read_curve_ids, SnapshotAssembler, SnapshotValuationResult};
@@ -93,12 +93,12 @@ impl RequestValuer {
     }
 
     /// The one-instrument snapshot of `reference` at `known_at` and its context. The
-    /// curves are the ones the product's valuation reads, resolved at the cutoff, so a
-    /// missing or stale one refuses the request as it does for bullets (P9a).
+    /// curves are the ones the product's valuation reads, read through `context` at its
+    /// cutoff (D69). A missing or stale one refuses the request as it does for bullets
+    /// (P9a); a curve the product does not read refuses nothing.
     pub(crate) async fn prepare(
         &self,
-        storage: &StorageAdapter,
-        context: &RequestContext,
+        context: &mut RequestContext,
         reference: &ReferenceRecord,
         settlement_date: BusinessDate,
         known_at: UtcTimestamp,
@@ -109,6 +109,12 @@ impl RequestValuer {
             .bond
             .as_ref()
             .ok_or(TraitError::InvalidInput("the stored reference is deleted"))?;
+        // The context reads its curves at its own cutoff, so the snapshot must share it.
+        if known_at != context.known_at {
+            return Err(
+                TraitError::InvalidInput("a request values at its context's cutoff").into(),
+            );
+        }
         let config = context.config();
         if !config.applies_to.matches(bond) {
             return Err(CurveResolutionError::NotCovered(context.id.clone()).into());
@@ -131,17 +137,17 @@ impl RequestValuer {
             .into_iter()
             .map(convex_core::ids::CurveId::new)
             .collect();
-        let curves = resolve_curves(storage.curves.as_ref(), &roots, known_at).await?;
         let invalid = |_| TraitError::InvalidInput("invalid request identity");
+        let configuration = ConfigurationPin {
+            id: context.id.clone(),
+            version: Version::new(config.version).map_err(invalid)?,
+        };
+        let curves = context.read(&roots).await?;
         let key = QuoteKey {
             instrument_id: reference.instrument_id.clone(),
             source: REQUEST_SOURCE.into(),
         };
         let instrument_id = InstrumentId::new(reference.instrument_id.as_str()).map_err(invalid)?;
-        let configuration = ConfigurationPin {
-            id: context.id.clone(),
-            version: Version::new(config.version).map_err(invalid)?,
-        };
         let assembly = SnapshotAssembly {
             as_of: known_at,
             known_at,

crates/convex-engine/src/telemetry.rs

@@ -19,7 +19,8 @@ pub const CALCULATE_SECONDS: &str = "convex_calculate_seconds";
 pub const PUBLISH_SECONDS: &str = "convex_publish_seconds";
 /// One curve graph built from stored recipes, labelled by [`CurvePath`].
 pub const CURVE_BUILD_SECONDS: &str = "convex_curve_build_seconds";
-/// One request-time valuation context: activation read and curve resolution.
+/// One request-time valuation context: the activation read. Each product path reads its
+/// curves later, at first use (D69).
 pub const REQUEST_CONTEXT_SECONDS: &str = "convex_request_context_seconds";
 /// One `POST /api/v1/quote`, from handler entry to response.
 pub const QUOTE_SECONDS: &str = "convex_quote_seconds";

crates/convex-engine/tests/support/configuration_setup.rs

@@ -92,7 +92,7 @@ pub async fn value_at(
     else {
         panic!("instrument valuation")
     };
-    let context = engine.request_context(None, known_at).await.unwrap();
+    let mut context = engine.request_context(None, known_at).await.unwrap();
     let reference = engine
         .reference_at_for_pricing(
             &instrument_id.clone().into(),
@@ -106,6 +106,6 @@ pub async fn value_at(
         .unwrap();
     let mark = mark.map(|mid| mid.parse().unwrap());
     engine
-        .value_request(&context, &reference, settlement, known_at, mark)
+        .value_request(&mut context, &reference, settlement, known_at, mark)
         .await
 }

crates/convex-ports/src/error.rs

@@ -3,7 +3,7 @@
 use thiserror::Error;
 
 /// Common error type for trait operations.
-#[derive(Debug, Error)]
+#[derive(Debug, Clone, Error)]
 pub enum TraitError {
     /// The request violates a declared storage precondition.
     #[error("invalid input: {0}")]

crates/convex-server/README.md

@@ -292,6 +292,12 @@ auditable only because its activation is named. A missing
 or stale curve, or one with the wrong role or currency, is refused with
 `422 MISSING_INPUT`; the route never prices without curves.
 
+Each product reads only its own curves, when it first needs them: a bullet its
+discount curve and swap benchmark, a callable or FRN the curves listed below. A
+curve the product does not read refuses nothing, so a stale swap benchmark refuses
+bullets and still prices callables and FRNs. A bond the configuration does not cover
+is `422 NOT_COVERED` before any curve is read.
+
 Callables and FRNs are valued by the runtime, through the code the stream runs, so
 the numbers match the stream's for the same mark, cutoff and settlement. Each request
 builds a one-instrument snapshot that is never stored: the stored terms at `known_at`,
@@ -322,10 +328,12 @@ only; it is not sent on the WebSocket.
 
 `POST /api/v1/quote` and `POST /api/v1/batch/price` take the same optional
 `configuration` and `known_at` and resolve the same context. A batch resolves the
-context and its curves once. A bond the context cannot price fails on its own in
-`errors`, and the rest still price. Their bodies carry `context`:
+context once, and each product's curves at the first bond that reads them. A bond the
+context cannot price, a curve it reads included, fails on its own in `errors`, and
+the rest still price. Their bodies carry `context`:
 - `{"kind": "configuration", "configuration", "activation", "known_at", "curves"}`
-  for a configuration, with the headers above.
+  for a configuration, with the headers above. In a batch, `curves` and
+  `x-convex-curve-versions` list every curve some bond read, each once.
 - `{"kind": "supplied"}` when `POST /api/v1/quote` supplies its own curves or
   volatility. That is a what-if, and naming a `configuration` with it is
   `422 INVALID_INPUT`.
@@ -481,7 +489,7 @@ Build `cargo build --locked -p convex-server --bins` to obtain `convex-config` a
 | `convex_valuation_seconds` | One instrument valued in the runtime |
 | `convex_calculate_seconds` | Every instrument of one snapshot, including graph commits |
 | `convex_publish_seconds` | One result record handed to the publisher |
-| `convex_request_context_seconds` | One request-time valuation context: activation read and curve resolution |
+| `convex_request_context_seconds` | One request-time valuation context: the activation read. Each product reads its curves later, at first use, and their build is `convex_curve_build_seconds{path="request"}` |
 | `convex_quote_seconds` | One `POST /api/v1/quote` |
 
 On-demand nominal fixed/zero quotes now use the [shared pure bond route](../../docs/BOND-QUOTES.md). Supply an observed price; the curves come from the activated configuration, or from exact supplied discount/swap/government inputs for a what-if. No demo curves, assumed volatility or model/par price are generated. Missing optional measures have structured errors. Full historical contexts, live admission and complete product/model certificates retain their separate gates.