@riocrypto/common 1.0.2715 → 1.0.2716

package/build/events/lmax-trade-updated-event.d.ts

@@ -0,0 +1,7 @@
+import { Subjects } from "./subjects";
+export interface LmaxTradeUpdatedEvent {
+    subject: Subjects.LmaxTradeUpdated;
+    data: {
+        id: string;
+    };
+}

package/build/events/lmax-trade-updated-event.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/events/rio-settings-updated-event.d.ts

@@ -1,6 +1,7 @@
 import { Country } from "../types/country";
 import { DeferredPaymentType } from "../types/deferred-payment-type";
 import { Fiat } from "../types/fiat";
+import { FXPriceSourcePolicies } from "../types/fx-price-source-policy";
 import { FXProvider } from "../types/fx-provider";
 import { FXTradingPolicies } from "../types/fx-trading-policy";
 import { Side } from "../types/side";
@@ -69,6 +70,7 @@ export interface RioSettingsUpdatedEvent {
         TVFXDataProvider?: {
             [key in Fiat]?: TVFXDataProvider;
         };
+        fxPriceSources?: FXPriceSourcePolicies;
         defaultTwoWaySettlementDateOffsetFee?: {
             [key in Country]?: {
                 [key in Side]?: {

package/build/events/subjects.d.ts

@@ -203,6 +203,7 @@ export declare enum Subjects {
     STPDepositCLABECreated = "stpDepositCLABE:created",
     ExternalTradeUpdated = "externalTrade:updated",
     StonexTradeUpdated = "stonexTrade:updated",
+    LmaxTradeUpdated = "lmaxTrade:updated",
     ExternalTradeRetryCompleted = "externalTrade:retryCompleted",
     AxeCreated = "axe:created",
     AxePartiallyTaken = "axe:partiallyTaken",

package/build/events/subjects.js

@@ -207,6 +207,7 @@ var Subjects;
     Subjects["STPDepositCLABECreated"] = "stpDepositCLABE:created";
     Subjects["ExternalTradeUpdated"] = "externalTrade:updated";
     Subjects["StonexTradeUpdated"] = "stonexTrade:updated";
+    Subjects["LmaxTradeUpdated"] = "lmaxTrade:updated";
     Subjects["ExternalTradeRetryCompleted"] = "externalTrade:retryCompleted";
     Subjects["AxeCreated"] = "axe:created";
     Subjects["AxePartiallyTaken"] = "axe:partiallyTaken";

package/build/helpers/get-minute-of-day-in-timezone.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Returns the minute-of-day in the given IANA timezone, in [0, 1440).
+ *
+ * Uses `Intl.DateTimeFormat` so DST transitions are handled by the
+ * platform rather than by manual offset arithmetic. Mexico stopped
+ * observing DST in 2022, but Peru, Colombia and the US windows this is
+ * also used for should not depend on that staying true.
+ *
+ * `now` is injectable so a caller evaluating several policies in one
+ * pass can pin a single timestamp and avoid straddling a minute
+ * boundary partway through.
+ */
+export declare const getMinuteOfDayInTimezone: (now: Date, timezone: string) => number;

package/build/helpers/get-minute-of-day-in-timezone.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMinuteOfDayInTimezone = void 0;
+/**
+ * Returns the minute-of-day in the given IANA timezone, in [0, 1440).
+ *
+ * Uses `Intl.DateTimeFormat` so DST transitions are handled by the
+ * platform rather than by manual offset arithmetic. Mexico stopped
+ * observing DST in 2022, but Peru, Colombia and the US windows this is
+ * also used for should not depend on that staying true.
+ *
+ * `now` is injectable so a caller evaluating several policies in one
+ * pass can pin a single timestamp and avoid straddling a minute
+ * boundary partway through.
+ */
+const getMinuteOfDayInTimezone = (now, timezone) => {
+    const parts = new Intl.DateTimeFormat("en-US", {
+        timeZone: timezone,
+        hour12: false,
+        hour: "2-digit",
+        minute: "2-digit",
+    }).formatToParts(now);
+    let hour = 0;
+    let minute = 0;
+    for (const part of parts) {
+        if (part.type === "hour")
+            hour = parseInt(part.value, 10);
+        if (part.type === "minute")
+            minute = parseInt(part.value, 10);
+    }
+    // Some Node versions format midnight as hour 24. Clamping keeps the
+    // result inside [0, 1440) so a window ending at 1440 is still matched.
+    if (hour === 24)
+        hour = 0;
+    return hour * 60 + minute;
+};
+exports.getMinuteOfDayInTimezone = getMinuteOfDayInTimezone;

package/build/helpers/resolve-fx-price-source.d.ts

@@ -0,0 +1,65 @@
+import { Fiat } from "../types/fiat";
+import { FXPriceSource, FXPriceSourceReason } from "../types/fx-price-source";
+import { FXPriceSourcePolicyForFiat, FXPriceSourceWindow } from "../types/fx-price-source-policy";
+export interface ResolvedFXPriceSource {
+    source: FXPriceSource;
+    reason: FXPriceSourceReason;
+    matchedWindow?: FXPriceSourceWindow;
+}
+/**
+ * The source a fiat is priced from when it has no policy at all, which
+ * is how every fiat looked before this setting existed.
+ *
+ * Per-fiat, and defined as the head of that fiat's selectable list, so
+ * each currency falls back to its own established publisher: TradingView
+ * for MXN, Bloomberg for PEN, SET-ICAP for COP. A single hard-coded
+ * default would have quietly pointed PEN and COP at a feed that does not
+ * quote them.
+ */
+export declare const getDefaultFXPriceSource: (fiat: Fiat) => FXPriceSource;
+export declare const isWellFormedFXPriceSourceWindow: (window: FXPriceSourceWindow, fiat: Fiat) => boolean;
+/**
+ * Resolve which source a fiat's canonical rate should be taken from
+ * right now, according to configuration alone.
+ *
+ * This deliberately knows nothing about whether that source is actually
+ * healthy. Configuration resolution is stable and shared, so it lives
+ * here and the dashboard can call it to show an operator which feed is
+ * scheduled to be active without a round trip. Deciding to abandon an
+ * unhealthy source is a separate, faster-moving judgement that belongs
+ * to the arbiter in `market-data`, next to the observations it needs.
+ *
+ * Precedence is override, then schedule, then primary. Malformed
+ * configuration falls back rather than throwing: this sits on the path
+ * that writes the platform's spot rate several times a second, and a
+ * bad hand-edit in Mongo should degrade to the previous behavior instead
+ * of stopping pricing.
+ */
+export declare const resolveConfiguredFXPriceSource: (policy: FXPriceSourcePolicyForFiat | undefined, fiat: Fiat, now?: Date) => ResolvedFXPriceSource;
+/**
+ * The single statement of the window coverage rule, shared by the
+ * throwing validator on the `rio-settings` PATCH and by the dashboard
+ * editor's inline check, so the two cannot disagree about what a valid
+ * schedule is.
+ *
+ * Returns a human-readable description of the first problem, or null
+ * when the list is acceptable. An empty list is acceptable and means no
+ * schedule is configured.
+ *
+ * Windows must be ordered, strictly contiguous, start at 0 and end at
+ * 1440, matching `validateFXTradingPolicies`. Order is significant and
+ * is not sorted first on purpose: if an operator's rows are out of
+ * order, saying so is more useful than silently reinterpreting them.
+ */
+export declare const findFXPriceSourceWindowCoverageIssue: (windows: FXPriceSourceWindow[], fiat: Fiat) => string | null;
+/**
+ * Builds the contiguous three-window day that covers the common case of
+ * "use a different source for one stretch of the afternoon", so neither
+ * the operator nor the dashboard has to assemble the filler rows by
+ * hand. Returns a single full-day window when the stretch covers
+ * everything.
+ *
+ * Requiring full coverage is what makes the stored policy unambiguous;
+ * it should not also make the routine edit tedious.
+ */
+export declare const buildContiguousFXPriceSourceWindows: (baseSource: FXPriceSource, windowSource: FXPriceSource, startMinute: number, endMinute: number) => FXPriceSourceWindow[];

package/build/helpers/resolve-fx-price-source.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildContiguousFXPriceSourceWindows = exports.findFXPriceSourceWindowCoverageIssue = exports.resolveConfiguredFXPriceSource = exports.isWellFormedFXPriceSourceWindow = exports.getDefaultFXPriceSource = void 0;
+const fx_price_source_1 = require("../types/fx-price-source");
+const fx_price_source_policy_1 = require("../types/fx-price-source-policy");
+const get_country_for_fiat_1 = require("./get-country-for-fiat");
+const get_country_timezone_1 = require("./get-country-timezone");
+const get_minute_of_day_in_timezone_1 = require("./get-minute-of-day-in-timezone");
+/**
+ * The source a fiat is priced from when it has no policy at all, which
+ * is how every fiat looked before this setting existed.
+ *
+ * Per-fiat, and defined as the head of that fiat's selectable list, so
+ * each currency falls back to its own established publisher: TradingView
+ * for MXN, Bloomberg for PEN, SET-ICAP for COP. A single hard-coded
+ * default would have quietly pointed PEN and COP at a feed that does not
+ * quote them.
+ */
+const getDefaultFXPriceSource = (fiat) => { var _a; return (_a = (0, fx_price_source_1.getSelectableFXPriceSources)(fiat)[0]) !== null && _a !== void 0 ? _a : fx_price_source_1.FXPriceSource.CurrencyAPI; };
+exports.getDefaultFXPriceSource = getDefaultFXPriceSource;
+const defaultResolution = (fiat) => ({
+    source: (0, exports.getDefaultFXPriceSource)(fiat),
+    reason: fx_price_source_1.FXPriceSourceReason.Primary,
+});
+const isWellFormedFXPriceSourceWindow = (window, fiat) => {
+    if (!window)
+        return false;
+    const { startMinute, endMinute, source } = window;
+    if (!Number.isInteger(startMinute) || !Number.isInteger(endMinute)) {
+        return false;
+    }
+    if (startMinute < 0 || endMinute > fx_price_source_policy_1.MINUTES_IN_DAY)
+        return false;
+    if (startMinute >= endMinute)
+        return false;
+    return (0, fx_price_source_1.isSelectableFXPriceSource)(fiat, source);
+};
+exports.isWellFormedFXPriceSourceWindow = isWellFormedFXPriceSourceWindow;
+const windowMatchesMinute = (window, minuteOfDay) => minuteOfDay >= window.startMinute && minuteOfDay < window.endMinute;
+/**
+ * Resolve which source a fiat's canonical rate should be taken from
+ * right now, according to configuration alone.
+ *
+ * This deliberately knows nothing about whether that source is actually
+ * healthy. Configuration resolution is stable and shared, so it lives
+ * here and the dashboard can call it to show an operator which feed is
+ * scheduled to be active without a round trip. Deciding to abandon an
+ * unhealthy source is a separate, faster-moving judgement that belongs
+ * to the arbiter in `market-data`, next to the observations it needs.
+ *
+ * Precedence is override, then schedule, then primary. Malformed
+ * configuration falls back rather than throwing: this sits on the path
+ * that writes the platform's spot rate several times a second, and a
+ * bad hand-edit in Mongo should degrade to the previous behavior instead
+ * of stopping pricing.
+ */
+const resolveConfiguredFXPriceSource = (policy, fiat, now = new Date()) => {
+    var _a;
+    if (!policy)
+        return defaultResolution(fiat);
+    const override = policy.override;
+    if (override &&
+        (0, fx_price_source_1.isSelectableFXPriceSource)(fiat, override.source) &&
+        override.expiresAt &&
+        new Date(override.expiresAt).getTime() > now.getTime()) {
+        return {
+            source: override.source,
+            reason: fx_price_source_1.FXPriceSourceReason.Override,
+        };
+    }
+    const primary = (0, fx_price_source_1.isSelectableFXPriceSource)(fiat, policy.primarySource)
+        ? policy.primarySource
+        : (0, exports.getDefaultFXPriceSource)(fiat);
+    if (policy.mode !== fx_price_source_policy_1.FXPriceSourceMode.Scheduled) {
+        return { source: primary, reason: fx_price_source_1.FXPriceSourceReason.Primary };
+    }
+    const windows = (_a = policy.windows) !== null && _a !== void 0 ? _a : [];
+    if (windows.length === 0) {
+        return { source: primary, reason: fx_price_source_1.FXPriceSourceReason.Primary };
+    }
+    const timezone = (0, get_country_timezone_1.getCountryTimezone)((0, get_country_for_fiat_1.getCountryForFiat)(fiat));
+    const minuteOfDay = (0, get_minute_of_day_in_timezone_1.getMinuteOfDayInTimezone)(now, timezone);
+    const matchedWindow = windows.find((window) => (0, exports.isWellFormedFXPriceSourceWindow)(window, fiat) &&
+        windowMatchesMinute(window, minuteOfDay));
+    // Validated windows cover the whole day, so a miss means the stored
+    // policy is malformed. Falling back to the primary keeps pricing
+    // running on the previous behavior rather than stopping it.
+    if (!matchedWindow) {
+        return { source: primary, reason: fx_price_source_1.FXPriceSourceReason.Primary };
+    }
+    return {
+        source: matchedWindow.source,
+        reason: fx_price_source_1.FXPriceSourceReason.Schedule,
+        matchedWindow,
+    };
+};
+exports.resolveConfiguredFXPriceSource = resolveConfiguredFXPriceSource;
+/**
+ * The single statement of the window coverage rule, shared by the
+ * throwing validator on the `rio-settings` PATCH and by the dashboard
+ * editor's inline check, so the two cannot disagree about what a valid
+ * schedule is.
+ *
+ * Returns a human-readable description of the first problem, or null
+ * when the list is acceptable. An empty list is acceptable and means no
+ * schedule is configured.
+ *
+ * Windows must be ordered, strictly contiguous, start at 0 and end at
+ * 1440, matching `validateFXTradingPolicies`. Order is significant and
+ * is not sorted first on purpose: if an operator's rows are out of
+ * order, saying so is more useful than silently reinterpreting them.
+ */
+const findFXPriceSourceWindowCoverageIssue = (windows, fiat) => {
+    if (!Array.isArray(windows))
+        return "windows must be an array";
+    if (windows.length === 0)
+        return null;
+    for (let i = 0; i < windows.length; i += 1) {
+        if (!(0, exports.isWellFormedFXPriceSourceWindow)(windows[i], fiat)) {
+            return `window[${i}] needs whole-minute startMinute < endMinute within 0..${fx_price_source_policy_1.MINUTES_IN_DAY} and a source selectable for ${fiat} (${(0, fx_price_source_1.getSelectableFXPriceSources)(fiat).join(", ")})`;
+        }
+    }
+    if (windows[0].startMinute !== 0) {
+        return `window[0].startMinute must be 0`;
+    }
+    for (let i = 0; i < windows.length - 1; i += 1) {
+        if (windows[i + 1].startMinute !== windows[i].endMinute) {
+            return `windows must be contiguous: window[${i}].endMinute (${windows[i].endMinute}) must equal window[${i + 1}].startMinute (${windows[i + 1].startMinute})`;
+        }
+    }
+    const last = windows[windows.length - 1];
+    if (last.endMinute !== fx_price_source_policy_1.MINUTES_IN_DAY) {
+        return `window[${windows.length - 1}].endMinute must be ${fx_price_source_policy_1.MINUTES_IN_DAY} so the windows cover the full day`;
+    }
+    return null;
+};
+exports.findFXPriceSourceWindowCoverageIssue = findFXPriceSourceWindowCoverageIssue;
+/**
+ * Builds the contiguous three-window day that covers the common case of
+ * "use a different source for one stretch of the afternoon", so neither
+ * the operator nor the dashboard has to assemble the filler rows by
+ * hand. Returns a single full-day window when the stretch covers
+ * everything.
+ *
+ * Requiring full coverage is what makes the stored policy unambiguous;
+ * it should not also make the routine edit tedious.
+ */
+const buildContiguousFXPriceSourceWindows = (baseSource, windowSource, startMinute, endMinute) => {
+    const windows = [];
+    if (startMinute > 0) {
+        windows.push({ startMinute: 0, endMinute: startMinute, source: baseSource });
+    }
+    windows.push({ startMinute, endMinute, source: windowSource });
+    if (endMinute < fx_price_source_policy_1.MINUTES_IN_DAY) {
+        windows.push({
+            startMinute: endMinute,
+            endMinute: fx_price_source_policy_1.MINUTES_IN_DAY,
+            source: baseSource,
+        });
+    }
+    return windows;
+};
+exports.buildContiguousFXPriceSourceWindows = buildContiguousFXPriceSourceWindows;

package/build/index.d.ts

@@ -267,6 +267,7 @@ export * from "./events/bank-account-needs-review-event";
 export * from "./events/bank-account-verification-dispatched-event";
 export * from "./events/external-trade-updated-event";
 export * from "./events/stonex-trade-updated-event";
+export * from "./events/lmax-trade-updated-event";
 export * from "./events/binance-rfq-order-settlement-completed-event";
 export * from "./events/bank-account-verification-actual-account-holder-name-obtained-event";
 export * from "./events/user-onboarding-ready-for-review-slack-message-sent-event";
@@ -412,6 +413,8 @@ export * from "./types/arbitrage-alert";
 export * from "./types/arbitrage-asset";
 export * from "./types/arbitrage-frequency";
 export * from "./types/arbitrage-provider";
+export * from "./types/fx-price-source";
+export * from "./types/fx-price-source-policy";
 export * from "./types/fx-provider";
 export * from "./types/fx-trading-policy";
 export * from "./types/liquidity-automation-frequency";
@@ -483,6 +486,13 @@ export * from "./types/stonex-settlement-type";
 export * from "./types/stonex-log";
 export * from "./types/stonex-order-type";
 export * from "./types/stonex-time-in-force";
+export * from "./types/lmax-fx-trade";
+export * from "./types/lmax-fx-trade-status";
+export * from "./types/lmax-order-book";
+export * from "./types/lmax-balances";
+export * from "./types/lmax-side";
+export * from "./types/lmax-order-type";
+export * from "./types/lmax-time-in-force";
 export * from "./types/emarkets-bot-status";
 export * from "./types/transnetwork-bot-status";
 export * from "./types/inbound-bank-deposit";
@@ -578,6 +588,8 @@ export * from "./helpers/get-country-timezone";
 export * from "./helpers/get-active-platform-fee-ranges";
 export * from "./helpers/find-platform-fee-range-conflict";
 export * from "./helpers/get-country-for-fiat";
+export * from "./helpers/get-minute-of-day-in-timezone";
+export * from "./helpers/resolve-fx-price-source";
 export * from "./helpers/get-processors-for-corridor";
 export * from "./helpers/get-default-processor";
 export * from "./helpers/get-routing-candidates";

package/build/index.js

@@ -283,6 +283,7 @@ __exportStar(require("./events/bank-account-needs-review-event"), exports);
 __exportStar(require("./events/bank-account-verification-dispatched-event"), exports);
 __exportStar(require("./events/external-trade-updated-event"), exports);
 __exportStar(require("./events/stonex-trade-updated-event"), exports);
+__exportStar(require("./events/lmax-trade-updated-event"), exports);
 __exportStar(require("./events/binance-rfq-order-settlement-completed-event"), exports);
 __exportStar(require("./events/bank-account-verification-actual-account-holder-name-obtained-event"), exports);
 __exportStar(require("./events/user-onboarding-ready-for-review-slack-message-sent-event"), exports);
@@ -428,6 +429,8 @@ __exportStar(require("./types/arbitrage-alert"), exports);
 __exportStar(require("./types/arbitrage-asset"), exports);
 __exportStar(require("./types/arbitrage-frequency"), exports);
 __exportStar(require("./types/arbitrage-provider"), exports);
+__exportStar(require("./types/fx-price-source"), exports);
+__exportStar(require("./types/fx-price-source-policy"), exports);
 __exportStar(require("./types/fx-provider"), exports);
 __exportStar(require("./types/fx-trading-policy"), exports);
 __exportStar(require("./types/liquidity-automation-frequency"), exports);
@@ -499,6 +502,13 @@ __exportStar(require("./types/stonex-settlement-type"), exports);
 __exportStar(require("./types/stonex-log"), exports);
 __exportStar(require("./types/stonex-order-type"), exports);
 __exportStar(require("./types/stonex-time-in-force"), exports);
+__exportStar(require("./types/lmax-fx-trade"), exports);
+__exportStar(require("./types/lmax-fx-trade-status"), exports);
+__exportStar(require("./types/lmax-order-book"), exports);
+__exportStar(require("./types/lmax-balances"), exports);
+__exportStar(require("./types/lmax-side"), exports);
+__exportStar(require("./types/lmax-order-type"), exports);
+__exportStar(require("./types/lmax-time-in-force"), exports);
 __exportStar(require("./types/emarkets-bot-status"), exports);
 __exportStar(require("./types/transnetwork-bot-status"), exports);
 __exportStar(require("./types/inbound-bank-deposit"), exports);
@@ -594,6 +604,8 @@ __exportStar(require("./helpers/get-country-timezone"), exports);
 __exportStar(require("./helpers/get-active-platform-fee-ranges"), exports);
 __exportStar(require("./helpers/find-platform-fee-range-conflict"), exports);
 __exportStar(require("./helpers/get-country-for-fiat"), exports);
+__exportStar(require("./helpers/get-minute-of-day-in-timezone"), exports);
+__exportStar(require("./helpers/resolve-fx-price-source"), exports);
 __exportStar(require("./helpers/get-processors-for-corridor"), exports);
 __exportStar(require("./helpers/get-default-processor"), exports);
 __exportStar(require("./helpers/get-routing-candidates"), exports);

package/build/types/dashboard-table-type.d.ts

@@ -36,5 +36,6 @@ export declare enum DashboardTableType {
     IndicativeQuotePages = "indicativeQuotePages",
     BulkPayments = "bulkPayments",
     StonexOrders = "stonexOrders",
+    LmaxOrders = "lmaxOrders",
     CircleOrders = "circleOrders"
 }

package/build/types/dashboard-table-type.js

@@ -40,5 +40,6 @@ var DashboardTableType;
     DashboardTableType["IndicativeQuotePages"] = "indicativeQuotePages";
     DashboardTableType["BulkPayments"] = "bulkPayments";
     DashboardTableType["StonexOrders"] = "stonexOrders";
+    DashboardTableType["LmaxOrders"] = "lmaxOrders";
     DashboardTableType["CircleOrders"] = "circleOrders";
 })(DashboardTableType = exports.DashboardTableType || (exports.DashboardTableType = {}));

package/build/types/external-trade.d.ts

@@ -4,6 +4,9 @@ import { ExternalTradeStatus } from "./external-trade-status";
 import { ExternalTradeType } from "./external-trade-type";
 import { ExternalTradingProvider } from "./external-trading-provider";
 import { Fiat } from "./fiat";
+import { LmaxOrderType } from "./lmax-order-type";
+import { LmaxSide } from "./lmax-side";
+import { LmaxTimeInForce } from "./lmax-time-in-force";
 import { Side } from "./side";
 import { StonexSettlementType } from "./stonex-settlement-type";
 export interface ExternalTrade {
@@ -64,6 +67,25 @@ export interface ExternalTrade {
             rate?: number;
             takeQuoteTradeKey?: string;
         };
+        lmax?: {
+            instrumentId?: string;
+            symbol?: string;
+            lmaxSide?: LmaxSide;
+            quantity?: number;
+            orderType?: LmaxOrderType;
+            timeInForce?: LmaxTimeInForce;
+            price?: number;
+            stopPrice?: number;
+            instructionId?: string;
+            orderId?: string;
+            matchedQuantity?: number;
+            unfilledQuantity?: number;
+            cumulativeMatchedQuantity?: number;
+            cancelledQuantity?: number;
+            matchedCost?: number;
+            commission?: number;
+            text?: string;
+        };
     };
     externalTradingAlgorithmId?: string;
     arbitrageSessionId?: string;

package/build/types/external-trading-provider.d.ts

@@ -4,6 +4,7 @@ export declare enum ExternalTradingProvider {
     Binance = "binance",
     Transnetwork = "transnetwork",
     StoneX = "stonex",
+    Lmax = "lmax",
     Kraken = "kraken",
     Coinbase = "coinbase",
     CircleRLI = "circleRLI",

package/build/types/external-trading-provider.js

@@ -8,6 +8,7 @@ var ExternalTradingProvider;
     ExternalTradingProvider["Binance"] = "binance";
     ExternalTradingProvider["Transnetwork"] = "transnetwork";
     ExternalTradingProvider["StoneX"] = "stonex";
+    ExternalTradingProvider["Lmax"] = "lmax";
     ExternalTradingProvider["Kraken"] = "kraken";
     ExternalTradingProvider["Coinbase"] = "coinbase";
     ExternalTradingProvider["CircleRLI"] = "circleRLI";

package/build/types/fx-price-source-policy.d.ts

@@ -0,0 +1,156 @@
+import { Fiat } from "./fiat";
+import { FXPriceSource } from "./fx-price-source";
+export declare enum FXPriceSourceMode {
+    /** Always use `primarySource`. Time windows are ignored. */
+    Manual = "manual",
+    /** Use the matching time window if there is one, else `primarySource`. */
+    Scheduled = "scheduled"
+}
+/**
+ * One time-of-day window naming the source a fiat is priced from while
+ * it is active.
+ *
+ * Minutes are from midnight in the currency's country-local timezone and
+ * the window is `[startMinute, endMinute)`.
+ *
+ * Windows follow the same coverage rule as `FXTradingPolicyTimeRange`:
+ * ordered, strictly contiguous, first starting at 0 and last ending at
+ * 1440, so every moment of the day maps to exactly one window. An empty
+ * list means "no schedule configured" and the resolver uses
+ * `primarySource`. A window spanning midnight is split into two rows
+ * with the same source rather than wrapping around.
+ *
+ * The cost of full coverage is that switching a fiat to LMAX for the
+ * Mexico City afternoon takes three rows rather than one. The benefit is
+ * that the configuration says what it means at every minute, an operator
+ * reading it does not have to hold "and the rest of the day is the
+ * primary" in their head, and the editor can render a single unbroken
+ * timeline they can check at a glance.
+ */
+export interface FXPriceSourceWindow {
+    startMinute: number;
+    endMinute: number;
+    source: FXPriceSource;
+}
+/**
+ * When a source is considered unhealthy.
+ *
+ * `staleMs` is measured against the last report of any kind, and catches
+ * a dead publisher. `staticMs` is measured against the last time the
+ * value actually moved, and catches a publisher that is alive but whose
+ * upstream has frozen. The second is the one that matters for the
+ * TradingView USDMXN scrape, which keeps answering through the Mexico
+ * City afternoon while its number stops moving.
+ *
+ * `staticMs` needs headroom over a genuinely quiet market or it will cry
+ * wolf overnight and at weekends, which is why it is far larger than
+ * `staleMs` and why the defaults differ per source.
+ */
+export interface FXPriceSourceHealthThresholds {
+    staleMs: number;
+    staticMs: number;
+}
+export interface FXPriceSourcePolicyForFiat {
+    mode: FXPriceSourceMode;
+    /**
+     * The source used in `Manual` mode.
+     *
+     * In `Scheduled` mode the windows cover the whole day, so this is only
+     * reached defensively, when the schedule is empty or a hand-edit in
+     * Mongo has left it malformed. It is kept required rather than
+     * optional precisely so that path always has somewhere safe to land:
+     * this sits on the code that writes the platform's spot rate several
+     * times a second, and "no source configured" must never be a
+     * reachable state.
+     */
+    primarySource: FXPriceSource;
+    /**
+     * Ordered, contiguous windows covering `[0, 1440)`. Only consulted
+     * when `mode` is `Scheduled`. Empty means no schedule.
+     */
+    windows?: FXPriceSourceWindow[];
+    /**
+     * Operator escape hatch for incidents. Wins over both the schedule and
+     * the primary while it is unexpired.
+     *
+     * The expiry is mandatory by construction rather than optional: an
+     * override with no end is how a temporary incident workaround becomes
+     * permanent undocumented behavior. `rio-settings` already sets the
+     * precedent of expiring a manually-set rate via cron with
+     * `previousDayUSDMXNConversionRate`.
+     */
+    override?: {
+        source: FXPriceSource;
+        expiresAt: Date;
+    };
+    /**
+     * Per-source overrides of `DEFAULT_FX_PRICE_SOURCE_HEALTH`. Absent
+     * entries take the default.
+     */
+    health?: {
+        [key in FXPriceSource]?: FXPriceSourceHealthThresholds;
+    };
+    /**
+     * Whether an unhealthy active source should hand over to the other
+     * healthy source.
+     *
+     * Off is the rollback, and reproduces today's behavior exactly: the
+     * feed is left where it is, the alert still fires, and a rate that goes
+     * far enough out of date is picked up by the currencyapi refresh in
+     * `market-data` as it always has been. Defaults to on.
+     */
+    failoverEnabled?: boolean;
+}
+export type FXPriceSourcePolicies = {
+    [key in Fiat]?: FXPriceSourcePolicyForFiat;
+};
+/**
+ * Health thresholds used when a fiat has no explicit override.
+ *
+ * TradingView is scraped roughly twice a second, so 30s without any
+ * report already means the publisher is gone; this matches the existing
+ * MXN staleness alert threshold in `exchange-rates-bot`. Its static
+ * window is deliberately generous because a scraped "last price" legally
+ * does sit still in thin conditions.
+ *
+ * LMAX is a live venue stream. It is allowed longer between ticks,
+ * because a quiet book genuinely does not print, but much less time
+ * frozen, because a top-of-book that has not moved in two minutes during
+ * a session means the stream is broken rather than the market is calm.
+ */
+/**
+ * How often `market-data` asks currencyapi for a rate purely to prove the
+ * fallback still works.
+ *
+ * The fallback is otherwise only called once every live feed has gone
+ * quiet, which means that without a probe its health is unknown exactly
+ * until the moment it is needed. Each sweep is a single request covering
+ * every fiat, and the interval is deliberately long: this answers "would
+ * the parachute open", not "what is the price right now".
+ */
+export declare const CURRENCY_API_PROBE_INTERVAL_MS: number;
+/**
+ * How often currencyapi is polled while it is the selected source for at
+ * least one fiat.
+ *
+ * Standby cadence is far too slow to price against: it would leave the
+ * canonical rate up to half an hour old. Selecting currencyapi therefore
+ * switches it to a real polling loop. It is still not a stream, and the
+ * upstream refresh rate depends on the account plan, so this is the floor
+ * on how fresh a currencyapi-priced rate can be, not a promise of it.
+ */
+export declare const CURRENCY_API_ACTIVE_POLL_INTERVAL_MS: number;
+/**
+ * Thresholds applied to currencyapi while it is the active source.
+ *
+ * The standby defaults are sized for a half-hourly probe and would let a
+ * dead feed price trades for over an hour before anyone noticed, which is
+ * unacceptable once it is the thing quoting customers. `staticMs` stays
+ * generous for the same reason it does on standby: the upstream rate can
+ * legitimately hold still for a long time on the lower plans.
+ */
+export declare const CURRENCY_API_ACTIVE_HEALTH: FXPriceSourceHealthThresholds;
+export declare const DEFAULT_FX_PRICE_SOURCE_HEALTH: {
+    [key in FXPriceSource]: FXPriceSourceHealthThresholds;
+};
+export declare const MINUTES_IN_DAY = 1440;

package/build/types/fx-price-source-policy.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MINUTES_IN_DAY = exports.DEFAULT_FX_PRICE_SOURCE_HEALTH = exports.CURRENCY_API_ACTIVE_HEALTH = exports.CURRENCY_API_ACTIVE_POLL_INTERVAL_MS = exports.CURRENCY_API_PROBE_INTERVAL_MS = exports.FXPriceSourceMode = void 0;
+const fx_price_source_1 = require("./fx-price-source");
+var FXPriceSourceMode;
+(function (FXPriceSourceMode) {
+    /** Always use `primarySource`. Time windows are ignored. */
+    FXPriceSourceMode["Manual"] = "manual";
+    /** Use the matching time window if there is one, else `primarySource`. */
+    FXPriceSourceMode["Scheduled"] = "scheduled";
+})(FXPriceSourceMode = exports.FXPriceSourceMode || (exports.FXPriceSourceMode = {}));
+/**
+ * Health thresholds used when a fiat has no explicit override.
+ *
+ * TradingView is scraped roughly twice a second, so 30s without any
+ * report already means the publisher is gone; this matches the existing
+ * MXN staleness alert threshold in `exchange-rates-bot`. Its static
+ * window is deliberately generous because a scraped "last price" legally
+ * does sit still in thin conditions.
+ *
+ * LMAX is a live venue stream. It is allowed longer between ticks,
+ * because a quiet book genuinely does not print, but much less time
+ * frozen, because a top-of-book that has not moved in two minutes during
+ * a session means the stream is broken rather than the market is calm.
+ */
+/**
+ * How often `market-data` asks currencyapi for a rate purely to prove the
+ * fallback still works.
+ *
+ * The fallback is otherwise only called once every live feed has gone
+ * quiet, which means that without a probe its health is unknown exactly
+ * until the moment it is needed. Each sweep is a single request covering
+ * every fiat, and the interval is deliberately long: this answers "would
+ * the parachute open", not "what is the price right now".
+ */
+exports.CURRENCY_API_PROBE_INTERVAL_MS = 30 * 60 * 1000;
+/**
+ * Static-price detection turned off, expressed as a threshold no real
+ * gap will cross rather than as a special case in the evaluator.
+ *
+ * Used for sources whose price legitimately holds still for long
+ * stretches, where a motionless number says nothing about whether the
+ * feed works. SET-ICAP publishes a closing rate that is fixed overnight,
+ * Bloomberg Línea's USDPEN quote sits still outside Lima market hours,
+ * and currencyapi's own refresh rate is as slow as daily on the lower
+ * account plans. For all three, reachability is the only real signal, and
+ * that is what `staleMs` already measures.
+ */
+const STATIC_CHECK_DISABLED_MS = 26 * 60 * 60 * 1000;
+/**
+ * How often currencyapi is polled while it is the selected source for at
+ * least one fiat.
+ *
+ * Standby cadence is far too slow to price against: it would leave the
+ * canonical rate up to half an hour old. Selecting currencyapi therefore
+ * switches it to a real polling loop. It is still not a stream, and the
+ * upstream refresh rate depends on the account plan, so this is the floor
+ * on how fresh a currencyapi-priced rate can be, not a promise of it.
+ */
+exports.CURRENCY_API_ACTIVE_POLL_INTERVAL_MS = 60 * 1000;
+/**
+ * Thresholds applied to currencyapi while it is the active source.
+ *
+ * The standby defaults are sized for a half-hourly probe and would let a
+ * dead feed price trades for over an hour before anyone noticed, which is
+ * unacceptable once it is the thing quoting customers. `staticMs` stays
+ * generous for the same reason it does on standby: the upstream rate can
+ * legitimately hold still for a long time on the lower plans.
+ */
+exports.CURRENCY_API_ACTIVE_HEALTH = {
+    staleMs: exports.CURRENCY_API_ACTIVE_POLL_INTERVAL_MS * 3,
+    staticMs: STATIC_CHECK_DISABLED_MS,
+};
+exports.DEFAULT_FX_PRICE_SOURCE_HEALTH = {
+    [fx_price_source_1.FXPriceSource.TradingView]: {
+        staleMs: 30 * 1000,
+        staticMs: 10 * 60 * 1000,
+    },
+    [fx_price_source_1.FXPriceSource.Lmax]: {
+        staleMs: 60 * 1000,
+        staticMs: 2 * 60 * 1000,
+    },
+    /**
+     * Bloomberg Línea is scraped for USDPEN once a minute, so four minutes
+     * of silence means the scrape is broken rather than merely slow. This
+     * matches the window after which the currencyapi fallback would step in
+     * for PEN anyway, so the alert and the handover line up.
+     */
+    [fx_price_source_1.FXPriceSource.Bloomberg]: {
+        staleMs: 4 * 60 * 1000,
+        staticMs: STATIC_CHECK_DISABLED_MS,
+    },
+    /**
+     * SET-ICAP is polled every 15 seconds; two minutes of nothing is a real
+     * outage rather than a slow response.
+     */
+    [fx_price_source_1.FXPriceSource.SetIcap]: {
+        staleMs: 2 * 60 * 1000,
+        staticMs: STATIC_CHECK_DISABLED_MS,
+    },
+    [fx_price_source_1.FXPriceSource.CurrencyAPI]: {
+        staleMs: exports.CURRENCY_API_PROBE_INTERVAL_MS * 2.5,
+        staticMs: STATIC_CHECK_DISABLED_MS,
+    },
+};
+exports.MINUTES_IN_DAY = 1440;

package/build/types/fx-price-source.d.ts

@@ -0,0 +1,119 @@
+import { Fiat } from "./fiat";
+import { TVFXDataProvider } from "./TV-FX-data-provider";
+/**
+ * An upstream that can produce a spot FX mid for a fiat.
+ *
+ * Distinct from `FXProvider`, which is where a trade is *executed*.
+ * A source only answers "where did this price come from". LMAX appears
+ * in both enums because we both price off it and trade on it.
+ *
+ * `CurrencyAPI` is the only source available for every fiat, because it
+ * is both selectable and the automatic last resort. The rest are tied to
+ * particular currencies by what actually publishes them: TradingView and
+ * LMAX quote USDMXN, Bloomberg Línea is scraped for USDPEN, and SET-ICAP
+ * is the Colombian interbank reference for USDCOP.
+ */
+export declare enum FXPriceSource {
+    TradingView = "tradingview",
+    Lmax = "lmax",
+    Bloomberg = "bloomberg",
+    SetIcap = "seticap",
+    CurrencyAPI = "currencyapi"
+}
+/**
+ * Sources an operator may configure for a given fiat, in display order.
+ *
+ * Per-fiat rather than one global list because the sources are not
+ * interchangeable: there is no LMAX book for COP and no SET-ICAP feed for
+ * MXN, so a single list would offer choices that cannot be honoured. The
+ * arbiter, the settings validator and the dashboard all read this, which
+ * is what keeps an impossible combination from being selectable in the
+ * first place rather than failing later.
+ *
+ * `CurrencyAPI` is last for every fiat, and is selectable as well as
+ * being the automatic fallback, so a reference rate can be chosen
+ * deliberately rather than only being reached once the real feed is gone.
+ * Choosing it is not free: it is a periodic REST poll rather than a live
+ * feed, so `market-data` polls it far harder while it is the active
+ * source and tightens its health thresholds to match. See
+ * `CURRENCY_API_ACTIVE_POLL_INTERVAL_MS`.
+ */
+export declare const SELECTABLE_FX_PRICE_SOURCES_BY_FIAT: {
+    [key in Fiat]?: FXPriceSource[];
+};
+/** Fiats whose price feed is configurable at all. */
+export declare const FIATS_WITH_SELECTABLE_SOURCES: Fiat[];
+export declare const getSelectableFXPriceSources: (fiat: Fiat) => FXPriceSource[];
+export declare const isSelectableFXPriceSource: (fiat: Fiat, source: unknown) => source is FXPriceSource;
+/**
+ * One source's latest reading for one fiat, as reported to the arbiter.
+ *
+ * `value` is always units of fiat per 1 USD (the `conversionRatesFromUSD`
+ * convention), so a source that natively quotes the inverse converts
+ * before reporting. Reporting both directions was considered and
+ * rejected: two numbers that must agree is a bug waiting to happen, and
+ * the arbiter already derives the inverse when it writes.
+ *
+ * `bid` / `ask` are optional because only a real venue has them. They
+ * are recorded for operator comparison and are not used in pricing
+ * today, since the canonical rate carries a single value.
+ *
+ * `tvProvider` is only meaningful when the reporting source is
+ * TradingView, and names which TradingView exchange the scrape came
+ * from. Which exchange to scrape stays a concern of the scraper, so this
+ * is carried as provenance rather than as something the arbiter decides.
+ */
+export interface FXPriceObservation {
+    value: number;
+    lastUpdated: Date;
+    /**
+     * When `value` last actually moved. The arbiter uses this, not
+     * `lastUpdated`, to decide a feed has gone static: a scraper that is
+     * happily returning the same stale number every 500ms is still
+     * "updating" but is no longer telling us anything.
+     */
+    lastPriceChangedAt?: Date;
+    bid?: number;
+    ask?: number;
+    tvProvider?: TVFXDataProvider;
+}
+/**
+ * Why a given source ended up active. Recorded on the canonical rate and
+ * surfaced in the dashboard so an operator can tell a deliberate
+ * schedule switch apart from a silent failover.
+ */
+export declare enum FXPriceSourceReason {
+    Override = "override",
+    Schedule = "schedule",
+    Primary = "primary",
+    Failover = "failover"
+}
+/**
+ * The arbiter's answer to a reported observation.
+ *
+ * `accepted` false is a normal, expected outcome, not an error: it means
+ * the report was recorded but another source is currently active. A
+ * producer publishing twice a second cannot treat losing as a failure,
+ * so this is a 200 with `accepted: false` rather than a 4xx, and the
+ * distinction matters for what gets alerted on.
+ */
+export interface FXPriceObservationResult {
+    accepted: boolean;
+    activeSource: FXPriceSource;
+    reason: FXPriceSourceReason;
+    /** The canonical fiat-per-USD rate after this report was handled. */
+    value?: number;
+    /** Set when the report was rejected as implausible rather than merely losing. */
+    rejectedReason?: string;
+}
+/**
+ * Why a source is considered unhealthy. `Static` is the failure mode
+ * that motivated per-source pricing in the first place: the TradingView
+ * USDMXN scrape keeps responding through the Mexico City afternoon but
+ * stops moving.
+ */
+export declare enum FXPriceSourceHealthIssue {
+    NeverReported = "neverReported",
+    Stale = "stale",
+    Static = "static"
+}

package/build/types/fx-price-source.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FXPriceSourceHealthIssue = exports.FXPriceSourceReason = exports.isSelectableFXPriceSource = exports.getSelectableFXPriceSources = exports.FIATS_WITH_SELECTABLE_SOURCES = exports.SELECTABLE_FX_PRICE_SOURCES_BY_FIAT = exports.FXPriceSource = void 0;
+const fiat_1 = require("./fiat");
+/**
+ * An upstream that can produce a spot FX mid for a fiat.
+ *
+ * Distinct from `FXProvider`, which is where a trade is *executed*.
+ * A source only answers "where did this price come from". LMAX appears
+ * in both enums because we both price off it and trade on it.
+ *
+ * `CurrencyAPI` is the only source available for every fiat, because it
+ * is both selectable and the automatic last resort. The rest are tied to
+ * particular currencies by what actually publishes them: TradingView and
+ * LMAX quote USDMXN, Bloomberg Línea is scraped for USDPEN, and SET-ICAP
+ * is the Colombian interbank reference for USDCOP.
+ */
+var FXPriceSource;
+(function (FXPriceSource) {
+    FXPriceSource["TradingView"] = "tradingview";
+    FXPriceSource["Lmax"] = "lmax";
+    FXPriceSource["Bloomberg"] = "bloomberg";
+    FXPriceSource["SetIcap"] = "seticap";
+    FXPriceSource["CurrencyAPI"] = "currencyapi";
+})(FXPriceSource = exports.FXPriceSource || (exports.FXPriceSource = {}));
+/**
+ * Sources an operator may configure for a given fiat, in display order.
+ *
+ * Per-fiat rather than one global list because the sources are not
+ * interchangeable: there is no LMAX book for COP and no SET-ICAP feed for
+ * MXN, so a single list would offer choices that cannot be honoured. The
+ * arbiter, the settings validator and the dashboard all read this, which
+ * is what keeps an impossible combination from being selectable in the
+ * first place rather than failing later.
+ *
+ * `CurrencyAPI` is last for every fiat, and is selectable as well as
+ * being the automatic fallback, so a reference rate can be chosen
+ * deliberately rather than only being reached once the real feed is gone.
+ * Choosing it is not free: it is a periodic REST poll rather than a live
+ * feed, so `market-data` polls it far harder while it is the active
+ * source and tightens its health thresholds to match. See
+ * `CURRENCY_API_ACTIVE_POLL_INTERVAL_MS`.
+ */
+exports.SELECTABLE_FX_PRICE_SOURCES_BY_FIAT = {
+    [fiat_1.Fiat.MXN]: [
+        FXPriceSource.TradingView,
+        FXPriceSource.Lmax,
+        FXPriceSource.CurrencyAPI,
+    ],
+    [fiat_1.Fiat.PEN]: [FXPriceSource.Bloomberg, FXPriceSource.CurrencyAPI],
+    [fiat_1.Fiat.COP]: [FXPriceSource.SetIcap, FXPriceSource.CurrencyAPI],
+};
+/** Fiats whose price feed is configurable at all. */
+exports.FIATS_WITH_SELECTABLE_SOURCES = Object.keys(exports.SELECTABLE_FX_PRICE_SOURCES_BY_FIAT);
+const getSelectableFXPriceSources = (fiat) => { var _a; return (_a = exports.SELECTABLE_FX_PRICE_SOURCES_BY_FIAT[fiat]) !== null && _a !== void 0 ? _a : []; };
+exports.getSelectableFXPriceSources = getSelectableFXPriceSources;
+const isSelectableFXPriceSource = (fiat, source) => (0, exports.getSelectableFXPriceSources)(fiat).includes(source);
+exports.isSelectableFXPriceSource = isSelectableFXPriceSource;
+/**
+ * Why a given source ended up active. Recorded on the canonical rate and
+ * surfaced in the dashboard so an operator can tell a deliberate
+ * schedule switch apart from a silent failover.
+ */
+var FXPriceSourceReason;
+(function (FXPriceSourceReason) {
+    FXPriceSourceReason["Override"] = "override";
+    FXPriceSourceReason["Schedule"] = "schedule";
+    FXPriceSourceReason["Primary"] = "primary";
+    FXPriceSourceReason["Failover"] = "failover";
+})(FXPriceSourceReason = exports.FXPriceSourceReason || (exports.FXPriceSourceReason = {}));
+/**
+ * Why a source is considered unhealthy. `Static` is the failure mode
+ * that motivated per-source pricing in the first place: the TradingView
+ * USDMXN scrape keeps responding through the Mexico City afternoon but
+ * stops moving.
+ */
+var FXPriceSourceHealthIssue;
+(function (FXPriceSourceHealthIssue) {
+    FXPriceSourceHealthIssue["NeverReported"] = "neverReported";
+    FXPriceSourceHealthIssue["Stale"] = "stale";
+    FXPriceSourceHealthIssue["Static"] = "static";
+})(FXPriceSourceHealthIssue = exports.FXPriceSourceHealthIssue || (exports.FXPriceSourceHealthIssue = {}));

package/build/types/fx-provider.d.ts

@@ -6,5 +6,6 @@ export declare enum FXProvider {
     Bitso = "bitso",
     Binance = "binance",
     StoneX = "stonex",
+    Lmax = "lmax",
     Other = "other"
 }

package/build/types/fx-provider.js

@@ -10,5 +10,6 @@ var FXProvider;
     FXProvider["Bitso"] = "bitso";
     FXProvider["Binance"] = "binance";
     FXProvider["StoneX"] = "stonex";
+    FXProvider["Lmax"] = "lmax";
     FXProvider["Other"] = "other";
 })(FXProvider = exports.FXProvider || (exports.FXProvider = {}));

package/build/types/lmax-balances.d.ts

@@ -0,0 +1,7 @@
+export interface LmaxBalances {
+    accountId?: string;
+    usd: number;
+    mxn: number;
+    live: boolean;
+    timestamp?: Date;
+}

package/build/types/lmax-balances.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/types/lmax-fx-trade-status.d.ts

@@ -0,0 +1,11 @@
+export declare enum LmaxFXTradeStatus {
+    Submitting = "submitting",
+    PendingNew = "pendingNew",
+    New = "new",
+    PartiallyFilled = "partiallyFilled",
+    Filled = "filled",
+    Cancelled = "cancelled",
+    Rejected = "rejected",
+    Expired = "expired",
+    Failed = "failed"
+}

package/build/types/lmax-fx-trade-status.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LmaxFXTradeStatus = void 0;
+var LmaxFXTradeStatus;
+(function (LmaxFXTradeStatus) {
+    LmaxFXTradeStatus["Submitting"] = "submitting";
+    LmaxFXTradeStatus["PendingNew"] = "pendingNew";
+    LmaxFXTradeStatus["New"] = "new";
+    LmaxFXTradeStatus["PartiallyFilled"] = "partiallyFilled";
+    LmaxFXTradeStatus["Filled"] = "filled";
+    LmaxFXTradeStatus["Cancelled"] = "cancelled";
+    LmaxFXTradeStatus["Rejected"] = "rejected";
+    LmaxFXTradeStatus["Expired"] = "expired";
+    LmaxFXTradeStatus["Failed"] = "failed";
+})(LmaxFXTradeStatus = exports.LmaxFXTradeStatus || (exports.LmaxFXTradeStatus = {}));

package/build/types/lmax-fx-trade.d.ts

@@ -0,0 +1,35 @@
+import { LmaxFXTradeStatus } from "./lmax-fx-trade-status";
+import { LmaxOrderType } from "./lmax-order-type";
+import { LmaxSide } from "./lmax-side";
+import { LmaxTimeInForce } from "./lmax-time-in-force";
+import { Side } from "./side";
+export interface LmaxFXTrade {
+    id: string;
+    createdAt: Date;
+    status: LmaxFXTradeStatus;
+    side: Side;
+    lmaxSide: LmaxSide;
+    instrumentId: string;
+    symbol: string;
+    originCurrency: string;
+    destinationCurrency: string;
+    quantity: number;
+    orderType: LmaxOrderType;
+    timeInForce: LmaxTimeInForce;
+    price?: number;
+    stopPrice?: number;
+    instructionId: string;
+    cancelInstructionId?: string;
+    orderId?: string;
+    tradeKey?: string;
+    matchedQuantity?: number;
+    unfilledQuantity?: number;
+    cumulativeMatchedQuantity?: number;
+    cancelledQuantity?: number;
+    matchedCost?: number;
+    commission?: number;
+    avgPrice?: number;
+    text?: string;
+    submitted?: boolean;
+    submitAttempts?: number;
+}

package/build/types/lmax-fx-trade.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/types/lmax-order-book.d.ts

@@ -0,0 +1,20 @@
+export interface LmaxOrderBookLevel {
+    price: number;
+    quantity: number;
+}
+export interface LmaxOrderBook {
+    instrumentId: string;
+    symbol: string;
+    streaming: boolean;
+    status?: string;
+    stale?: boolean;
+    bid?: LmaxOrderBookLevel;
+    ask?: LmaxOrderBookLevel;
+    timestamp?: Date;
+    baseCurrency?: string;
+    quoteCurrency?: string;
+    minimumQuantity?: number;
+    quantityIncrement?: number;
+    priceIncrement?: number;
+    maxOrderUsd?: number;
+}

package/build/types/lmax-order-book.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/types/lmax-order-type.d.ts

@@ -0,0 +1,6 @@
+export declare enum LmaxOrderType {
+    Market = "MARKET",
+    Limit = "LIMIT",
+    Stop = "STOP",
+    StopLimit = "STOP_LIMIT"
+}

package/build/types/lmax-order-type.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LmaxOrderType = void 0;
+// LMAX Account API order-type strings.
+var LmaxOrderType;
+(function (LmaxOrderType) {
+    LmaxOrderType["Market"] = "MARKET";
+    LmaxOrderType["Limit"] = "LIMIT";
+    LmaxOrderType["Stop"] = "STOP";
+    LmaxOrderType["StopLimit"] = "STOP_LIMIT";
+})(LmaxOrderType = exports.LmaxOrderType || (exports.LmaxOrderType = {}));

package/build/types/lmax-side.d.ts

@@ -0,0 +1,4 @@
+export declare enum LmaxSide {
+    Bid = "BID",
+    Ask = "ASK"
+}

package/build/types/lmax-side.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LmaxSide = void 0;
+// LMAX Account API side strings (buy/sell the instrument base currency).
+var LmaxSide;
+(function (LmaxSide) {
+    LmaxSide["Bid"] = "BID";
+    LmaxSide["Ask"] = "ASK";
+})(LmaxSide = exports.LmaxSide || (exports.LmaxSide = {}));

package/build/types/lmax-time-in-force.d.ts

@@ -0,0 +1,6 @@
+export declare enum LmaxTimeInForce {
+    FillOrKill = "FILL_OR_KILL",
+    ImmediateOrCancel = "IMMEDIATE_OR_CANCEL",
+    GoodForDay = "GOOD_FOR_DAY",
+    GoodTilCancelled = "GOOD_TIL_CANCELLED"
+}

package/build/types/lmax-time-in-force.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LmaxTimeInForce = void 0;
+// LMAX Account API time-in-force strings.
+var LmaxTimeInForce;
+(function (LmaxTimeInForce) {
+    LmaxTimeInForce["FillOrKill"] = "FILL_OR_KILL";
+    LmaxTimeInForce["ImmediateOrCancel"] = "IMMEDIATE_OR_CANCEL";
+    LmaxTimeInForce["GoodForDay"] = "GOOD_FOR_DAY";
+    LmaxTimeInForce["GoodTilCancelled"] = "GOOD_TIL_CANCELLED";
+})(LmaxTimeInForce = exports.LmaxTimeInForce || (exports.LmaxTimeInForce = {}));

package/build/types/market-data.d.ts

@@ -1,24 +1,35 @@
+import { FXPriceSource } from "./fx-price-source";
 import { TVFXDataProvider } from "./TV-FX-data-provider";
+/**
+ * The canonical spot rate for one fiat, in one direction.
+ *
+ * `provider` predates multi-source pricing and names a TradingView
+ * exchange. It stays populated when the winning source is TradingView
+ * and is left unset otherwise, so existing readers that switch on
+ * `TVFXDataProvider` keep seeing either a value they understand or the
+ * `undefined` they already tolerate.
+ *
+ * `bot` is legacy and is superseded by `source`. It was a boolean
+ * standing in for "came from the scraper rather than the currencyapi
+ * fallback", which stopped being expressible as a boolean once there was
+ * more than one real feed. It is still written for the benefit of
+ * existing readers; new code should branch on `source`.
+ */
+export interface ConversionRate {
+    value: number;
+    source?: FXPriceSource;
+    provider?: TVFXDataProvider;
+    bot?: boolean;
+    frozen?: boolean;
+    lastUpdated: Date;
+    lastPriceChangedAt?: Date;
+}
 export interface MarketData {
     conversionRatesToUSD: {
-        [key: string]: {
-            value: number;
-            provider?: TVFXDataProvider;
-            bot?: boolean;
-            frozen?: boolean;
-            lastUpdated: Date;
-            lastPriceChangedAt?: Date;
-        };
+        [key: string]: ConversionRate;
     };
     conversionRatesFromUSD: {
-        [key: string]: {
-            value: number;
-            provider?: TVFXDataProvider;
-            bot?: boolean;
-            frozen?: boolean;
-            lastUpdated: Date;
-            lastPriceChangedAt?: Date;
-        };
+        [key: string]: ConversionRate;
     };
     assetPricesInUSD: {
         [key: string]: {

package/build/types/rio-settings-update.d.ts

@@ -1,5 +1,6 @@
 import { Country } from "./country";
 import { Fiat } from "./fiat";
+import { FXPriceSourcePolicies } from "./fx-price-source-policy";
 import { FXProvider } from "./fx-provider";
 import { FXTradingPolicies } from "./fx-trading-policy";
 import { Side } from "./side";
@@ -56,6 +57,7 @@ export interface RioSettingsUpdate {
     TVFXDataProvider?: {
         [key in Fiat]: TVFXDataProvider;
     };
+    fxPriceSources?: FXPriceSourcePolicies;
     defaultTwoWaySettlementDateOffsetFee?: {
         [key in Country]?: {
             [key in Side]?: {

package/build/types/rio-settings.d.ts

@@ -2,6 +2,7 @@ import { Country } from "./country";
 import { Crypto } from "./crypto";
 import { DeferredPaymentType } from "./deferred-payment-type";
 import { Fiat } from "./fiat";
+import { FXPriceSourcePolicies } from "./fx-price-source-policy";
 import { FXProvider } from "./fx-provider";
 import { FXTradingPolicies } from "./fx-trading-policy";
 import { ProcessorRoutingConfig } from "./processor-routing";
@@ -74,6 +75,19 @@ export interface RioSettings {
     TVFXDataProvider: {
         [key in Fiat]?: TVFXDataProvider;
     };
+    /**
+     * Which upstream feed the canonical spot rate for each fiat is taken
+     * from, and when. Resolved by `market-data`, which is the only writer
+     * of the canonical rate.
+     *
+     * `TVFXDataProvider` above is the narrower question of *which
+     * TradingView exchange* to scrape, and only has any effect while the
+     * resolved source for that fiat is TradingView.
+     *
+     * Absent for a fiat means TradingView with no schedule, which is how
+     * pricing behaved before this setting existed.
+     */
+    fxPriceSources?: FXPriceSourcePolicies;
     defaultTwoWaySettlementDateOffsetFee?: {
         [key in Country]?: {
             [key in Side]?: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@riocrypto/common",
-  "version": "1.0.2715",
+  "version": "1.0.2716",
   "description": "",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",