lampamazaza-new-intents-sdk 0.47.1

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

@@ -0,0 +1,44 @@
+import { RouteEnum } from "../../constants/route-enum.js";
+import { MIN_GAS_AMOUNT, NEAR_NATIVE_ASSET_ID } from "./direct-bridge-constants.js";
+import { assert, unwrapNearFailoverRpcProvider, utils } from "lampamazaza-internal-utils";
+import { providers } from "near-api-js";
+
+//#region src/bridges/direct-bridge/direct-bridge-utils.ts
+function createWithdrawIntentPrimitive(params) {
+	if (params.assetId === NEAR_NATIVE_ASSET_ID && params.msg === void 0) return {
+		intent: "native_withdraw",
+		receiver_id: params.destinationAddress,
+		amount: params.amount.toString()
+	};
+	const { contractId: tokenAccountId, standard } = utils.parseDefuseAssetId(params.assetId);
+	assert(standard === "nep141", "Only NEP-141 is supported");
+	if (params.msg !== void 0) params.logger?.warn("min_gas is not set for direct-bridge withdrawal with msg, gas consumption is unpredictable");
+	return {
+		intent: "ft_withdraw",
+		token: tokenAccountId,
+		receiver_id: params.destinationAddress,
+		amount: params.amount.toString(),
+		storage_deposit: params.storageDeposit > 0n ? params.storageDeposit.toString() : void 0,
+		msg: params.msg,
+		min_gas: params.msg == null ? MIN_GAS_AMOUNT : void 0
+	};
+}
+function withdrawalParamsInvariant(params) {
+	assert(!params.routeConfig ? true : params.routeConfig.route === RouteEnum.NearWithdrawal, "Bridge is not direct");
+}
+async function accountExistsInNEAR(provider, accountId) {
+	try {
+		await unwrapNearFailoverRpcProvider(provider).query({
+			request_type: "view_account",
+			account_id: accountId,
+			finality: "final"
+		});
+		return true;
+	} catch (error) {
+		if (error instanceof providers.TypedError && error.type === "AccountDoesNotExist") return false;
+		throw error;
+	}
+}
+
+//#endregion
+export { accountExistsInNEAR, createWithdrawIntentPrimitive, withdrawalParamsInvariant };

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

@@ -0,0 +1,155 @@
+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_direct_bridge_constants = require('./direct-bridge-constants.cjs');
+const require_direct_bridge_utils = require('./direct-bridge-utils.cjs');
+const require_error = require('./error.cjs');
+let lampamazaza_internal_utils = require("lampamazaza-internal-utils");
+let lru_cache = require("lru-cache");
+
+//#region src/bridges/direct-bridge/direct-bridge.ts
+var DirectBridge = class {
+	constructor({ envConfig, nearProvider, solverRelayApiKey }) {
+		this.route = require_route_enum.RouteEnum.NearWithdrawal;
+		this.storageDepositCache = new lru_cache.LRUCache({
+			max: 100,
+			ttl: 36e5
+		});
+		this.accountExistenceCache = new lru_cache.LRUCache({
+			max: 100,
+			ttl: 36e5
+		});
+		this.envConfig = envConfig;
+		this.nearProvider = nearProvider;
+		this.solverRelayApiKey = solverRelayApiKey;
+	}
+	is(routeConfig) {
+		return routeConfig.route === require_route_enum.RouteEnum.NearWithdrawal;
+	}
+	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.standard === "nep141") return Object.assign(parsed, {
+			blockchain: require_caip2.Chains.Near,
+			bridgeName: require_bridge_name_enum.BridgeNameEnum.None,
+			address: parsed.contractId
+		});
+		return null;
+	}
+	createWithdrawalIntents(args) {
+		require_direct_bridge_utils.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 = require_direct_bridge_utils.createWithdrawIntentPrimitive({
+			assetId: args.withdrawalParams.assetId,
+			destinationAddress: args.withdrawalParams.destinationAddress,
+			amount: args.withdrawalParams.amount,
+			storageDeposit: require_estimate_fee.getUnderlyingFee(args.feeEstimation, require_route_enum.RouteEnum.NearWithdrawal, "storageDepositFee"),
+			msg: args.withdrawalParams.routeConfig?.msg,
+			logger: args.logger
+		});
+		intents.push(intent);
+		return Promise.resolve(intents);
+	}
+	/**
+	* Direct 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, require_caip2.Chains.Near);
+		if (lampamazaza_internal_utils.utils.isImplicitAccount(args.destinationAddress) === false && await this.getCachedAccountExistenceCheck(args.destinationAddress) === false) throw new require_error.DestinationExplicitNearAccountDoesntExistError(args.destinationAddress);
+	}
+	async estimateWithdrawalFee(args) {
+		require_direct_bridge_utils.withdrawalParamsInvariant(args.withdrawalParams);
+		const { contractId: tokenAccountId, standard } = lampamazaza_internal_utils.utils.parseDefuseAssetId(args.withdrawalParams.assetId);
+		(0, lampamazaza_internal_utils.assert)(standard === "nep141", "Only NEP-141 is supported");
+		if (args.withdrawalParams.assetId === require_direct_bridge_constants.NEAR_NATIVE_ASSET_ID && args.withdrawalParams.routeConfig?.msg === void 0) return {
+			amount: 0n,
+			quote: null,
+			underlyingFees: { [require_route_enum.RouteEnum.NearWithdrawal]: { storageDepositFee: 0n } }
+		};
+		const [minStorageBalance, userStorageBalance] = await this.getCachedStorageDepositValue(tokenAccountId, args.withdrawalParams.destinationAddress);
+		if (minStorageBalance <= userStorageBalance) return {
+			amount: 0n,
+			quote: null,
+			underlyingFees: { [require_route_enum.RouteEnum.NearWithdrawal]: { storageDepositFee: 0n } }
+		};
+		const feeAssetId = require_direct_bridge_constants.NEAR_NATIVE_ASSET_ID;
+		const feeAmount = minStorageBalance - userStorageBalance;
+		const feeQuote = args.withdrawalParams.assetId === feeAssetId ? 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.NearWithdrawal]: { storageDepositFee: feeAmount } }
+		};
+	}
+	/**
+	* Gets storage deposit for a token to avoid frequent RPC calls.
+	*/
+	async getCachedStorageDepositValue(contractId, accountId) {
+		const key = `${contractId}${accountId}`;
+		const cached = this.storageDepositCache.get(key);
+		if (cached !== void 0) return cached;
+		const result = await Promise.all([(0, lampamazaza_internal_utils.getNearNep141MinStorageBalance)({
+			contractId,
+			nearProvider: this.nearProvider
+		}), (0, lampamazaza_internal_utils.getNearNep141StorageBalance)({
+			contractId,
+			accountId,
+			nearProvider: this.nearProvider
+		})]);
+		if (result[1] >= result[0]) this.storageDepositCache.set(key, result);
+		return result;
+	}
+	/**
+	* Checks account existence to avoid frequent RPC calls.
+	*/
+	async getCachedAccountExistenceCheck(accountId) {
+		const cached = this.accountExistenceCache.get(accountId);
+		if (cached !== void 0) return cached;
+		const exist = await require_direct_bridge_utils.accountExistsInNEAR(this.nearProvider, accountId);
+		if (exist) this.accountExistenceCache.set(accountId, exist);
+		return exist;
+	}
+	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.DirectBridge = DirectBridge;

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

@@ -0,0 +1,154 @@
+import { InvalidDestinationAddressForWithdrawalError, UnsupportedAssetIdError } 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 { NEAR_NATIVE_ASSET_ID } from "./direct-bridge-constants.js";
+import { accountExistsInNEAR, createWithdrawIntentPrimitive, withdrawalParamsInvariant } from "./direct-bridge-utils.js";
+import { DestinationExplicitNearAccountDoesntExistError } from "./error.js";
+import { assert, getNearNep141MinStorageBalance, getNearNep141StorageBalance, utils } from "lampamazaza-internal-utils";
+import { LRUCache } from "lru-cache";
+
+//#region src/bridges/direct-bridge/direct-bridge.ts
+var DirectBridge = class {
+	constructor({ envConfig, nearProvider, solverRelayApiKey }) {
+		this.route = RouteEnum.NearWithdrawal;
+		this.storageDepositCache = new LRUCache({
+			max: 100,
+			ttl: 36e5
+		});
+		this.accountExistenceCache = new LRUCache({
+			max: 100,
+			ttl: 36e5
+		});
+		this.envConfig = envConfig;
+		this.nearProvider = nearProvider;
+		this.solverRelayApiKey = solverRelayApiKey;
+	}
+	is(routeConfig) {
+		return routeConfig.route === RouteEnum.NearWithdrawal;
+	}
+	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.standard === "nep141") return Object.assign(parsed, {
+			blockchain: Chains.Near,
+			bridgeName: BridgeNameEnum.None,
+			address: parsed.contractId
+		});
+		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,
+			destinationAddress: args.withdrawalParams.destinationAddress,
+			amount: args.withdrawalParams.amount,
+			storageDeposit: getUnderlyingFee(args.feeEstimation, RouteEnum.NearWithdrawal, "storageDepositFee"),
+			msg: args.withdrawalParams.routeConfig?.msg,
+			logger: args.logger
+		});
+		intents.push(intent);
+		return Promise.resolve(intents);
+	}
+	/**
+	* Direct bridge doesn't have withdrawal restrictions.
+	*/
+	async validateWithdrawal(args) {
+		if (validateAddress(args.destinationAddress, Chains.Near) === false) throw new InvalidDestinationAddressForWithdrawalError(args.destinationAddress, Chains.Near);
+		if (utils.isImplicitAccount(args.destinationAddress) === false && await this.getCachedAccountExistenceCheck(args.destinationAddress) === false) throw new DestinationExplicitNearAccountDoesntExistError(args.destinationAddress);
+	}
+	async estimateWithdrawalFee(args) {
+		withdrawalParamsInvariant(args.withdrawalParams);
+		const { contractId: tokenAccountId, standard } = utils.parseDefuseAssetId(args.withdrawalParams.assetId);
+		assert(standard === "nep141", "Only NEP-141 is supported");
+		if (args.withdrawalParams.assetId === NEAR_NATIVE_ASSET_ID && args.withdrawalParams.routeConfig?.msg === void 0) return {
+			amount: 0n,
+			quote: null,
+			underlyingFees: { [RouteEnum.NearWithdrawal]: { storageDepositFee: 0n } }
+		};
+		const [minStorageBalance, userStorageBalance] = await this.getCachedStorageDepositValue(tokenAccountId, args.withdrawalParams.destinationAddress);
+		if (minStorageBalance <= userStorageBalance) return {
+			amount: 0n,
+			quote: null,
+			underlyingFees: { [RouteEnum.NearWithdrawal]: { storageDepositFee: 0n } }
+		};
+		const feeAssetId = NEAR_NATIVE_ASSET_ID;
+		const feeAmount = minStorageBalance - userStorageBalance;
+		const feeQuote = args.withdrawalParams.assetId === feeAssetId ? 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.NearWithdrawal]: { storageDepositFee: feeAmount } }
+		};
+	}
+	/**
+	* Gets storage deposit for a token to avoid frequent RPC calls.
+	*/
+	async getCachedStorageDepositValue(contractId, accountId) {
+		const key = `${contractId}${accountId}`;
+		const cached = this.storageDepositCache.get(key);
+		if (cached !== void 0) return cached;
+		const result = await Promise.all([getNearNep141MinStorageBalance({
+			contractId,
+			nearProvider: this.nearProvider
+		}), getNearNep141StorageBalance({
+			contractId,
+			accountId,
+			nearProvider: this.nearProvider
+		})]);
+		if (result[1] >= result[0]) this.storageDepositCache.set(key, result);
+		return result;
+	}
+	/**
+	* Checks account existence to avoid frequent RPC calls.
+	*/
+	async getCachedAccountExistenceCheck(accountId) {
+		const cached = this.accountExistenceCache.get(accountId);
+		if (cached !== void 0) return cached;
+		const exist = await accountExistsInNEAR(this.nearProvider, accountId);
+		if (exist) this.accountExistenceCache.set(accountId, exist);
+		return exist;
+	}
+	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 { DirectBridge };

package/dist/src/bridges/direct-bridge/error.cjs

@@ -0,0 +1,16 @@
+const require_rolldown_runtime = require('../../../_virtual/rolldown_runtime.cjs');
+let lampamazaza_internal_utils = require("lampamazaza-internal-utils");
+
+//#region src/bridges/direct-bridge/error.ts
+var DestinationExplicitNearAccountDoesntExistError = class extends lampamazaza_internal_utils.BaseError {
+	constructor(accountId) {
+		super("Destination explicit NEAR account doesn't exist.", {
+			metaMessages: [`Account Id: ${accountId}`],
+			name: "DestinationExplicitNearAccountDoesntExistError"
+		});
+		this.accountId = accountId;
+	}
+};
+
+//#endregion
+exports.DestinationExplicitNearAccountDoesntExistError = DestinationExplicitNearAccountDoesntExistError;

package/dist/src/bridges/direct-bridge/error.d.cts

@@ -0,0 +1,12 @@
+import { BaseError } from "lampamazaza-internal-utils";
+
+//#region src/bridges/direct-bridge/error.d.ts
+type DestinationExplicitNearAccountDoesntExistErrorType = DestinationExplicitNearAccountDoesntExistError & {
+  name: "DestinationExplicitNearAccountDoesntExistError";
+};
+declare class DestinationExplicitNearAccountDoesntExistError extends BaseError {
+  accountId: string;
+  constructor(accountId: string);
+}
+//#endregion
+export { DestinationExplicitNearAccountDoesntExistError, DestinationExplicitNearAccountDoesntExistErrorType };

package/dist/src/bridges/direct-bridge/error.d.ts

@@ -0,0 +1,12 @@
+import { BaseError } from "lampamazaza-internal-utils";
+
+//#region src/bridges/direct-bridge/error.d.ts
+type DestinationExplicitNearAccountDoesntExistErrorType = DestinationExplicitNearAccountDoesntExistError & {
+  name: "DestinationExplicitNearAccountDoesntExistError";
+};
+declare class DestinationExplicitNearAccountDoesntExistError extends BaseError {
+  accountId: string;
+  constructor(accountId: string);
+}
+//#endregion
+export { DestinationExplicitNearAccountDoesntExistError, DestinationExplicitNearAccountDoesntExistErrorType };

package/dist/src/bridges/direct-bridge/error.js

@@ -0,0 +1,15 @@
+import { BaseError } from "lampamazaza-internal-utils";
+
+//#region src/bridges/direct-bridge/error.ts
+var DestinationExplicitNearAccountDoesntExistError = class extends BaseError {
+	constructor(accountId) {
+		super("Destination explicit NEAR account doesn't exist.", {
+			metaMessages: [`Account Id: ${accountId}`],
+			name: "DestinationExplicitNearAccountDoesntExistError"
+		});
+		this.accountId = accountId;
+	}
+};
+
+//#endregion
+export { DestinationExplicitNearAccountDoesntExistError };

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

@@ -0,0 +1,23 @@
+const require_rolldown_runtime = require('../../../_virtual/rolldown_runtime.cjs');
+let lampamazaza_internal_utils = require("lampamazaza-internal-utils");
+
+//#region src/bridges/hot-bridge/error.ts
+var HotWithdrawalNotFoundError = class extends lampamazaza_internal_utils.BaseError {
+	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 HotWithdrawalApiFeeRequestTimeoutError = class extends lampamazaza_internal_utils.BaseError {
+	constructor() {
+		super("Hot bridge withdrawal fee request timed out.", { name: "HotWithdrawalApiFeeRequestTimeoutError" });
+	}
+};
+
+//#endregion
+exports.HotWithdrawalApiFeeRequestTimeoutError = HotWithdrawalApiFeeRequestTimeoutError;
+exports.HotWithdrawalNotFoundError = HotWithdrawalNotFoundError;

package/dist/src/bridges/hot-bridge/error.d.cts

@@ -0,0 +1,19 @@
+import { BaseError } from "lampamazaza-internal-utils";
+
+//#region src/bridges/hot-bridge/error.d.ts
+type HotWithdrawalNotFoundErrorType = HotWithdrawalNotFoundError & {
+  name: "HotWithdrawalNotFoundError";
+};
+declare class HotWithdrawalNotFoundError extends BaseError {
+  txHash: string;
+  index: number;
+  constructor(txHash: string, index: number);
+}
+type HotWithdrawalApiFeeRequestTimeoutErrorType = HotWithdrawalApiFeeRequestTimeoutError & {
+  name: "HotWithdrawalApiFeeRequestTimeoutError";
+};
+declare class HotWithdrawalApiFeeRequestTimeoutError extends BaseError {
+  constructor();
+}
+//#endregion
+export { HotWithdrawalApiFeeRequestTimeoutError, HotWithdrawalApiFeeRequestTimeoutErrorType, HotWithdrawalNotFoundError, HotWithdrawalNotFoundErrorType };

package/dist/src/bridges/hot-bridge/error.d.ts

@@ -0,0 +1,19 @@
+import { BaseError } from "lampamazaza-internal-utils";
+
+//#region src/bridges/hot-bridge/error.d.ts
+type HotWithdrawalNotFoundErrorType = HotWithdrawalNotFoundError & {
+  name: "HotWithdrawalNotFoundError";
+};
+declare class HotWithdrawalNotFoundError extends BaseError {
+  txHash: string;
+  index: number;
+  constructor(txHash: string, index: number);
+}
+type HotWithdrawalApiFeeRequestTimeoutErrorType = HotWithdrawalApiFeeRequestTimeoutError & {
+  name: "HotWithdrawalApiFeeRequestTimeoutError";
+};
+declare class HotWithdrawalApiFeeRequestTimeoutError extends BaseError {
+  constructor();
+}
+//#endregion
+export { HotWithdrawalApiFeeRequestTimeoutError, HotWithdrawalApiFeeRequestTimeoutErrorType, HotWithdrawalNotFoundError, HotWithdrawalNotFoundErrorType };

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

@@ -0,0 +1,21 @@
+import { BaseError } from "lampamazaza-internal-utils";
+
+//#region src/bridges/hot-bridge/error.ts
+var HotWithdrawalNotFoundError = class extends BaseError {
+	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 HotWithdrawalApiFeeRequestTimeoutError = class extends BaseError {
+	constructor() {
+		super("Hot bridge withdrawal fee request timed out.", { name: "HotWithdrawalApiFeeRequestTimeoutError" });
+	}
+};
+
+//#endregion
+export { HotWithdrawalApiFeeRequestTimeoutError, HotWithdrawalNotFoundError };

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

@@ -0,0 +1,21 @@
+const require_caip2 = require('../../lib/caip2.cjs');
+
+//#region src/bridges/hot-bridge/hot-bridge-chains.ts
+const HotBridgeChains = [
+	require_caip2.Chains.Polygon,
+	require_caip2.Chains.BNB,
+	require_caip2.Chains.TON,
+	require_caip2.Chains.Optimism,
+	require_caip2.Chains.Avalanche,
+	require_caip2.Chains.Monad,
+	require_caip2.Chains.Stellar,
+	require_caip2.Chains.LayerX,
+	require_caip2.Chains.Adi,
+	require_caip2.Chains.Scroll,
+	require_caip2.Chains.Plasma
+];
+const HotBridgeEVMChains = HotBridgeChains.filter((a) => a.startsWith("eip155:"));
+
+//#endregion
+exports.HotBridgeChains = HotBridgeChains;
+exports.HotBridgeEVMChains = HotBridgeEVMChains;

package/dist/src/bridges/hot-bridge/hot-bridge-chains.d.cts

@@ -0,0 +1,6 @@
+//#region src/bridges/hot-bridge/hot-bridge-chains.d.ts
+type HotBridgeChain = (typeof HotBridgeChains)[number];
+type HotBridgeEVMChain = Extract<HotBridgeChain, `eip155:${string}`>;
+declare const HotBridgeChains: ("eip155:10" | "eip155:56" | "eip155:137" | "eip155:143" | "eip155:196" | "eip155:36900" | "eip155:43114" | "tvm:-239" | "stellar:pubnet" | "eip155:9745" | "eip155:534352")[];
+//#endregion
+export { HotBridgeEVMChain };

package/dist/src/bridges/hot-bridge/hot-bridge-chains.d.ts

@@ -0,0 +1,6 @@
+//#region src/bridges/hot-bridge/hot-bridge-chains.d.ts
+type HotBridgeChain = (typeof HotBridgeChains)[number];
+type HotBridgeEVMChain = Extract<HotBridgeChain, `eip155:${string}`>;
+declare const HotBridgeChains: ("eip155:10" | "eip155:56" | "eip155:137" | "eip155:143" | "eip155:196" | "eip155:36900" | "eip155:43114" | "tvm:-239" | "stellar:pubnet" | "eip155:9745" | "eip155:534352")[];
+//#endregion
+export { HotBridgeEVMChain };

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

@@ -0,0 +1,20 @@
+import { Chains } from "../../lib/caip2.js";
+
+//#region src/bridges/hot-bridge/hot-bridge-chains.ts
+const HotBridgeChains = [
+	Chains.Polygon,
+	Chains.BNB,
+	Chains.TON,
+	Chains.Optimism,
+	Chains.Avalanche,
+	Chains.Monad,
+	Chains.Stellar,
+	Chains.LayerX,
+	Chains.Adi,
+	Chains.Scroll,
+	Chains.Plasma
+];
+const HotBridgeEVMChains = HotBridgeChains.filter((a) => a.startsWith("eip155:"));
+
+//#endregion
+export { HotBridgeChains, HotBridgeEVMChains };

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

@@ -0,0 +1,11 @@
+
+//#region src/bridges/hot-bridge/hot-bridge-constants.ts
+const HotWithdrawStatus = {
+	Completed: "COMPLETED",
+	Canceled: "CANCELED"
+};
+const MIN_GAS_AMOUNT = "91300000000000";
+
+//#endregion
+exports.HotWithdrawStatus = HotWithdrawStatus;
+exports.MIN_GAS_AMOUNT = MIN_GAS_AMOUNT;

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

@@ -0,0 +1,9 @@
+//#region src/bridges/hot-bridge/hot-bridge-constants.ts
+const HotWithdrawStatus = {
+	Completed: "COMPLETED",
+	Canceled: "CANCELED"
+};
+const MIN_GAS_AMOUNT = "91300000000000";
+
+//#endregion
+export { HotWithdrawStatus, MIN_GAS_AMOUNT };

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

@@ -0,0 +1,66 @@
+const require_rolldown_runtime = require('../../../_virtual/rolldown_runtime.cjs');
+const require_caip2 = require('../../lib/caip2.cjs');
+const require_hot_bridge_chains = require('./hot-bridge-chains.cjs');
+let lampamazaza_internal_utils = require("lampamazaza-internal-utils");
+let _hot_labs_omni_sdk = require("@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 = {
+	[require_caip2.Chains.BNB]: "nep245:v2_1.omni.hot.tg:56_11111111111111111111",
+	[require_caip2.Chains.Polygon]: "nep245:v2_1.omni.hot.tg:137_11111111111111111111",
+	[require_caip2.Chains.Monad]: "nep245:v2_1.omni.hot.tg:143_11111111111111111111",
+	[require_caip2.Chains.TON]: "nep245:v2_1.omni.hot.tg:1117_",
+	[require_caip2.Chains.Optimism]: "nep245:v2_1.omni.hot.tg:10_11111111111111111111",
+	[require_caip2.Chains.Avalanche]: "nep245:v2_1.omni.hot.tg:43114_11111111111111111111",
+	[require_caip2.Chains.Stellar]: "nep245:v2_1.omni.hot.tg:1100_111bzQBB5v7AhLyPMDwS8uJgQV24KaAPXtwyVWu2KXbbfQU6NXRCz",
+	[require_caip2.Chains.LayerX]: "nep245:v2_1.omni.hot.tg:196_11111111111111111111",
+	[require_caip2.Chains.Adi]: "nep245:v2_1.omni.hot.tg:36900_11111111111111111111",
+	[require_caip2.Chains.Scroll]: "nep245:v2_1.omni.hot.tg:534352_11111111111111111111",
+	[require_caip2.Chains.Plasma]: "nep245:v2_1.omni.hot.tg:9745_11111111111111111111"
+};
+const caip2NetworkIdMapping = {
+	[require_caip2.Chains.BNB]: _hot_labs_omni_sdk.Network.Bnb,
+	[require_caip2.Chains.Polygon]: _hot_labs_omni_sdk.Network.Polygon,
+	[require_caip2.Chains.Monad]: MONAD_MAINNET_NETWORK_ID,
+	[require_caip2.Chains.TON]: _hot_labs_omni_sdk.Network.Ton,
+	[require_caip2.Chains.Optimism]: _hot_labs_omni_sdk.Network.Optimism,
+	[require_caip2.Chains.Avalanche]: _hot_labs_omni_sdk.Network.Avalanche,
+	[require_caip2.Chains.Stellar]: _hot_labs_omni_sdk.Network.Stellar,
+	[require_caip2.Chains.LayerX]: _hot_labs_omni_sdk.Network.Xlayer,
+	[require_caip2.Chains.Adi]: ADI_NETWORK_ID,
+	[require_caip2.Chains.Scroll]: _hot_labs_omni_sdk.Network.Scroll,
+	[require_caip2.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) {
+	(0, lampamazaza_internal_utils.assert)(require_hot_bridge_chains.HotBridgeChains.includes(blockchain), `${blockchain} is not a valid HOT Bridge blockchain. Supported values: ${require_hot_bridge_chains.HotBridgeChains.join()}`);
+}
+
+//#endregion
+exports.formatTxHash = formatTxHash;
+exports.getFeeAssetIdForChain = getFeeAssetIdForChain;
+exports.hotBlockchainInvariant = hotBlockchainInvariant;
+exports.hotNetworkIdToCAIP2 = hotNetworkIdToCAIP2;
+exports.toHotNetworkId = toHotNetworkId;