@rhea-finance/cross-chain-aggregation-dex 1.0.6 → 2.0.0

package/dist/index.js

@@ -1,641 +1,2437 @@
 'use strict';
 
-var Big = require('big.js');
+var zod = require('zod');
 
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+// src/core/errors.ts
+var SwapSdkError = class extends Error {
+  constructor(code, stage, message, options = {}) {
+    super(message);
+    this.code = code;
+    this.stage = stage;
+    this.options = options;
+    this.name = "SwapSdkError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+  get retryable() {
+    return this.options.retryable ?? false;
+  }
+  get cause() {
+    return this.options.cause;
+  }
+  get details() {
+    return this.options.details;
+  }
+};
+function asSwapSdkError(error, stage) {
+  if (error instanceof SwapSdkError) return error;
+  const message = error instanceof Error ? error.message : String(error);
+  return new SwapSdkError("API_ERROR", stage, message, { cause: error });
+}
+
+// src/api/ApiClient.ts
+var DEFAULT_RETRY = {
+  maxRetries: 2,
+  baseDelayMs: 250,
+  maxDelayMs: 2e3,
+  jitter: true
+};
+var ApiClient = class {
+  constructor(config) {
+    this.config = config;
+    this.baseUrl = config.baseUrl.replace(/\/$/, "");
+    const fetchImpl = config.fetch ?? globalThis.fetch;
+    if (typeof fetchImpl !== "function") {
+      throw new SwapSdkError(
+        "INVALID_REQUEST",
+        "quote",
+        "Fetch is unavailable; inject fetch when using Node.js 16"
+      );
+    }
+    this.fetchImpl = fetchImpl.bind(globalThis);
+  }
+  quote(body, options = {}) {
+    return this.request("/api/swap/quote", "quote", {
+      ...options,
+      method: "POST",
+      body,
+      retryableOperation: true
+    });
+  }
+  build(body, options = {}) {
+    return this.request("/api/swap/swap", "build", {
+      ...options,
+      method: "POST",
+      body
+    });
+  }
+  submitOrder(body, options = {}) {
+    return this.request("/api/swap/order-submit", "submit", {
+      ...options,
+      method: "POST",
+      body
+    });
+  }
+  getOrderStatus(params, options = {}) {
+    return this.request("/api/swap/order-status", "status", {
+      ...options,
+      method: "GET",
+      retryableOperation: true,
+      query: {
+        orderId: params.orderId,
+        router: params.router,
+        chainId: params.chainId
+      }
+    });
+  }
+  report(body, options = {}) {
+    return this.request("/api/swap/report", "report", {
+      ...options,
+      method: "POST",
+      body
+    });
+  }
+  getHistory(params, options = {}) {
+    return this.request("/api/swap/history", "history", {
+      ...options,
+      method: "GET",
+      retryableOperation: true,
+      query: {
+        sender: params.sender,
+        pageNumber: params.pageNumber,
+        pageSize: params.pageSize
+      }
+    });
+  }
+  async request(path, stage, options) {
+    const url = this.buildUrl(path, options.query);
+    const headers = await this.buildHeaders(options.idempotencyKey);
+    const retry = this.retryConfig();
+    let attempt = 1;
+    for (; ; ) {
+      this.log({
+        level: "debug",
+        event: "api.request",
+        path,
+        stage,
+        attempt
+      });
+      try {
+        return await this.requestOnce(url, path, stage, options, headers, attempt);
+      } catch (error) {
+        const sdkError = error instanceof SwapSdkError ? error : new SwapSdkError("HTTP_ERROR", stage, "Network request failed", {
+          cause: error,
+          retryable: true
+        });
+        const canRetry = options.retryableOperation === true && sdkError.retryable && sdkError.code !== "REQUEST_ABORTED" && attempt <= retry.maxRetries;
+        if (!canRetry) throw sdkError;
+        this.log({
+          level: "warn",
+          event: "api.retry",
+          path,
+          stage,
+          attempt,
+          code: sdkError.code
+        });
+        await waitForRetry(this.retryDelay(attempt, retry), options.signal, stage);
+        attempt += 1;
+      }
+    }
+  }
+  async requestOnce(url, path, stage, options, headers, attempt) {
+    if (options.signal?.aborted) {
+      throw new SwapSdkError("REQUEST_ABORTED", stage, "Request aborted", {
+        cause: options.signal.reason
+      });
+    }
+    const controller = new AbortController();
+    const timeoutMs = this.config.timeoutMs ?? 15e3;
+    let timedOut = false;
+    const startedAt = Date.now();
+    const abortFromCaller = () => controller.abort(options.signal?.reason);
+    if (options.signal?.aborted) abortFromCaller();
+    options.signal?.addEventListener("abort", abortFromCaller, { once: true });
+    const timeout = setTimeout(() => {
+      timedOut = true;
+      controller.abort();
+    }, timeoutMs);
+    try {
+      const response = await this.fetchImpl(url, {
+        method: options.method,
+        headers,
+        body: options.body === void 0 ? void 0 : JSON.stringify(options.body),
+        signal: controller.signal
+      });
+      if (controller.signal.aborted) {
+        throw new SwapSdkError(
+          timedOut ? "REQUEST_TIMEOUT" : "REQUEST_ABORTED",
+          stage,
+          timedOut ? `Request timed out after ${timeoutMs}ms` : "Request aborted",
+          { retryable: timedOut }
+        );
+      }
+      this.log({
+        level: "debug",
+        event: "api.response",
+        path,
+        stage,
+        attempt,
+        status: response.status,
+        durationMs: Date.now() - startedAt
+      });
+      const text = await response.text();
+      const parsed = this.parseResponse(text, response.status, stage);
+      if (!response.ok) {
+        const message = this.readMessage(parsed) || `HTTP ${response.status}`;
+        if (response.status === 401 || response.status === 403) {
+          throw new SwapSdkError("AUTH_FAILED", stage, message);
+        }
+        if (response.status === 429) {
+          throw new SwapSdkError("RATE_LIMITED", stage, message, {
+            retryable: true
+          });
+        }
+        throw new SwapSdkError("HTTP_ERROR", stage, message, {
+          retryable: response.status >= 500,
+          details: { status: response.status }
+        });
+      }
+      if (!this.isEnvelope(parsed)) {
+        throw new SwapSdkError(
+          "INVALID_API_RESPONSE",
+          stage,
+          "Invalid unified swap API response envelope"
+        );
+      }
+      if (parsed.code !== 0) {
+        throw new SwapSdkError(
+          "API_ERROR",
+          stage,
+          parsed.msg || `Service returned code ${parsed.code}`,
+          { details: { apiCode: parsed.code } }
+        );
+      }
+      return parsed.data;
+    } catch (error) {
+      if (error instanceof SwapSdkError) throw error;
+      if (controller.signal.aborted) {
+        throw new SwapSdkError(
+          timedOut ? "REQUEST_TIMEOUT" : "REQUEST_ABORTED",
+          stage,
+          timedOut ? `Request timed out after ${timeoutMs}ms` : "Request aborted",
+          { cause: error, retryable: timedOut }
+        );
+      }
+      const details = networkFailureDetails(
+        error,
+        options.method,
+        path,
+        attempt
+      );
+      console.error("SDK network request failed", {
+        ...details,
+        stage
+      });
+      throw new SwapSdkError(
+        "HTTP_ERROR",
+        stage,
+        `Network request failed: ${details.causeName}: ${details.causeMessage}`,
+        {
+          cause: error,
+          retryable: true,
+          details
+        }
+      );
+    } finally {
+      clearTimeout(timeout);
+      options.signal?.removeEventListener("abort", abortFromCaller);
+    }
+  }
+  buildUrl(path, query) {
+    if (!query) return `${this.baseUrl}${path}`;
+    const search = new URLSearchParams();
+    for (const [key, value] of Object.entries(query)) {
+      if (value === void 0 || value === null) continue;
+      search.set(key, String(value));
+    }
+    const suffix = search.toString();
+    return suffix ? `${this.baseUrl}${path}?${suffix}` : `${this.baseUrl}${path}`;
+  }
+  async buildHeaders(idempotencyKey) {
+    const configured = typeof this.config.headers === "function" ? await this.config.headers() : this.config.headers ?? {};
+    const token = this.config.getAccessToken ? await this.config.getAccessToken() : this.config.apiKey;
+    return {
+      "Content-Type": "application/json",
+      ...token ? { Authorization: `Bearer ${token}` } : {},
+      ...idempotencyKey ? { "Idempotency-Key": idempotencyKey } : {},
+      ...configured
+    };
+  }
+  retryConfig() {
+    const configured = { ...DEFAULT_RETRY, ...this.config.retry };
+    if (!Number.isSafeInteger(configured.maxRetries) || configured.maxRetries < 0 || !Number.isFinite(configured.baseDelayMs) || configured.baseDelayMs < 0 || !Number.isFinite(configured.maxDelayMs) || configured.maxDelayMs < configured.baseDelayMs) {
+      throw new SwapSdkError(
+        "INVALID_REQUEST",
+        "quote",
+        "Invalid retry configuration"
+      );
+    }
+    return configured;
+  }
+  retryDelay(attempt, retry) {
+    const exponential = Math.min(
+      retry.maxDelayMs,
+      retry.baseDelayMs * 2 ** (attempt - 1)
+    );
+    return retry.jitter ? Math.min(retry.maxDelayMs, exponential * (0.5 + Math.random())) : exponential;
+  }
+  log(entry) {
+    try {
+      this.config.logger?.log(entry);
+    } catch {
+    }
+  }
+  parseResponse(text, status, stage) {
+    try {
+      return text ? JSON.parse(text) : {};
+    } catch (error) {
+      throw new SwapSdkError(
+        status >= 400 ? "HTTP_ERROR" : "INVALID_API_RESPONSE",
+        stage,
+        status >= 400 ? `HTTP ${status}` : "Response is not valid JSON",
+        { cause: error, retryable: status >= 500 }
+      );
+    }
+  }
+  isEnvelope(value) {
+    return typeof value === "object" && value !== null && "code" in value && typeof value.code === "number" && "msg" in value && typeof value.msg === "string" && "data" in value;
+  }
+  readMessage(value) {
+    if (typeof value !== "object" || value === null || !("msg" in value)) {
+      return void 0;
+    }
+    return typeof value.msg === "string" && value.msg.trim() ? value.msg.trim() : void 0;
+  }
+};
+function networkFailureDetails(error, method, path, attempt) {
+  const causeName = error instanceof Error && error.name.trim() ? error.name.trim() : "Error";
+  const rawMessage = error instanceof Error && error.message.trim() ? error.message.trim() : String(error);
+  const causeMessage = rawMessage.replace(
+    /\b(https?:\/\/[^\s?#]+)\?[^\s#]*/gi,
+    "$1?[redacted]"
+  );
+  return {
+    method,
+    path,
+    attempt,
+    causeName,
+    causeMessage
+  };
+}
+function waitForRetry(delayMs, signal, stage) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(
+        new SwapSdkError("REQUEST_ABORTED", stage, "Request aborted", {
+          cause: signal.reason
+        })
+      );
+      return;
+    }
+    const onAbort = () => {
+      clearTimeout(timeout);
+      reject(
+        new SwapSdkError("REQUEST_ABORTED", stage, "Request aborted", {
+          cause: signal?.reason
+        })
+      );
+    };
+    const timeout = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, delayMs);
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+
+// src/core/lifecycle.ts
+var ORDER_STATUS_MAP = {
+  PENDING: "pending",
+  CREATED: "pending",
+  PROCESSING: "processing",
+  IN_PROGRESS: "processing",
+  SUCCESS: "completed",
+  COMPLETED: "completed",
+  FILLED: "completed",
+  FAILED: "failed",
+  REFUNDED: "refunded",
+  EXPIRED: "expired"
+};
+function normalizeOrderStatus(raw) {
+  const value = raw.status ?? raw.state;
+  if (typeof value !== "string") return "unknown";
+  return ORDER_STATUS_MAP[value.trim().toUpperCase()] ?? "unknown";
+}
+
+// src/core/registry.ts
+var ExecutorRegistry = class {
+  constructor(executors = []) {
+    this.executors = /* @__PURE__ */ new Map();
+    for (const executor of executors) this.register(executor);
+  }
+  register(executor, allowOverride = false) {
+    for (const kind of executor.kinds) {
+      if (!allowOverride && this.executors.has(kind)) {
+        throw new SwapSdkError(
+          "INVALID_REQUEST",
+          "build",
+          `Executor already registered for ${kind}`
+        );
+      }
+      this.executors.set(kind, executor);
+    }
+  }
+  get(kind) {
+    const executor = this.executors.get(kind);
+    if (!executor) {
+      throw new SwapSdkError(
+        "EXECUTOR_NOT_FOUND",
+        "sign",
+        `No executor registered for ${kind}`
+      );
+    }
+    return executor;
+  }
+  getSigner(chain, requireSignMessage = false) {
+    const executor = Array.from(new Set(this.executors.values())).find(
+      (candidate) => candidate.signerChain === chain
+    );
+    if (!executor) {
+      throw new SwapSdkError(
+        "EXECUTOR_NOT_FOUND",
+        "sign",
+        `No executor registered for signer chain ${chain}`
+      );
+    }
+    if (!executor.getIdentityKey) {
+      throw new SwapSdkError(
+        "SIGNING_FAILED",
+        "sign",
+        `Executor for signer chain ${chain} must implement getIdentityKey`
+      );
+    }
+    if (requireSignMessage && !executor.signMessage) {
+      throw new SwapSdkError(
+        "SIGNING_FAILED",
+        "sign",
+        `Executor for signer chain ${chain} must implement signMessage`
+      );
+    }
+    return executor;
+  }
+};
+
+// src/normalizers/chain.ts
+var CANONICAL_NON_EVM_CHAINS = /* @__PURE__ */ new Set([
+  "solana",
+  "aptos",
+  "near",
+  "tron",
+  "btc",
+  "zcash",
+  "sui"
+]);
+var RAW_API_ALIASES = /* @__PURE__ */ new Map([
+  ["sol", "solana"],
+  ["501", "solana"],
+  ["637", "aptos"],
+  ["trx", "tron"],
+  ["bitcoin", "btc"],
+  ["zec", "zcash"]
+]);
+var NATIVE_ADDRESSES = /* @__PURE__ */ new Map([
+  ["solana", "So11111111111111111111111111111111111111112"],
+  ["aptos", "0xa"],
+  ["near", "wrap.near"],
+  ["tron", "trx"],
+  ["btc", "btc"],
+  ["zcash", "nep141:zec.omft.near"],
+  ["sui", "0x2::sui::SUI"]
+]);
+var EVM_ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+var DECIMAL_EVM_CHAIN_ID = /^[1-9]\d*$/;
+function toApiChain(chain) {
+  if (DECIMAL_EVM_CHAIN_ID.test(chain) || CANONICAL_NON_EVM_CHAINS.has(chain)) {
+    return chain;
+  }
+  throw unsupportedChain(chain);
+}
+function fromApiChain(chain) {
+  const normalized = chain.trim().toLowerCase();
+  const alias = RAW_API_ALIASES.get(normalized);
+  if (alias) return alias;
+  if (CANONICAL_NON_EVM_CHAINS.has(normalized)) {
+    return normalized;
+  }
+  if (/^0x[0-9a-f]+$/.test(normalized)) {
+    const decimal = BigInt(normalized).toString();
+    if (decimal !== "0") return decimal;
+  }
+  if (DECIMAL_EVM_CHAIN_ID.test(normalized)) {
+    return BigInt(normalized).toString();
+  }
+  throw unsupportedChain(chain);
+}
+function toApiAssetAddress(asset) {
+  const explicit = asset.address.trim();
+  if (explicit) return explicit;
+  if (!asset.isNative) {
+    throw new SwapSdkError(
+      "INVALID_REQUEST",
+      "quote",
+      `Asset address is required for ${asset.chain}`
+    );
+  }
+  if (DECIMAL_EVM_CHAIN_ID.test(asset.chain)) return EVM_ZERO_ADDRESS;
+  const nativeAddress = NATIVE_ADDRESSES.get(asset.chain);
+  if (!nativeAddress) {
+    throw new SwapSdkError(
+      "UNSUPPORTED_CHAIN",
+      "quote",
+      `No native asset mapping for ${asset.chain}`
+    );
+  }
+  return nativeAddress;
+}
+function unsupportedChain(chain) {
+  return new SwapSdkError(
+    "UNSUPPORTED_CHAIN",
+    "quote",
+    `Unsupported chain: ${chain}`
+  );
+}
+var decimalStringSchema = zod.z.string().regex(/^(0|[1-9]\d*)$/);
+var nonEmptyStringSchema = zod.z.string().trim().min(1);
+var hexDataSchema = zod.z.string().regex(/^0x(?:[0-9a-fA-F]{2})*$/);
+var positiveIntegerSchema = zod.z.number().int().positive();
+var evmQuantitySchema = zod.z.string().regex(/^(?:0|[1-9]\d*|0x[0-9a-fA-F]+)$/).transform(
+  (value) => value.startsWith("0x") ? BigInt(value).toString() : value
+);
+var evmTxSchema = zod.z.object({
+  to: nonEmptyStringSchema,
+  data: hexDataSchema,
+  value: evmQuantitySchema,
+  gasLimit: evmQuantitySchema,
+  chainId: positiveIntegerSchema
+});
+
+// src/normalizers/build.ts
+var tokenSchema = zod.z.object({
+  address: zod.z.string(),
+  symbol: zod.z.string(),
+  decimals: zod.z.number().int().nonnegative()
+});
+var commonBuildSchema = zod.z.object({
+  isCrossChain: zod.z.boolean(),
+  chainType: nonEmptyStringSchema,
+  router: nonEmptyStringSchema,
+  fromChain: nonEmptyStringSchema,
+  toChain: nonEmptyStringSchema,
+  tokenIn: tokenSchema,
+  tokenOut: tokenSchema,
+  amountIn: decimalStringSchema,
+  estimatedOut: decimalStringSchema,
+  minAmountOut: decimalStringSchema
+});
+var signingRequestSchema = zod.z.object({
+  type: nonEmptyStringSchema,
+  router: nonEmptyStringSchema,
+  quoteId: nonEmptyStringSchema,
+  chainId: positiveIntegerSchema,
+  signingScheme: zod.z.string().optional(),
+  typedData: zod.z.object({
+    domain: zod.z.record(zod.z.string(), zod.z.unknown()),
+    types: zod.z.record(
+      zod.z.string(),
+      zod.z.array(zod.z.object({ name: zod.z.string(), type: zod.z.string() }))
+    ),
+    primaryType: nonEmptyStringSchema,
+    message: zod.z.record(zod.z.string(), zod.z.unknown())
+  }),
+  submit: zod.z.object({
+    endpoint: zod.z.string(),
+    method: zod.z.string(),
+    params: zod.z.record(zod.z.string(), zod.z.string())
+  }).optional()
+});
+var solanaTxSchema = zod.z.object({
+  transaction: zod.z.string(),
+  format: nonEmptyStringSchema,
+  addressLookupTableAddresses: zod.z.array(zod.z.string()).optional(),
+  recentBlockhash: zod.z.string().optional(),
+  txValidUntil: zod.z.number().optional(),
+  transactionSize: zod.z.number().optional()
+});
+var aptosTxSchema = zod.z.object({
+  function: nonEmptyStringSchema,
+  type_arguments: zod.z.array(zod.z.string()),
+  arguments: zod.z.array(zod.z.unknown())
+});
+var nearTxSchema = zod.z.object({
+  signerId: zod.z.string().optional(),
+  receiverId: nonEmptyStringSchema,
+  actions: zod.z.array(zod.z.unknown()).min(1)
+});
+var transferBaseSchema = zod.z.object({
+  kind: nonEmptyStringSchema,
+  chainId: zod.z.string().optional(),
+  chain: zod.z.string().optional(),
+  amount: decimalStringSchema,
+  depositAddress: nonEmptyStringSchema
+});
+var tronTxSchema = transferBaseSchema.extend({
+  tokenAddress: zod.z.string().optional(),
+  standard: zod.z.string().optional()
+});
+var bitcoinTxSchema = transferBaseSchema.extend({
+  feeRate: zod.z.number().positive().optional()
+});
+var zcashTxSchema = transferBaseSchema.extend({
+  decimals: zod.z.number().int().nonnegative().optional()
+});
+var suiTxSchema = transferBaseSchema.extend({
+  coinType: nonEmptyStringSchema.refine(
+    (value) => !value.toLowerCase().startsWith("nep141:"),
+    "Sui coinType cannot be an OMFT asset id"
+  )
+});
+function normalizeBuild(raw, executionId = createExecutionId(), request) {
+  try {
+    const common = commonBuildSchema.parse(raw);
+    const fromChain = fromApiChain(common.fromChain);
+    const toChain = fromApiChain(common.toChain);
+    const lane = laneFromChainType(common.chainType, fromChain);
+    assertLaneMatchesChain(lane, fromChain);
+    const execution = normalizeExecution(raw, lane, fromChain);
+    const order = normalizeOrder(raw, execution);
+    const deposit = normalizeDeposit(raw.deposit);
+    return {
+      executionId,
+      ...raw.signingRequest?.quoteId ? { quoteId: raw.signingRequest.quoteId } : {},
+      isCrossChain: common.isCrossChain,
+      fromChain,
+      toChain,
+      tokenIn: { chain: fromChain, ...common.tokenIn },
+      tokenOut: { chain: toChain, ...common.tokenOut },
+      amountIn: common.amountIn,
+      estimatedOut: common.estimatedOut,
+      minAmountOut: common.minAmountOut,
+      router: common.router,
+      execution,
+      ...order ? { order } : {},
+      ...deposit ? { deposit } : {},
+      ...request ? { request: { ...request } } : {},
+      raw
+    };
+  } catch (error) {
+    if (error instanceof SwapSdkError) throw error;
+    throw invalidBuild(error);
+  }
+}
+function normalizeExecution(raw, lane, chain) {
+  switch (lane) {
+    case "evm":
+      return normalizeEvmExecution(raw, chain);
+    case "solana": {
+      const tx = solanaTxSchema.parse(raw.tx);
+      return {
+        kind: "solana-transaction",
+        chain,
+        transaction: tx.transaction,
+        format: tx.format,
+        metadata: {
+          ...tx.addressLookupTableAddresses ? { addressLookupTableAddresses: tx.addressLookupTableAddresses } : {},
+          ...tx.recentBlockhash ? { recentBlockhash: tx.recentBlockhash } : {},
+          ...tx.txValidUntil === void 0 ? {} : { txValidUntil: tx.txValidUntil },
+          ...tx.transactionSize === void 0 ? {} : { transactionSize: tx.transactionSize }
+        }
+      };
+    }
+    case "aptos": {
+      const tx = aptosTxSchema.parse(raw.tx);
+      return {
+        kind: "aptos-entry-function",
+        chain,
+        function: tx.function,
+        typeArguments: tx.type_arguments,
+        functionArguments: tx.arguments
+      };
+    }
+    case "near": {
+      const transactions = zod.z.union([nearTxSchema, zod.z.array(nearTxSchema).min(1)]).parse(raw.tx);
+      return {
+        kind: "near-transaction-batch",
+        chain,
+        transactions: Array.isArray(transactions) ? transactions : [transactions]
+      };
+    }
+    case "tron": {
+      const tx = tronTxSchema.parse(raw.tx);
+      assertKind(tx.kind, ["tron_transfer"]);
+      return {
+        kind: "tron-transfer",
+        chain,
+        amount: tx.amount,
+        depositAddress: tx.depositAddress,
+        ...tx.tokenAddress ? { tokenAddress: tx.tokenAddress } : {},
+        ...tx.standard ? { standard: tx.standard } : {}
+      };
+    }
+    case "bitcoin": {
+      const tx = bitcoinTxSchema.parse(raw.tx);
+      assertKind(tx.kind, ["btc_transfer", "utxo_transfer"]);
+      return {
+        kind: "bitcoin-transfer",
+        chain,
+        amount: tx.amount,
+        depositAddress: tx.depositAddress,
+        ...tx.feeRate === void 0 ? {} : { feeRate: tx.feeRate }
+      };
+    }
+    case "zcash": {
+      const tx = zcashTxSchema.parse(raw.tx);
+      assertKind(tx.kind, ["zcash_transfer", "utxo_transfer"]);
+      return {
+        kind: "zcash-transfer",
+        chain,
+        amount: tx.amount,
+        depositAddress: tx.depositAddress,
+        ...tx.decimals === void 0 ? {} : { decimals: tx.decimals }
+      };
+    }
+    case "sui": {
+      const candidate = typeof raw.tx === "object" && raw.tx !== null ? {
+        ...raw.tx,
+        coinType: "coinType" in raw.tx && raw.tx.coinType ? raw.tx.coinType : raw.tokenIn.address
+      } : raw.tx;
+      const tx = suiTxSchema.parse(candidate);
+      assertKind(tx.kind, ["sui_transfer"]);
+      return {
+        kind: "sui-transfer",
+        chain,
+        amount: tx.amount,
+        depositAddress: tx.depositAddress,
+        coinType: tx.coinType
+      };
+    }
+  }
+}
+function normalizeEvmExecution(raw, chain) {
+  const approval = normalizeEvmApproval(raw, chain);
+  if (raw.executionType === "signature" || raw.signingRequest) {
+    const request = signingRequestSchema.parse(raw.signingRequest);
+    assertEvmChainId(chain, request.chainId);
+    return {
+      kind: "evm-signature",
+      chain,
+      request,
+      ...approval ? { approval } : {}
+    };
+  }
+  const tx = evmTxSchema.parse(raw.tx);
+  assertEvmChainId(chain, tx.chainId);
+  return {
+    kind: "evm-transaction",
+    chain,
+    tx,
+    ...approval ? { approval } : {}
+  };
+}
+function normalizeEvmApproval(raw, chain) {
+  if (raw.approve) {
+    const approveTx = evmTxSchema.parse(raw.approve.tx);
+    assertEvmChainId(chain, approveTx.chainId);
+    return {
+      tx: approveTx,
+      spender: nonEmptyStringSchema.parse(raw.approve.spender)
+    };
+  }
+  return void 0;
+}
+function laneFromChainType(chainType, fromChain) {
+  const normalized = chainType.toLowerCase();
+  const aliases = {
+    evm: "evm",
+    solana: "solana",
+    sol: "solana",
+    aptos: "aptos",
+    near: "near",
+    tron: "tron",
+    btc: "bitcoin",
+    bitcoin: "bitcoin",
+    zcash: "zcash",
+    zec: "zcash",
+    sui: "sui"
+  };
+  if (normalized === "cross-chain") return laneFromChain(fromChain);
+  const lane = aliases[normalized];
+  if (!lane) {
+    throw new SwapSdkError(
+      "UNSUPPORTED_CHAIN",
+      "build",
+      `Unsupported build chainType: ${chainType}`
+    );
+  }
+  return lane;
+}
+function laneFromChain(chain) {
+  if (/^[1-9]\d*$/.test(chain)) return "evm";
+  const lanes = {
+    solana: "solana",
+    aptos: "aptos",
+    near: "near",
+    tron: "tron",
+    btc: "bitcoin",
+    zcash: "zcash",
+    sui: "sui"
+  };
+  const lane = lanes[chain];
+  if (!lane) {
+    throw new SwapSdkError(
+      "UNSUPPORTED_CHAIN",
+      "build",
+      `Unsupported source chain: ${chain}`
+    );
+  }
+  return lane;
+}
+function assertLaneMatchesChain(lane, chain) {
+  const chainLane = laneFromChain(chain);
+  if (lane !== chainLane) {
+    throw new SwapSdkError(
+      "CHAIN_MISMATCH",
+      "build",
+      `Build chainType ${lane} does not match source chain ${chain}`
+    );
+  }
+}
+function assertEvmChainId(chain, chainId) {
+  if (chain !== String(chainId)) {
+    throw new SwapSdkError(
+      "CHAIN_MISMATCH",
+      "build",
+      `EVM transaction chainId ${chainId} does not match ${chain}`
+    );
+  }
+}
+function assertKind(actual, allowed) {
+  if (!allowed.includes(actual.toLowerCase())) {
+    throw new SwapSdkError(
+      "INVALID_API_RESPONSE",
+      "build",
+      `Unexpected transaction kind: ${actual}`
+    );
+  }
+}
+function normalizeOrder(raw, execution) {
+  const depositOrderId = readRecordString(raw.deposit, "orderId");
+  const orderId = raw.orderId ?? depositOrderId;
+  if (!orderId) return void 0;
+  const router = raw.statusRouter ?? (execution.kind === "evm-signature" ? execution.request.router : void 0) ?? raw.router;
+  const chainId = execution.kind === "evm-signature" ? String(execution.request.chainId) : execution.kind === "evm-transaction" ? String(execution.tx.chainId) : void 0;
+  return { orderId, router, ...chainId ? { chainId } : {} };
+}
+function normalizeDeposit(value) {
+  if (typeof value !== "object" || value === null) return void 0;
+  const depositAddress = readRecordString(value, "depositAddress");
+  if (!depositAddress) return void 0;
+  return {
+    depositAddress,
+    ...readRecordString(value, "depositMemo") ? { depositMemo: readRecordString(value, "depositMemo") } : {},
+    ...readRecordString(value, "orderId") ? { orderId: readRecordString(value, "orderId") } : {},
+    ...readRecordString(value, "estimatedOut") ? { estimatedOut: decimalStringSchema.parse(readRecordString(value, "estimatedOut")) } : {},
+    ...readRecordString(value, "minAmountOut") ? { minAmountOut: decimalStringSchema.parse(readRecordString(value, "minAmountOut")) } : {},
+    ...typeof Reflect.get(value, "timeEstimate") === "number" || typeof Reflect.get(value, "timeEstimate") === "string" ? { timeEstimate: Reflect.get(value, "timeEstimate") } : {}
+  };
+}
+function readRecordString(value, key) {
+  if (typeof value !== "object" || value === null) return void 0;
+  const field = Reflect.get(value, key);
+  return typeof field === "string" && field.trim() ? field.trim() : void 0;
+}
+function createExecutionId() {
+  if (typeof globalThis.crypto?.randomUUID === "function") {
+    return globalThis.crypto.randomUUID();
+  }
+  return `swap_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+}
+function invalidBuild(error) {
+  return new SwapSdkError(
+    "INVALID_API_RESPONSE",
+    "build",
+    "Invalid swap build response",
+    {
+      cause: error,
+      details: error instanceof zod.ZodError ? {
+        issues: error.issues.map((issue) => ({
+          path: issue.path.join("."),
+          message: issue.message
+        }))
+      } : void 0
+    }
+  );
+}
+
+// src/types/chain.ts
+var BASE_UNIT_AMOUNT = /^(0|[1-9]\d*)$/;
+function assertBaseUnitAmount(value) {
+  if (!BASE_UNIT_AMOUNT.test(value)) {
+    throw new SwapSdkError(
+      "INVALID_REQUEST",
+      "quote",
+      `Invalid base-unit amount: ${value}`
+    );
+  }
+  return value;
+}
+
+// src/normalizers/quote.ts
+var DEFAULT_QUOTE_WAITING_TIME_MS = 3e3;
+function serializeQuoteRequest(request) {
+  validateQuoteRequest(request);
+  return {
+    ...request.extensions ?? {},
+    fromChain: toApiChain(request.fromChain),
+    toChain: toApiChain(request.toChain),
+    tokenIn: toApiAssetAddress(request.tokenIn),
+    tokenOut: toApiAssetAddress(request.tokenOut),
+    amountIn: request.amountIn,
+    slippage: request.slippageBps,
+    quoteWaitingTimeMs: request.quoteWaitingTimeMs ?? DEFAULT_QUOTE_WAITING_TIME_MS,
+    sender: request.sender.trim(),
+    ...request.recipient?.trim() ? { recipient: request.recipient.trim() } : {}
+  };
+}
+function normalizeQuote(request, raw, receivedAt = Date.now()) {
+  const bestRoute = normalizeRoute(raw.bestQuote, true);
+  if (!bestRoute) {
+    throw invalidQuote("Quote response does not contain a valid best route");
+  }
+  const quoteId = readOptionalString(raw.bestQuote.quoteId);
+  const apiRequest = Object.freeze({ ...serializeQuoteRequest(request) });
+  const buildContext = Object.freeze({
+    request: apiRequest,
+    router: bestRoute.router,
+    ...bestRoute.market ? { market: bestRoute.market } : {},
+    expectedOut: bestRoute.amountOut,
+    minAmountOut: bestRoute.minAmountOut,
+    preSwap: raw.bestQuote.preSwap ?? null,
+    bridge: raw.bestQuote.bridge ?? null,
+    ...quoteId ? { quoteId } : {}
+  });
+  const expiresAt = readTimestamp(
+    raw.bestQuote.expiresAt ?? raw.bestQuote.expirationTime
+  );
+  return {
+    ...quoteId ? { id: quoteId } : {},
+    fromChain: request.fromChain,
+    toChain: request.toChain,
+    tokenIn: { ...request.tokenIn },
+    tokenOut: { ...request.tokenOut },
+    amountIn: validateResponseAmount(request.amountIn, "amountIn"),
+    estimatedOut: bestRoute.amountOut,
+    minAmountOut: bestRoute.minAmountOut,
+    route: bestRoute,
+    alternatives: raw.allQuotes.flatMap((route) => {
+      try {
+        const normalized = normalizeRoute(route, false);
+        return normalized ? [normalized] : [];
+      } catch {
+        return [];
+      }
+    }),
+    receivedAt,
+    ...expiresAt === void 0 ? {} : { expiresAt },
+    buildContext,
+    raw
+  };
+}
+function validateQuoteRequest(request) {
+  assertBaseUnitAmount(request.amountIn);
+  if (!Number.isInteger(request.slippageBps) || request.slippageBps < 0) {
+    throw new SwapSdkError(
+      "INVALID_REQUEST",
+      "quote",
+      "slippageBps must be a non-negative integer"
+    );
+  }
+  if (request.slippageBps > 1e4) {
+    throw new SwapSdkError(
+      "INVALID_REQUEST",
+      "quote",
+      "slippageBps cannot exceed 10000"
+    );
+  }
+  if (request.quoteWaitingTimeMs !== void 0 && (!Number.isFinite(request.quoteWaitingTimeMs) || !Number.isInteger(request.quoteWaitingTimeMs) || request.quoteWaitingTimeMs < 0)) {
+    throw new SwapSdkError(
+      "INVALID_REQUEST",
+      "quote",
+      "quoteWaitingTimeMs must be a non-negative integer"
+    );
+  }
+  if (!request.sender.trim()) {
+    throw new SwapSdkError(
+      "INVALID_REQUEST",
+      "quote",
+      "sender is required"
+    );
+  }
+  if (request.tokenIn.chain !== request.fromChain) {
+    throw new SwapSdkError(
+      "CHAIN_MISMATCH",
+      "quote",
+      "tokenIn chain does not match fromChain"
+    );
+  }
+  if (request.tokenOut.chain !== request.toChain) {
+    throw new SwapSdkError(
+      "CHAIN_MISMATCH",
+      "quote",
+      "tokenOut chain does not match toChain"
+    );
+  }
+}
+function normalizeRoute(raw, required) {
+  const router = readOptionalString(raw.router);
+  const amountOutValue = raw.amountOut ?? raw.estimatedOut;
+  const amountOut = readOptionalString(amountOutValue);
+  const minAmountOut = readOptionalString(raw.minAmountOut) ?? amountOut;
+  if (!router || !amountOut || !minAmountOut) {
+    if (required) throw invalidQuote("Quote response is missing route fields");
+    return void 0;
+  }
+  return {
+    router,
+    ...readOptionalString(raw.market) ? { market: readOptionalString(raw.market) } : {},
+    amountOut: validateResponseAmount(amountOut, "amountOut"),
+    minAmountOut: validateResponseAmount(minAmountOut, "minAmountOut"),
+    raw
+  };
+}
+function validateResponseAmount(value, field) {
+  try {
+    return assertBaseUnitAmount(value);
+  } catch (error) {
+    throw invalidQuote(`Quote response has invalid ${field}`, error);
+  }
+}
+function readOptionalString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function readTimestamp(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string" && /^\d+$/.test(value)) return Number(value);
+  return void 0;
+}
+function invalidQuote(message, cause) {
+  return new SwapSdkError("INVALID_API_RESPONSE", "quote", message, {
+    cause
+  });
+}
+var historyRecordSchema = zod.z.object({
+  id: zod.z.number().int(),
+  sender: zod.z.string(),
+  recipient: zod.z.unknown().optional(),
+  from_hash: zod.z.string(),
+  to_hash: zod.z.string().nullable().optional(),
+  deposit_address: zod.z.string().optional(),
+  from_token: zod.z.string(),
+  to_token: zod.z.string(),
+  from_chain: zod.z.string(),
+  to_chain: zod.z.string(),
+  amount_in: decimalStringSchema.optional(),
+  estimated_out: decimalStringSchema.optional(),
+  actual_out: decimalStringSchema.nullable().optional(),
+  router: zod.z.string().optional(),
+  status: zod.z.string().optional(),
+  swap_id: zod.z.string().nullable().optional(),
+  status_response: zod.z.record(zod.z.string(), zod.z.unknown()).optional(),
+  created_at: zod.z.string().optional(),
+  updated_at: zod.z.string().optional()
+}).passthrough();
+var historyPageSchema = zod.z.object({
+  record_list: zod.z.array(historyRecordSchema),
+  page_number: zod.z.number().int().nonnegative(),
+  page_size: zod.z.number().int().nonnegative(),
+  total_page: zod.z.number().int().nonnegative(),
+  total_size: zod.z.number().int().nonnegative()
+});
+var HISTORY_STATUS_MAP = {
+  PENDING: "pending",
+  CREATED: "pending",
+  PROCESSING: "processing",
+  IN_PROGRESS: "processing",
+  SUCCESS: "completed",
+  COMPLETED: "completed",
+  FILLED: "completed",
+  FAILED: "failed",
+  REFUNDED: "refunded",
+  EXPIRED: "expired"
+};
+var NATIVE_ASSET_IDS = {
+  solana: [
+    "sol",
+    "So11111111111111111111111111111111111111112"
+  ],
+  aptos: ["0xa", "0x1::aptos_coin::AptosCoin"],
+  near: ["near", "wrap.near"],
+  tron: ["trx"],
+  btc: ["btc", "bitcoin"],
+  zcash: ["zec", "zcash", "nep141:zec.omft.near"],
+  sui: ["0x2::sui::SUI"]
+};
+function normalizeHistory(raw) {
+  const parsed = historyPageSchema.safeParse(raw);
+  if (!parsed.success) {
+    throw new SwapSdkError(
+      "INVALID_API_RESPONSE",
+      "history",
+      "Invalid swap history response",
+      {
+        details: {
+          issues: parsed.error.issues.map((issue) => ({
+            path: issue.path.join("."),
+            message: issue.message
+          }))
+        }
+      }
+    );
+  }
+  return {
+    items: raw.record_list.map(normalizeHistoryItem),
+    page: raw.page_number,
+    pageSize: raw.page_size,
+    totalPages: raw.total_page,
+    totalItems: raw.total_size
+  };
+}
+function normalizeHistoryStatus(status) {
+  if (typeof status !== "string") return "unknown";
+  return HISTORY_STATUS_MAP[status.trim().toUpperCase()] ?? "unknown";
+}
+function normalizeHistoryItem(raw) {
+  const fromChain = fromApiChain(raw.from_chain);
+  const toChain = fromApiChain(raw.to_chain);
+  const createdAt = normalizeTimestamp(raw.created_at);
+  const updatedAt = normalizeTimestamp(raw.updated_at);
+  return {
+    id: String(raw.id),
+    sender: raw.sender,
+    ...typeof raw.recipient === "string" && raw.recipient ? { recipient: raw.recipient } : {},
+    fromChain,
+    toChain,
+    tokenIn: normalizeHistoryAsset(fromChain, raw.from_token),
+    tokenOut: normalizeHistoryAsset(toChain, raw.to_token),
+    ...raw.amount_in !== void 0 ? { amountIn: raw.amount_in } : {},
+    ...raw.estimated_out !== void 0 ? { estimatedOut: raw.estimated_out } : {},
+    ...raw.actual_out !== void 0 && raw.actual_out !== null ? { actualOut: raw.actual_out } : {},
+    ...raw.from_hash ? { sourceTxHash: raw.from_hash } : {},
+    ...raw.to_hash ? { destinationTxHash: raw.to_hash } : {},
+    ...raw.swap_id ? { orderId: raw.swap_id } : {},
+    ...raw.deposit_address ? { depositAddress: raw.deposit_address } : {},
+    ...raw.router ? { router: raw.router } : {},
+    status: normalizeHistoryStatus(raw.status),
+    ...createdAt ? { createdAt } : {},
+    ...updatedAt ? { updatedAt } : {},
+    ...raw.status_response ? { statusResponse: raw.status_response } : {},
+    raw
+  };
+}
+function normalizeHistoryAsset(chain, address) {
+  return {
+    chain,
+    address,
+    ...isNativeAsset(chain, address) ? { isNative: true } : {}
+  };
+}
+function isNativeAsset(chain, address) {
+  const normalized = address.trim().toLowerCase();
+  if (/^[1-9]\d*$/.test(chain) && (normalized === "0x0000000000000000000000000000000000000000" || normalized === "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee")) {
+    return true;
+  }
+  return (NATIVE_ASSET_IDS[chain] ?? []).some(
+    (candidate) => candidate.toLowerCase() === normalized
+  );
+}
+function normalizeTimestamp(value) {
+  if (!value?.trim()) return void 0;
+  const trimmed = value.trim();
+  const normalized = /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}(?:\.\d+)?$/.test(
+    trimmed
+  ) ? `${trimmed.replace(" ", "T")}Z` : trimmed;
+  const date = new Date(normalized);
+  return Number.isNaN(date.getTime()) ? void 0 : date.toISOString();
+}
+
+// src/mca/quote.ts
+function serializeMcaQuoteRequest(request, signer) {
+  const mcaAccountId = request.mcaAccountId.trim();
+  if (!mcaAccountId) {
+    throw invalidRequest("mcaAccountId is required");
+  }
+  if (signer.chain !== request.signerChain) {
+    throw invalidRequest(
+      `Resolved signer chain ${signer.chain} does not match requested signer chain ${request.signerChain}`
+    );
+  }
+  const identityKey = signer.identityKey.trim();
+  if (!identityKey) {
+    throw invalidRequest("signer identityKey is required");
+  }
+  if (request.flow === "withdraw" && !/^(?:0|[1-9]\d*)(?:\.\d+)?$/.test(
+    request.collateral.decreaseAmountBurrow.trim()
+  )) {
+    throw invalidRequest(
+      "collateral.decreaseAmountBurrow must be a non-negative decimal string"
+    );
+  }
+  const mca = {
+    flow: request.flow,
+    mcaAccountId,
+    signer: {
+      chain: signer.chain,
+      identityKey
+    },
+    ...request.flow === "deposit" ? { useAsCollateral: request.collateral.useAsCollateral } : {
+      needDecreaseCollateral: request.collateral.needDecrease,
+      decreaseCollateralAmountBurrow: request.collateral.decreaseAmountBurrow,
+      ...request.collateral.withdrawAll ? { withdrawAll: true } : {}
+    },
+    ...request.recipientMsgSignatures ? { recipientMsgSignatures: [...request.recipientMsgSignatures] } : {},
+    ...request.depositSignerProofSignatures ? {
+      depositSignerProofSignatures: [
+        ...request.depositSignerProofSignatures
+      ]
+    } : {}
+  };
+  return {
+    ...serializeQuoteRequest(request),
+    mca
+  };
+}
+function normalizeMcaQuote(request, signer, quote) {
+  const mca = serializeMcaQuoteRequest(request, signer).mca;
+  const base = {
+    ...quote,
+    flow: request.flow,
+    mcaAccountId: request.mcaAccountId.trim(),
+    signer: Object.freeze({
+      ...signer,
+      identityKey: signer.identityKey.trim()
+    }),
+    request,
+    mca: Object.freeze({ ...mca })
+  };
+  if (request.flow === "deposit") {
+    if (readString(quote.raw.nearDepositTxError)) {
+      throw invalidResponse(String(quote.raw.nearDepositTxError));
+    }
+    return {
+      ...base,
+      flow: "deposit",
+      executionMode: "deposit",
+      request,
+      ...quote.raw.nearDepositTx === void 0 ? {} : { nearDepositTx: quote.raw.nearDepositTx }
+    };
+  }
+  if (readString(quote.raw.nearMcaWithdrawTxError)) {
+    throw invalidResponse(String(quote.raw.nearMcaWithdrawTxError));
+  }
+  const mode = resolveWithdrawMode(request);
+  const preview = mode === "withdraw-near" ? quote.raw.nearMcaWithdrawTx ?? quote.raw.mcaWithdrawToIntents : quote.raw.mcaWithdrawToIntents;
+  if (!isPlainObject(preview)) {
+    throw invalidResponse(
+      mode === "withdraw-near" ? "MCA withdraw quote is missing nearMcaWithdrawTx" : "MCA withdraw quote is missing mcaWithdrawToIntents"
+    );
+  }
+  return {
+    ...base,
+    flow: "withdraw",
+    executionMode: mode,
+    request,
+    preview
+  };
+}
+function resolveWithdrawMode(request) {
+  if (request.executionPreference === "near") return "withdraw-near";
+  if (request.executionPreference === "relayer") return "withdraw-relayer";
+  const recipient = request.recipient?.trim();
+  const boundNearAccountId = request.boundNearAccountId?.trim();
+  return request.toChain === "near" && Boolean(recipient) && recipient === boundNearAccountId ? "withdraw-near" : "withdraw-relayer";
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function invalidRequest(message) {
+  return new SwapSdkError("INVALID_REQUEST", "quote", message);
+}
+function invalidResponse(message) {
+  return new SwapSdkError("INVALID_API_RESPONSE", "quote", message);
+}
+
+// src/mca/signers.ts
+var DEFAULT_MCA_SIGNER_PRIORITY = [
+  "evm",
+  "solana",
+  "btc",
+  "aptos",
+  "near",
+  "zcash",
+  "sui",
+  "tron"
+];
+var WALLET_KEYS = {
+  evm: "EVM",
+  solana: "Solana",
+  btc: "Bitcoin",
+  near: "Near",
+  aptos: "Aptos",
+  sui: "Sui",
+  zcash: "Zcash",
+  tron: "Tron"
+};
+function formatMcaWallet(chain, identityKey) {
+  const identity = identityKey.trim();
+  if (!identity) {
+    throw new SwapSdkError(
+      "INVALID_REQUEST",
+      "sign",
+      "MCA signer identityKey is required"
+    );
+  }
+  return {
+    [WALLET_KEYS[chain]]: chain === "evm" ? identity.replace(/^0x/i, "") : identity
+  };
+}
+function selectMcaSigner(boundWallets, connectedSigners, priority = DEFAULT_MCA_SIGNER_PRIORITY) {
+  for (const chain of priority) {
+    const key = WALLET_KEYS[chain];
+    const boundValues = boundWallets.flatMap((wallet) => {
+      const value = wallet[key];
+      return typeof value === "string" && value.trim() ? [value.trim()] : [];
+    });
+    if (boundValues.length === 0) continue;
+    for (const signer of connectedSigners) {
+      if (signer.chain !== chain) continue;
+      const candidates = [signer.identityKey, signer.accountId].filter((value) => Boolean(value?.trim())).map((value) => normalizeIdentity(chain, value));
+      if (boundValues.some(
+        (bound) => candidates.includes(normalizeIdentity(chain, bound))
+      )) {
+        return signer;
+      }
+    }
+  }
+  return void 0;
+}
+function isSameMcaSignerIdentity(a, b) {
+  return a.chain === b.chain && normalizeIdentity(a.chain, a.identityKey) === normalizeIdentity(b.chain, b.identityKey);
+}
+function normalizeIdentity(chain, value) {
+  const trimmed = value.trim();
+  if (chain === "evm") return trimmed.replace(/^0x/i, "").toLowerCase();
+  if (chain === "sui" || chain === "aptos") return trimmed.toLowerCase();
+  return trimmed;
+}
 
-var Big__default = /*#__PURE__*/_interopDefault(Big);
+// src/utils/units.ts
+var HUMAN_AMOUNT = /^(0|[1-9]\d*)(?:\.(\d+))?$/;
+var MAX_DECIMALS = 255;
+function parseUnits(value, decimals) {
+  assertDecimals(decimals);
+  const match = HUMAN_AMOUNT.exec(value);
+  if (!match) {
+    throw invalid(`Invalid human-readable amount: ${value}`);
+  }
+  const whole = match[1];
+  const fraction = match[2] ?? "";
+  if (fraction.length > decimals) {
+    throw invalid(
+      `Amount has ${fraction.length} fractional digits but token supports ${decimals}`
+    );
+  }
+  const combined = `${whole}${fraction.padEnd(decimals, "0")}`;
+  return combined.replace(/^0+(?=\d)/, "") || "0";
+}
+function formatUnits(value, decimals) {
+  assertDecimals(decimals);
+  const amount = assertBaseUnitAmount(value);
+  if (decimals === 0) return amount;
+  const padded = amount.padStart(decimals + 1, "0");
+  const whole = padded.slice(0, -decimals);
+  const fraction = padded.slice(-decimals).replace(/0+$/, "");
+  return fraction ? `${whole}.${fraction}` : whole;
+}
+function assertDecimals(decimals) {
+  if (!Number.isSafeInteger(decimals) || decimals < 0 || decimals > MAX_DECIMALS) {
+    throw invalid(`Invalid token decimals: ${String(decimals)}`);
+  }
+}
+function invalid(message) {
+  return new SwapSdkError("INVALID_REQUEST", "quote", message);
+}
 
-// src/utils/logger.ts
-var LOG_LEVELS = {
-  silent: 0,
-  error: 1,
-  warn: 2,
-  info: 3,
-  debug: 4
-};
-function getLogLevel() {
-  if (typeof process !== "undefined" && process.env?.LOG_LEVEL) {
-    const level = process.env.LOG_LEVEL.toLowerCase();
-    if (LOG_LEVELS[level] !== void 0) {
-      return level;
-    }
+// src/mca/withdraw.ts
+function extractMcaWithdrawBusiness(preview) {
+  if (!isPlainObject2(preview)) return void 0;
+  if (isPlainObject2(preview.business)) return cloneObject(preview.business);
+  return extractPreviewField(preview, "business");
+}
+function extractMcaWithdrawSignerWallet(preview) {
+  if (!isPlainObject2(preview)) return void 0;
+  if (isPlainObject2(preview.signer_wallet)) {
+    return cloneObject(preview.signer_wallet);
   }
-  return typeof process !== "undefined" && process.env?.NODE_ENV === "production" ? "warn" : "debug";
+  return extractPreviewField(preview, "signer_wallet");
 }
-var currentLogLevel = getLogLevel();
-var currentLevelValue = LOG_LEVELS[currentLogLevel];
-function shouldLog(level) {
-  return LOG_LEVELS[level] <= currentLevelValue;
+function extractMcaWithdrawDepositAddress(input) {
+  return pickString(input.snapshotDepositAddress) || pickString(input.storeDepositAddress) || extractDepositAddressFromObject(input.preview) || extractDepositAddressFromObject(input.bestQuote);
 }
-var logger = {
-  debug: (...args) => {
-    if (shouldLog("debug")) {
-      console.debug(...args);
-    }
-  },
-  info: (...args) => {
-    if (shouldLog("info")) {
-      console.info(...args);
+function buildNearMcaWithdrawTransactions(preview, input) {
+  if (!isPlainObject2(preview)) {
+    throw invalidPreview("MCA withdraw preview must be an object");
+  }
+  const fallbackAccount = input.mcaAccountId.trim();
+  const executionArgs = {
+    business: cloneObject(input.business),
+    signer_wallet: cloneObject(input.signerWallet),
+    signature: input.signature ?? ""
+  };
+  const transactions = Array.isArray(preview.transactions) ? preview.transactions : [];
+  const mapped = transactions.flatMap((value) => {
+    if (!isPlainObject2(value)) return [];
+    const receiverId = pickString(value.contractId) || fallbackAccount;
+    if (!receiverId) return [];
+    const methodName = pickString(value.methodName) || "exec";
+    const existingArgs = isPlainObject2(value.args) ? cloneObject(value.args) : {};
+    return [
+      {
+        receiverId,
+        actions: [
+          {
+            type: "FunctionCall",
+            params: {
+              methodName,
+              args: { ...existingArgs, ...executionArgs },
+              gas: normalizeGas(value.gas),
+              deposit: normalizeDeposit2(value.deposit)
+            }
+          }
+        ]
+      }
+    ];
+  });
+  if (mapped.length > 0) return mapped;
+  if (!fallbackAccount) {
+    throw invalidPreview("MCA withdraw preview is missing mcaAccountId");
+  }
+  return [
+    {
+      receiverId: fallbackAccount,
+      actions: [
+        {
+          type: "FunctionCall",
+          params: {
+            methodName: "exec",
+            args: executionArgs,
+            gas: "300000000000000",
+            deposit: "0"
+          }
+        }
+      ]
     }
-  },
-  warn: (...args) => {
-    if (shouldLog("warn")) {
-      console.warn(...args);
+  ];
+}
+function buildMcaWithdrawRelayerRequest(input) {
+  const mcaAccountId = input.mcaAccountId.trim();
+  if (!mcaAccountId) {
+    throw new SwapSdkError(
+      "INVALID_REQUEST",
+      "build",
+      "mcaAccountId is required for an MCA relayer request"
+    );
+  }
+  const recipient = pickString(input.quoteBuild.recipient) || pickString(input.recipientFallback);
+  return {
+    ...input.quoteBuild,
+    ...recipient ? { recipient } : {},
+    mcaRelayer: {
+      ...input.mcaRelayer,
+      wallet: cloneValue(input.mcaRelayer.wallet),
+      business: cloneObject(input.mcaRelayer.business)
+    },
+    mca: {
+      ...input.quoteBuild.mca ?? {},
+      flow: input.quoteBuild.mca?.flow ?? input.quoteBuild.mca?.mcaFlow ?? "withdraw",
+      mcaAccountId
+    },
+    deposit_address: input.depositAddress.trim(),
+    is_cross_chain: input.isCrossChain,
+    tx_type: "mca-withdraw-relayer",
+    multi_addr: mcaAccountId
+  };
+}
+function extractPreviewField(preview, field) {
+  const transactions = preview.transactions;
+  if (Array.isArray(transactions)) {
+    for (const transaction of transactions) {
+      if (!isPlainObject2(transaction) || !isPlainObject2(transaction.args)) {
+        continue;
+      }
+      const value = parseObject(transaction.args[field]);
+      if (value) return cloneObject(value);
     }
-  },
-  error: (...args) => {
-    if (shouldLog("error")) {
-      console.error(...args);
+  }
+  const actions = preview.actions;
+  if (Array.isArray(actions)) {
+    for (const action of actions) {
+      if (!isPlainObject2(action) || action.type !== "FunctionCall" || !isPlainObject2(action.params)) {
+        continue;
+      }
+      const args = parseObject(action.params.args);
+      if (!args) continue;
+      const value = parseObject(args[field]);
+      if (value) return cloneObject(value);
     }
   }
-};
-
-// src/utils/index.ts
-var bluechipTokensConfig = null;
-function setBluechipTokensConfig(config) {
-  bluechipTokensConfig = config;
-}
-function getBluechipTokensConfig() {
-  if (!bluechipTokensConfig) {
-    logger.warn(
-      "getBluechipTokensConfig - Bluechip tokens config not set, returning empty config"
-    );
-    return {};
+  return void 0;
+}
+function extractDepositAddressFromObject(value) {
+  if (!isPlainObject2(value)) return "";
+  const direct = pickString(value.depositAddress) || pickString(value.deposit_address);
+  if (direct) return direct;
+  if (!isPlainObject2(value.deposit)) return "";
+  return pickString(value.deposit.depositAddress) || pickString(value.deposit.deposit_address);
+}
+function parseObject(value) {
+  if (isPlainObject2(value)) return value;
+  if (typeof value !== "string" || !value.trim()) return void 0;
+  try {
+    const parsed = JSON.parse(value);
+    return isPlainObject2(parsed) ? parsed : void 0;
+  } catch {
+    return void 0;
   }
-  return bluechipTokensConfig;
 }
-function normalizeTokenId(tokenId, wrapNearContractId = "wrap.near") {
-  if (!tokenId) {
-    logger.error("normalizeTokenId - Empty tokenId:", tokenId);
-    return "";
+function isPlainObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function pickString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : "";
+}
+function normalizeGas(value) {
+  if (typeof value === "number" && Number.isFinite(value) && value >= 0) {
+    return BigInt(Math.trunc(value)) < 10000n ? (BigInt(Math.trunc(value)) * 1000000000000n).toString() : BigInt(Math.trunc(value)).toString();
   }
-  let normalized = tokenId.replace(/^nep141:/, "");
-  if (normalized === "near") {
-    normalized = wrapNearContractId;
+  if (typeof value === "string" && /^\d+$/.test(value.trim())) {
+    const gas = BigInt(value.trim());
+    return gas < 10000n ? (gas * 1000000000000n).toString() : gas.toString();
   }
-  if (!normalized) {
-    logger.error("normalizeTokenId - Result is empty:", {
-      tokenId,
-      normalized
-    });
+  return "300000000000000";
+}
+function normalizeDeposit2(value) {
+  if (value === void 0 || value === null || value === "") return "0";
+  const decimal = typeof value === "number" && Number.isFinite(value) && value >= 0 ? String(value) : typeof value === "string" ? value.trim() : "";
+  if (!decimal) {
+    throw invalidPreview("MCA withdraw transaction has an invalid NEAR deposit");
+  }
+  try {
+    return parseUnits(decimal, 24);
+  } catch (error) {
+    throw new SwapSdkError(
+      "INVALID_API_RESPONSE",
+      "build",
+      "MCA withdraw transaction has an invalid NEAR deposit",
+      { cause: error }
+    );
   }
-  return normalized;
 }
-function isNearIntentsSupportedToken(token, bluechipTokens) {
-  if (!token?.symbol || !token?.address) {
-    return false;
+function cloneObject(value) {
+  return cloneValue(value);
+}
+function cloneValue(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+function invalidPreview(message) {
+  return new SwapSdkError("INVALID_API_RESPONSE", "build", message);
+}
+
+// src/mca/McaSwapService.ts
+var McaSwapService = class {
+  constructor(client, config) {
+    this.client = client;
+    this.relayerReports = /* @__PURE__ */ new Map();
+    this.now = config.now ?? Date.now;
+    this.maxQuoteAgeMs = config.maxQuoteAgeMs === void 0 ? 3e4 : config.maxQuoteAgeMs;
+    this.reportMode = config.reportMode ?? "auto";
+    this.onEvent = config.onEvent;
+    this.resolveSignerIdentity = config.resolveSignerIdentity;
+    this.resolveMessageSigner = config.resolveMessageSigner;
+    this.buildStandardSwap = config.buildStandardSwap;
   }
-  const config = bluechipTokens || getBluechipTokensConfig();
-  const normalizedSymbol = token.symbol.toUpperCase();
-  const symbolKey = normalizedSymbol === "NEAR" || normalizedSymbol === "WNEAR" ? "NEAR" : normalizedSymbol;
-  const tokenConfig = config[symbolKey];
-  if (!tokenConfig) {
-    return false;
+  async quote(request, options = {}) {
+    const signer = await this.readSignerIdentity(request.signerChain, "quote");
+    const rawRequest = serializeMcaQuoteRequest(request, signer);
+    const raw = await this.client.quoteRaw(rawRequest, options);
+    const normalizationRequest = {
+      ...request,
+      extensions: {
+        ...request.extensions ?? {},
+        mca: rawRequest.mca
+      }
+    };
+    const quote = normalizeQuote(normalizationRequest, raw, this.now());
+    return normalizeMcaQuote(request, signer, quote);
   }
-  const normalizeAddress = (addr) => addr.replace(/^nep141:/, "").toLowerCase();
-  const tokenAddress = normalizeAddress(token.address);
-  const configAddress = normalizeAddress(tokenConfig.address || "");
-  const configAssetId = tokenConfig.assetId ? normalizeAddress(tokenConfig.assetId) : "";
-  return tokenAddress === configAddress || tokenAddress === configAssetId;
-}
-function findBestBluechipToken(bluechipTokens, wrapNearContractId = "wrap.near") {
-  const preferredTokens = [];
-  if (bluechipTokens.USDT?.address) {
-    preferredTokens.push({
-      address: bluechipTokens.USDT.address,
-      symbol: "USDT",
-      decimals: bluechipTokens.USDT.decimals || 6,
-      chain: "near"
-    });
+  async build(input) {
+    this.assertQuoteFresh(input.quote);
+    if (input.quote.executionMode === "withdraw-relayer") {
+      throw new SwapSdkError(
+        "INVALID_REQUEST",
+        "build",
+        "MCA relayer withdraw requires a signature and must use swap()"
+      );
+    }
+    const build = input.quote.executionMode === "deposit" ? await this.buildStandardSwap(input) : this.buildNearWithdraw(input.quote);
+    return {
+      ...build,
+      reportContext: {
+        ...build.reportContext,
+        multiAddr: input.quote.mcaAccountId,
+        ...input.quote.executionMode === "deposit" ? {
+          txType: build.isCrossChain ? "cross-chain" : "same-chain"
+        } : {}
+      }
+    };
   }
-  if (bluechipTokens.USDC?.address) {
-    preferredTokens.push({
-      address: bluechipTokens.USDC.address,
-      symbol: "USDC",
-      decimals: bluechipTokens.USDC.decimals || 6,
-      chain: "near"
+  async swap(input) {
+    this.assertQuoteFresh(input.quote);
+    if (input.quote.executionMode === "withdraw-relayer") {
+      return this.executeRelayerWithdraw({ ...input, quote: input.quote });
+    }
+    const build = await this.build({
+      quote: input.quote,
+      signal: input.signal,
+      idempotencyKey: input.idempotencyKey
     });
-  }
-  if (bluechipTokens.NEAR?.address) {
-    preferredTokens.push({
-      address: bluechipTokens.NEAR.address,
-      symbol: "wNEAR",
-      decimals: bluechipTokens.NEAR.decimals || 24,
-      chain: "near"
+    const nearStatusKey = input.quote.executionMode === "withdraw-near" && input.waitFor === "completed" ? extractMcaWithdrawDepositAddress({
+      preview: input.quote.preview,
+      bestQuote: input.quote.raw.bestQuote
+    }) : void 0;
+    if (input.quote.executionMode === "withdraw-near" && input.waitFor === "completed" && !nearStatusKey) {
+      throw new SwapSdkError(
+        "INVALID_API_RESPONSE",
+        "status",
+        "MCA NEAR withdraw is missing a status deposit address"
+      );
+    }
+    const result = await this.client.executeSwap({
+      build,
+      waitFor: input.quote.executionMode === "withdraw-near" && input.waitFor === "completed" ? "source-confirmed" : input.waitFor,
+      signal: input.signal,
+      onEvent: input.onEvent
     });
+    if (input.quote.executionMode === "withdraw-near" && input.waitFor === "completed") {
+      const status = await this.client.waitForOrder({
+        orderId: nearStatusKey,
+        router: input.quote.route.router,
+        signal: input.signal
+      });
+      this.emitEvent(
+        {
+          type: "order-status",
+          executionId: result.executionId,
+          status: status.status
+        },
+        input.onEvent
+      );
+      result.status = status.status === "unknown" || status.status === "pending" ? "processing" : status.status;
+      if (status.status === "completed") {
+        this.emitEvent(
+          { type: "completed", executionId: result.executionId },
+          input.onEvent
+        );
+      }
+    }
+    return result;
   }
-  if (preferredTokens.length === 0) {
-    logger.warn(
-      "findBestBluechipToken - No preferred tokens found, using wrap.near"
+  reportIfManaged(result) {
+    const request = this.relayerReports.get(result.executionId);
+    if (!request) return void 0;
+    return this.client.reportRaw(request);
+  }
+  buildNearWithdraw(quote) {
+    const business = extractMcaWithdrawBusiness(quote.preview);
+    if (!business) {
+      throw new SwapSdkError(
+        "INVALID_API_RESPONSE",
+        "build",
+        "MCA NEAR withdraw preview is missing business"
+      );
+    }
+    const recipient = quote.request.recipient?.trim();
+    const signerWallet = extractMcaWithdrawSignerWallet(quote.preview) ?? (recipient ? formatMcaWallet("near", recipient) : void 0);
+    if (!signerWallet) {
+      throw new SwapSdkError(
+        "INVALID_REQUEST",
+        "build",
+        "MCA NEAR withdraw requires a NEAR recipient or signer_wallet"
+      );
+    }
+    const transactions = buildNearMcaWithdrawTransactions(quote.preview, {
+      business,
+      signerWallet,
+      signature: "",
+      mcaAccountId: quote.mcaAccountId
+    });
+    const request = buildRequestFromQuote(quote);
+    const depositAddress = extractMcaWithdrawDepositAddress({
+      preview: quote.preview,
+      bestQuote: quote.raw.bestQuote
+    });
+    const build = normalizeBuild(
+      {
+        isCrossChain: true,
+        chainType: "near",
+        router: quote.route.router,
+        fromChain: request.fromChain,
+        toChain: request.toChain,
+        tokenIn: {
+          address: request.tokenIn,
+          symbol: quote.tokenIn.symbol ?? "",
+          decimals: quote.tokenIn.decimals ?? 0
+        },
+        tokenOut: {
+          address: request.tokenOut,
+          symbol: quote.tokenOut.symbol ?? "",
+          decimals: quote.tokenOut.decimals ?? 0
+        },
+        amountIn: quote.amountIn,
+        estimatedOut: quote.estimatedOut,
+        minAmountOut: quote.minAmountOut,
+        tx: transactions,
+        approve: null,
+        ...depositAddress ? { deposit: { depositAddress } } : {}
+      },
+      void 0,
+      request
     );
     return {
-      address: wrapNearContractId,
-      symbol: "wNEAR",
-      decimals: 24,
-      chain: "near"
+      ...build,
+      reportContext: {
+        txType: "mca-withdraw-near",
+        multiAddr: quote.mcaAccountId,
+        ...depositAddress ? { depositAddress } : {},
+        ...recipient ? { recipient } : {},
+        isCrossChain: true
+      }
     };
   }
-  logger.debug("findBestBluechipToken - Selected token:", preferredTokens[0]);
-  return preferredTokens[0];
-}
-function convertSlippageToBasisPoints(slippage) {
-  if (slippage >= 1) {
-    return Math.round(slippage);
+  async executeRelayerWithdraw(input) {
+    const executionId = createExecutionId();
+    const emit = (event) => this.emitEvent(event, input.onEvent);
+    try {
+      const signer = this.resolveMessageSigner(input.quote.signer.chain);
+      const currentSigner = await this.readSignerIdentity(
+        input.quote.signer.chain,
+        "sign",
+        signer
+      );
+      assertSignerMatchesQuote(currentSigner, input.quote.signer);
+      const business = extractMcaWithdrawBusiness(input.quote.preview);
+      if (!business) {
+        throw new SwapSdkError(
+          "INVALID_API_RESPONSE",
+          "sign",
+          "MCA relayer preview is missing business"
+        );
+      }
+      const message = readString2(input.quote.preview.messageToSign);
+      if (!message) {
+        throw new SwapSdkError(
+          "INVALID_API_RESPONSE",
+          "sign",
+          "MCA relayer preview is missing messageToSign"
+        );
+      }
+      const depositAddress = extractMcaWithdrawDepositAddress({
+        snapshotDepositAddress: readString2(input.quote.raw.depositAddress),
+        preview: input.quote.preview,
+        bestQuote: input.quote.raw.bestQuote
+      });
+      if (!depositAddress) {
+        throw new SwapSdkError(
+          "INVALID_API_RESPONSE",
+          "build",
+          "MCA relayer preview is missing a deposit address"
+        );
+      }
+      emit({ type: "signing-requested", executionId });
+      await input.beforeSign?.({
+        chain: currentSigner.chain,
+        identityKey: currentSigner.identityKey,
+        message,
+        business
+      });
+      let signature;
+      try {
+        signature = (await signer.signMessage(message, {
+          signal: input.signal,
+          context: {
+            flow: "withdraw",
+            mcaAccountId: input.quote.mcaAccountId,
+            business
+          }
+        })).trim();
+      } catch (error) {
+        if (error instanceof SwapSdkError) throw error;
+        throw new SwapSdkError(
+          "SIGNING_FAILED",
+          "sign",
+          "Failed to sign the MCA relayer message",
+          { cause: error }
+        );
+      }
+      if (!signature) {
+        throw new SwapSdkError(
+          "SIGNING_FAILED",
+          "sign",
+          "MCA signer returned an empty signature"
+        );
+      }
+      const mcaRelayer = {
+        mcaAccountId: input.quote.mcaAccountId,
+        wallet: formatMcaWallet(
+          currentSigner.chain,
+          currentSigner.identityKey
+        ),
+        business,
+        signature
+      };
+      const request = buildMcaWithdrawRelayerRequest({
+        quoteBuild: buildRequestFromQuote(input.quote),
+        mcaRelayer,
+        isCrossChain: input.quote.raw.isCrossChain ?? true,
+        depositAddress,
+        mcaAccountId: input.quote.mcaAccountId,
+        recipientFallback: input.quote.request.recipient
+      });
+      const raw = await this.client.buildRaw(request, {
+        signal: input.signal,
+        idempotencyKey: input.idempotencyKey
+      });
+      const orderId = readString2(raw.orderId) ?? readRecordString2(raw.deposit, "orderId");
+      const router = readString2(raw.router) ?? input.quote.route.router;
+      const submittedDepositAddress = readRecordString2(raw.deposit, "depositAddress") ?? depositAddress;
+      if (!orderId || !router) {
+        throw new SwapSdkError(
+          "INVALID_API_RESPONSE",
+          "submit",
+          "MCA relayer submission is missing orderId or router"
+        );
+      }
+      const reportRequest = {
+        sender: input.quote.request.sender,
+        recipient: input.quote.request.recipient ?? input.quote.request.sender,
+        from_hash: orderId,
+        from_token: request.tokenIn,
+        to_token: request.tokenOut,
+        deposit_address: submittedDepositAddress,
+        from_chain: request.fromChain,
+        to_chain: request.toChain,
+        amount_in: request.amountIn,
+        estimated_out: input.quote.estimatedOut,
+        router,
+        is_cross_chain: true,
+        tx_type: "mca-withdraw-relayer",
+        multi_addr: input.quote.mcaAccountId,
+        swapId: orderId
+      };
+      this.relayerReports.set(executionId, reportRequest);
+      const result = {
+        executionId,
+        status: "submitted",
+        router,
+        orderId,
+        depositAddress: submittedDepositAddress,
+        report: { status: "skipped" },
+        raw
+      };
+      emit({ type: "submitted", executionId, orderId });
+      if (this.reportMode === "auto") {
+        try {
+          await this.client.reportRaw(reportRequest, { signal: input.signal });
+          result.report = { status: "reported" };
+        } catch (error) {
+          const warning = {
+            code: "REPORT_FAILED",
+            message: "MCA withdraw submitted but report failed",
+            cause: error
+          };
+          result.report = { status: "failed", warning };
+          emit({ type: "warning", executionId, warning });
+        }
+      }
+      if (input.waitFor === "completed") {
+        const status = await this.client.waitForOrder({
+          orderId,
+          router,
+          signal: input.signal
+        });
+        emit({ type: "order-status", executionId, status: status.status });
+        result.status = status.status === "unknown" || status.status === "pending" ? "processing" : status.status;
+        if (status.status === "completed") {
+          emit({ type: "completed", executionId });
+        }
+      }
+      return result;
+    } catch (error) {
+      const sdkError = asSwapSdkError(error, "submit");
+      emit({ type: "failed", executionId, error: sdkError });
+      throw sdkError;
+    }
   }
-  if (slippage > 0 && slippage < 0.01) {
-    return Math.round(slippage * 1e4);
+  async readSignerIdentity(chain, stage, provider = this.resolveSignerIdentity(chain)) {
+    let identityKey;
+    try {
+      identityKey = (await provider.getIdentityKey()).trim();
+    } catch (error) {
+      if (error instanceof SwapSdkError) throw error;
+      throw new SwapSdkError(
+        "SIGNING_FAILED",
+        stage,
+        "Failed to read the MCA signer identity",
+        { cause: error }
+      );
+    }
+    if (!identityKey) {
+      throw new SwapSdkError(
+        "SIGNING_FAILED",
+        stage,
+        "MCA executor returned an empty signer identity"
+      );
+    }
+    return { chain, identityKey };
   }
-  if (slippage >= 0.01 && slippage < 1) {
-    return Math.round(slippage * 100);
+  emitEvent(event, local) {
+    this.onEvent?.(event);
+    if (local !== this.onEvent) local?.(event);
   }
-  return Math.round(slippage);
-}
-function normalizeDestinationAsset(assetId, wrapNearContractId = "wrap.near") {
-  if (!assetId) return assetId;
-  if (assetId.startsWith("nep141:") || assetId.startsWith("nep245:")) {
-    return assetId;
+  assertQuoteFresh(quote) {
+    const now = this.now();
+    const expiredByApi = quote.expiresAt !== void 0 && now > quote.expiresAt;
+    const expiredByAge = this.maxQuoteAgeMs !== null && now - quote.receivedAt > Math.max(0, this.maxQuoteAgeMs);
+    if (expiredByApi || expiredByAge) {
+      throw new SwapSdkError(
+        "QUOTE_EXPIRED",
+        "build",
+        "Quote has expired; request a fresh quote"
+      );
+    }
   }
-  if (assetId === "near" || assetId === "nep141:near") {
-    return `nep141:${wrapNearContractId}`;
+};
+function buildRequestFromQuote(quote) {
+  const context = quote.buildContext;
+  return {
+    ...context.request,
+    router: context.router,
+    ...context.market ? { market: context.market } : {},
+    expectedOut: context.expectedOut,
+    minAmountOut: context.minAmountOut,
+    preSwap: context.preSwap,
+    bridge: context.bridge,
+    ...context.quoteId ? { quoteId: context.quoteId } : {}
+  };
+}
+function assertSignerMatchesQuote(signer, expected) {
+  if (!isSameMcaSignerIdentity(signer, expected)) {
+    throw new SwapSdkError(
+      "SIGNING_FAILED",
+      "sign",
+      "MCA signer does not match the signer used for the quote"
+    );
   }
-  if (assetId.includes(".")) {
-    return `nep141:${normalizeTokenId(assetId, wrapNearContractId)}`;
+}
+function readString2(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function readRecordString2(value, field) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return void 0;
   }
-  return assetId;
+  return readString2(value[field]);
 }
-var NearSmartRouter = class {
+
+// src/client/SwapClient.ts
+var SwapClient = class {
   constructor(config) {
-    this.findPathAdapter = config.findPathAdapter;
-    this.nearChainAdapter = config.nearChainAdapter;
-    this.configAdapter = config.configAdapter;
-    this.wrapNearContractId = this.configAdapter.getWrapNearContractId();
-    this.refExchangeId = this.configAdapter.getRefExchangeId();
-    this.tokenStorageDepositRead = this.configAdapter.getTokenStorageDepositRead?.() || "1250000000000000000000";
-  }
-  /**
-   * Get a swap quote (normalizes token ids and queries FindPath for routes).
-   */
-  async quote(params) {
-    try {
-      const {
-        tokenIn,
-        tokenOut,
-        amountIn,
-        slippage,
-        swapType: _swapType = "EXACT_INPUT"
-        // Currently not used, reserved for future use
-      } = params;
-      if (!tokenIn?.address || !tokenOut?.address) {
-        return {
-          success: false,
-          tokenIn: params.tokenIn,
-          tokenOut: params.tokenOut,
-          amountIn: params.amountIn,
-          amountOut: "0",
-          minAmountOut: "0",
-          routes: [],
-          error: "Missing token address"
-        };
-      }
-      const normalizedTokenIn = normalizeTokenId(
-        tokenIn.address,
-        this.wrapNearContractId
-      );
-      const normalizedTokenOut = normalizeTokenId(
-        tokenOut.address,
-        this.wrapNearContractId
-      );
-      if (!normalizedTokenIn || !normalizedTokenOut) {
-        logger.error("SmartRouter quote - Invalid token addresses:", {
-          tokenIn: {
-            original: tokenIn.address,
-            normalized: normalizedTokenIn
-          },
-          tokenOut: {
-            original: tokenOut.address,
-            normalized: normalizedTokenOut
-          }
-        });
-        return {
-          success: false,
-          tokenIn: params.tokenIn,
-          tokenOut: params.tokenOut,
-          amountIn: params.amountIn,
-          amountOut: "0",
-          minAmountOut: "0",
-          routes: [],
-          error: `Invalid token address: tokenIn=${normalizedTokenIn || "empty"}, tokenOut=${normalizedTokenOut || "empty"}`
-        };
-      }
-      const slippageBps = convertSlippageToBasisPoints(slippage);
-      const slippageDecimalForApi = slippageBps / 1e4;
-      logger.debug("SmartRouter quote - Calling findPath:", {
-        tokenIn: normalizedTokenIn,
-        tokenOut: normalizedTokenOut,
-        amountIn,
-        slippage: slippageDecimalForApi,
-        slippageBps
-      });
-      const response = await this.findPathAdapter.findPath({
-        tokenIn: normalizedTokenIn,
-        tokenOut: normalizedTokenOut,
-        amountIn: String(amountIn),
-        slippage: slippageDecimalForApi,
-        supportLedger: false
-      });
-      logger.debug("SmartRouter quote - findPath response:", {
-        result_code: response?.result_code,
-        result_msg: response?.result_msg || response?.result_message,
-        hasRoutes: !!response?.result_data?.routes?.length
+    this.inFlight = /* @__PURE__ */ new Set();
+    this.reportRequests = /* @__PURE__ */ new Map();
+    this.config = config;
+    this.api = new ApiClient(config);
+    this.registry = new ExecutorRegistry(config.executors ?? []);
+    this.reportMode = config.reportMode ?? "auto";
+    this.now = config.now ?? Date.now;
+    this.managedSwapFlow = new McaSwapService(this, {
+      now: this.now,
+      maxQuoteAgeMs: config.maxQuoteAgeMs,
+      reportMode: this.reportMode,
+      resolveSignerIdentity: (chain) => this.registry.getSigner(chain),
+      resolveMessageSigner: (chain) => this.registry.getSigner(chain, true),
+      buildStandardSwap: (input) => this.buildStandardSwap(input),
+      ...config.onEvent ? { onEvent: config.onEvent } : {}
+    });
+  }
+  quoteRaw(request, options = {}) {
+    return this.api.quote(request, options);
+  }
+  async quote(request, options = {}) {
+    if (isMcaQuoteRequest(request)) {
+      return this.managedSwapFlow.quote(request, options);
+    }
+    return this.quoteStandard(request, options);
+  }
+  async quoteStandard(request, options = {}) {
+    const rawRequest = serializeQuoteRequest(request);
+    const raw = await this.api.quote(rawRequest, options);
+    return normalizeQuote(request, raw, this.now());
+  }
+  buildRaw(request, options = {}) {
+    return this.api.build(request, options);
+  }
+  async buildSwap(input) {
+    if (isMcaQuote(input.quote)) {
+      return this.managedSwapFlow.build({
+        quote: input.quote,
+        signal: input.signal,
+        idempotencyKey: input.idempotencyKey
       });
-      if (response?.result_code !== 0 || !response?.result_data?.routes?.length) {
-        return {
-          success: false,
-          tokenIn,
-          tokenOut,
-          amountIn,
-          amountOut: "0",
-          minAmountOut: "0",
-          routes: [],
-          error: response?.result_msg || response?.result_message || "No route found"
-        };
-      }
-      const { routes: serverRoutes, amount_out } = response.result_data;
-      const slippageDecimal = new Big__default.default(slippageBps).div(1e4);
-      const routes = serverRoutes.map((route) => ({
-        pools: route.pools.map((pool) => ({
-          pool_id: Number(pool.pool_id),
-          token_in: pool.token_in || normalizedTokenIn,
-          token_out: pool.token_out || normalizedTokenOut,
-          amount_in: pool.amount_in,
-          amount_out: pool.amount_out,
-          fee: pool.fee
-        })),
-        amountIn,
-        amountOut: route.amount_out || amount_out || "0"
-      }));
-      const amountOut = new Big__default.default(amount_out || 0);
-      const minAmountOut = amountOut.mul(new Big__default.default(1).minus(slippageDecimal)).toFixed(0, Big__default.default.roundDown);
-      return {
-        success: true,
-        tokenIn,
-        tokenOut,
-        amountIn,
-        amountOut: amountOut.toFixed(0),
-        minAmountOut,
-        routes,
-        // Save raw serverRoutes data for executeSwap
-        rawRoutes: serverRoutes
-      };
-    } catch (error) {
-      return {
-        success: false,
-        tokenIn: params.tokenIn,
-        tokenOut: params.tokenOut,
-        amountIn: params.amountIn,
-        amountOut: "0",
-        minAmountOut: "0",
-        routes: [],
-        error: error?.message || "Quote failed"
-      };
     }
+    return this.buildStandardSwap(input);
+  }
+  async buildStandardSwap(input) {
+    this.assertQuoteFresh(input.quote);
+    const executionId = createExecutionId();
+    this.emit({ type: "build-started", executionId });
+    const context = input.quote.buildContext;
+    const request = {
+      ...context.request,
+      router: context.router,
+      ...context.market ? { market: context.market } : {},
+      expectedOut: context.expectedOut,
+      minAmountOut: context.minAmountOut,
+      preSwap: context.preSwap,
+      bridge: context.bridge,
+      ...context.quoteId ? { quoteId: context.quoteId } : {}
+    };
+    const raw = await this.api.build(request, {
+      signal: input.signal,
+      idempotencyKey: input.idempotencyKey
+    });
+    const build = normalizeBuild(raw, executionId, request);
+    this.emit({ type: "build-completed", executionId });
+    return build;
   }
-  /**
-   * Execute a swap: optionally adds `storage_deposit` for the recipient, then calls REF via `ft_transfer_call`.
-   */
-  async executeSwap(params) {
+  async executeSwap(input) {
+    const { build } = input;
+    if (this.inFlight.has(build.executionId)) {
+      throw new SwapSdkError(
+        "INVALID_REQUEST",
+        "sign",
+        `Execution ${build.executionId} is already in progress`
+      );
+    }
+    this.inFlight.add(build.executionId);
+    const emit = (event) => {
+      this.emit(event);
+      if (input.onEvent !== this.config.onEvent) input.onEvent?.(event);
+    };
     try {
-      const { quote, recipient, depositAddress } = params;
-      if (!quote.success || !quote.routes.length) {
-        return {
-          success: false,
-          error: "Invalid quote"
-        };
-      }
-      const swapActions = [];
-      const routesToUse = quote.rawRoutes || quote.routes;
-      routesToUse.forEach((route) => {
-        const pools = route.pools || [];
-        pools.forEach((pool) => {
-          const poolCopy = { ...pool };
-          if (+(poolCopy?.amount_in || 0) == 0) {
-            delete poolCopy.amount_in;
-          }
-          poolCopy.pool_id = Number(poolCopy.pool_id);
-          swapActions.push(poolCopy);
+      const executor = this.registry.get(build.execution.kind);
+      const context = {
+        executionId: build.executionId,
+        signal: input.signal,
+        waitFor: input.waitFor ?? "submitted",
+        emit,
+        ...input.beforeSign ? { beforeSign: input.beforeSign } : {}
+      };
+      await executor.validate(build.execution, context);
+      emit({ type: "signing-requested", executionId: build.executionId });
+      const chainResult = await executor.execute(build.execution, context);
+      let orderId = chainResult.orderId ?? build.order?.orderId;
+      let orderRouter = build.order?.router;
+      let orderChainId = build.order?.chainId;
+      if (chainResult.signature) {
+        if (build.execution.kind !== "evm-signature") {
+          throw new SwapSdkError(
+            "INVALID_TRANSACTION",
+            "submit",
+            "Only signature executions can submit signed orders"
+          );
+        }
+        const submitParams = build.execution.request.submit?.params;
+        const submitRouter = readNonEmptyString(submitParams?.router) ?? build.execution.request.router;
+        const submitQuoteId = readNonEmptyString(submitParams?.quoteId) ?? build.execution.request.quoteId;
+        const signingScheme = readNonEmptyString(submitParams?.signingScheme) ?? chainResult.signingScheme ?? build.execution.request.signingScheme ?? "eip712";
+        const submitted = await this.api.submitOrder(
+          {
+            router: submitRouter,
+            quoteId: submitQuoteId,
+            signature: chainResult.signature,
+            signingScheme
+          },
+          { signal: input.signal }
+        );
+        orderId = submitted.orderId;
+        orderRouter = readNonEmptyString(submitted.router) ?? submitRouter;
+        orderChainId = String(
+          submitted.chainId ?? build.execution.request.chainId
+        );
+      }
+      const result = {
+        executionId: build.executionId,
+        status: chainResult.status,
+        router: build.router,
+        ...chainResult.txHash ? { txHash: chainResult.txHash } : {},
+        ...chainResult.txHashes ? { txHashes: chainResult.txHashes } : {},
+        ...orderId ? { orderId } : {},
+        ...build.deposit?.depositAddress ? { depositAddress: build.deposit.depositAddress } : {},
+        report: { status: "skipped" },
+        raw: chainResult.raw ?? build.raw
+      };
+      if (chainResult.status === "requires-user-action") {
+        emit({
+          type: "requires-user-action",
+          executionId: build.executionId
         });
-      });
-      if (!swapActions.length) {
-        return {
-          success: false,
-          error: "No swap actions"
-        };
-      }
-      const finalRecipient = depositAddress || recipient;
-      const transactions = [];
-      if (finalRecipient && quote.tokenOut?.address) {
-        let isRegistered = false;
-        try {
-          const storageBalance = await this.nearChainAdapter.view({
-            contractId: quote.tokenOut.address,
-            methodName: "storage_balance_of",
-            args: {
-              account_id: finalRecipient
-            }
+      } else {
+        emit({
+          type: "submitted",
+          executionId: build.executionId,
+          ...chainResult.txHash ? { txHash: chainResult.txHash } : {},
+          ...orderId ? { orderId } : {}
+        });
+        if (chainResult.status === "source-confirmed") {
+          emit({
+            type: "source-confirmed",
+            executionId: build.executionId
           });
-          isRegistered = !!storageBalance;
-        } catch (err) {
-          isRegistered = false;
         }
-        if (!isRegistered) {
-          logger.debug("SmartRouter - Registering recipient account:", {
-            contractId: quote.tokenOut.address,
-            accountId: finalRecipient
-          });
-          transactions.push({
-            contractId: quote.tokenOut.address,
-            methodName: "storage_deposit",
-            args: {
-              account_id: finalRecipient,
-              registration_only: true
-            },
-            gas: "50",
-            expandDeposit: this.tokenStorageDepositRead
-          });
+      }
+      const reportRequest = this.createReportRequest(build, result);
+      if (reportRequest) {
+        this.reportRequests.set(build.executionId, reportRequest);
+      }
+      if (this.reportMode === "auto" && reportRequest) {
+        try {
+          await this.api.report(reportRequest, { signal: input.signal });
+          result.report = { status: "reported" };
+        } catch (error) {
+          const warning = {
+            code: "REPORT_FAILED",
+            message: "Swap submitted but report failed",
+            cause: error
+          };
+          result.report = { status: "failed", warning };
+          emit({ type: "warning", executionId: build.executionId, warning });
         }
       }
-      const swapMsg = {
-        force: 0,
-        actions: swapActions,
-        skip_unwrap_near: false
-      };
-      if (finalRecipient) {
-        swapMsg.swap_out_recipient = finalRecipient;
-      }
-      logger.debug("SmartRouter - Executing swap:", {
-        contractId: quote.tokenIn.address,
-        receiver_id: this.refExchangeId,
-        amount: quote.amountIn,
-        swapMsg,
-        swapActionsCount: swapActions.length,
-        recipient: finalRecipient,
-        tokenOut: quote.tokenOut?.address
-      });
-      transactions.push({
-        contractId: quote.tokenIn.address,
-        methodName: "ft_transfer_call",
-        args: {
-          receiver_id: this.refExchangeId,
-          amount: quote.amountIn,
-          msg: JSON.stringify(swapMsg)
-        },
-        gas: "250",
-        // NEP-141 requires attaching 1 yoctoNEAR for certain calls.
-        expandDeposit: "1"
-      });
-      const result = await this.nearChainAdapter.call({
-        transactions
-      });
-      if (result.status === "success") {
-        return {
-          success: true,
-          txHash: result.txHash,
-          txHashArray: result.txHashArr || (result.txHash ? [result.txHash] : [])
-        };
-      } else {
-        return {
-          success: false,
-          error: result.message || "Execute swap failed"
-        };
+      if ((input.waitFor ?? "submitted") === "completed" && orderId) {
+        const status = await this.waitForOrder({
+          orderId,
+          router: orderRouter ?? build.router,
+          chainId: orderChainId,
+          signal: input.signal
+        });
+        result.status = status.status === "unknown" || status.status === "pending" ? "processing" : status.status;
+        if (status.status === "completed") {
+          emit({ type: "completed", executionId: build.executionId });
+        }
       }
+      return result;
     } catch (error) {
-      return {
-        success: false,
-        error: error?.message || "Execute swap failed"
-      };
+      const sdkError = asSwapSdkError(error, "broadcast");
+      emit({ type: "failed", executionId: build.executionId, error: sdkError });
+      throw sdkError;
+    } finally {
+      this.inFlight.delete(build.executionId);
     }
   }
-  /**
-   * Get supported chain
-   */
-  getSupportedChain() {
-    return "near";
-  }
-};
-async function completeQuote(params, config) {
-  const {
-    sourceToken,
-    targetToken,
-    sourceChain,
-    targetChain: _targetChain,
-    // Reserved for future use
-    amountIn,
-    slippage,
-    recipient,
-    refundTo
-  } = params;
-  const { intentsQuotationAdapter, dexRouter, bluechipTokens, configAdapter } = config;
-  const wrapNearContractId = configAdapter.getWrapNearContractId();
-  if (!sourceToken?.address) {
-    throw new Error("Source token address is required");
-  }
-  if (!targetToken?.address) {
-    throw new Error("Target token address is required");
-  }
-  const needsPreSwap = sourceChain === "near" && !isNearIntentsSupportedToken(sourceToken, bluechipTokens);
-  const bluechipToken = findBestBluechipToken(
-    bluechipTokens,
-    wrapNearContractId
-  );
-  if (!bluechipToken?.address) {
-    logger.error("DEX Aggregator - Failed to find bluechip token:", {
-      bluechipToken,
-      bluechipTokens
+  async swap(input) {
+    if (isMcaQuote(input.quote)) {
+      return this.managedSwapFlow.swap(input);
+    }
+    const regularInput = input;
+    const build = await this.buildSwap({
+      quote: regularInput.quote,
+      signal: regularInput.signal,
+      idempotencyKey: regularInput.idempotencyKey
+    });
+    return this.executeSwap({
+      build,
+      waitFor: regularInput.waitFor,
+      signal: regularInput.signal,
+      onEvent: regularInput.onEvent,
+      beforeSign: regularInput.beforeSign
     });
-    throw new Error("Failed to find bluechip token address");
   }
-  logger.debug("DEX Aggregator - Using bluechip token:", {
-    address: bluechipToken.address,
-    symbol: bluechipToken.symbol,
-    decimals: bluechipToken.decimals
-  });
-  let preSwapQuote = null;
-  if (needsPreSwap) {
-    if (!sourceToken?.address) {
-      throw new Error("Source token address is required");
-    }
-    logger.debug("DEX Aggregator - Pre-swap quote params:", {
-      tokenIn: {
-        address: sourceToken.address,
-        symbol: sourceToken.symbol
-      },
-      tokenOut: {
-        address: bluechipToken.address,
-        symbol: bluechipToken.symbol
+  async getOrderStatus(input) {
+    const raw = await this.api.getOrderStatus(
+      {
+        orderId: input.orderId,
+        router: input.router,
+        chainId: input.chainId
       },
-      amountIn,
-      slippage
-    });
-    if (!dexRouter) {
-      throw new Error(
-        `No DEX router registered for sourceChain=${sourceChain}`
+      { signal: input.signal }
+    );
+    return {
+      orderId: input.orderId,
+      router: input.router,
+      status: normalizeOrderStatus(raw),
+      raw
+    };
+  }
+  async waitForOrder(input) {
+    const intervalMs = input.intervalMs ?? 5e3;
+    const timeoutMs = input.timeoutMs ?? 25e4;
+    const startedAt = this.now();
+    for (; ; ) {
+      if (input.signal?.aborted) {
+        throw new SwapSdkError(
+          "REQUEST_ABORTED",
+          "status",
+          "Order polling aborted; any submitted transaction is unaffected"
+        );
+      }
+      const result = await this.getOrderStatus(input);
+      if (result.status === "completed" || result.status === "failed" || result.status === "refunded" || result.status === "expired") {
+        return result;
+      }
+      if (this.now() - startedAt >= timeoutMs) {
+        throw new SwapSdkError(
+          "ORDER_TIMEOUT",
+          "status",
+          `Order status timed out after ${timeoutMs}ms`,
+          { retryable: true }
+        );
+      }
+      await delay(intervalMs, input.signal);
+    }
+  }
+  submitOrderRaw(request, options = {}) {
+    return this.api.submitOrder(request, options);
+  }
+  getOrderStatusRaw(request, options = {}) {
+    return this.api.getOrderStatus(request, options);
+  }
+  reportRaw(request, options = {}) {
+    return this.api.report(request, options);
+  }
+  report(result) {
+    const managedReport = this.managedSwapFlow.reportIfManaged(result);
+    if (managedReport) return managedReport;
+    const request = this.reportRequests.get(result.executionId);
+    if (!request) {
+      throw new SwapSdkError(
+        "INVALID_REQUEST",
+        "report",
+        `No report context for execution ${result.executionId}`
       );
     }
-    preSwapQuote = await dexRouter.quote({
-      tokenIn: sourceToken,
-      tokenOut: bluechipToken,
-      amountIn,
-      slippage,
-      swapType: "EXACT_INPUT"
-    });
-    if (!preSwapQuote.success) {
-      logger.error("DEX Aggregator - Pre-swap quote failed:", {
-        error: preSwapQuote.error,
-        tokenIn: sourceToken,
-        tokenOut: bluechipToken
-      });
-      throw new Error(`Pre-swap quote failed: ${preSwapQuote.error}`);
-    }
-    const preSwapAmountOut = preSwapQuote.amountOut;
-    if (!preSwapAmountOut || new Big__default.default(preSwapAmountOut).lte(0)) {
-      logger.error("DEX Aggregator - Pre-swap amountOut is invalid:", {
-        amountOut: preSwapAmountOut,
-        tokenIn: sourceToken,
-        tokenOut: bluechipToken
-      });
-      throw new Error(
-        "Pre-swap returned invalid amount: amount is too small or zero"
+    return this.api.report(request);
+  }
+  retryReport(result) {
+    return this.report(result);
+  }
+  getHistoryRaw(params, options = {}) {
+    return this.api.getHistory(params, options);
+  }
+  async getHistory(request, options = {}) {
+    const raw = await this.api.getHistory(
+      {
+        sender: request.sender,
+        ...request.page !== void 0 ? { pageNumber: request.page } : {},
+        ...request.pageSize !== void 0 ? { pageSize: request.pageSize } : {}
+      },
+      options
+    );
+    const page = normalizeHistory(raw);
+    if (request.status === void 0) return page;
+    const statuses = new Set(request.status);
+    return {
+      ...page,
+      items: page.items.filter((item) => statuses.has(item.status)),
+      filteredLocally: true
+    };
+  }
+  emit(event) {
+    this.config.onEvent?.(event);
+  }
+  assertQuoteFresh(quote) {
+    const now = this.now();
+    const maxAge = this.config.maxQuoteAgeMs === void 0 ? 3e4 : this.config.maxQuoteAgeMs;
+    const expiredByApi = quote.expiresAt !== void 0 && now > quote.expiresAt;
+    const expiredByAge = maxAge !== null && now - quote.receivedAt > Math.max(0, maxAge);
+    if (expiredByApi || expiredByAge) {
+      throw new SwapSdkError(
+        "QUOTE_EXPIRED",
+        "build",
+        "Quote has expired; request a fresh quote"
       );
     }
-    logger.debug("DEX Aggregator - Pre-swap quote success:", {
-      amountOut: preSwapAmountOut,
-      tokenOut: bluechipToken.symbol,
-      decimals: bluechipToken.decimals
-    });
   }
-  let normalizedSourceAsset;
-  if (needsPreSwap) {
-    const bluechipKey = bluechipToken.symbol?.toUpperCase() === "WNEAR" ? "NEAR" : bluechipToken.symbol?.toUpperCase();
-    const bluechipTokenConfig = bluechipKey && bluechipTokens[bluechipKey] || void 0;
-    if (bluechipTokenConfig?.assetId) {
-      normalizedSourceAsset = bluechipTokenConfig.assetId;
-      logger.debug("Using bluechip token assetId for NearIntents:", {
-        symbol: bluechipToken.symbol,
-        assetId: normalizedSourceAsset,
-        contractAddress: bluechipToken.address
-      });
-    } else {
-      normalizedSourceAsset = `nep141:${bluechipToken.address}`;
-      logger.warn(
-        "Bluechip token assetId not found, using contractAddress with prefix:",
-        {
-          symbol: bluechipToken.symbol,
-          normalizedSourceAsset
-        }
+  createReportRequest(build, result) {
+    const request = build.request;
+    const reportContext = build.reportContext;
+    const fromHash = reportContext?.fromHash ?? result.txHash ?? result.orderId;
+    if (!request || !fromHash) return void 0;
+    return {
+      sender: reportContext?.sender ?? request.sender,
+      recipient: reportContext?.recipient ?? request.recipient ?? request.sender,
+      from_hash: fromHash,
+      from_token: request.tokenIn,
+      to_token: request.tokenOut,
+      deposit_address: reportContext?.depositAddress ?? result.depositAddress ?? "",
+      from_chain: request.fromChain,
+      to_chain: request.toChain,
+      is_cross_chain: reportContext?.isCrossChain ?? build.isCrossChain,
+      amount_in: request.amountIn,
+      estimated_out: build.estimatedOut,
+      router: build.router,
+      tx_type: reportContext?.txType ?? (build.isCrossChain ? "cross-chain" : "same-chain"),
+      ...reportContext?.multiAddr ? { multi_addr: reportContext.multiAddr } : {},
+      ...reportContext?.swapId ?? result.orderId ? { swapId: reportContext?.swapId ?? result.orderId } : {}
+    };
+  }
+};
+function isMcaQuoteRequest(request) {
+  if (!("flow" in request) || !("mcaAccountId" in request)) return false;
+  const flow = Reflect.get(request, "flow");
+  const accountId = Reflect.get(request, "mcaAccountId");
+  return (flow === "deposit" || flow === "withdraw") && typeof accountId === "string" && accountId.trim().length > 0;
+}
+function isMcaQuote(quote) {
+  if (!("executionMode" in quote) || !("mcaAccountId" in quote)) {
+    return false;
+  }
+  const mode = Reflect.get(quote, "executionMode");
+  return mode === "deposit" || mode === "withdraw-near" || mode === "withdraw-relayer";
+}
+function readNonEmptyString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function delay(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(
+        new SwapSdkError(
+          "REQUEST_ABORTED",
+          "status",
+          "Order polling aborted; any submitted transaction is unaffected"
+        )
       );
+      return;
     }
-  } else {
-    if (sourceToken.symbol) {
-      const sourceKey = sourceToken.symbol.toUpperCase();
-      const sourceTokenConfig = bluechipTokens[sourceKey];
-      if (sourceTokenConfig?.assetId) {
-        normalizedSourceAsset = sourceTokenConfig.assetId;
-      } else {
-        normalizedSourceAsset = normalizeTokenId(
-          sourceToken.address,
-          wrapNearContractId
-        );
-        if (!normalizedSourceAsset.startsWith("nep141:")) {
-          normalizedSourceAsset = `nep141:${normalizedSourceAsset}`;
-        }
-      }
-    } else {
-      normalizedSourceAsset = normalizeTokenId(
-        sourceToken.address,
-        wrapNearContractId
+    const onAbort = () => {
+      clearTimeout(timeout);
+      reject(
+        new SwapSdkError(
+          "REQUEST_ABORTED",
+          "status",
+          "Order polling aborted; any submitted transaction is unaffected"
+        )
       );
-      if (!normalizedSourceAsset.startsWith("nep141:")) {
-        normalizedSourceAsset = `nep141:${normalizedSourceAsset}`;
-      }
-    }
-  }
-  let normalizedTargetAsset = targetToken.address;
-  if (normalizedTargetAsset && !normalizedTargetAsset.startsWith("nep141:") && !normalizedTargetAsset.startsWith("nep245:") && normalizedTargetAsset.includes(".")) {
-    normalizedTargetAsset = `nep141:${normalizeTokenId(
-      normalizedTargetAsset,
-      wrapNearContractId
-    )}`;
-  }
-  normalizedTargetAsset = normalizeDestinationAsset(normalizedTargetAsset, wrapNearContractId) || normalizedTargetAsset;
-  const slippageBps = convertSlippageToBasisPoints(slippage);
-  const intentsAmount = needsPreSwap ? preSwapQuote.amountOut : amountIn;
-  logger.debug("DEX Aggregator - Calling NearIntents quotation:", {
-    originAsset: normalizedSourceAsset,
-    destinationAsset: normalizedTargetAsset,
-    amount: intentsAmount,
-    needsPreSwap,
-    preSwapAmountOut: needsPreSwap ? preSwapQuote.amountOut : void 0
-  });
-  const swapTypeForIntents = needsPreSwap ? "FLEX_INPUT" : void 0;
-  logger.debug("DEX Aggregator - swapType for NearIntents:", {
-    needsPreSwap,
-    swapType: swapTypeForIntents || "EXACT_INPUT (default)"
-  });
-  const intentsQuote = await intentsQuotationAdapter.quote({
-    originAsset: normalizedSourceAsset,
-    destinationAsset: normalizedTargetAsset,
-    amount: intentsAmount,
-    refundTo: refundTo || recipient,
-    recipient,
-    slippageTolerance: slippageBps,
-    swapType: swapTypeForIntents
-  });
-  logger.debug("DEX Aggregator - NearIntents quotation result:", {
-    quoteStatus: intentsQuote.quoteStatus,
-    message: intentsQuote.message,
-    hasDepositAddress: !!intentsQuote.quoteSuccessResult?.quote?.depositAddress
+    };
+    const timeout = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, Math.max(0, ms));
+    signal?.addEventListener("abort", onAbort, { once: true });
   });
-  if (intentsQuote.quoteStatus !== "success") {
-    const errorMessage = intentsQuote.message || "Unknown error";
-    logger.error("DEX Aggregator - NearIntents quote failed:", {
-      error: errorMessage,
-      originAsset: normalizedSourceAsset,
-      destinationAsset: normalizedTargetAsset,
-      amount: intentsAmount,
-      needsPreSwap,
-      preSwapAmountOut: needsPreSwap ? preSwapQuote.amountOut : void 0
-    });
-    throw new Error(`Intents quote failed: ${errorMessage}`);
-  }
-  const depositAddress = intentsQuote.quoteSuccessResult?.quote?.depositAddress || "";
-  if (!depositAddress) {
-    throw new Error("Deposit address not found in intents quote");
+}
+
+// src/mca/collateral.ts
+function resolveMcaWithdrawPolicy(input) {
+  const collateral = parseDecimal(input.collateralBalance, "collateralBalance");
+  const available = parseDecimal(input.availableBalance, "availableBalance");
+  const amount = parseDecimal(input.amountIn, "amountIn");
+  const needDecrease = collateral.digits > 0n;
+  return {
+    needDecrease,
+    decreaseAmountBurrow: needDecrease ? input.collateralBalance.trim() : "0",
+    withdrawAll: input.isMax || available.digits > 0n && isAtLeastWithdrawAllThreshold(amount, available)
+  };
+}
+function isAtLeastWithdrawAllThreshold(amount, available) {
+  const [amountScaled, availableScaled] = alignScale(amount, available);
+  return amountScaled * 1000000n >= availableScaled * 999999n;
+}
+function alignScale(a, b) {
+  const scale = Math.max(a.scale, b.scale);
+  return [
+    a.digits * pow10(scale - a.scale),
+    b.digits * pow10(scale - b.scale)
+  ];
+}
+function parseDecimal(value, field) {
+  const trimmed = value.trim();
+  if (!/^(?:0|[1-9]\d*)(?:\.\d+)?$/.test(trimmed)) {
+    throw new SwapSdkError(
+      "INVALID_REQUEST",
+      "quote",
+      `${field} must be a non-negative decimal string`
+    );
   }
+  const [integer = "0", fraction = ""] = trimmed.split(".");
   return {
-    intents: {
-      quote: intentsQuote,
-      depositAddress
-    },
-    preSwap: needsPreSwap ? {
-      quote: preSwapQuote,
-      tokenIn: sourceToken,
-      tokenOut: bluechipToken,
-      executor: dexRouter
-    } : void 0,
-    finalAmountOut: intentsQuote.quoteSuccessResult?.quote?.amountOut || "0"
+    digits: BigInt(`${integer}${fraction}`),
+    scale: fraction.length
   };
 }
+function pow10(exponent) {
+  return 10n ** BigInt(exponent);
+}
 
-exports.NearSmartRouter = NearSmartRouter;
-exports.completeQuote = completeQuote;
-exports.convertSlippageToBasisPoints = convertSlippageToBasisPoints;
-exports.findBestBluechipToken = findBestBluechipToken;
-exports.getBluechipTokensConfig = getBluechipTokensConfig;
-exports.isNearIntentsSupportedToken = isNearIntentsSupportedToken;
-exports.logger = logger;
-exports.normalizeDestinationAsset = normalizeDestinationAsset;
-exports.normalizeTokenId = normalizeTokenId;
-exports.setBluechipTokensConfig = setBluechipTokensConfig;
+exports.ApiClient = ApiClient;
+exports.DEFAULT_MCA_SIGNER_PRIORITY = DEFAULT_MCA_SIGNER_PRIORITY;
+exports.ExecutorRegistry = ExecutorRegistry;
+exports.SwapClient = SwapClient;
+exports.SwapSdkError = SwapSdkError;
+exports.asSwapSdkError = asSwapSdkError;
+exports.assertBaseUnitAmount = assertBaseUnitAmount;
+exports.buildMcaWithdrawRelayerRequest = buildMcaWithdrawRelayerRequest;
+exports.buildNearMcaWithdrawTransactions = buildNearMcaWithdrawTransactions;
+exports.createExecutionId = createExecutionId;
+exports.extractMcaWithdrawBusiness = extractMcaWithdrawBusiness;
+exports.extractMcaWithdrawDepositAddress = extractMcaWithdrawDepositAddress;
+exports.extractMcaWithdrawSignerWallet = extractMcaWithdrawSignerWallet;
+exports.formatMcaWallet = formatMcaWallet;
+exports.formatUnits = formatUnits;
+exports.fromApiChain = fromApiChain;
+exports.isSameMcaSignerIdentity = isSameMcaSignerIdentity;
+exports.normalizeBuild = normalizeBuild;
+exports.normalizeHistory = normalizeHistory;
+exports.normalizeHistoryStatus = normalizeHistoryStatus;
+exports.normalizeMcaQuote = normalizeMcaQuote;
+exports.normalizeOrderStatus = normalizeOrderStatus;
+exports.normalizeQuote = normalizeQuote;
+exports.parseUnits = parseUnits;
+exports.resolveMcaWithdrawPolicy = resolveMcaWithdrawPolicy;
+exports.selectMcaSigner = selectMcaSigner;
+exports.serializeMcaQuoteRequest = serializeMcaQuoteRequest;
+exports.serializeQuoteRequest = serializeQuoteRequest;
+exports.toApiAssetAddress = toApiAssetAddress;
+exports.toApiChain = toApiChain;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map