Seed runtime-added currency conversion rates immediately (#9568)

JosueNina · Martin-Molinero · claude · web-flow · commit eb12c8fa655f · 2026-07-01T12:40:54.000-03:00
* Seed runtime-added currency conversion rates immediately

Fixes the spurious 'The conversion rate for &lt;currency&gt; is not available'
runtime error caused by a two-path seeding asymmetry.

The setup path (BaseSetupHandler.SetupCurrencyConversions) wires up a
currency's conversion feed AND seeds its rate via history/last-known-price
so the rate is non-zero right away. The runtime path
(UniverseSelection.EnsureCurrencyDataFeeds, invoked during universe
selection / SetCash mid-run) only created the conversion subscription and
left the rate at 0 until the first bar of the pair arrived. Any conversion
in that gap (classically a midnight scheduled SetHoldings firing before the
day's first conversion-pair bar) threw.

EnsureCurrencyDataFeeds now seeds newly introduced, still-zero-rate
conversion securities and calls cash.Update(), mirroring the setup path.
Seeding is gated behind a seedNewCurrencies flag (default true) so the
setup caller, which performs its own optionally white-listed seeding, can
opt out and not regress white-list semantics. SeedSecurities degrades
gracefully when no history/data is available, leaving the rate at 0 as
before, so live mode and no-history scenarios are safe.

Adds a regression test exercising the runtime path.

Co-Authored-By: Claude Opus 4.8 (1M context) &lt;noreply@anthropic.com&gt;

* Make runtime currency seeding robust and fix regression expectation

CI failures from the runtime currency-conversion seeding change:

1. AlgorithmWarmupTests.WarmUpInternalSubscriptions threw
   ArgumentNullException because the new EnsureCurrencyDataFeeds seeding
   path ran GetLastKnownPrices in a stub where the conversion security
   lacked SymbolProperties. Pre-seeding is best-effort and must never
   break the algorithm, so wrap it in try/catch and degrade gracefully
   (leave the rate at 0, the pre-fix behavior) - matching the documented
   intent. The first conversion-pair bar still updates the rate.

2. ScheduledUniverseSelectionModelRegressionAlgorithm (C# + Python)
   asserted AlgorithmHistoryDataPoints == 0. The algorithm runtime-adds
   Forex pairs (EURGBP -&gt; GBP cash) via scheduled universe selection;
   the fix now correctly seeds that runtime currency's conversion rate
   with a last-known-price history request (deterministically 50 points).
   The old 0 reflected the buggy unseeded behavior, so update the
   expectation to 50. No other statistics changed.

Co-Authored-By: Claude Opus 4.8 (1M context) &lt;noreply@anthropic.com&gt;

* Seed runtime added currency conversion rates

* Seed currencies with no new conversion feed and dedup the seeding helper

---------

Co-authored-by: Martin-Molinero &lt;Martin-Molinero@users.noreply.github.com&gt;
Co-authored-by: Claude Opus 4.8 (1M context) &lt;noreply@anthropic.com&gt;
diff --git a/Algorithm.CSharp/RuntimeCurrencyConversionSeedingRegressionAlgorithm.cs b/Algorithm.CSharp/RuntimeCurrencyConversionSeedingRegressionAlgorithm.cs
@@ -0,0 +1,174 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
+using System.Collections.Generic;
+using System.Linq;
+using QuantConnect.Brokerages;
+using QuantConnect.Data;
+using QuantConnect.Data.UniverseSelection;
+using QuantConnect.Interfaces;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Regression algorithm asserting that a currency added at runtime (here BTCEUR, from a scheduled event) has its
+    /// conversion rate seeded right away, so using it immediately no longer throws because the rate is still 0.
+    /// </summary>
+    public class RuntimeCurrencyConversionSeedingRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Symbol _ltcusd;
+        private bool _addedAtRuntime;
+        private bool _assertedSeeded;
+
+        /// <summary>
+        /// Initialise the data and resolution required, as well as the cash and start-end dates for your algorithm. All algorithms must initialized.
+        /// </summary>
+        public override void Initialize()
+        {
+            SetStartDate(2018, 4, 5);
+            SetEndDate(2018, 4, 5);
+            SetBrokerageModel(BrokerageName.GDAX, AccountType.Cash);
+            SetCash(100000);
+
+            // Account currency asset that funds the loop
+            _ltcusd = AddCrypto("LTCUSD", Resolution.Minute).Symbol;
+
+            // Add a non-account-currency asset at runtime, mirroring users that add assets from a scheduled event
+            Schedule.On(DateRules.EveryDay(), TimeRules.At(10, 0), () =>
+            {
+                if (_addedAtRuntime)
+                {
+                    return;
+                }
+                _addedAtRuntime = true;
+                AddCrypto("BTCEUR", Resolution.Minute);
+            });
+        }
+
+        /// <summary>
+        /// Runs right after the runtime-added security is wired up, the earliest point it can be used
+        /// </summary>
+        public override void OnSecuritiesChanged(SecurityChanges changes)
+        {
+            if (!changes.AddedSecurities.Any(security => security.Symbol.Value == "BTCEUR"))
+            {
+                return;
+            }
+            _assertedSeeded = true;
+
+            // With the fix these are already seeded here. Without it they would still be 0 and the conversion below would throw.
+            var eur = Portfolio.CashBook["EUR"];
+            var btc = Portfolio.CashBook["BTC"];
+            if (eur.ConversionRate == 0 || btc.ConversionRate == 0)
+            {
+                throw new RegressionTestException(
+                    $"Runtime-added currency conversion rates were not seeded (EUR={eur.ConversionRate}, BTC={btc.ConversionRate})");
+            }
+
+            if (Portfolio.CashBook.ConvertToAccountCurrency(100m, "EUR") <= 0)
+            {
+                throw new RegressionTestException("Expected a positive EUR -> account currency conversion");
+            }
+        }
+
+        /// <summary>
+        /// OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here.
+        /// </summary>
+        /// <param name="slice">Slice object keyed by symbol containing the stock data</param>
+        public override void OnData(Slice slice)
+        {
+            if (!_addedAtRuntime || Portfolio.Invested)
+            {
+                return;
+            }
+
+            if (Securities[_ltcusd].Price != 0)
+            {
+                SetHoldings(_ltcusd, 0.5);
+            }
+        }
+
+        /// <summary>
+        /// Makes sure the seeding path was actually exercised so the test can't silently pass
+        /// </summary>
+        public override void OnEndOfAlgorithm()
+        {
+            if (!_assertedSeeded)
+            {
+                throw new RegressionTestException("BTCEUR was never added at runtime, the seeding path was not exercised");
+            }
+        }
+
+        /// <summary>
+        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
+        /// </summary>
+        public bool CanRunLocally { get; } = true;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate which languages this algorithm is written in.
+        /// </summary>
+        public List<Language> Languages { get; } = new() { Language.CSharp };
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 6005;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public int AlgorithmHistoryDataPoints => 591;
+
+        /// <summary>
+        /// Final status of the algorithm
+        /// </summary>
+        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
+        {
+            {"Total Orders", "1"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "0%"},
+            {"Drawdown", "0%"},
+            {"Expectancy", "0"},
+            {"Start Equity", "100000.00"},
+            {"End Equity", "99064.52"},
+            {"Net Profit", "0%"},
+            {"Sharpe Ratio", "0"},
+            {"Sortino Ratio", "0"},
+            {"Probabilistic Sharpe Ratio", "0%"},
+            {"Loss Rate", "0%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "0"},
+            {"Beta", "0"},
+            {"Annual Standard Deviation", "0"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "0"},
+            {"Tracking Error", "0"},
+            {"Treynor Ratio", "0"},
+            {"Total Fees", "$149.18"},
+            {"Estimated Strategy Capacity", "$160000.00"},
+            {"Lowest Capacity Asset", "LTCUSD 2XR"},
+            {"Portfolio Turnover", "50.20%"},
+            {"Drawdown Recovery", "0"},
+            {"OrderListHash", "69d27a394cffbd938ec23fbb451f37ae"}
+        };
+    }
+}
diff --git a/Algorithm.CSharp/ScheduledUniverseSelectionModelRegressionAlgorithm.cs b/Algorithm.CSharp/ScheduledUniverseSelectionModelRegressionAlgorithm.cs
@@ -199,7 +199,7 @@ private void ExpectRemovals(SecurityChanges changes, params string[] tickers)
         /// <summary>
         /// Data Points count of the algorithm history
         /// </summary>
-        public int AlgorithmHistoryDataPoints => 0;
+        public int AlgorithmHistoryDataPoints => 10;
 
         /// <summary>
         /// Final status of the algorithm
diff --git a/Common/AlgorithmUtils.cs b/Common/AlgorithmUtils.cs
@@ -15,6 +15,7 @@
 
 using QuantConnect.Interfaces;
 using QuantConnect.Securities;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 
@@ -46,5 +47,39 @@ public static void SeedSecurities(IReadOnlyCollection<Security> securities, IAlg
                 }
             }
         }
+
+        /// <summary>
+        /// Seeds an initial conversion rate for the cashbook currencies that don't have one yet, so they are
+        /// non-zero right away instead of waiting for the first conversion pair bar to arrive
+        /// </summary>
+        /// <param name="algorithm">The algorithm instance</param>
+        /// <param name="currenciesToUpdateWhiteList">
+        /// If passed, only the currencies in the CashBook contained in this list will be updated.
+        /// By default, if not passed (null), all currencies in the cashbook without a properly set up currency conversion will be updated.
+        /// </param>
+        public static void SeedCurrencyConversionRates(IAlgorithm algorithm, IReadOnlyCollection<string> currenciesToUpdateWhiteList = null)
+        {
+            Func<Cash, bool> cashToUpdateFilter = currenciesToUpdateWhiteList == null
+                ? (x) => x.CurrencyConversion != null && x.ConversionRate == 0
+                : (x) => currenciesToUpdateWhiteList.Contains(x.Symbol);
+            var cashToUpdate = algorithm.Portfolio.CashBook.Values.Where(cashToUpdateFilter).ToList();
+
+            if (cashToUpdate.Count == 0)
+            {
+                return;
+            }
+
+            var securitiesToUpdate = cashToUpdate
+                .SelectMany(x => x.CurrencyConversion.ConversionRateSecurities)
+                .Distinct()
+                .ToList();
+
+            SeedSecurities(securitiesToUpdate, algorithm);
+
+            foreach (var cash in cashToUpdate)
+            {
+                cash.Update();
+            }
+        }
     }
 }
diff --git a/Engine/DataFeeds/CurrencySubscriptionDataConfigManager.cs b/Engine/DataFeeds/CurrencySubscriptionDataConfigManager.cs
@@ -131,8 +131,14 @@ public IEnumerable<SubscriptionDataConfig> GetPendingSubscriptionDataConfigs()
         /// <summary>
         /// Checks the current <see cref="SubscriptionDataConfig"/> and adds new necessary currency pair feeds to provide real time conversion data
         /// </summary>
-        public void EnsureCurrencySubscriptionDataConfigs(SecurityChanges securityChanges, IBrokerageModel brokerageModel)
+        /// <returns>True if a new currency was introduced, either as a new internal conversion feed or as a new cash
+        /// entry added to the cashbook. Lets callers skip follow up work like seeding the new conversion rates when
+        /// nothing was added</returns>
+        public bool EnsureCurrencySubscriptionDataConfigs(SecurityChanges securityChanges, IBrokerageModel brokerageModel)
         {
+            // a new cash added to the cashbook also needs its conversion rate seeded, even when its conversion
+            // security is an already subscribed one and no new internal feed is introduced below
+            var newCashAdded = _ensureCurrencyDataFeeds;
             _ensureCurrencyDataFeeds = false;
             // remove any 'to be added' if the security has already been added
             _toBeAddedCurrencySubscriptionDataConfigs.RemoveWhere(
@@ -150,6 +156,8 @@ public void EnsureCurrencySubscriptionDataConfigs(SecurityChanges securityChange
                 _toBeAddedCurrencySubscriptionDataConfigs.Add(config);
             }
             _pendingSubscriptionDataConfigs = _toBeAddedCurrencySubscriptionDataConfigs.Any();
+
+            return newConfigs.Count > 0 || newCashAdded;
         }
     }
 }
diff --git a/Engine/DataFeeds/UniverseSelection.cs b/Engine/DataFeeds/UniverseSelection.cs
@@ -128,7 +128,7 @@ public SecurityChanges ApplyUniverseSelection(Universe universe, DateTime dateTi
 
                     // if the input is already fundamental data we just need to filter it and pass it through
                     var hasFundamentalData = universeData.Data.Count > 0 && universeData.Data[0] is Fundamental;
-                    if(hasFundamentalData)
+                    if (hasFundamentalData)
                     {
                         // Remove selected symbols that does not have fine fundamental data
                         var anyDoesNotHaveFundamentalData = false;
@@ -137,7 +137,8 @@ public SecurityChanges ApplyUniverseSelection(Universe universe, DateTime dateTi
                         // which do not use coarse data as underlying, in which case it could happen that we try to load fine fundamental data that is missing, but no problem,
                         // 'FineFundamentalSubscriptionEnumeratorFactory' won't emit it
                         var set = selectSymbolsResult.ToHashSet();
-                        fineCollection.Data.AddRange(universeData.Data.OfType<Fundamental>().Where(fundamental => {
+                        fineCollection.Data.AddRange(universeData.Data.OfType<Fundamental>().Where(fundamental =>
+                        {
                             // we remove to we distict by symbol
                             if (set.Remove(fundamental.Symbol))
                             {
@@ -360,7 +361,7 @@ public bool AddPendingInternalDataFeeds(DateTime utcStart)
                         resolution = supportedResolutions.OrderByDescending(x => x).First();
                     }
 
-                    var subscriptionList = new List<Tuple<Type, TickType>>() {subscriptionType};
+                    var subscriptionList = new List<Tuple<Type, TickType>>() { subscriptionType };
                     var dataConfig = _algorithm.SubscriptionManager.SubscriptionDataConfigService.Add(
                         securityBenchmark.Security.Symbol,
                         resolution,
@@ -418,9 +419,32 @@ public bool AddPendingInternalDataFeeds(DateTime utcStart)
         /// <summary>
         /// Checks the current subscriptions and adds necessary currency pair feeds to provide real time conversion data
         /// </summary>
-        public void EnsureCurrencyDataFeeds(SecurityChanges securityChanges)
+        /// <param name="securityChanges">The security changes to consume</param>
+        /// <param name="seedNewCurrencies">Whether to seed the conversion rate of newly added currencies with their last
+        /// known price. The setup handler passes false because it performs its own (optionally white-listed) seeding</param>
+        public void EnsureCurrencyDataFeeds(SecurityChanges securityChanges, bool seedNewCurrencies = true)
         {
-            _currencySubscriptionDataConfigManager.EnsureCurrencySubscriptionDataConfigs(securityChanges, _algorithm.BrokerageModel);
+            var newCurrenciesAdded = _currencySubscriptionDataConfigManager.EnsureCurrencySubscriptionDataConfigs(securityChanges, _algorithm.BrokerageModel);
+
+            // Only scan the cashbook and seed when a new currency was actually introduced, either as a new
+            // internal conversion feed or as a new cash entry whose conversion security is an already added one
+            if (!seedNewCurrencies || !newCurrenciesAdded)
+            {
+                return;
+            }
+
+            // Seed the new conversion rates with their last known price so they are non-zero right away, instead of
+            // waiting for the first conversion pair bar to arrive. Otherwise a conversion needed in that gap would
+            // throw. This is the same thing BaseSetupHandler does during setup, but for cashes added at runtime.
+            try
+            {
+                AlgorithmUtils.SeedCurrencyConversionRates(_algorithm);
+            }
+            catch (Exception err)
+            {
+                // Seeding must never break the algorithm, the rate will be set on the first conversion pair bar
+                Log.Error($"UniverseSelection.EnsureCurrencyDataFeeds(): failed to seed runtime currency conversion rate(s): {err.Message}");
+            }
         }
 
         /// <summary>
diff --git a/Engine/Setup/BaseSetupHandler.cs b/Engine/Setup/BaseSetupHandler.cs
@@ -84,26 +84,13 @@ public static void SetupCurrencyConversions(
             IReadOnlyCollection<string> currenciesToUpdateWhiteList = null)
         {
             // this is needed to have non-zero currency conversion rates during warmup
-            // will also set the Cash.ConversionRateSecurity
-            universeSelection.EnsureCurrencyDataFeeds(SecurityChanges.None);
+            // will also set the Cash.ConversionRateSecurity.
+            // We don't let it seed the conversion rates here because we do that right below,
+            // where we can also limit the seeding to a specific white list of currencies
+            universeSelection.EnsureCurrencyDataFeeds(SecurityChanges.None, seedNewCurrencies: false);
 
             // now set conversion rates
-            Func<Cash, bool> cashToUpdateFilter = currenciesToUpdateWhiteList == null
-                ? (x) => x.CurrencyConversion != null && x.ConversionRate == 0
-                : (x) => currenciesToUpdateWhiteList.Contains(x.Symbol);
-            var cashToUpdate = algorithm.Portfolio.CashBook.Values.Where(cashToUpdateFilter).ToList();
-
-            var securitiesToUpdate = cashToUpdate
-                .SelectMany(x => x.CurrencyConversion.ConversionRateSecurities)
-                .Distinct()
-                .ToList();
-
-            AlgorithmUtils.SeedSecurities(securitiesToUpdate, algorithm);
-
-            foreach (var cash in cashToUpdate)
-            {
-                cash.Update();
-            }
+            AlgorithmUtils.SeedCurrencyConversionRates(algorithm, currenciesToUpdateWhiteList);
 
             Log.Trace($"BaseSetupHandler.SetupCurrencyConversions():{Environment.NewLine}" +
                 $"Account Type: {algorithm.BrokerageModel.AccountType}{Environment.NewLine}{Environment.NewLine}{algorithm.Portfolio.CashBook}");
diff --git a/Tests/Engine/Setup/BaseSetupHandlerTests.cs b/Tests/Engine/Setup/BaseSetupHandlerTests.cs

Original file line number	Diff line number	Diff line change
`@@ -131,8 +131,14 @@ public IEnumerable<SubscriptionDataConfig> GetPendingSubscriptionDataConfigs()`
`131`	`131`	`/// <summary>`
`132`	`132`	`/// Checks the current <see cref="SubscriptionDataConfig"/> and adds new necessary currency pair feeds to provide real time conversion data`
`133`	`133`	`/// </summary>`
`134`		`- public void EnsureCurrencySubscriptionDataConfigs(SecurityChanges securityChanges, IBrokerageModel brokerageModel)`
	`134`	`+ /// <returns>True if a new currency was introduced, either as a new internal conversion feed or as a new cash`
	`135`	`+ /// entry added to the cashbook. Lets callers skip follow up work like seeding the new conversion rates when`
	`136`	`+ /// nothing was added</returns>`
	`137`	`+ public bool EnsureCurrencySubscriptionDataConfigs(SecurityChanges securityChanges, IBrokerageModel brokerageModel)`
`135`	`138`	`{`
	`139`	`+ // a new cash added to the cashbook also needs its conversion rate seeded, even when its conversion`
	`140`	`+ // security is an already subscribed one and no new internal feed is introduced below`
	`141`	`+ var newCashAdded = _ensureCurrencyDataFeeds;`
`136`	`142`	`_ensureCurrencyDataFeeds = false;`
`137`	`143`	`// remove any 'to be added' if the security has already been added`
`138`	`144`	`_toBeAddedCurrencySubscriptionDataConfigs.RemoveWhere(`
`@@ -150,6 +156,8 @@ public void EnsureCurrencySubscriptionDataConfigs(SecurityChanges securityChange`
`150`	`156`	`_toBeAddedCurrencySubscriptionDataConfigs.Add(config);`
`151`	`157`	`}`
`152`	`158`	`_pendingSubscriptionDataConfigs = _toBeAddedCurrencySubscriptionDataConfigs.Any();`
	`159`	`+`
	`160`	`+ return newConfigs.Count > 0 \|\| newCashAdded;`
`153`	`161`	`}`
`154`	`162`	`}`
`155`	`163`	`}`