@riocrypto/common-server 1.0.2721 → 1.0.2723

package/build/index.d.ts

@@ -116,8 +116,13 @@ export * from "./models/compliance-session";
 export * from "./models/compliance-bot-chat";
 export * from "./models/compliance-bot-rule";
 export * from "./models/compliance-bot-rule-result";
+export * from "./models/binance-rfq-log";
+export * from "./models/binance-rfq-order";
+export * from "./models/binance-rfq-quote";
+export * from "./models/binance-rfq-trade";
 export * from "./models/static-bank-payment-reference";
 export * from "./models/indicative-quote-page";
+export * from "./models/indicative-quote-page-verification";
 export * from "./clients/axios-with-logging";
 export * from "./clients/slack-client";
 export * from "./clients/fireblocks-client";

package/build/index.js

@@ -132,8 +132,13 @@ __exportStar(require("./models/compliance-session"), exports);
 __exportStar(require("./models/compliance-bot-chat"), exports);
 __exportStar(require("./models/compliance-bot-rule"), exports);
 __exportStar(require("./models/compliance-bot-rule-result"), exports);
+__exportStar(require("./models/binance-rfq-log"), exports);
+__exportStar(require("./models/binance-rfq-order"), exports);
+__exportStar(require("./models/binance-rfq-quote"), exports);
+__exportStar(require("./models/binance-rfq-trade"), exports);
 __exportStar(require("./models/static-bank-payment-reference"), exports);
 __exportStar(require("./models/indicative-quote-page"), exports);
+__exportStar(require("./models/indicative-quote-page-verification"), exports);
 __exportStar(require("./clients/axios-with-logging"), exports);
 __exportStar(require("./clients/slack-client"), exports);
 __exportStar(require("./clients/fireblocks-client"), exports);

package/build/middlewares/authorize.d.ts

@@ -13,6 +13,10 @@ declare global {
             validClusterApiKey?: boolean;
             validGenisisAdminKey?: boolean;
             isAuthMissing2FA?: boolean;
+            indicativeQuoteAuth?: {
+                email: string;
+                pageId: string;
+            };
         }
     }
 }

package/build/middlewares/authorize.js

@@ -200,6 +200,31 @@ const authorize = (req, res, next, mongoose, authorizationTypes) => __awaiter(vo
             }))());
         }
     }
+    // Check for indicative quote auth token - only if needed
+    if (authorizationTypes.includes(common_1.AuthorizationType.IndicativeQuoteAuth)) {
+        const authHeader = req.header("Authorization");
+        const token = (authHeader === null || authHeader === void 0 ? void 0 : authHeader.startsWith("Bearer "))
+            ? authHeader.slice(7)
+            : null;
+        if (token) {
+            promises.push((() => __awaiter(void 0, void 0, void 0, function* () {
+                try {
+                    const INDICATIVE_PAGE_TOKEN_SECRET = yield secret_manager_client_1.secretManagerClient.getSecretValue("INDICATIVE_PAGE_TOKEN_SECRET");
+                    if (!INDICATIVE_PAGE_TOKEN_SECRET) {
+                        return;
+                    }
+                    const payload = jsonwebtoken_1.default.verify(token, INDICATIVE_PAGE_TOKEN_SECRET);
+                    if (payload.email && payload.pageId) {
+                        req.indicativeQuoteAuth = {
+                            email: payload.email,
+                            pageId: payload.pageId,
+                        };
+                    }
+                }
+                catch (err) { }
+            }))());
+        }
+    }
     // Wait for all promises to complete
     yield Promise.all(promises);
     // Check authorization results and proceed if authorized
@@ -216,7 +241,9 @@ const authorize = (req, res, next, mongoose, authorizationTypes) => __awaiter(vo
             req.adminAuth) ||
         ((authorizationTypes.includes(common_1.AuthorizationType.User) ||
             authorizationTypes.includes(common_1.AuthorizationType.UserNoKYC)) &&
-            req.user)) {
+            req.user) ||
+        (authorizationTypes.includes(common_1.AuthorizationType.IndicativeQuoteAuth) &&
+            req.indicativeQuoteAuth)) {
         next();
         return;
     }

package/build/models/binance-rfq-log.d.ts

@@ -0,0 +1,23 @@
+import { Mongoose, Model, Document } from "mongoose";
+import { BinanceRFQLogDirection } from "@riocrypto/common";
+interface BinanceRFQLogAttrs {
+    endpoint: string;
+    inOut: BinanceRFQLogDirection;
+    msgType: string;
+    message: string;
+    refId?: string;
+}
+interface BinanceRFQLogDoc extends Document {
+    endpoint: string;
+    inOut: BinanceRFQLogDirection;
+    msgType: string;
+    message: string;
+    refId?: string;
+    createdAt: Date;
+    updatedAt: Date;
+}
+interface BinanceRFQLogModel extends Model<BinanceRFQLogDoc> {
+    build(attrs: BinanceRFQLogAttrs): BinanceRFQLogDoc;
+}
+declare const buildBinanceRFQLog: (mongoose: Mongoose) => BinanceRFQLogModel;
+export { buildBinanceRFQLog, BinanceRFQLogDoc, BinanceRFQLogAttrs };

package/build/models/binance-rfq-log.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildBinanceRFQLog = void 0;
+const common_1 = require("@riocrypto/common");
+const buildBinanceRFQLog = (mongoose) => {
+    if (mongoose.models.BinanceRFQLog) {
+        return mongoose.model("BinanceRFQLog");
+    }
+    const BinanceRFQLogSchema = new mongoose.Schema({
+        endpoint: {
+            type: String,
+            required: true,
+        },
+        inOut: {
+            type: String,
+            enum: Object.values(common_1.BinanceRFQLogDirection),
+            required: true,
+        },
+        msgType: {
+            type: String,
+            required: true,
+        },
+        message: {
+            type: String,
+            required: true,
+        },
+        refId: {
+            type: String,
+            required: false,
+        },
+    }, {
+        timestamps: true,
+        toJSON: {
+            transform(doc, ret) {
+                ret.id = ret._id.valueOf();
+                delete ret._id;
+                delete ret.__v;
+            },
+        },
+    });
+    BinanceRFQLogSchema.statics.build = (attrs) => {
+        return new BinanceRFQLog(attrs);
+    };
+    const BinanceRFQLog = mongoose.model("BinanceRFQLog", BinanceRFQLogSchema);
+    return BinanceRFQLog;
+};
+exports.buildBinanceRFQLog = buildBinanceRFQLog;

package/build/models/binance-rfq-order.d.ts

@@ -0,0 +1,45 @@
+import { Mongoose, Model, Document } from "mongoose";
+import { BinanceRFQSide, BinanceRFQStatus } from "@riocrypto/common";
+interface BinanceRFQOrderAttrs {
+    rfqId: string;
+    rfqStatus: BinanceRFQStatus;
+    settlementStatus?: string | null;
+    rfqExpireTime: number;
+    symbol: string;
+    side: BinanceRFQSide;
+    baseAsset: string;
+    quoteAsset: string;
+    quantity: number;
+    quoteOrderQty: number;
+    lastBidQuoteId?: string | null;
+    lastOfferQuoteId?: string | null;
+    bidPrice?: number | null;
+    bidQuantity?: number | null;
+    offerPrice?: number | null;
+    offerQuantity?: number | null;
+}
+interface BinanceRFQOrderDoc extends Document {
+    rfqId: string;
+    rfqStatus: BinanceRFQStatus;
+    settlementStatus: string | null;
+    rfqExpireTime: number;
+    symbol: string;
+    side: BinanceRFQSide;
+    baseAsset: string;
+    quoteAsset: string;
+    quantity: number;
+    quoteOrderQty: number;
+    lastBidQuoteId: string | null;
+    lastOfferQuoteId: string | null;
+    bidPrice: number | null;
+    bidQuantity: number | null;
+    offerPrice: number | null;
+    offerQuantity: number | null;
+    createdAt: Date;
+    updatedAt: Date;
+}
+interface BinanceRFQOrderModel extends Model<BinanceRFQOrderDoc> {
+    build(attrs: BinanceRFQOrderAttrs): BinanceRFQOrderDoc;
+}
+declare const buildBinanceRFQOrder: (mongoose: Mongoose) => BinanceRFQOrderModel;
+export { buildBinanceRFQOrder, BinanceRFQOrderDoc, BinanceRFQOrderAttrs };

package/build/models/binance-rfq-order.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildBinanceRFQOrder = void 0;
+const common_1 = require("@riocrypto/common");
+const buildBinanceRFQOrder = (mongoose) => {
+    if (mongoose.models.BinanceRFQOrder) {
+        return mongoose.model("BinanceRFQOrder");
+    }
+    const BinanceRFQOrderSchema = new mongoose.Schema({
+        rfqId: {
+            type: String,
+            required: true,
+        },
+        rfqStatus: {
+            type: String,
+            enum: Object.values(common_1.BinanceRFQStatus),
+            required: true,
+        },
+        settlementStatus: {
+            type: String,
+            default: null,
+        },
+        rfqExpireTime: {
+            type: Number,
+            required: true,
+        },
+        symbol: {
+            type: String,
+            required: true,
+        },
+        side: {
+            type: String,
+            enum: Object.values(common_1.BinanceRFQSide),
+            required: true,
+        },
+        baseAsset: {
+            type: String,
+            required: true,
+        },
+        quoteAsset: {
+            type: String,
+            required: true,
+        },
+        quantity: {
+            type: Number,
+            required: true,
+        },
+        quoteOrderQty: {
+            type: Number,
+            required: true,
+        },
+        lastBidQuoteId: {
+            type: String,
+            default: null,
+        },
+        lastOfferQuoteId: {
+            type: String,
+            default: null,
+        },
+        bidPrice: {
+            type: Number,
+            default: null,
+        },
+        bidQuantity: {
+            type: Number,
+            default: null,
+        },
+        offerPrice: {
+            type: Number,
+            default: null,
+        },
+        offerQuantity: {
+            type: Number,
+            default: null,
+        },
+    }, {
+        timestamps: true,
+        toJSON: {
+            transform(doc, ret) {
+                ret.id = ret._id.valueOf();
+                delete ret._id;
+                delete ret.__v;
+            },
+        },
+    });
+    BinanceRFQOrderSchema.statics.build = (attrs) => {
+        return new BinanceRFQOrder(attrs);
+    };
+    const BinanceRFQOrder = mongoose.model("BinanceRFQOrder", BinanceRFQOrderSchema);
+    return BinanceRFQOrder;
+};
+exports.buildBinanceRFQOrder = buildBinanceRFQOrder;

package/build/models/binance-rfq-quote.d.ts

@@ -0,0 +1,33 @@
+import { Mongoose, Model, Document } from "mongoose";
+import { BinanceRFQQuoteStatus, BinanceRFQSide } from "@riocrypto/common";
+interface BinanceRFQQuoteAttrs {
+    rfqId: string;
+    quoteId: string;
+    clientQuoteId: string;
+    baseAsset: string;
+    quoteAsset: string;
+    side: BinanceRFQSide;
+    price: number;
+    quantity: number;
+    settleTime: number;
+    status: BinanceRFQQuoteStatus;
+}
+interface BinanceRFQQuoteDoc extends Document {
+    rfqId: string;
+    quoteId: string;
+    clientQuoteId: string;
+    baseAsset: string;
+    quoteAsset: string;
+    side: BinanceRFQSide;
+    price: number;
+    quantity: number;
+    settleTime: number;
+    status: BinanceRFQQuoteStatus;
+    createdAt: Date;
+    updatedAt: Date;
+}
+interface BinanceRFQQuoteModel extends Model<BinanceRFQQuoteDoc> {
+    build(attrs: BinanceRFQQuoteAttrs): BinanceRFQQuoteDoc;
+}
+declare const buildBinanceRFQQuote: (mongoose: Mongoose) => BinanceRFQQuoteModel;
+export { buildBinanceRFQQuote, BinanceRFQQuoteDoc, BinanceRFQQuoteAttrs };

package/build/models/binance-rfq-quote.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildBinanceRFQQuote = void 0;
+const common_1 = require("@riocrypto/common");
+const buildBinanceRFQQuote = (mongoose) => {
+    if (mongoose.models.BinanceRFQQuote) {
+        return mongoose.model("BinanceRFQQuote");
+    }
+    const BinanceRFQQuoteSchema = new mongoose.Schema({
+        rfqId: {
+            type: String,
+            required: true,
+        },
+        quoteId: {
+            type: String,
+            required: true,
+        },
+        clientQuoteId: {
+            type: String,
+            required: true,
+        },
+        baseAsset: {
+            type: String,
+            required: true,
+        },
+        quoteAsset: {
+            type: String,
+            required: true,
+        },
+        side: {
+            type: String,
+            enum: Object.values(common_1.BinanceRFQSide),
+            required: true,
+        },
+        price: {
+            type: Number,
+            required: true,
+        },
+        quantity: {
+            type: Number,
+            required: true,
+        },
+        settleTime: {
+            type: Number,
+            required: true,
+        },
+        status: {
+            type: String,
+            enum: Object.values(common_1.BinanceRFQQuoteStatus),
+            required: true,
+        },
+    }, {
+        timestamps: true,
+        toJSON: {
+            transform(doc, ret) {
+                ret.id = ret._id.valueOf();
+                delete ret._id;
+                delete ret.__v;
+            },
+        },
+    });
+    BinanceRFQQuoteSchema.statics.build = (attrs) => {
+        return new BinanceRFQQuote(attrs);
+    };
+    const BinanceRFQQuote = mongoose.model("BinanceRFQQuote", BinanceRFQQuoteSchema);
+    return BinanceRFQQuote;
+};
+exports.buildBinanceRFQQuote = buildBinanceRFQQuote;

package/build/models/binance-rfq-trade.d.ts

@@ -0,0 +1,29 @@
+import { Mongoose, Model, Document } from "mongoose";
+import { BinanceRFQTradeStatus } from "@riocrypto/common";
+interface BinanceRFQTradeAttrs {
+    rfqId: string;
+    quoteId: string;
+    tradeId: string;
+    executedPrice: number;
+    executedQty: number;
+    tradeStatus: BinanceRFQTradeStatus;
+    tradeAt: Date;
+    settledAt: Date | null;
+}
+interface BinanceRFQTradeDoc extends Document {
+    rfqId: string;
+    quoteId: string;
+    tradeId: string;
+    executedPrice: number;
+    executedQty: number;
+    tradeStatus: BinanceRFQTradeStatus;
+    tradeAt: Date;
+    settledAt: Date | null;
+    createdAt: Date;
+    updatedAt: Date;
+}
+interface BinanceRFQTradeModel extends Model<BinanceRFQTradeDoc> {
+    build(attrs: BinanceRFQTradeAttrs): BinanceRFQTradeDoc;
+}
+declare const buildBinanceRFQTrade: (mongoose: Mongoose) => BinanceRFQTradeModel;
+export { buildBinanceRFQTrade, BinanceRFQTradeDoc, BinanceRFQTradeAttrs };

package/build/models/binance-rfq-trade.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildBinanceRFQTrade = void 0;
+const common_1 = require("@riocrypto/common");
+const buildBinanceRFQTrade = (mongoose) => {
+    if (mongoose.models.BinanceRFQTrade) {
+        return mongoose.model("BinanceRFQTrade");
+    }
+    const BinanceRFQTradeSchema = new mongoose.Schema({
+        rfqId: {
+            type: String,
+            required: true,
+        },
+        quoteId: {
+            type: String,
+            required: true,
+        },
+        tradeId: {
+            type: String,
+            required: true,
+        },
+        executedPrice: {
+            type: Number,
+            required: true,
+        },
+        executedQty: {
+            type: Number,
+            required: true,
+        },
+        tradeStatus: {
+            type: String,
+            enum: Object.values(common_1.BinanceRFQTradeStatus),
+            required: true,
+        },
+        tradeAt: {
+            type: Date,
+            required: true,
+        },
+        settledAt: {
+            type: Date,
+            default: null,
+        },
+    }, {
+        timestamps: true,
+        toJSON: {
+            transform(doc, ret) {
+                ret.id = ret._id.valueOf();
+                delete ret._id;
+                delete ret.__v;
+            },
+        },
+    });
+    BinanceRFQTradeSchema.statics.build = (attrs) => {
+        return new BinanceRFQTrade(attrs);
+    };
+    const BinanceRFQTrade = mongoose.model("BinanceRFQTrade", BinanceRFQTradeSchema);
+    return BinanceRFQTrade;
+};
+exports.buildBinanceRFQTrade = buildBinanceRFQTrade;

package/build/models/indicative-quote-page-verification.d.ts

@@ -0,0 +1,23 @@
+import { Mongoose, Model, Document } from "mongoose";
+interface IndicativeQuotePageVerificationAttrs {
+    pageId: string;
+    email: string;
+    verificationCode: string;
+    expiresAt: Date;
+    attempts: number;
+    createdAt: Date;
+}
+interface IndicativeQuotePageVerificationModel extends Model<IndicativeQuotePageVerificationDoc> {
+    build(attrs: IndicativeQuotePageVerificationAttrs): IndicativeQuotePageVerificationDoc;
+}
+interface IndicativeQuotePageVerificationDoc extends Document {
+    _id: string;
+    pageId: string;
+    email: string;
+    verificationCode: string;
+    expiresAt: Date;
+    attempts: number;
+    createdAt: Date;
+}
+declare const buildIndicativeQuotePageVerification: (mongoose: Mongoose) => IndicativeQuotePageVerificationModel;
+export { buildIndicativeQuotePageVerification, IndicativeQuotePageVerificationDoc, IndicativeQuotePageVerificationAttrs, };

package/build/models/indicative-quote-page-verification.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildIndicativeQuotePageVerification = void 0;
+const buildIndicativeQuotePageVerification = (mongoose) => {
+    if (mongoose.models.IndicativeQuotePageVerification) {
+        return mongoose.model("IndicativeQuotePageVerification");
+    }
+    const IndicativeQuotePageVerificationSchema = new mongoose.Schema({
+        pageId: {
+            type: String,
+            required: true,
+        },
+        email: {
+            type: String,
+            required: true,
+        },
+        verificationCode: {
+            type: String,
+            required: true,
+        },
+        expiresAt: {
+            type: Date,
+            required: true,
+        },
+        attempts: {
+            type: Number,
+            default: 0,
+        },
+        createdAt: {
+            type: Date,
+            required: true,
+        },
+    }, {
+        toJSON: {
+            transform(doc, ret) {
+                ret.id = ret._id.valueOf();
+                delete ret._id;
+                delete ret.__v;
+            },
+        },
+    });
+    IndicativeQuotePageVerificationSchema.index({ pageId: 1, email: 1 }, { unique: true });
+    IndicativeQuotePageVerificationSchema.index({ expiresAt: 1 }, { expireAfterSeconds: 0 });
+    IndicativeQuotePageVerificationSchema.statics.build = (attrs) => {
+        return new IndicativeQuotePageVerification(attrs);
+    };
+    const IndicativeQuotePageVerification = mongoose.model("IndicativeQuotePageVerification", IndicativeQuotePageVerificationSchema);
+    return IndicativeQuotePageVerification;
+};
+exports.buildIndicativeQuotePageVerification = buildIndicativeQuotePageVerification;

package/build/models/indicative-quote-page.d.ts

@@ -1,9 +1,8 @@
 import { IndicativeQuotePageQuoteConfig } from "@riocrypto/common";
 import { Mongoose, Model, Document } from "mongoose";
 interface IndicativeQuotePageAttrs {
-    userId?: string;
     quotes: IndicativeQuotePageQuoteConfig[];
-    allowedIPs: string[];
+    allowedEmails: string[];
     createdBy: string;
     createdAt: Date;
     updatedAt: Date;
@@ -13,9 +12,8 @@ interface IndicativeQuotePageModel extends Model<IndicativeQuotePageDoc> {
 }
 interface IndicativeQuotePageDoc extends Document {
     _id: string;
-    userId?: string;
     quotes: IndicativeQuotePageQuoteConfig[];
-    allowedIPs: string[];
+    allowedEmails: string[];
     createdBy: string;
     createdAt: Date;
     updatedAt: Date;

package/build/models/indicative-quote-page.js

@@ -54,14 +54,11 @@ const buildIndicativeQuotePage = (mongoose) => {
         },
     }, { _id: false });
     const IndicativeQuotePageSchema = new mongoose.Schema({
-        userId: {
-            type: String,
-        },
         quotes: {
             type: [QuoteConfigSchema],
             required: true,
         },
-        allowedIPs: {
+        allowedEmails: {
             type: [String],
             required: true,
         },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@riocrypto/common-server",
-  "version": "1.0.2721",
+  "version": "1.0.2723",
   "description": "",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
@@ -28,7 +28,7 @@
     "@google-cloud/secret-manager": "^5.3.0",
     "@google-cloud/storage": "^6.9.5",
     "@hyperdx/node-opentelemetry": "^0.7.0",
-    "@riocrypto/common": "^1.0.2516",
+    "@riocrypto/common": "^1.0.2520",
     "@types/express": "^4.17.13",
     "axios": "^1.7.4",
     "crypto-js": "^4.2.0",