@riocrypto/common 1.0.370 → 1.0.375

package/build/index.d.ts

@@ -27,6 +27,12 @@ export * from "./middlewares/verify-admin-api-key";
 export * from "./middlewares/require-admin-api-key";
 export * from "./middlewares/current-admin-auth";
 export * from "./middlewares/validate-auth";
+export * from "./middlewares/get-order";
+export * from "./middlewares/get-partner";
+export * from "./middlewares/get-user";
+export * from "./middlewares/require-priveleges";
+export * from "./middlewares/validate-kyc";
+export * from "./middlewares/validate-order";
 export * from "./events/base-listener";
 export * from "./events/base-publisher";
 export * from "./events/subjects";
@@ -134,3 +140,12 @@ export * from "./classes/PaymentMethodAsset";
 export * from "./classes/PayoutMethodAsset";
 export * from "./classes/USStateAsset";
 export * from "./classes/WyrePaymentMethodAsset";
+export * from "./services/apiKey";
+export * from "./services/password";
+export * from "./models/admin-auth";
+export * from "./models/auth";
+export * from "./models/business-user";
+export * from "./models/bank-payout";
+export * from "./models/order";
+export * from "./models/partner";
+export * from "./models/user";

package/build/index.js

@@ -43,6 +43,12 @@ __exportStar(require("./middlewares/verify-admin-api-key"), exports);
 __exportStar(require("./middlewares/require-admin-api-key"), exports);
 __exportStar(require("./middlewares/current-admin-auth"), exports);
 __exportStar(require("./middlewares/validate-auth"), exports);
+__exportStar(require("./middlewares/get-order"), exports);
+__exportStar(require("./middlewares/get-partner"), exports);
+__exportStar(require("./middlewares/get-user"), exports);
+__exportStar(require("./middlewares/require-priveleges"), exports);
+__exportStar(require("./middlewares/validate-kyc"), exports);
+__exportStar(require("./middlewares/validate-order"), exports);
 __exportStar(require("./events/base-listener"), exports);
 __exportStar(require("./events/base-publisher"), exports);
 __exportStar(require("./events/subjects"), exports);
@@ -150,3 +156,18 @@ __exportStar(require("./classes/PaymentMethodAsset"), exports);
 __exportStar(require("./classes/PayoutMethodAsset"), exports);
 __exportStar(require("./classes/USStateAsset"), exports);
 __exportStar(require("./classes/WyrePaymentMethodAsset"), exports);
+__exportStar(require("./services/apiKey"), exports);
+__exportStar(require("./services/password"), exports);
+__exportStar(require("./models/admin-auth"), exports);
+//@ts-ignore
+__exportStar(require("./models/auth"), exports);
+//@ts-ignore
+__exportStar(require("./models/business-user"), exports);
+//@ts-ignore
+__exportStar(require("./models/bank-payout"), exports);
+//@ts-ignore
+__exportStar(require("./models/order"), exports);
+//@ts-ignore
+__exportStar(require("./models/partner"), exports);
+//@ts-ignore
+__exportStar(require("./models/user"), exports);

package/build/middlewares/get-order.d.ts

@@ -0,0 +1,10 @@
+import { Request, Response, NextFunction } from "express";
+import { OrderDoc } from "../models/order";
+declare global {
+    namespace Express {
+        interface Request {
+            order?: OrderDoc;
+        }
+    }
+}
+export declare const getOrder: (req: Request, res: Response, next: NextFunction) => Promise<void>;

package/build/middlewares/get-order.js

@@ -0,0 +1,41 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOrder = void 0;
+const not_found_error_1 = require("../errors/not-found-error");
+const order_1 = require("../models/order");
+const getOrder = (req, res, next) => __awaiter(void 0, void 0, void 0, function* () {
+    let orderId = "";
+    if (req.body.orderId) {
+        orderId = req.body.orderId;
+    }
+    else if (req.params.orderId) {
+        orderId = req.params.orderId;
+    }
+    else if (req.query.orderId) {
+        orderId = req.query.orderId;
+    }
+    if (!orderId) {
+        throw new Error("Failed to provide orderId");
+    }
+    try {
+        const order = yield order_1.Order.findById(orderId);
+        if (!order) {
+            throw new Error();
+        }
+        req.order = order;
+    }
+    catch (error) {
+        throw new not_found_error_1.NotFoundError();
+    }
+    next();
+});
+exports.getOrder = getOrder;

package/build/middlewares/get-partner.d.ts

@@ -0,0 +1,9 @@
+import { Request, Response, NextFunction } from "express";
+declare global {
+    namespace Express {
+        interface Request {
+            partnerId?: string;
+        }
+    }
+}
+export declare const getPartner: (req: Request, res: Response, next: NextFunction) => Promise<void>;

package/build/middlewares/get-partner.js

@@ -0,0 +1,40 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPartner = void 0;
+const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+const partner_1 = require("../models/partner");
+const apiKey_1 = require("../services/apiKey");
+const getPartner = (req, res, next) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        if (!req.headers["x-api-key"]) {
+            const payload = jsonwebtoken_1.default.verify(req.cookies.partnerAuthJwt, process.env.JWT_KEY_PARTNER);
+            req.partnerId = payload.partnerId;
+        }
+        else {
+            const hashedApiKey = yield apiKey_1.ApiKey.toHash(req.headers["x-api-key"]);
+            const partner = yield partner_1.Partner.findOne({
+                apiKeys: { $elemMatch: { value: hashedApiKey } },
+            });
+            if (partner) {
+                req.partnerId = partner._id.valueOf();
+            }
+        }
+        next();
+    }
+    catch (err) {
+        next();
+    }
+});
+exports.getPartner = getPartner;

package/build/middlewares/get-user.d.ts

@@ -0,0 +1,11 @@
+import { Request, Response, NextFunction } from "express";
+import { BusinessUserDoc } from "../models/business-user";
+import { UserDoc } from "../models/user";
+declare global {
+    namespace Express {
+        interface Request {
+            user?: UserDoc | BusinessUserDoc;
+        }
+    }
+}
+export declare const getUser: (req: Request, res: Response, next: NextFunction) => Promise<void>;

package/build/middlewares/get-user.js

@@ -0,0 +1,43 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUser = void 0;
+const business_user_1 = require("../models/business-user");
+const user_1 = require("../models/user");
+const user_attribute_1 = require("../types/user-attribute");
+const getUser = (req, res, next) => __awaiter(void 0, void 0, void 0, function* () {
+    let individualUser;
+    let businessUser;
+    try {
+        individualUser = yield user_1.User.findOne({
+            phoneNumber: req.currentAuth.phoneNumber,
+            attributes: { $ne: user_attribute_1.UserAttribute.deleted },
+        });
+    }
+    catch (err) {
+        individualUser = null;
+    }
+    try {
+        businessUser = yield business_user_1.BusinessUser.findOne({
+            phoneNumber: req.currentAuth.phoneNumber,
+            attributes: { $ne: user_attribute_1.UserAttribute.deleted },
+        });
+    }
+    catch (err) {
+        businessUser = null;
+    }
+    const user = individualUser || businessUser;
+    if (user) {
+        req.user = user;
+    }
+    next();
+});
+exports.getUser = getUser;

package/build/middlewares/require-priveleges.d.ts

@@ -0,0 +1,2 @@
+import { Request, Response, NextFunction } from "express";
+export declare const requirePriveleges: (req: Request, res: Response, next: NextFunction) => void;

package/build/middlewares/require-priveleges.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requirePriveleges = void 0;
+const missing_user_error_1 = require("../errors/missing-user-error");
+const not_authorized_error_1 = require("../errors/not-authorized-error");
+const requirePriveleges = (req, res, next) => {
+    if (req.currentAuth && !req.user) {
+        throw new missing_user_error_1.MissingUserError();
+    }
+    if (!req.partnerId && !req.user && !req.currentAdminAuth) {
+        throw new not_authorized_error_1.NotAuthorizedError();
+    }
+    next();
+};
+exports.requirePriveleges = requirePriveleges;

package/build/middlewares/validate-auth.d.ts

@@ -1,2 +1,2 @@
 import { Request, Response, NextFunction } from "express";
-export declare const validateKYC: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+export declare const validateAuth: (req: Request, res: Response, next: NextFunction) => Promise<void>;

package/build/middlewares/validate-auth.js

@@ -9,10 +9,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateKYC = void 0;
+exports.validateAuth = void 0;
 const missing_password_error_1 = require("../errors/missing-password-error");
 const missing_security_question_error_1 = require("../errors/missing-security-question-error");
-const validateKYC = (req, res, next) => __awaiter(void 0, void 0, void 0, function* () {
+const validateAuth = (req, res, next) => __awaiter(void 0, void 0, void 0, function* () {
     const auth = req.currentAuth;
     if (auth) {
         if (auth.missing.includes("password")) {
@@ -27,4 +27,4 @@ const validateKYC = (req, res, next) => __awaiter(void 0, void 0, void 0, functi
     }
     next();
 });
-exports.validateKYC = validateKYC;
+exports.validateAuth = validateAuth;

package/build/middlewares/validate-kyc.d.ts

@@ -0,0 +1,2 @@
+import { Request, Response, NextFunction } from "express";
+export declare const validateKYC: (req: Request, res: Response, next: NextFunction) => Promise<void>;

package/build/middlewares/validate-kyc.js

@@ -0,0 +1,30 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateKYC = void 0;
+const missing_kyc_approval_error_1 = require("../errors/missing-kyc-approval-error");
+const kyc_status_1 = require("../types/kyc-status");
+const user_type_1 = require("../types/user-type");
+const validateKYC = (req, res, next) => __awaiter(void 0, void 0, void 0, function* () {
+    const user = req.user;
+    if ((user === null || user === void 0 ? void 0 : user.type) === user_type_1.UserType.Individual) {
+        if (user.kycStatus !== kyc_status_1.KYCStatus.Passed) {
+            throw new missing_kyc_approval_error_1.MissingKYCApprovalError();
+        }
+    }
+    if ((user === null || user === void 0 ? void 0 : user.type) === user_type_1.UserType.Business) {
+        if (user.kycStatus !== kyc_status_1.KYCStatus.businessApproved) {
+            throw new missing_kyc_approval_error_1.MissingKYCApprovalError();
+        }
+    }
+    next();
+});
+exports.validateKYC = validateKYC;

package/build/middlewares/validate-order.d.ts

@@ -0,0 +1,2 @@
+import { Request, Response, NextFunction } from "express";
+export declare const validateOrder: (req: Request, res: Response, next: NextFunction) => Promise<void>;

package/build/middlewares/validate-order.js

@@ -0,0 +1,27 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateOrder = void 0;
+const not_authorized_error_1 = require("../errors/not-authorized-error");
+const validateOrder = (req, res, next) => __awaiter(void 0, void 0, void 0, function* () {
+    const order = req.order;
+    if (!order) {
+        throw new not_authorized_error_1.NotAuthorizedError();
+    }
+    if (req.partnerId && req.partnerId !== order.partnerId) {
+        throw new not_authorized_error_1.NotAuthorizedError();
+    }
+    if (req.user && req.user._id.valueOf() !== order.userId) {
+        throw new not_authorized_error_1.NotAuthorizedError();
+    }
+    next();
+});
+exports.validateOrder = validateOrder;

package/build/models/admin-auth.d.ts

@@ -0,0 +1,16 @@
+import mongoose from "mongoose";
+interface AdminAuthAttrs {
+    email: string;
+    password: string;
+    previousPasswords?: string[];
+}
+interface AdminAuthDoc extends mongoose.Document {
+    email: string;
+    password: string;
+    previousPasswords?: string[];
+}
+interface AdminAuthModel extends mongoose.Model<AdminAuthDoc> {
+    build(attrs: AdminAuthAttrs): AdminAuthDoc;
+}
+declare const AdminAuth: AdminAuthModel;
+export { AdminAuth, AdminAuthDoc };

package/build/models/admin-auth.js

@@ -0,0 +1,56 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdminAuth = void 0;
+const mongoose_1 = __importDefault(require("mongoose"));
+const password_1 = require("../services/password");
+const AdminSchema = new mongoose_1.default.Schema({
+    email: {
+        type: String,
+        required: true,
+    },
+    password: {
+        type: String,
+        required: true,
+    },
+    previousPasswords: [
+        {
+            type: String,
+            required: false,
+        },
+    ],
+}, {
+    toJSON: {
+        transform(doc, ret) {
+            ret.id = ret._id.valueOf();
+            delete ret._id;
+            delete ret.__v;
+            delete ret.password;
+        },
+    },
+});
+AdminSchema.pre("save", function (done) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (this.isModified("password")) {
+            const hashed = yield password_1.Password.toHash(this.get("password"));
+            this.set("password", hashed);
+        }
+        done();
+    });
+});
+AdminSchema.statics.build = (attrs) => {
+    return new AdminAuth(attrs);
+};
+const AdminAuth = mongoose_1.default.model("Admin", AdminSchema);
+exports.AdminAuth = AdminAuth;

package/build/models/auth.d.ts

@@ -0,0 +1,24 @@
+import mongoose from "mongoose";
+import { APIKey } from "../types/api-key";
+import { SecurityQuestion } from "../types/security-question";
+interface AuthAttrs {
+    phoneNumber: string;
+    password?: string;
+    securityQuestion?: SecurityQuestion;
+    securityAnswer?: string;
+    previousPasswords?: string[];
+    apiKeys?: APIKey[];
+}
+interface AuthDoc extends mongoose.Document {
+    phoneNumber: string;
+    password?: string;
+    securityQuestion?: SecurityQuestion;
+    securityAnswer?: string;
+    previousPasswords?: string[];
+    apiKeys?: APIKey[];
+}
+interface AuthModel extends mongoose.Model<AuthDoc> {
+    build(attrs: AuthAttrs): AuthDoc;
+}
+declare const Auth: AuthModel;
+export { Auth, AuthDoc };

package/build/models/auth.js

@@ -0,0 +1,80 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Auth = void 0;
+const mongoose_1 = __importDefault(require("mongoose"));
+const password_1 = require("../services/password");
+const AuthSchema = new mongoose_1.default.Schema({
+    phoneNumber: {
+        type: String,
+        required: true,
+    },
+    password: {
+        type: String,
+    },
+    securityQuestion: {
+        type: String,
+    },
+    securityAnswer: {
+        type: String,
+    },
+    previousPasswords: [
+        {
+            type: String,
+        },
+    ],
+    apiKeys: [
+        {
+            value: {
+                type: String,
+                required: true,
+            },
+            label: {
+                type: String,
+            },
+            id: {
+                type: String,
+                required: true,
+            },
+        },
+    ],
+}, {
+    toJSON: {
+        transform(doc, ret) {
+            ret.id = ret._id.valueOf();
+            delete ret._id;
+            delete ret.__v;
+            delete ret.password;
+            delete ret.securityAnswer;
+            delete ret.previousPasswords;
+            for (let apiKey of ret.apiKeys) {
+                delete apiKey.value;
+            }
+        },
+    },
+});
+AuthSchema.pre("save", function (done) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (this.isModified("password")) {
+            const hashed = yield password_1.Password.toHash(this.get("password"));
+            this.set("password", hashed);
+        }
+        done();
+    });
+});
+AuthSchema.statics.build = (attrs) => {
+    return new Auth(attrs);
+};
+const Auth = mongoose_1.default.model("Auth", AuthSchema);
+exports.Auth = Auth;

package/build/models/bank-payout.d.ts

@@ -0,0 +1,20 @@
+import mongoose from "mongoose";
+interface BankPayoutAttrs {
+    orderId: string;
+    originBank: string;
+    destinationBank?: string;
+    accountNumber: string;
+    status: string;
+}
+interface BankPayoutDoc extends mongoose.Document {
+    orderId: string;
+    originBank: string;
+    destinationBank?: string;
+    accountNumber: string;
+    status: string;
+}
+interface BankPayoutModel extends mongoose.Model<BankPayoutDoc> {
+    build(attrs: BankPayoutAttrs): BankPayoutDoc;
+}
+declare const BankPayout: BankPayoutModel;
+export { BankPayout, BankPayoutDoc };

package/build/models/bank-payout.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BankPayout = void 0;
+const mongoose_1 = __importDefault(require("mongoose"));
+const BankPayoutSchema = new mongoose_1.default.Schema({
+    orderId: {
+        type: String,
+        required: true,
+    },
+    originBank: {
+        type: String,
+        required: true,
+    },
+    accountNumber: {
+        type: String,
+        required: true,
+    },
+    status: {
+        type: String,
+        required: true,
+    },
+    destinationBank: {
+        type: String,
+    },
+}, {
+    toJSON: {
+        transform(doc, ret) {
+            ret.id = ret._id;
+            delete ret._id;
+            delete ret.__v;
+        },
+    },
+});
+BankPayoutSchema.statics.build = (attrs) => {
+    return new BankPayout(attrs);
+};
+const BankPayout = mongoose_1.default.model("BankPayout", BankPayoutSchema);
+exports.BankPayout = BankPayout;

package/build/models/business-user.d.ts

@@ -0,0 +1,55 @@
+import mongoose from "mongoose";
+import { Country } from "../types/country";
+import { KYCStatus } from "../types/kyc-status";
+import { Language } from "../types/language";
+import { PlatformFeeRange } from "../types/platform-fee-range";
+import { USState } from "../types/us-state";
+import { UserAttribute } from "../types/user-attribute";
+import { UserType } from "../types/user-type";
+interface BusinessUserAttrs {
+    type: UserType;
+    companyName: string;
+    legalRepresentative: string;
+    phoneNumber: string;
+    email: string;
+    street1: string;
+    street2?: string;
+    city: string;
+    state: USState | string;
+    postalCode: string;
+    country: Country;
+    kycStatus: KYCStatus;
+    COIFile?: string;
+    KYCReportFile?: string;
+    cpf?: string;
+    language?: Language;
+    attributes?: UserAttribute[];
+    brokerId?: string;
+    platformFeeRanges?: PlatformFeeRange[];
+}
+interface BusinessUserModel extends mongoose.Model<BusinessUserDoc> {
+    build(attrs: BusinessUserAttrs): BusinessUserDoc;
+}
+interface BusinessUserDoc extends mongoose.Document {
+    type: UserType;
+    companyName: string;
+    legalRepresentative: string;
+    phoneNumber: string;
+    email: string;
+    street1: string;
+    street2?: string;
+    city: string;
+    state: USState | string;
+    postalCode: string;
+    country: Country;
+    kycStatus: KYCStatus;
+    COIFile?: string;
+    KYCReportFile?: string;
+    cpf?: string;
+    language?: Language;
+    attributes?: UserAttribute[];
+    brokerId?: string;
+    platformFeeRanges?: PlatformFeeRange[];
+}
+declare const BusinessUser: BusinessUserModel;
+export { BusinessUser, BusinessUserDoc };

package/build/models/business-user.js

@@ -0,0 +1,105 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BusinessUser = void 0;
+const mongoose_1 = __importDefault(require("mongoose"));
+const BusinessUserSchema = new mongoose_1.default.Schema({
+    type: {
+        type: String,
+        required: true,
+    },
+    companyName: {
+        type: String,
+        required: true,
+    },
+    legalRepresentative: {
+        type: String,
+        required: true,
+    },
+    phoneNumber: {
+        type: String,
+        required: true,
+    },
+    email: {
+        type: String,
+        required: true,
+    },
+    street1: {
+        type: String,
+        required: true,
+    },
+    street2: {
+        type: String,
+    },
+    city: {
+        type: String,
+        required: true,
+    },
+    state: {
+        type: String,
+        required: true,
+    },
+    postalCode: {
+        type: String,
+        required: true,
+    },
+    country: {
+        type: String,
+        required: true,
+    },
+    language: {
+        type: String,
+    },
+    cpf: {
+        type: String,
+    },
+    attributes: [
+        {
+            type: String,
+        },
+    ],
+    kycStatus: {
+        type: String,
+        required: true,
+    },
+    COIFile: {
+        type: String,
+    },
+    KYCReportFile: {
+        type: String,
+    },
+    brokerId: {
+        type: String,
+    },
+    platformFeeRanges: [
+        {
+            min: {
+                type: Number,
+                required: true,
+            },
+            max: {
+                type: Number,
+                required: true,
+            },
+            fee: {
+                type: Number,
+                required: true,
+            },
+        },
+    ],
+}, {
+    toJSON: {
+        transform(doc, ret) {
+            ret.id = ret._id;
+            delete ret._id;
+            delete ret.__v;
+        },
+    },
+});
+BusinessUserSchema.statics.build = (attrs) => {
+    return new BusinessUser(attrs);
+};
+const BusinessUser = mongoose_1.default.model("BusinessUser", BusinessUserSchema);
+exports.BusinessUser = BusinessUser;

package/build/models/order.d.ts

@@ -0,0 +1,66 @@
+import mongoose from "mongoose";
+import { Country } from "../types/country";
+import { Fees } from "../types/fees";
+import { Fiat } from "../types/fiat";
+import { LiquidityProvider } from "../types/liquidity-provider";
+import { OrderStatus } from "../types/order-status";
+import { PaymentMethod } from "../types/payment-method";
+import { PayoutMethod } from "../types/payout-method";
+import { Processor } from "../types/processor";
+import { Side } from "../types/side";
+import { USState } from "../types/us-state";
+interface OrderAttrs {
+    userId: string;
+    crypto: Crypto;
+    side: Side;
+    fiat: Fiat;
+    paymentMethod?: PaymentMethod;
+    payoutMethod?: PayoutMethod;
+    createdAt: Date;
+    status: OrderStatus;
+    cryptoAddress: string;
+    country: Country;
+    state: USState | string;
+    amountFiat?: number;
+    amountCrypto?: number;
+    liquidityProvider?: LiquidityProvider;
+    processor?: Processor;
+    fees?: Fees;
+    price?: number;
+    partnerId?: string;
+    depositAddress?: string;
+    depositTxId?: string;
+    withdrawalTxId?: string;
+    addressVerified?: boolean;
+    brokerCustomerId?: string;
+}
+interface OrderDoc extends mongoose.Document {
+    userId: string;
+    status: OrderStatus;
+    crypto: Crypto;
+    side: Side;
+    fiat: Fiat;
+    paymentMethod?: PaymentMethod;
+    payoutMethod?: PayoutMethod;
+    createdAt: Date;
+    country: Country;
+    state: USState | string;
+    cryptoAddress: string;
+    amountFiat?: number;
+    amountCrypto?: number;
+    liquidityProvider?: LiquidityProvider;
+    processor?: Processor;
+    fees?: Fees;
+    price?: number;
+    partnerId?: string;
+    depositAddress?: string;
+    depositTxId?: string;
+    withdrawalTxId?: string;
+    addressVerified?: boolean;
+    brokerCustomerId?: string;
+}
+interface OrderModel extends mongoose.Model<OrderDoc> {
+    build(attrs: OrderAttrs): OrderDoc;
+}
+declare const Order: OrderModel;
+export { Order, OrderDoc };

package/build/models/order.js

@@ -0,0 +1,120 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Order = void 0;
+const mongoose_1 = __importDefault(require("mongoose"));
+const orderSchema = new mongoose_1.default.Schema({
+    userId: {
+        type: String,
+        required: true,
+    },
+    status: {
+        type: String,
+        required: true,
+    },
+    crypto: {
+        type: String,
+        required: true,
+    },
+    side: {
+        type: String,
+        required: true,
+    },
+    fiat: {
+        type: String,
+        required: true,
+    },
+    paymentMethod: {
+        type: String,
+    },
+    payoutMethod: {
+        type: String,
+    },
+    createdAt: {
+        type: mongoose_1.default.Schema.Types.Date,
+        required: true,
+    },
+    cryptoAddress: {
+        type: String,
+        required: true,
+    },
+    country: {
+        type: String,
+        required: true,
+    },
+    state: {
+        type: String,
+        required: true,
+    },
+    amountFiat: {
+        type: Number,
+    },
+    amountCrypto: {
+        type: Number,
+    },
+    processor: {
+        type: String,
+    },
+    liquidityProvider: {
+        type: String,
+    },
+    depositTxId: {
+        type: String,
+    },
+    withdrawalTxId: {
+        type: String,
+    },
+    depositAddress: {
+        type: String,
+    },
+    fees: {
+        processingFeeCrypto: {
+            type: Number,
+        },
+        transferFeeCrypto: {
+            type: Number,
+        },
+        platformFeeCrypto: {
+            type: Number,
+        },
+        processingFeeFiat: {
+            type: Number,
+        },
+        transferFeeFiat: {
+            type: Number,
+        },
+        platformFeeFiat: {
+            type: Number,
+        },
+        partnerFeeFiat: {
+            type: Number,
+        },
+    },
+    price: {
+        type: Number,
+    },
+    partnerId: {
+        type: String,
+    },
+    addressVerified: {
+        type: Boolean,
+    },
+    brokerCustomerId: {
+        type: String,
+    },
+}, {
+    toJSON: {
+        transform(doc, ret) {
+            ret.id = ret._id;
+            delete ret._id;
+            delete ret.__v;
+        },
+    },
+});
+orderSchema.statics.build = (attrs) => {
+    return new Order(attrs);
+};
+const Order = mongoose_1.default.model("Order", orderSchema);
+exports.Order = Order;

package/build/models/partner.d.ts

@@ -0,0 +1,33 @@
+import mongoose from "mongoose";
+import { PartnerStatus } from "../types/partner-status";
+interface PartnerAttrs {
+    name: string;
+    status: PartnerStatus;
+    partnerFee: number;
+    platformFee: number;
+    color?: string;
+    logo?: string;
+    apiKeys?: {
+        value: string;
+        label: string;
+        id: string;
+    }[];
+}
+interface PartnerDoc extends mongoose.Document {
+    name: string;
+    status: PartnerStatus;
+    partnerFee: number;
+    platformFee: number;
+    color?: string;
+    logo?: string;
+    apiKeys?: {
+        value: string;
+        label: string;
+        id: string;
+    }[];
+}
+interface PartnerModel extends mongoose.Model<PartnerDoc> {
+    build(attrs: PartnerAttrs): PartnerDoc;
+}
+declare const Partner: PartnerModel;
+export { Partner, PartnerDoc };

package/build/models/partner.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Partner = void 0;
+const mongoose_1 = __importDefault(require("mongoose"));
+const PartnerSchema = new mongoose_1.default.Schema({
+    name: {
+        type: String,
+        required: true,
+    },
+    status: {
+        type: String,
+        required: true,
+    },
+    partnerFee: {
+        type: Number,
+        required: true,
+    },
+    platformFee: {
+        type: Number,
+        required: true,
+    },
+    color: {
+        type: String,
+    },
+    logo: {
+        type: String,
+    },
+    apiKeys: [
+        {
+            value: {
+                type: String,
+                required: true,
+            },
+            label: {
+                type: String,
+            },
+            id: {
+                type: String,
+                required: true,
+            },
+        },
+    ],
+}, {
+    toJSON: {
+        transform(doc, ret) {
+            ret.id = ret._id;
+            delete ret._id;
+            delete ret.__v;
+            ret.apiKeys.forEach((apiKey) => {
+                delete apiKey.value;
+            });
+        },
+    },
+});
+PartnerSchema.statics.build = (attrs) => {
+    return new Partner(attrs);
+};
+const Partner = mongoose_1.default.model("Partner", PartnerSchema);
+exports.Partner = Partner;

package/build/models/user.d.ts

@@ -0,0 +1,50 @@
+import mongoose from "mongoose";
+import { Country } from "../types/country";
+import { KYCStatus } from "../types/kyc-status";
+import { Language } from "../types/language";
+import { USState } from "../types/us-state";
+import { UserAttribute } from "../types/user-attribute";
+import { UserType } from "../types/user-type";
+interface UserAttrs {
+    type: UserType;
+    firstName: string;
+    lastName: string;
+    phoneNumber: string;
+    birthday: Date;
+    email: string;
+    street1: string;
+    street2?: string;
+    city: string;
+    state: USState | string;
+    postalCode: string;
+    country: Country;
+    kycStatus: KYCStatus;
+    cpf?: string;
+    language?: Language;
+    attributes?: UserAttribute[];
+    partnerId?: string;
+}
+interface UserModel extends mongoose.Model<UserDoc> {
+    build(attrs: UserAttrs): UserDoc;
+}
+interface UserDoc extends mongoose.Document {
+    type: UserType;
+    firstName: string;
+    lastName: string;
+    phoneNumber: string;
+    birthday: Date;
+    email: string;
+    street1: string;
+    street2?: string;
+    city: string;
+    state: USState | string;
+    postalCode: string;
+    country: Country;
+    kycStatus: KYCStatus;
+    cpf?: string;
+    language?: Language;
+    attributes?: UserAttribute[];
+    partnerId?: string;
+}
+declare const User: UserModel;
+export { User, UserDoc };

package/build/models/user.js

@@ -0,0 +1,87 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.User = void 0;
+const mongoose_1 = __importDefault(require("mongoose"));
+const userSchema = new mongoose_1.default.Schema({
+    type: {
+        type: String,
+        required: true,
+    },
+    firstName: {
+        type: String,
+        required: true,
+    },
+    lastName: {
+        type: String,
+        required: true,
+    },
+    phoneNumber: {
+        type: String,
+        required: true,
+    },
+    birthday: {
+        type: Date,
+        required: true,
+    },
+    email: {
+        type: String,
+        required: true,
+    },
+    street1: {
+        type: String,
+        required: true,
+    },
+    street2: {
+        type: String,
+    },
+    city: {
+        type: String,
+        required: true,
+    },
+    state: {
+        type: String,
+        required: true,
+    },
+    postalCode: {
+        type: String,
+        required: true,
+    },
+    country: {
+        type: String,
+        required: true,
+    },
+    language: {
+        type: String,
+    },
+    cpf: {
+        type: String,
+    },
+    attributes: [
+        {
+            type: String,
+        },
+    ],
+    kycStatus: {
+        type: String,
+        required: true,
+    },
+    partnerId: {
+        type: String,
+    },
+}, {
+    toJSON: {
+        transform(doc, ret) {
+            ret.id = ret._id;
+            delete ret._id;
+            delete ret.__v;
+        },
+    },
+});
+userSchema.statics.build = (attrs) => {
+    return new User(attrs);
+};
+const User = mongoose_1.default.model("User", userSchema);
+exports.User = User;

package/build/services/apiKey.d.ts

@@ -0,0 +1,3 @@
+export declare class ApiKey {
+    static toHash(apiKey: string): Promise<string>;
+}

package/build/services/apiKey.js

@@ -0,0 +1,24 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiKey = void 0;
+const crypto_1 = require("crypto");
+class ApiKey {
+    static toHash(apiKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const salt = process.env.API_KEY_SALT;
+            const hash = (0, crypto_1.createHmac)("sha256", salt);
+            hash.update(apiKey);
+            return hash.digest("hex");
+        });
+    }
+}
+exports.ApiKey = ApiKey;

package/build/services/password.d.ts

@@ -0,0 +1,4 @@
+export declare class Password {
+    static toHash(password: string): Promise<string>;
+    static compare(storedPassword: string, suppliedPassword: string): Promise<boolean>;
+}

package/build/services/password.js

@@ -0,0 +1,32 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Password = void 0;
+const crypto_1 = require("crypto");
+const util_1 = require("util");
+const scryptAsync = (0, util_1.promisify)(crypto_1.scrypt);
+class Password {
+    static toHash(password) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const salt = (0, crypto_1.randomBytes)(8).toString("hex");
+            const buf = (yield scryptAsync(password, salt, 64));
+            return `${buf.toString("hex")}.${salt}`;
+        });
+    }
+    static compare(storedPassword, suppliedPassword) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [hashedPassword, salt] = storedPassword.split(".");
+            const buf = (yield scryptAsync(suppliedPassword, salt, 64));
+            return buf.toString("hex") === hashedPassword;
+        });
+    }
+}
+exports.Password = Password;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@riocrypto/common",
-  "version": "1.0.370",
+  "version": "1.0.375",
   "description": "",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
@@ -25,6 +25,7 @@
     "express": "^4.18.1",
     "express-validator": "^6.14.2",
     "jsonwebtoken": "^8.5.1",
+    "mongoose": "^7.0.2",
     "node-nats-streaming": "^0.3.2"
   }
 }