@defuse-protocol/intents-sdk 0.16.3 → 0.17.0

package/dist/index.cjs

@@ -30,31 +30,32 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // index.ts
 var index_exports = {};
 __export(index_exports, {
-  AssertionError: () => import_internal_utils22.AssertionError,
-  BaseError: () => import_internal_utils19.BaseError,
+  AssertionError: () => import_internal_utils25.AssertionError,
+  BaseError: () => import_internal_utils22.BaseError,
   BridgeNameEnum: () => BridgeNameEnum,
   Chains: () => Chains,
   FeeExceedsAmountError: () => FeeExceedsAmountError,
   HotWithdrawalCancelledError: () => HotWithdrawalCancelledError,
   HotWithdrawalNotFoundError: () => HotWithdrawalNotFoundError,
   HotWithdrawalPendingError: () => HotWithdrawalPendingError,
-  HttpRequestError: () => import_internal_utils21.HttpRequestError,
-  IntentSettlementError: () => import_internal_utils23.IntentSettlementError,
+  HttpRequestError: () => import_internal_utils24.HttpRequestError,
+  IntentSettlementError: () => import_internal_utils26.IntentSettlementError,
   IntentsSDK: () => IntentsSDK,
   MinWithdrawalAmountError: () => MinWithdrawalAmountError,
   OmniTransferDestinationChainHashNotFoundError: () => OmniTransferDestinationChainHashNotFoundError,
   OmniTransferNotFoundError: () => OmniTransferNotFoundError,
-  PoaWithdrawalInvariantError: () => import_internal_utils20.PoaWithdrawalInvariantError,
-  PoaWithdrawalNotFoundError: () => import_internal_utils20.PoaWithdrawalNotFoundError,
-  PoaWithdrawalPendingError: () => import_internal_utils20.PoaWithdrawalPendingError,
-  QuoteError: () => import_internal_utils23.QuoteError,
-  RelayPublishError: () => import_internal_utils23.RelayPublishError,
+  PoaWithdrawalInvariantError: () => import_internal_utils23.PoaWithdrawalInvariantError,
+  PoaWithdrawalNotFoundError: () => import_internal_utils23.PoaWithdrawalNotFoundError,
+  PoaWithdrawalPendingError: () => import_internal_utils23.PoaWithdrawalPendingError,
+  QuoteError: () => import_internal_utils26.QuoteError,
+  RelayPublishError: () => import_internal_utils26.RelayPublishError,
   RouteEnum: () => RouteEnum,
-  RpcRequestError: () => import_internal_utils21.RpcRequestError,
-  TimeoutError: () => import_internal_utils21.TimeoutError,
+  RpcRequestError: () => import_internal_utils24.RpcRequestError,
+  TimeoutError: () => import_internal_utils24.TimeoutError,
   TokenNotFoundInDestinationChainError: () => TokenNotFoundInDestinationChainError,
   TokenNotSupportedByOmniRelayerError: () => TokenNotSupportedByOmniRelayerError,
   TrustlineNotFoundError: () => TrustlineNotFoundError,
+  UnsupportedAssetIdError: () => UnsupportedAssetIdError,
   UnsupportedDestinationMemoError: () => UnsupportedDestinationMemoError,
   createDefaultRoute: () => createDefaultRoute,
   createHotBridgeRoute: () => createHotBridgeRoute,
@@ -63,19 +64,19 @@ __export(index_exports, {
   createIntentSignerViem: () => createIntentSignerViem,
   createInternalTransferRoute: () => createInternalTransferRoute,
   createNearWithdrawalRoute: () => createNearWithdrawalRoute,
-  createOmniWithdrawalRoute: () => createOmniWithdrawalRoute,
+  createOmniBridgeRoute: () => createOmniBridgeRoute,
   createPoaBridgeRoute: () => createPoaBridgeRoute,
   createVirtualChainRoute: () => createVirtualChainRoute
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/sdk.ts
-var import_internal_utils16 = require("@defuse-protocol/internal-utils");
+var import_internal_utils19 = require("@defuse-protocol/internal-utils");
 var import_omni_sdk3 = __toESM(require("@hot-labs/omni-sdk"), 1);
 var import_viem2 = require("viem");
 
 // src/bridges/aurora-engine-bridge/aurora-engine-bridge.ts
-var import_internal_utils2 = require("@defuse-protocol/internal-utils");
+var import_internal_utils6 = require("@defuse-protocol/internal-utils");
 
 // src/constants/route-enum.ts
 var RouteEnum = {
@@ -129,6 +130,190 @@ function withdrawalParamsInvariant(params) {
   );
 }
 
+// src/lib/parse-defuse-asset-id.ts
+var import_internal_utils3 = require("@defuse-protocol/internal-utils");
+
+// src/classes/errors.ts
+var import_internal_utils2 = require("@defuse-protocol/internal-utils");
+var FeeExceedsAmountError = class extends import_internal_utils2.BaseError {
+  constructor(feeEstimation, amount) {
+    super("Amount too small to pay fee.", {
+      metaMessages: [
+        `Required fee: ${feeEstimation.amount}`,
+        `Withdrawal amount: ${amount}`
+      ],
+      name: "FeeExceedsAmountError"
+    });
+    this.feeEstimation = feeEstimation;
+    this.amount = amount;
+  }
+};
+var MinWithdrawalAmountError = class extends import_internal_utils2.BaseError {
+  constructor(minAmount, requestedAmount, assetId) {
+    super("Withdrawal amount is below minimum required by the bridge.", {
+      metaMessages: [
+        `Asset ID: ${assetId}`,
+        `Minimum amount: ${minAmount}`,
+        `Requested amount: ${requestedAmount}`
+      ],
+      name: "MinWithdrawalAmountError"
+    });
+    this.minAmount = minAmount;
+    this.requestedAmount = requestedAmount;
+    this.assetId = assetId;
+  }
+};
+var UnsupportedDestinationMemoError = class extends import_internal_utils2.BaseError {
+  constructor(blockchain, assetId) {
+    super("Destination memo is not supported for this blockchain.", {
+      details: "Destination memo is only supported for XRP Ledger withdrawals.",
+      metaMessages: [`Blockchain: ${blockchain}`, `Asset ID: ${assetId}`],
+      name: "UnsupportedDestinationMemoError"
+    });
+    this.blockchain = blockchain;
+    this.assetId = assetId;
+  }
+};
+var TrustlineNotFoundError = class extends import_internal_utils2.BaseError {
+  constructor(destinationAddress, assetId, blockchain, tokenAddress) {
+    super("Destination address does not have a trustline for this asset.", {
+      details: "The destination address must establish a trustline before receiving this asset.",
+      metaMessages: [
+        `Blockchain: ${blockchain}`,
+        `Asset ID: ${assetId}`,
+        `Destination address: ${destinationAddress}`,
+        `Token address: ${tokenAddress}`
+      ],
+      name: "TrustlineNotFoundError"
+    });
+    this.destinationAddress = destinationAddress;
+    this.assetId = assetId;
+    this.blockchain = blockchain;
+    this.tokenAddress = tokenAddress;
+  }
+};
+var UnsupportedAssetIdError = class extends import_internal_utils2.BaseError {
+  constructor(assetId, details) {
+    super("Asset ID is not supported.", {
+      details,
+      metaMessages: [`Asset ID: ${assetId}`],
+      name: "UnsupportedAssetIdError"
+    });
+    this.assetId = assetId;
+  }
+};
+
+// src/lib/parse-defuse-asset-id.ts
+function parseDefuseAssetId(assetId) {
+  try {
+    return import_internal_utils3.utils.parseDefuseAssetId(assetId);
+  } catch {
+    throw new UnsupportedAssetIdError(assetId, "Invalid asset id format.");
+  }
+}
+
+// src/lib/estimate-fee.ts
+var import_internal_utils5 = require("@defuse-protocol/internal-utils");
+
+// src/lib/tokensUsdPricesHttpClient/apis.ts
+var import_internal_utils4 = require("@defuse-protocol/internal-utils");
+async function tokens(config) {
+  const response = await (0, import_internal_utils4.request)({
+    url: new URL(
+      "tokens",
+      import_internal_utils4.configsByEnvironment[config.env].managerConsoleBaseURL
+    ),
+    ...config,
+    fetchOptions: {
+      ...config.fetchOptions,
+      method: "GET"
+    }
+  });
+  return response.json();
+}
+
+// src/lib/estimate-fee.ts
+async function getFeeQuote({
+  feeAmount,
+  feeAssetId,
+  tokenAssetId,
+  quoteOptions,
+  env,
+  logger
+}) {
+  try {
+    return await import_internal_utils5.solverRelay.getQuote({
+      quoteParams: {
+        defuse_asset_identifier_in: tokenAssetId,
+        defuse_asset_identifier_out: feeAssetId,
+        exact_amount_out: feeAmount.toString(),
+        wait_ms: quoteOptions?.waitMs
+      },
+      config: {
+        baseURL: import_internal_utils5.configsByEnvironment[env].solverRelayBaseURL,
+        logBalanceSufficient: false,
+        logger
+      }
+    });
+  } catch (err) {
+    if (!(err instanceof import_internal_utils5.QuoteError)) {
+      throw err;
+    }
+    logger?.info(
+      "Can't get exact out quote, trying to get exact in quote with x1.2"
+    );
+    const prices = await tokens({ env });
+    const feeAssetPrice = prices.items.find(
+      (t) => t.defuse_asset_id === feeAssetId
+    );
+    const tokenAssetPrice = prices.items.find(
+      (t) => t.defuse_asset_id === tokenAssetId
+    );
+    if (feeAssetPrice == null || tokenAssetPrice == null) {
+      throw err;
+    }
+    const USD_SCALE = 1e6;
+    const feePriceScaled = BigInt(Math.round(feeAssetPrice.price * USD_SCALE));
+    const tokenPriceScaled = BigInt(
+      Math.round(tokenAssetPrice.price * USD_SCALE)
+    );
+    const feeDecimals = BigInt(feeAssetPrice.decimals);
+    const tokenDecimals = BigInt(tokenAssetPrice.decimals);
+    const num = feeAmount * feePriceScaled * 12n * 10n ** tokenDecimals;
+    const den = tokenPriceScaled * 10n ** feeDecimals * 10n;
+    let exactAmountIn = num / den;
+    if (num % den !== 0n) exactAmountIn += 1n;
+    if (exactAmountIn === 0n) exactAmountIn = 1n;
+    const quote = await import_internal_utils5.solverRelay.getQuote({
+      quoteParams: {
+        defuse_asset_identifier_in: tokenAssetId,
+        defuse_asset_identifier_out: feeAssetId,
+        exact_amount_in: exactAmountIn.toString(),
+        wait_ms: quoteOptions?.waitMs
+      },
+      config: {
+        baseURL: import_internal_utils5.configsByEnvironment[env].solverRelayBaseURL,
+        logBalanceSufficient: false,
+        logger
+      }
+    });
+    const RATIO_SCALE = 1000n;
+    const actualRatio = BigInt(quote.amount_out) * RATIO_SCALE / feeAmount;
+    const actualRatioNumber = Number(actualRatio) / Number(RATIO_SCALE);
+    if (actualRatio > 1500n) {
+      logger?.warn(
+        `Quote amount_out ratio is too high: ${actualRatioNumber.toFixed(2)}x`
+      );
+      throw err;
+    }
+    if (BigInt(quote.amount_out) < feeAmount) {
+      logger?.warn("Quote amount_out is less than feeAmount");
+      throw err;
+    }
+    return quote;
+  }
+}
+
 // src/bridges/aurora-engine-bridge/aurora-engine-bridge.ts
 var AuroraEngineBridge = class {
   constructor({
@@ -141,11 +326,19 @@ var AuroraEngineBridge = class {
   is(routeConfig) {
     return routeConfig.route === RouteEnum.VirtualChain;
   }
-  supports(params) {
-    if ("routeConfig" in params && params.routeConfig != null) {
-      return this.is(params.routeConfig);
+  async supports(params) {
+    if (params.routeConfig == null || !this.is(params.routeConfig)) {
+      return false;
     }
-    return false;
+    const assetInfo = parseDefuseAssetId(params.assetId);
+    const isValid = assetInfo.standard === "nep141";
+    if (!isValid) {
+      throw new UnsupportedAssetIdError(
+        params.assetId,
+        "`assetId` does not match `routeConfig`."
+      );
+    }
+    return isValid;
   }
   parseAssetId() {
     return null;
@@ -182,16 +375,16 @@ var AuroraEngineBridge = class {
   }
   async estimateWithdrawalFee(args) {
     withdrawalParamsInvariant(args.withdrawalParams);
-    const { contractId: tokenAccountId, standard } = import_internal_utils2.utils.parseDefuseAssetId(
+    const { contractId: tokenAccountId, standard } = import_internal_utils6.utils.parseDefuseAssetId(
       args.withdrawalParams.assetId
     );
-    (0, import_internal_utils2.assert)(standard === "nep141", "Only NEP-141 is supported");
+    (0, import_internal_utils6.assert)(standard === "nep141", "Only NEP-141 is supported");
     const [minStorageBalance, userStorageBalance] = await Promise.all([
-      (0, import_internal_utils2.getNearNep141MinStorageBalance)({
+      (0, import_internal_utils6.getNearNep141MinStorageBalance)({
         contractId: tokenAccountId,
         nearProvider: this.nearProvider
       }),
-      (0, import_internal_utils2.getNearNep141StorageBalance)({
+      (0, import_internal_utils6.getNearNep141StorageBalance)({
         contractId: tokenAccountId,
         accountId: args.withdrawalParams.routeConfig.auroraEngineContractId,
         nearProvider: this.nearProvider
@@ -205,18 +398,13 @@ var AuroraEngineBridge = class {
     }
     const feeAssetId = NEAR_NATIVE_ASSET_ID;
     const feeAmount = minStorageBalance - userStorageBalance;
-    const feeQuote = args.withdrawalParams.assetId === feeAssetId ? null : await import_internal_utils2.solverRelay.getQuote({
-      quoteParams: {
-        defuse_asset_identifier_in: args.withdrawalParams.assetId,
-        defuse_asset_identifier_out: feeAssetId,
-        exact_amount_out: feeAmount.toString(),
-        wait_ms: args.quoteOptions?.waitMs
-      },
-      config: {
-        baseURL: import_internal_utils2.configsByEnvironment[this.env].solverRelayBaseURL,
-        logBalanceSufficient: false,
-        logger: args.logger
-      }
+    const feeQuote = args.withdrawalParams.assetId === feeAssetId ? null : await getFeeQuote({
+      feeAmount,
+      feeAssetId,
+      tokenAssetId: args.withdrawalParams.assetId,
+      logger: args.logger,
+      env: this.env,
+      quoteOptions: args.quoteOptions
     });
     return {
       amount: feeQuote ? BigInt(feeQuote.amount_in) : feeAmount,
@@ -229,7 +417,7 @@ var AuroraEngineBridge = class {
 };
 
 // src/bridges/direct-bridge/direct-bridge.ts
-var import_internal_utils5 = require("@defuse-protocol/internal-utils");
+var import_internal_utils9 = require("@defuse-protocol/internal-utils");
 
 // src/constants/bridge-name-enum.ts
 var BridgeNameEnum = {
@@ -240,7 +428,7 @@ var BridgeNameEnum = {
 };
 
 // src/lib/caip2.ts
-var import_internal_utils3 = require("@defuse-protocol/internal-utils");
+var import_internal_utils7 = require("@defuse-protocol/internal-utils");
 var Chains = {
   Bitcoin: "bip122:000000000019d6689c085ae165831e93",
   Zcash: "bip122:00040fe8ec8471911baa1db1266ea15d",
@@ -265,11 +453,11 @@ var Chains = {
   Cardano: "cip34:1-764824073"
 };
 function getEIP155ChainId(chain) {
-  (0, import_internal_utils3.assert)(chain.startsWith("eip155:"), "Chain is not an EIP-155 chain");
+  (0, import_internal_utils7.assert)(chain.startsWith("eip155:"), "Chain is not an EIP-155 chain");
   const chainIdStr = chain.slice(7);
-  (0, import_internal_utils3.assert)(chainIdStr.length > 0, "Chain is not an EIP-155 chain");
+  (0, import_internal_utils7.assert)(chainIdStr.length > 0, "Chain is not an EIP-155 chain");
   const chainId = Number(chainIdStr);
-  (0, import_internal_utils3.assert)(!Number.isNaN(chainId), "Chain is not an EIP-155 chain");
+  (0, import_internal_utils7.assert)(!Number.isNaN(chainId), "Chain is not an EIP-155 chain");
   return chainId;
 }
 
@@ -277,7 +465,7 @@ function getEIP155ChainId(chain) {
 var NEAR_NATIVE_ASSET_ID2 = "nep141:wrap.near";
 
 // src/bridges/direct-bridge/direct-bridge-utils.ts
-var import_internal_utils4 = require("@defuse-protocol/internal-utils");
+var import_internal_utils8 = require("@defuse-protocol/internal-utils");
 function createWithdrawIntentPrimitive2(params) {
   if (params.assetId === NEAR_NATIVE_ASSET_ID2 && // Ensure `msg` is not passed, because `native_withdraw` intent doesn't support `msg`
   params.msg === void 0) {
@@ -287,10 +475,10 @@ function createWithdrawIntentPrimitive2(params) {
       amount: params.amount.toString()
     };
   }
-  const { contractId: tokenAccountId, standard } = import_internal_utils4.utils.parseDefuseAssetId(
+  const { contractId: tokenAccountId, standard } = import_internal_utils8.utils.parseDefuseAssetId(
     params.assetId
   );
-  (0, import_internal_utils4.assert)(standard === "nep141", "Only NEP-141 is supported");
+  (0, import_internal_utils8.assert)(standard === "nep141", "Only NEP-141 is supported");
   return {
     intent: "ft_withdraw",
     token: tokenAccountId,
@@ -301,7 +489,7 @@ function createWithdrawIntentPrimitive2(params) {
   };
 }
 function withdrawalParamsInvariant2(params) {
-  (0, import_internal_utils4.assert)(
+  (0, import_internal_utils8.assert)(
     !params.routeConfig ? true : params.routeConfig.route === RouteEnum.NearWithdrawal,
     "Bridge is not direct"
   );
@@ -319,19 +507,22 @@ var DirectBridge = class {
   is(routeConfig) {
     return routeConfig.route === RouteEnum.NearWithdrawal;
   }
-  supports(params) {
-    let result = true;
-    if ("routeConfig" in params && params.routeConfig != null) {
-      result && (result = this.is(params.routeConfig));
-    }
-    try {
-      return result && this.parseAssetId(params.assetId) != null;
-    } catch {
+  async supports(params) {
+    if (params.routeConfig != null && !this.is(params.routeConfig)) {
       return false;
     }
+    const assetInfo = this.parseAssetId(params.assetId);
+    const isValid = assetInfo != null;
+    if (!isValid && params.routeConfig != null) {
+      throw new UnsupportedAssetIdError(
+        params.assetId,
+        "`assetId` does not match `routeConfig`."
+      );
+    }
+    return isValid;
   }
   parseAssetId(assetId) {
-    const parsed = import_internal_utils5.utils.parseDefuseAssetId(assetId);
+    const parsed = parseDefuseAssetId(assetId);
     if (parsed.standard === "nep141") {
       return Object.assign(parsed, {
         blockchain: Chains.Near,
@@ -372,10 +563,10 @@ var DirectBridge = class {
   }
   async estimateWithdrawalFee(args) {
     withdrawalParamsInvariant2(args.withdrawalParams);
-    const { contractId: tokenAccountId, standard } = import_internal_utils5.utils.parseDefuseAssetId(
+    const { contractId: tokenAccountId, standard } = import_internal_utils9.utils.parseDefuseAssetId(
       args.withdrawalParams.assetId
     );
-    (0, import_internal_utils5.assert)(standard === "nep141", "Only NEP-141 is supported");
+    (0, import_internal_utils9.assert)(standard === "nep141", "Only NEP-141 is supported");
     if (
       // We don't directly withdraw `wrap.near`, we unwrap it first, so it doesn't require storage
       args.withdrawalParams.assetId === NEAR_NATIVE_ASSET_ID2 && // Ensure `msg` is not passed, because `native_withdraw` intent doesn't support `msg`
@@ -386,11 +577,11 @@ var DirectBridge = class {
         quote: null
       };
     const [minStorageBalance, userStorageBalance] = await Promise.all([
-      (0, import_internal_utils5.getNearNep141MinStorageBalance)({
+      (0, import_internal_utils9.getNearNep141MinStorageBalance)({
         contractId: tokenAccountId,
         nearProvider: this.nearProvider
       }),
-      (0, import_internal_utils5.getNearNep141StorageBalance)({
+      (0, import_internal_utils9.getNearNep141StorageBalance)({
         contractId: tokenAccountId,
         accountId: args.withdrawalParams.destinationAddress,
         nearProvider: this.nearProvider
@@ -404,18 +595,13 @@ var DirectBridge = class {
     }
     const feeAssetId = NEAR_NATIVE_ASSET_ID2;
     const feeAmount = minStorageBalance - userStorageBalance;
-    const feeQuote = args.withdrawalParams.assetId === feeAssetId ? null : await import_internal_utils5.solverRelay.getQuote({
-      quoteParams: {
-        defuse_asset_identifier_in: args.withdrawalParams.assetId,
-        defuse_asset_identifier_out: feeAssetId,
-        exact_amount_out: feeAmount.toString(),
-        wait_ms: args.quoteOptions?.waitMs
-      },
-      config: {
-        baseURL: import_internal_utils5.configsByEnvironment[this.env].solverRelayBaseURL,
-        logBalanceSufficient: false,
-        logger: args.logger
-      }
+    const feeQuote = args.withdrawalParams.assetId === feeAssetId ? null : await getFeeQuote({
+      feeAmount,
+      feeAssetId,
+      tokenAssetId: args.withdrawalParams.assetId,
+      logger: args.logger,
+      env: this.env,
+      quoteOptions: args.quoteOptions
     });
     return {
       amount: feeQuote ? BigInt(feeQuote.amount_in) : feeAmount,
@@ -428,73 +614,13 @@ var DirectBridge = class {
 };
 
 // src/bridges/hot-bridge/hot-bridge.ts
-var import_internal_utils9 = require("@defuse-protocol/internal-utils");
+var import_internal_utils12 = require("@defuse-protocol/internal-utils");
 var import_omni_sdk2 = require("@hot-labs/omni-sdk");
 var import_attempt = require("@lifeomic/attempt");
 
-// src/classes/errors.ts
-var import_internal_utils6 = require("@defuse-protocol/internal-utils");
-var FeeExceedsAmountError = class extends import_internal_utils6.BaseError {
-  constructor(feeEstimation, amount) {
-    super("Amount too small to pay fee.", {
-      metaMessages: [
-        `Required fee: ${feeEstimation.amount}`,
-        `Withdrawal amount: ${amount}`
-      ],
-      name: "FeeExceedsAmountError"
-    });
-    this.feeEstimation = feeEstimation;
-    this.amount = amount;
-  }
-};
-var MinWithdrawalAmountError = class extends import_internal_utils6.BaseError {
-  constructor(minAmount, requestedAmount, assetId) {
-    super("Withdrawal amount is below minimum required by the bridge.", {
-      metaMessages: [
-        `Asset ID: ${assetId}`,
-        `Minimum amount: ${minAmount}`,
-        `Requested amount: ${requestedAmount}`
-      ],
-      name: "MinWithdrawalAmountError"
-    });
-    this.minAmount = minAmount;
-    this.requestedAmount = requestedAmount;
-    this.assetId = assetId;
-  }
-};
-var UnsupportedDestinationMemoError = class extends import_internal_utils6.BaseError {
-  constructor(blockchain, assetId) {
-    super("Destination memo is not supported for this blockchain.", {
-      details: "Destination memo is only supported for XRP Ledger withdrawals.",
-      metaMessages: [`Blockchain: ${blockchain}`, `Asset ID: ${assetId}`],
-      name: "UnsupportedDestinationMemoError"
-    });
-    this.blockchain = blockchain;
-    this.assetId = assetId;
-  }
-};
-var TrustlineNotFoundError = class extends import_internal_utils6.BaseError {
-  constructor(destinationAddress, assetId, blockchain, tokenAddress) {
-    super("Destination address does not have a trustline for this asset.", {
-      details: "The destination address must establish a trustline before receiving this asset.",
-      metaMessages: [
-        `Blockchain: ${blockchain}`,
-        `Asset ID: ${assetId}`,
-        `Destination address: ${destinationAddress}`,
-        `Token address: ${tokenAddress}`
-      ],
-      name: "TrustlineNotFoundError"
-    });
-    this.destinationAddress = destinationAddress;
-    this.assetId = assetId;
-    this.blockchain = blockchain;
-    this.tokenAddress = tokenAddress;
-  }
-};
-
 // src/bridges/hot-bridge/error.ts
-var import_internal_utils7 = require("@defuse-protocol/internal-utils");
-var HotWithdrawalPendingError = class extends import_internal_utils7.BaseError {
+var import_internal_utils10 = require("@defuse-protocol/internal-utils");
+var HotWithdrawalPendingError = class extends import_internal_utils10.BaseError {
   constructor(txHash, index) {
     super("Withdrawal is still pending.", {
       metaMessages: [`TxHash: ${txHash}`, `Index: ${index}`],
@@ -504,7 +630,7 @@ var HotWithdrawalPendingError = class extends import_internal_utils7.BaseError {
     this.index = index;
   }
 };
-var HotWithdrawalNotFoundError = class extends import_internal_utils7.BaseError {
+var HotWithdrawalNotFoundError = class extends import_internal_utils10.BaseError {
   constructor(txHash, index) {
     super("Withdrawal with given index is not found.", {
       metaMessages: [`TxHash: ${txHash}`, `Index: ${index}`],
@@ -514,7 +640,7 @@ var HotWithdrawalNotFoundError = class extends import_internal_utils7.BaseError
     this.index = index;
   }
 };
-var HotWithdrawalCancelledError = class extends import_internal_utils7.BaseError {
+var HotWithdrawalCancelledError = class extends import_internal_utils10.BaseError {
   constructor(txHash, index) {
     super("Gasless withdrawal was canceled.", {
       metaMessages: [`TxHash: ${txHash}`, `Index: ${index}`],
@@ -532,7 +658,7 @@ var HotWithdrawStatus = {
 };
 
 // src/bridges/hot-bridge/hot-bridge-utils.ts
-var import_internal_utils8 = require("@defuse-protocol/internal-utils");
+var import_internal_utils11 = require("@defuse-protocol/internal-utils");
 var import_omni_sdk = require("@hot-labs/omni-sdk");
 
 // src/bridges/hot-bridge/hot-bridge-chains.ts
@@ -586,7 +712,7 @@ function formatTxHash(txHash, caip2) {
   return txHash;
 }
 function hotBlockchainInvariant(blockchain) {
-  (0, import_internal_utils8.assert)(
+  (0, import_internal_utils11.assert)(
     HotBridgeChains.includes(blockchain),
     `${blockchain} is not a valid HOT Bridge blockchain. Supported values: ${HotBridgeChains.join()}`
   );
@@ -601,41 +727,60 @@ var HotBridge = class {
   is(routeConfig) {
     return routeConfig.route === RouteEnum.HotBridge;
   }
-  supports(params) {
-    let result = true;
-    if ("routeConfig" in params && params.routeConfig != null) {
-      result && (result = this.is(params.routeConfig));
-    }
-    try {
-      return result && this.parseAssetId(params.assetId) != null;
-    } catch {
+  async supports(params) {
+    if (params.routeConfig != null && !this.is(params.routeConfig)) {
       return false;
     }
+    const assetInfo = this.parseAssetId(params.assetId);
+    const isValid = assetInfo != null;
+    if (!isValid && params.routeConfig != null) {
+      throw new UnsupportedAssetIdError(
+        params.assetId,
+        "`assetId` does not match `routeConfig`."
+      );
+    }
+    return isValid;
   }
   parseAssetId(assetId) {
-    const parsed = import_internal_utils9.utils.parseDefuseAssetId(assetId);
-    if (parsed.contractId === import_omni_sdk2.utils.OMNI_HOT_V2) {
-      (0, import_internal_utils9.assert)(
-        parsed.standard === "nep245",
-        "NEP-245 is supported only for HOT bridge"
+    const parsed = parseDefuseAssetId(assetId);
+    const contractIdSatisfies = parsed.contractId === import_omni_sdk2.utils.OMNI_HOT_V2;
+    if (!contractIdSatisfies) {
+      return null;
+    }
+    if (parsed.standard !== "nep245") {
+      throw new UnsupportedAssetIdError(
+        assetId,
+        'Should start with "nep245:".'
       );
-      const [chainId, address] = import_omni_sdk2.utils.fromOmni(parsed.tokenId).split(":");
-      (0, import_internal_utils9.assert)(chainId != null, "Chain ID is not found");
-      (0, import_internal_utils9.assert)(address != null, "Address is not found");
-      return Object.assign(
-        parsed,
-        {
-          blockchain: hotNetworkIdToCAIP2(chainId),
-          bridgeName: BridgeNameEnum.Hot
-        },
-        address === "native" ? { native: true } : { address }
+    }
+    const [chainId, address] = import_omni_sdk2.utils.fromOmni(parsed.tokenId).split(":");
+    if (chainId == null || address == null) {
+      throw new UnsupportedAssetIdError(
+        assetId,
+        "Asset has invalid token id format."
       );
     }
-    return null;
+    let blockchain;
+    try {
+      blockchain = hotNetworkIdToCAIP2(chainId);
+    } catch {
+      throw new UnsupportedAssetIdError(
+        assetId,
+        "Asset belongs to unknown blockchain."
+      );
+    }
+    return Object.assign(
+      parsed,
+      {
+        blockchain,
+        bridgeName: BridgeNameEnum.Hot
+      },
+      address === "native" ? { native: true } : { address }
+    );
   }
   async createWithdrawalIntents(args) {
     const assetInfo = this.parseAssetId(args.withdrawalParams.assetId);
-    (0, import_internal_utils9.assert)(assetInfo != null, "Asset is not supported");
+    (0, import_internal_utils12.assert)(assetInfo != null, "Asset is not supported");
     if (args.withdrawalParams.destinationMemo != null && args.withdrawalParams.destinationMemo !== "") {
       throw new UnsupportedDestinationMemoError(
         assetInfo.blockchain,
@@ -669,9 +814,9 @@ var HotBridge = class {
       intentAccount: ""
       // it is not used inside the function
     });
-    (0, import_internal_utils9.assert)(intent.amounts[0] === amount.toString(), "Amount is not correct");
+    (0, import_internal_utils12.assert)(intent.amounts[0] === amount.toString(), "Amount is not correct");
     if (intent.amounts.length === 2) {
-      (0, import_internal_utils9.assert)(
+      (0, import_internal_utils12.assert)(
         intent.amounts[1] === feeAmount.toString(),
         "Amount is not correct"
       );
@@ -686,7 +831,7 @@ var HotBridge = class {
    */
   async validateWithdrawal(args) {
     const assetInfo = this.parseAssetId(args.assetId);
-    (0, import_internal_utils9.assert)(assetInfo != null, "Asset is not supported");
+    (0, import_internal_utils12.assert)(assetInfo != null, "Asset is not supported");
     hotBlockchainInvariant(assetInfo.blockchain);
     if (assetInfo.blockchain === Chains.Stellar) {
       const token = "native" in assetInfo ? "native" : assetInfo.address;
@@ -706,25 +851,20 @@ var HotBridge = class {
   }
   async estimateWithdrawalFee(args) {
     const assetInfo = this.parseAssetId(args.withdrawalParams.assetId);
-    (0, import_internal_utils9.assert)(assetInfo != null, "Asset is not supported");
+    (0, import_internal_utils12.assert)(assetInfo != null, "Asset is not supported");
     hotBlockchainInvariant(assetInfo.blockchain);
     const { gasPrice: feeAmount } = await this.hotSdk.getGaslessWithdrawFee(
       toHotNetworkId(assetInfo.blockchain),
       args.withdrawalParams.destinationAddress
     );
     const feeAssetId = getFeeAssetIdForChain(assetInfo.blockchain);
-    const feeQuote = args.withdrawalParams.assetId === feeAssetId || feeAmount === 0n ? null : await import_internal_utils9.solverRelay.getQuote({
-      quoteParams: {
-        defuse_asset_identifier_in: args.withdrawalParams.assetId,
-        defuse_asset_identifier_out: feeAssetId,
-        exact_amount_out: feeAmount.toString(),
-        wait_ms: args.quoteOptions?.waitMs
-      },
-      config: {
-        baseURL: import_internal_utils9.configsByEnvironment[this.env].solverRelayBaseURL,
-        logBalanceSufficient: false,
-        logger: args.logger
-      }
+    const feeQuote = args.withdrawalParams.assetId === feeAssetId || feeAmount === 0n ? null : await getFeeQuote({
+      feeAmount,
+      feeAssetId,
+      tokenAssetId: args.withdrawalParams.assetId,
+      logger: args.logger,
+      env: this.env,
+      quoteOptions: args.quoteOptions
     });
     return {
       amount: feeQuote ? BigInt(feeQuote.amount_in) : feeAmount,
@@ -762,7 +902,7 @@ var HotBridge = class {
         throw new HotWithdrawalPendingError(args.tx.hash, args.index);
       },
       {
-        ...args.retryOptions ?? import_internal_utils9.RETRY_CONFIGS.TWO_MINS_GRADUAL,
+        ...args.retryOptions ?? import_internal_utils12.RETRY_CONFIGS.TWO_MINS_GRADUAL,
         handleError: (err, ctx) => {
           if (err instanceof HotWithdrawalCancelledError || err === args.signal?.reason) {
             ctx.abort();
@@ -778,7 +918,7 @@ var IntentsBridge = class {
   is(routeConfig) {
     return routeConfig.route === RouteEnum.InternalTransfer;
   }
-  supports(params) {
+  async supports(params) {
     if ("routeConfig" in params && params.routeConfig != null) {
       return this.is(params.routeConfig);
     }
@@ -817,13 +957,13 @@ var IntentsBridge = class {
 };
 
 // src/bridges/poa-bridge/poa-bridge.ts
-var import_internal_utils11 = require("@defuse-protocol/internal-utils");
+var import_internal_utils14 = require("@defuse-protocol/internal-utils");
 var import_ttlcache = __toESM(require("@isaacs/ttlcache"), 1);
 
 // src/bridges/poa-bridge/poa-bridge-utils.ts
-var import_internal_utils10 = require("@defuse-protocol/internal-utils");
+var import_internal_utils13 = require("@defuse-protocol/internal-utils");
 function createWithdrawIntentPrimitive3(params) {
-  const { contractId: tokenAccountId } = import_internal_utils10.utils.parseDefuseAssetId(
+  const { contractId: tokenAccountId } = import_internal_utils13.utils.parseDefuseAssetId(
     params.assetId
   );
   return {
@@ -904,30 +1044,43 @@ var PoaBridge = class {
   is(routeConfig) {
     return routeConfig.route === RouteEnum.PoaBridge;
   }
-  supports(params) {
-    let result = true;
-    if ("routeConfig" in params && params.routeConfig != null) {
-      result && (result = this.is(params.routeConfig));
-    }
-    try {
-      return result && this.parseAssetId(params.assetId) != null;
-    } catch {
+  async supports(params) {
+    if (params.routeConfig != null && !this.is(params.routeConfig)) {
       return false;
     }
+    const assetInfo = this.parseAssetId(params.assetId);
+    const isValid = assetInfo != null;
+    if (!isValid && params.routeConfig != null) {
+      throw new UnsupportedAssetIdError(
+        params.assetId,
+        "`assetId` does not match `routeConfig`."
+      );
+    }
+    return isValid;
   }
   parseAssetId(assetId) {
-    const parsed = import_internal_utils11.utils.parseDefuseAssetId(assetId);
-    if (parsed.contractId.endsWith(
-      `.${import_internal_utils11.configsByEnvironment[this.env].poaTokenFactoryContractID}`
-    )) {
-      return Object.assign(parsed, {
-        blockchain: contractIdToCaip2(parsed.contractId),
-        bridgeName: BridgeNameEnum.Poa,
-        address: ""
-        // todo: derive address (or native)
-      });
+    const parsed = parseDefuseAssetId(assetId);
+    const contractIdSatisfies = parsed.contractId.endsWith(
+      `.${import_internal_utils14.configsByEnvironment[this.env].poaTokenFactoryContractID}`
+    );
+    if (!contractIdSatisfies) {
+      return null;
     }
-    return null;
+    let blockchain;
+    try {
+      blockchain = contractIdToCaip2(parsed.contractId);
+    } catch {
+      throw new UnsupportedAssetIdError(
+        assetId,
+        "Asset belongs to unknown blockchain."
+      );
+    }
+    return Object.assign(parsed, {
+      blockchain,
+      bridgeName: BridgeNameEnum.Poa,
+      address: ""
+      // todo: derive address (or native)
+    });
   }
   createWithdrawalIntents(args) {
     const intent = createWithdrawIntentPrimitive3({
@@ -945,12 +1098,12 @@ var PoaBridge = class {
    */
   async validateWithdrawal(args) {
     const assetInfo = this.parseAssetId(args.assetId);
-    (0, import_internal_utils11.assert)(assetInfo != null, "Asset is not supported");
-    const { tokens } = await this.getCachedSupportedTokens(
+    (0, import_internal_utils14.assert)(assetInfo != null, "Asset is not supported");
+    const { tokens: tokens2 } = await this.getCachedSupportedTokens(
       [toPoaNetwork(assetInfo.blockchain)],
       args.logger
     );
-    const tokenInfo = tokens.find(
+    const tokenInfo = tokens2.find(
       (token) => token.intents_token_id === args.assetId
     );
     if (tokenInfo != null) {
@@ -966,16 +1119,16 @@ var PoaBridge = class {
   }
   async estimateWithdrawalFee(args) {
     const assetInfo = this.parseAssetId(args.withdrawalParams.assetId);
-    (0, import_internal_utils11.assert)(assetInfo != null, "Asset is not supported");
-    const estimation = await import_internal_utils11.poaBridge.httpClient.getWithdrawalEstimate(
+    (0, import_internal_utils14.assert)(assetInfo != null, "Asset is not supported");
+    const estimation = await import_internal_utils14.poaBridge.httpClient.getWithdrawalEstimate(
       {
-        token: import_internal_utils11.utils.getTokenAccountId(args.withdrawalParams.assetId),
+        token: import_internal_utils14.utils.getTokenAccountId(args.withdrawalParams.assetId),
         address: args.withdrawalParams.destinationAddress,
         // biome-ignore lint/suspicious/noExplicitAny: <explanation>
         chain: toPoaNetwork(assetInfo.blockchain)
       },
       {
-        baseURL: import_internal_utils11.configsByEnvironment[this.env].poaBridgeBaseURL,
+        baseURL: import_internal_utils14.configsByEnvironment[this.env].poaBridgeBaseURL,
         logger: args.logger
       }
     );
@@ -985,12 +1138,12 @@ var PoaBridge = class {
     };
   }
   async waitForWithdrawalCompletion(args) {
-    const withdrawalStatus = await import_internal_utils11.poaBridge.waitForWithdrawalCompletion({
+    const withdrawalStatus = await import_internal_utils14.poaBridge.waitForWithdrawalCompletion({
       txHash: args.tx.hash,
       index: args.index,
       signal: args.signal ?? new AbortController().signal,
       retryOptions: args.retryOptions,
-      baseURL: import_internal_utils11.configsByEnvironment[this.env].poaBridgeBaseURL,
+      baseURL: import_internal_utils14.configsByEnvironment[this.env].poaBridgeBaseURL,
       logger: args.logger
     });
     return { hash: withdrawalStatus.destinationTxHash };
@@ -1005,10 +1158,10 @@ var PoaBridge = class {
     if (cached != null) {
       return cached;
     }
-    const data = await import_internal_utils11.poaBridge.httpClient.getSupportedTokens(
+    const data = await import_internal_utils14.poaBridge.httpClient.getSupportedTokens(
       { chains },
       {
-        baseURL: import_internal_utils11.configsByEnvironment[this.env].poaBridgeBaseURL,
+        baseURL: import_internal_utils14.configsByEnvironment[this.env].poaBridgeBaseURL,
         logger
       }
     );
@@ -1030,7 +1183,7 @@ var PUBLIC_STELLAR_RPC_URLS = {
 };
 
 // src/intents/intent-executer-impl/intent-executer.ts
-var import_internal_utils12 = require("@defuse-protocol/internal-utils");
+var import_internal_utils15 = require("@defuse-protocol/internal-utils");
 
 // ../../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/_u64.js
 var U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
@@ -1411,7 +1564,7 @@ var IntentExecuter = class {
     relayParams: relayParamsFactory,
     ...intentParams
   }) {
-    const verifyingContract = import_internal_utils12.configsByEnvironment[this.env].contractID;
+    const verifyingContract = import_internal_utils15.configsByEnvironment[this.env].contractID;
     let intentPayload = defaultIntentPayloadFactory({
       verifying_contract: verifyingContract,
       ...intentParams
@@ -1461,7 +1614,7 @@ async function mergeIntentPayloads(basePayload, intentPayloadFactory) {
 }
 
 // src/intents/intent-relayer-impl/intent-relayer-public.ts
-var import_internal_utils13 = require("@defuse-protocol/internal-utils");
+var import_internal_utils16 = require("@defuse-protocol/internal-utils");
 var IntentRelayerPublic = class {
   constructor({ env }) {
     this.env = env;
@@ -1483,13 +1636,13 @@ var IntentRelayerPublic = class {
     multiPayloads,
     quoteHashes
   }, ctx = {}) {
-    const a = await import_internal_utils13.solverRelay.publishIntents(
+    const a = await import_internal_utils16.solverRelay.publishIntents(
       {
         quote_hashes: quoteHashes,
         signed_datas: multiPayloads
       },
       {
-        baseURL: import_internal_utils13.configsByEnvironment[this.env].solverRelayBaseURL,
+        baseURL: import_internal_utils16.configsByEnvironment[this.env].solverRelayBaseURL,
         logger: ctx.logger
       }
     );
@@ -1499,10 +1652,10 @@ var IntentRelayerPublic = class {
     throw a.unwrapErr();
   }
   async waitForSettlement(ticket, ctx = {}) {
-    const result = await import_internal_utils13.solverRelay.waitForIntentSettlement({
+    const result = await import_internal_utils16.solverRelay.waitForIntentSettlement({
       intentHash: ticket,
       signal: new AbortController().signal,
-      baseURL: import_internal_utils13.configsByEnvironment[this.env].solverRelayBaseURL,
+      baseURL: import_internal_utils16.configsByEnvironment[this.env].solverRelayBaseURL,
       logger: ctx.logger
     });
     return {
@@ -1510,7 +1663,7 @@ var IntentRelayerPublic = class {
         hash: result.txHash,
         // Usually relayer's account id is the verifying contract (`intents.near`),
         // but it is not set in stone and may change in the future.
-        accountId: import_internal_utils13.configsByEnvironment[this.env].contractID
+        accountId: import_internal_utils16.configsByEnvironment[this.env].contractID
       }
     };
   }
@@ -1524,14 +1677,14 @@ var noopIntentSigner = {
 };
 
 // src/lib/array.ts
-var import_internal_utils14 = require("@defuse-protocol/internal-utils");
+var import_internal_utils17 = require("@defuse-protocol/internal-utils");
 function zip(arr1, arr2) {
-  (0, import_internal_utils14.assert)(arr1.length === arr2.length, "Arrays must have the same length");
+  (0, import_internal_utils17.assert)(arr1.length === arr2.length, "Arrays must have the same length");
   return arr1.map((v, i) => [v, arr2[i]]);
 }
 
 // src/lib/configure-rpc-config.ts
-var import_internal_utils15 = require("@defuse-protocol/internal-utils");
+var import_internal_utils18 = require("@defuse-protocol/internal-utils");
 
 // src/lib/object.ts
 function pick(obj, keys) {
@@ -1555,7 +1708,7 @@ function configureEvmRpcUrls(defaultRpcUrls, userRpcUrls, supportedChains) {
     ).map(([caip2, urls]) => [getEIP155ChainId(caip2), urls])
   );
   for (const [chainId, urls] of Object.entries(evmRpcUrls)) {
-    (0, import_internal_utils15.assert)(
+    (0, import_internal_utils18.assert)(
       urls.length > 0,
       `EVM RPC URLs for chain ${chainId} are not provided`
     );
@@ -1569,7 +1722,7 @@ function configureStellarRpcUrls(defaultRpcUrls, userRpcUrls) {
     userRpcUrls?.[Chains.Stellar] ?? {}
   );
   for (const [key, value] of Object.entries(stellarRpcUrls)) {
-    (0, import_internal_utils15.assert)(value.length > 0, `Stellar RPC URL for ${key} is not provided`);
+    (0, import_internal_utils18.assert)(value.length > 0, `Stellar RPC URL for ${key} is not provided`);
   }
   return stellarRpcUrls;
 }
@@ -1581,7 +1734,7 @@ function createInternalTransferRoute() {
 function createNearWithdrawalRoute(msg) {
   return { route: RouteEnum.NearWithdrawal, msg };
 }
-function createOmniWithdrawalRoute() {
+function createOmniBridgeRoute() {
   return { route: RouteEnum.OmniBridge };
 }
 function createVirtualChainRoute(auroraEngineContractId, proxyTokenContractId) {
@@ -1615,17 +1768,11 @@ function determineRouteConfig(sdk, withdrawalParams) {
   const bridgeName = parseAssetId.bridgeName;
   switch (bridgeName) {
     case BridgeNameEnum.Hot:
-      return {
-        route: RouteEnum.HotBridge,
-        chain: parseAssetId.blockchain
-      };
+      return createHotBridgeRoute(parseAssetId.blockchain);
     case BridgeNameEnum.Poa:
-      return {
-        route: RouteEnum.PoaBridge,
-        chain: parseAssetId.blockchain
-      };
+      return createPoaBridgeRoute(parseAssetId.blockchain);
     case BridgeNameEnum.Omni:
-      return createOmniWithdrawalRoute();
+      return createOmniBridgeRoute();
     case BridgeNameEnum.None:
       return createNearWithdrawalRoute();
     default:
@@ -1639,9 +1786,9 @@ var IntentsSDK = class {
   constructor(args) {
     this.env = args.env ?? "production";
     this.referral = args.referral;
-    const nearRpcUrls = args.rpc?.[Chains.Near] ?? import_internal_utils16.PUBLIC_NEAR_RPC_URLS;
-    (0, import_internal_utils16.assert)(nearRpcUrls.length > 0, "NEAR RPC URLs are not provided");
-    const nearProvider = (0, import_internal_utils16.nearFailoverRpcProvider)({ urls: nearRpcUrls });
+    const nearRpcUrls = args.rpc?.[Chains.Near] ?? import_internal_utils19.PUBLIC_NEAR_RPC_URLS;
+    (0, import_internal_utils19.assert)(nearRpcUrls.length > 0, "NEAR RPC URLs are not provided");
+    const nearProvider = (0, import_internal_utils19.nearFailoverRpcProvider)({ urls: nearRpcUrls });
     const stellarRpcUrls = configureStellarRpcUrls(
       PUBLIC_STELLAR_RPC_URLS,
       args.rpc
@@ -1690,7 +1837,7 @@ var IntentsSDK = class {
   }
   async createWithdrawalIntents(args) {
     for (const bridge of this.bridges) {
-      if (bridge.supports(args.withdrawalParams)) {
+      if (await bridge.supports(args.withdrawalParams)) {
         const actualAmount = args.withdrawalParams.feeInclusive ? args.withdrawalParams.amount - args.feeEstimation.amount : args.withdrawalParams.amount;
         await bridge.validateWithdrawal({
           assetId: args.withdrawalParams.assetId,
@@ -1732,7 +1879,7 @@ var IntentsSDK = class {
   }
   async _estimateWithdrawalFee(args) {
     for (const bridge of this.bridges) {
-      if (bridge.supports(args.withdrawalParams)) {
+      if (await bridge.supports(args.withdrawalParams)) {
         const fee = await bridge.estimateWithdrawalFee({
           withdrawalParams: args.withdrawalParams,
           quoteOptions: args.quoteOptions,
@@ -1767,7 +1914,7 @@ var IntentsSDK = class {
       const routeConfig = determineRouteConfig(this, w);
       const route = routeConfig.route;
       const index = indexes.get(route);
-      (0, import_internal_utils16.assert)(index != null, "Index is not found for route");
+      (0, import_internal_utils19.assert)(index != null, "Index is not found for route");
       indexes.set(route, index + 1);
       return {
         routeConfig,
@@ -1801,7 +1948,7 @@ var IntentsSDK = class {
     if (Array.isArray(args.withdrawalParams)) {
       return result;
     }
-    (0, import_internal_utils16.assert)(result.length === 1, "Unexpected result length");
+    (0, import_internal_utils19.assert)(result.length === 1, "Unexpected result length");
     return result[0];
   }
   parseAssetId(assetId) {
@@ -1815,7 +1962,7 @@ var IntentsSDK = class {
   }
   async signAndSendIntent(args) {
     const intentSigner = args.signer ?? this.intentSigner;
-    (0, import_internal_utils16.assert)(intentSigner != null, "Intent signer is not provided");
+    (0, import_internal_utils19.assert)(intentSigner != null, "Intent signer is not provided");
     const intentExecuter = new IntentExecuter({
       env: this.env,
       logger: args.logger,
@@ -1884,12 +2031,12 @@ var IntentsSDK = class {
     intentHash,
     logger
   }) {
-    return import_internal_utils16.solverRelay.getStatus(
+    return import_internal_utils19.solverRelay.getStatus(
       {
         intent_hash: intentHash
       },
       {
-        baseURL: import_internal_utils16.configsByEnvironment[this.env].solverRelayBaseURL,
+        baseURL: import_internal_utils19.configsByEnvironment[this.env].solverRelayBaseURL,
         logger
       }
     );
@@ -1920,7 +2067,7 @@ var IntentsSDK = class {
       withdrawalParams,
       intentTx,
       logger: args.logger,
-      retryOptions: import_internal_utils16.RETRY_CONFIGS.FIVE_MINS_STEADY
+      retryOptions: import_internal_utils19.RETRY_CONFIGS.FIVE_MINS_STEADY
     });
     if (!Array.isArray(args.withdrawalParams)) {
       return {
@@ -1999,14 +2146,14 @@ var IntentSignerNearKeypair = class extends IntentSignerNEP413 {
 };
 
 // src/intents/intent-signer-impl/intent-signer-viem.ts
-var import_internal_utils17 = require("@defuse-protocol/internal-utils");
+var import_internal_utils20 = require("@defuse-protocol/internal-utils");
 var IntentSignerViem = class {
   constructor(account) {
     this.account = account;
   }
   async signIntent(intent) {
     const payload = JSON.stringify({
-      signer_id: intent.signer_id ?? import_internal_utils17.utils.authHandleToIntentsUserId({
+      signer_id: intent.signer_id ?? import_internal_utils20.utils.authHandleToIntentsUserId({
         identifier: this.account.address,
         method: "evm"
       }),
@@ -2024,7 +2171,7 @@ var IntentSignerViem = class {
     return {
       standard: "erc191",
       payload,
-      signature: import_internal_utils17.utils.transformERC191Signature(signature)
+      signature: import_internal_utils20.utils.transformERC191Signature(signature)
     };
   }
 };
@@ -2041,11 +2188,11 @@ function createIntentSignerViem(config) {
 }
 
 // index.ts
-var import_internal_utils19 = require("@defuse-protocol/internal-utils");
+var import_internal_utils22 = require("@defuse-protocol/internal-utils");
 
 // src/bridges/omni-bridge/error.ts
-var import_internal_utils18 = require("@defuse-protocol/internal-utils");
-var OmniTransferNotFoundError = class extends import_internal_utils18.BaseError {
+var import_internal_utils21 = require("@defuse-protocol/internal-utils");
+var OmniTransferNotFoundError = class extends import_internal_utils21.BaseError {
   constructor(txHash) {
     super("Omni transfer with given hash is not found in the relayer.", {
       metaMessages: [`OriginTxHash: ${txHash}`],
@@ -2054,7 +2201,7 @@ var OmniTransferNotFoundError = class extends import_internal_utils18.BaseError
     this.txHash = txHash;
   }
 };
-var OmniTransferDestinationChainHashNotFoundError = class extends import_internal_utils18.BaseError {
+var OmniTransferDestinationChainHashNotFoundError = class extends import_internal_utils21.BaseError {
   constructor(txHash, destinationChain) {
     super("Relayer did not return destination chain hash for a transfer.", {
       metaMessages: [
@@ -2067,7 +2214,7 @@ var OmniTransferDestinationChainHashNotFoundError = class extends import_interna
     this.destinationChain = destinationChain;
   }
 };
-var TokenNotSupportedByOmniRelayerError = class extends import_internal_utils18.BaseError {
+var TokenNotSupportedByOmniRelayerError = class extends import_internal_utils21.BaseError {
   constructor(token) {
     super(`Omni Relayer doesn't accept fee in the transferred token ${token}`, {
       metaMessages: [`Token: ${token}`],
@@ -2076,7 +2223,7 @@ var TokenNotSupportedByOmniRelayerError = class extends import_internal_utils18.
     this.token = token;
   }
 };
-var TokenNotFoundInDestinationChainError = class extends import_internal_utils18.BaseError {
+var TokenNotFoundInDestinationChainError = class extends import_internal_utils21.BaseError {
   constructor(token, chainKind) {
     super(
       `The token ${token} doesn't exist in destination network ${chainKind}`,
@@ -2090,10 +2237,10 @@ var TokenNotFoundInDestinationChainError = class extends import_internal_utils18
 };
 
 // index.ts
-var import_internal_utils20 = require("@defuse-protocol/internal-utils");
-var import_internal_utils21 = require("@defuse-protocol/internal-utils");
-var import_internal_utils22 = require("@defuse-protocol/internal-utils");
 var import_internal_utils23 = require("@defuse-protocol/internal-utils");
+var import_internal_utils24 = require("@defuse-protocol/internal-utils");
+var import_internal_utils25 = require("@defuse-protocol/internal-utils");
+var import_internal_utils26 = require("@defuse-protocol/internal-utils");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AssertionError,
@@ -2121,6 +2268,7 @@ var import_internal_utils23 = require("@defuse-protocol/internal-utils");
   TokenNotFoundInDestinationChainError,
   TokenNotSupportedByOmniRelayerError,
   TrustlineNotFoundError,
+  UnsupportedAssetIdError,
   UnsupportedDestinationMemoError,
   createDefaultRoute,
   createHotBridgeRoute,
@@ -2129,7 +2277,7 @@ var import_internal_utils23 = require("@defuse-protocol/internal-utils");
   createIntentSignerViem,
   createInternalTransferRoute,
   createNearWithdrawalRoute,
-  createOmniWithdrawalRoute,
+  createOmniBridgeRoute,
   createPoaBridgeRoute,
   createVirtualChainRoute
 });