wapi-client 0.7.2 → 0.8.1

package/dist/index.js

@@ -0,0 +1,60 @@
+// src/index.ts
+import {
+  Client,
+  createClientWithHttp,
+  createClientWithWS
+} from "./client";
+import {
+  ERROR_MESSAGES as ErrorMessage,
+  ERROR_TYPES as Errors
+} from "./lib/errors";
+import { QueryBuilder } from "./lib/query-builder";
+import { StreamPromise } from "./lib/stream-promise";
+import { getIdentifier } from "./lib/utils";
+import { SchemaNames, Validator } from "./lib/validator";
+export * from "./db";
+export * from "./fns";
+export * from "./txs";
+var validate = Validator.getValidator(SchemaNames.ClientOptions);
+var WapiClientType = /* @__PURE__ */ ((WapiClientType2) => {
+  WapiClientType2["ws"] = "ws";
+  WapiClientType2["https"] = "https";
+  return WapiClientType2;
+})(WapiClientType || {});
+function create(options) {
+  const config = options.config;
+  const { inputCopy, error } = validate(options);
+  if (error) {
+    throw error;
+  }
+  if (inputCopy.client === "ws" /* ws */) {
+    return createClientWithWS(
+      inputCopy.connection,
+      config
+    );
+  }
+  if (inputCopy.client === "https" /* https */) {
+    return createClientWithHttp(
+      inputCopy.connection,
+      config
+    );
+  }
+  throw new TypeError("Invalid client type");
+}
+var utils = {
+  /**
+   * Return a uuidv4
+   */
+  getIdentifier
+};
+export {
+  Client,
+  ErrorMessage,
+  Errors,
+  QueryBuilder,
+  StreamPromise,
+  Validator,
+  WapiClientType,
+  create,
+  utils
+};

package/dist/interfaces.d.browser.cjs

@@ -0,0 +1,17 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/interfaces.d.ts
+var interfaces_d_exports = {};
+module.exports = __toCommonJS(interfaces_d_exports);

package/dist/lib/debug.browser.cjs

@@ -0,0 +1,29 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/debug.ts
+var debug_exports = {};
+__export(debug_exports, {
+  debugLog: () => debugLog
+});
+module.exports = __toCommonJS(debug_exports);
+function debugLog(...args) {
+  if (window.WAPI_DEBUG) {
+    console.log(...args);
+  }
+}

package/dist/lib/debug.browser.js

@@ -0,0 +1,9 @@
+// src/lib/debug.ts
+function debugLog(...args) {
+  if (window.WAPI_DEBUG) {
+    console.log(...args);
+  }
+}
+export {
+  debugLog
+};

package/dist/lib/debug.cjs

@@ -0,0 +1,33 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/debug.ts
+var debug_exports = {};
+__export(debug_exports, {
+  debugLog: () => debugLog
+});
+module.exports = __toCommonJS(debug_exports);
+function debugLog(...args) {
+  if (process.env.WAPI_DEBUG) {
+    console.log(...args);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  debugLog
+});

package/dist/lib/debug.js

@@ -0,0 +1,9 @@
+// src/lib/debug.ts
+function debugLog(...args) {
+  if (process.env.WAPI_DEBUG) {
+    console.log(...args);
+  }
+}
+export {
+  debugLog
+};

package/dist/lib/errors.browser.cjs

@@ -0,0 +1,298 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/errors.ts
+var errors_exports = {};
+__export(errors_exports, {
+  AuthenticationError: () => AuthenticationError,
+  ConnectionError: () => ConnectionError,
+  ConstraintError: () => ConstraintError,
+  CoreError: () => CoreError,
+  DatabaseError: () => DatabaseError,
+  ERROR_MESSAGES: () => ERROR_MESSAGES,
+  ERROR_TYPES: () => ERROR_TYPES,
+  ErrorDescriptions: () => ErrorDescriptions,
+  InputError: () => InputError,
+  StreamError: () => StreamError,
+  UnknownError: () => UnknownError,
+  ValidationError: () => ValidationError,
+  getError: () => getError
+});
+module.exports = __toCommonJS(errors_exports);
+var CoreError = class extends Error {
+  constructor({ code, message, data, description }) {
+    var _a;
+    super(message);
+    this.code = code;
+    this.message = message;
+    this.data = data;
+    this.description = (_a = description != null ? description : ErrorDescriptions[message]) != null ? _a : "";
+  }
+  toJSON() {
+    return {
+      code: this.code,
+      message: this.message,
+      description: this.description,
+      data: this.data
+    };
+  }
+};
+var DatabaseError = class extends CoreError {
+  constructor({ message, data, code }) {
+    super({
+      message,
+      data,
+      code: code || "DatabaseError" /* DatabaseError */
+    });
+  }
+};
+var ValidationError = class extends CoreError {
+  constructor({ message, data, code }) {
+    super({
+      message,
+      data,
+      code: code || "SchemaValidationError" /* SchemaValidationError */
+    });
+  }
+};
+var InputError = class extends CoreError {
+  constructor({ message, data, code }) {
+    super({
+      message,
+      data,
+      code: code || "InputError" /* InputError */
+    });
+  }
+};
+var ConstraintError = class extends CoreError {
+  constructor({ message, data, code }) {
+    super({
+      message,
+      data,
+      code: code || "ConstraintError" /* ConstraintError */
+    });
+  }
+};
+var UnknownError = class extends CoreError {
+  constructor({ message, data, code }) {
+    super({
+      message,
+      data,
+      code: code || "UnknownError" /* UnknownError */
+    });
+  }
+};
+var ConnectionError = class extends CoreError {
+  constructor({ message, data, code }) {
+    super({
+      message,
+      data,
+      code: code || "ConnectionError" /* ConnectionError */
+    });
+  }
+};
+var StreamError = class extends CoreError {
+  constructor({ message, data, code }) {
+    super({
+      message,
+      data,
+      code: code || "StreamError" /* StreamError */
+    });
+  }
+};
+var AuthenticationError = class extends CoreError {
+  constructor({ message, data, code }) {
+    super({
+      message,
+      data,
+      code: code || "AuthenticationError" /* AuthenticationError */
+    });
+  }
+};
+function getError({ message, data, code }) {
+  switch (code) {
+    case "SchemaValidationError" /* SchemaValidationError */:
+      return new ValidationError({ message, data, code });
+    case "DatabaseError" /* DatabaseError */:
+      return new DatabaseError({ message, data, code });
+    case "InputError" /* InputError */:
+      return new InputError({ message, data, code });
+    case "ConstraintError" /* ConstraintError */:
+      return new ConstraintError({ message, data, code });
+    case "ConnectionError" /* ConnectionError */:
+      return new ConnectionError({ message, data, code });
+    case "StreamError" /* StreamError */:
+      return new StreamError({ message, data, code });
+    case "AuthenticationError" /* AuthenticationError */:
+      return new AuthenticationError({ message, data, code });
+    default:
+      return new UnknownError({ message, data, code });
+  }
+}
+var ERROR_TYPES = /* @__PURE__ */ ((ERROR_TYPES2) => {
+  ERROR_TYPES2["SchemaValidationError"] = "SchemaValidationError";
+  ERROR_TYPES2["DatabaseError"] = "DatabaseError";
+  ERROR_TYPES2["InputError"] = "InputError";
+  ERROR_TYPES2["UnknownError"] = "UnknownError";
+  ERROR_TYPES2["ConstraintError"] = "ConstraintError";
+  ERROR_TYPES2["ConnectionError"] = "ConnectionError";
+  ERROR_TYPES2["StreamError"] = "StreamError";
+  ERROR_TYPES2["AuthenticationError"] = "AuthenticationError";
+  return ERROR_TYPES2;
+})(ERROR_TYPES || {});
+var ERROR_MESSAGES = /* @__PURE__ */ ((ERROR_MESSAGES2) => {
+  ERROR_MESSAGES2["AUTHENTICATION_FAILED"] = "AUTHENTICATION_FAILED";
+  ERROR_MESSAGES2["BAL_FUTURE_DATETIME"] = "BAL_FUTURE_DATETIME";
+  ERROR_MESSAGES2["CONFLICTING_OPTIONS"] = "CONFLICTING_OPTIONS";
+  ERROR_MESSAGES2["CONTRACT_OWNER_NOT_FOUND"] = "CONTRACT_OWNER_NOT_FOUND";
+  ERROR_MESSAGES2["DATABASE_ERROR"] = "DATABASE_ERROR";
+  ERROR_MESSAGES2["DISTRIBUTION_MISSING_TARGETS"] = "DISTRIBUTION_MISSING_TARGETS";
+  ERROR_MESSAGES2["EXCHANGE_MISSING_TARGETS"] = "EXCHANGE_MISSING_TARGETS";
+  ERROR_MESSAGES2["IMPORT_MISSING_CONTRACT_TOKEN"] = "IMPORT_MISSING_CONTRACT_TOKEN";
+  ERROR_MESSAGES2["IMPORT_MISSING_TOKEN_WALLET"] = "IMPORT_MISSING_TOKEN_WALLET";
+  ERROR_MESSAGES2["IMPORT_OBJECT_DUPLICATE"] = "IMPORT_OBJECT_DUPLICATE";
+  ERROR_MESSAGES2["IMPORT_OBJECT_EXISTS"] = "IMPORT_OBJECT_EXISTS";
+  ERROR_MESSAGES2["IMPORT_PREDATED_TRANSFER"] = "IMPORT_PREDATED_TRANSFER";
+  ERROR_MESSAGES2["IMPORT_USE_BEFORE_CREATE"] = "IMPORT_USE_BEFORE_CREATE";
+  ERROR_MESSAGES2["INPUT_NEEDS_IDENTIFIER"] = "INPUT_NEEDS_IDENTIFIER";
+  ERROR_MESSAGES2["INPUT_NEEDS_TOKEN"] = "INPUT_NEEDS_TOKEN";
+  ERROR_MESSAGES2["INPUT_STREAM_ERROR"] = "INPUT_STREAM_ERROR";
+  ERROR_MESSAGES2["INPUT_STREAM_TIMEOUT"] = "INPUT_STREAM_TIMEOUT";
+  ERROR_MESSAGES2["INPUT_STREAM_INVALID"] = "INPUT_STREAM_INVALID";
+  ERROR_MESSAGES2["INPUT_STREAM_NOT_ALLOWED"] = "INPUT_STREAM_NOT_ALLOWED";
+  ERROR_MESSAGES2["INPUT_INVALID"] = "INPUT_INVALID";
+  ERROR_MESSAGES2["INVALID_COMPLEX_FILTER"] = "INVALID_COMPLEX_FILTER";
+  ERROR_MESSAGES2["INVALID_FIELD_AGR_COMB"] = "INVALID_FIELD_AGR_COMB";
+  ERROR_MESSAGES2["INVALID_FIELD_FOR_MODEL"] = "INVALID_FIELD_FOR_MODEL";
+  ERROR_MESSAGES2["INVALID_LATEST_HASH"] = "INVALID_LATEST_HASH";
+  ERROR_MESSAGES2["INVALID_MODEL"] = "INVALID_MODEL";
+  ERROR_MESSAGES2["NO_METADATA_ON_MODEL"] = "NO_METADATA_ON_MODEL";
+  ERROR_MESSAGES2["RUNNING_BALANCE_WITHOUT_WALLET"] = "RUNNING_BALANCE_WITHOUT_WALLET";
+  ERROR_MESSAGES2["SIGNED_AMOUNT_WITHOUT_WALLET"] = "SIGNED_AMOUNT_WITHOUT_WALLET";
+  ERROR_MESSAGES2["TOKEN_INVALID_WALLET"] = "TOKEN_INVALID_WALLET";
+  ERROR_MESSAGES2["TOKEN_LIMIT_REACHED"] = "TOKEN_LIMIT_REACHED";
+  ERROR_MESSAGES2["TR_AMOUNT_NOT_DIVISIBLE"] = "TR_AMOUNT_NOT_DIVISIBLE";
+  ERROR_MESSAGES2["TR_CANCELLED_CANT_RV"] = "TR_CANCELLED_CANT_RV";
+  ERROR_MESSAGES2["TR_CANT_UPDATE_TO_PENDING"] = "TR_CANT_UPDATE_TO_PENDING";
+  ERROR_MESSAGES2["TR_DEPOSIT_CANT_RV_WITHOUT_FLAG"] = "TR_DEPOSIT_CANT_RV_WITHOUT_FLAG";
+  ERROR_MESSAGES2["TR_FROM_WALLET_DEPOSIT"] = "TR_FROM_WALLET_DEPOSIT";
+  ERROR_MESSAGES2["TR_FROM_WALLET_STATUS_CONSTRAINT"] = "TR_FROM_WALLET_STATUS_CONSTRAINT";
+  ERROR_MESSAGES2["TR_INVALID_BALANCE"] = "TR_INVALID_BALANCE";
+  ERROR_MESSAGES2["TR_INVALID_CANCELLED"] = "TR_INVALID_CANCELLED";
+  ERROR_MESSAGES2["TR_TIMESTAMP_IN_PAST"] = "TR_TIMESTAMP_IN_PAST";
+  ERROR_MESSAGES2["TR_TO_WALLET_STATUS_CONSTRAINT"] = "TR_TO_WALLET_STATUS_CONSTRAINT";
+  ERROR_MESSAGES2["TR_TO_WALLET_WITHDRAWAL"] = "TR_TO_WALLET_WITHDRAWAL";
+  ERROR_MESSAGES2["TR_TOKEN_DISABLED"] = "TR_TOKEN_DISABLED";
+  ERROR_MESSAGES2["TR_TOKEN_DWONLY"] = "TR_TOKEN_DWONLY";
+  ERROR_MESSAGES2["TR_TRG_CLOSED"] = "TR_TRG_CLOSED";
+  ERROR_MESSAGES2["TR_TRG_STATUS_MISMATCH"] = "TR_TRG_STATUS_MISMATCH";
+  ERROR_MESSAGES2["TR_WITHDRAWAL_CANT_RV_WITHOUT_FLAG"] = "TR_WITHDRAWAL_CANT_RV_WITHOUT_FLAG";
+  ERROR_MESSAGES2["TRANSACTION_NOT_FOUND"] = "TRANSACTION_NOT_FOUND";
+  ERROR_MESSAGES2["TRANSACTION_TIMEOUT"] = "TRANSACTION_TIMEOUT";
+  ERROR_MESSAGES2["TRG_BALANCE_CHECK_REQUIRED_WITHOUT_STATUS_LOCK"] = "TRG_BALANCE_CHECK_REQUIRED_WITHOUT_STATUS_LOCK";
+  ERROR_MESSAGES2["TRG_CANCELLED_CANT_RV"] = "TRG_CANCELLED_CANT_RV";
+  ERROR_MESSAGES2["TRG_DEPOSIT_CANT_RV_WITHOUT_FLAG"] = "TRG_DEPOSIT_CANT_RV_WITHOUT_FLAG";
+  ERROR_MESSAGES2["TRG_SINGLE_PENDING_TR_CANT_RV"] = "TRG_SINGLE_PENDING_TR_CANT_RV";
+  ERROR_MESSAGES2["TRG_WITHDRAWAL_CANT_RV_WITHOUT_FLAG"] = "TRG_WITHDRAWAL_CANT_RV_WITHOUT_FLAG";
+  ERROR_MESSAGES2["UNCLEAR_AGGREGATOR"] = "UNCLEAR_AGGREGATOR";
+  ERROR_MESSAGES2["TR_MISSING_FILTER"] = "TR_MISSING_FILTER";
+  ERROR_MESSAGES2["TRG_MISSING_FILTER"] = "TRG_MISSING_FILTER";
+  ERROR_MESSAGES2["HTTP_BODY_SIZE"] = "HTTP_BODY_SIZE";
+  ERROR_MESSAGES2["METHOD_DISABLED"] = "METHOD_DISABLED";
+  ERROR_MESSAGES2["DATABASE_IMPORT_UNEXPECTED_ERROR"] = "DATABASE_IMPORT_UNEXPECTED_ERROR";
+  ERROR_MESSAGES2["DATABASE_IMPORT_NOT_FOUND"] = "DATABASE_IMPORT_NOT_FOUND";
+  ERROR_MESSAGES2["DATABASE_EXPORT_CONFLICT"] = "DATABASE_EXPORT_CONFLICT";
+  ERROR_MESSAGES2["DATABASE_IMPORT_CONFLICT"] = "DATABASE_IMPORT_CONFLICT";
+  ERROR_MESSAGES2["DATABASE_EXPORT_UNEXPECTED_ERROR"] = "DATABASE_EXPORT_UNEXPECTED_ERROR";
+  ERROR_MESSAGES2["DATABASE_EXPORT_LIST_UNEXPECTED_ERROR"] = "DATABASE_EXPORT_LIST_UNEXPECTED_ERROR";
+  ERROR_MESSAGES2["DATABASE_IMPORT_PROGRESS_NOT_FOUND"] = "DATABASE_IMPORT_PROGRESS_NOT_FOUND";
+  ERROR_MESSAGES2["DATABASE_IMPORT_PROGRESS_UNEXPECTED_ERROR"] = "DATABASE_IMPORT_PROGRESS_UNEXPECTED_ERROR";
+  ERROR_MESSAGES2["DATABASE_EXPORT_PROGRESS_NOT_FOUND"] = "DATABASE_EXPORT_PROGRESS_NOT_FOUND";
+  ERROR_MESSAGES2["DATABASE_EXPORT_PROGRESS_UNEXPECTED_ERROR"] = "DATABASE_EXPORT_PROGRESS_UNEXPECTED_ERROR";
+  return ERROR_MESSAGES2;
+})(ERROR_MESSAGES || {});
+var ErrorDescriptions = {
+  AUTHENTICATION_FAILED: `Provided credentials are invalid`,
+  BAL_FUTURE_DATETIME: `Balance datetime can't be in the future`,
+  CONFLICTING_OPTIONS: `return_running_balance and return_running_balance_for can't be specified together`,
+  CONTRACT_OWNER_NOT_FOUND: `Unable to find Wallet specified as Contract token owner`,
+  DATABASE_ERROR: `Something went wrong in the DB layer`,
+  DISTRIBUTION_MISSING_TARGETS: `Unable to resolve all targets (Wallets, Tokens) for distribution request`,
+  EXCHANGE_MISSING_TARGETS: `Unable to resolve all targets (Wallets, Token) for exchange request`,
+  IMPORT_MISSING_CONTRACT_TOKEN: `The import contract specifies Token that does not exist`,
+  IMPORT_MISSING_TOKEN_WALLET: `The import results in invalid Token without valid Wallet`,
+  IMPORT_OBJECT_DUPLICATE: `The import includes create directives for same object multiple times`,
+  IMPORT_OBJECT_EXISTS: `The import includes create directives for already existing objects`,
+  IMPORT_PREDATED_TRANSFER: `The oldest Transfer in the import file is older than already existing Transfers in the WAPI instance`,
+  IMPORT_USE_BEFORE_CREATE: `The import includes create directive for object that is used in Transfer before create dateTime`,
+  INPUT_NEEDS_IDENTIFIER: `Missing identifier - automatically calculated identifiers conflict on identical input for 30s To make an identical transfer during that window you need to provide a unique identifier`,
+  INPUT_NEEDS_TOKEN: `token must be specified on input or in client config`,
+  INPUT_STREAM_ERROR: `Input stream emitted an error`,
+  INPUT_STREAM_TIMEOUT: `No data provided to input stream in 30s`,
+  INPUT_STREAM_INVALID: `Invalid input stream identifier provided`,
+  INPUT_STREAM_NOT_ALLOWED: `Method does not support input stream`,
+  INPUT_INVALID: `Invalid input on stream`,
+  INVALID_COMPLEX_FILTER: `The provided complex filter does not pass validation`,
+  INVALID_FIELD_AGR_COMB: `Provided aggregation field was not found on Model`,
+  INVALID_FIELD_FOR_MODEL: `Provided groupBy field was not found on Model`,
+  INVALID_LATEST_HASH: `Provided latest_control_hash does not match the latest outgoing Transfer from Wallet`,
+  INVALID_MODEL: `Provided Model name is invalid`,
+  NO_METADATA_ON_MODEL: `Can't use metadata field for grouping as current Model does not have metadata`,
+  RUNNING_BALANCE_WITHOUT_WALLET: `return_running_balance option requires Wallet filter to be specified`,
+  SIGNED_AMOUNT_WITHOUT_WALLET: `return_signed_balance option requires Wallet filter to be specified`,
+  TOKEN_INVALID_WALLET: `Invalid belongs_to wallet provided`,
+  TOKEN_LIMIT_REACHED: `Unable to issue more tokens as Token.limit has been reached`,
+  TR_AMOUNT_NOT_DIVISIBLE: `Transfer amount is not divisible by specified Token.divisor`,
+  TR_CANCELLED_CANT_RV: `Cancelled Transfer can not be reversed`,
+  TR_CANT_UPDATE_TO_PENDING: `Transfer status can only move from 'pending'->'finished'/'cancelled`,
+  TR_DEPOSIT_CANT_RV_WITHOUT_FLAG: `Deposits are expected connection points with outside systems, thus extra validation is required. Reversing a Transfer.type = 'deposit' requires reverse_deposit option to be true.`,
+  TR_FROM_WALLET_DEPOSIT: `From wallet can't be specified when doing a deposit`,
+  TR_FROM_WALLET_STATUS_CONSTRAINT: `From wallet.status doesn't allow this type of transfers`,
+  TR_INVALID_BALANCE: `Transfer results in invalid balance for a Wallet`,
+  TR_INVALID_CANCELLED: `Cant create cancelled transfer`,
+  TR_TIMESTAMP_IN_PAST: `Transfer.created_at must be the latest`,
+  TR_TO_WALLET_STATUS_CONSTRAINT: `To wallet.status doesn't allow this type of transfers`,
+  TR_TO_WALLET_WITHDRAWAL: `To wallet can't be specified when doing a withdrawal`,
+  TR_TOKEN_DISABLED: `Token status is set to 'disabled' - no new transfers allowed`,
+  TR_TOKEN_DWONLY: `Token status is set to 'dw-only' - only deposits or withdrawals allowed`,
+  TR_TRG_CLOSED: `Cant add Transfer to group. TransferGroup is closed`,
+  TR_TRG_STATUS_MISMATCH: `Transfers in transfer_group must match transfer_group.transfer_status`,
+  TR_WITHDRAWAL_CANT_RV_WITHOUT_FLAG: `Withdrawals are expected connection points with outside systems, thus extra validation is required. Reversing a Transfer.type = 'withdrawal' requires reverse_withdrawal option to be true.`,
+  TRANSACTION_NOT_FOUND: `No open DB transaction with provided was found`,
+  TRANSACTION_TIMEOUT: `Transaction timed out`,
+  TRG_BALANCE_CHECK_REQUIRED_WITHOUT_STATUS_LOCK: `For integrity reasons running balance validations are required if TransferGroup.transfer_status_lock = false`,
+  TRG_CANCELLED_CANT_RV: `Cancelled TransferGroup can not be reversed`,
+  TRG_DEPOSIT_CANT_RV_WITHOUT_FLAG: `TransferGroup includes Transfer.type = 'deposit', thus for extra validation the reverse_deposit option must be set true`,
+  TRG_SINGLE_PENDING_TR_CANT_RV: `Transfer is part of TransferGroup and can not be reversed separately`,
+  TRG_WITHDRAWAL_CANT_RV_WITHOUT_FLAG: `TransferGroup includes Transfer.type = 'withdrawal', thus for extra validation the reverse_withdrawal option must be set true`,
+  UNCLEAR_AGGREGATOR: `Invalid aggregator function provided`,
+  TR_MISSING_FILTER: `Transactions can't reversed or updated without valid filter`,
+  TRG_MISSING_FILTER: `Transaction groups can't reversed or updated without valid filter`,
+  HTTP_BODY_SIZE: `Http body size can't be more than 100MB`,
+  METHOD_DISABLED: `Method is disabled`,
+  DATABASE_IMPORT_UNEXPECTED_ERROR: `Unexpected error while importing database`,
+  DATABASE_IMPORT_NOT_FOUND: `Database import file not found`,
+  DATABASE_EXPORT_CONFLICT: `Database export already in progress`,
+  DATABASE_IMPORT_CONFLICT: `Database import already in progress`,
+  DATABASE_EXPORT_UNEXPECTED_ERROR: `Unexpected error while creating database export`,
+  DATABASE_EXPORT_LIST_UNEXPECTED_ERROR: `Unexpected error while listing database backups`,
+  DATABASE_IMPORT_PROGRESS_NOT_FOUND: `Import database progress not found`,
+  DATABASE_IMPORT_PROGRESS_UNEXPECTED_ERROR: `Unexpected error while getting database import progress`,
+  DATABASE_EXPORT_PROGRESS_NOT_FOUND: `Database backup progress not found`,
+  DATABASE_EXPORT_PROGRESS_UNEXPECTED_ERROR: `Unexpected error while getting database backup progress`
+};