@riocrypto/common-server 1.0.2909 → 1.0.2911

package/build/clients/cluster-client.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 /// <reference types="node" />
-import { Quote, Fiat, Crypto, BitsoBankAccount, Side, Country, Order, CryptoAddress, BankAccount, AuthRole, Auth, ImportOrderData, TreasuryProvider, FXProvider, EmarketsFXTrade, ExternalTradingAlgorithm, ExternalTrade, ExternalTradeType, ExternalTradingProvider, ExternalTradingAlgorithmType, STPMXNWithdrawal, AuthPermission, DeferredPaymentType, TwoWaySettlementType, OrderType, EmarketsSettlementType, EmarketsOrderType, BulkBankPayout, BulkCryptoPayout, BulkBankPayment, BulkCryptoPayment, OrderStatus, TWAPSession, TransnetworkFXTrade, TransnetworkSettlementType, TransnetworkOrderType, AuthMethod, StonexFXTrade, CancelExternalTradeReason } from "@riocrypto/common";
+import { Quote, Fiat, Crypto, BitsoBankAccount, Side, Country, Order, CryptoAddress, BankAccount, AuthRole, Auth, ImportOrderData, TreasuryProvider, FXProvider, EmarketsFXTrade, ExternalTradingAlgorithm, ExternalTrade, ExternalTradeType, ExternalTradingProvider, ExternalTradingAlgorithmType, STPMXNWithdrawal, AuthPermission, DeferredPaymentType, TwoWaySettlementType, OrderType, EmarketsSettlementType, EmarketsOrderType, BulkBankPayout, BulkCryptoPayout, BulkBankPayment, BulkCryptoPayment, OrderStatus, TWAPSession, TransnetworkFXTrade, TransnetworkSettlementType, TransnetworkOrderType, AuthMethod, StonexFXTrade, LmaxFXTrade, CancelExternalTradeReason, FXPriceSource, FXPriceObservationResult, TVFXDataProvider } from "@riocrypto/common";
 import { STPMXNWithdrawalDoc } from "../models/STP-mxn-withdrawal";
 import { FintocMXNWithdrawalDoc } from "../models/fintoc-mxn-withdrawal";
 export interface FintocTransfer {
@@ -343,6 +343,30 @@ declare class ClusterClient {
         tradeKey: string;
     }): Promise<StonexFXTrade>;
     getStonexTrade(tradeId: string): Promise<StonexFXTrade>;
+    placeLmaxOrder(params: {
+        originCurrency: string;
+        destinationCurrency: string;
+        side: string;
+        orderType: string;
+        timeInForce?: string;
+        requestedOriginAmount?: number;
+        requestedDestinationAmount?: number;
+        price?: number;
+        stopPrice?: number;
+        tradeKey: string;
+    }): Promise<LmaxFXTrade>;
+    getLmaxTrade(tradeId: string): Promise<LmaxFXTrade>;
+    getLmaxTradeByKey(tradeKey: string): Promise<LmaxFXTrade | null>;
+    cancelLmaxTrade(tradeId: string): Promise<LmaxFXTrade>;
+    reportFXPriceObservation(params: {
+        fiat: Fiat;
+        source: FXPriceSource;
+        value: number;
+        bid?: number;
+        ask?: number;
+        tvProvider?: TVFXDataProvider;
+        bypassBasisPointsCheck?: boolean;
+    }): Promise<FXPriceObservationResult>;
     getStonexTradeByKey(tradeKey: string): Promise<StonexFXTrade | null>;
     getStonexTrades(offset: number, limit: number): Promise<{
         data: StonexFXTrade[];

package/build/clients/cluster-client.js

@@ -17,6 +17,16 @@ const common_1 = require("@riocrypto/common");
 const https_1 = __importDefault(require("https"));
 const axios_with_logging_1 = require("./axios-with-logging");
 const secret_manager_client_1 = require("./secret-manager-client");
+/**
+ * Deadline for one FX price report.
+ *
+ * Generous enough for a round trip through the public ingress, and short
+ * enough that a stalled path costs a gap in reports rather than a
+ * publisher that never sends again. Comfortably inside the staleness
+ * thresholds market-data judges these feeds by, so an abandoned report
+ * does not by itself make a source look dead.
+ */
+const FX_OBSERVATION_TIMEOUT_MS = 5000;
 class ClusterClient {
     constructor(baseUrl, clusterApiKey) {
         this.baseUrl = baseUrl;
@@ -955,6 +965,78 @@ class ClusterClient {
             return response.data;
         });
     }
+    placeLmaxOrder(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { tradeKey } = params;
+            const response = yield this.axios.post(`${this.baseUrl}/api/lmax/place-order`, params, {
+                headers: {
+                    "x-cluster-api-key": this.clusterApiKey,
+                    "X-Trade-Key": tradeKey,
+                },
+            });
+            return response.data;
+        });
+    }
+    getLmaxTrade(tradeId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.axios.get(`${this.baseUrl}/api/lmax/trades/${tradeId}`, { headers: { "x-cluster-api-key": this.clusterApiKey } });
+            return response.data;
+        });
+    }
+    getLmaxTradeByKey(tradeKey) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield this.axios.get(`${this.baseUrl}/api/lmax/trades/by-trade-key/${encodeURIComponent(tradeKey)}`, { headers: { "x-cluster-api-key": this.clusterApiKey } });
+                return response.data;
+            }
+            catch (err) {
+                if (typeof err === "object" &&
+                    err !== null &&
+                    "response" in err &&
+                    ((_a = err.response) === null || _a === void 0 ? void 0 : _a.status) === 404) {
+                    return null;
+                }
+                throw err;
+            }
+        });
+    }
+    cancelLmaxTrade(tradeId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.axios.post(`${this.baseUrl}/api/lmax/cancel-trade/${tradeId}`, {}, { headers: { "x-cluster-api-key": this.clusterApiKey } });
+            return response.data;
+        });
+    }
+    // Report one source's latest spot reading to market-data, which decides
+    // whether it becomes the canonical rate.
+    //
+    // `value` is always units of fiat per 1 USD, whichever way round the
+    // source natively quotes, because market-data derives the inverse
+    // itself and two numbers that have to agree is a bug waiting to
+    // happen.
+    //
+    // Callers publish on every tick, so this is called several times a
+    // second and every caller must attach a catch. An unhandled rejection
+    // here would take the publisher down on the first blip, and a blip in
+    // one feed is precisely when the other one needs to still be running.
+    // Losing arbitration is not an error: a 200 with `accepted: false`
+    // means the report was recorded while another source is active.
+    reportFXPriceObservation(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.axios.post(`${this.baseUrl}/api/market/data/fx-observation`, params, {
+                headers: { "x-cluster-api-key": this.clusterApiKey },
+                // The shared axios instance has no default timeout, which is fine
+                // for the request/response calls on this client but not for one
+                // published on a fixed interval. Without a deadline a stalled
+                // ingest path leaves requests open indefinitely and the publisher
+                // accumulates them. Scoped to this call rather than set as a
+                // client default, because several endpoints here are legitimately
+                // slow and would start failing.
+                timeout: FX_OBSERVATION_TIMEOUT_MS,
+            });
+            return response.data;
+        });
+    }
     // Reconcile helper: look up a Stonex trade by caller-supplied trade key.
     // Returns null when the key has no matching trade (the server either
     // never received the request or failed before persisting). External-trading

package/build/clients/currency-api-client.d.ts

@@ -4,6 +4,18 @@ declare class CurrencyAPIClient {
     private axiosClient;
     constructor(apiKey: string);
     convert(from: Fiat, to: Fiat): Promise<number>;
+    /**
+     * Fetch several rates against one base in a single request.
+     *
+     * `convert` issues one request per pair, so checking three currencies
+     * through it costs three calls against a metered quota. The `currencies`
+     * parameter takes a comma-separated list, so the same answer costs one.
+     *
+     * Intentionally not cached: the only caller is a health probe, and a
+     * cached hit would report the fallback as reachable when the last real
+     * request may have failed.
+     */
+    getLatestRates(baseCurrency: Fiat, currencies: Fiat[]): Promise<Partial<Record<Fiat, number>>>;
     getHistoricalExchangeRates(from: Fiat, to: Fiat, start: string, end: string): Promise<any>;
 }
 export declare const buildCurrencyAPIClient: () => Promise<CurrencyAPIClient>;

package/build/clients/currency-api-client.js

@@ -44,7 +44,11 @@ class CurrencyAPIClient {
                 if (!cachedResponse) {
                     throw new common_1.GenericInternalError(`Unable to get exchange rate from currencyAPI for ${from} to ${to}`);
                 }
-                const exchangeRate = cachedResponse.data[to].value;
+                // Assigns the outer binding deliberately. Declaring a local here
+                // shadowed it, so the cached rate was computed and thrown away and
+                // the zero check below then threw, which made this whole fallback
+                // unreachable on the one path it exists for.
+                exchangeRate = cachedResponse.data[to].value;
             }
             if (!exchangeRate) {
                 (_a = logger_1.default.getLogger()) === null || _a === void 0 ? void 0 : _a.error("Unable to get exchange rate");
@@ -53,6 +57,35 @@ class CurrencyAPIClient {
             return exchangeRate;
         });
     }
+    /**
+     * Fetch several rates against one base in a single request.
+     *
+     * `convert` issues one request per pair, so checking three currencies
+     * through it costs three calls against a metered quota. The `currencies`
+     * parameter takes a comma-separated list, so the same answer costs one.
+     *
+     * Intentionally not cached: the only caller is a health probe, and a
+     * cached hit would report the fallback as reachable when the last real
+     * request may have failed.
+     */
+    getLatestRates(baseCurrency, currencies) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.axiosClient.get(`https://api.currencyapi.com/v3/latest?apikey=${this.apiKey}&base_currency=${baseCurrency}&currencies=${currencies.join(",")}`);
+            const data = (_a = response.data) === null || _a === void 0 ? void 0 : _a.data;
+            if (!data) {
+                throw new common_1.GenericInternalError(`Unable to get latest exchange rates from currencyAPI for ${baseCurrency}`);
+            }
+            const rates = {};
+            for (const currency of currencies) {
+                const value = (_b = data[currency]) === null || _b === void 0 ? void 0 : _b.value;
+                if (typeof value === "number" && value > 0) {
+                    rates[currency] = value;
+                }
+            }
+            return rates;
+        });
+    }
     getHistoricalExchangeRates(from, to, start, end) {
         return __awaiter(this, void 0, void 0, function* () {
             try {

package/build/helpers/get-fx-trading-policy.d.ts

@@ -5,6 +5,18 @@ import { Fiat, FXTradingSidePolicy, RioSettings, ResolvedFXPlacement, Side } fro
  * provider, not a per-policy admin setting.
  */
 export declare const TRANSNETWORK_MIN_MXN_AMOUNT = 1000000;
+/**
+ * LMAX quotes USD/MXN in whole 1,000-USD increments and the lmax service
+ * rounds the requested size onto the nearest one. A hedge can therefore
+ * come back either short or long of the FX trade's fiat amount by up to
+ * half an increment, which callers reconciling `amountTraded` against
+ * `amount` have to tolerate in both directions. Bands smaller than one
+ * increment cannot be hedged on LMAX at all - the placement is rejected
+ * outright rather than rounded up - and operators express that with the
+ * band's own `minAmount` rather than a hardcoded fiat floor here, since
+ * the USD/MXN rate that would convert it moves.
+ */
+export declare const LMAX_QUANTITY_INCREMENT = 1000;
 type RioSettingsForPolicy = Pick<RioSettings, "fxTradingPolicies">;
 /**
  * Resolve the active FX trading side-policy for a given (fiat, side, offset).

package/build/helpers/get-fx-trading-policy.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveFXProviderForAmount = exports.getFXTradingPolicy = exports.TRANSNETWORK_MIN_MXN_AMOUNT = void 0;
+exports.resolveFXProviderForAmount = exports.getFXTradingPolicy = exports.LMAX_QUANTITY_INCREMENT = exports.TRANSNETWORK_MIN_MXN_AMOUNT = void 0;
 const common_1 = require("@riocrypto/common");
 /**
  * Minimum trade size (in MXN) below which the Transnetwork bot will reject
@@ -12,13 +12,29 @@ exports.TRANSNETWORK_MIN_MXN_AMOUNT = 1000000;
  * Settlement-offset constraints baked into provider eligibility. The
  * Emarkets and Transnetwork bots only quote spot / very-short-dated MXN
  * (T+0..T+2), and StoneX is RFQ/RFS for forward MXN (T+1+) and refuses
- * same-day (T+0). Keep these in sync with
- * `isProviderSelectableForFiatAndOffset` in the dashboard's
- * fx-trading-policy-card so saved policies match what the runtime will
- * actually pick.
+ * same-day (T+0). LMAX is a spot-only order-book venue: external-trading
+ * places LMAX orders with no settlement offset at all, so it is only
+ * eligible for T+0. Operators that want to hedge a longer-dated band on
+ * LMAX do so explicitly via `tradeAsTwoWaySettlementDateOffset: 0`.
+ * Keep these in sync with `isProviderSelectableForFiatAndOffset` in the
+ * dashboard's fx-trading-policy-card so saved policies match what the
+ * runtime will actually pick.
  */
 const SHORT_DATED_BOT_MAX_OFFSET = 2;
 const STONEX_MIN_OFFSET = 1;
+const LMAX_MAX_OFFSET = 0;
+/**
+ * LMAX quotes USD/MXN in whole 1,000-USD increments and the lmax service
+ * rounds the requested size onto the nearest one. A hedge can therefore
+ * come back either short or long of the FX trade's fiat amount by up to
+ * half an increment, which callers reconciling `amountTraded` against
+ * `amount` have to tolerate in both directions. Bands smaller than one
+ * increment cannot be hedged on LMAX at all - the placement is rejected
+ * outright rather than rounded up - and operators express that with the
+ * band's own `minAmount` rather than a hardcoded fiat floor here, since
+ * the USD/MXN rate that would convert it moves.
+ */
+exports.LMAX_QUANTITY_INCREMENT = 1000;
 /**
  * Providers that do not support a cosigner approval workflow. For these
  * providers the `automatic` flag is meaningless and the runtime always
@@ -145,13 +161,15 @@ exports.getFXTradingPolicy = getFXTradingPolicy;
  *
  * `offset === undefined` is interpreted as T+0 (the system convention:
  * "no settlement type specified" == "default" == spot), matching
- * `getFXTradingPolicy`. As a result Emarkets / Transnetwork stay eligible
- * for undefined-offset callers but StoneX (which refuses T+0) does not.
+ * `getFXTradingPolicy`. As a result Emarkets / Transnetwork / LMAX stay
+ * eligible for undefined-offset callers but StoneX (which refuses T+0)
+ * does not.
  */
 const isProviderEligible = (provider, fiat, amountFiat, offset) => {
     if (provider === common_1.FXProvider.StoneX ||
         provider === common_1.FXProvider.Emarkets ||
-        provider === common_1.FXProvider.Transnetwork) {
+        provider === common_1.FXProvider.Transnetwork ||
+        provider === common_1.FXProvider.Lmax) {
         if (fiat !== common_1.Fiat.MXN)
             return false;
     }
@@ -169,6 +187,9 @@ const isProviderEligible = (provider, fiat, amountFiat, offset) => {
     if (provider === common_1.FXProvider.StoneX && effectiveOffset < STONEX_MIN_OFFSET) {
         return false;
     }
+    if (provider === common_1.FXProvider.Lmax && effectiveOffset > LMAX_MAX_OFFSET) {
+        return false;
+    }
     return true;
 };
 /**

package/build/index.d.ts

@@ -50,6 +50,7 @@ export * from "./models/internal-swap";
 export * from "./models/bitso-mxn-withdrawal";
 export * from "./models/circle-address-book-recipient";
 export * from "./models/circle-payout";
+export * from "./models/fx-price-observation";
 export * from "./models/market-data";
 export * from "./models/market-price";
 export * from "./models/telegram-session";
@@ -118,6 +119,7 @@ export * from "./models/twap-settlement";
 export * from "./models/transnetwork-fx-trade";
 export * from "./models/stonex-fx-trade";
 export * from "./models/stonex-log";
+export * from "./models/lmax-fx-trade";
 export * from "./models/inbound-bank-deposit";
 export * from "./models/inbound-crypto-deposit";
 export * from "./models/order-log";

package/build/index.js

@@ -66,6 +66,7 @@ __exportStar(require("./models/internal-swap"), exports);
 __exportStar(require("./models/bitso-mxn-withdrawal"), exports);
 __exportStar(require("./models/circle-address-book-recipient"), exports);
 __exportStar(require("./models/circle-payout"), exports);
+__exportStar(require("./models/fx-price-observation"), exports);
 __exportStar(require("./models/market-data"), exports);
 __exportStar(require("./models/market-price"), exports);
 __exportStar(require("./models/telegram-session"), exports);
@@ -134,6 +135,7 @@ __exportStar(require("./models/twap-settlement"), exports);
 __exportStar(require("./models/transnetwork-fx-trade"), exports);
 __exportStar(require("./models/stonex-fx-trade"), exports);
 __exportStar(require("./models/stonex-log"), exports);
+__exportStar(require("./models/lmax-fx-trade"), exports);
 __exportStar(require("./models/inbound-bank-deposit"), exports);
 __exportStar(require("./models/inbound-crypto-deposit"), exports);
 __exportStar(require("./models/order-log"), exports);

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

@@ -1,4 +1,4 @@
-import { Fiat, Side, Crypto, ExternalTradeType, ExternalTradingProvider, ExternalTradeStatus, ExternalTradeAmountType, EmarketsSettlementType } from "@riocrypto/common";
+import { Fiat, Side, Crypto, ExternalTradeType, ExternalTradingProvider, ExternalTradeStatus, ExternalTradeAmountType, EmarketsSettlementType, LmaxOrderType, LmaxSide, LmaxTimeInForce } from "@riocrypto/common";
 import { Mongoose, Model, Document, HydratedDocument } from "mongoose";
 interface ExternalTradeAttrs {
     createdAt: Date;
@@ -49,6 +49,25 @@ interface ExternalTradeAttrs {
             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;
@@ -104,6 +123,25 @@ interface ExternalTradeDoc extends Document {
             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/models/fx-price-observation.d.ts

@@ -0,0 +1,46 @@
+import { Fiat, FXPriceObservation, FXPriceSource } from "@riocrypto/common";
+import { Mongoose, Model, Document, HydratedDocument } from "mongoose";
+/**
+ * One source's latest spot reading for one fiat.
+ *
+ * Deliberately its own collection rather than a field on `MarketData`.
+ * `MarketData` is a single document that roughly a dozen services read
+ * on their hot paths, and observations are written several times a
+ * second by each publisher independently. Keeping them apart means feed
+ * churn never contends with a quote read, and a bug in the ingest path
+ * cannot bloat or corrupt the one document the whole platform prices
+ * from.
+ *
+ * One document per (fiat, source) rather than a single document holding
+ * a map of all of them, so two publishers reporting different sources
+ * never take a lock on the same document. That is the entire reason the
+ * collection was split out, and a shared singleton would have given most
+ * of it back.
+ *
+ * The cost of splitting is that an observation and the canonical rate it
+ * produced are no longer written atomically. The arbiter therefore
+ * writes the canonical rate first and the observation second: a crash
+ * between the two leaves the observation looking stale, which trips the
+ * health alert, rather than leaving it looking fresh while the rate
+ * silently stopped moving. Fail loud, in the direction that gets
+ * noticed.
+ */
+/**
+ * The reading itself is `FXPriceObservation` from `common`, which is
+ * also the shape the ingest route accepts and the dashboard renders.
+ * Only the identifying keys are added here, so there is one definition
+ * of what a reading contains.
+ */
+interface FXPriceObservationAttrs extends FXPriceObservation {
+    fiat: Fiat;
+    source: FXPriceSource;
+}
+interface FXPriceObservationModel extends Model<FXPriceObservationDoc> {
+    build(attrs: FXPriceObservationAttrs): HydratedDocument<FXPriceObservationDoc>;
+}
+interface FXPriceObservationDoc extends Document, FXPriceObservation {
+    fiat: Fiat;
+    source: FXPriceSource;
+}
+declare const buildFXPriceObservation: (mongoose: Mongoose) => FXPriceObservationModel;
+export { buildFXPriceObservation, FXPriceObservationDoc, FXPriceObservationAttrs, };

package/build/models/fx-price-observation.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildFXPriceObservation = void 0;
+const buildFXPriceObservation = (mongoose) => {
+    if (mongoose.models.FXPriceObservation) {
+        return mongoose.model("FXPriceObservation");
+    }
+    const FXPriceObservationSchema = new mongoose.Schema({
+        fiat: {
+            type: String,
+            required: true,
+        },
+        source: {
+            type: String,
+            required: true,
+        },
+        value: {
+            type: Number,
+            required: true,
+        },
+        lastUpdated: {
+            type: Date,
+            required: true,
+        },
+        lastPriceChangedAt: {
+            type: Date,
+        },
+        bid: {
+            type: Number,
+        },
+        ask: {
+            type: Number,
+        },
+        tvProvider: {
+            type: String,
+        },
+    }, {
+        toJSON: {
+            transform(doc, ret) {
+                ret.id = ret._id.valueOf();
+                delete ret._id;
+                delete ret.__v;
+            },
+        },
+    });
+    // At most one row per (fiat, source). The ingest path upserts on this
+    // key, so the uniqueness is what stops a race on the very first report
+    // for a pair from leaving two rows that then take turns being read.
+    FXPriceObservationSchema.index({ fiat: 1, source: 1 }, { unique: true });
+    FXPriceObservationSchema.statics.build = (attrs) => {
+        return new FXPriceObservation(attrs);
+    };
+    const FXPriceObservation = mongoose.model("FXPriceObservation", FXPriceObservationSchema);
+    return FXPriceObservation;
+};
+exports.buildFXPriceObservation = buildFXPriceObservation;

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

@@ -0,0 +1,66 @@
+import { LmaxFXTradeStatus, LmaxOrderType, LmaxSide, LmaxTimeInForce, Side } from "@riocrypto/common";
+import { Mongoose, Model, Document } from "mongoose";
+interface LmaxFXTradeAttrs {
+    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;
+}
+interface LmaxFXTradeDoc extends Document {
+    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;
+}
+interface LmaxFXTradeModel extends Model<LmaxFXTradeDoc> {
+    build(attrs: LmaxFXTradeAttrs): LmaxFXTradeDoc;
+}
+declare const buildLmaxFXTrade: (mongoose: Mongoose) => LmaxFXTradeModel;
+export { buildLmaxFXTrade, LmaxFXTradeDoc, LmaxFXTradeAttrs };

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

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildLmaxFXTrade = void 0;
+const buildLmaxFXTrade = (mongoose) => {
+    if (mongoose.models.LmaxFXTrade) {
+        return mongoose.model("LmaxFXTrade");
+    }
+    const LmaxFXTradeSchema = new mongoose.Schema({
+        createdAt: {
+            type: Date,
+            required: true,
+        },
+        status: {
+            type: String,
+            required: true,
+        },
+        side: {
+            type: String,
+            required: true,
+        },
+        lmaxSide: {
+            type: String,
+            required: true,
+        },
+        instrumentId: {
+            type: String,
+            required: true,
+        },
+        symbol: {
+            type: String,
+            required: true,
+        },
+        originCurrency: {
+            type: String,
+            required: true,
+        },
+        destinationCurrency: {
+            type: String,
+            required: true,
+        },
+        quantity: {
+            type: Number,
+            required: true,
+        },
+        orderType: {
+            type: String,
+            required: true,
+        },
+        timeInForce: {
+            type: String,
+            required: true,
+        },
+        price: {
+            type: Number,
+        },
+        stopPrice: {
+            type: Number,
+        },
+        instructionId: {
+            type: String,
+            required: true,
+        },
+        cancelInstructionId: {
+            type: String,
+        },
+        orderId: {
+            type: String,
+        },
+        tradeKey: {
+            type: String,
+        },
+        matchedQuantity: {
+            type: Number,
+        },
+        unfilledQuantity: {
+            type: Number,
+        },
+        cumulativeMatchedQuantity: {
+            type: Number,
+        },
+        cancelledQuantity: {
+            type: Number,
+        },
+        matchedCost: {
+            type: Number,
+        },
+        commission: {
+            type: Number,
+        },
+        avgPrice: {
+            type: Number,
+        },
+        text: {
+            type: String,
+        },
+        submitted: {
+            type: Boolean,
+            default: false,
+        },
+        submitAttempts: {
+            type: Number,
+            default: 0,
+        },
+    }, {
+        toJSON: {
+            transform(doc, ret) {
+                ret.id = ret._id.valueOf();
+                delete ret._id;
+                delete ret.__v;
+            },
+        },
+    });
+    // Partial unique index: only docs with a string tradeKey are indexed,
+    // so existing docs (no field) don't collide. Guarantees at most one
+    // LmaxFXTrade per caller-supplied trade key.
+    LmaxFXTradeSchema.index({ tradeKey: 1 }, {
+        unique: true,
+        partialFilterExpression: { tradeKey: { $type: "string" } },
+    });
+    LmaxFXTradeSchema.statics.build = (attrs) => {
+        return new LmaxFXTrade(attrs);
+    };
+    const LmaxFXTrade = mongoose.model("LmaxFXTrade", LmaxFXTradeSchema);
+    return LmaxFXTrade;
+};
+exports.buildLmaxFXTrade = buildLmaxFXTrade;

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

@@ -1,25 +1,11 @@
-import { TVFXDataProvider } from "@riocrypto/common";
+import { ConversionRate } from "@riocrypto/common";
 import { Mongoose, Model, Document, HydratedDocument } from "mongoose";
 interface MarketDataAttrs {
     conversionRatesToUSD: {
-        [key: string]: {
-            value: number;
-            lastUpdated: Date;
-            lastPriceChangedAt?: Date;
-            provider?: TVFXDataProvider;
-            bot?: boolean;
-            frozen?: boolean;
-        };
+        [key: string]: ConversionRate;
     };
     conversionRatesFromUSD: {
-        [key: string]: {
-            value: number;
-            lastUpdated: Date;
-            lastPriceChangedAt?: Date;
-            provider?: TVFXDataProvider;
-            bot?: boolean;
-            frozen?: boolean;
-        };
+        [key: string]: ConversionRate;
     };
     assetPricesInUSD: {
         [key: string]: {
@@ -64,24 +50,10 @@ interface MarketDataModel extends Model<MarketDataDoc> {
 }
 interface MarketDataDoc extends Document {
     conversionRatesToUSD: {
-        [key: string]: {
-            value: number;
-            lastUpdated: Date;
-            lastPriceChangedAt?: Date;
-            provider?: TVFXDataProvider;
-            bot?: boolean;
-            frozen?: boolean;
-        };
+        [key: string]: ConversionRate;
     };
     conversionRatesFromUSD: {
-        [key: string]: {
-            value: number;
-            lastUpdated: Date;
-            lastPriceChangedAt?: Date;
-            provider?: TVFXDataProvider;
-            bot?: boolean;
-            frozen?: boolean;
-        };
+        [key: string]: ConversionRate;
     };
     assetPricesInUSD: {
         [key: string]: {

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

@@ -1,4 +1,4 @@
-import { Country, Crypto, DeferredPaymentType, Fiat, FXProvider, FXTradingPolicies, ProcessorRoutingConfig, Side } from "@riocrypto/common";
+import { Country, Crypto, DeferredPaymentType, Fiat, FXPriceSourcePolicies, FXProvider, FXTradingPolicies, ProcessorRoutingConfig, Side } from "@riocrypto/common";
 import { TVFXDataProvider } from "@riocrypto/common";
 import mongoose, { HydratedDocument } from "mongoose";
 interface RioSettingsAttrs {
@@ -60,6 +60,7 @@ interface RioSettingsAttrs {
     TVFXDataProvider: {
         [key in Fiat]: TVFXDataProvider;
     };
+    fxPriceSources?: FXPriceSourcePolicies;
     defaultTwoWaySettlementDateOffsetFee?: {
         [key in Country]?: {
             [key in Side]?: {
@@ -156,6 +157,7 @@ interface RioSettingsDoc extends mongoose.Document {
     TVFXDataProvider: {
         [key in Fiat]: TVFXDataProvider;
     };
+    fxPriceSources?: FXPriceSourcePolicies;
     defaultTwoWaySettlementDateOffsetFee?: {
         [key in Country]?: {
             [key in Side]?: {

package/build/models/rio-settings.js

@@ -68,6 +68,9 @@ const buildRioSettings = (mongoose) => {
         TVFXDataProvider: {
             type: Object,
         },
+        fxPriceSources: {
+            type: Object,
+        },
         defaultTwoWaySettlementDateOffsetFee: {
             type: Object,
         },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@riocrypto/common-server",
-  "version": "1.0.2909",
+  "version": "1.0.2911",
   "description": "",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
@@ -28,7 +28,7 @@
     "@google-cloud/secret-manager": "^5.6.0",
     "@google-cloud/storage": "^7.19.0",
     "@hyperdx/node-opentelemetry": "^0.10.3",
-    "@riocrypto/common": "1.0.2715",
+    "@riocrypto/common": "1.0.2720",
     "@slack/web-api": "^7.15.0",
     "@types/express": "^4.17.25",
     "axios": "1.18.1",