Return Mayan min amount (#59)

* return proper mayan error for amount too small

* fix error format

* code cleanup

* Update error.ts

* code cleanup

Author: 0xh3rman

apps/api/src/error.ts

@@ -0,0 +1,53 @@
+import { SwapperError } from "@gemwallet/types";
+import { Response } from "express";
+
+type ErrorResponse = { type: string; message: string | object };
+export type ProxyErrorResponse = { err: ErrorResponse } | { error: string };
+
+export function errorResponse(err: SwapperError, rawError: unknown, structured: boolean): ProxyErrorResponse {
+  const rawMessage = extractMessage(rawError);
+  if (!structured) {
+    return { error: rawMessage ?? ("message" in err ? err.message : undefined) ?? "Unknown error occurred" };
+  }
+  if (hasStringMessage(err)) {
+    return { err: { type: err.type, message: rawMessage ?? err.message ?? "" } };
+  }
+  const { type, ...rest } = err;
+  return { err: { type, message: rest } };
+}
+
+export function httpStatus(err: SwapperError): number {
+  switch (err.type) {
+    case "input_amount_error":
+    case "not_supported_chain":
+    case "not_supported_asset":
+    case "invalid_route":
+      return 400;
+    case "no_available_provider":
+    case "no_quote_available":
+      return 404;
+    case "compute_quote_error":
+    case "transaction_error":
+    default:
+      return 500;
+  }
+}
+
+function extractMessage(error: unknown): string | undefined {
+  if (error instanceof Error) return error.message;
+  if (typeof error === "string") return error;
+  return undefined;
+}
+
+function hasStringMessage(err: SwapperError): err is Extract<SwapperError, { message: string }> {
+  return err.type === "compute_quote_error" || err.type === "transaction_error";
+}
+
+export function sendErrorResponse(
+  res: Response,
+  swapperError: SwapperError,
+  rawError: unknown,
+  objectResponse: boolean
+) {
+  res.status(httpStatus(swapperError)).json(errorResponse(swapperError, rawError, objectResponse));
+}

apps/api/src/index.test.ts

@@ -1,5 +1,29 @@
-describe('API', () => {
-  it('should pass', () => {
-    expect(true).toBe(true);
+import { errorResponse, httpStatus } from "./error";
+import { SwapperError } from "@gemwallet/types";
+
+describe("httpStatus", () => {
+  it.each([
+    [400, { type: "input_amount_error", min_amount: "100" }],
+    [404, { type: "no_quote_available" }],
+    [500, { type: "compute_quote_error", message: "error" }],
+  ] as const)("returns %i for %s", (expected, err) => {
+    expect(httpStatus(err as SwapperError)).toBe(expected);
+  });
+});
+
+describe("errorResponse", () => {
+  it("wraps input_amount_error fields in message object", () => {
+    const result = errorResponse({ type: "input_amount_error", min_amount: "19620000" }, null, true);
+    expect(result).toEqual({ err: { type: "input_amount_error", message: { min_amount: "19620000" } } });
+  });
+
+  it("uses raw error message for compute_quote_error", () => {
+    const result = errorResponse({ type: "compute_quote_error", message: "" }, new Error("fail"), true);
+    expect(result).toEqual({ err: { type: "compute_quote_error", message: "fail" } });
+  });
+
+  it("returns plain error when not structured", () => {
+    const result = errorResponse({ type: "compute_quote_error", message: "" }, new Error("fail"), false);
+    expect(result).toEqual({ error: "fail" });
   });
 });

apps/api/src/index.ts

@@ -2,16 +2,17 @@ import path from "node:path";
 import dotenv from "dotenv";
 import express from "express";
 
-import { Quote, QuoteRequest, SwapperError, SwapQuoteData } from "@gemwallet/types";
-import { StonfiProvider, Protocol, MayanProvider, CetusAggregatorProvider, RelayProvider, OrcaWhirlpoolProvider, PanoraProvider } from "@gemwallet/swapper";
+import { Quote, QuoteRequest, SwapQuoteData } from "@gemwallet/types";
+import { StonfiProvider, Protocol, MayanProvider, CetusAggregatorProvider, RelayProvider, OrcaWhirlpoolProvider, PanoraProvider, SwapperException } from "@gemwallet/swapper";
 import versionInfo from "./version.json";
+import { errorResponse, sendErrorResponse, ProxyErrorResponse } from "./error";
 
 if (process.env.NODE_ENV !== "production") {
     const rootEnvPath = path.resolve(__dirname, "../../..", ".env");
     dotenv.config({ path: rootEnvPath, override: false });
 }
 
-type ProxyResponse<T> = { ok: T } | { err: SwapperError } | { error: string };
+type ProxyResponse<T> = { ok: T } | ProxyErrorResponse;
 type ProviderRequest = express.Request & { provider?: Protocol; objectResponse?: boolean };
 
 const app = express();
@@ -60,7 +61,10 @@ app.post("/:providerId/quote", withProvider, async (req: ProviderRequest, res) =
       console.error("Error fetching quote via POST:", error);
       console.debug("Request metadata:", { providerId: req.params.providerId, hasBody: Boolean(req.body) });
     }
-    res.status(500).json(errorResponse({ type: "compute_quote_error", message: "" }, error, objectResponse));
+    const swapperError = SwapperException.isSwapperException(error)
+      ? error.swapperError
+      : { type: "compute_quote_error" as const, message: "" };
+    sendErrorResponse(res, swapperError, error, objectResponse);
   }
 });
 
@@ -70,7 +74,6 @@ app.post("/:providerId/quote_data", withProvider, async (req: ProviderRequest, r
   const quote_request = req.body as Quote;
 
   try {
-
     const quote = await provider.get_quote_data(quote_request);
     if (objectResponse) {
       res.json({ ok: quote } satisfies ProxyResponse<SwapQuoteData>);
@@ -82,40 +85,22 @@ app.post("/:providerId/quote_data", withProvider, async (req: ProviderRequest, r
       console.error("Error fetching quote data:", error);
       console.debug("Quote metadata:", { providerId: req.params.providerId, hasQuote: Boolean(quote_request) });
     }
-    res.status(500).json(errorResponse({ type: "transaction_error", message: "" }, error, objectResponse));
+    const swapperError = SwapperException.isSwapperException(error)
+      ? error.swapperError
+      : { type: "transaction_error" as const, message: "" };
+    sendErrorResponse(res, swapperError, error, objectResponse);
   }
 });
 
 app.listen(PORT, () => {
   console.log(`swapper api is running on port ${PORT}.`);
 });
 
-function errorResponse(err: SwapperError, rawError: unknown, structured: boolean): ProxyResponse<never> {
-  const message = extractMessage(rawError) ?? ("message" in err ? err.message : undefined);
-  if (!structured) {
-    return { error: message ?? "Unknown error occurred" };
-  }
-  if (isMessageError(err)) {
-    return { err: { ...err, message: message ?? err.message ?? "" } };
-  }
-  return { err };
-}
-
 function parseVersion(raw: unknown): number {
   const num = typeof raw === "string" ? Number(raw) : Array.isArray(raw) ? Number(raw[0]) : NaN;
   return Number.isFinite(num) ? num : 0;
 }
 
-function extractMessage(error: unknown): string | undefined {
-  if (error instanceof Error) return error.message;
-  if (typeof error === "string") return error;
-  return undefined;
-}
-
-function isMessageError(err: SwapperError): err is Extract<SwapperError, { message: string }> {
-  return err.type === "compute_quote_error" || err.type === "transaction_error";
-}
-
 function withProvider(req: ProviderRequest, res: express.Response, next: express.NextFunction) {
   const providerId = req.params.providerId as string;
   const provider = providers[providerId];

packages/swapper/src/error.ts

@@ -0,0 +1,18 @@
+import { SwapperError } from "@gemwallet/types";
+
+export class SwapperException extends Error {
+    readonly swapperError: SwapperError;
+
+    constructor(swapperError: SwapperError) {
+        const message = "message" in swapperError && swapperError.message
+            ? swapperError.message
+            : swapperError.type;
+        super(message);
+        this.name = "SwapperException";
+        this.swapperError = swapperError;
+    }
+
+    static isSwapperException(error: unknown): error is SwapperException {
+        return error instanceof SwapperException;
+    }
+}

packages/swapper/src/index.ts

@@ -6,3 +6,4 @@ export * from './relay';
 export * from './referrer';
 export * from './orca';
 export * from './panora';
+export * from './error';

packages/swapper/src/mayan/error.ts

@@ -1,35 +1,41 @@
-export enum MayanErrorCode {
-    AmountTooSmall = "AMOUNT_TOO_SMALL",
-}
+import { SwapperException } from "../error";
+import { BigIntMath } from "../bigint_math";
 
-export type ErrorData = {
-    code?: MayanErrorCode | string;
-    message?: string;
-    data?: unknown;
-};
+export function toMayanError(error: unknown, decimals: number): Error {
+    if (SwapperException.isSwapperException(error)) {
+        return error;
+    }
 
-export function toMayanError(error: unknown): Error {
     const message = extractErrorMessage(error);
     if (message) {
+        const minAmount = extractMinAmount(message, decimals);
+        if (minAmount !== undefined) {
+            return new SwapperException({
+                type: "input_amount_error",
+                min_amount: minAmount,
+            });
+        }
         return new Error(message);
     }
+
     if (error instanceof Error) {
         return error;
     }
     return new Error("Unknown Mayan error");
 }
 
-function extractErrorMessage(error: unknown): string | undefined {
-    const payloadMessage = extractPayloadMessage(error);
-    if (payloadMessage) return payloadMessage;
-
-    if (error instanceof Error && error.message) return error.message;
-    return undefined;
+function extractMinAmount(message: string, decimals: number): string | null | undefined {
+    if (!message.includes("Amount too small")) {
+        return undefined;
+    }
+    const match = message.match(/~?(\d+(?:\.\d+)?)\s*\w+\)/);
+    return match ? BigIntMath.parseDecimals(match[1], decimals).toString() : null;
 }
 
-function extractPayloadMessage(error: unknown): string | undefined {
-    if (!error || typeof error !== "object") return undefined;
-
-    const obj = error as Record<string, unknown>;
-    return typeof obj.message === "string" ? obj.message : undefined;
+function extractErrorMessage(error: unknown): string | undefined {
+    if (error instanceof Error) return error.message;
+    if (error && typeof error === "object" && "message" in error) {
+        return typeof error.message === "string" ? error.message : undefined;
+    }
+    return undefined;
 }

packages/swapper/src/mayan/index.test.ts

@@ -1,8 +1,29 @@
-describe('Fetch Quote', () => {
-    it('Convert hex BigInt string to decimal', () => {
-        const hexValue = "0x2386f26fc10000";
-        const expectedDecimalValue = BigInt(hexValue).toString();
+import { toMayanError } from "./error";
+import { SwapperException } from "../error";
 
-        expect(expectedDecimalValue).toEqual("10000000000000000");
+describe('toMayanError', () => {
+    it('converts "Amount too small (min ~0.01962 SOL)" to input_amount_error', () => {
+        const result = toMayanError({ message: "Amount too small (min ~0.01962 SOL)" }, 9);
+
+        expect((result as SwapperException).swapperError).toEqual({
+            type: "input_amount_error",
+            min_amount: "19620000",
+        });
+    });
+
+    it('converts "Amount too small" without min to input_amount_error with null', () => {
+        const result = toMayanError({ message: "Amount too small" }, 9);
+
+        expect((result as SwapperException).swapperError).toEqual({
+            type: "input_amount_error",
+            min_amount: null,
+        });
+    });
+
+    it('returns generic Error for non-amount errors', () => {
+        const result = toMayanError({ message: "Network error" }, 9);
+
+        expect(result).not.toBeInstanceOf(SwapperException);
+        expect(result.message).toBe("Network error");
     });
 });

packages/swapper/src/mayan/index.ts

@@ -1,3 +1 @@
 export { MayanProvider } from "./provider";
-export { MayanErrorCode } from "./error";
-export type { ErrorData } from "./error";

packages/swapper/src/mayan/provider.ts

@@ -73,7 +73,7 @@ export class MayanProvider implements Protocol {
         try {
             quotes = await fetchQuote(params, options);
         } catch (error) {
-            throw toMayanError(error);
+            throw toMayanError(error, quoteRequest.from_asset.decimals);
         }
 
         if (!quotes || quotes.length === 0) {