@riocrypto/common-server 1.0.2765 → 1.0.2768

package/build/clients/axios-with-logging.js

@@ -86,7 +86,7 @@ function buildAxiosWithLogging() {
         }
         return response;
     }, (error) => {
-        var _a, _b, _c;
+        var _a, _b, _c, _d;
         // Combine and log the response error details without headers
         let logMessage = `Response Error: url=${maskUrl((_a = error.config) === null || _a === void 0 ? void 0 : _a.url)}, message=${error.message}`;
         if (error.response) {
@@ -96,6 +96,7 @@ function buildAxiosWithLogging() {
         return Promise.reject({
             message: logMessage,
             status: (_c = error.response) === null || _c === void 0 ? void 0 : _c.status,
+            data: (_d = error.response) === null || _d === void 0 ? void 0 : _d.data,
         });
     });
     return axiosWithLogging;

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

@@ -1,4 +1,4 @@
-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 } 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 } from "@riocrypto/common";
 import { STPMXNWithdrawalDoc } from "../models/STP-mxn-withdrawal";
 declare class ClusterClient {
     private baseUrl;
@@ -235,6 +235,54 @@ declare class ClusterClient {
         minClipSize: number;
         interval: number;
     }>;
+    createStonexTrade(data: {
+        symbol: string;
+        side: string;
+        quantity: number;
+        valueDate?: string;
+        fiat?: string;
+        tradeKey: string;
+    }): Promise<StonexFXTrade>;
+    takeStonexQuote(tradeId: string, side: "buy" | "sell", tradeKey: string): Promise<StonexFXTrade>;
+    cancelStonexTrade(tradeId: string): Promise<StonexFXTrade>;
+    updateStonexOrder(tradeId: string, params: {
+        quantity?: number;
+        price?: number;
+        stopPx?: number;
+        timeInForce?: string;
+        tradeKey: string;
+    }): Promise<StonexFXTrade>;
+    placeStonexDirectOrder(params: {
+        symbol: string;
+        side: string;
+        quantity: number;
+        ordType: string;
+        timeInForce: string;
+        currency: string;
+        price?: number;
+        stopPx?: number;
+        valueDate?: string;
+        execInst?: string;
+        tradeKey: string;
+    }): Promise<StonexFXTrade>;
+    getStonexTrade(tradeId: string): Promise<StonexFXTrade>;
+    getStonexTradeByKey(tradeKey: string): Promise<StonexFXTrade | null>;
+    getStonexTrades(offset: number, limit: number): Promise<{
+        data: StonexFXTrade[];
+        hasMore: boolean;
+    }>;
+    getValueDates(country?: string): Promise<Record<string, string>>;
+    getStonexStatus(): Promise<{
+        order: string;
+        md: string;
+        spotRate: {
+            bid?: number;
+            offer?: number;
+        } | null;
+    }>;
+    sendStonexCommand(command: string): Promise<{
+        message: string;
+    }>;
 }
 export declare const buildClusterClient: () => Promise<ClusterClient>;
 export {};

package/build/clients/cluster-client.js

@@ -791,6 +791,118 @@ class ClusterClient {
             return response.data;
         });
     }
+    // ─── StoneX FIX ───────────────────────────────────────────────────
+    createStonexTrade(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { tradeKey } = data;
+            const response = yield this.axios.post(`${this.baseUrl}/api/stonex/create-quote-stream`, data, {
+                headers: {
+                    "x-cluster-api-key": this.clusterApiKey,
+                    "X-Trade-Key": tradeKey,
+                },
+            });
+            return response.data;
+        });
+    }
+    takeStonexQuote(tradeId, side, tradeKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.axios.post(`${this.baseUrl}/api/stonex/take-quote/${tradeId}`, { side, tradeKey }, {
+                headers: {
+                    "x-cluster-api-key": this.clusterApiKey,
+                    "X-Trade-Key": tradeKey,
+                },
+            });
+            return response.data;
+        });
+    }
+    cancelStonexTrade(tradeId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.axios.post(`${this.baseUrl}/api/stonex/cancel-trade/${tradeId}`, {}, { headers: { "x-cluster-api-key": this.clusterApiKey } });
+            return response.data;
+        });
+    }
+    updateStonexOrder(tradeId, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { tradeKey } = params;
+            const response = yield this.axios.post(`${this.baseUrl}/api/stonex/update-order/${tradeId}`, params, {
+                headers: {
+                    "x-cluster-api-key": this.clusterApiKey,
+                    "X-Trade-Key": tradeKey,
+                },
+            });
+            return response.data;
+        });
+    }
+    placeStonexDirectOrder(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { tradeKey } = params;
+            const response = yield this.axios.post(`${this.baseUrl}/api/stonex/place-order`, params, {
+                headers: {
+                    "x-cluster-api-key": this.clusterApiKey,
+                    "X-Trade-Key": tradeKey,
+                },
+            });
+            return response.data;
+        });
+    }
+    getStonexTrade(tradeId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.axios.get(`${this.baseUrl}/api/stonex/trades/${tradeId}`, { headers: { "x-cluster-api-key": this.clusterApiKey } });
+            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
+    // calls this before stamping a local trade as Failed so a lost HTTP
+    // response does not desync the two systems.
+    getStonexTradeByKey(tradeKey) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield this.axios.get(`${this.baseUrl}/api/stonex/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;
+            }
+        });
+    }
+    getStonexTrades(offset, limit) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.axios.get(`${this.baseUrl}/api/stonex/trades?offset=${offset}&limit=${limit}`, { headers: { "x-cluster-api-key": this.clusterApiKey } });
+            return response.data;
+        });
+    }
+    getValueDates(country) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const url = country
+                ? `${this.baseUrl}/api/stonex/value-dates?country=${country}`
+                : `${this.baseUrl}/api/stonex/value-dates`;
+            const response = yield this.axios.get(url, {
+                headers: { "x-cluster-api-key": this.clusterApiKey },
+            });
+            return response.data;
+        });
+    }
+    getStonexStatus() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.axios.get(`${this.baseUrl}/api/stonex/status`, { headers: { "x-cluster-api-key": this.clusterApiKey } });
+            return response.data;
+        });
+    }
+    sendStonexCommand(command) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.axios.post(`${this.baseUrl}/api/stonex/command`, { command }, { headers: { "x-cluster-api-key": this.clusterApiKey } });
+            return response.data;
+        });
+    }
 }
 const buildClusterClient = () => __awaiter(void 0, void 0, void 0, function* () {
     // Retrieve secrets asynchronously

package/build/index.d.ts

@@ -102,6 +102,8 @@ export * from "./models/bulk-bank-payout";
 export * from "./models/bulk-crypto-payout";
 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/inbound-bank-deposit";
 export * from "./models/inbound-crypto-deposit";
 export * from "./models/order-log";

package/build/index.js

@@ -118,6 +118,8 @@ __exportStar(require("./models/bulk-bank-payout"), exports);
 __exportStar(require("./models/bulk-crypto-payout"), exports);
 __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/inbound-bank-deposit"), exports);
 __exportStar(require("./models/inbound-crypto-deposit"), exports);
 __exportStar(require("./models/order-log"), exports);

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

@@ -3,6 +3,7 @@ import { Mongoose, Model, Document, HydratedDocument } from "mongoose";
 interface ExternalTradeAttrs {
     createdAt: Date;
     providerOrderId?: string;
+    tradeKey?: string;
     type: ExternalTradeType;
     side: Side;
     provider: ExternalTradingProvider;
@@ -21,6 +22,18 @@ interface ExternalTradeAttrs {
         emarkets?: {
             settlementType?: EmarketsSettlementType;
         };
+        stonex?: {
+            valueDate?: Date;
+            quoteReqId?: string;
+            bidPx?: number;
+            offerPx?: number;
+            clOrdId?: string;
+            text?: string;
+            ordType?: string;
+            amountReceived?: number;
+            stopPx?: number;
+            takeQuoteTradeKey?: string;
+        };
     };
     externalTradingAlgorithmId?: string;
     arbitrageSessionId?: string;
@@ -29,6 +42,7 @@ interface ExternalTradeAttrs {
 interface ExternalTradeDoc extends Document {
     createdAt: Date;
     providerOrderId?: string;
+    tradeKey?: string;
     type: ExternalTradeType;
     side: Side;
     amountType: ExternalTradeAmountType;
@@ -48,6 +62,18 @@ interface ExternalTradeDoc extends Document {
         emarkets?: {
             settlementType?: EmarketsSettlementType;
         };
+        stonex?: {
+            valueDate?: Date;
+            quoteReqId?: string;
+            bidPx?: number;
+            offerPx?: number;
+            clOrdId?: string;
+            text?: string;
+            ordType?: string;
+            amountReceived?: number;
+            stopPx?: number;
+            takeQuoteTradeKey?: string;
+        };
     };
     externalTradingAlgorithmId?: string;
     arbitrageSessionId?: string;

package/build/models/external-trade.js

@@ -14,6 +14,9 @@ const buildExternalTrade = (mongoose) => {
         providerOrderId: {
             type: String,
         },
+        tradeKey: {
+            type: String,
+        },
         requestedAmountType: {
             type: String,
             required: true,
@@ -87,6 +90,18 @@ const buildExternalTrade = (mongoose) => {
             },
         },
     });
+    // Partial unique compound index: guarantees at most one ExternalTrade per
+    // (provider, tradeKey) pair. Legacy rows without tradeKey are
+    // excluded by the partial filter, so no backfill is required.
+    ExternalTradeSchema.index({ provider: 1, tradeKey: 1 }, {
+        unique: true,
+        partialFilterExpression: { tradeKey: { $type: "string" } },
+    });
+    // Defense-in-depth: at most one ExternalTrade per (provider, providerOrderId).
+    ExternalTradeSchema.index({ provider: 1, providerOrderId: 1 }, {
+        unique: true,
+        partialFilterExpression: { providerOrderId: { $type: "string" } },
+    });
     ExternalTradeSchema.statics.build = (attrs) => {
         return new ExternalTrade(attrs);
     };

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

@@ -0,0 +1,78 @@
+import { Fiat, Side, StonexFXTradeStatus, StonexSettlementType } from "@riocrypto/common";
+import { Mongoose, Model, Document } from "mongoose";
+interface StonexFXTradeAttrs {
+    createdAt: Date;
+    status: StonexFXTradeStatus;
+    side: Side;
+    fiat: Fiat;
+    symbol: string;
+    amountToTrade: number;
+    amountReceived?: number;
+    actualPrice?: number;
+    limitPrice?: number;
+    settlementType?: StonexSettlementType;
+    valueDate?: string;
+    clOrdId?: string;
+    quoteReqId?: string;
+    quoteId?: string;
+    bidPx?: number;
+    offerPx?: number;
+    validUntilTime?: string;
+    exchangeOrderId?: string;
+    execId?: string;
+    text?: string;
+    ordType?: string;
+    timeInForce?: string;
+    stopPx?: number;
+    execInst?: string;
+    minQty?: number;
+    maxShow?: number;
+    expireTime?: string;
+    leavesQty?: number;
+    avgPx?: number;
+    tradeKey?: string;
+    takeQuoteTradeKey?: string;
+    fixSubmitted?: boolean;
+    submitAttempts?: number;
+}
+interface StonexFXTradeDoc extends Document {
+    id: string;
+    createdAt: Date;
+    status: StonexFXTradeStatus;
+    side: Side;
+    fiat: Fiat;
+    symbol: string;
+    amountToTrade: number;
+    amountReceived?: number;
+    actualPrice?: number;
+    limitPrice?: number;
+    settlementType?: StonexSettlementType;
+    valueDate?: string;
+    clOrdId?: string;
+    quoteReqId?: string;
+    quoteId?: string;
+    bidPx?: number;
+    offerPx?: number;
+    validUntilTime?: string;
+    exchangeOrderId?: string;
+    execId?: string;
+    text?: string;
+    ordType?: string;
+    timeInForce?: string;
+    stopPx?: number;
+    execInst?: string;
+    minQty?: number;
+    maxShow?: number;
+    expireTime?: string;
+    leavesQty?: number;
+    avgPx?: number;
+    tradeKey?: string;
+    takeQuoteTradeKey?: string;
+    fixSubmitted?: boolean;
+    submitAttempts?: number;
+}
+interface StonexFXTradeModel extends Model<StonexFXTradeDoc> {
+    build(attrs: StonexFXTradeAttrs): StonexFXTradeDoc;
+}
+declare const buildStonexFXTrade: (mongoose: Mongoose) => StonexFXTradeModel;
+export { buildStonexFXTrade, StonexFXTradeDoc, StonexFXTradeAttrs };

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

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildStonexFXTrade = void 0;
+const buildStonexFXTrade = (mongoose) => {
+    if (mongoose.models.StonexFXTrade) {
+        return mongoose.model("StonexFXTrade");
+    }
+    const StonexFXTradeSchema = new mongoose.Schema({
+        createdAt: {
+            type: Date,
+            required: true,
+        },
+        status: {
+            type: String,
+            required: true,
+        },
+        side: {
+            type: String,
+            required: true,
+        },
+        fiat: {
+            type: String,
+            required: true,
+        },
+        symbol: {
+            type: String,
+            required: true,
+        },
+        amountToTrade: {
+            type: Number,
+            required: true,
+        },
+        amountReceived: {
+            type: Number,
+        },
+        actualPrice: {
+            type: Number,
+        },
+        limitPrice: {
+            type: Number,
+        },
+        settlementType: {
+            type: String,
+        },
+        valueDate: {
+            type: String,
+        },
+        clOrdId: {
+            type: String,
+        },
+        quoteReqId: {
+            type: String,
+        },
+        quoteId: {
+            type: String,
+        },
+        bidPx: {
+            type: Number,
+        },
+        offerPx: {
+            type: Number,
+        },
+        validUntilTime: {
+            type: String,
+        },
+        exchangeOrderId: {
+            type: String,
+        },
+        execId: {
+            type: String,
+        },
+        text: {
+            type: String,
+        },
+        ordType: {
+            type: String,
+        },
+        timeInForce: {
+            type: String,
+        },
+        stopPx: {
+            type: Number,
+        },
+        execInst: {
+            type: String,
+        },
+        minQty: {
+            type: Number,
+        },
+        maxShow: {
+            type: Number,
+        },
+        expireTime: {
+            type: String,
+        },
+        leavesQty: {
+            type: Number,
+        },
+        avgPx: {
+            type: Number,
+        },
+        tradeKey: {
+            type: String,
+        },
+        takeQuoteTradeKey: {
+            type: String,
+        },
+        fixSubmitted: {
+            type: Boolean,
+            default: false,
+        },
+        submitAttempts: {
+            type: Number,
+            default: 0,
+        },
+        metadata: {
+            type: Map,
+            of: mongoose.Schema.Types.Mixed,
+        },
+    }, {
+        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 StonexFXTrade
+    // per caller-supplied trade key.
+    StonexFXTradeSchema.index({ tradeKey: 1 }, {
+        unique: true,
+        partialFilterExpression: { tradeKey: { $type: "string" } },
+    });
+    StonexFXTradeSchema.index({ takeQuoteTradeKey: 1 }, {
+        unique: true,
+        partialFilterExpression: {
+            takeQuoteTradeKey: { $type: "string" },
+        },
+    });
+    StonexFXTradeSchema.statics.build = (attrs) => {
+        return new StonexFXTrade(attrs);
+    };
+    const StonexFXTrade = mongoose.model("StonexFXTrade", StonexFXTradeSchema);
+    return StonexFXTrade;
+};
+exports.buildStonexFXTrade = buildStonexFXTrade;

package/build/models/stonex-log.d.ts

@@ -0,0 +1,21 @@
+import { Mongoose, Model, Document } from "mongoose";
+interface StonexLogAttrs {
+    timestamp: Date;
+    direction: "inbound" | "outbound";
+    session: "order" | "quote";
+    msgType: string;
+    data: string;
+}
+interface StonexLogDoc extends Document {
+    id: string;
+    timestamp: Date;
+    direction: "inbound" | "outbound";
+    session: "order" | "quote";
+    msgType: string;
+    data: string;
+}
+interface StonexLogModel extends Model<StonexLogDoc> {
+    build(attrs: StonexLogAttrs): StonexLogDoc;
+}
+declare const buildStonexLog: (mongoose: Mongoose) => StonexLogModel;
+export { buildStonexLog, StonexLogDoc, StonexLogAttrs };

package/build/models/stonex-log.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildStonexLog = void 0;
+const buildStonexLog = (mongoose) => {
+    if (mongoose.models.StonexLog) {
+        return mongoose.model("StonexLog");
+    }
+    const StonexLogSchema = new mongoose.Schema({
+        timestamp: {
+            type: Date,
+            required: true,
+        },
+        direction: {
+            type: String,
+            required: true,
+            enum: ["inbound", "outbound"],
+        },
+        session: {
+            type: String,
+            required: true,
+            enum: ["order", "quote"],
+        },
+        msgType: {
+            type: String,
+            required: true,
+        },
+        data: {
+            type: String,
+            required: true,
+        },
+    }, {
+        toJSON: {
+            transform(doc, ret) {
+                ret.id = ret._id.valueOf();
+                delete ret._id;
+                delete ret.__v;
+            },
+        },
+    });
+    StonexLogSchema.statics.build = (attrs) => {
+        return new StonexLog(attrs);
+    };
+    const StonexLog = mongoose.model("StonexLog", StonexLogSchema);
+    return StonexLog;
+};
+exports.buildStonexLog = buildStonexLog;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@riocrypto/common-server",
-  "version": "1.0.2765",
+  "version": "1.0.2768",
   "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.2560",
+    "@riocrypto/common": "1.0.2565",
     "@slack/web-api": "^7.15.0",
     "@types/express": "^4.17.25",
     "axios": "1.13.6",