wapi-client 0.8.13 → 0.9.0

package/dist/lib/errors.js

@@ -1,278 +1,709 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+
 // src/lib/errors.ts
-var CoreError = class extends Error {
-  constructor({ code, message, data, description }) {
+var ERROR_GROUPS = {
+  JSONRPC: {
+    min: -32700,
+    max: -32600,
+    ERRORS: {
+      // These error messages differ from types because of JSONRPC spec
+      PARSE_ERROR: {
+        code: -32700,
+        message: "Parse error",
+        description: "Unable to parse JSON input"
+      },
+      INVALID_REQUEST: {
+        code: -32600,
+        message: "Invalid request",
+        description: "JSON input does not match JSONRPC spec"
+      },
+      METHOD_NOT_FOUND: {
+        code: -32601,
+        message: "Method not found",
+        description: "Requested method not found"
+      },
+      INVALID_PARAMS: {
+        code: -32602,
+        message: "Invalid params",
+        description: "Invalid params provided for method"
+      },
+      INTERNAL_SERVER_ERROR: {
+        code: -32603,
+        message: "Internal server error",
+        description: "Unknown error occurred"
+      }
+    }
+  },
+  AUTH: {
+    min: -20999,
+    max: -2e4,
+    ERRORS: {
+      AUTHENTICATION_ERROR: {
+        code: -2e4,
+        // Historic reasons why not AUTHENTICATION_ERROR
+        message: "Authentication error",
+        description: "Invalid authentication credentials"
+      },
+      AUTHORIZATION_ERROR: {
+        code: -20001,
+        message: "AUTHORIZATION_ERROR",
+        description: "Provided credentials lack access rights"
+      }
+    }
+  },
+  STREAM: {
+    min: -10999,
+    max: -1e4,
+    ERRORS: {
+      CONNECTION_LOST: {
+        code: -1e4,
+        message: "CONNECTION_LOST",
+        description: "Lost connection to server"
+      },
+      INPUT_STREAM_INVALID: {
+        code: -10001,
+        message: "INPUT_STREAM_INVALID",
+        description: "Invalid input stream identifier provided"
+      },
+      INVALID_RESPONSE_STREAM_CHUNK: {
+        code: -10002,
+        message: "INVALID_RESPONSE_STREAM_CHUNK",
+        description: "Received multiple chunks for non-array property"
+      },
+      INVALID_INPUT_STREAM_CHUNK: {
+        code: -10003,
+        message: "INVALID_INPUT_STREAM_CHUNK",
+        description: "Invalid chunk sent to input stream"
+      },
+      INPUT_STREAM_TIMEOUT: {
+        code: -10004,
+        message: "INPUT_STREAM_TIMEOUT",
+        description: "Input stream failed to finish in allotted time"
+      },
+      INPUT_STREAM_ERROR: {
+        code: -10005,
+        message: "INPUT_STREAM_ERROR",
+        description: "Unknown error in input stream"
+      },
+      INPUT_STREAM_NOT_ALLOWED: {
+        code: -10006,
+        message: "INPUT_STREAM_NOT_ALLOWED",
+        description: "Stream input not allowed for method"
+      }
+    }
+  },
+  INPUT: {
+    min: -14999,
+    max: -11e3,
+    ERRORS: {
+      HTTP_BODY_SIZE: {
+        code: -11e3,
+        message: "HTTP_BODY_SIZE",
+        description: "Http body size can't be more than 100MB"
+      },
+      DATABASE_EXPORT_CONFLICT: {
+        code: -12e3,
+        message: "DATABASE_EXPORT_CONFLICT",
+        description: "Database export already in progress"
+      },
+      DATABASE_IMPORT_CONFLICT: {
+        code: -12001,
+        message: "DATABASE_IMPORT_CONFLICT",
+        description: "Database import already in progress"
+      },
+      DATABASE_EXPORT_PROGRESS_NOT_FOUND: {
+        code: -12002,
+        message: "DATABASE_EXPORT_PROGRESS_NOT_FOUND",
+        description: `Database backup process not found`
+      },
+      DATABASE_IMPORT_PROGRESS_NOT_FOUND: {
+        code: -12003,
+        message: "DATABASE_IMPORT_PROGRESS_NOT_FOUND",
+        description: `Database backup process not found`
+      },
+      DATABASE_IMPORT_NOT_FOUND: {
+        code: -12004,
+        message: "DATABASE_IMPORT_NOT_FOUND",
+        description: "Database import file not found"
+      },
+      TR_CANT_UPDATE_TO_PENDING: {
+        code: -12100,
+        message: "TR_CANT_UPDATE_TO_PENDING",
+        description: `Transfer status can only move from 'pending'->'finished'/'cancelled`
+      },
+      TR_CANT_UPDATE_TIMESTAMP: {
+        code: -12101,
+        message: "TR_CANT_UPDATE_TIMESTAMP",
+        description: "Cant update transfer.updated_at - allow_timestamps flag is set to off"
+      },
+      TR_CANT_INSERT_TIMESTAMP: {
+        code: -12102,
+        message: "TR_CANT_INSERT_TIMESTAMP",
+        description: "Cant insert transfer.created_at - allow_timestamps flag is set to off"
+      },
+      TR_EMPTY_UPDATE_REQUEST: {
+        code: -12103,
+        message: "TR_EMPTY_UPDATE_REQUEST",
+        description: "Update request for transfer is empty"
+      },
+      TR_MISSING_FILTER: {
+        code: -12104,
+        message: "TR_MISSING_FILTER",
+        description: `Transactions can't reversed or updated without valid filter`
+      },
+      TR_TO_WALLET_WITHDRAWAL: {
+        code: -12105,
+        message: "TR_TO_WALLET_WITHDRAWAL",
+        description: `To wallet can't be specified when doing a withdrawal`
+      },
+      TR_FROM_WALLET_DEPOSIT: {
+        code: -12106,
+        message: "TR_FROM_WALLET_DEPOSIT",
+        description: `From wallet can't be specified when doing a deposit`
+      },
+      TR_FROM_TO_CONFLICT: {
+        code: -12107,
+        message: "TR_FROM_TO_CONFLICT",
+        description: "from_wallet and to_wallet can not be the same"
+      },
+      TR_UNABLE_TO_RESOLVE_INPUT: {
+        code: -12108,
+        message: "TR_UNABLE_TO_RESOLVE_INPUT",
+        description: "Unable to resolve references to foreign keys"
+      },
+      TRG_MISSING_FILTER: {
+        code: -12200,
+        message: "TRG_MISSING_FILTER",
+        description: `Transaction groups can't reversed or updated without valid filter`
+      },
+      INVALID_FIELD_AGR_COMB: {
+        code: -12300,
+        message: "INVALID_FIELD_AGR_COMB",
+        description: `Provided aggregation field was not found on Model`
+      },
+      INVALID_FIELD_FOR_MODEL: {
+        code: -12301,
+        message: "INVALID_FIELD_FOR_MODEL",
+        description: `Provided groupBy field was not found on Model`
+      },
+      NO_METADATA_ON_MODEL: {
+        code: -12302,
+        message: "NO_METADATA_ON_MODEL",
+        description: `Can't use metadata field for grouping as current Model does not have metadata`
+      },
+      INVALID_MODEL: {
+        code: -12303,
+        message: "INVALID_MODEL",
+        description: `Provided Model name is invalid`
+      },
+      INVALID_COMPLEX_FILTER: {
+        code: -12304,
+        message: "INVALID_COMPLEX_FILTER",
+        description: `The provided complex filter does not pass validation`
+      },
+      UNCLEAR_AGGREGATOR: {
+        code: -12305,
+        message: "UNCLEAR_AGGREGATOR",
+        description: `Invalid aggregator function provided`
+      },
+      CONTRACT_OWNER_NOT_FOUND: {
+        code: -12306,
+        message: "CONTRACT_OWNER_NOT_FOUND",
+        description: `Unable to find Wallet specified as Contract token owner`
+      },
+      DISTRIBUTION_MISSING_TARGETS: {
+        code: -12307,
+        message: "DISTRIBUTION_MISSING_TARGETS",
+        description: `Unable to resolve all targets (Wallets, Tokens) for distribution request`
+      },
+      TOKEN_INVALID_WALLET: {
+        code: -12308,
+        message: "TOKEN_INVALID_WALLET",
+        description: `Invalid belongs_to wallet provided`
+      },
+      BAL_FUTURE_DATETIME: {
+        code: -12309,
+        message: "BAL_FUTURE_DATETIME",
+        description: `Balance datetime can't be in the future`
+      },
+      INPUT_NEEDS_IDENTIFIER: {
+        code: -12310,
+        message: "INPUT_NEEDS_IDENTIFIER",
+        description: `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`
+      },
+      RESET_INVALID_CONFIRMATION: {
+        code: -12311,
+        message: "RESET_INVALID_CONFIRMATION",
+        description: "Provided reset confirmation code is invalid"
+      },
+      INPUT_NEEDS_TOKEN: {
+        code: -12312,
+        message: "INPUT_NEEDS_TOKEN",
+        description: "token must be specified on input or in client config"
+      },
+      CONFLICTING_OPTIONS_FOR_BALANCE: {
+        code: -12313,
+        message: "CONFLICTING_OPTIONS_FOR_BALANCE",
+        description: `return_running_balance and return_running_balance_for can't be specified together`
+      },
+      CONFLICTING_OPTIONS_FOR_SIGNED_AMOUNT: {
+        code: -12314,
+        message: "CONFLICTING_OPTIONS_FOR_SIGNED_AMOUNT",
+        description: `return_signed_amount and return_signed_amount_for_wallet can't be specified together`
+      },
+      RUNNING_BALANCE_WITHOUT_WALLET: {
+        code: -12315,
+        message: "RUNNING_BALANCE_WITHOUT_WALLET",
+        description: "return_running_balance option requires Wallet filter to be specified"
+      },
+      SIGNED_AMOUNT_WITHOUT_WALLET: {
+        code: -12316,
+        message: "SIGNED_AMOUNT_WITHOUT_WALLET",
+        description: `return_signed_amount option requires Wallet filter to be specified`
+      },
+      REQUIRED_INPUT_MISSING: {
+        code: -12317,
+        message: "REQUIRED_INPUT_MISSING",
+        description: `input does not specify required keys`
+      },
+      TRX_NOT_ALLOWED: {
+        code: -12400,
+        message: "TRX_NOT_ALLOWED",
+        description: "This method can not run in a transaction"
+      },
+      TRANSACTION_NOT_FOUND: {
+        code: -12401,
+        message: "TRANSACTION_NOT_FOUND",
+        description: "Transaction not found"
+      },
+      ONLY_SELECT_ALLOWED: {
+        code: -12402,
+        message: "ONLY_SELECT_ALLOWED",
+        description: "Only select queries are allowed"
+      }
+    }
+  },
+  CONSTRAINT: {
+    min: -19999,
+    max: -19e3,
+    ERRORS: {
+      INVALID_LATEST_HASH: {
+        code: -19e3,
+        message: "INVALID_LATEST_HASH",
+        description: "Http body size can't be more than 100MB"
+      },
+      TOKEN_LIMIT_REACHED: {
+        code: -19001,
+        message: "TOKEN_LIMIT_REACHED",
+        description: "Unable to issue more tokens as Token.limit has been reached"
+      },
+      TR_INVALID_BALANCE: {
+        code: -19101,
+        message: "TR_INVALID_BALANCE",
+        description: "Transfer would result in invalid balance for a Wallet"
+      },
+      TR_AMOUNT_NOT_DIVISIBLE: {
+        code: -19102,
+        message: "TR_AMOUNT_NOT_DIVISIBLE",
+        description: `Transfer amount is not divisible by specified Token.divisor`
+      },
+      TR_TOKEN_DISABLED: {
+        code: -19103,
+        message: "TR_TOKEN_DISABLED",
+        description: `Token status is set to 'disabled' - no new transfers allowed`
+      },
+      TR_TOKEN_DWONLY: {
+        code: -19104,
+        message: "TR_TOKEN_DWONLY",
+        description: `Token status is set to 'dw-only' - only deposits or withdrawals allowed`
+      },
+      TR_TRG_STATUS_MISMATCH: {
+        code: -19105,
+        message: "TR_TRG_STATUS_MISMATCH",
+        description: `Transfers in transfer_group must match transfer_group.transfer_status`
+      },
+      TR_TRG_CLOSED: {
+        code: -19106,
+        message: "TR_TRG_CLOSED",
+        description: `Cant add Transfer to group. TransferGroup is closed`
+      },
+      TR_TIMESTAMP_IN_PAST: {
+        code: -19107,
+        message: "TR_TIMESTAMP_IN_PAST",
+        description: `Transfer.created_at must be the latest`
+      },
+      TR_TIMESTAMP_MUST_BE_LATEST: {
+        code: -19108,
+        message: "TR_TIMESTAMP_MUST_BE_LATEST",
+        description: `Transfer.created_at must be the latest`
+      },
+      TR_INVALID_CANCELLED: {
+        code: -19109,
+        message: "TR_INVALID_CANCELLED",
+        description: `Cant create cancelled transfer`
+      },
+      TR_FROM_WALLET_STATUS_CONSTRAINT: {
+        code: -19110,
+        message: "TR_FROM_WALLET_STATUS_CONSTRAINT",
+        description: `From wallet.status doesn't allow this type of transfers`
+      },
+      TR_TO_WALLET_STATUS_CONSTRAINT: {
+        code: -19111,
+        message: "TR_TO_WALLET_STATUS_CONSTRAINT",
+        description: `To wallet.status doesn't allow this type of transfers`
+      },
+      TR_CANCELLED_CANT_RV: {
+        code: -19112,
+        message: "TR_CANCELLED_CANT_RV",
+        description: `Cancelled Transfer can not be reversed`
+      },
+      TR_DEPOSIT_CANT_RV_WITHOUT_FLAG: {
+        code: -19113,
+        message: "TR_DEPOSIT_CANT_RV_WITHOUT_FLAG",
+        description: `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_WITHDRAWAL_CANT_RV_WITHOUT_FLAG: {
+        code: -19114,
+        message: "TR_WITHDRAWAL_CANT_RV_WITHOUT_FLAG",
+        description: `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.`
+      },
+      TRG_SINGLE_PENDING_TR_CANT_RV: {
+        code: -19200,
+        message: "TRG_SINGLE_PENDING_TR_CANT_RV",
+        description: `Transfer is part of TransferGroup and can not be reversed separately`
+      },
+      TRG_CANCELLED_CANT_RV: {
+        code: -19201,
+        message: "TRG_CANCELLED_CANT_RV",
+        description: `Cancelled TransferGroup can not be reversed`
+      },
+      TRG_DEPOSIT_CANT_RV_WITHOUT_FLAG: {
+        code: -19202,
+        message: "TRG_DEPOSIT_CANT_RV_WITHOUT_FLAG",
+        description: `TransferGroup includes Transfer.type = 'deposit', thus for extra validation the reverse_deposit option must be set true`
+      },
+      TRG_WITHDRAWAL_CANT_RV_WITHOUT_FLAG: {
+        code: -19203,
+        message: "TRG_WITHDRAWAL_CANT_RV_WITHOUT_FLAG",
+        description: `TransferGroup includes Transfer.type = 'withdrawal', thus for extra validation the reverse_withdrawal option must be set true`
+      }
+    }
+  },
+  CONFIG: {
+    min: -16e3,
+    max: -15e3,
+    ERRORS: {
+      METHOD_DISABLED: {
+        code: -15e3,
+        message: "METHOD_DISABLED",
+        description: "Method is disabled"
+      },
+      FLAG_PRODUCTION_ON: {
+        code: -15001,
+        message: "FLAG_PRODUCTION_ON",
+        description: 'Production flag is "on" - this method is disabled'
+      },
+      FLAG_PRODUCTION_LOCKED: {
+        code: -15002,
+        message: "FLAG_PRODUCTION_LOCKED",
+        description: "Cant update production flag to false in this server"
+      },
+      TRANSACTION_TIMEOUT: {
+        code: -15003,
+        message: "TRANSACTION_TIMEOUT",
+        description: "Database transaction timed out"
+      }
+    }
+  }
+};
+var ERRORS = __spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues({}, ERROR_GROUPS.JSONRPC.ERRORS), ERROR_GROUPS.AUTH.ERRORS), ERROR_GROUPS.CONFIG.ERRORS), ERROR_GROUPS.STREAM.ERRORS), ERROR_GROUPS.INPUT.ERRORS), ERROR_GROUPS.CONSTRAINT.ERRORS);
+function getTypeMap(input) {
+  return Object.fromEntries(Object.keys(input).map((key) => [key, key]));
+}
+var ERROR_TYPES = getTypeMap(ERRORS);
+var WAPIError = class extends Error {
+  constructor({ type, code, message, data }) {
     var _a;
     super(message);
-    this.code = code;
-    this.message = message;
-    this.data = data;
-    this.description = (_a = description != null ? description : ErrorDescriptions[message]) != null ? _a : "";
+    const errorType = (_a = ERRORS[type]) != null ? _a : ERRORS.INTERNAL_SERVER_ERROR;
+    this.type = ERRORS[type] ? type : ERROR_TYPES.INTERNAL_SERVER_ERROR;
+    this.code = code || errorType.code;
+    this.message = message || errorType.message;
+    this.data = __spreadValues({
+      description: errorType.description
+    }, data && typeof data === "object" ? data : { error: data });
   }
   toJSON() {
     return {
       code: this.code,
       message: this.message,
-      description: this.description,
       data: this.data
     };
   }
 };
-var DatabaseError = class extends CoreError {
-  constructor({ message, data, code }) {
+var JSONRPCError = class extends WAPIError {
+  constructor(type, data, message) {
     super({
+      type,
       message,
-      data,
-      code: code || "DatabaseError" /* DatabaseError */
+      data
     });
   }
+  static get group() {
+    return ERROR_GROUPS.JSONRPC.ERRORS;
+  }
+  static get types() {
+    return getTypeMap(ERROR_GROUPS.JSONRPC.ERRORS);
+  }
 };
-var ValidationError = class extends CoreError {
-  constructor({ message, data, code }) {
+var StreamError = class extends WAPIError {
+  constructor(type, data, message) {
     super({
+      type,
       message,
-      data,
-      code: code || "SchemaValidationError" /* SchemaValidationError */
+      data
     });
   }
+  static get group() {
+    return ERROR_GROUPS.STREAM.ERRORS;
+  }
+  static get types() {
+    return getTypeMap(ERROR_GROUPS.STREAM.ERRORS);
+  }
 };
-var InputError = class extends CoreError {
-  constructor({ message, data, code }) {
+var InputError = class extends WAPIError {
+  constructor(type, data, message) {
     super({
+      type,
       message,
-      data,
-      code: code || "InputError" /* InputError */
+      data
     });
   }
+  static get group() {
+    return ERROR_GROUPS.INPUT.ERRORS;
+  }
+  static get types() {
+    return getTypeMap(ERROR_GROUPS.INPUT.ERRORS);
+  }
 };
-var ConstraintError = class extends CoreError {
-  constructor({ message, data, code }) {
+var ConfigError = class extends WAPIError {
+  constructor(type, data, message) {
     super({
+      type,
       message,
-      data,
-      code: code || "ConstraintError" /* ConstraintError */
+      data
     });
   }
+  static get group() {
+    return ERROR_GROUPS.CONFIG.ERRORS;
+  }
+  static get types() {
+    return getTypeMap(ERROR_GROUPS.CONFIG.ERRORS);
+  }
 };
-var UnknownError = class extends CoreError {
-  constructor({ message, data, code }) {
+var AuthError = class extends WAPIError {
+  constructor(type, data, message) {
     super({
+      type,
       message,
-      data,
-      code: code || "UnknownError" /* UnknownError */
+      data
     });
   }
+  static get group() {
+    return ERROR_GROUPS.AUTH.ERRORS;
+  }
+  static get types() {
+    return getTypeMap(ERROR_GROUPS.AUTH.ERRORS);
+  }
 };
-var ConnectionError = class extends CoreError {
-  constructor({ message, data, code }) {
+var ConstraintError = class extends WAPIError {
+  constructor(type, data, message) {
     super({
+      type,
       message,
-      data,
-      code: code || "ConnectionError" /* ConnectionError */
+      data
     });
   }
+  static get group() {
+    return ERROR_GROUPS.CONSTRAINT.ERRORS;
+  }
+  static get types() {
+    return getTypeMap(ERROR_GROUPS.CONSTRAINT.ERRORS);
+  }
+};
+var ValidationError = class extends JSONRPCError {
+  constructor(data, message) {
+    super(JSONRPCError.types.INVALID_PARAMS, data, message);
+  }
 };
-var StreamError = class extends CoreError {
-  constructor({ message, data, code }) {
+var AuthenticationError = class extends AuthError {
+  constructor(data) {
+    super(AuthError.types.AUTHENTICATION_ERROR, data);
+  }
+};
+var AuthorizationError = class extends AuthError {
+  constructor(data) {
+    super(AuthError.types.AUTHORIZATION_ERROR, data);
+  }
+};
+var InternalError = class extends WAPIError {
+  constructor(data) {
     super({
-      message,
-      data,
-      code: code || "StreamError" /* StreamError */
+      type: ERROR_TYPES.INTERNAL_SERVER_ERROR,
+      data
     });
   }
+  toJSON() {
+    return {
+      code: this.code,
+      message: this.message,
+      data: {
+        description: ERRORS.INTERNAL_SERVER_ERROR.description
+      }
+    };
+  }
 };
-var AuthenticationError = class extends CoreError {
-  constructor({ message, data, code }) {
+var UnknownError = class extends InternalError {
+  constructor(message) {
     super({
-      message,
-      data,
-      code: code || "AuthenticationError" /* AuthenticationError */
+      data: {
+        message
+      }
     });
   }
+  toJSON() {
+    const json = super.toJSON();
+    json.data = {
+      description: json.data.description,
+      message: this.data.message
+    };
+    return {
+      code: this.code,
+      message: this.message,
+      data: {
+        message: this.data.message,
+        description: ERRORS.INTERNAL_SERVER_ERROR.description
+      }
+    };
+  }
 };
-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 });
+var ERROR_CODE_TO_TYPE = Object.fromEntries(
+  Object.keys(ERRORS).map((key) => [ERRORS[key].code, key])
+);
+function categorizeErrorCode(code) {
+  const type = ERROR_CODE_TO_TYPE[code];
+  if (!type) {
+    return {
+      group: void 0,
+      type: void 0
+    };
+  }
+  const group = Object.keys(ERROR_GROUPS).find((groupName) => {
+    return type in ERROR_GROUPS[groupName].ERRORS;
+  });
+  if (!group) {
+    console.error("ERRORS and ERROR_GROUPS are out of sync", type);
+    return {
+      group: void 0,
+      type
+    };
+  }
+  return {
+    group,
+    type
+  };
+}
+function getError({ code, message, data }) {
+  const { group, type } = categorizeErrorCode(code);
+  message = message && message !== type ? message : ERRORS[type].description;
+  switch (group) {
+    case "JSONRPC":
+      return new JSONRPCError(
+        type,
+        data,
+        message
+      );
+    case "AUTH":
+      return new AuthError(
+        type,
+        data,
+        message
+      );
+    case "CONFIG":
+      return new ConfigError(
+        type,
+        data,
+        message
+      );
+    case "CONSTRAINT":
+      return new ConstraintError(
+        type,
+        data,
+        message
+      );
+    case "INPUT":
+      return new InputError(
+        type,
+        data,
+        message
+      );
+    case "STREAM":
+      return new StreamError(
+        type,
+        data,
+        message
+      );
     default:
-      return new UnknownError({ message, data, code });
+      return new WAPIError({
+        code,
+        message,
+        data,
+        type: type != null ? type : ERROR_TYPES.INTERNAL_SERVER_ERROR
+      });
   }
 }
-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`
-};
+var ERROR_MESSAGES = Object.fromEntries(
+  Object.keys(ERRORS).map((key) => [key, ERRORS[key].message])
+);
+var ERROR_DESCRIPTIONS = Object.fromEntries(
+  Object.keys(ERRORS).map((key) => [
+    key,
+    ERRORS[key].description
+  ])
+);
 export {
+  AuthError,
   AuthenticationError,
-  ConnectionError,
+  AuthorizationError,
+  ConfigError,
   ConstraintError,
-  CoreError,
-  DatabaseError,
+  ERRORS,
+  ERROR_CODE_TO_TYPE,
+  ERROR_DESCRIPTIONS,
+  ERROR_GROUPS,
   ERROR_MESSAGES,
   ERROR_TYPES,
-  ErrorDescriptions,
   InputError,
+  InternalError,
+  JSONRPCError,
   StreamError,
   UnknownError,
   ValidationError,
+  WAPIError,
   getError
 };