lampamazaza-new-internal-utils 0.24.3

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 NEAR Foundation
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/_virtual/rolldown_runtime.cjs

@@ -0,0 +1,43 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __exportAll = (all, symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+
+exports.__exportAll = __exportAll;
+exports.__toESM = __toESM;

package/dist/_virtual/rolldown_runtime.js

@@ -0,0 +1,18 @@
+//#region rolldown:runtime
+var __defProp = Object.defineProperty;
+var __exportAll = (all, symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+
+//#endregion
+export { __exportAll };

package/dist/config.cjs

@@ -0,0 +1,82 @@
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+let valibot = require("valibot");
+valibot = require_rolldown_runtime.__toESM(valibot);
+
+//#region src/config.ts
+const optionalUrlSchema = valibot.pipe(valibot.string(), valibot.check((value) => value === "" || URL.canParse(value), "must be a valid URL or empty string"));
+const envConfigSchema = valibot.object({
+	contractID: valibot.pipe(valibot.string(), valibot.minLength(1, "contractID is required")),
+	poaTokenFactoryContractID: valibot.string(),
+	poaBridgeBaseURL: optionalUrlSchema,
+	solverRelayBaseURL: optionalUrlSchema,
+	managerConsoleBaseURL: optionalUrlSchema,
+	nearIntentsBaseURL: optionalUrlSchema
+});
+/**
+* Resolves environment configuration from either a preset name or custom config.
+* Defaults to "production" if no env is provided.
+*
+* @param env - Either "production"/"stage" preset name, or a custom EnvConfig object
+* @returns Resolved EnvConfig
+* @throws Error if custom config fails validation
+*/
+function resolveEnvConfig(env) {
+	if (env === void 0) return configsByEnvironment.production;
+	if (typeof env === "string") return configsByEnvironment[env];
+	const result = valibot.safeParse(envConfigSchema, env);
+	if (!result.success) {
+		const issues = result.issues.map((issue) => `${issue.path?.map((p) => p.key).join(".")}: ${issue.message}`).join(", ");
+		throw new Error(`Invalid EnvConfig: ${issues}`);
+	}
+	return result.output;
+}
+const configsByEnvironment = {
+	production: {
+		contractID: "intents.near",
+		poaTokenFactoryContractID: "omft.near",
+		poaBridgeBaseURL: "https://bridge.chaindefuser.com",
+		solverRelayBaseURL: "https://solver-relay-v2.chaindefuser.com",
+		managerConsoleBaseURL: "https://api-mng-console.chaindefuser.com/api/",
+		nearIntentsBaseURL: "https://near-intents.org/api/"
+	},
+	stage: {
+		contractID: "staging-intents.near",
+		poaTokenFactoryContractID: "stft.near",
+		poaBridgeBaseURL: "https://poa-stage.intents-near.org",
+		solverRelayBaseURL: "https://solver-relay-stage.intents-near.org",
+		managerConsoleBaseURL: "https://mng-console-stage.intents-near.org/api/",
+		nearIntentsBaseURL: "https://stage.near-intents.org/api/"
+	}
+};
+let config = {
+	env: configsByEnvironment.production,
+	features: { hyperliquid: false }
+};
+function configureSDK({ env, features, environments }) {
+	if (environments) for (const [key, value] of Object.entries(environments)) configsByEnvironment[key] = {
+		...configsByEnvironment[key],
+		...value
+	};
+	if (env !== void 0) config = {
+		...config,
+		env: resolveEnvConfig(env)
+	};
+	config = {
+		...config,
+		features: {
+			...config.features,
+			...features
+		}
+	};
+}
+
+//#endregion
+Object.defineProperty(exports, 'config', {
+  enumerable: true,
+  get: function () {
+    return config;
+  }
+});
+exports.configsByEnvironment = configsByEnvironment;
+exports.configureSDK = configureSDK;
+exports.resolveEnvConfig = resolveEnvConfig;

package/dist/config.d.cts

@@ -0,0 +1,42 @@
+import { ILogger } from "./logger.cjs";
+
+//#region src/config.d.ts
+interface SDKConfig {
+  logger?: ILogger;
+  env: EnvConfig;
+  features: {
+    hyperliquid: boolean;
+  };
+}
+interface EnvConfig {
+  contractID: string;
+  poaTokenFactoryContractID: string;
+  poaBridgeBaseURL: string;
+  solverRelayBaseURL: string;
+  managerConsoleBaseURL: string;
+  nearIntentsBaseURL: string;
+}
+type NearIntentsEnv = "production" | "stage";
+/**
+ * Resolves environment configuration from either a preset name or custom config.
+ * Defaults to "production" if no env is provided.
+ *
+ * @param env - Either "production"/"stage" preset name, or a custom EnvConfig object
+ * @returns Resolved EnvConfig
+ * @throws Error if custom config fails validation
+ */
+declare function resolveEnvConfig(env: NearIntentsEnv | EnvConfig | undefined): EnvConfig;
+declare const configsByEnvironment: Record<NearIntentsEnv, EnvConfig>;
+declare let config: SDKConfig;
+interface ConfigureSDKArgs {
+  env?: EnvConfig | NearIntentsEnv;
+  features?: { [K in keyof SDKConfig["features"]]?: boolean };
+  environments?: Record<NearIntentsEnv, Partial<EnvConfig>>;
+}
+declare function configureSDK({
+  env,
+  features,
+  environments
+}: ConfigureSDKArgs): void;
+//#endregion
+export { EnvConfig, NearIntentsEnv, config, configsByEnvironment, configureSDK, resolveEnvConfig };

package/dist/config.d.ts

@@ -0,0 +1,42 @@
+import { ILogger } from "./logger.js";
+
+//#region src/config.d.ts
+interface SDKConfig {
+  logger?: ILogger;
+  env: EnvConfig;
+  features: {
+    hyperliquid: boolean;
+  };
+}
+interface EnvConfig {
+  contractID: string;
+  poaTokenFactoryContractID: string;
+  poaBridgeBaseURL: string;
+  solverRelayBaseURL: string;
+  managerConsoleBaseURL: string;
+  nearIntentsBaseURL: string;
+}
+type NearIntentsEnv = "production" | "stage";
+/**
+ * Resolves environment configuration from either a preset name or custom config.
+ * Defaults to "production" if no env is provided.
+ *
+ * @param env - Either "production"/"stage" preset name, or a custom EnvConfig object
+ * @returns Resolved EnvConfig
+ * @throws Error if custom config fails validation
+ */
+declare function resolveEnvConfig(env: NearIntentsEnv | EnvConfig | undefined): EnvConfig;
+declare const configsByEnvironment: Record<NearIntentsEnv, EnvConfig>;
+declare let config: SDKConfig;
+interface ConfigureSDKArgs {
+  env?: EnvConfig | NearIntentsEnv;
+  features?: { [K in keyof SDKConfig["features"]]?: boolean };
+  environments?: Record<NearIntentsEnv, Partial<EnvConfig>>;
+}
+declare function configureSDK({
+  env,
+  features,
+  environments
+}: ConfigureSDKArgs): void;
+//#endregion
+export { EnvConfig, NearIntentsEnv, config, configsByEnvironment, configureSDK, resolveEnvConfig };

package/dist/config.js

@@ -0,0 +1,72 @@
+import * as v from "valibot";
+
+//#region src/config.ts
+const optionalUrlSchema = v.pipe(v.string(), v.check((value) => value === "" || URL.canParse(value), "must be a valid URL or empty string"));
+const envConfigSchema = v.object({
+	contractID: v.pipe(v.string(), v.minLength(1, "contractID is required")),
+	poaTokenFactoryContractID: v.string(),
+	poaBridgeBaseURL: optionalUrlSchema,
+	solverRelayBaseURL: optionalUrlSchema,
+	managerConsoleBaseURL: optionalUrlSchema,
+	nearIntentsBaseURL: optionalUrlSchema
+});
+/**
+* Resolves environment configuration from either a preset name or custom config.
+* Defaults to "production" if no env is provided.
+*
+* @param env - Either "production"/"stage" preset name, or a custom EnvConfig object
+* @returns Resolved EnvConfig
+* @throws Error if custom config fails validation
+*/
+function resolveEnvConfig(env) {
+	if (env === void 0) return configsByEnvironment.production;
+	if (typeof env === "string") return configsByEnvironment[env];
+	const result = v.safeParse(envConfigSchema, env);
+	if (!result.success) {
+		const issues = result.issues.map((issue) => `${issue.path?.map((p) => p.key).join(".")}: ${issue.message}`).join(", ");
+		throw new Error(`Invalid EnvConfig: ${issues}`);
+	}
+	return result.output;
+}
+const configsByEnvironment = {
+	production: {
+		contractID: "intents.near",
+		poaTokenFactoryContractID: "omft.near",
+		poaBridgeBaseURL: "https://bridge.chaindefuser.com",
+		solverRelayBaseURL: "https://solver-relay-v2.chaindefuser.com",
+		managerConsoleBaseURL: "https://api-mng-console.chaindefuser.com/api/",
+		nearIntentsBaseURL: "https://near-intents.org/api/"
+	},
+	stage: {
+		contractID: "staging-intents.near",
+		poaTokenFactoryContractID: "stft.near",
+		poaBridgeBaseURL: "https://poa-stage.intents-near.org",
+		solverRelayBaseURL: "https://solver-relay-stage.intents-near.org",
+		managerConsoleBaseURL: "https://mng-console-stage.intents-near.org/api/",
+		nearIntentsBaseURL: "https://stage.near-intents.org/api/"
+	}
+};
+let config = {
+	env: configsByEnvironment.production,
+	features: { hyperliquid: false }
+};
+function configureSDK({ env, features, environments }) {
+	if (environments) for (const [key, value] of Object.entries(environments)) configsByEnvironment[key] = {
+		...configsByEnvironment[key],
+		...value
+	};
+	if (env !== void 0) config = {
+		...config,
+		env: resolveEnvConfig(env)
+	};
+	config = {
+		...config,
+		features: {
+			...config.features,
+			...features
+		}
+	};
+}
+
+//#endregion
+export { config, configsByEnvironment, configureSDK, resolveEnvConfig };

package/dist/errors/assert.cjs

@@ -0,0 +1,11 @@
+const require_base = require('./base.cjs');
+
+//#region src/errors/assert.ts
+var AssertionError = class extends require_base.BaseError {
+	constructor(message) {
+		super(message || "Assertion failed", { name: "AssertionError" });
+	}
+};
+
+//#endregion
+exports.AssertionError = AssertionError;

package/dist/errors/assert.d.cts

@@ -0,0 +1,11 @@
+import { BaseError } from "./base.cjs";
+
+//#region src/errors/assert.d.ts
+type AssertionErrorType = AssertionError & {
+  name: "AssertionError";
+};
+declare class AssertionError extends BaseError {
+  constructor(message: string | undefined);
+}
+//#endregion
+export { AssertionError, AssertionErrorType };

package/dist/errors/assert.d.ts

@@ -0,0 +1,11 @@
+import { BaseError } from "./base.js";
+
+//#region src/errors/assert.d.ts
+type AssertionErrorType = AssertionError & {
+  name: "AssertionError";
+};
+declare class AssertionError extends BaseError {
+  constructor(message: string | undefined);
+}
+//#endregion
+export { AssertionError, AssertionErrorType };

package/dist/errors/assert.js

@@ -0,0 +1,11 @@
+import { BaseError } from "./base.js";
+
+//#region src/errors/assert.ts
+var AssertionError = class extends BaseError {
+	constructor(message) {
+		super(message || "Assertion failed", { name: "AssertionError" });
+	}
+};
+
+//#endregion
+export { AssertionError };

package/dist/errors/base.cjs

@@ -0,0 +1,34 @@
+
+//#region src/errors/base.ts
+var BaseError = class BaseError extends Error {
+	constructor(shortMessage, args = {}) {
+		const details = (() => {
+			if (args.cause instanceof BaseError) return args.cause.details;
+			if (args.cause != null && typeof args.cause === "object" && "message" in args.cause && typeof args.cause.message === "string") return args.cause.message;
+			return args.details ?? "";
+		})();
+		const message = [
+			shortMessage || "An error occurred.",
+			"",
+			...args.metaMessages ? [...args.metaMessages, ""] : [],
+			...details ? [`Details: ${details}`] : []
+		].join("\n");
+		super(message, args.cause ? { cause: args.cause } : void 0);
+		this.name = "BaseError";
+		this.details = details;
+		this.metaMessages = args.metaMessages;
+		this.name = args.name ?? this.name;
+		this.shortMessage = shortMessage;
+	}
+	walk(fn) {
+		return walk(this, fn);
+	}
+};
+function walk(err, fn) {
+	if (fn?.(err)) return err;
+	if (err && typeof err === "object" && "cause" in err && err.cause !== void 0) return walk(err.cause, fn);
+	return fn ? null : err;
+}
+
+//#endregion
+exports.BaseError = BaseError;

package/dist/errors/base.d.cts

@@ -0,0 +1,21 @@
+//#region src/errors/base.d.ts
+type BaseErrorParameters = {
+  cause?: unknown;
+  details?: string | undefined;
+  metaMessages?: string[] | undefined;
+  name?: string | undefined;
+};
+type BaseErrorType = BaseError & {
+  name: "BaseError";
+};
+declare class BaseError extends Error {
+  details: string;
+  metaMessages?: string[] | undefined;
+  shortMessage: string;
+  name: string;
+  constructor(shortMessage: string, args?: BaseErrorParameters);
+  walk(): Error;
+  walk(fn: (err: unknown) => boolean): Error | null;
+}
+//#endregion
+export { BaseError, BaseErrorType };

package/dist/errors/base.d.ts

@@ -0,0 +1,21 @@
+//#region src/errors/base.d.ts
+type BaseErrorParameters = {
+  cause?: unknown;
+  details?: string | undefined;
+  metaMessages?: string[] | undefined;
+  name?: string | undefined;
+};
+type BaseErrorType = BaseError & {
+  name: "BaseError";
+};
+declare class BaseError extends Error {
+  details: string;
+  metaMessages?: string[] | undefined;
+  shortMessage: string;
+  name: string;
+  constructor(shortMessage: string, args?: BaseErrorParameters);
+  walk(): Error;
+  walk(fn: (err: unknown) => boolean): Error | null;
+}
+//#endregion
+export { BaseError, BaseErrorType };

package/dist/errors/base.js

@@ -0,0 +1,33 @@
+//#region src/errors/base.ts
+var BaseError = class BaseError extends Error {
+	constructor(shortMessage, args = {}) {
+		const details = (() => {
+			if (args.cause instanceof BaseError) return args.cause.details;
+			if (args.cause != null && typeof args.cause === "object" && "message" in args.cause && typeof args.cause.message === "string") return args.cause.message;
+			return args.details ?? "";
+		})();
+		const message = [
+			shortMessage || "An error occurred.",
+			"",
+			...args.metaMessages ? [...args.metaMessages, ""] : [],
+			...details ? [`Details: ${details}`] : []
+		].join("\n");
+		super(message, args.cause ? { cause: args.cause } : void 0);
+		this.name = "BaseError";
+		this.details = details;
+		this.metaMessages = args.metaMessages;
+		this.name = args.name ?? this.name;
+		this.shortMessage = shortMessage;
+	}
+	walk(fn) {
+		return walk(this, fn);
+	}
+};
+function walk(err, fn) {
+	if (fn?.(err)) return err;
+	if (err && typeof err === "object" && "cause" in err && err.cause !== void 0) return walk(err.cause, fn);
+	return fn ? null : err;
+}
+
+//#endregion
+export { BaseError };

package/dist/errors/index.cjs

@@ -0,0 +1,23 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_base = require('./base.cjs');
+const require_request = require('./request.cjs');
+const require_toError = require('./utils/toError.cjs');
+const require_assert = require('./assert.cjs');
+
+//#region src/errors/index.ts
+var errors_exports = /* @__PURE__ */ require_rolldown_runtime.__exportAll({
+	AssertionError: () => require_assert.AssertionError,
+	BaseError: () => require_base.BaseError,
+	HttpRequestError: () => require_request.HttpRequestError,
+	RpcRequestError: () => require_request.RpcRequestError,
+	TimeoutError: () => require_request.TimeoutError,
+	toError: () => require_toError.toError
+});
+
+//#endregion
+Object.defineProperty(exports, 'errors_exports', {
+  enumerable: true,
+  get: function () {
+    return errors_exports;
+  }
+});

package/dist/errors/index.d.cts

@@ -0,0 +1,11 @@
+import { BaseError, BaseErrorType } from "./base.cjs";
+import { HttpRequestError, HttpRequestErrorType, RpcRequestError, RpcRequestErrorType, TimeoutError, TimeoutErrorType } from "./request.cjs";
+import { AssertionError, AssertionErrorType } from "./assert.cjs";
+import { toError } from "./utils/toError.cjs";
+
+//#region src/errors/index.d.ts
+declare namespace index_d_exports {
+  export { AssertionError, AssertionErrorType, BaseError, BaseErrorType, HttpRequestError, HttpRequestErrorType, RpcRequestError, RpcRequestErrorType, TimeoutError, TimeoutErrorType, toError };
+}
+//#endregion
+export { index_d_exports };

package/dist/errors/index.d.ts

@@ -0,0 +1,11 @@
+import { BaseError, BaseErrorType } from "./base.js";
+import { HttpRequestError, HttpRequestErrorType, RpcRequestError, RpcRequestErrorType, TimeoutError, TimeoutErrorType } from "./request.js";
+import { AssertionError, AssertionErrorType } from "./assert.js";
+import { toError } from "./utils/toError.js";
+
+//#region src/errors/index.d.ts
+declare namespace index_d_exports {
+  export { AssertionError, AssertionErrorType, BaseError, BaseErrorType, HttpRequestError, HttpRequestErrorType, RpcRequestError, RpcRequestErrorType, TimeoutError, TimeoutErrorType, toError };
+}
+//#endregion
+export { index_d_exports };

package/dist/errors/index.js

@@ -0,0 +1,18 @@
+import { __exportAll } from "../_virtual/rolldown_runtime.js";
+import { BaseError } from "./base.js";
+import { HttpRequestError, RpcRequestError, TimeoutError } from "./request.js";
+import { toError } from "./utils/toError.js";
+import { AssertionError } from "./assert.js";
+
+//#region src/errors/index.ts
+var errors_exports = /* @__PURE__ */ __exportAll({
+	AssertionError: () => AssertionError,
+	BaseError: () => BaseError,
+	HttpRequestError: () => HttpRequestError,
+	RpcRequestError: () => RpcRequestError,
+	TimeoutError: () => TimeoutError,
+	toError: () => toError
+});
+
+//#endregion
+export { errors_exports };

package/dist/errors/request.cjs

@@ -0,0 +1,48 @@
+const require_serialize = require('../utils/serialize.cjs');
+const require_base = require('./base.cjs');
+
+//#region src/errors/request.ts
+var HttpRequestError = class extends require_base.BaseError {
+	constructor({ body, cause, details, headers, status, url }) {
+		super("HTTP request failed.", {
+			cause,
+			details,
+			metaMessages: [
+				status && `Status: ${status}`,
+				`URL: ${url}`,
+				body && `Request body: ${require_serialize.serialize(body)}`
+			].filter(Boolean),
+			name: "HttpRequestError"
+		});
+		this.body = body;
+		this.headers = headers;
+		this.status = status;
+		this.url = url;
+	}
+};
+var RpcRequestError = class extends require_base.BaseError {
+	constructor({ body, error, url }) {
+		super("RPC Request failed.", {
+			cause: error,
+			details: error.message,
+			metaMessages: [`URL: ${url}`, `Request body: ${require_serialize.serialize(body)}`],
+			name: "RpcRequestError"
+		});
+		this.code = error.code;
+		this.data = error.data;
+	}
+};
+var TimeoutError = class extends require_base.BaseError {
+	constructor({ body, url }) {
+		super("The request took too long to respond.", {
+			details: "The request timed out.",
+			metaMessages: [`URL: ${url}`, `Request body: ${require_serialize.serialize(body)}`],
+			name: "TimeoutError"
+		});
+	}
+};
+
+//#endregion
+exports.HttpRequestError = HttpRequestError;
+exports.RpcRequestError = RpcRequestError;
+exports.TimeoutError = TimeoutError;

package/dist/errors/request.d.cts

@@ -0,0 +1,61 @@
+import { BaseError } from "./base.cjs";
+
+//#region src/errors/request.d.ts
+type HttpRequestErrorType = HttpRequestError & {
+  name: "HttpRequestError";
+};
+declare class HttpRequestError extends BaseError {
+  body?: unknown | undefined;
+  headers?: Headers | undefined;
+  status?: number | undefined;
+  url: string;
+  constructor({
+    body,
+    cause,
+    details,
+    headers,
+    status,
+    url
+  }: {
+    body?: unknown | undefined;
+    cause?: Error | undefined;
+    details?: string | undefined;
+    headers?: Headers | undefined;
+    status?: number | undefined;
+    url: string;
+  });
+}
+type RpcRequestErrorType = RpcRequestError & {
+  name: "RpcRequestError";
+};
+declare class RpcRequestError extends BaseError {
+  code: number;
+  data?: unknown;
+  constructor({
+    body,
+    error,
+    url
+  }: {
+    body: unknown;
+    error: {
+      code: number;
+      data?: unknown;
+      message: string;
+    };
+    url: string;
+  });
+}
+type TimeoutErrorType = TimeoutError & {
+  name: "TimeoutError";
+};
+declare class TimeoutError extends BaseError {
+  constructor({
+    body,
+    url
+  }: {
+    body: unknown;
+    url: string;
+  });
+}
+//#endregion
+export { HttpRequestError, HttpRequestErrorType, RpcRequestError, RpcRequestErrorType, TimeoutError, TimeoutErrorType };