amogus-sdk-internal-utils 0.35.2

package/dist/solverRelay/solverRelayHttpClient/index.js

@@ -0,0 +1,13 @@
+import { __exportAll } from "../../_virtual/rolldown_runtime.js";
+import { getStatus, publishIntent, publishIntents, quote } from "./apis.js";
+
+//#region src/solverRelay/solverRelayHttpClient/index.ts
+var solverRelayHttpClient_exports = /* @__PURE__ */ __exportAll({
+	getStatus: () => getStatus,
+	publishIntent: () => publishIntent,
+	publishIntents: () => publishIntents,
+	quote: () => quote
+});
+
+//#endregion
+export { solverRelayHttpClient_exports };

package/dist/solverRelay/solverRelayHttpClient/runtime.cjs

@@ -0,0 +1,60 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+const require_config = require('../../config.cjs');
+const require_request = require('../../utils/request.cjs');
+const require_handleRPCResponse = require('../../utils/handleRPCResponse.cjs');
+const require_retry = require('../../utils/retry.cjs');
+let valibot = require("valibot");
+valibot = require_rolldown_runtime.__toESM(valibot);
+
+//#region src/solverRelay/solverRelayHttpClient/runtime.ts
+const rpcResponseSchema = valibot.union([valibot.object({
+	jsonrpc: valibot.literal("2.0"),
+	id: valibot.string(),
+	result: valibot.unknown()
+}), valibot.object({
+	jsonrpc: valibot.literal("2.0"),
+	id: valibot.string(),
+	error: valibot.pipe(valibot.union([valibot.string(), valibot.object({
+		code: valibot.number(),
+		message: valibot.string()
+	})]), valibot.transform((v) => {
+		if (typeof v === "string") return {
+			code: -1,
+			data: null,
+			message: v
+		};
+		return {
+			code: v.code,
+			data: null,
+			message: v.message
+		};
+	}))
+})]);
+async function jsonRPCRequest(method, params, config$1) {
+	const baseURL = config$1?.baseURL ?? require_config.config.env.solverRelayBaseURL;
+	const url = new URL("rpc", baseURL);
+	url.searchParams.set("method", String(method));
+	const body = {
+		id: config$1?.requestId ?? "dontcare",
+		jsonrpc: "2.0",
+		method,
+		params: params !== void 0 ? [params] : void 0
+	};
+	const fetchOptions = {
+		...config$1?.fetchOptions,
+		method: "POST",
+		headers: new Headers(config$1?.fetchOptions?.headers)
+	};
+	if (config$1?.solverRelayApiKey) fetchOptions.headers.append("Authorization", `Bearer ${config$1.solverRelayApiKey}`);
+	return require_handleRPCResponse.handleRPCResponse(await require_request.request({
+		url,
+		body,
+		...config$1,
+		fetchOptions,
+		retryOptions: config$1?.retryOptions ?? require_retry.RETRY_CONFIGS.THIRTY_SECS_AGGRESSIVE,
+		logger: config$1?.logger
+	}), body, rpcResponseSchema);
+}
+
+//#endregion
+exports.jsonRPCRequest = jsonRPCRequest;

package/dist/solverRelay/solverRelayHttpClient/runtime.js

@@ -0,0 +1,58 @@
+import { config } from "../../config.js";
+import { request } from "../../utils/request.js";
+import { handleRPCResponse } from "../../utils/handleRPCResponse.js";
+import { RETRY_CONFIGS } from "../../utils/retry.js";
+import * as v from "valibot";
+
+//#region src/solverRelay/solverRelayHttpClient/runtime.ts
+const rpcResponseSchema = v.union([v.object({
+	jsonrpc: v.literal("2.0"),
+	id: v.string(),
+	result: v.unknown()
+}), v.object({
+	jsonrpc: v.literal("2.0"),
+	id: v.string(),
+	error: v.pipe(v.union([v.string(), v.object({
+		code: v.number(),
+		message: v.string()
+	})]), v.transform((v$1) => {
+		if (typeof v$1 === "string") return {
+			code: -1,
+			data: null,
+			message: v$1
+		};
+		return {
+			code: v$1.code,
+			data: null,
+			message: v$1.message
+		};
+	}))
+})]);
+async function jsonRPCRequest(method, params, config$1) {
+	const baseURL = config$1?.baseURL ?? config.env.solverRelayBaseURL;
+	const url = new URL("rpc", baseURL);
+	url.searchParams.set("method", String(method));
+	const body = {
+		id: config$1?.requestId ?? "dontcare",
+		jsonrpc: "2.0",
+		method,
+		params: params !== void 0 ? [params] : void 0
+	};
+	const fetchOptions = {
+		...config$1?.fetchOptions,
+		method: "POST",
+		headers: new Headers(config$1?.fetchOptions?.headers)
+	};
+	if (config$1?.solverRelayApiKey) fetchOptions.headers.append("Authorization", `Bearer ${config$1.solverRelayApiKey}`);
+	return handleRPCResponse(await request({
+		url,
+		body,
+		...config$1,
+		fetchOptions,
+		retryOptions: config$1?.retryOptions ?? RETRY_CONFIGS.THIRTY_SECS_AGGRESSIVE,
+		logger: config$1?.logger
+	}), body, rpcResponseSchema);
+}
+
+//#endregion
+export { jsonRPCRequest };

package/dist/solverRelay/solverRelayHttpClient/types.d.cts

@@ -0,0 +1,117 @@
+import { RpcRequestError } from "../../errors/request.cjs";
+import { ILogger } from "../../logger.cjs";
+import { RetryOptions } from "../../utils/retry.cjs";
+import { RequestErrorType } from "../../utils/request.cjs";
+import { MultiPayload } from "amogus-sdk-contract-types";
+
+//#region src/solverRelay/solverRelayHttpClient/types.d.ts
+type RequestConfig = {
+  requestId?: string | undefined;
+  timeout?: number | undefined;
+  fetchOptions?: Omit<RequestInit, "body"> | undefined;
+  baseURL?: string | undefined;
+  retryOptions?: RetryOptions;
+  logger?: ILogger;
+  solverRelayApiKey?: string;
+};
+type JSONRPCRequest<Method, Params$1> = {
+  id: string;
+  jsonrpc: "2.0";
+  method: Method;
+  params: Params$1[];
+};
+type JSONRPCResponse<Result> = {
+  id: string;
+  jsonrpc: "2.0";
+  result: Result;
+};
+type JSONRPCErrorType = RequestErrorType | RpcRequestError;
+type QuoteParamsBase = {
+  defuse_asset_identifier_in: string;
+  defuse_asset_identifier_out: string;
+  min_deadline_ms?: number;
+  wait_ms?: number;
+  min_wait_ms?: number;
+  max_wait_ms?: number;
+  trusted_metadata?: unknown;
+};
+type QuoteParamsExactIn = QuoteParamsBase & {
+  exact_amount_in: string;
+  exact_amount_out?: never;
+};
+type QuoteParamsExactOut = QuoteParamsBase & {
+  exact_amount_out: string;
+  exact_amount_in?: never;
+};
+type QuoteParams = QuoteParamsExactIn | QuoteParamsExactOut;
+type QuoteRequest = JSONRPCRequest<"quote", QuoteParams>;
+type Params<T extends JSONRPCRequest<unknown, unknown>> = T["params"][0];
+type FailedQuote = {
+  type: "INSUFFICIENT_AMOUNT";
+  min_amount: string;
+};
+type Quote = {
+  quote_hash: string;
+  defuse_asset_identifier_in: string;
+  defuse_asset_identifier_out: string;
+  amount_in: string;
+  amount_out: string;
+  expiration_time: string;
+};
+type QuoteResponse = JSONRPCResponse<null | Array<Quote | FailedQuote>>;
+type PublishIntentRequest = JSONRPCRequest<"publish_intent", {
+  quote_hashes: string[];
+  signed_data: MultiPayload;
+}>;
+type PublishIntentResponse = JSONRPCResponse<PublishIntentResponseSuccess | PublishIntentResponseFailure>;
+type PublishIntentResponseSuccess = {
+  intent_hash: string;
+  status: "OK";
+};
+type PublishIntentResponseFailure = {
+  intent_hash: string;
+  status: "FAILED";
+  reason: string | "expired" | "internal";
+};
+type PublishIntentsRequest = JSONRPCRequest<"publish_intents", {
+  quote_hashes: string[];
+  signed_datas: MultiPayload[];
+}>;
+type PublishIntentsResponse = JSONRPCResponse<PublishIntentsResponseSuccess | PublishIntentsResponseFailure>;
+type PublishIntentsResponseSuccess = {
+  intent_hashes: string[];
+  status: "OK";
+};
+type PublishIntentsResponseFailure = {
+  intent_hashes: string[];
+  status: "FAILED";
+  reason: string | "expired" | "internal";
+};
+type GetStatusRequest = JSONRPCRequest<"get_status", {
+  intent_hash: string;
+}>;
+type GetStatusResponse = JSONRPCResponse<{
+  status: "PENDING";
+  intent_hash: string;
+} | {
+  status: "TX_BROADCASTED";
+  intent_hash: string;
+  data: {
+    hash: string;
+  };
+} | {
+  status: "SETTLED";
+  intent_hash: string;
+  data: {
+    hash: string;
+  };
+} | {
+  status: "NOT_FOUND_OR_NOT_VALID";
+  intent_hash: string;
+  status_details?: "FAILED";
+  data?: {
+    hash: string;
+  };
+}>;
+//#endregion
+export { FailedQuote, GetStatusRequest, GetStatusResponse, JSONRPCErrorType, JSONRPCRequest, JSONRPCResponse, Params, PublishIntentRequest, PublishIntentResponse, PublishIntentResponseFailure, PublishIntentResponseSuccess, PublishIntentsRequest, PublishIntentsResponse, PublishIntentsResponseFailure, PublishIntentsResponseSuccess, Quote, QuoteRequest, QuoteResponse, RequestConfig };

package/dist/solverRelay/solverRelayHttpClient/types.d.ts

@@ -0,0 +1,117 @@
+import { RpcRequestError } from "../../errors/request.js";
+import { ILogger } from "../../logger.js";
+import { RetryOptions } from "../../utils/retry.js";
+import { RequestErrorType } from "../../utils/request.js";
+import { MultiPayload } from "amogus-sdk-contract-types";
+
+//#region src/solverRelay/solverRelayHttpClient/types.d.ts
+type RequestConfig = {
+  requestId?: string | undefined;
+  timeout?: number | undefined;
+  fetchOptions?: Omit<RequestInit, "body"> | undefined;
+  baseURL?: string | undefined;
+  retryOptions?: RetryOptions;
+  logger?: ILogger;
+  solverRelayApiKey?: string;
+};
+type JSONRPCRequest<Method, Params$1> = {
+  id: string;
+  jsonrpc: "2.0";
+  method: Method;
+  params: Params$1[];
+};
+type JSONRPCResponse<Result> = {
+  id: string;
+  jsonrpc: "2.0";
+  result: Result;
+};
+type JSONRPCErrorType = RequestErrorType | RpcRequestError;
+type QuoteParamsBase = {
+  defuse_asset_identifier_in: string;
+  defuse_asset_identifier_out: string;
+  min_deadline_ms?: number;
+  wait_ms?: number;
+  min_wait_ms?: number;
+  max_wait_ms?: number;
+  trusted_metadata?: unknown;
+};
+type QuoteParamsExactIn = QuoteParamsBase & {
+  exact_amount_in: string;
+  exact_amount_out?: never;
+};
+type QuoteParamsExactOut = QuoteParamsBase & {
+  exact_amount_out: string;
+  exact_amount_in?: never;
+};
+type QuoteParams = QuoteParamsExactIn | QuoteParamsExactOut;
+type QuoteRequest = JSONRPCRequest<"quote", QuoteParams>;
+type Params<T extends JSONRPCRequest<unknown, unknown>> = T["params"][0];
+type FailedQuote = {
+  type: "INSUFFICIENT_AMOUNT";
+  min_amount: string;
+};
+type Quote = {
+  quote_hash: string;
+  defuse_asset_identifier_in: string;
+  defuse_asset_identifier_out: string;
+  amount_in: string;
+  amount_out: string;
+  expiration_time: string;
+};
+type QuoteResponse = JSONRPCResponse<null | Array<Quote | FailedQuote>>;
+type PublishIntentRequest = JSONRPCRequest<"publish_intent", {
+  quote_hashes: string[];
+  signed_data: MultiPayload;
+}>;
+type PublishIntentResponse = JSONRPCResponse<PublishIntentResponseSuccess | PublishIntentResponseFailure>;
+type PublishIntentResponseSuccess = {
+  intent_hash: string;
+  status: "OK";
+};
+type PublishIntentResponseFailure = {
+  intent_hash: string;
+  status: "FAILED";
+  reason: string | "expired" | "internal";
+};
+type PublishIntentsRequest = JSONRPCRequest<"publish_intents", {
+  quote_hashes: string[];
+  signed_datas: MultiPayload[];
+}>;
+type PublishIntentsResponse = JSONRPCResponse<PublishIntentsResponseSuccess | PublishIntentsResponseFailure>;
+type PublishIntentsResponseSuccess = {
+  intent_hashes: string[];
+  status: "OK";
+};
+type PublishIntentsResponseFailure = {
+  intent_hashes: string[];
+  status: "FAILED";
+  reason: string | "expired" | "internal";
+};
+type GetStatusRequest = JSONRPCRequest<"get_status", {
+  intent_hash: string;
+}>;
+type GetStatusResponse = JSONRPCResponse<{
+  status: "PENDING";
+  intent_hash: string;
+} | {
+  status: "TX_BROADCASTED";
+  intent_hash: string;
+  data: {
+    hash: string;
+  };
+} | {
+  status: "SETTLED";
+  intent_hash: string;
+  data: {
+    hash: string;
+  };
+} | {
+  status: "NOT_FOUND_OR_NOT_VALID";
+  intent_hash: string;
+  status_details?: "FAILED";
+  data?: {
+    hash: string;
+  };
+}>;
+//#endregion
+export { FailedQuote, GetStatusRequest, GetStatusResponse, JSONRPCErrorType, JSONRPCRequest, JSONRPCResponse, Params, PublishIntentRequest, PublishIntentResponse, PublishIntentResponseFailure, PublishIntentResponseSuccess, PublishIntentsRequest, PublishIntentsResponse, PublishIntentsResponseFailure, PublishIntentsResponseSuccess, Quote, QuoteRequest, QuoteResponse, RequestConfig };

package/dist/solverRelay/utils/parseFailedPublishError.cjs

@@ -0,0 +1,64 @@
+const require_serialize = require('../../utils/serialize.cjs');
+const require_base = require('../../errors/base.cjs');
+const require_assert = require('../../utils/assert.cjs');
+
+//#region src/solverRelay/utils/parseFailedPublishError.ts
+var RelayPublishError = class extends require_base.BaseError {
+	constructor({ cause, metaMessages, name, publishParams, reason }) {
+		super("Failed to publish intent.", {
+			details: reason,
+			metaMessages: [...metaMessages ?? [], `Publish params: ${require_serialize.serialize(publishParams)}`],
+			name,
+			cause
+		});
+		this.publishParams = publishParams;
+	}
+};
+var RelayPublishRejectedError = class extends RelayPublishError {
+	constructor({ reason, code, publishParams }) {
+		super({
+			reason,
+			metaMessages: [`Code: ${code}`],
+			name: "RelayPublishRejectedError",
+			publishParams
+		});
+		this.name = "RelayPublishRejectedError";
+		this.code = code;
+	}
+};
+var RelayPublishResultUnknownError = class extends RelayPublishError {
+	constructor({ reason, publishParams, cause }) {
+		super({
+			reason,
+			name: "RelayPublishResultUnknownError",
+			publishParams,
+			cause
+		});
+		this.name = "RelayPublishResultUnknownError";
+	}
+};
+function toRelayPublishError(publishParams, response) {
+	require_assert.assert(response.status === "FAILED", "Expected response to be failed");
+	return new RelayPublishRejectedError({
+		reason: response.reason,
+		code: parseFailedPublishReason(response),
+		publishParams
+	});
+}
+function parseFailedPublishReason(response) {
+	require_assert.assert(response.status === "FAILED", "Expected response to be failed");
+	if (response.reason === "expired" || response.reason.includes("deadline has expired")) return "SIGNATURE_EXPIRED";
+	if (response.reason === "internal") return "INTERNAL_ERROR";
+	if (response.reason.includes("invalid signature")) return "SIGNATURE_INVALID";
+	if (response.reason.includes("nonce was already used")) return "NONCE_USED";
+	if (response.reason.includes("insufficient balance or overflow")) return "INSUFFICIENT_BALANCE";
+	if (response.reason.includes("public key doesn't exist")) return "PUBLIC_KEY_NOT_EXIST";
+	if (response.reason.includes("invalid salt")) return "INVALID_SALT";
+	return "UNKNOWN_ERROR";
+}
+
+//#endregion
+exports.RelayPublishError = RelayPublishError;
+exports.RelayPublishRejectedError = RelayPublishRejectedError;
+exports.RelayPublishResultUnknownError = RelayPublishResultUnknownError;
+exports.toRelayPublishError = toRelayPublishError;

package/dist/solverRelay/utils/parseFailedPublishError.d.cts

@@ -0,0 +1,56 @@
+import { BaseError } from "../../errors/base.cjs";
+import { publishIntent, publishIntents } from "../solverRelayHttpClient/apis.cjs";
+
+//#region src/solverRelay/utils/parseFailedPublishError.d.ts
+type PublishErrorCode = "SIGNATURE_EXPIRED" | "INTERNAL_ERROR" | "SIGNATURE_INVALID" | "NONCE_USED" | "INSUFFICIENT_BALANCE" | "PUBLIC_KEY_NOT_EXIST" | "UNKNOWN_ERROR" | "INVALID_SALT";
+type PublishParams = Parameters<typeof publishIntents>[0] | Parameters<typeof publishIntent>[0];
+type RelayPublishRejectedErrorType = RelayPublishRejectedError & {
+  name: "RelayPublishRejectedError";
+};
+type RelayPublishResultUnknownErrorType = RelayPublishResultUnknownError & {
+  name: "RelayPublishResultUnknownError";
+};
+type RelayPublishErrorType = RelayPublishRejectedErrorType | RelayPublishResultUnknownErrorType;
+declare abstract class RelayPublishError extends BaseError {
+  publishParams: PublishParams;
+  protected constructor({
+    cause,
+    metaMessages,
+    name,
+    publishParams,
+    reason
+  }: {
+    cause?: unknown;
+    metaMessages?: string[];
+    name: "RelayPublishRejectedError" | "RelayPublishResultUnknownError";
+    publishParams: PublishParams;
+    reason: string;
+  });
+}
+declare class RelayPublishRejectedError extends RelayPublishError {
+  name: "RelayPublishRejectedError";
+  code: PublishErrorCode;
+  constructor({
+    reason,
+    code,
+    publishParams
+  }: {
+    reason: string;
+    code: PublishErrorCode;
+    publishParams: PublishParams;
+  });
+}
+declare class RelayPublishResultUnknownError extends RelayPublishError {
+  name: "RelayPublishResultUnknownError";
+  constructor({
+    reason,
+    publishParams,
+    cause
+  }: {
+    reason: string;
+    publishParams: PublishParams;
+    cause?: unknown;
+  });
+}
+//#endregion
+export { RelayPublishError, RelayPublishErrorType, RelayPublishRejectedError, RelayPublishRejectedErrorType, RelayPublishResultUnknownError, RelayPublishResultUnknownErrorType };

package/dist/solverRelay/utils/parseFailedPublishError.d.ts

@@ -0,0 +1,57 @@
+import { BaseError } from "../../errors/base.js";
+import { publishIntent, publishIntents } from "../solverRelayHttpClient/apis.js";
+import "../solverRelayHttpClient/index.js";
+
+//#region src/solverRelay/utils/parseFailedPublishError.d.ts
+type PublishErrorCode = "SIGNATURE_EXPIRED" | "INTERNAL_ERROR" | "SIGNATURE_INVALID" | "NONCE_USED" | "INSUFFICIENT_BALANCE" | "PUBLIC_KEY_NOT_EXIST" | "UNKNOWN_ERROR" | "INVALID_SALT";
+type PublishParams = Parameters<typeof publishIntents>[0] | Parameters<typeof publishIntent>[0];
+type RelayPublishRejectedErrorType = RelayPublishRejectedError & {
+  name: "RelayPublishRejectedError";
+};
+type RelayPublishResultUnknownErrorType = RelayPublishResultUnknownError & {
+  name: "RelayPublishResultUnknownError";
+};
+type RelayPublishErrorType = RelayPublishRejectedErrorType | RelayPublishResultUnknownErrorType;
+declare abstract class RelayPublishError extends BaseError {
+  publishParams: PublishParams;
+  protected constructor({
+    cause,
+    metaMessages,
+    name,
+    publishParams,
+    reason
+  }: {
+    cause?: unknown;
+    metaMessages?: string[];
+    name: "RelayPublishRejectedError" | "RelayPublishResultUnknownError";
+    publishParams: PublishParams;
+    reason: string;
+  });
+}
+declare class RelayPublishRejectedError extends RelayPublishError {
+  name: "RelayPublishRejectedError";
+  code: PublishErrorCode;
+  constructor({
+    reason,
+    code,
+    publishParams
+  }: {
+    reason: string;
+    code: PublishErrorCode;
+    publishParams: PublishParams;
+  });
+}
+declare class RelayPublishResultUnknownError extends RelayPublishError {
+  name: "RelayPublishResultUnknownError";
+  constructor({
+    reason,
+    publishParams,
+    cause
+  }: {
+    reason: string;
+    publishParams: PublishParams;
+    cause?: unknown;
+  });
+}
+//#endregion
+export { RelayPublishError, RelayPublishErrorType, RelayPublishRejectedError, RelayPublishRejectedErrorType, RelayPublishResultUnknownError, RelayPublishResultUnknownErrorType };

package/dist/solverRelay/utils/parseFailedPublishError.js

@@ -0,0 +1,61 @@
+import { serialize } from "../../utils/serialize.js";
+import { BaseError } from "../../errors/base.js";
+import { assert } from "../../utils/assert.js";
+
+//#region src/solverRelay/utils/parseFailedPublishError.ts
+var RelayPublishError = class extends BaseError {
+	constructor({ cause, metaMessages, name, publishParams, reason }) {
+		super("Failed to publish intent.", {
+			details: reason,
+			metaMessages: [...metaMessages ?? [], `Publish params: ${serialize(publishParams)}`],
+			name,
+			cause
+		});
+		this.publishParams = publishParams;
+	}
+};
+var RelayPublishRejectedError = class extends RelayPublishError {
+	constructor({ reason, code, publishParams }) {
+		super({
+			reason,
+			metaMessages: [`Code: ${code}`],
+			name: "RelayPublishRejectedError",
+			publishParams
+		});
+		this.name = "RelayPublishRejectedError";
+		this.code = code;
+	}
+};
+var RelayPublishResultUnknownError = class extends RelayPublishError {
+	constructor({ reason, publishParams, cause }) {
+		super({
+			reason,
+			name: "RelayPublishResultUnknownError",
+			publishParams,
+			cause
+		});
+		this.name = "RelayPublishResultUnknownError";
+	}
+};
+function toRelayPublishError(publishParams, response) {
+	assert(response.status === "FAILED", "Expected response to be failed");
+	return new RelayPublishRejectedError({
+		reason: response.reason,
+		code: parseFailedPublishReason(response),
+		publishParams
+	});
+}
+function parseFailedPublishReason(response) {
+	assert(response.status === "FAILED", "Expected response to be failed");
+	if (response.reason === "expired" || response.reason.includes("deadline has expired")) return "SIGNATURE_EXPIRED";
+	if (response.reason === "internal") return "INTERNAL_ERROR";
+	if (response.reason.includes("invalid signature")) return "SIGNATURE_INVALID";
+	if (response.reason.includes("nonce was already used")) return "NONCE_USED";
+	if (response.reason.includes("insufficient balance or overflow")) return "INSUFFICIENT_BALANCE";
+	if (response.reason.includes("public key doesn't exist")) return "PUBLIC_KEY_NOT_EXIST";
+	if (response.reason.includes("invalid salt")) return "INVALID_SALT";
+	return "UNKNOWN_ERROR";
+}
+
+//#endregion
+export { RelayPublishError, RelayPublishRejectedError, RelayPublishResultUnknownError, toRelayPublishError };

package/dist/solverRelay/utils/quoteWithLog.cjs

@@ -0,0 +1,21 @@
+const require_apis = require('../solverRelayHttpClient/apis.cjs');
+
+//#region src/solverRelay/utils/quoteWithLog.ts
+async function quoteWithLog(params, { logBalanceSufficient, ...config }) {
+	const requestId = crypto.randomUUID();
+	const result = await require_apis.quote(params, {
+		...config,
+		requestId
+	});
+	if (result == null) {
+		config.logger?.warn("quote: No liquidity available", { quoteParams: params });
+		if (logBalanceSufficient && (params.wait_ms == null || params.wait_ms > 2500)) config.logger?.warn("quote: No liquidity available for user with sufficient balance", {
+			quoteParams: params,
+			quoteRequestInfo: { requestId }
+		});
+	}
+	return result;
+}
+
+//#endregion
+exports.quoteWithLog = quoteWithLog;

package/dist/solverRelay/utils/quoteWithLog.d.cts

@@ -0,0 +1,12 @@
+import { FailedQuote, Quote } from "../solverRelayHttpClient/types.cjs";
+import { quote } from "../solverRelayHttpClient/apis.cjs";
+
+//#region src/solverRelay/utils/quoteWithLog.d.ts
+declare function quoteWithLog(params: Parameters<typeof quote>[0], {
+  logBalanceSufficient,
+  ...config
+}: {
+  logBalanceSufficient: boolean;
+} & Parameters<typeof quote>[1]): Promise<(Quote | FailedQuote)[] | null>;
+//#endregion
+export { quoteWithLog };

package/dist/solverRelay/utils/quoteWithLog.d.ts

@@ -0,0 +1,14 @@
+import { FailedQuote, Quote } from "../solverRelayHttpClient/types.js";
+import { quote } from "../solverRelayHttpClient/apis.js";
+import "../solverRelayHttpClient/index.js";
+import "../index.js";
+
+//#region src/solverRelay/utils/quoteWithLog.d.ts
+declare function quoteWithLog(params: Parameters<typeof quote>[0], {
+  logBalanceSufficient,
+  ...config
+}: {
+  logBalanceSufficient: boolean;
+} & Parameters<typeof quote>[1]): Promise<(Quote | FailedQuote)[] | null>;
+//#endregion
+export { quoteWithLog };

package/dist/solverRelay/utils/quoteWithLog.js

@@ -0,0 +1,21 @@
+import { quote } from "../solverRelayHttpClient/apis.js";
+
+//#region src/solverRelay/utils/quoteWithLog.ts
+async function quoteWithLog(params, { logBalanceSufficient, ...config }) {
+	const requestId = crypto.randomUUID();
+	const result = await quote(params, {
+		...config,
+		requestId
+	});
+	if (result == null) {
+		config.logger?.warn("quote: No liquidity available", { quoteParams: params });
+		if (logBalanceSufficient && (params.wait_ms == null || params.wait_ms > 2500)) config.logger?.warn("quote: No liquidity available for user with sufficient balance", {
+			quoteParams: params,
+			quoteRequestInfo: { requestId }
+		});
+	}
+	return result;
+}
+
+//#endregion
+export { quoteWithLog };