@defuse-protocol/intents-sdk 0.16.4 → 0.17.1

package/dist/index.js

@@ -3,9 +3,9 @@ import {
   assert as assert11,
   PUBLIC_NEAR_RPC_URLS,
   RETRY_CONFIGS as RETRY_CONFIGS2,
-  configsByEnvironment as configsByEnvironment7,
+  configsByEnvironment as configsByEnvironment6,
   nearFailoverRpcProvider,
-  solverRelay as solverRelay5
+  solverRelay as solverRelay3
 } from "@defuse-protocol/internal-utils";
 import hotOmniSdk from "@hot-labs/omni-sdk";
 import { stringify } from "viem";
@@ -13,11 +13,9 @@ import { stringify } from "viem";
 // src/bridges/aurora-engine-bridge/aurora-engine-bridge.ts
 import {
   assert as assert2,
-  configsByEnvironment,
   getNearNep141MinStorageBalance,
   getNearNep141StorageBalance,
-  solverRelay,
-  utils as utils2
+  utils as utils3
 } from "@defuse-protocol/internal-utils";
 
 // src/constants/route-enum.ts
@@ -72,6 +70,194 @@ function withdrawalParamsInvariant(params) {
   );
 }
 
+// src/lib/parse-defuse-asset-id.ts
+import { utils as utils2 } from "@defuse-protocol/internal-utils";
+
+// src/classes/errors.ts
+import { BaseError } from "@defuse-protocol/internal-utils";
+var FeeExceedsAmountError = class extends 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 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 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 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 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 utils2.parseDefuseAssetId(assetId);
+  } catch {
+    throw new UnsupportedAssetIdError(assetId, "Invalid asset id format.");
+  }
+}
+
+// src/lib/estimate-fee.ts
+import {
+  configsByEnvironment as configsByEnvironment2,
+  QuoteError,
+  solverRelay
+} from "@defuse-protocol/internal-utils";
+
+// src/lib/tokensUsdPricesHttpClient/apis.ts
+import { request, configsByEnvironment } from "@defuse-protocol/internal-utils";
+async function tokens(config) {
+  const response = await request({
+    url: new URL(
+      "tokens",
+      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 solverRelay.getQuote({
+      quoteParams: {
+        defuse_asset_identifier_in: tokenAssetId,
+        defuse_asset_identifier_out: feeAssetId,
+        exact_amount_out: feeAmount.toString(),
+        wait_ms: quoteOptions?.waitMs
+      },
+      config: {
+        baseURL: configsByEnvironment2[env].solverRelayBaseURL,
+        logBalanceSufficient: false,
+        logger
+      }
+    });
+  } catch (err) {
+    if (!(err instanceof 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 solverRelay.getQuote({
+      quoteParams: {
+        defuse_asset_identifier_in: tokenAssetId,
+        defuse_asset_identifier_out: feeAssetId,
+        exact_amount_in: exactAmountIn.toString(),
+        wait_ms: quoteOptions?.waitMs
+      },
+      config: {
+        baseURL: configsByEnvironment2[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({
@@ -84,11 +270,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;
@@ -125,7 +319,7 @@ var AuroraEngineBridge = class {
   }
   async estimateWithdrawalFee(args) {
     withdrawalParamsInvariant(args.withdrawalParams);
-    const { contractId: tokenAccountId, standard } = utils2.parseDefuseAssetId(
+    const { contractId: tokenAccountId, standard } = utils3.parseDefuseAssetId(
       args.withdrawalParams.assetId
     );
     assert2(standard === "nep141", "Only NEP-141 is supported");
@@ -148,18 +342,13 @@ var AuroraEngineBridge = class {
     }
     const feeAssetId = NEAR_NATIVE_ASSET_ID;
     const feeAmount = minStorageBalance - userStorageBalance;
-    const feeQuote = args.withdrawalParams.assetId === feeAssetId ? null : await 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: 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,
@@ -174,11 +363,9 @@ var AuroraEngineBridge = class {
 // src/bridges/direct-bridge/direct-bridge.ts
 import {
   assert as assert5,
-  configsByEnvironment as configsByEnvironment2,
   getNearNep141MinStorageBalance as getNearNep141MinStorageBalance2,
   getNearNep141StorageBalance as getNearNep141StorageBalance2,
-  solverRelay as solverRelay2,
-  utils as utils4
+  utils as utils5
 } from "@defuse-protocol/internal-utils";
 
 // src/constants/bridge-name-enum.ts
@@ -227,7 +414,7 @@ function getEIP155ChainId(chain) {
 var NEAR_NATIVE_ASSET_ID2 = "nep141:wrap.near";
 
 // src/bridges/direct-bridge/direct-bridge-utils.ts
-import { assert as assert4, utils as utils3 } from "@defuse-protocol/internal-utils";
+import { assert as assert4, utils as utils4 } from "@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) {
@@ -237,7 +424,7 @@ function createWithdrawIntentPrimitive2(params) {
       amount: params.amount.toString()
     };
   }
-  const { contractId: tokenAccountId, standard } = utils3.parseDefuseAssetId(
+  const { contractId: tokenAccountId, standard } = utils4.parseDefuseAssetId(
     params.assetId
   );
   assert4(standard === "nep141", "Only NEP-141 is supported");
@@ -269,19 +456,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 = utils4.parseDefuseAssetId(assetId);
+    const parsed = parseDefuseAssetId(assetId);
     if (parsed.standard === "nep141") {
       return Object.assign(parsed, {
         blockchain: Chains.Near,
@@ -322,7 +512,7 @@ var DirectBridge = class {
   }
   async estimateWithdrawalFee(args) {
     withdrawalParamsInvariant2(args.withdrawalParams);
-    const { contractId: tokenAccountId, standard } = utils4.parseDefuseAssetId(
+    const { contractId: tokenAccountId, standard } = utils5.parseDefuseAssetId(
       args.withdrawalParams.assetId
     );
     assert5(standard === "nep141", "Only NEP-141 is supported");
@@ -354,18 +544,13 @@ var DirectBridge = class {
     }
     const feeAssetId = NEAR_NATIVE_ASSET_ID2;
     const feeAmount = minStorageBalance - userStorageBalance;
-    const feeQuote = args.withdrawalParams.assetId === feeAssetId ? null : await solverRelay2.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: configsByEnvironment2[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,
@@ -380,74 +565,12 @@ var DirectBridge = class {
 // src/bridges/hot-bridge/hot-bridge.ts
 import {
   assert as assert7,
-  RETRY_CONFIGS,
-  configsByEnvironment as configsByEnvironment3,
-  utils as internalUtils,
-  solverRelay as solverRelay3
+  RETRY_CONFIGS
 } from "@defuse-protocol/internal-utils";
-import { utils as utils5 } from "@hot-labs/omni-sdk";
+import { OMNI_HOT_V2 } from "@hot-labs/omni-sdk";
+import { utils as utils6 } from "@hot-labs/omni-sdk";
 import { retry } from "@lifeomic/attempt";
 
-// src/classes/errors.ts
-import { BaseError } from "@defuse-protocol/internal-utils";
-var FeeExceedsAmountError = class extends 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 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 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 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
 import { BaseError as BaseError2 } from "@defuse-protocol/internal-utils";
 var HotWithdrawalPendingError = class extends BaseError2 {
@@ -557,37 +680,56 @@ 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 = internalUtils.parseDefuseAssetId(assetId);
-    if (parsed.contractId === utils5.OMNI_HOT_V2) {
-      assert7(
-        parsed.standard === "nep245",
-        "NEP-245 is supported only for HOT bridge"
+    const parsed = parseDefuseAssetId(assetId);
+    const contractIdSatisfies = parsed.contractId === OMNI_HOT_V2;
+    if (!contractIdSatisfies) {
+      return null;
+    }
+    if (parsed.standard !== "nep245") {
+      throw new UnsupportedAssetIdError(
+        assetId,
+        'Should start with "nep245:".'
       );
-      const [chainId, address] = utils5.fromOmni(parsed.tokenId).split(":");
-      assert7(chainId != null, "Chain ID is not found");
-      assert7(address != null, "Address is not found");
-      return Object.assign(
-        parsed,
-        {
-          blockchain: hotNetworkIdToCAIP2(chainId),
-          bridgeName: BridgeNameEnum.Hot
-        },
-        address === "native" ? { native: true } : { address }
+    }
+    const [chainId, address] = utils6.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);
@@ -664,23 +806,19 @@ var HotBridge = class {
     const assetInfo = this.parseAssetId(args.withdrawalParams.assetId);
     assert7(assetInfo != null, "Asset is not supported");
     hotBlockchainInvariant(assetInfo.blockchain);
-    const { gasPrice: feeAmount } = await this.hotSdk.getGaslessWithdrawFee(
-      toHotNetworkId(assetInfo.blockchain),
-      args.withdrawalParams.destinationAddress
-    );
+    const { gasPrice: feeAmount } = await this.hotSdk.getGaslessWithdrawFee({
+      chain: toHotNetworkId(assetInfo.blockchain),
+      token: "native" in assetInfo ? "native" : assetInfo.address,
+      receiver: args.withdrawalParams.destinationAddress
+    });
     const feeAssetId = getFeeAssetIdForChain(assetInfo.blockchain);
-    const feeQuote = args.withdrawalParams.assetId === feeAssetId || feeAmount === 0n ? null : await solverRelay3.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: configsByEnvironment3[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,
@@ -734,7 +872,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);
     }
@@ -775,16 +913,16 @@ var IntentsBridge = class {
 // src/bridges/poa-bridge/poa-bridge.ts
 import {
   assert as assert8,
-  configsByEnvironment as configsByEnvironment4,
+  configsByEnvironment as configsByEnvironment3,
   poaBridge,
-  utils as utils7
+  utils as utils8
 } from "@defuse-protocol/internal-utils";
 import TTLCache from "@isaacs/ttlcache";
 
 // src/bridges/poa-bridge/poa-bridge-utils.ts
-import { utils as utils6 } from "@defuse-protocol/internal-utils";
+import { utils as utils7 } from "@defuse-protocol/internal-utils";
 function createWithdrawIntentPrimitive3(params) {
-  const { contractId: tokenAccountId } = utils6.parseDefuseAssetId(
+  const { contractId: tokenAccountId } = utils7.parseDefuseAssetId(
     params.assetId
   );
   return {
@@ -865,30 +1003,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 = utils7.parseDefuseAssetId(assetId);
-    if (parsed.contractId.endsWith(
-      `.${configsByEnvironment4[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(
+      `.${configsByEnvironment3[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({
@@ -907,11 +1058,11 @@ var PoaBridge = class {
   async validateWithdrawal(args) {
     const assetInfo = this.parseAssetId(args.assetId);
     assert8(assetInfo != null, "Asset is not supported");
-    const { tokens } = await this.getCachedSupportedTokens(
+    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) {
@@ -930,13 +1081,13 @@ var PoaBridge = class {
     assert8(assetInfo != null, "Asset is not supported");
     const estimation = await poaBridge.httpClient.getWithdrawalEstimate(
       {
-        token: utils7.getTokenAccountId(args.withdrawalParams.assetId),
+        token: utils8.getTokenAccountId(args.withdrawalParams.assetId),
         address: args.withdrawalParams.destinationAddress,
         // biome-ignore lint/suspicious/noExplicitAny: <explanation>
         chain: toPoaNetwork(assetInfo.blockchain)
       },
       {
-        baseURL: configsByEnvironment4[this.env].poaBridgeBaseURL,
+        baseURL: configsByEnvironment3[this.env].poaBridgeBaseURL,
         logger: args.logger
       }
     );
@@ -951,7 +1102,7 @@ var PoaBridge = class {
       index: args.index,
       signal: args.signal ?? new AbortController().signal,
       retryOptions: args.retryOptions,
-      baseURL: configsByEnvironment4[this.env].poaBridgeBaseURL,
+      baseURL: configsByEnvironment3[this.env].poaBridgeBaseURL,
       logger: args.logger
     });
     return { hash: withdrawalStatus.destinationTxHash };
@@ -969,7 +1120,7 @@ var PoaBridge = class {
     const data = await poaBridge.httpClient.getSupportedTokens(
       { chains },
       {
-        baseURL: configsByEnvironment4[this.env].poaBridgeBaseURL,
+        baseURL: configsByEnvironment3[this.env].poaBridgeBaseURL,
         logger
       }
     );
@@ -992,7 +1143,7 @@ var PUBLIC_STELLAR_RPC_URLS = {
 
 // src/intents/intent-executer-impl/intent-executer.ts
 import {
-  configsByEnvironment as configsByEnvironment5
+  configsByEnvironment as configsByEnvironment4
 } from "@defuse-protocol/internal-utils";
 
 // ../../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/_u64.js
@@ -1374,7 +1525,7 @@ var IntentExecuter = class {
     relayParams: relayParamsFactory,
     ...intentParams
   }) {
-    const verifyingContract = configsByEnvironment5[this.env].contractID;
+    const verifyingContract = configsByEnvironment4[this.env].contractID;
     let intentPayload = defaultIntentPayloadFactory({
       verifying_contract: verifyingContract,
       ...intentParams
@@ -1425,8 +1576,8 @@ async function mergeIntentPayloads(basePayload, intentPayloadFactory) {
 
 // src/intents/intent-relayer-impl/intent-relayer-public.ts
 import {
-  configsByEnvironment as configsByEnvironment6,
-  solverRelay as solverRelay4
+  configsByEnvironment as configsByEnvironment5,
+  solverRelay as solverRelay2
 } from "@defuse-protocol/internal-utils";
 var IntentRelayerPublic = class {
   constructor({ env }) {
@@ -1449,13 +1600,13 @@ var IntentRelayerPublic = class {
     multiPayloads,
     quoteHashes
   }, ctx = {}) {
-    const a = await solverRelay4.publishIntents(
+    const a = await solverRelay2.publishIntents(
       {
         quote_hashes: quoteHashes,
         signed_datas: multiPayloads
       },
       {
-        baseURL: configsByEnvironment6[this.env].solverRelayBaseURL,
+        baseURL: configsByEnvironment5[this.env].solverRelayBaseURL,
         logger: ctx.logger
       }
     );
@@ -1465,10 +1616,10 @@ var IntentRelayerPublic = class {
     throw a.unwrapErr();
   }
   async waitForSettlement(ticket, ctx = {}) {
-    const result = await solverRelay4.waitForIntentSettlement({
+    const result = await solverRelay2.waitForIntentSettlement({
       intentHash: ticket,
       signal: new AbortController().signal,
-      baseURL: configsByEnvironment6[this.env].solverRelayBaseURL,
+      baseURL: configsByEnvironment5[this.env].solverRelayBaseURL,
       logger: ctx.logger
     });
     return {
@@ -1476,7 +1627,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: configsByEnvironment6[this.env].contractID
+        accountId: configsByEnvironment5[this.env].contractID
       }
     };
   }
@@ -1547,7 +1698,7 @@ function createInternalTransferRoute() {
 function createNearWithdrawalRoute(msg) {
   return { route: RouteEnum.NearWithdrawal, msg };
 }
-function createOmniWithdrawalRoute() {
+function createOmniBridgeRoute() {
   return { route: RouteEnum.OmniBridge };
 }
 function createVirtualChainRoute(auroraEngineContractId, proxyTokenContractId) {
@@ -1581,17 +1732,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:
@@ -1656,7 +1801,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,
@@ -1698,7 +1843,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,
@@ -1850,12 +1995,12 @@ var IntentsSDK = class {
     intentHash,
     logger
   }) {
-    return solverRelay5.getStatus(
+    return solverRelay3.getStatus(
       {
         intent_hash: intentHash
       },
       {
-        baseURL: configsByEnvironment7[this.env].solverRelayBaseURL,
+        baseURL: configsByEnvironment6[this.env].solverRelayBaseURL,
         logger
       }
     );
@@ -1965,14 +2110,14 @@ var IntentSignerNearKeypair = class extends IntentSignerNEP413 {
 };
 
 // src/intents/intent-signer-impl/intent-signer-viem.ts
-import { utils as utils8 } from "@defuse-protocol/internal-utils";
+import { utils as utils9 } from "@defuse-protocol/internal-utils";
 var IntentSignerViem = class {
   constructor(account) {
     this.account = account;
   }
   async signIntent(intent) {
     const payload = JSON.stringify({
-      signer_id: intent.signer_id ?? utils8.authHandleToIntentsUserId({
+      signer_id: intent.signer_id ?? utils9.authHandleToIntentsUserId({
         identifier: this.account.address,
         method: "evm"
       }),
@@ -1990,7 +2135,7 @@ var IntentSignerViem = class {
     return {
       standard: "erc191",
       payload,
-      signature: utils8.transformERC191Signature(signature)
+      signature: utils9.transformERC191Signature(signature)
     };
   }
 };
@@ -2072,7 +2217,7 @@ import {
   AssertionError
 } from "@defuse-protocol/internal-utils";
 import {
-  QuoteError,
+  QuoteError as QuoteError2,
   IntentSettlementError,
   RelayPublishError
 } from "@defuse-protocol/internal-utils";
@@ -2094,7 +2239,7 @@ export {
   PoaWithdrawalInvariantError,
   PoaWithdrawalNotFoundError,
   PoaWithdrawalPendingError,
-  QuoteError,
+  QuoteError2 as QuoteError,
   RelayPublishError,
   RouteEnum,
   RpcRequestError,
@@ -2102,6 +2247,7 @@ export {
   TokenNotFoundInDestinationChainError,
   TokenNotSupportedByOmniRelayerError,
   TrustlineNotFoundError,
+  UnsupportedAssetIdError,
   UnsupportedDestinationMemoError,
   createDefaultRoute,
   createHotBridgeRoute,
@@ -2110,7 +2256,7 @@ export {
   createIntentSignerViem,
   createInternalTransferRoute,
   createNearWithdrawalRoute,
-  createOmniWithdrawalRoute,
+  createOmniBridgeRoute,
   createPoaBridgeRoute,
   createVirtualChainRoute
 };