@defuse-protocol/intents-sdk 0.14.0

package/dist/index.js

@@ -0,0 +1,2055 @@
+// src/sdk.ts
+import {
+  assert as assert11,
+  PUBLIC_NEAR_RPC_URLS,
+  RETRY_CONFIGS as RETRY_CONFIGS2,
+  configsByEnvironment as configsByEnvironment7,
+  nearFailoverRpcProvider,
+  solverRelay as solverRelay5
+} from "@defuse-protocol/internal-utils";
+import hotOmniSdk from "@hot-labs/omni-sdk";
+import { stringify } from "viem";
+
+// src/bridges/aurora-engine-bridge/aurora-engine-bridge.ts
+import {
+  assert as assert2,
+  configsByEnvironment,
+  getNearNep141MinStorageBalance,
+  getNearNep141StorageBalance,
+  solverRelay,
+  utils as utils2
+} from "@defuse-protocol/internal-utils";
+
+// src/constants/route-enum.ts
+var RouteEnum = {
+  HotBridge: "hot_bridge",
+  PoaBridge: "poa_bridge",
+  NearWithdrawal: "near_withdrawal",
+  VirtualChain: "virtual_chain",
+  InternalTransfer: "internal_transfer"
+};
+
+// src/bridges/aurora-engine-bridge/aurora-engine-bridge-constants.ts
+var NEAR_NATIVE_ASSET_ID = "nep141:wrap.near";
+
+// src/bridges/aurora-engine-bridge/aurora-engine-bridge-utils.ts
+import { assert, utils } from "@defuse-protocol/internal-utils";
+import { getAddress } from "viem";
+function createWithdrawIntentPrimitive(params) {
+  const { contractId: tokenAccountId, standard } = utils.parseDefuseAssetId(
+    params.assetId
+  );
+  assert(standard === "nep141", "Only NEP-141 is supported");
+  if (params.proxyTokenContractId == null) {
+    return {
+      intent: "ft_withdraw",
+      token: tokenAccountId,
+      receiver_id: params.auroraEngineContractId,
+      amount: params.amount.toString(),
+      msg: makeAuroraEngineDepositMsg(params.destinationAddress),
+      storage_deposit: params.storageDeposit > 0n ? params.storageDeposit.toString() : null
+    };
+  }
+  return {
+    intent: "ft_withdraw",
+    token: tokenAccountId,
+    receiver_id: params.proxyTokenContractId,
+    amount: params.amount.toString(),
+    msg: `${params.auroraEngineContractId}:${makeAuroraEngineDepositMsg(params.destinationAddress)}`,
+    storage_deposit: params.storageDeposit > 0n ? params.storageDeposit.toString() : null
+  };
+}
+function makeAuroraEngineDepositMsg(recipientAddress) {
+  const parsedRecipientAddress = getAddress(recipientAddress);
+  return parsedRecipientAddress.slice(2).toLowerCase();
+}
+function withdrawalParamsInvariant(params) {
+  assert(params.routeConfig != null, "Bridge config is required");
+  assert(
+    params.routeConfig.route === RouteEnum.VirtualChain,
+    "Bridge is not aurora_engine"
+  );
+}
+
+// src/bridges/aurora-engine-bridge/aurora-engine-bridge.ts
+var AuroraEngineBridge = class {
+  constructor({
+    env,
+    nearProvider
+  }) {
+    this.env = env;
+    this.nearProvider = nearProvider;
+  }
+  is(routeConfig) {
+    return routeConfig.route === RouteEnum.VirtualChain;
+  }
+  supports(params) {
+    if ("routeConfig" in params && params.routeConfig != null) {
+      return this.is(params.routeConfig);
+    }
+    return false;
+  }
+  parseAssetId() {
+    return null;
+  }
+  createWithdrawalIntents(args) {
+    withdrawalParamsInvariant(args.withdrawalParams);
+    const intents = [];
+    if (args.feeEstimation.quote != null) {
+      intents.push({
+        intent: "token_diff",
+        diff: {
+          [args.feeEstimation.quote.defuse_asset_identifier_in]: `-${args.feeEstimation.quote.amount_in}`,
+          [args.feeEstimation.quote.defuse_asset_identifier_out]: args.feeEstimation.quote.amount_out
+        },
+        referral: args.referral
+      });
+    }
+    const intent = createWithdrawIntentPrimitive({
+      assetId: args.withdrawalParams.assetId,
+      auroraEngineContractId: args.withdrawalParams.routeConfig.auroraEngineContractId,
+      proxyTokenContractId: args.withdrawalParams.routeConfig.proxyTokenContractId,
+      destinationAddress: args.withdrawalParams.destinationAddress,
+      amount: args.withdrawalParams.amount,
+      storageDeposit: args.feeEstimation.quote ? BigInt(args.feeEstimation.quote.amount_out) : args.feeEstimation.amount
+    });
+    intents.push(intent);
+    return Promise.resolve(intents);
+  }
+  /**
+   * Aurora Engine bridge doesn't have withdrawal restrictions.
+   */
+  async validateWithdrawal(_args) {
+    return;
+  }
+  async estimateWithdrawalFee(args) {
+    withdrawalParamsInvariant(args.withdrawalParams);
+    const { contractId: tokenAccountId, standard } = utils2.parseDefuseAssetId(
+      args.withdrawalParams.assetId
+    );
+    assert2(standard === "nep141", "Only NEP-141 is supported");
+    const [minStorageBalance, userStorageBalance] = await Promise.all([
+      getNearNep141MinStorageBalance({
+        contractId: tokenAccountId,
+        nearProvider: this.nearProvider
+      }),
+      getNearNep141StorageBalance({
+        contractId: tokenAccountId,
+        accountId: args.withdrawalParams.routeConfig.auroraEngineContractId,
+        nearProvider: this.nearProvider
+      })
+    ]);
+    if (minStorageBalance <= userStorageBalance) {
+      return {
+        amount: 0n,
+        quote: null
+      };
+    }
+    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
+      }
+    });
+    return {
+      amount: feeQuote ? BigInt(feeQuote.amount_in) : feeAmount,
+      quote: feeQuote
+    };
+  }
+  async waitForWithdrawalCompletion(_args) {
+    return { hash: null };
+  }
+};
+
+// 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
+} from "@defuse-protocol/internal-utils";
+
+// src/constants/bridge-name-enum.ts
+var BridgeNameEnum = {
+  Hot: "hot",
+  Poa: "poa",
+  None: null
+};
+
+// src/lib/caip2.ts
+import { assert as assert3 } from "@defuse-protocol/internal-utils";
+var Chains = {
+  Bitcoin: "bip122:000000000019d6689c085ae165831e93",
+  Ethereum: "eip155:1",
+  Base: "eip155:8453",
+  Arbitrum: "eip155:42161",
+  BNB: "eip155:56",
+  Polygon: "eip155:137",
+  Near: "near:mainnet",
+  Solana: "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp",
+  Tron: "tron:27Lqcw",
+  Gnosis: "eip155:100",
+  XRPL: "xrpl:0",
+  Dogecoin: "bip122:1a91e3dace36e2be3bf030a65679fe82",
+  Zcash: "zcash:0",
+  Berachain: "eip155:80085",
+  TON: "tvm:-239",
+  Optimism: "eip155:10",
+  Avalanche: "eip155:43114",
+  Sui: "sui:mainnet",
+  Aptos: "aptos:mainnet",
+  Stellar: "stellar:pubnet",
+  Cardano: "cip34:1-764824073"
+};
+function getEIP155ChainId(chain) {
+  assert3(chain.startsWith("eip155:"), "Chain is not an EIP-155 chain");
+  const chainIdStr = chain.slice(7);
+  assert3(chainIdStr.length > 0, "Chain is not an EIP-155 chain");
+  const chainId = Number(chainIdStr);
+  assert3(!Number.isNaN(chainId), "Chain is not an EIP-155 chain");
+  return chainId;
+}
+
+// src/bridges/direct-bridge/direct-bridge-constants.ts
+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";
+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) {
+    return {
+      intent: "native_withdraw",
+      receiver_id: params.destinationAddress,
+      amount: params.amount.toString()
+    };
+  }
+  const { contractId: tokenAccountId, standard } = utils3.parseDefuseAssetId(
+    params.assetId
+  );
+  assert4(standard === "nep141", "Only NEP-141 is supported");
+  return {
+    intent: "ft_withdraw",
+    token: tokenAccountId,
+    receiver_id: params.destinationAddress,
+    amount: params.amount.toString(),
+    storage_deposit: params.storageDeposit > 0n ? params.storageDeposit.toString() : null,
+    msg: params.msg
+  };
+}
+function withdrawalParamsInvariant2(params) {
+  assert4(
+    !params.routeConfig ? true : params.routeConfig.route === RouteEnum.NearWithdrawal,
+    "Bridge is not direct"
+  );
+}
+
+// src/bridges/direct-bridge/direct-bridge.ts
+var DirectBridge = class {
+  constructor({
+    env,
+    nearProvider
+  }) {
+    this.env = env;
+    this.nearProvider = nearProvider;
+  }
+  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 {
+      return false;
+    }
+  }
+  parseAssetId(assetId) {
+    const parsed = utils4.parseDefuseAssetId(assetId);
+    if (parsed.standard === "nep141") {
+      return Object.assign(parsed, {
+        blockchain: Chains.Near,
+        bridgeName: BridgeNameEnum.None,
+        address: parsed.contractId
+      });
+    }
+    return null;
+  }
+  createWithdrawalIntents(args) {
+    withdrawalParamsInvariant2(args.withdrawalParams);
+    const intents = [];
+    if (args.feeEstimation.quote != null) {
+      intents.push({
+        intent: "token_diff",
+        diff: {
+          [args.feeEstimation.quote.defuse_asset_identifier_in]: `-${args.feeEstimation.quote.amount_in}`,
+          [args.feeEstimation.quote.defuse_asset_identifier_out]: args.feeEstimation.quote.amount_out
+        },
+        referral: args.referral
+      });
+    }
+    const intent = createWithdrawIntentPrimitive2({
+      assetId: args.withdrawalParams.assetId,
+      destinationAddress: args.withdrawalParams.destinationAddress,
+      amount: args.withdrawalParams.amount,
+      storageDeposit: args.feeEstimation.quote ? BigInt(args.feeEstimation.quote.amount_out) : args.feeEstimation.amount,
+      msg: args.withdrawalParams.routeConfig?.msg
+    });
+    intents.push(intent);
+    return Promise.resolve(intents);
+  }
+  /**
+   * Direct bridge doesn't have withdrawal restrictions.
+   */
+  async validateWithdrawal(_args) {
+    return;
+  }
+  async estimateWithdrawalFee(args) {
+    withdrawalParamsInvariant2(args.withdrawalParams);
+    const { contractId: tokenAccountId, standard } = utils4.parseDefuseAssetId(
+      args.withdrawalParams.assetId
+    );
+    assert5(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`
+      args.withdrawalParams.routeConfig?.msg === void 0
+    )
+      return {
+        amount: 0n,
+        quote: null
+      };
+    const [minStorageBalance, userStorageBalance] = await Promise.all([
+      getNearNep141MinStorageBalance2({
+        contractId: tokenAccountId,
+        nearProvider: this.nearProvider
+      }),
+      getNearNep141StorageBalance2({
+        contractId: tokenAccountId,
+        accountId: args.withdrawalParams.destinationAddress,
+        nearProvider: this.nearProvider
+      })
+    ]);
+    if (minStorageBalance <= userStorageBalance) {
+      return {
+        amount: 0n,
+        quote: null
+      };
+    }
+    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
+      }
+    });
+    return {
+      amount: feeQuote ? BigInt(feeQuote.amount_in) : feeAmount,
+      quote: feeQuote
+    };
+  }
+  async waitForWithdrawalCompletion(args) {
+    return { hash: args.tx.hash };
+  }
+};
+
+// src/bridges/hot-bridge/hot-bridge.ts
+import {
+  assert as assert7,
+  RETRY_CONFIGS,
+  configsByEnvironment as configsByEnvironment3,
+  utils as internalUtils,
+  solverRelay as solverRelay3
+} from "@defuse-protocol/internal-utils";
+import { utils as utils5 } 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 {
+  constructor(txHash, index) {
+    super("Withdrawal is still pending.", {
+      metaMessages: [`TxHash: ${txHash}`, `Index: ${index}`],
+      name: "HotWithdrawalPendingError"
+    });
+    this.txHash = txHash;
+    this.index = index;
+  }
+};
+var HotWithdrawalNotFoundError = class extends BaseError2 {
+  constructor(txHash, index) {
+    super("Withdrawal with given index is not found.", {
+      metaMessages: [`TxHash: ${txHash}`, `Index: ${index}`],
+      name: "HotWithdrawalNotFoundError"
+    });
+    this.txHash = txHash;
+    this.index = index;
+  }
+};
+var HotWithdrawalCancelledError = class extends BaseError2 {
+  constructor(txHash, index) {
+    super("Gasless withdrawal was canceled.", {
+      metaMessages: [`TxHash: ${txHash}`, `Index: ${index}`],
+      name: "HotWithdrawalCancelledError"
+    });
+    this.txHash = txHash;
+    this.index = index;
+  }
+};
+
+// src/bridges/hot-bridge/hot-bridge-constants.ts
+var HotWithdrawStatus = {
+  Completed: "COMPLETED",
+  Canceled: "CANCELED"
+};
+
+// src/bridges/hot-bridge/hot-bridge-utils.ts
+import { assert as assert6 } from "@defuse-protocol/internal-utils";
+import { Network } from "@hot-labs/omni-sdk";
+
+// src/bridges/hot-bridge/hot-bridge-chains.ts
+var HotBridgeChains = [
+  Chains.Polygon,
+  Chains.BNB,
+  Chains.TON,
+  Chains.Optimism,
+  Chains.Avalanche,
+  Chains.Stellar
+];
+var HotBridgeEVMChains = HotBridgeChains.filter((a) => a.startsWith("eip155:"));
+
+// src/bridges/hot-bridge/hot-bridge-utils.ts
+var nativeTokenMapping = {
+  [Chains.BNB]: "nep245:v2_1.omni.hot.tg:56_11111111111111111111",
+  [Chains.Polygon]: "nep245:v2_1.omni.hot.tg:137_11111111111111111111",
+  [Chains.TON]: "nep245:v2_1.omni.hot.tg:1117_",
+  [Chains.Optimism]: "nep245:v2_1.omni.hot.tg:10_11111111111111111111",
+  [Chains.Avalanche]: "nep245:v2_1.omni.hot.tg:43114_11111111111111111111",
+  [Chains.Stellar]: "nep245:v2_1.omni.hot.tg:1100_111bzQBB5v7AhLyPMDwS8uJgQV24KaAPXtwyVWu2KXbbfQU6NXRCz"
+};
+var caip2NetworkIdMapping = {
+  [Chains.BNB]: Network.Bnb,
+  [Chains.Polygon]: Network.Polygon,
+  [Chains.TON]: Network.Ton,
+  [Chains.Optimism]: Network.Optimism,
+  [Chains.Avalanche]: Network.Avalanche,
+  [Chains.Stellar]: Network.Stellar
+};
+var networkIdCAIP2Mapping = Object.fromEntries(
+  Object.entries(caip2NetworkIdMapping).map(([k, v]) => [v, k])
+);
+function getFeeAssetIdForChain(caip2) {
+  return nativeTokenMapping[caip2];
+}
+function toHotNetworkId(caip2) {
+  hotBlockchainInvariant(caip2);
+  return caip2NetworkIdMapping[caip2];
+}
+function hotNetworkIdToCAIP2(network) {
+  if (networkIdCAIP2Mapping[network] != null) {
+    return networkIdCAIP2Mapping[network];
+  }
+  throw new Error(`Unsupported HOT Bridge chain = ${network}`);
+}
+function formatTxHash(txHash, caip2) {
+  if (caip2.startsWith("eip155:")) {
+    return `0x${txHash}`;
+  }
+  return txHash;
+}
+function hotBlockchainInvariant(blockchain) {
+  assert6(
+    HotBridgeChains.includes(blockchain),
+    `${blockchain} is not a valid HOT Bridge blockchain. Supported values: ${HotBridgeChains.join()}`
+  );
+}
+
+// src/bridges/hot-bridge/hot-bridge.ts
+var HotBridge = class {
+  constructor({ env, hotSdk }) {
+    this.env = env;
+    this.hotSdk = hotSdk;
+  }
+  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 {
+      return false;
+    }
+  }
+  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 [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 }
+      );
+    }
+    return null;
+  }
+  async createWithdrawalIntents(args) {
+    const assetInfo = this.parseAssetId(args.withdrawalParams.assetId);
+    assert7(assetInfo != null, "Asset is not supported");
+    if (args.withdrawalParams.destinationMemo != null && args.withdrawalParams.destinationMemo !== "") {
+      throw new UnsupportedDestinationMemoError(
+        assetInfo.blockchain,
+        args.withdrawalParams.assetId
+      );
+    }
+    const intents = [];
+    let feeAmount;
+    if (args.feeEstimation.quote == null) {
+      feeAmount = args.feeEstimation.amount;
+    } else {
+      feeAmount = BigInt(args.feeEstimation.quote.amount_out);
+      intents.push({
+        intent: "token_diff",
+        diff: {
+          [args.feeEstimation.quote.defuse_asset_identifier_in]: `-${args.feeEstimation.quote.amount_in}`,
+          [args.feeEstimation.quote.defuse_asset_identifier_out]: args.feeEstimation.quote.amount_out
+        },
+        referral: args.referral
+      });
+    }
+    const isNative = "native" in assetInfo;
+    const amount = args.withdrawalParams.amount + (isNative ? feeAmount : 0n);
+    const intent = await this.hotSdk.buildGaslessWithdrawIntent({
+      feeToken: "native",
+      feeAmount,
+      chain: toHotNetworkId(assetInfo.blockchain),
+      token: isNative ? "native" : assetInfo.address,
+      amount,
+      receiver: args.withdrawalParams.destinationAddress,
+      intentAccount: ""
+      // it is not used inside the function
+    });
+    assert7(intent.amounts[0] === amount.toString(), "Amount is not correct");
+    if (intent.amounts.length === 2) {
+      assert7(
+        intent.amounts[1] === feeAmount.toString(),
+        "Amount is not correct"
+      );
+    }
+    intents.push(intent);
+    return intents;
+  }
+  /**
+   * Hot bridge validates trustlines for Stellar addresses.
+   * For Stellar chains, checks if the destination address has the required trustline.
+   * @throws {TrustlineNotFoundError} If Stellar destination address lacks required trustline
+   */
+  async validateWithdrawal(args) {
+    const assetInfo = this.parseAssetId(args.assetId);
+    assert7(assetInfo != null, "Asset is not supported");
+    hotBlockchainInvariant(assetInfo.blockchain);
+    if (assetInfo.blockchain === Chains.Stellar) {
+      const token = "native" in assetInfo ? "native" : assetInfo.address;
+      const hasTrustline = await this.hotSdk.stellar.isTrustlineExists(
+        args.destinationAddress,
+        token
+      );
+      if (!hasTrustline) {
+        throw new TrustlineNotFoundError(
+          args.destinationAddress,
+          args.assetId,
+          assetInfo.blockchain,
+          token
+        );
+      }
+    }
+  }
+  async estimateWithdrawalFee(args) {
+    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 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
+      }
+    });
+    return {
+      amount: feeQuote ? BigInt(feeQuote.amount_in) : feeAmount,
+      quote: feeQuote
+    };
+  }
+  async waitForWithdrawalCompletion(args) {
+    const nonces = await this.hotSdk.near.parseWithdrawalNonces(
+      args.tx.hash,
+      args.tx.accountId
+    );
+    const nonce = nonces[args.index];
+    if (nonce == null) {
+      throw new HotWithdrawalNotFoundError(args.tx.hash, args.index);
+    }
+    return retry(
+      async () => {
+        if (args.signal?.aborted) {
+          throw args.signal.reason;
+        }
+        const status = await this.hotSdk.getGaslessWithdrawStatus(
+          nonce.toString()
+        );
+        if (status === HotWithdrawStatus.Canceled) {
+          throw new HotWithdrawalCancelledError(args.tx.hash, args.index);
+        }
+        if (status === HotWithdrawStatus.Completed) {
+          return { hash: null };
+        }
+        if (typeof status === "string") {
+          return {
+            hash: "chain" in args.routeConfig ? formatTxHash(status, args.routeConfig.chain) : status
+          };
+        }
+        throw new HotWithdrawalPendingError(args.tx.hash, args.index);
+      },
+      {
+        ...args.retryOptions ?? RETRY_CONFIGS.TWO_MINS_GRADUAL,
+        handleError: (err, ctx) => {
+          if (err instanceof HotWithdrawalCancelledError || err === args.signal?.reason) {
+            ctx.abort();
+          }
+        }
+      }
+    );
+  }
+};
+
+// src/bridges/intents-bridge/intents-bridge.ts
+var IntentsBridge = class {
+  is(routeConfig) {
+    return routeConfig.route === RouteEnum.InternalTransfer;
+  }
+  supports(params) {
+    if ("routeConfig" in params && params.routeConfig != null) {
+      return this.is(params.routeConfig);
+    }
+    return false;
+  }
+  parseAssetId() {
+    return null;
+  }
+  createWithdrawalIntents(args) {
+    const intents = [
+      {
+        intent: "transfer",
+        receiver_id: args.withdrawalParams.destinationAddress,
+        tokens: {
+          [args.withdrawalParams.assetId]: args.withdrawalParams.amount.toString()
+        }
+      }
+    ];
+    return Promise.resolve(intents);
+  }
+  /**
+   * Intents bridge doesn't have withdrawal restrictions.
+   */
+  async validateWithdrawal(_args) {
+    return;
+  }
+  async estimateWithdrawalFee() {
+    return {
+      amount: 0n,
+      quote: null
+    };
+  }
+  async waitForWithdrawalCompletion(args) {
+    return { hash: args.tx.hash };
+  }
+};
+
+// src/bridges/poa-bridge/poa-bridge.ts
+import {
+  assert as assert8,
+  configsByEnvironment as configsByEnvironment4,
+  poaBridge,
+  utils as utils7
+} 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";
+function createWithdrawIntentPrimitive3(params) {
+  const { contractId: tokenAccountId } = utils6.parseDefuseAssetId(
+    params.assetId
+  );
+  return {
+    intent: "ft_withdraw",
+    token: tokenAccountId,
+    receiver_id: tokenAccountId,
+    amount: params.amount.toString(),
+    memo: createWithdrawMemo({
+      receiverAddress: params.destinationAddress,
+      xrpMemo: params.destinationMemo
+    })
+  };
+}
+function createWithdrawMemo({
+  receiverAddress,
+  xrpMemo
+}) {
+  const memo = ["WITHDRAW_TO", receiverAddress];
+  if (xrpMemo != null && xrpMemo !== "") {
+    memo.push(xrpMemo);
+  }
+  return memo.join(":");
+}
+var caip2Mapping = {
+  [Chains.Ethereum]: "eth:1",
+  [Chains.Base]: "eth:8453",
+  [Chains.Arbitrum]: "eth:42161",
+  [Chains.Bitcoin]: "btc:mainnet",
+  [Chains.Solana]: "sol:mainnet",
+  [Chains.Dogecoin]: "doge:mainnet",
+  [Chains.XRPL]: "xrp:mainnet",
+  [Chains.Zcash]: "zec:mainnet",
+  [Chains.Gnosis]: "eth:100",
+  [Chains.Berachain]: "eth:80094",
+  [Chains.Tron]: "tron:mainnet",
+  [Chains.Sui]: "sui:mainnet",
+  [Chains.Aptos]: "aptos:mainnet",
+  [Chains.Cardano]: "cardano:mainnet"
+};
+function toPoaNetwork(caip2) {
+  if (caip2Mapping[caip2] == null) {
+    throw new Error(`Unsupported POA Bridge chain = ${caip2}`);
+  }
+  return caip2Mapping[caip2];
+}
+var tokenPrefixMapping = {
+  eth: Chains.Ethereum,
+  base: Chains.Base,
+  arb: Chains.Arbitrum,
+  btc: Chains.Bitcoin,
+  sol: Chains.Solana,
+  doge: Chains.Dogecoin,
+  xrp: Chains.XRPL,
+  zec: Chains.Zcash,
+  gnosis: Chains.Gnosis,
+  bera: Chains.Berachain,
+  tron: Chains.Tron,
+  sui: Chains.Sui,
+  aptos: Chains.Aptos,
+  cardano: Chains.Cardano
+};
+function contractIdToCaip2(contractId) {
+  for (const [prefix, caip2] of Object.entries(tokenPrefixMapping)) {
+    if (contractId.startsWith(`${prefix}.`) || contractId.startsWith(`${prefix}-`)) {
+      return caip2;
+    }
+  }
+  throw new Error(`Unsupported POA Bridge contractId = ${contractId}`);
+}
+
+// src/bridges/poa-bridge/poa-bridge.ts
+var PoaBridge = class {
+  constructor({ env }) {
+    // TTL cache for supported tokens with 30-second TTL
+    this.supportedTokensCache = new TTLCache({ ttl: 30 * 1e3 });
+    this.env = env;
+  }
+  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 {
+      return false;
+    }
+  }
+  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)
+      });
+    }
+    return null;
+  }
+  createWithdrawalIntents(args) {
+    const intent = createWithdrawIntentPrimitive3({
+      ...args.withdrawalParams,
+      amount: args.withdrawalParams.amount + args.feeEstimation.amount,
+      destinationMemo: args.withdrawalParams.destinationMemo
+    });
+    return Promise.resolve([intent]);
+  }
+  /**
+   * Validates minimum withdrawal amount for POA bridge tokens.
+   * Checks the bridge's supported tokens API to ensure the withdrawal amount
+   * meets the minimum required amount for the specific token and blockchain.
+   * @throws {MinWithdrawalAmountError} If the amount is below the minimum required
+   */
+  async validateWithdrawal(args) {
+    const assetInfo = this.parseAssetId(args.assetId);
+    assert8(assetInfo != null, "Asset is not supported");
+    const { tokens } = await this.getCachedSupportedTokens(
+      [toPoaNetwork(assetInfo.blockchain)],
+      args.logger
+    );
+    const tokenInfo = tokens.find(
+      (token) => token.intents_token_id === args.assetId
+    );
+    if (tokenInfo != null) {
+      const minWithdrawalAmount = BigInt(tokenInfo.min_withdrawal_amount);
+      if (args.amount < minWithdrawalAmount) {
+        throw new MinWithdrawalAmountError(
+          minWithdrawalAmount,
+          args.amount,
+          args.assetId
+        );
+      }
+    }
+  }
+  async estimateWithdrawalFee(args) {
+    const assetInfo = this.parseAssetId(args.withdrawalParams.assetId);
+    assert8(assetInfo != null, "Asset is not supported");
+    const estimation = await poaBridge.httpClient.getWithdrawalEstimate(
+      {
+        token: utils7.getTokenAccountId(args.withdrawalParams.assetId),
+        address: args.withdrawalParams.destinationAddress,
+        // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+        chain: toPoaNetwork(assetInfo.blockchain)
+      },
+      {
+        baseURL: configsByEnvironment4[this.env].poaBridgeBaseURL,
+        logger: args.logger
+      }
+    );
+    return {
+      amount: BigInt(estimation.withdrawalFee),
+      quote: null
+    };
+  }
+  async waitForWithdrawalCompletion(args) {
+    const withdrawalStatus = await poaBridge.waitForWithdrawalCompletion({
+      txHash: args.tx.hash,
+      index: args.index,
+      signal: args.signal ?? new AbortController().signal,
+      retryOptions: args.retryOptions,
+      baseURL: configsByEnvironment4[this.env].poaBridgeBaseURL,
+      logger: args.logger
+    });
+    return { hash: withdrawalStatus.destinationTxHash };
+  }
+  /**
+   * Gets supported tokens with caching to avoid frequent API calls.
+   * Cache expires after 30 seconds using TTL cache.
+   */
+  async getCachedSupportedTokens(chains, logger) {
+    const cacheKey = chains.sort().join(",");
+    const cached = this.supportedTokensCache.get(cacheKey);
+    if (cached != null) {
+      return cached;
+    }
+    const data = await poaBridge.httpClient.getSupportedTokens(
+      { chains },
+      {
+        baseURL: configsByEnvironment4[this.env].poaBridgeBaseURL,
+        logger
+      }
+    );
+    this.supportedTokensCache.set(cacheKey, data);
+    return data;
+  }
+};
+
+// src/constants/public-rpc-urls.ts
+var PUBLIC_EVM_RPC_URLS = {
+  [Chains.BNB]: ["https://bsc-rpc.publicnode.com"],
+  [Chains.Polygon]: ["https://polygon-bor-rpc.publicnode.com"],
+  [Chains.Optimism]: ["https://optimism-rpc.publicnode.com"],
+  [Chains.Avalanche]: ["https://avalanche-c-chain-rpc.publicnode.com"]
+};
+var PUBLIC_STELLAR_RPC_URLS = {
+  soroban: ["https://mainnet.sorobanrpc.com"],
+  horizon: ["https://horizon.stellar.org"]
+};
+
+// src/intents/intent-executer-impl/intent-executer.ts
+import {
+  configsByEnvironment as configsByEnvironment5
+} from "@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);
+var _32n = /* @__PURE__ */ BigInt(32);
+function fromBig(n, le = false) {
+  if (le)
+    return { h: Number(n & U32_MASK64), l: Number(n >> _32n & U32_MASK64) };
+  return { h: Number(n >> _32n & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };
+}
+function split(lst, le = false) {
+  const len = lst.length;
+  let Ah = new Uint32Array(len);
+  let Al = new Uint32Array(len);
+  for (let i = 0; i < len; i++) {
+    const { h, l } = fromBig(lst[i], le);
+    [Ah[i], Al[i]] = [h, l];
+  }
+  return [Ah, Al];
+}
+var rotlSH = (h, l, s) => h << s | l >>> 32 - s;
+var rotlSL = (h, l, s) => l << s | h >>> 32 - s;
+var rotlBH = (h, l, s) => l << s - 32 | h >>> 64 - s;
+var rotlBL = (h, l, s) => h << s - 32 | l >>> 64 - s;
+
+// ../../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/utils.js
+function isBytes(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+}
+function anumber(n) {
+  if (!Number.isSafeInteger(n) || n < 0)
+    throw new Error("positive integer expected, got " + n);
+}
+function abytes(b, ...lengths) {
+  if (!isBytes(b))
+    throw new Error("Uint8Array expected");
+  if (lengths.length > 0 && !lengths.includes(b.length))
+    throw new Error("Uint8Array expected of length " + lengths + ", got length=" + b.length);
+}
+function aexists(instance, checkFinished = true) {
+  if (instance.destroyed)
+    throw new Error("Hash instance has been destroyed");
+  if (checkFinished && instance.finished)
+    throw new Error("Hash#digest() has already been called");
+}
+function aoutput(out, instance) {
+  abytes(out);
+  const min = instance.outputLen;
+  if (out.length < min) {
+    throw new Error("digestInto() expects output buffer of length at least " + min);
+  }
+}
+function u32(arr) {
+  return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
+}
+function clean(...arrays) {
+  for (let i = 0; i < arrays.length; i++) {
+    arrays[i].fill(0);
+  }
+}
+var isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68)();
+function byteSwap(word) {
+  return word << 24 & 4278190080 | word << 8 & 16711680 | word >>> 8 & 65280 | word >>> 24 & 255;
+}
+function byteSwap32(arr) {
+  for (let i = 0; i < arr.length; i++) {
+    arr[i] = byteSwap(arr[i]);
+  }
+  return arr;
+}
+var swap32IfBE = isLE ? (u) => u : byteSwap32;
+function utf8ToBytes(str) {
+  if (typeof str !== "string")
+    throw new Error("string expected");
+  return new Uint8Array(new TextEncoder().encode(str));
+}
+function toBytes(data) {
+  if (typeof data === "string")
+    data = utf8ToBytes(data);
+  abytes(data);
+  return data;
+}
+var Hash = class {
+};
+function createHasher(hashCons) {
+  const hashC = (msg) => hashCons().update(toBytes(msg)).digest();
+  const tmp = hashCons();
+  hashC.outputLen = tmp.outputLen;
+  hashC.blockLen = tmp.blockLen;
+  hashC.create = () => hashCons();
+  return hashC;
+}
+
+// ../../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/sha3.js
+var _0n = BigInt(0);
+var _1n = BigInt(1);
+var _2n = BigInt(2);
+var _7n = BigInt(7);
+var _256n = BigInt(256);
+var _0x71n = BigInt(113);
+var SHA3_PI = [];
+var SHA3_ROTL = [];
+var _SHA3_IOTA = [];
+for (let round = 0, R = _1n, x = 1, y = 0; round < 24; round++) {
+  [x, y] = [y, (2 * x + 3 * y) % 5];
+  SHA3_PI.push(2 * (5 * y + x));
+  SHA3_ROTL.push((round + 1) * (round + 2) / 2 % 64);
+  let t = _0n;
+  for (let j = 0; j < 7; j++) {
+    R = (R << _1n ^ (R >> _7n) * _0x71n) % _256n;
+    if (R & _2n)
+      t ^= _1n << (_1n << /* @__PURE__ */ BigInt(j)) - _1n;
+  }
+  _SHA3_IOTA.push(t);
+}
+var IOTAS = split(_SHA3_IOTA, true);
+var SHA3_IOTA_H = IOTAS[0];
+var SHA3_IOTA_L = IOTAS[1];
+var rotlH = (h, l, s) => s > 32 ? rotlBH(h, l, s) : rotlSH(h, l, s);
+var rotlL = (h, l, s) => s > 32 ? rotlBL(h, l, s) : rotlSL(h, l, s);
+function keccakP(s, rounds = 24) {
+  const B = new Uint32Array(5 * 2);
+  for (let round = 24 - rounds; round < 24; round++) {
+    for (let x = 0; x < 10; x++)
+      B[x] = s[x] ^ s[x + 10] ^ s[x + 20] ^ s[x + 30] ^ s[x + 40];
+    for (let x = 0; x < 10; x += 2) {
+      const idx1 = (x + 8) % 10;
+      const idx0 = (x + 2) % 10;
+      const B0 = B[idx0];
+      const B1 = B[idx0 + 1];
+      const Th = rotlH(B0, B1, 1) ^ B[idx1];
+      const Tl = rotlL(B0, B1, 1) ^ B[idx1 + 1];
+      for (let y = 0; y < 50; y += 10) {
+        s[x + y] ^= Th;
+        s[x + y + 1] ^= Tl;
+      }
+    }
+    let curH = s[2];
+    let curL = s[3];
+    for (let t = 0; t < 24; t++) {
+      const shift = SHA3_ROTL[t];
+      const Th = rotlH(curH, curL, shift);
+      const Tl = rotlL(curH, curL, shift);
+      const PI = SHA3_PI[t];
+      curH = s[PI];
+      curL = s[PI + 1];
+      s[PI] = Th;
+      s[PI + 1] = Tl;
+    }
+    for (let y = 0; y < 50; y += 10) {
+      for (let x = 0; x < 10; x++)
+        B[x] = s[y + x];
+      for (let x = 0; x < 10; x++)
+        s[y + x] ^= ~B[(x + 2) % 10] & B[(x + 4) % 10];
+    }
+    s[0] ^= SHA3_IOTA_H[round];
+    s[1] ^= SHA3_IOTA_L[round];
+  }
+  clean(B);
+}
+var Keccak = class _Keccak extends Hash {
+  // NOTE: we accept arguments in bytes instead of bits here.
+  constructor(blockLen, suffix, outputLen, enableXOF = false, rounds = 24) {
+    super();
+    this.pos = 0;
+    this.posOut = 0;
+    this.finished = false;
+    this.destroyed = false;
+    this.enableXOF = false;
+    this.blockLen = blockLen;
+    this.suffix = suffix;
+    this.outputLen = outputLen;
+    this.enableXOF = enableXOF;
+    this.rounds = rounds;
+    anumber(outputLen);
+    if (!(0 < blockLen && blockLen < 200))
+      throw new Error("only keccak-f1600 function is supported");
+    this.state = new Uint8Array(200);
+    this.state32 = u32(this.state);
+  }
+  clone() {
+    return this._cloneInto();
+  }
+  keccak() {
+    swap32IfBE(this.state32);
+    keccakP(this.state32, this.rounds);
+    swap32IfBE(this.state32);
+    this.posOut = 0;
+    this.pos = 0;
+  }
+  update(data) {
+    aexists(this);
+    data = toBytes(data);
+    abytes(data);
+    const { blockLen, state } = this;
+    const len = data.length;
+    for (let pos = 0; pos < len; ) {
+      const take = Math.min(blockLen - this.pos, len - pos);
+      for (let i = 0; i < take; i++)
+        state[this.pos++] ^= data[pos++];
+      if (this.pos === blockLen)
+        this.keccak();
+    }
+    return this;
+  }
+  finish() {
+    if (this.finished)
+      return;
+    this.finished = true;
+    const { state, suffix, pos, blockLen } = this;
+    state[pos] ^= suffix;
+    if ((suffix & 128) !== 0 && pos === blockLen - 1)
+      this.keccak();
+    state[blockLen - 1] ^= 128;
+    this.keccak();
+  }
+  writeInto(out) {
+    aexists(this, false);
+    abytes(out);
+    this.finish();
+    const bufferOut = this.state;
+    const { blockLen } = this;
+    for (let pos = 0, len = out.length; pos < len; ) {
+      if (this.posOut >= blockLen)
+        this.keccak();
+      const take = Math.min(blockLen - this.posOut, len - pos);
+      out.set(bufferOut.subarray(this.posOut, this.posOut + take), pos);
+      this.posOut += take;
+      pos += take;
+    }
+    return out;
+  }
+  xofInto(out) {
+    if (!this.enableXOF)
+      throw new Error("XOF is not possible for this instance");
+    return this.writeInto(out);
+  }
+  xof(bytes) {
+    anumber(bytes);
+    return this.xofInto(new Uint8Array(bytes));
+  }
+  digestInto(out) {
+    aoutput(out, this);
+    if (this.finished)
+      throw new Error("digest() was already called");
+    this.writeInto(out);
+    this.destroy();
+    return out;
+  }
+  digest() {
+    return this.digestInto(new Uint8Array(this.outputLen));
+  }
+  destroy() {
+    this.destroyed = true;
+    clean(this.state);
+  }
+  _cloneInto(to) {
+    const { blockLen, suffix, outputLen, rounds, enableXOF } = this;
+    to || (to = new _Keccak(blockLen, suffix, outputLen, enableXOF, rounds));
+    to.state32.set(this.state32);
+    to.pos = this.pos;
+    to.posOut = this.posOut;
+    to.finished = this.finished;
+    to.rounds = rounds;
+    to.suffix = suffix;
+    to.outputLen = outputLen;
+    to.enableXOF = enableXOF;
+    to.destroyed = this.destroyed;
+    return to;
+  }
+};
+var gen = (suffix, blockLen, outputLen) => createHasher(() => new Keccak(blockLen, suffix, outputLen));
+var keccak_256 = /* @__PURE__ */ (() => gen(1, 136, 256 / 8))();
+
+// src/intents/intent-hash.ts
+import { base58, base64 } from "@scure/base";
+
+// src/lib/nep413.ts
+import { BorshSchema, borshSerialize } from "borsher";
+var nep413PayloadSchema = BorshSchema.Struct({
+  message: BorshSchema.String,
+  nonce: BorshSchema.Array(BorshSchema.u8, 32),
+  recipient: BorshSchema.String,
+  callback_url: BorshSchema.Option(BorshSchema.String)
+});
+async function hashNEP413Message({
+  message,
+  recipient,
+  nonce,
+  callback_url
+}) {
+  const payload = {
+    message,
+    nonce: Array.from(nonce),
+    recipient,
+    callback_url
+  };
+  const payloadSerialized = borshSerialize(nep413PayloadSchema, payload);
+  const baseInt = 2 ** 31 + 413;
+  const baseIntSerialized = borshSerialize(BorshSchema.u32, baseInt);
+  const combinedData = new Uint8Array(
+    baseIntSerialized.length + payloadSerialized.length
+  );
+  combinedData.set(baseIntSerialized);
+  combinedData.set(payloadSerialized, baseIntSerialized.length);
+  const hashBuffer = await crypto.subtle.digest("SHA-256", combinedData);
+  return new Uint8Array(hashBuffer);
+}
+
+// src/intents/intent-hash.ts
+async function computeIntentHash(multiPayload) {
+  const hashBytes = await computeIntentHashBytes(multiPayload);
+  return base58.encode(hashBytes);
+}
+async function computeIntentHashBytes(multiPayload) {
+  switch (multiPayload.standard) {
+    case "nep413":
+      return computeNep413Hash(
+        multiPayload
+      );
+    case "erc191":
+      return computeErc191Hash(
+        multiPayload
+      );
+    default:
+      throw new Error(
+        `Standard is not yet supported: ${multiPayload.standard}`
+      );
+  }
+}
+async function computeNep413Hash(multiPayload) {
+  const payload = multiPayload.payload;
+  return hashNEP413Message({
+    message: payload.message,
+    recipient: payload.recipient,
+    nonce: Array.from(base64.decode(payload.nonce)),
+    callback_url: payload.callbackUrl
+  });
+}
+function computeErc191Hash(multiPayload) {
+  const message = multiPayload.payload;
+  const prefix = "Ethereum Signed Message:\n";
+  const messageWithPrefix = prefix + message.length.toString() + message;
+  return keccak_256(new TextEncoder().encode(messageWithPrefix));
+}
+
+// src/intents/intent-payload-factory.ts
+import { base64 as base642 } from "@scure/base";
+function defaultIntentPayloadFactory({
+  intents,
+  verifying_contract,
+  ...params
+}) {
+  params = Object.fromEntries(
+    Object.entries(params).filter(([, value]) => value !== void 0)
+  );
+  return {
+    verifying_contract,
+    deadline: new Date(Date.now() + 60 * 1e3).toISOString(),
+    nonce: base642.encode(crypto.getRandomValues(new Uint8Array(32))),
+    intents: intents == null ? [] : intents,
+    signer_id: void 0,
+    // or you can specify intent user id
+    ...params
+  };
+}
+
+// src/intents/intent-executer-impl/intent-executer.ts
+var IntentExecuter = class {
+  constructor(args) {
+    this.env = args.env;
+    this.logger = args.logger;
+    this.intentPayloadFactory = args.intentPayloadFactory;
+    this.intentRelayer = args.intentRelayer;
+    this.intentSigner = args.intentSigner;
+    this.onBeforePublishIntent = args.onBeforePublishIntent;
+  }
+  async signAndSendIntent({
+    relayParams: relayParamsFactory,
+    ...intentParams
+  }) {
+    const verifyingContract = configsByEnvironment5[this.env].contractID;
+    let intentPayload = defaultIntentPayloadFactory({
+      verifying_contract: verifyingContract,
+      ...intentParams
+    });
+    if (this.intentPayloadFactory) {
+      intentPayload = await mergeIntentPayloads(
+        intentPayload,
+        this.intentPayloadFactory
+      );
+    }
+    const multiPayload = await this.intentSigner.signIntent(intentPayload);
+    const relayParams = relayParamsFactory ? await relayParamsFactory() : {};
+    if (this.onBeforePublishIntent) {
+      const intentHash = await computeIntentHash(multiPayload);
+      await this.onBeforePublishIntent({
+        intentHash,
+        intentPayload,
+        multiPayload,
+        relayParams
+      });
+    }
+    const ticket = await this.intentRelayer.publishIntent(
+      {
+        multiPayload,
+        ...relayParams
+      },
+      { logger: this.logger }
+    );
+    return { ticket };
+  }
+  async waitForSettlement(ticket) {
+    return this.intentRelayer.waitForSettlement(ticket, {
+      logger: this.logger
+    });
+  }
+};
+async function mergeIntentPayloads(basePayload, intentPayloadFactory) {
+  const customPayload = await intentPayloadFactory(basePayload);
+  const customPayloadIntents = customPayload.intents ?? [];
+  return {
+    ...basePayload,
+    ...customPayload,
+    intents: Array.from(
+      /* @__PURE__ */ new Set([...customPayloadIntents, ...basePayload.intents])
+    )
+  };
+}
+
+// src/intents/intent-relayer-impl/intent-relayer-public.ts
+import {
+  configsByEnvironment as configsByEnvironment6,
+  solverRelay as solverRelay4
+} from "@defuse-protocol/internal-utils";
+var IntentRelayerPublic = class {
+  constructor({ env }) {
+    this.env = env;
+  }
+  async publishIntent({
+    multiPayload,
+    quoteHashes
+  }, ctx = {}) {
+    return (await this.publishIntents(
+      {
+        multiPayloads: [multiPayload],
+        quoteHashes: quoteHashes ?? []
+      },
+      ctx
+    ))[0];
+  }
+  // как прокидывать доп. параметры, например, quoteHashes (или специфичные параметры для каждого релея?)
+  async publishIntents({
+    multiPayloads,
+    quoteHashes
+  }, ctx = {}) {
+    const a = await solverRelay4.publishIntents(
+      {
+        quote_hashes: quoteHashes,
+        signed_datas: multiPayloads
+      },
+      {
+        baseURL: configsByEnvironment6[this.env].solverRelayBaseURL,
+        logger: ctx.logger
+      }
+    );
+    if (a.isOk()) {
+      return a.unwrap();
+    }
+    throw a.unwrapErr();
+  }
+  async waitForSettlement(ticket, ctx = {}) {
+    const result = await solverRelay4.waitForIntentSettlement({
+      intentHash: ticket,
+      signal: new AbortController().signal,
+      baseURL: configsByEnvironment6[this.env].solverRelayBaseURL,
+      logger: ctx.logger
+    });
+    return {
+      tx: {
+        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
+      }
+    };
+  }
+};
+
+// src/intents/intent-signer-impl/intent-signer-noop.ts
+var noopIntentSigner = {
+  signIntent() {
+    throw new Error("Not implemented");
+  }
+};
+
+// src/lib/array.ts
+import { assert as assert9 } from "@defuse-protocol/internal-utils";
+function zip(arr1, arr2) {
+  assert9(arr1.length === arr2.length, "Arrays must have the same length");
+  return arr1.map((v, i) => [v, arr2[i]]);
+}
+
+// src/lib/configure-rpc-config.ts
+import { assert as assert10 } from "@defuse-protocol/internal-utils";
+
+// src/lib/object.ts
+function pick(obj, keys) {
+  const result = {};
+  for (const key of keys) {
+    if (key in obj) {
+      result[key] = obj[key];
+    }
+  }
+  return result;
+}
+
+// src/lib/configure-rpc-config.ts
+function configureEvmRpcUrls(defaultRpcUrls, userRpcUrls, supportedChains) {
+  const evmRpcUrls = Object.fromEntries(
+    Object.entries(
+      pick(
+        Object.assign({}, defaultRpcUrls, userRpcUrls ?? {}),
+        supportedChains
+      )
+    ).map(([caip2, urls]) => [getEIP155ChainId(caip2), urls])
+  );
+  for (const [chainId, urls] of Object.entries(evmRpcUrls)) {
+    assert10(
+      urls.length > 0,
+      `EVM RPC URLs for chain ${chainId} are not provided`
+    );
+  }
+  return evmRpcUrls;
+}
+function configureStellarRpcUrls(defaultRpcUrls, userRpcUrls) {
+  const stellarRpcUrls = Object.assign(
+    {},
+    defaultRpcUrls,
+    userRpcUrls?.[Chains.Stellar] ?? {}
+  );
+  for (const [key, value] of Object.entries(stellarRpcUrls)) {
+    assert10(value.length > 0, `Stellar RPC URL for ${key} is not provided`);
+  }
+  return stellarRpcUrls;
+}
+
+// src/lib/route-config-factory.ts
+function createInternalTransferRoute() {
+  return { route: RouteEnum.InternalTransfer };
+}
+function createNearWithdrawalRoute(msg) {
+  return { route: RouteEnum.NearWithdrawal, msg };
+}
+function createVirtualChainRoute(auroraEngineContractId, proxyTokenContractId) {
+  return {
+    route: RouteEnum.VirtualChain,
+    auroraEngineContractId,
+    proxyTokenContractId
+  };
+}
+function createPoaBridgeRoute(chain) {
+  return {
+    route: RouteEnum.PoaBridge,
+    chain
+  };
+}
+function createHotBridgeRoute(chain) {
+  return {
+    route: RouteEnum.HotBridge,
+    chain
+  };
+}
+function createDefaultRoute() {
+}
+
+// src/lib/route-config.ts
+function determineRouteConfig(sdk, withdrawalParams) {
+  if (withdrawalParams.routeConfig != null) {
+    return withdrawalParams.routeConfig;
+  }
+  const parseAssetId = sdk.parseAssetId(withdrawalParams.assetId);
+  const bridgeName = parseAssetId.bridgeName;
+  switch (bridgeName) {
+    case BridgeNameEnum.Hot:
+      return {
+        route: RouteEnum.HotBridge,
+        chain: parseAssetId.blockchain
+      };
+    case BridgeNameEnum.Poa:
+      return {
+        route: RouteEnum.PoaBridge,
+        chain: parseAssetId.blockchain
+      };
+    case BridgeNameEnum.None:
+      return createNearWithdrawalRoute();
+    default:
+      bridgeName;
+      throw new Error(`Unexpected bridge = ${bridgeName}`);
+  }
+}
+
+// src/sdk.ts
+var IntentsSDK = class {
+  constructor(args) {
+    this.env = args.env ?? "production";
+    this.referral = args.referral;
+    const nearRpcUrls = args.rpc?.[Chains.Near] ?? PUBLIC_NEAR_RPC_URLS;
+    assert11(nearRpcUrls.length > 0, "NEAR RPC URLs are not provided");
+    const nearProvider = nearFailoverRpcProvider({ urls: nearRpcUrls });
+    const stellarRpcUrls = configureStellarRpcUrls(
+      PUBLIC_STELLAR_RPC_URLS,
+      args.rpc
+    );
+    const evmRpcUrls = configureEvmRpcUrls(
+      PUBLIC_EVM_RPC_URLS,
+      args.rpc,
+      HotBridgeEVMChains
+    );
+    this.bridges = [
+      new IntentsBridge(),
+      new AuroraEngineBridge({
+        env: this.env,
+        nearProvider
+      }),
+      new PoaBridge({ env: this.env }),
+      new HotBridge({
+        env: this.env,
+        hotSdk: new hotOmniSdk.HotBridge({
+          logger: console,
+          evmRpc: evmRpcUrls,
+          // 1. HotBridge from omni-sdk does not support FailoverProvider.
+          // 2. omni-sdk has near-api-js@5.0.1, and it uses `instanceof` which doesn't work when multiple versions of packages are installed
+          nearRpc: nearRpcUrls,
+          stellarRpc: stellarRpcUrls.soroban,
+          stellarHorizonRpc: stellarRpcUrls.horizon,
+          async executeNearTransaction() {
+            throw new Error("not implemented");
+          }
+        })
+      }),
+      new DirectBridge({
+        env: this.env,
+        nearProvider
+      })
+    ];
+    this.intentRelayer = new IntentRelayerPublic({ env: this.env });
+    this.intentSigner = args.intentSigner;
+  }
+  setIntentSigner(signer) {
+    this.intentSigner = signer;
+  }
+  async createWithdrawalIntents(args) {
+    for (const bridge of this.bridges) {
+      if (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,
+          amount: actualAmount,
+          destinationAddress: args.withdrawalParams.destinationAddress,
+          logger: args.logger
+        });
+        return bridge.createWithdrawalIntents({
+          withdrawalParams: {
+            ...args.withdrawalParams,
+            amount: actualAmount
+          },
+          feeEstimation: args.feeEstimation,
+          referral: args.referral ?? this.referral
+        });
+      }
+    }
+    throw new Error(
+      `Cannot determine bridge for withdrawal = ${stringify(args.withdrawalParams)}`
+    );
+  }
+  estimateWithdrawalFee(args) {
+    if (!Array.isArray(args.withdrawalParams)) {
+      return this._estimateWithdrawalFee({
+        ...args,
+        withdrawalParams: args.withdrawalParams
+      });
+    }
+    return Promise.all(
+      args.withdrawalParams.map(
+        (withdrawalParams) => this._estimateWithdrawalFee({
+          ...args,
+          withdrawalParams
+        })
+      )
+    );
+  }
+  async _estimateWithdrawalFee(args) {
+    for (const bridge of this.bridges) {
+      if (bridge.supports(args.withdrawalParams)) {
+        const fee = await bridge.estimateWithdrawalFee({
+          withdrawalParams: args.withdrawalParams,
+          quoteOptions: args.quoteOptions,
+          logger: args.logger
+        });
+        if (args.withdrawalParams.feeInclusive) {
+          if (args.withdrawalParams.amount <= fee.amount) {
+            throw new FeeExceedsAmountError(fee, args.withdrawalParams.amount);
+          }
+        }
+        return fee;
+      }
+    }
+    throw new Error(
+      `Cannot determine bridge for withdrawal = ${stringify(args.withdrawalParams)}`
+    );
+  }
+  getWithdrawalsIdentifiers({
+    withdrawalParams,
+    intentTx
+  }) {
+    const indexes = new Map(
+      zip(
+        withdrawalParams.map((w) => {
+          const routeConfig = determineRouteConfig(this, w);
+          return routeConfig.route;
+        }),
+        Array(withdrawalParams.length).fill(0)
+      )
+    );
+    return withdrawalParams.map((w) => {
+      const routeConfig = determineRouteConfig(this, w);
+      const route = routeConfig.route;
+      const index = indexes.get(route);
+      assert11(index != null, "Index is not found for route");
+      indexes.set(route, index + 1);
+      return {
+        routeConfig,
+        index,
+        tx: intentTx
+      };
+    });
+  }
+  async waitForWithdrawalCompletion(args) {
+    const wids = this.getWithdrawalsIdentifiers({
+      withdrawalParams: Array.isArray(args.withdrawalParams) ? args.withdrawalParams : [args.withdrawalParams],
+      intentTx: args.intentTx
+    });
+    const result = await Promise.all(
+      wids.map((wid) => {
+        for (const bridge of this.bridges) {
+          if (bridge.is(wid.routeConfig)) {
+            return bridge.waitForWithdrawalCompletion({
+              tx: args.intentTx,
+              index: wid.index,
+              routeConfig: wid.routeConfig,
+              signal: args.signal,
+              retryOptions: args.retryOptions,
+              logger: args.logger
+            });
+          }
+        }
+        throw new Error(`Unsupported route = ${stringify(wid.routeConfig)}`);
+      })
+    );
+    if (Array.isArray(args.withdrawalParams)) {
+      return result;
+    }
+    assert11(result.length === 1, "Unexpected result length");
+    return result[0];
+  }
+  parseAssetId(assetId) {
+    for (const bridge of this.bridges) {
+      const parsed = bridge.parseAssetId(assetId);
+      if (parsed != null) {
+        return parsed;
+      }
+    }
+    throw new Error(`Cannot determine bridge for assetId = ${assetId}`);
+  }
+  async signAndSendIntent(args) {
+    const intentSigner = args.signer ?? this.intentSigner;
+    assert11(intentSigner != null, "Intent signer is not provided");
+    const intentExecuter = new IntentExecuter({
+      env: this.env,
+      logger: args.logger,
+      intentSigner,
+      intentRelayer: this.intentRelayer,
+      intentPayloadFactory: args.payload,
+      onBeforePublishIntent: args.onBeforePublishIntent
+    });
+    const { ticket } = await intentExecuter.signAndSendIntent({
+      intents: args.intents,
+      relayParams: args.relayParams
+    });
+    return { intentHash: ticket };
+  }
+  async signAndSendWithdrawalIntent(args) {
+    let withdrawalParamsArray;
+    let feeEstimations;
+    if (isBatchMode(args)) {
+      withdrawalParamsArray = args.withdrawalParams;
+      feeEstimations = args.feeEstimation;
+    } else {
+      withdrawalParamsArray = [args.withdrawalParams];
+      feeEstimations = [args.feeEstimation];
+    }
+    const intentsP = zip(withdrawalParamsArray, feeEstimations).map(
+      ([withdrawalParams, feeEstimation]) => {
+        return this.createWithdrawalIntents({
+          withdrawalParams,
+          feeEstimation,
+          referral: args.referral ?? this.referral,
+          logger: args.logger
+        });
+      }
+    );
+    const intents = (await Promise.all(intentsP)).flat();
+    const relayParamsFn = async () => {
+      const relayParams = args.intent?.relayParams != null ? await args.intent?.relayParams() : { quoteHashes: void 0 };
+      const quoteHashes = relayParams.quoteHashes ?? [];
+      for (const fee of feeEstimations) {
+        if (fee.quote != null) {
+          quoteHashes.push(fee.quote.quote_hash);
+        }
+      }
+      return { ...relayParams, quoteHashes };
+    };
+    return this.signAndSendIntent({
+      intents,
+      signer: args.intent?.signer,
+      onBeforePublishIntent: args.intent?.onBeforePublishIntent,
+      relayParams: relayParamsFn,
+      payload: args.intent?.payload,
+      logger: args.logger
+    });
+  }
+  async waitForIntentSettlement(args) {
+    const intentExecuter = new IntentExecuter({
+      env: this.env,
+      logger: args.logger,
+      intentSigner: noopIntentSigner,
+      intentRelayer: this.intentRelayer
+    });
+    const { tx } = await intentExecuter.waitForSettlement(args.intentHash);
+    return tx;
+  }
+  async getIntentStatus({
+    intentHash,
+    logger
+  }) {
+    return solverRelay5.getStatus(
+      {
+        intent_hash: intentHash
+      },
+      {
+        baseURL: configsByEnvironment7[this.env].solverRelayBaseURL,
+        logger
+      }
+    );
+  }
+  async processWithdrawal(args) {
+    const withdrawalParams = Array.isArray(args.withdrawalParams) ? args.withdrawalParams : [args.withdrawalParams];
+    const feeEstimation = await (() => {
+      if (args.feeEstimation != null) {
+        return Array.isArray(args.feeEstimation) ? args.feeEstimation : [args.feeEstimation];
+      }
+      return this.estimateWithdrawalFee({
+        withdrawalParams,
+        logger: args.logger
+      });
+    })();
+    const { intentHash } = await this.signAndSendWithdrawalIntent({
+      withdrawalParams,
+      feeEstimation,
+      referral: args.referral,
+      intent: args.intent,
+      logger: args.logger
+    });
+    const intentTx = await this.waitForIntentSettlement({
+      intentHash,
+      logger: args.logger
+    });
+    const destinationTx = await this.waitForWithdrawalCompletion({
+      withdrawalParams,
+      intentTx,
+      logger: args.logger,
+      retryOptions: RETRY_CONFIGS2.FIVE_MINS_STEADY
+    });
+    if (!Array.isArray(args.withdrawalParams)) {
+      return {
+        // biome-ignore lint/style/noNonNullAssertion: <explanation>
+        feeEstimation: feeEstimation[0],
+        intentHash,
+        intentTx,
+        // biome-ignore lint/style/noNonNullAssertion: <explanation>
+        destinationTx: destinationTx[0]
+      };
+    }
+    return {
+      feeEstimation,
+      intentHash,
+      intentTx,
+      destinationTx
+    };
+  }
+};
+function isBatchMode(args) {
+  return Array.isArray(args.withdrawalParams);
+}
+
+// src/intents/intent-signer-impl/intent-signer-near-keypair.ts
+import { base64 as base644 } from "@scure/base";
+
+// src/intents/intent-signer-impl/intent-signer-nep413.ts
+import { base58 as base582, base64 as base643 } from "@scure/base";
+var IntentSignerNEP413 = class {
+  constructor({ signMessage, accountId }) {
+    this.signMessage = signMessage;
+    this.accountId = accountId;
+  }
+  async signIntent(intent) {
+    const nep413Payload = {
+      recipient: intent.verifying_contract,
+      nonce: Array.from(base643.decode(intent.nonce)),
+      message: JSON.stringify({
+        deadline: intent.deadline,
+        intents: intent.intents,
+        signer_id: intent.signer_id ?? this.accountId
+      })
+    };
+    const nep413Hash = await hashNEP413Message(nep413Payload);
+    const { publicKey, signature } = await this.signMessage(
+      nep413Payload,
+      nep413Hash
+    );
+    const signatureFormatted = signature.startsWith("ed25519:") ? signature : `ed25519:${base582.encode(base643.decode(signature))}`;
+    return {
+      standard: "nep413",
+      payload: {
+        ...nep413Payload,
+        nonce: intent.nonce
+      },
+      public_key: publicKey,
+      signature: signatureFormatted
+    };
+  }
+};
+
+// src/intents/intent-signer-impl/intent-signer-near-keypair.ts
+var IntentSignerNearKeypair = class extends IntentSignerNEP413 {
+  constructor({ keypair, accountId }) {
+    super({
+      signMessage: (_nep413Payload, nep413Hash) => {
+        const { publicKey, signature } = keypair.sign(nep413Hash);
+        return {
+          publicKey: publicKey.toString(),
+          signature: base644.encode(signature)
+        };
+      },
+      accountId
+    });
+  }
+};
+
+// src/intents/intent-signer-impl/intent-signer-viem.ts
+import { utils as utils8 } 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({
+        identifier: this.account.address,
+        method: "evm"
+      }),
+      verifying_contract: intent.verifying_contract,
+      deadline: intent.deadline,
+      nonce: intent.nonce,
+      intents: intent.intents
+    });
+    const signature = await this.account.signMessage?.({
+      message: payload
+    });
+    if (signature == null) {
+      throw new Error("No signature is returned");
+    }
+    return {
+      standard: "erc191",
+      payload,
+      signature: utils8.transformERC191Signature(signature)
+    };
+  }
+};
+
+// src/intents/intent-signer-impl/factories.ts
+function createIntentSignerNEP413(config) {
+  return new IntentSignerNEP413(config);
+}
+function createIntentSignerNearKeyPair(config) {
+  return new IntentSignerNearKeypair(config);
+}
+function createIntentSignerViem(config) {
+  return new IntentSignerViem(config);
+}
+
+// index.ts
+import {
+  BaseError as BaseError3
+} from "@defuse-protocol/internal-utils";
+import {
+  PoaWithdrawalInvariantError,
+  PoaWithdrawalNotFoundError,
+  PoaWithdrawalPendingError
+} from "@defuse-protocol/internal-utils";
+import {
+  HttpRequestError,
+  RpcRequestError,
+  TimeoutError
+} from "@defuse-protocol/internal-utils";
+import {
+  AssertionError
+} from "@defuse-protocol/internal-utils";
+import {
+  QuoteError,
+  IntentSettlementError,
+  RelayPublishError
+} from "@defuse-protocol/internal-utils";
+export {
+  AssertionError,
+  BaseError3 as BaseError,
+  BridgeNameEnum,
+  Chains,
+  FeeExceedsAmountError,
+  HotWithdrawalCancelledError,
+  HotWithdrawalNotFoundError,
+  HotWithdrawalPendingError,
+  HttpRequestError,
+  IntentSettlementError,
+  IntentsSDK,
+  MinWithdrawalAmountError,
+  PoaWithdrawalInvariantError,
+  PoaWithdrawalNotFoundError,
+  PoaWithdrawalPendingError,
+  QuoteError,
+  RelayPublishError,
+  RouteEnum,
+  RpcRequestError,
+  TimeoutError,
+  TrustlineNotFoundError,
+  UnsupportedDestinationMemoError,
+  createDefaultRoute,
+  createHotBridgeRoute,
+  createIntentSignerNEP413,
+  createIntentSignerNearKeyPair,
+  createIntentSignerViem,
+  createInternalTransferRoute,
+  createNearWithdrawalRoute,
+  createPoaBridgeRoute,
+  createVirtualChainRoute
+};
+/*! Bundled license information:
+
+@noble/hashes/esm/utils.js:
+  (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+*/