@riocrypto/common-server 1.0.1603 → 1.0.1605

package/build/common/src/errors/address-check-failed-error.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AddressCheckFailed = void 0;
+const custom_error_1 = require("./custom-error");
+class AddressCheckFailed extends custom_error_1.CustomError {
+    constructor() {
+        super("Address check failed");
+        this.statusCode = 400;
+        this.internalCode = 2;
+        Object.setPrototypeOf(this, AddressCheckFailed.prototype);
+    }
+    serializeErrors() {
+        return [{ code: this.internalCode, message: "Address check failed" }];
+    }
+}
+exports.AddressCheckFailed = AddressCheckFailed;

package/build/common/src/errors/admin-already-exists-error.d.ts

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

package/build/common/src/errors/admin-already-exists-error.js

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

package/build/common/src/errors/admin-not-found-error.d.ts

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

package/build/common/src/errors/admin-not-found-error.js

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

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

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

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

@@ -0,0 +1,21 @@
+"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;
+        this.internalCode = 5;
+        Object.setPrototypeOf(this, AdminOnlyError.prototype);
+    }
+    serializeErrors() {
+        return [
+            {
+                code: this.internalCode,
+                message: "This endpoint can only be called by admins",
+            },
+        ];
+    }
+}
+exports.AdminOnlyError = AdminOnlyError;

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

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

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

@@ -0,0 +1,16 @@
+"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;
+        this.internalCode = 6;
+        Object.setPrototypeOf(this, APIKeyNotFoundError.prototype);
+    }
+    serializeErrors() {
+        return [{ code: this.internalCode, message: "API key not found" }];
+    }
+}
+exports.APIKeyNotFoundError = APIKeyNotFoundError;

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

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

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

@@ -0,0 +1,21 @@
+"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;
+        this.internalCode = 7;
+        Object.setPrototypeOf(this, AuthAlreadyExistsError.prototype);
+    }
+    serializeErrors() {
+        return [
+            {
+                code: this.internalCode,
+                message: "Auth with provided phone number already exists",
+            },
+        ];
+    }
+}
+exports.AuthAlreadyExistsError = AuthAlreadyExistsError;

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

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

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

@@ -0,0 +1,16 @@
+"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;
+        this.internalCode = 8;
+        Object.setPrototypeOf(this, AuthNotFoundError.prototype);
+    }
+    serializeErrors() {
+        return [{ code: this.internalCode, message: "Auth not found" }];
+    }
+}
+exports.AuthNotFoundError = AuthNotFoundError;

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

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

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

@@ -0,0 +1,16 @@
+"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;
+        this.internalCode = 9;
+        Object.setPrototypeOf(this, AuthorizationFailedError.prototype);
+    }
+    serializeErrors() {
+        return [{ code: this.internalCode, message: "Authorization failed" }];
+    }
+}
+exports.AuthorizationFailedError = AuthorizationFailedError;

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

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

package/build/common/src/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/common/src/errors/database-connection-error.d.ts

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

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

@@ -0,0 +1,17 @@
+"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.internalCode = 10;
+        this.reason = "Error connecting to database";
+        Object.setPrototypeOf(this, DatabaseConnectionError.prototype);
+    }
+    serializeErrors() {
+        return [{ code: this.internalCode, message: this.reason }];
+    }
+}
+exports.DatabaseConnectionError = DatabaseConnectionError;

package/build/common/src/errors/expired-quote-error.d.ts

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

package/build/common/src/errors/expired-quote-error.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExpiredQuoteError = void 0;
+const custom_error_1 = require("./custom-error");
+class ExpiredQuoteError extends custom_error_1.CustomError {
+    constructor() {
+        super("Quote has expired");
+        this.statusCode = 422;
+        this.internalCode = 41;
+        Object.setPrototypeOf(this, ExpiredQuoteError.prototype);
+    }
+    serializeErrors() {
+        return [{ code: this.internalCode, message: "Quote has expired" }];
+    }
+}
+exports.ExpiredQuoteError = ExpiredQuoteError;

package/build/common/src/errors/generic-input-error.d.ts

@@ -0,0 +1,11 @@
+import { CustomError } from "./custom-error";
+export declare class GenericInputError extends CustomError {
+    private customMessage?;
+    statusCode: number;
+    internalCode: number;
+    constructor(customMessage?: string | undefined);
+    serializeErrors(): {
+        code: number;
+        message: string;
+    }[];
+}

package/build/common/src/errors/generic-input-error.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenericInputError = void 0;
+const custom_error_1 = require("./custom-error");
+class GenericInputError extends custom_error_1.CustomError {
+    constructor(customMessage) {
+        super(customMessage || "Unknown input error");
+        this.customMessage = customMessage;
+        this.statusCode = 400;
+        this.internalCode = 39;
+        Object.setPrototypeOf(this, GenericInputError.prototype);
+    }
+    serializeErrors() {
+        return [
+            {
+                code: this.internalCode,
+                message: this.customMessage || "Unknown input error",
+            },
+        ];
+    }
+}
+exports.GenericInputError = GenericInputError;

package/build/common/src/errors/generic-internal-error.d.ts

@@ -0,0 +1,11 @@
+import { CustomError } from "./custom-error";
+export declare class GenericInternalError extends CustomError {
+    private customMessage?;
+    statusCode: number;
+    internalCode: number;
+    constructor(customMessage?: string | undefined);
+    serializeErrors(): {
+        code: number;
+        message: string;
+    }[];
+}

package/build/common/src/errors/generic-internal-error.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenericInternalError = void 0;
+const custom_error_1 = require("./custom-error");
+class GenericInternalError extends custom_error_1.CustomError {
+    constructor(customMessage) {
+        super(customMessage || "Unknown internal error");
+        this.customMessage = customMessage;
+        this.statusCode = 500;
+        this.internalCode = 40;
+        Object.setPrototypeOf(this, GenericInternalError.prototype);
+    }
+    serializeErrors() {
+        return [
+            {
+                code: this.internalCode,
+                message: this.customMessage || "Unknown internal error",
+            },
+        ];
+    }
+}
+exports.GenericInternalError = GenericInternalError;

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

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

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

@@ -0,0 +1,21 @@
+"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;
+        this.internalCode = 11;
+        Object.setPrototypeOf(this, InsufficientLiquidityError.prototype);
+    }
+    serializeErrors() {
+        return [
+            {
+                code: this.internalCode,
+                message: "Insufficient liquidity to process order, please try again later",
+            },
+        ];
+    }
+}
+exports.InsufficientLiquidityError = InsufficientLiquidityError;

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

@@ -0,0 +1,15 @@
+import { Fiat } from "../types/fiat";
+import { CustomError } from "./custom-error";
+export declare class InvalidOrderSizeError extends CustomError {
+    private minAmount;
+    private minAmountFiat;
+    statusCode: number;
+    internalCode: number;
+    constructor(minAmount: number, minAmountFiat: Fiat);
+    serializeErrors(): {
+        code: number;
+        message: string;
+        minAmount: number;
+        minAmountFiat: Fiat;
+    }[];
+}

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

@@ -0,0 +1,25 @@
+"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(minAmount, minAmountFiat) {
+        super("Invalid order size");
+        this.minAmount = minAmount;
+        this.minAmountFiat = minAmountFiat;
+        this.statusCode = 400;
+        this.internalCode = 12;
+        Object.setPrototypeOf(this, InvalidOrderSizeError.prototype);
+    }
+    serializeErrors() {
+        return [
+            {
+                code: this.internalCode,
+                message: "Invalid order size",
+                minAmount: this.minAmount,
+                minAmountFiat: this.minAmountFiat,
+            },
+        ];
+    }
+}
+exports.InvalidOrderSizeError = InvalidOrderSizeError;

package/build/common/src/errors/invalid-refresh-token-error.d.ts

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

package/build/common/src/errors/invalid-refresh-token-error.js

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

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

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

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

@@ -0,0 +1,18 @@
+"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;
+        this.internalCode = 13;
+        Object.setPrototypeOf(this, MessageFailedError.prototype);
+    }
+    serializeErrors() {
+        return [
+            { code: this.internalCode, message: "Failed to send verification code" },
+        ];
+    }
+}
+exports.MessageFailedError = MessageFailedError;

package/build/common/src/errors/missing-cpf-error.d.ts

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

package/build/common/src/errors/missing-cpf-error.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MissingCPFError = void 0;
+const custom_error_1 = require("./custom-error");
+class MissingCPFError extends custom_error_1.CustomError {
+    constructor() {
+        super("User is missing CPF");
+        this.statusCode = 401;
+        this.internalCode = 14;
+        Object.setPrototypeOf(this, MissingCPFError.prototype);
+    }
+    serializeErrors() {
+        return [{ code: this.internalCode, message: "User is missing CPF" }];
+    }
+}
+exports.MissingCPFError = MissingCPFError;

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

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

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

@@ -0,0 +1,21 @@
+"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 for this user");
+        this.statusCode = 401;
+        this.internalCode = 15;
+        Object.setPrototypeOf(this, MissingKYCApprovalError.prototype);
+    }
+    serializeErrors() {
+        return [
+            {
+                code: this.internalCode,
+                message: "KYC status is not approved is not approved for this user",
+            },
+        ];
+    }
+}
+exports.MissingKYCApprovalError = MissingKYCApprovalError;

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

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

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

@@ -0,0 +1,16 @@
+"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;
+        this.internalCode = 16;
+        Object.setPrototypeOf(this, MissingPasswordError.prototype);
+    }
+    serializeErrors() {
+        return [{ code: this.internalCode, message: "Password is not registered" }];
+    }
+}
+exports.MissingPasswordError = MissingPasswordError;

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

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