@riocrypto/common-server 1.0.506

package/build/errors/admin-only-error.d.ts

@@ -0,0 +1,8 @@
+import { CustomError } from "./custom-error";
+export declare class AdminOnlyError extends CustomError {
+    statusCode: number;
+    constructor();
+    serializeErrors(): {
+        message: string;
+    }[];
+}

package/build/errors/admin-only-error.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdminOnlyError = void 0;
+const custom_error_1 = require("./custom-error");
+class AdminOnlyError extends custom_error_1.CustomError {
+    constructor() {
+        super("This endpoint can only be called by admins");
+        this.statusCode = 401;
+        Object.setPrototypeOf(this, AdminOnlyError.prototype);
+    }
+    serializeErrors() {
+        return [{ message: "This endpoint can only be called by admins" }];
+    }
+}
+exports.AdminOnlyError = AdminOnlyError;

package/build/errors/api-key-not-found-error.d.ts

@@ -0,0 +1,8 @@
+import { CustomError } from "./custom-error";
+export declare class APIKeyNotFoundError extends CustomError {
+    statusCode: number;
+    constructor();
+    serializeErrors(): {
+        message: string;
+    }[];
+}

package/build/errors/api-key-not-found-error.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APIKeyNotFoundError = void 0;
+const custom_error_1 = require("./custom-error");
+class APIKeyNotFoundError extends custom_error_1.CustomError {
+    constructor() {
+        super("API key not found");
+        this.statusCode = 404;
+        Object.setPrototypeOf(this, APIKeyNotFoundError.prototype);
+    }
+    serializeErrors() {
+        return [{ message: "API key not found" }];
+    }
+}
+exports.APIKeyNotFoundError = APIKeyNotFoundError;

package/build/errors/auth-already-exists-error.d.ts

@@ -0,0 +1,8 @@
+import { CustomError } from "./custom-error";
+export declare class AuthAlreadyExistsError extends CustomError {
+    statusCode: number;
+    constructor();
+    serializeErrors(): {
+        message: string;
+    }[];
+}

package/build/errors/auth-already-exists-error.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthAlreadyExistsError = void 0;
+const custom_error_1 = require("./custom-error");
+class AuthAlreadyExistsError extends custom_error_1.CustomError {
+    constructor() {
+        super("Auth with provided phone number already exists");
+        this.statusCode = 409;
+        Object.setPrototypeOf(this, AuthAlreadyExistsError.prototype);
+    }
+    serializeErrors() {
+        return [{ message: "Auth with provided phone number already exists" }];
+    }
+}
+exports.AuthAlreadyExistsError = AuthAlreadyExistsError;

package/build/errors/auth-not-found-error.d.ts

@@ -0,0 +1,8 @@
+import { CustomError } from "./custom-error";
+export declare class AuthNotFoundError extends CustomError {
+    statusCode: number;
+    constructor();
+    serializeErrors(): {
+        message: string;
+    }[];
+}

package/build/errors/auth-not-found-error.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthNotFoundError = void 0;
+const custom_error_1 = require("./custom-error");
+class AuthNotFoundError extends custom_error_1.CustomError {
+    constructor() {
+        super("Auth not found");
+        this.statusCode = 404;
+        Object.setPrototypeOf(this, AuthNotFoundError.prototype);
+    }
+    serializeErrors() {
+        return [{ message: "Auth not found" }];
+    }
+}
+exports.AuthNotFoundError = AuthNotFoundError;

package/build/errors/authorization-failed-error.d.ts

@@ -0,0 +1,8 @@
+import { CustomError } from "./custom-error";
+export declare class AuthorizationFailedError extends CustomError {
+    statusCode: number;
+    constructor();
+    serializeErrors(): {
+        message: string;
+    }[];
+}

package/build/errors/authorization-failed-error.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthorizationFailedError = void 0;
+const custom_error_1 = require("./custom-error");
+class AuthorizationFailedError extends custom_error_1.CustomError {
+    constructor() {
+        super("Wyre authorization codes failed validation");
+        this.statusCode = 400;
+        Object.setPrototypeOf(this, AuthorizationFailedError.prototype);
+    }
+    serializeErrors() {
+        return [{ message: "Authorization failed" }];
+    }
+}
+exports.AuthorizationFailedError = AuthorizationFailedError;

package/build/errors/custom-error.d.ts

@@ -0,0 +1,8 @@
+export declare abstract class CustomError extends Error {
+    abstract statusCode: number;
+    constructor(message: string);
+    abstract serializeErrors(): {
+        message: string;
+        field?: string;
+    }[];
+}

package/build/errors/custom-error.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomError = void 0;
+class CustomError extends Error {
+    constructor(message) {
+        super();
+        Object.setPrototypeOf(this, CustomError.prototype);
+    }
+}
+exports.CustomError = CustomError;

package/build/errors/database-connection-error.d.ts

@@ -0,0 +1,9 @@
+import { CustomError } from "./custom-error";
+export declare class DatabaseConnectionError extends CustomError {
+    statusCode: number;
+    reason: string;
+    constructor();
+    serializeErrors(): {
+        message: string;
+    }[];
+}

package/build/errors/database-connection-error.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabaseConnectionError = void 0;
+const custom_error_1 = require("./custom-error");
+class DatabaseConnectionError extends custom_error_1.CustomError {
+    constructor() {
+        super("Error connecting to database");
+        this.statusCode = 500;
+        this.reason = "Error connecting to database";
+        Object.setPrototypeOf(this, DatabaseConnectionError.prototype);
+    }
+    serializeErrors() {
+        return [{ message: this.reason }];
+    }
+}
+exports.DatabaseConnectionError = DatabaseConnectionError;

package/build/errors/insufficient-liquidity-error.d.ts

@@ -0,0 +1,8 @@
+import { CustomError } from "./custom-error";
+export declare class InsufficientLiquidityError extends CustomError {
+    statusCode: number;
+    constructor();
+    serializeErrors(): {
+        message: string;
+    }[];
+}

package/build/errors/insufficient-liquidity-error.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InsufficientLiquidityError = void 0;
+const custom_error_1 = require("./custom-error");
+class InsufficientLiquidityError extends custom_error_1.CustomError {
+    constructor() {
+        super("Insufficient liquidity to process order");
+        this.statusCode = 400;
+        Object.setPrototypeOf(this, InsufficientLiquidityError.prototype);
+    }
+    serializeErrors() {
+        return [
+            {
+                message: "Insufficient liquidity to process order, please try again later",
+            },
+        ];
+    }
+}
+exports.InsufficientLiquidityError = InsufficientLiquidityError;

package/build/errors/invalid-order-size-error.d.ts

@@ -0,0 +1,8 @@
+import { CustomError } from "./custom-error";
+export declare class InvalidOrderSizeError extends CustomError {
+    statusCode: number;
+    constructor();
+    serializeErrors(): {
+        message: string;
+    }[];
+}

package/build/errors/invalid-order-size-error.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidOrderSizeError = void 0;
+const custom_error_1 = require("./custom-error");
+class InvalidOrderSizeError extends custom_error_1.CustomError {
+    constructor() {
+        super("Invalid order size");
+        this.statusCode = 400;
+        Object.setPrototypeOf(this, InvalidOrderSizeError.prototype);
+    }
+    serializeErrors() {
+        return [{ message: "Invalid order size" }];
+    }
+}
+exports.InvalidOrderSizeError = InvalidOrderSizeError;

package/build/errors/message-failed-error.d.ts

@@ -0,0 +1,8 @@
+import { CustomError } from "./custom-error";
+export declare class MessageFailedError extends CustomError {
+    statusCode: number;
+    constructor();
+    serializeErrors(): {
+        message: string;
+    }[];
+}

package/build/errors/message-failed-error.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageFailedError = void 0;
+const custom_error_1 = require("./custom-error");
+class MessageFailedError extends custom_error_1.CustomError {
+    constructor() {
+        super("Failed to send verification code");
+        this.statusCode = 500;
+        Object.setPrototypeOf(this, MessageFailedError.prototype);
+    }
+    serializeErrors() {
+        return [{ message: "Failed to send verification code" }];
+    }
+}
+exports.MessageFailedError = MessageFailedError;

package/build/errors/missing-kyc-approval-error.d.ts

@@ -0,0 +1,8 @@
+import { CustomError } from "./custom-error";
+export declare class MissingKYCApprovalError extends CustomError {
+    statusCode: number;
+    constructor();
+    serializeErrors(): {
+        message: string;
+    }[];
+}

package/build/errors/missing-kyc-approval-error.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MissingKYCApprovalError = void 0;
+const custom_error_1 = require("./custom-error");
+class MissingKYCApprovalError extends custom_error_1.CustomError {
+    constructor() {
+        super("KYC status is not approved");
+        this.statusCode = 401;
+        Object.setPrototypeOf(this, MissingKYCApprovalError.prototype);
+    }
+    serializeErrors() {
+        return [{ message: "KYC status is not approved" }];
+    }
+}
+exports.MissingKYCApprovalError = MissingKYCApprovalError;

package/build/errors/missing-password-error.d.ts

@@ -0,0 +1,8 @@
+import { CustomError } from "./custom-error";
+export declare class MissingPasswordError extends CustomError {
+    statusCode: number;
+    constructor();
+    serializeErrors(): {
+        message: string;
+    }[];
+}

package/build/errors/missing-password-error.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MissingPasswordError = void 0;
+const custom_error_1 = require("./custom-error");
+class MissingPasswordError extends custom_error_1.CustomError {
+    constructor() {
+        super("Password is not registered");
+        this.statusCode = 401;
+        Object.setPrototypeOf(this, MissingPasswordError.prototype);
+    }
+    serializeErrors() {
+        return [{ message: "Password is not registered" }];
+    }
+}
+exports.MissingPasswordError = MissingPasswordError;

package/build/errors/missing-security-question-error.d.ts

@@ -0,0 +1,8 @@
+import { CustomError } from "./custom-error";
+export declare class MissingSecurityQuestionError extends CustomError {
+    statusCode: number;
+    constructor();
+    serializeErrors(): {
+        message: string;
+    }[];
+}

package/build/errors/missing-security-question-error.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MissingSecurityQuestionError = void 0;
+const custom_error_1 = require("./custom-error");
+class MissingSecurityQuestionError extends custom_error_1.CustomError {
+    constructor() {
+        super("Security question is not registered");
+        this.statusCode = 401;
+        Object.setPrototypeOf(this, MissingSecurityQuestionError.prototype);
+    }
+    serializeErrors() {
+        return [{ message: "Security question is not registered" }];
+    }
+}
+exports.MissingSecurityQuestionError = MissingSecurityQuestionError;

package/build/errors/missing-user-error.d.ts

@@ -0,0 +1,8 @@
+import { CustomError } from "./custom-error";
+export declare class MissingUserError extends CustomError {
+    statusCode: number;
+    constructor();
+    serializeErrors(): {
+        message: string;
+    }[];
+}

package/build/errors/missing-user-error.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MissingUserError = void 0;
+const custom_error_1 = require("./custom-error");
+class MissingUserError extends custom_error_1.CustomError {
+    constructor() {
+        super("Auth is not registered to a user");
+        this.statusCode = 401;
+        Object.setPrototypeOf(this, MissingUserError.prototype);
+    }
+    serializeErrors() {
+        return [{ message: "Auth is not registered to a user" }];
+    }
+}
+exports.MissingUserError = MissingUserError;

package/build/errors/not-authorized-error.d.ts

@@ -0,0 +1,8 @@
+import { CustomError } from "./custom-error";
+export declare class NotAuthorizedError extends CustomError {
+    statusCode: number;
+    constructor();
+    serializeErrors(): {
+        message: string;
+    }[];
+}

package/build/errors/not-authorized-error.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotAuthorizedError = void 0;
+const custom_error_1 = require("./custom-error");
+class NotAuthorizedError extends custom_error_1.CustomError {
+    constructor() {
+        super("Not authorized");
+        this.statusCode = 401;
+        Object.setPrototypeOf(this, NotAuthorizedError.prototype);
+    }
+    serializeErrors() {
+        return [{ message: "Not authorized" }];
+    }
+}
+exports.NotAuthorizedError = NotAuthorizedError;

package/build/errors/not-broker-error.d.ts

@@ -0,0 +1,8 @@
+import { CustomError } from "./custom-error";
+export declare class NotBrokerError extends CustomError {
+    statusCode: number;
+    constructor();
+    serializeErrors(): {
+        message: string;
+    }[];
+}

package/build/errors/not-broker-error.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotBrokerError = void 0;
+const custom_error_1 = require("./custom-error");
+class NotBrokerError extends custom_error_1.CustomError {
+    constructor() {
+        super("To call this endpoint as a user, you must be a broker");
+        this.statusCode = 401;
+        Object.setPrototypeOf(this, NotBrokerError.prototype);
+    }
+    serializeErrors() {
+        return [
+            { message: "To call this endpoint as a user, you must be a broker" },
+        ];
+    }
+}
+exports.NotBrokerError = NotBrokerError;

package/build/errors/not-found-error.d.ts

@@ -0,0 +1,8 @@
+import { CustomError } from "./custom-error";
+export declare class NotFoundError extends CustomError {
+    statusCode: number;
+    constructor();
+    serializeErrors(): {
+        message: string;
+    }[];
+}

package/build/errors/not-found-error.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotFoundError = void 0;
+const custom_error_1 = require("./custom-error");
+class NotFoundError extends custom_error_1.CustomError {
+    constructor() {
+        super("Route not found");
+        this.statusCode = 404;
+        Object.setPrototypeOf(this, NotFoundError.prototype);
+    }
+    serializeErrors() {
+        return [{ message: "Not found" }];
+    }
+}
+exports.NotFoundError = NotFoundError;

package/build/errors/partner-already-exists-error.d.ts

@@ -0,0 +1,8 @@
+import { CustomError } from "./custom-error";
+export declare class PartnerAlreadyExistsError extends CustomError {
+    statusCode: number;
+    constructor();
+    serializeErrors(): {
+        message: string;
+    }[];
+}

package/build/errors/partner-already-exists-error.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PartnerAlreadyExistsError = void 0;
+const custom_error_1 = require("./custom-error");
+class PartnerAlreadyExistsError extends custom_error_1.CustomError {
+    constructor() {
+        super("Partner already exists");
+        this.statusCode = 409;
+        Object.setPrototypeOf(this, PartnerAlreadyExistsError.prototype);
+    }
+    serializeErrors() {
+        return [{ message: "Partner already exists" }];
+    }
+}
+exports.PartnerAlreadyExistsError = PartnerAlreadyExistsError;

package/build/errors/partner-not-found-error.d.ts

@@ -0,0 +1,8 @@
+import { CustomError } from "./custom-error";
+export declare class PartnerNotFoundError extends CustomError {
+    statusCode: number;
+    constructor();
+    serializeErrors(): {
+        message: string;
+    }[];
+}

package/build/errors/partner-not-found-error.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PartnerNotFoundError = void 0;
+const custom_error_1 = require("./custom-error");
+class PartnerNotFoundError extends custom_error_1.CustomError {
+    constructor() {
+        super("Partner not found");
+        this.statusCode = 404;
+        Object.setPrototypeOf(this, PartnerNotFoundError.prototype);
+    }
+    serializeErrors() {
+        return [{ message: "Partner not found" }];
+    }
+}
+exports.PartnerNotFoundError = PartnerNotFoundError;

package/build/errors/password-already-used-error.d.ts

@@ -0,0 +1,8 @@
+import { CustomError } from "./custom-error";
+export declare class PasswordAlreadyUsedError extends CustomError {
+    statusCode: number;
+    constructor();
+    serializeErrors(): {
+        message: string;
+    }[];
+}

package/build/errors/password-already-used-error.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PasswordAlreadyUsedError = void 0;
+const custom_error_1 = require("./custom-error");
+class PasswordAlreadyUsedError extends custom_error_1.CustomError {
+    constructor() {
+        super("Password already used");
+        this.statusCode = 400;
+        Object.setPrototypeOf(this, PasswordAlreadyUsedError.prototype);
+    }
+    serializeErrors() {
+        return [{ message: "Password already used" }];
+    }
+}
+exports.PasswordAlreadyUsedError = PasswordAlreadyUsedError;

package/build/errors/request-validation-error.d.ts

@@ -0,0 +1,11 @@
+import { CustomError } from "./custom-error";
+import { ValidationError } from "express-validator";
+export declare class RequestValidationError extends CustomError {
+    errors: ValidationError[];
+    statusCode: number;
+    constructor(errors: ValidationError[]);
+    serializeErrors(): {
+        message: any;
+        field: string;
+    }[];
+}

package/build/errors/request-validation-error.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestValidationError = void 0;
+const custom_error_1 = require("./custom-error");
+class RequestValidationError extends custom_error_1.CustomError {
+    constructor(errors) {
+        super("Invalid request parameters");
+        this.errors = errors;
+        this.statusCode = 400;
+        Object.setPrototypeOf(this, RequestValidationError.prototype);
+    }
+    serializeErrors() {
+        return this.errors.map((err) => {
+            return { message: err.msg, field: err.param };
+        });
+    }
+}
+exports.RequestValidationError = RequestValidationError;

package/build/errors/rio-settings-already-exists-error.d.ts

@@ -0,0 +1,8 @@
+import { CustomError } from "./custom-error";
+export declare class RioSettingsAlreadyExistsError extends CustomError {
+    statusCode: number;
+    constructor();
+    serializeErrors(): {
+        message: string;
+    }[];
+}

package/build/errors/rio-settings-already-exists-error.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RioSettingsAlreadyExistsError = void 0;
+const custom_error_1 = require("./custom-error");
+class RioSettingsAlreadyExistsError extends custom_error_1.CustomError {
+    constructor() {
+        super("Rio settings already exists");
+        this.statusCode = 409;
+        Object.setPrototypeOf(this, RioSettingsAlreadyExistsError.prototype);
+    }
+    serializeErrors() {
+        return [{ message: "Rio settings already exists" }];
+    }
+}
+exports.RioSettingsAlreadyExistsError = RioSettingsAlreadyExistsError;

package/build/errors/rio-settings-not-found-error.d.ts

@@ -0,0 +1,8 @@
+import { CustomError } from "./custom-error";
+export declare class RioSettingsNotFoundError extends CustomError {
+    statusCode: number;
+    constructor();
+    serializeErrors(): {
+        message: string;
+    }[];
+}

package/build/errors/rio-settings-not-found-error.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RioSettingsNotFoundError = void 0;
+const custom_error_1 = require("./custom-error");
+class RioSettingsNotFoundError extends custom_error_1.CustomError {
+    constructor() {
+        super("Rio settings not found");
+        this.statusCode = 404;
+        Object.setPrototypeOf(this, RioSettingsNotFoundError.prototype);
+    }
+    serializeErrors() {
+        return [{ message: "Missing internal Rio settings" }];
+    }
+}
+exports.RioSettingsNotFoundError = RioSettingsNotFoundError;

package/build/errors/user-already-exists-error.d.ts

@@ -0,0 +1,8 @@
+import { CustomError } from "./custom-error";
+export declare class UserAlreadyExistsError extends CustomError {
+    statusCode: number;
+    constructor();
+    serializeErrors(): {
+        message: string;
+    }[];
+}

package/build/errors/user-already-exists-error.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserAlreadyExistsError = void 0;
+const custom_error_1 = require("./custom-error");
+class UserAlreadyExistsError extends custom_error_1.CustomError {
+    constructor() {
+        super("User already exists");
+        this.statusCode = 409;
+        Object.setPrototypeOf(this, UserAlreadyExistsError.prototype);
+    }
+    serializeErrors() {
+        return [{ message: "User already exists" }];
+    }
+}
+exports.UserAlreadyExistsError = UserAlreadyExistsError;