@riocrypto/common-server 1.0.2777 → 1.0.2780

package/build/helpers/find-user-tier-forward-curve-rate.d.ts

@@ -0,0 +1,17 @@
+import { Country, Side, User } from "@riocrypto/common";
+/**
+ * Walks the user's tier ranges from the current tier (matched by amount)
+ * down to lower tiers, returning the first defined interpolated rate.
+ *
+ * Mirrors the tier-walk used in fee resolution so a higher tier whose
+ * forward curve omits a day can still inherit from a lower tier with a more
+ * complete curve. Returns undefined if no tier matches the amount or no
+ * tier contains the requested day.
+ */
+export declare const findUserTierForwardCurveRate: ({ user, country, side, amount, day, }: {
+    user: User | undefined | null;
+    country: Country;
+    side: Side;
+    amount: number;
+    day: number;
+}) => number | undefined;

package/build/helpers/find-user-tier-forward-curve-rate.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findUserTierForwardCurveRate = void 0;
+const interpolate_forward_curve_rate_1 = require("./interpolate-forward-curve-rate");
+/**
+ * Walks the user's tier ranges from the current tier (matched by amount)
+ * down to lower tiers, returning the first defined interpolated rate.
+ *
+ * Mirrors the tier-walk used in fee resolution so a higher tier whose
+ * forward curve omits a day can still inherit from a lower tier with a more
+ * complete curve. Returns undefined if no tier matches the amount or no
+ * tier contains the requested day.
+ */
+const findUserTierForwardCurveRate = ({ user, country, side, amount, day, }) => {
+    var _a, _b;
+    const ranges = (_b = (_a = user === null || user === void 0 ? void 0 : user.platformFeeRanges) === null || _a === void 0 ? void 0 : _a[country]) === null || _b === void 0 ? void 0 : _b[side];
+    if (!ranges || ranges.length === 0)
+        return undefined;
+    const sorted = [...ranges].sort((a, b) => a.min - b.min);
+    let currentRangeIndex = -1;
+    for (let i = 0; i < sorted.length; i++) {
+        const range = sorted[i];
+        if (range.min <= amount && range.max >= amount) {
+            currentRangeIndex = i;
+            break;
+        }
+    }
+    if (currentRangeIndex === -1 &&
+        sorted.length > 0 &&
+        amount > sorted[sorted.length - 1].max) {
+        currentRangeIndex = sorted.length - 1;
+    }
+    if (currentRangeIndex === -1)
+        return undefined;
+    for (let i = currentRangeIndex; i >= 0; i--) {
+        const rate = (0, interpolate_forward_curve_rate_1.interpolateForwardCurveRate)(sorted[i].twoWaySettlementDateOffsetFee, day);
+        if (rate !== undefined)
+            return rate;
+    }
+    return undefined;
+};
+exports.findUserTierForwardCurveRate = findUserTierForwardCurveRate;

package/build/helpers/get-resolved-forward-curve-tiers.d.ts

@@ -0,0 +1,35 @@
+import { Country, RioSettings, Side, User } from "@riocrypto/common";
+export type ResolvedForwardCurveTier = {
+    min: number;
+    max: number;
+    /**
+     * Anchor points keyed by day (string for transport / MongoDB
+     * compatibility) -> rate (decimal, e.g. 0.0005 = 5 BPS).
+     *
+     * The set of keys is the union of every day defined by any layer relevant
+     * to this tier (user tier, lower user tiers, broker tiers, platform
+     * default). At each key the resolved value is what the trader would
+     * actually be charged at that T+n, so visual interpolation between anchor
+     * points produces a single continuous curve covering the full range.
+     */
+    curve: {
+        [day: string]: number;
+    };
+};
+/**
+ * Builds per-tier resolved forward curves suitable for charting.
+ *
+ * Tiers come from the user's amount tiers when defined, otherwise from the
+ * broker's tiers, otherwise a single synthetic tier covering the platform
+ * default. For each tier, every "anchor day" defined anywhere in the
+ * fallback chain is filled with the resolved rate at that day; the chart
+ * can then linearly interpolate between anchors to render a single
+ * continuous line.
+ */
+export declare const getResolvedForwardCurveTiers: ({ user, broker, country, side, rioSettings, }: {
+    user: User;
+    broker?: User | null | undefined;
+    country: Country;
+    side: Side;
+    rioSettings: Pick<RioSettings, "defaultTwoWaySettlementDateOffsetFee">;
+}) => ResolvedForwardCurveTier[];

package/build/helpers/get-resolved-forward-curve-tiers.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getResolvedForwardCurveTiers = void 0;
+const resolve_forward_curve_rate_1 = require("./resolve-forward-curve-rate");
+/**
+ * Builds per-tier resolved forward curves suitable for charting.
+ *
+ * Tiers come from the user's amount tiers when defined, otherwise from the
+ * broker's tiers, otherwise a single synthetic tier covering the platform
+ * default. For each tier, every "anchor day" defined anywhere in the
+ * fallback chain is filled with the resolved rate at that day; the chart
+ * can then linearly interpolate between anchors to render a single
+ * continuous line.
+ */
+const getResolvedForwardCurveTiers = ({ user, broker, country, side, rioSettings, }) => {
+    var _a, _b, _c, _d, _e, _f;
+    const userRanges = (_b = (_a = user.platformFeeRanges) === null || _a === void 0 ? void 0 : _a[country]) === null || _b === void 0 ? void 0 : _b[side];
+    const brokerRanges = (_d = (_c = broker === null || broker === void 0 ? void 0 : broker.platformFeeRanges) === null || _c === void 0 ? void 0 : _c[country]) === null || _d === void 0 ? void 0 : _d[side];
+    const platformCurve = (_f = (_e = rioSettings.defaultTwoWaySettlementDateOffsetFee) === null || _e === void 0 ? void 0 : _e[country]) === null || _f === void 0 ? void 0 : _f[side];
+    let tiers = [];
+    if (userRanges && userRanges.length > 0) {
+        tiers = [...userRanges]
+            .sort((a, b) => a.min - b.min)
+            .map((r) => ({ min: r.min, max: r.max }));
+    }
+    else if (brokerRanges && brokerRanges.length > 0) {
+        tiers = [...brokerRanges]
+            .sort((a, b) => a.min - b.min)
+            .map((r) => ({ min: r.min, max: r.max }));
+    }
+    else {
+        tiers = [{ min: 0, max: Number.MAX_SAFE_INTEGER }];
+    }
+    const collectDays = (curve) => {
+        if (!curve)
+            return [];
+        return Object.keys(curve)
+            .map((k) => Number(k))
+            .filter((d) => Number.isFinite(d));
+    };
+    const anchorDays = new Set();
+    if (userRanges) {
+        for (const r of userRanges) {
+            collectDays(r.twoWaySettlementDateOffsetFee).forEach((d) => anchorDays.add(d));
+        }
+    }
+    if (brokerRanges) {
+        for (const r of brokerRanges) {
+            collectDays(r.twoWaySettlementDateOffsetFee).forEach((d) => anchorDays.add(d));
+        }
+    }
+    collectDays(platformCurve).forEach((d) => anchorDays.add(d));
+    if (anchorDays.size === 0) {
+        return tiers.map((t) => (Object.assign(Object.assign({}, t), { curve: {} })));
+    }
+    const sortedDays = [...anchorDays].sort((a, b) => a - b);
+    return tiers.map((tier) => {
+        const sampleAmount = tier.max >= Number.MAX_SAFE_INTEGER
+            ? tier.min + 1
+            : Math.floor((tier.min + tier.max) / 2);
+        const curve = {};
+        for (const day of sortedDays) {
+            const rate = (0, resolve_forward_curve_rate_1.resolveForwardCurveRate)({
+                user,
+                broker,
+                country,
+                side,
+                amount: sampleAmount,
+                day,
+                rioSettings,
+            });
+            if (rate !== undefined)
+                curve[String(day)] = rate;
+        }
+        return Object.assign(Object.assign({}, tier), { curve });
+    });
+};
+exports.getResolvedForwardCurveTiers = getResolvedForwardCurveTiers;

package/build/helpers/interpolate-forward-curve-rate.d.ts

@@ -0,0 +1,15 @@
+export type ForwardCurve = {
+    [day: number]: number;
+};
+/**
+ * Linearly interpolates a forward curve at a given day.
+ *
+ * - Returns the rate at the requested day, with linear interpolation between
+ *   defined points.
+ * - Returns undefined if the requested day is outside [minDefinedDay,
+ *   maxDefinedDay] or if the curve has no defined points.
+ *
+ * Days outside the defined range are intentionally undefined so callers can
+ * fall back to the next layer (broker parent curve or platform default).
+ */
+export declare const interpolateForwardCurveRate: (curve: ForwardCurve | undefined, daysUntilSettlementDate: number) => number | undefined;

package/build/helpers/interpolate-forward-curve-rate.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.interpolateForwardCurveRate = void 0;
+/**
+ * Linearly interpolates a forward curve at a given day.
+ *
+ * - Returns the rate at the requested day, with linear interpolation between
+ *   defined points.
+ * - Returns undefined if the requested day is outside [minDefinedDay,
+ *   maxDefinedDay] or if the curve has no defined points.
+ *
+ * Days outside the defined range are intentionally undefined so callers can
+ * fall back to the next layer (broker parent curve or platform default).
+ */
+const interpolateForwardCurveRate = (curve, daysUntilSettlementDate) => {
+    if (!curve)
+        return undefined;
+    const definedDays = Object.keys(curve)
+        .map((key) => Number(key))
+        .filter((day) => Number.isFinite(day) && curve[day] !== undefined)
+        .sort((a, b) => a - b);
+    if (definedDays.length === 0)
+        return undefined;
+    const minDay = definedDays[0];
+    const maxDay = definedDays[definedDays.length - 1];
+    if (daysUntilSettlementDate < minDay || daysUntilSettlementDate > maxDay) {
+        return undefined;
+    }
+    if (curve[daysUntilSettlementDate] !== undefined) {
+        return curve[daysUntilSettlementDate];
+    }
+    let lowerDay = definedDays[0];
+    let upperDay = definedDays[definedDays.length - 1];
+    for (let i = 0; i < definedDays.length - 1; i++) {
+        if (definedDays[i] <= daysUntilSettlementDate &&
+            definedDays[i + 1] >= daysUntilSettlementDate) {
+            lowerDay = definedDays[i];
+            upperDay = definedDays[i + 1];
+            break;
+        }
+    }
+    const lowerFee = curve[lowerDay];
+    const upperFee = curve[upperDay];
+    if (upperDay === lowerDay)
+        return lowerFee;
+    const slope = (upperFee - lowerFee) / (upperDay - lowerDay);
+    return lowerFee + slope * (daysUntilSettlementDate - lowerDay);
+};
+exports.interpolateForwardCurveRate = interpolateForwardCurveRate;

package/build/helpers/resolve-forward-curve-rate.d.ts

@@ -0,0 +1,19 @@
+import { Country, RioSettings, Side, User } from "@riocrypto/common";
+/**
+ * Resolves the effective two-way-settlement-date-offset rate at a given day,
+ * walking the full fallback chain:
+ *   1. user's own tier curves (current tier and lower)
+ *   2. broker parent's tier curves (same logic applied to broker)
+ *   3. platform default forward curve from RioSettings
+ *
+ * Returns undefined only if every layer is missing or out of range.
+ */
+export declare const resolveForwardCurveRate: ({ user, broker, country, side, amount, day, rioSettings, }: {
+    user: User | undefined | null;
+    broker?: User | null | undefined;
+    country: Country;
+    side: Side;
+    amount: number;
+    day: number;
+    rioSettings: Pick<RioSettings, "defaultTwoWaySettlementDateOffsetFee">;
+}) => number | undefined;

package/build/helpers/resolve-forward-curve-rate.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveForwardCurveRate = void 0;
+const find_user_tier_forward_curve_rate_1 = require("./find-user-tier-forward-curve-rate");
+const interpolate_forward_curve_rate_1 = require("./interpolate-forward-curve-rate");
+/**
+ * Resolves the effective two-way-settlement-date-offset rate at a given day,
+ * walking the full fallback chain:
+ *   1. user's own tier curves (current tier and lower)
+ *   2. broker parent's tier curves (same logic applied to broker)
+ *   3. platform default forward curve from RioSettings
+ *
+ * Returns undefined only if every layer is missing or out of range.
+ */
+const resolveForwardCurveRate = ({ user, broker, country, side, amount, day, rioSettings, }) => {
+    var _a, _b;
+    const userRate = (0, find_user_tier_forward_curve_rate_1.findUserTierForwardCurveRate)({
+        user,
+        country,
+        side,
+        amount,
+        day,
+    });
+    if (userRate !== undefined)
+        return userRate;
+    if (broker) {
+        const brokerRate = (0, find_user_tier_forward_curve_rate_1.findUserTierForwardCurveRate)({
+            user: broker,
+            country,
+            side,
+            amount,
+            day,
+        });
+        if (brokerRate !== undefined)
+            return brokerRate;
+    }
+    return (0, interpolate_forward_curve_rate_1.interpolateForwardCurveRate)((_b = (_a = rioSettings.defaultTwoWaySettlementDateOffsetFee) === null || _a === void 0 ? void 0 : _a[country]) === null || _b === void 0 ? void 0 : _b[side], day);
+};
+exports.resolveForwardCurveRate = resolveForwardCurveRate;

package/build/index.d.ts

@@ -166,3 +166,7 @@ export * from "./helpers/extract-error-message";
 export * from "./helpers/get-exchange-rates-with-markups";
 export * from "./helpers/get-order-from-static-reference";
 export * from "./helpers/is-after-hours";
+export * from "./helpers/interpolate-forward-curve-rate";
+export * from "./helpers/find-user-tier-forward-curve-rate";
+export * from "./helpers/resolve-forward-curve-rate";
+export * from "./helpers/get-resolved-forward-curve-tiers";

package/build/index.js

@@ -182,3 +182,7 @@ __exportStar(require("./helpers/extract-error-message"), exports);
 __exportStar(require("./helpers/get-exchange-rates-with-markups"), exports);
 __exportStar(require("./helpers/get-order-from-static-reference"), exports);
 __exportStar(require("./helpers/is-after-hours"), exports);
+__exportStar(require("./helpers/interpolate-forward-curve-rate"), exports);
+__exportStar(require("./helpers/find-user-tier-forward-curve-rate"), exports);
+__exportStar(require("./helpers/resolve-forward-curve-rate"), exports);
+__exportStar(require("./helpers/get-resolved-forward-curve-tiers"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@riocrypto/common-server",
-  "version": "1.0.2777",
+  "version": "1.0.2780",
   "description": "",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
@@ -24,7 +24,7 @@
     "@google-cloud/secret-manager": "^5.6.0",
     "@google-cloud/storage": "^7.19.0",
     "@hyperdx/node-opentelemetry": "^0.10.3",
-    "@riocrypto/common": "1.0.2574",
+    "@riocrypto/common": "1.0.2582",
     "@slack/web-api": "^7.15.0",
     "@types/express": "^4.17.25",
     "axios": "1.13.6",