lampamazaza-new-intents-sdk 0.47.1

package/dist/src/bridges/hot-bridge/hot-bridge-utils.js

@@ -0,0 +1,61 @@
+import { Chains } from "../../lib/caip2.js";
+import { HotBridgeChains } from "./hot-bridge-chains.js";
+import { assert } from "lampamazaza-internal-utils";
+import { Network } from "@hot-labs/omni-sdk";
+
+//#region src/bridges/hot-bridge/hot-bridge-utils.ts
+const MONAD_MAINNET_NETWORK_ID = 143;
+const ADI_NETWORK_ID = 36900;
+const PLASMA_NETWORK_ID = 9745;
+const nativeTokenMapping = {
+	[Chains.BNB]: "nep245:v2_1.omni.hot.tg:56_11111111111111111111",
+	[Chains.Polygon]: "nep245:v2_1.omni.hot.tg:137_11111111111111111111",
+	[Chains.Monad]: "nep245:v2_1.omni.hot.tg:143_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",
+	[Chains.LayerX]: "nep245:v2_1.omni.hot.tg:196_11111111111111111111",
+	[Chains.Adi]: "nep245:v2_1.omni.hot.tg:36900_11111111111111111111",
+	[Chains.Scroll]: "nep245:v2_1.omni.hot.tg:534352_11111111111111111111",
+	[Chains.Plasma]: "nep245:v2_1.omni.hot.tg:9745_11111111111111111111"
+};
+const caip2NetworkIdMapping = {
+	[Chains.BNB]: Network.Bnb,
+	[Chains.Polygon]: Network.Polygon,
+	[Chains.Monad]: MONAD_MAINNET_NETWORK_ID,
+	[Chains.TON]: Network.Ton,
+	[Chains.Optimism]: Network.Optimism,
+	[Chains.Avalanche]: Network.Avalanche,
+	[Chains.Stellar]: Network.Stellar,
+	[Chains.LayerX]: Network.Xlayer,
+	[Chains.Adi]: ADI_NETWORK_ID,
+	[Chains.Scroll]: Network.Scroll,
+	[Chains.Plasma]: PLASMA_NETWORK_ID
+};
+const 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) {
+	const mappedChain = networkIdCAIP2Mapping[network];
+	if (mappedChain != null) return mappedChain;
+	throw new Error(`Unsupported HOT Bridge chain = ${network}`);
+}
+/**
+* HOT returns hexified raw bytes. So we need to return more friendly/common string.
+*/
+function formatTxHash(txHash, caip2) {
+	if (caip2.startsWith("eip155:")) return `0x${txHash}`;
+	return txHash;
+}
+function hotBlockchainInvariant(blockchain) {
+	assert(HotBridgeChains.includes(blockchain), `${blockchain} is not a valid HOT Bridge blockchain. Supported values: ${HotBridgeChains.join()}`);
+}
+
+//#endregion
+export { formatTxHash, getFeeAssetIdForChain, hotBlockchainInvariant, hotNetworkIdToCAIP2, toHotNetworkId };

package/dist/src/bridges/hot-bridge/hot-bridge.cjs

@@ -0,0 +1,241 @@
+const require_rolldown_runtime = require('../../../_virtual/rolldown_runtime.cjs');
+const require_errors = require('../../classes/errors.cjs');
+const require_route_enum = require('../../constants/route-enum.cjs');
+const require_caip2 = require('../../lib/caip2.cjs');
+const require_estimate_fee = require('../../lib/estimate-fee.cjs');
+const require_parse_defuse_asset_id = require('../../lib/parse-defuse-asset-id.cjs');
+const require_validateAddress = require('../../lib/validateAddress.cjs');
+const require_bridge_name_enum = require('../../constants/bridge-name-enum.cjs');
+const require_error = require('./error.cjs');
+const require_hot_bridge_constants = require('./hot-bridge-constants.cjs');
+const require_hot_bridge_utils = require('./hot-bridge-utils.cjs');
+const require_hex = require('../../lib/hex.cjs');
+let lampamazaza_internal_utils = require("lampamazaza-internal-utils");
+let _hot_labs_omni_sdk = require("@hot-labs/omni-sdk");
+let lru_cache = require("lru-cache");
+let valibot = require("valibot");
+valibot = require_rolldown_runtime.__toESM(valibot);
+
+//#region src/bridges/hot-bridge/hot-bridge.ts
+const HotApiWithdrawalSchema = valibot.object({
+	hash: valibot.nullable(valibot.string()),
+	nonce: valibot.string(),
+	near_trx: valibot.string(),
+	verified_withdraw: valibot.boolean(),
+	chain_id: valibot.number()
+});
+const HotApiWithdrawalResponseSchema = valibot.object({
+	hash: valibot.nullable(valibot.string()),
+	nonce: valibot.string(),
+	near_trx: valibot.string(),
+	withdrawals: valibot.array(HotApiWithdrawalSchema)
+});
+var HotBridge = class HotBridge {
+	static {
+		this.API_FALLBACK_TIMEOUT_MS = 5e3;
+	}
+	static {
+		this.NEAR_RPC_TIMEOUT_MS = 1e4;
+	}
+	constructor({ envConfig, hotSdk, solverRelayApiKey }) {
+		this.route = require_route_enum.RouteEnum.HotBridge;
+		this.envConfig = envConfig;
+		this.hotSdk = hotSdk;
+		this.solverRelayApiKey = solverRelayApiKey;
+		this.noncesCache = new lru_cache.LRUCache({
+			max: 50,
+			ttl: 3600 * 1e3,
+			fetchMethod: async (_key, _staleValue, { context: tx }) => {
+				return (0, lampamazaza_internal_utils.withTimeout)(() => this.hotSdk.near.parseWithdrawalNonces(tx.hash, tx.accountId), { timeout: HotBridge.NEAR_RPC_TIMEOUT_MS });
+			}
+		});
+	}
+	getNoncesCacheKey(tx) {
+		return `${tx.hash}:${tx.accountId}`;
+	}
+	is(routeConfig) {
+		return routeConfig.route === require_route_enum.RouteEnum.HotBridge;
+	}
+	async supports(params) {
+		if (params.routeConfig != null && !this.is(params.routeConfig)) return false;
+		const isValid = this.parseAssetId(params.assetId) != null;
+		if (!isValid && params.routeConfig != null) throw new require_errors.UnsupportedAssetIdError(params.assetId, "`assetId` does not match `routeConfig`.");
+		return isValid;
+	}
+	parseAssetId(assetId) {
+		const parsed = require_parse_defuse_asset_id.parseDefuseAssetId(assetId);
+		if (!(parsed.contractId === _hot_labs_omni_sdk.OMNI_HOT_V2)) return null;
+		if (parsed.standard !== "nep245") throw new require_errors.UnsupportedAssetIdError(assetId, "Should start with \"nep245:\".");
+		const [chainId, address] = _hot_labs_omni_sdk.utils.fromOmni(parsed.tokenId).split(":");
+		if (chainId == null || address == null) throw new require_errors.UnsupportedAssetIdError(assetId, "Asset has invalid token id format.");
+		let blockchain;
+		try {
+			blockchain = require_hot_bridge_utils.hotNetworkIdToCAIP2(chainId);
+		} catch {
+			throw new require_errors.UnsupportedAssetIdError(assetId, "Asset belongs to unknown blockchain.");
+		}
+		return Object.assign(parsed, {
+			blockchain,
+			bridgeName: require_bridge_name_enum.BridgeNameEnum.Hot
+		}, address === "native" ? { native: true } : { address });
+	}
+	async createWithdrawalIntents(args) {
+		const assetInfo = this.parseAssetId(args.withdrawalParams.assetId);
+		(0, lampamazaza_internal_utils.assert)(assetInfo != null, "Asset is not supported");
+		if (args.withdrawalParams.destinationMemo != null && args.withdrawalParams.destinationMemo !== "") throw new require_errors.UnsupportedDestinationMemoError(assetInfo.blockchain, args.withdrawalParams.assetId);
+		const intents = [];
+		const feeAmount = require_estimate_fee.getUnderlyingFee(args.feeEstimation, require_route_enum.RouteEnum.HotBridge, "relayerFee");
+		const blockNumber = require_estimate_fee.getUnderlyingFee(args.feeEstimation, require_route_enum.RouteEnum.HotBridge, "blockNumber");
+		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 isNative = "native" in assetInfo;
+		const amount = args.withdrawalParams.amount + (isNative ? feeAmount : 0n);
+		const intent = await this.hotSdk.buildGaslessWithdrawIntent({
+			feeToken: "native",
+			feeAmount,
+			blockNumber,
+			chain: require_hot_bridge_utils.toHotNetworkId(assetInfo.blockchain),
+			token: isNative ? "native" : assetInfo.address,
+			amount,
+			receiver: args.withdrawalParams.destinationAddress
+		});
+		(0, lampamazaza_internal_utils.assert)(intent.amounts[0] === amount.toString(), "Amount is not correct");
+		if (intent.amounts.length === 2) (0, lampamazaza_internal_utils.assert)(intent.amounts[1] === feeAmount.toString(), "Amount is not correct");
+		const mtWithdrawIntent = intent;
+		mtWithdrawIntent.min_gas = require_hot_bridge_constants.MIN_GAS_AMOUNT;
+		intents.push(mtWithdrawIntent);
+		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);
+		(0, lampamazaza_internal_utils.assert)(assetInfo != null, "Asset is not supported");
+		require_hot_bridge_utils.hotBlockchainInvariant(assetInfo.blockchain);
+		if (require_validateAddress.validateAddress(args.destinationAddress, assetInfo.blockchain) === false) throw new require_errors.InvalidDestinationAddressForWithdrawalError(args.destinationAddress, assetInfo.blockchain);
+		if (assetInfo.blockchain === require_caip2.Chains.Stellar) {
+			const token = "native" in assetInfo ? "native" : assetInfo.address;
+			if (!await this.hotSdk.stellar.isTrustlineExists(args.destinationAddress, token)) throw new require_errors.TrustlineNotFoundError(args.destinationAddress, args.assetId, assetInfo.blockchain, token);
+		}
+	}
+	async estimateWithdrawalFee(args) {
+		const assetInfo = this.parseAssetId(args.withdrawalParams.assetId);
+		(0, lampamazaza_internal_utils.assert)(assetInfo != null, "Asset is not supported");
+		require_hot_bridge_utils.hotBlockchainInvariant(assetInfo.blockchain);
+		const feeAssetId = require_hot_bridge_utils.getFeeAssetIdForChain(assetInfo.blockchain);
+		const { gasPrice: feeAmount, blockNumber } = await (0, lampamazaza_internal_utils.withTimeout)(async () => {
+			const result = await this.hotSdk.getGaslessWithdrawFee({
+				chain: require_hot_bridge_utils.toHotNetworkId(assetInfo.blockchain),
+				token: "native" in assetInfo ? "native" : assetInfo.address,
+				receiver: args.withdrawalParams.destinationAddress
+			});
+			if (assetInfo.blockchain === require_caip2.Chains.Plasma && args.withdrawalParams.assetId !== feeAssetId) result.gasPrice *= 20n;
+			return result;
+		}, {
+			errorInstance: new require_error.HotWithdrawalApiFeeRequestTimeoutError(),
+			timeout: typeof window !== "undefined" ? 1e4 : 3e3
+		});
+		const feeQuote = args.withdrawalParams.assetId === feeAssetId || feeAmount === 0n ? null : await require_estimate_fee.getFeeQuote({
+			feeAmount,
+			feeAssetId,
+			tokenAssetId: args.withdrawalParams.assetId,
+			logger: args.logger,
+			envConfig: this.envConfig,
+			quoteOptions: args.quoteOptions,
+			solverRelayApiKey: this.solverRelayApiKey
+		});
+		return {
+			amount: feeQuote ? BigInt(feeQuote.amount_in) : feeAmount,
+			quote: feeQuote,
+			underlyingFees: { [require_route_enum.RouteEnum.HotBridge]: {
+				relayerFee: feeAmount,
+				blockNumber
+			} }
+		};
+	}
+	createWithdrawalIdentifier(args) {
+		const assetInfo = this.parseAssetId(args.withdrawalParams.assetId);
+		(0, lampamazaza_internal_utils.assert)(assetInfo != null, "Asset is not supported");
+		return {
+			landingChain: assetInfo.blockchain,
+			index: args.index,
+			withdrawalParams: args.withdrawalParams,
+			tx: args.tx
+		};
+	}
+	async describeWithdrawal(args) {
+		const cacheKey = this.getNoncesCacheKey(args.tx);
+		const nonces = await this.noncesCache.fetch(cacheKey, { context: args.tx });
+		if (nonces == null) throw new require_error.HotWithdrawalNotFoundError(args.tx.hash, args.index);
+		const nonce = nonces[args.index];
+		if (nonce == null) throw new require_error.HotWithdrawalNotFoundError(args.tx.hash, args.index);
+		const status = await this.hotSdk.getGaslessWithdrawStatus(nonce.toString());
+		if (status === require_hot_bridge_constants.HotWithdrawStatus.Canceled) return {
+			status: "failed",
+			reason: "Withdrawal was cancelled"
+		};
+		if (status === require_hot_bridge_constants.HotWithdrawStatus.Completed) return {
+			status: "completed",
+			txHash: null
+		};
+		if (typeof status === "string") {
+			if (!require_hex.default(status)) {
+				args.logger?.warn("HOT Bridge incorrect destination tx hash detected", { value: status });
+				return {
+					status: "completed",
+					txHash: null
+				};
+			}
+			return {
+				status: "completed",
+				txHash: require_hot_bridge_utils.formatTxHash(status, args.landingChain)
+			};
+		}
+		const apiHash = await this.fetchWithdrawalHashFromApi(args.tx.hash, nonce, args.logger);
+		if (apiHash != null) return {
+			status: "completed",
+			txHash: require_hot_bridge_utils.formatTxHash(apiHash, args.landingChain)
+		};
+		return { status: "pending" };
+	}
+	async fetchWithdrawalHashFromApi(nearTxHash, nonce, logger) {
+		try {
+			const data = await (await (0, lampamazaza_internal_utils.withTimeout)(() => this.hotSdk.api.requestApi(`/api/v1/evm/bridge_withdrawal_hash?near_trx=${nearTxHash}`, { method: "GET" }), { timeout: HotBridge.API_FALLBACK_TIMEOUT_MS })).json();
+			const parseResult = valibot.safeParse(HotApiWithdrawalResponseSchema, data);
+			if (!parseResult.success) {
+				logger?.debug("HOT API response parse failed", { issues: parseResult.issues });
+				return null;
+			}
+			const withdrawal = parseResult.output.withdrawals.find((w) => w.nonce === nonce.toString());
+			if (withdrawal?.hash) {
+				const hash = withdrawal.hash.replace(/^0x/, "");
+				if (require_hex.default(hash)) {
+					logger?.info("HOT withdrawal hash found via API fallback", {
+						nearTxHash,
+						nonce: nonce.toString()
+					});
+					return hash;
+				}
+			}
+			return null;
+		} catch (error) {
+			logger?.debug("HOT API fallback failed", {
+				error,
+				nearTxHash
+			});
+			return null;
+		}
+	}
+};
+
+//#endregion
+exports.HotBridge = HotBridge;

package/dist/src/bridges/hot-bridge/hot-bridge.js

@@ -0,0 +1,239 @@
+import { InvalidDestinationAddressForWithdrawalError, TrustlineNotFoundError, UnsupportedAssetIdError, UnsupportedDestinationMemoError } from "../../classes/errors.js";
+import { RouteEnum } from "../../constants/route-enum.js";
+import { Chains } from "../../lib/caip2.js";
+import { getFeeQuote, getUnderlyingFee } from "../../lib/estimate-fee.js";
+import { parseDefuseAssetId } from "../../lib/parse-defuse-asset-id.js";
+import { validateAddress } from "../../lib/validateAddress.js";
+import { BridgeNameEnum } from "../../constants/bridge-name-enum.js";
+import { HotWithdrawalApiFeeRequestTimeoutError, HotWithdrawalNotFoundError } from "./error.js";
+import { HotWithdrawStatus, MIN_GAS_AMOUNT } from "./hot-bridge-constants.js";
+import { formatTxHash, getFeeAssetIdForChain, hotBlockchainInvariant, hotNetworkIdToCAIP2, toHotNetworkId } from "./hot-bridge-utils.js";
+import isHex from "../../lib/hex.js";
+import { assert, withTimeout } from "lampamazaza-internal-utils";
+import { OMNI_HOT_V2, utils as utils$1 } from "@hot-labs/omni-sdk";
+import { LRUCache } from "lru-cache";
+import * as v from "valibot";
+
+//#region src/bridges/hot-bridge/hot-bridge.ts
+const HotApiWithdrawalSchema = v.object({
+	hash: v.nullable(v.string()),
+	nonce: v.string(),
+	near_trx: v.string(),
+	verified_withdraw: v.boolean(),
+	chain_id: v.number()
+});
+const HotApiWithdrawalResponseSchema = v.object({
+	hash: v.nullable(v.string()),
+	nonce: v.string(),
+	near_trx: v.string(),
+	withdrawals: v.array(HotApiWithdrawalSchema)
+});
+var HotBridge$1 = class HotBridge$1 {
+	static {
+		this.API_FALLBACK_TIMEOUT_MS = 5e3;
+	}
+	static {
+		this.NEAR_RPC_TIMEOUT_MS = 1e4;
+	}
+	constructor({ envConfig, hotSdk, solverRelayApiKey }) {
+		this.route = RouteEnum.HotBridge;
+		this.envConfig = envConfig;
+		this.hotSdk = hotSdk;
+		this.solverRelayApiKey = solverRelayApiKey;
+		this.noncesCache = new LRUCache({
+			max: 50,
+			ttl: 3600 * 1e3,
+			fetchMethod: async (_key, _staleValue, { context: tx }) => {
+				return withTimeout(() => this.hotSdk.near.parseWithdrawalNonces(tx.hash, tx.accountId), { timeout: HotBridge$1.NEAR_RPC_TIMEOUT_MS });
+			}
+		});
+	}
+	getNoncesCacheKey(tx) {
+		return `${tx.hash}:${tx.accountId}`;
+	}
+	is(routeConfig) {
+		return routeConfig.route === RouteEnum.HotBridge;
+	}
+	async supports(params) {
+		if (params.routeConfig != null && !this.is(params.routeConfig)) return false;
+		const isValid = this.parseAssetId(params.assetId) != null;
+		if (!isValid && params.routeConfig != null) throw new UnsupportedAssetIdError(params.assetId, "`assetId` does not match `routeConfig`.");
+		return isValid;
+	}
+	parseAssetId(assetId) {
+		const parsed = parseDefuseAssetId(assetId);
+		if (!(parsed.contractId === OMNI_HOT_V2)) return null;
+		if (parsed.standard !== "nep245") throw new UnsupportedAssetIdError(assetId, "Should start with \"nep245:\".");
+		const [chainId, address] = utils$1.fromOmni(parsed.tokenId).split(":");
+		if (chainId == null || address == null) throw new UnsupportedAssetIdError(assetId, "Asset has invalid token id format.");
+		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);
+		assert(assetInfo != null, "Asset is not supported");
+		if (args.withdrawalParams.destinationMemo != null && args.withdrawalParams.destinationMemo !== "") throw new UnsupportedDestinationMemoError(assetInfo.blockchain, args.withdrawalParams.assetId);
+		const intents = [];
+		const feeAmount = getUnderlyingFee(args.feeEstimation, RouteEnum.HotBridge, "relayerFee");
+		const blockNumber = getUnderlyingFee(args.feeEstimation, RouteEnum.HotBridge, "blockNumber");
+		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 isNative = "native" in assetInfo;
+		const amount = args.withdrawalParams.amount + (isNative ? feeAmount : 0n);
+		const intent = await this.hotSdk.buildGaslessWithdrawIntent({
+			feeToken: "native",
+			feeAmount,
+			blockNumber,
+			chain: toHotNetworkId(assetInfo.blockchain),
+			token: isNative ? "native" : assetInfo.address,
+			amount,
+			receiver: args.withdrawalParams.destinationAddress
+		});
+		assert(intent.amounts[0] === amount.toString(), "Amount is not correct");
+		if (intent.amounts.length === 2) assert(intent.amounts[1] === feeAmount.toString(), "Amount is not correct");
+		const mtWithdrawIntent = intent;
+		mtWithdrawIntent.min_gas = MIN_GAS_AMOUNT;
+		intents.push(mtWithdrawIntent);
+		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);
+		assert(assetInfo != null, "Asset is not supported");
+		hotBlockchainInvariant(assetInfo.blockchain);
+		if (validateAddress(args.destinationAddress, assetInfo.blockchain) === false) throw new InvalidDestinationAddressForWithdrawalError(args.destinationAddress, assetInfo.blockchain);
+		if (assetInfo.blockchain === Chains.Stellar) {
+			const token = "native" in assetInfo ? "native" : assetInfo.address;
+			if (!await this.hotSdk.stellar.isTrustlineExists(args.destinationAddress, token)) throw new TrustlineNotFoundError(args.destinationAddress, args.assetId, assetInfo.blockchain, token);
+		}
+	}
+	async estimateWithdrawalFee(args) {
+		const assetInfo = this.parseAssetId(args.withdrawalParams.assetId);
+		assert(assetInfo != null, "Asset is not supported");
+		hotBlockchainInvariant(assetInfo.blockchain);
+		const feeAssetId = getFeeAssetIdForChain(assetInfo.blockchain);
+		const { gasPrice: feeAmount, blockNumber } = await withTimeout(async () => {
+			const result = await this.hotSdk.getGaslessWithdrawFee({
+				chain: toHotNetworkId(assetInfo.blockchain),
+				token: "native" in assetInfo ? "native" : assetInfo.address,
+				receiver: args.withdrawalParams.destinationAddress
+			});
+			if (assetInfo.blockchain === Chains.Plasma && args.withdrawalParams.assetId !== feeAssetId) result.gasPrice *= 20n;
+			return result;
+		}, {
+			errorInstance: new HotWithdrawalApiFeeRequestTimeoutError(),
+			timeout: typeof window !== "undefined" ? 1e4 : 3e3
+		});
+		const feeQuote = args.withdrawalParams.assetId === feeAssetId || feeAmount === 0n ? null : await getFeeQuote({
+			feeAmount,
+			feeAssetId,
+			tokenAssetId: args.withdrawalParams.assetId,
+			logger: args.logger,
+			envConfig: this.envConfig,
+			quoteOptions: args.quoteOptions,
+			solverRelayApiKey: this.solverRelayApiKey
+		});
+		return {
+			amount: feeQuote ? BigInt(feeQuote.amount_in) : feeAmount,
+			quote: feeQuote,
+			underlyingFees: { [RouteEnum.HotBridge]: {
+				relayerFee: feeAmount,
+				blockNumber
+			} }
+		};
+	}
+	createWithdrawalIdentifier(args) {
+		const assetInfo = this.parseAssetId(args.withdrawalParams.assetId);
+		assert(assetInfo != null, "Asset is not supported");
+		return {
+			landingChain: assetInfo.blockchain,
+			index: args.index,
+			withdrawalParams: args.withdrawalParams,
+			tx: args.tx
+		};
+	}
+	async describeWithdrawal(args) {
+		const cacheKey = this.getNoncesCacheKey(args.tx);
+		const nonces = await this.noncesCache.fetch(cacheKey, { context: args.tx });
+		if (nonces == null) throw new HotWithdrawalNotFoundError(args.tx.hash, args.index);
+		const nonce = nonces[args.index];
+		if (nonce == null) throw new HotWithdrawalNotFoundError(args.tx.hash, args.index);
+		const status = await this.hotSdk.getGaslessWithdrawStatus(nonce.toString());
+		if (status === HotWithdrawStatus.Canceled) return {
+			status: "failed",
+			reason: "Withdrawal was cancelled"
+		};
+		if (status === HotWithdrawStatus.Completed) return {
+			status: "completed",
+			txHash: null
+		};
+		if (typeof status === "string") {
+			if (!isHex(status)) {
+				args.logger?.warn("HOT Bridge incorrect destination tx hash detected", { value: status });
+				return {
+					status: "completed",
+					txHash: null
+				};
+			}
+			return {
+				status: "completed",
+				txHash: formatTxHash(status, args.landingChain)
+			};
+		}
+		const apiHash = await this.fetchWithdrawalHashFromApi(args.tx.hash, nonce, args.logger);
+		if (apiHash != null) return {
+			status: "completed",
+			txHash: formatTxHash(apiHash, args.landingChain)
+		};
+		return { status: "pending" };
+	}
+	async fetchWithdrawalHashFromApi(nearTxHash, nonce, logger) {
+		try {
+			const data = await (await withTimeout(() => this.hotSdk.api.requestApi(`/api/v1/evm/bridge_withdrawal_hash?near_trx=${nearTxHash}`, { method: "GET" }), { timeout: HotBridge$1.API_FALLBACK_TIMEOUT_MS })).json();
+			const parseResult = v.safeParse(HotApiWithdrawalResponseSchema, data);
+			if (!parseResult.success) {
+				logger?.debug("HOT API response parse failed", { issues: parseResult.issues });
+				return null;
+			}
+			const withdrawal = parseResult.output.withdrawals.find((w) => w.nonce === nonce.toString());
+			if (withdrawal?.hash) {
+				const hash = withdrawal.hash.replace(/^0x/, "");
+				if (isHex(hash)) {
+					logger?.info("HOT withdrawal hash found via API fallback", {
+						nearTxHash,
+						nonce: nonce.toString()
+					});
+					return hash;
+				}
+			}
+			return null;
+		} catch (error) {
+			logger?.debug("HOT API fallback failed", {
+				error,
+				nearTxHash
+			});
+			return null;
+		}
+	}
+};
+
+//#endregion
+export { HotBridge$1 as HotBridge };

package/dist/src/bridges/intents-bridge/intents-bridge.cjs

@@ -0,0 +1,59 @@
+const require_errors = require('../../classes/errors.cjs');
+const require_route_enum = require('../../constants/route-enum.cjs');
+const require_caip2 = require('../../lib/caip2.cjs');
+const require_validateAddress = require('../../lib/validateAddress.cjs');
+
+//#region src/bridges/intents-bridge/intents-bridge.ts
+var IntentsBridge = class {
+	constructor() {
+		this.route = require_route_enum.RouteEnum.InternalTransfer;
+	}
+	is(routeConfig) {
+		return routeConfig.route === this.route;
+	}
+	async 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) {
+		if (require_validateAddress.validateAddress(args.destinationAddress, require_caip2.Chains.Near) === false) throw new require_errors.InvalidDestinationAddressForWithdrawalError(args.destinationAddress, "near-intents");
+	}
+	async estimateWithdrawalFee() {
+		return {
+			amount: 0n,
+			quote: null,
+			underlyingFees: { [require_route_enum.RouteEnum.InternalTransfer]: null }
+		};
+	}
+	createWithdrawalIdentifier(args) {
+		return {
+			landingChain: require_caip2.Chains.Near,
+			index: args.index,
+			withdrawalParams: args.withdrawalParams,
+			tx: args.tx
+		};
+	}
+	async describeWithdrawal(args) {
+		return {
+			status: "completed",
+			txHash: args.tx.hash
+		};
+	}
+};
+
+//#endregion
+exports.IntentsBridge = IntentsBridge;

package/dist/src/bridges/intents-bridge/intents-bridge.js

@@ -0,0 +1,59 @@
+import { InvalidDestinationAddressForWithdrawalError } from "../../classes/errors.js";
+import { RouteEnum } from "../../constants/route-enum.js";
+import { Chains } from "../../lib/caip2.js";
+import { validateAddress } from "../../lib/validateAddress.js";
+
+//#region src/bridges/intents-bridge/intents-bridge.ts
+var IntentsBridge = class {
+	constructor() {
+		this.route = RouteEnum.InternalTransfer;
+	}
+	is(routeConfig) {
+		return routeConfig.route === this.route;
+	}
+	async 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) {
+		if (validateAddress(args.destinationAddress, Chains.Near) === false) throw new InvalidDestinationAddressForWithdrawalError(args.destinationAddress, "near-intents");
+	}
+	async estimateWithdrawalFee() {
+		return {
+			amount: 0n,
+			quote: null,
+			underlyingFees: { [RouteEnum.InternalTransfer]: null }
+		};
+	}
+	createWithdrawalIdentifier(args) {
+		return {
+			landingChain: Chains.Near,
+			index: args.index,
+			withdrawalParams: args.withdrawalParams,
+			tx: args.tx
+		};
+	}
+	async describeWithdrawal(args) {
+		return {
+			status: "completed",
+			txHash: args.tx.hash
+		};
+	}
+};
+
+//#endregion
+export { IntentsBridge };