@riocrypto/common-server 1.0.506

package/build/models/checked-address.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildCheckedAddress = void 0;
+const buildCheckedAddress = (mongoose) => {
+    // if model is already defined, return it
+    if (mongoose.models.CheckedAddress) {
+        return mongoose.model("CheckedAddress");
+    }
+    const CheckedAddressSchema = new mongoose.Schema({
+        address: {
+            type: String,
+            required: true,
+        },
+        result: {
+            type: String,
+            required: true,
+        },
+        lastChecked: {
+            type: mongoose.Schema.Types.Date,
+            required: true,
+        },
+    }, {
+        toJSON: {
+            transform(doc, ret) {
+                ret.id = ret._id;
+                delete ret._id;
+                delete ret.__v;
+            },
+        },
+    });
+    CheckedAddressSchema.statics.build = (attrs) => {
+        return new CheckedAddress(attrs);
+    };
+    const CheckedAddress = mongoose.model("CheckedAddress", CheckedAddressSchema);
+    return CheckedAddress;
+};
+exports.buildCheckedAddress = buildCheckedAddress;

package/build/models/kushki-payment.d.ts

@@ -0,0 +1,16 @@
+import mongoose from "mongoose";
+interface KushkiPaymentAttrs {
+    orderId: string;
+    kushkiTransactionReference: string;
+    status: string;
+}
+interface KushkiPaymentDoc extends mongoose.Document {
+    orderId: string;
+    status: string;
+    kushkiTransactionReference: string;
+}
+interface KushkiPaymentModel extends mongoose.Model<KushkiPaymentDoc> {
+    build(attrs: KushkiPaymentAttrs): KushkiPaymentDoc;
+}
+declare const buildKushkiPayment: (mongoose: typeof mongoose) => KushkiPaymentModel;
+export { buildKushkiPayment, KushkiPaymentDoc };

package/build/models/kushki-payment.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildKushkiPayment = void 0;
+const buildKushkiPayment = (mongoose) => {
+    // if model is already defined, return it
+    if (mongoose.models.KushkiPayment) {
+        return mongoose.model("KushkiPayment");
+    }
+    const KushkiPaymentSchema = new mongoose.Schema({
+        orderId: {
+            type: String,
+            required: true,
+        },
+        kushkiTransactionReference: {
+            type: String,
+            required: true,
+        },
+        status: {
+            type: String,
+            required: true,
+        },
+    }, {
+        toJSON: {
+            transform(doc, ret) {
+                ret.id = ret._id;
+                delete ret._id;
+                delete ret.__v;
+            },
+        },
+    });
+    KushkiPaymentSchema.statics.build = (attrs) => {
+        return new KushkiPayment(attrs);
+    };
+    const KushkiPayment = mongoose.model("KushkiPayment", KushkiPaymentSchema);
+    return KushkiPayment;
+};
+exports.buildKushkiPayment = buildKushkiPayment;

package/build/models/kyc.d.ts

@@ -0,0 +1,20 @@
+import mongoose from "mongoose";
+interface KYCAttrs {
+    userId: string;
+    provider: string;
+    providerId: string;
+    result: string;
+    lastChecked: Date;
+}
+interface KYCDoc extends mongoose.Document {
+    userId: string;
+    provider: string;
+    providerId: string;
+    result: string;
+    lastChecked: Date;
+}
+interface KYCModel extends mongoose.Model<KYCDoc> {
+    build(attrs: KYCAttrs): KYCDoc;
+}
+declare const buildKYC: (mongoose: typeof mongoose) => KYCModel;
+export { buildKYC, KYCDoc };

package/build/models/kyc.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildKYC = void 0;
+const buildKYC = (mongoose) => {
+    // if model is already defined, return it
+    if (mongoose.models.KYC) {
+        return mongoose.model("KYC");
+    }
+    const KYCSchema = new mongoose.Schema({
+        userId: {
+            type: String,
+            required: true,
+        },
+        provider: {
+            type: String,
+            required: true,
+        },
+        providerId: {
+            type: String,
+            required: true,
+        },
+        result: {
+            type: String,
+            required: true,
+        },
+        lastChecked: {
+            type: mongoose.Schema.Types.Date,
+            required: true,
+        },
+    }, {
+        toJSON: {
+            transform(doc, ret) {
+                ret.id = ret._id;
+                delete ret._id;
+                delete ret.__v;
+            },
+        },
+    });
+    KYCSchema.statics.build = (attrs) => {
+        return new KYC(attrs);
+    };
+    const KYC = mongoose.model("KYC", KYCSchema);
+    return KYC;
+};
+exports.buildKYC = buildKYC;

package/build/models/order.d.ts

@@ -0,0 +1,67 @@
+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";
+import { Crypto } from "../types/crypto";
+import { Mongoose, Model, Document } from "mongoose";
+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 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 Model<OrderDoc> {
+    build(attrs: OrderAttrs): OrderDoc;
+}
+declare const buildOrder: (mongoose: Mongoose) => OrderModel;
+export { buildOrder, OrderDoc };

package/build/models/order.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildOrder = void 0;
+const buildOrder = (mongoose) => {
+    // if model is already defined, return it
+    if (mongoose.models.Order) {
+        return mongoose.model("Order");
+    }
+    const orderSchema = new mongoose.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.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.valueOf();
+                delete ret._id;
+                delete ret.__v;
+            },
+        },
+    });
+    orderSchema.statics.build = (attrs) => {
+        return new Order(attrs);
+    };
+    const Order = mongoose.model("Order", orderSchema);
+    return Order;
+};
+exports.buildOrder = buildOrder;

package/build/models/partner.d.ts

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

package/build/models/partner.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildPartner = void 0;
+const buildPartner = (mongoose) => {
+    // if model is already defined, return it
+    if (mongoose.models.Partner) {
+        return mongoose.model("Partner");
+    }
+    const PartnerSchema = new mongoose.Schema({
+        authId: {
+            type: String,
+            required: true,
+        },
+        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.valueOf();
+                delete ret._id;
+                delete ret.__v;
+                ret.apiKeys.forEach((apiKey) => {
+                    delete apiKey.value;
+                });
+            },
+        },
+    });
+    PartnerSchema.statics.build = (attrs) => {
+        return new Partner(attrs);
+    };
+    const Partner = mongoose.model("Partner", PartnerSchema);
+    return Partner;
+};
+exports.buildPartner = buildPartner;

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

@@ -0,0 +1,12 @@
+import mongoose from "mongoose";
+interface RioSettingsAttrs {
+    platformFee: number;
+}
+interface RioSettingsDoc extends mongoose.Document {
+    platformFee: number;
+}
+interface RioSettingsModel extends mongoose.Model<RioSettingsDoc> {
+    build(attrs: RioSettingsAttrs): RioSettingsDoc;
+}
+declare const buildRioSettings: (mongoose: typeof mongoose) => RioSettingsModel;
+export { buildRioSettings, RioSettingsModel };

package/build/models/rio-settings.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildRioSettings = void 0;
+const buildRioSettings = (mongoose) => {
+    // if model is already defined, return it
+    if (mongoose.models.RioSettings) {
+        return mongoose.model("RioSettings");
+    }
+    const RioSettingsSchema = new mongoose.Schema({
+        platformFee: {
+            type: Number,
+            required: true,
+        },
+    }, {
+        toJSON: {
+            transform(doc, ret) {
+                ret.id = ret._id;
+                delete ret._id;
+                delete ret.__v;
+            },
+        },
+    });
+    RioSettingsSchema.statics.build = (attrs) => {
+        return new RioSettings(attrs);
+    };
+    const RioSettings = mongoose.model("RioSettings", RioSettingsSchema);
+    return RioSettings;
+};
+exports.buildRioSettings = buildRioSettings;

package/build/models/user.d.ts

@@ -0,0 +1,53 @@
+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";
+import { Mongoose, Model, Document } from "mongoose";
+interface UserAttrs {
+    authId: string;
+    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 Model<UserDoc> {
+    build(attrs: UserAttrs): UserDoc;
+}
+interface UserDoc extends Document {
+    _id: string;
+    authId: string;
+    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 buildUser: (mongoose: Mongoose) => UserModel;
+export { buildUser, UserDoc };

package/build/models/user.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildUser = void 0;
+const buildUser = (mongoose) => {
+    // if model is already defined, return it
+    if (mongoose.models.User) {
+        return mongoose.model("User");
+    }
+    const userSchema = new mongoose.Schema({
+        authId: {
+            type: String,
+            required: true,
+        },
+        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.valueOf();
+                delete ret._id;
+                delete ret.__v;
+            },
+        },
+    });
+    userSchema.statics.build = (attrs) => {
+        return new User(attrs);
+    };
+    const User = mongoose.model("User", userSchema);
+    return User;
+};
+exports.buildUser = buildUser;

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>;
+}