@defuse-protocol/intents-sdk 0.43.2 → 0.44.0

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

@@ -1,21 +1,22 @@
+import { InvalidDestinationAddressForWithdrawalError, MinWithdrawalAmountError, UnsupportedAssetIdError } from "../../classes/errors.js";
 import { RouteEnum } from "../../constants/route-enum.js";
 import { getFeeQuote, getUnderlyingFee } from "../../lib/estimate-fee.js";
-import { InvalidDestinationAddressForWithdrawalError, MinWithdrawalAmountError, UnsupportedAssetIdError } from "../../classes/errors.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 { InsufficientUtxoForOmniBridgeWithdrawalError, IntentsNearOmniAvailableBalanceTooLowError, InvalidFeeValueError, OmniTransferDestinationChainHashNotFoundError, OmniTransferNotFoundError, OmniWithdrawalApiFeeRequestTimeoutError, TokenNotFoundInDestinationChainError } from "./error.js";
+import { InsufficientUtxoForOmniBridgeWithdrawalError, IntentsNearOmniAvailableBalanceTooLowError, InvalidFeeValueError, OmniWithdrawalApiFeeRequestTimeoutError, TokenNotFoundInDestinationChainError } from "./error.js";
 import { MIN_ALLOWED_STORAGE_BALANCE_FOR_INTENTS_NEAR, NEAR_NATIVE_ASSET_ID, OMNI_BRIDGE_CONTRACT } from "./omni-bridge-constants.js";
-import { caip2ToChainKind, chainKindToCaip2, createWithdrawIntentsPrimitive, getAccountOmniStorageBalance, getBridgedToken, getTokenDecimals, isUtxoChain, validateOmniToken } from "./omni-bridge-utils.js";
-import { RETRY_CONFIGS, assert, configsByEnvironment, getNearNep141MinStorageBalance, getNearNep141StorageBalance, withTimeout } from "@defuse-protocol/internal-utils";
+import { POA_TOKENS_ROUTABLE_THROUGH_OMNI_BRIDGE } from "../../constants/poa-tokens-routable-through-omni-bridge.js";
+import { caip2ToChainKind, chainKindToCaip2, createWithdrawIntentsPrimitive, getAccountOmniStorageBalance, getBridgedToken, getTokenDecimals, isUtxoChain, poaContractIdToChainKind, validateOmniToken } from "./omni-bridge-utils.js";
+import { assert, configsByEnvironment, getNearNep141MinStorageBalance, getNearNep141StorageBalance, withTimeout } from "@defuse-protocol/internal-utils";
 import { LRUCache } from "lru-cache";
-import { retry } from "@lifeomic/attempt";
 import TTLCache from "@isaacs/ttlcache";
 import { ChainKind, OmniBridgeAPI, getChain, getMinimumTransferableAmount, isEvmChain, omniAddress, parseOriginChain, verifyTransferAmount } from "omni-bridge-sdk";
 
 //#region src/bridges/omni-bridge/omni-bridge.ts
 var OmniBridge = class {
-	constructor({ env, nearProvider, solverRelayApiKey }) {
+	constructor({ env, nearProvider, solverRelayApiKey, routeMigratedPoaTokensThroughOmniBridge }) {
+		this.route = RouteEnum.OmniBridge;
 		this.storageDepositCache = new LRUCache({
 			max: 100,
 			ttl: 36e5
@@ -26,6 +27,7 @@ var OmniBridge = class {
 		this.nearProvider = nearProvider;
 		this.omniBridgeAPI = new OmniBridgeAPI();
 		this.solverRelayApiKey = solverRelayApiKey;
+		this.routeMigratedPoaTokensThroughOmniBridge = routeMigratedPoaTokensThroughOmniBridge ?? false;
 	}
 	is(routeConfig) {
 		return routeConfig.route === RouteEnum.OmniBridge;
@@ -38,7 +40,8 @@ var OmniBridge = class {
 		const nonValidStandard = parsed.standard !== "nep141";
 		if (nonValidStandard && (omniBridgeSetWithNoChain || targetChainSpecified)) throw new UnsupportedAssetIdError(params.assetId, `Only NEP-141 tokens are supported by Omni Bridge.`);
 		if (nonValidStandard) return false;
-		const nonValidToken = validateOmniToken(parsed.contractId) === false;
+		const poaTokenRoutedThroughOmniBridge = this.isPoaTokenRoutedThroughOmniBridge(parsed.contractId);
+		const nonValidToken = !poaTokenRoutedThroughOmniBridge && validateOmniToken(parsed.contractId) === false;
 		if (nonValidToken && omniBridgeSetWithNoChain) throw new UnsupportedAssetIdError(params.assetId, `Non valid omni contract id ${parsed.contractId}`);
 		if (!targetChainSpecified && nonValidToken) return false;
 		let omniChainKind = null;
@@ -48,7 +51,7 @@ var OmniBridge = class {
 			if (omniChainKind === null) throw new UnsupportedAssetIdError(params.assetId, `Chain ${params.routeConfig.chain} is not supported in Omni Bridge.`);
 			caip2Chain = params.routeConfig.chain;
 		} else {
-			omniChainKind = parseOriginChain(parsed.contractId);
+			omniChainKind = poaTokenRoutedThroughOmniBridge ? poaContractIdToChainKind(parsed.contractId) : parseOriginChain(parsed.contractId);
 			if (omniChainKind === null) throw new UnsupportedAssetIdError(params.assetId, `Withdrawal of ${parsed.contractId} to its origin chain is not supported in Omni Bridge.`);
 			caip2Chain = chainKindToCaip2(omniChainKind);
 			if (caip2Chain === null) throw new UnsupportedAssetIdError(params.assetId, `Withdrawal of ${parsed.contractId} to its origin chain is not supported in Omni Bridge.`);
@@ -62,7 +65,7 @@ var OmniBridge = class {
 	parseAssetId(assetId) {
 		const parsed = parseDefuseAssetId(assetId);
 		if (parsed.standard !== "nep141") return null;
-		const omniChainKind = parseOriginChain(parsed.contractId);
+		const omniChainKind = this.isPoaTokenRoutedThroughOmniBridge(parsed.contractId) ? poaContractIdToChainKind(parsed.contractId) : parseOriginChain(parsed.contractId);
 		if (omniChainKind === null) return null;
 		const blockchain = chainKindToCaip2(omniChainKind);
 		if (blockchain === null) return null;
@@ -81,7 +84,7 @@ var OmniBridge = class {
 			omniChainKind = caip2ToChainKind(routeConfig.chain);
 			blockchain = routeConfig.chain;
 		} else {
-			omniChainKind = parseOriginChain(parsed.contractId);
+			omniChainKind = this.isPoaTokenRoutedThroughOmniBridge(parsed.contractId) ? poaContractIdToChainKind(parsed.contractId) : parseOriginChain(parsed.contractId);
 			if (omniChainKind === null) return null;
 			blockchain = chainKindToCaip2(omniChainKind);
 		}
@@ -232,25 +235,33 @@ var OmniBridge = class {
 			underlyingFees: { [RouteEnum.OmniBridge]: underlyingFees }
 		};
 	}
-	async waitForWithdrawalCompletion(args) {
-		return retry(async () => {
-			if (args.signal?.aborted) throw args.signal.reason;
-			const transfer = (await this.omniBridgeAPI.getTransfer({ transactionHash: args.tx.hash }))[args.index];
-			if (transfer == null || transfer.transfer_message == null) throw new OmniTransferNotFoundError(args.tx.hash);
-			const destinationChain = getChain(transfer.transfer_message.recipient);
-			let txHash = null;
-			if (isEvmChain(destinationChain)) txHash = transfer.finalised?.EVMLog?.transaction_hash;
-			else if (destinationChain === ChainKind.Sol) txHash = transfer.finalised?.Solana?.signature;
-			else if (destinationChain === ChainKind.Btc) txHash = typeof window !== "undefined" ? transfer.utxo_transfer?.btc_pending_id : transfer.finalised?.UtxoLog?.transaction_hash;
-			else return { hash: null };
-			if (!txHash) throw new OmniTransferDestinationChainHashNotFoundError(args.tx.hash, ChainKind[destinationChain].toLowerCase());
-			return { hash: txHash };
-		}, {
-			...args.retryOptions ?? RETRY_CONFIGS.FIVE_MINS_STEADY,
-			handleError: (err, ctx) => {
-				if (err === args.signal?.reason) ctx.abort();
-			}
-		});
+	createWithdrawalIdentifier(args) {
+		const assetInfo = this.makeAssetInfo(args.withdrawalParams.assetId, args.withdrawalParams.routeConfig);
+		assert(assetInfo !== null, `Asset ${args.withdrawalParams.assetId} is not supported by Omni Bridge`);
+		return {
+			landingChain: args.withdrawalParams.routeConfig != null && "chain" in args.withdrawalParams.routeConfig && args.withdrawalParams.routeConfig.chain !== void 0 ? args.withdrawalParams.routeConfig.chain : assetInfo.blockchain,
+			index: args.index,
+			withdrawalParams: args.withdrawalParams,
+			tx: args.tx
+		};
+	}
+	async describeWithdrawal(args) {
+		const transfer = (await this.omniBridgeAPI.getTransfer({ transactionHash: args.tx.hash }))[args.index];
+		if (transfer == null || transfer.transfer_message == null) return { status: "pending" };
+		const destinationChain = getChain(transfer.transfer_message.recipient);
+		let txHash = null;
+		if (isEvmChain(destinationChain)) txHash = transfer.finalised?.EVMLog?.transaction_hash;
+		else if (destinationChain === ChainKind.Sol) txHash = transfer.finalised?.Solana?.signature;
+		else if (destinationChain === ChainKind.Btc) txHash = typeof window !== "undefined" ? transfer.utxo_transfer?.btc_pending_id : transfer.finalised?.UtxoLog?.transaction_hash;
+		else return {
+			status: "completed",
+			txHash: null
+		};
+		if (!txHash) return { status: "pending" };
+		return {
+			status: "completed",
+			txHash
+		};
 	}
 	/**
 	* Gets storage deposit for a token to avoid frequent RPC calls.
@@ -290,6 +301,13 @@ var OmniBridge = class {
 		if (tokenDecimals !== null) this.tokenDecimalsCache.set(omniAddress$1, tokenDecimals);
 		return tokenDecimals;
 	}
+	/**
+	* Checks if passed token contract id is an allowlisted PoA token that should be routed via OmniBridge.
+	* Always return false when feature flag routeMigratedPoaTokensThroughOmniBridge = false.
+	*/
+	isPoaTokenRoutedThroughOmniBridge(nearAddress) {
+		return this.routeMigratedPoaTokensThroughOmniBridge ? POA_TOKENS_ROUTABLE_THROUGH_OMNI_BRIDGE[nearAddress] !== void 0 : false;
+	}
 };
 
 //#endregion

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

@@ -1,11 +1,11 @@
 const require_rolldown_runtime = require('../../../_virtual/rolldown_runtime.cjs');
 const require_caip2 = require('../../lib/caip2.cjs');
 const require_poa_constants = require('./poa-constants.cjs');
-let __defuse_protocol_internal_utils = require("@defuse-protocol/internal-utils");
+let _defuse_protocol_internal_utils = require("@defuse-protocol/internal-utils");
 
 //#region src/bridges/poa-bridge/poa-bridge-utils.ts
 function createWithdrawIntentPrimitive(params) {
-	const { contractId: tokenAccountId } = __defuse_protocol_internal_utils.utils.parseDefuseAssetId(params.assetId);
+	const { contractId: tokenAccountId } = _defuse_protocol_internal_utils.utils.parseDefuseAssetId(params.assetId);
 	return {
 		intent: "ft_withdraw",
 		token: tokenAccountId,

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

@@ -1,33 +1,38 @@
 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_estimate_fee = require('../../lib/estimate-fee.cjs');
-const require_errors = require('../../classes/errors.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_poa_tokens_routable_through_omni_bridge = require('../../constants/poa-tokens-routable-through-omni-bridge.cjs');
 const require_poa_bridge_utils = require('./poa-bridge-utils.cjs');
-let __defuse_protocol_internal_utils = require("@defuse-protocol/internal-utils");
-let __isaacs_ttlcache = require("@isaacs/ttlcache");
-__isaacs_ttlcache = require_rolldown_runtime.__toESM(__isaacs_ttlcache);
+let _defuse_protocol_internal_utils = require("@defuse-protocol/internal-utils");
+let _isaacs_ttlcache = require("@isaacs/ttlcache");
+_isaacs_ttlcache = require_rolldown_runtime.__toESM(_isaacs_ttlcache);
 
 //#region src/bridges/poa-bridge/poa-bridge.ts
 var PoaBridge = class {
-	constructor({ env }) {
-		this.supportedTokensCache = new __isaacs_ttlcache.default({ ttl: 30 * 1e3 });
+	constructor({ env, routeMigratedPoaTokensThroughOmniBridge }) {
+		this.route = require_route_enum.RouteEnum.PoaBridge;
+		this.supportedTokensCache = new _isaacs_ttlcache.default({ ttl: 30 * 1e3 });
 		this.env = env;
+		this.routeMigratedPoaTokensThroughOmniBridge = routeMigratedPoaTokensThroughOmniBridge ?? false;
 	}
 	is(routeConfig) {
 		return routeConfig.route === require_route_enum.RouteEnum.PoaBridge;
 	}
 	async supports(params) {
 		if (params.routeConfig != null && !this.is(params.routeConfig)) return false;
-		const isValid = this.parseAssetId(params.assetId) != null;
+		const assetInfo = this.parseAssetId(params.assetId);
+		const isValid = assetInfo != null;
 		if (!isValid && params.routeConfig != null) throw new require_errors.UnsupportedAssetIdError(params.assetId, "`assetId` does not match `routeConfig`.");
+		if (this.routeMigratedPoaTokensThroughOmniBridge && assetInfo != null && require_poa_tokens_routable_through_omni_bridge.POA_TOKENS_ROUTABLE_THROUGH_OMNI_BRIDGE[assetInfo.contractId] !== void 0 && params.routeConfig === void 0) return false;
 		return isValid;
 	}
 	parseAssetId(assetId) {
 		const parsed = require_parse_defuse_asset_id.parseDefuseAssetId(assetId);
-		if (!parsed.contractId.endsWith(`.${__defuse_protocol_internal_utils.configsByEnvironment[this.env].poaTokenFactoryContractID}`)) return null;
+		if (!parsed.contractId.endsWith(`.${_defuse_protocol_internal_utils.configsByEnvironment[this.env].poaTokenFactoryContractID}`)) return null;
 		let blockchain;
 		try {
 			blockchain = require_poa_bridge_utils.contractIdToCaip2(parsed.contractId);
@@ -42,7 +47,7 @@ var PoaBridge = class {
 	}
 	createWithdrawalIntents(args) {
 		const relayerFee = require_estimate_fee.getUnderlyingFee(args.feeEstimation, require_route_enum.RouteEnum.PoaBridge, "relayerFee");
-		(0, __defuse_protocol_internal_utils.assert)(relayerFee > 0n, `Invalid POA bridge relayer fee: expected > 0, got ${relayerFee}`);
+		(0, _defuse_protocol_internal_utils.assert)(relayerFee > 0n, `Invalid POA bridge relayer fee: expected > 0, got ${relayerFee}`);
 		const intent = require_poa_bridge_utils.createWithdrawIntentPrimitive({
 			...args.withdrawalParams,
 			amount: args.withdrawalParams.amount + relayerFee,
@@ -58,7 +63,7 @@ var PoaBridge = class {
 	*/
 	async validateWithdrawal(args) {
 		const assetInfo = this.parseAssetId(args.assetId);
-		(0, __defuse_protocol_internal_utils.assert)(assetInfo != null, "Asset is not supported");
+		(0, _defuse_protocol_internal_utils.assert)(assetInfo != null, "Asset is not supported");
 		if (require_validateAddress.validateAddress(args.destinationAddress, assetInfo.blockchain) === false) throw new require_errors.InvalidDestinationAddressForWithdrawalError(args.destinationAddress, assetInfo.blockchain);
 		const { tokens } = await this.getCachedSupportedTokens([require_poa_bridge_utils.toPoaNetwork(assetInfo.blockchain)], args.logger);
 		const tokenInfo = tokens.find((token) => token.intents_token_id === args.assetId);
@@ -69,32 +74,59 @@ var PoaBridge = class {
 	}
 	async estimateWithdrawalFee(args) {
 		const assetInfo = this.parseAssetId(args.withdrawalParams.assetId);
-		(0, __defuse_protocol_internal_utils.assert)(assetInfo != null, "Asset is not supported");
-		const estimation = await __defuse_protocol_internal_utils.poaBridge.httpClient.getWithdrawalEstimate({
-			token: __defuse_protocol_internal_utils.utils.getTokenAccountId(args.withdrawalParams.assetId),
+		(0, _defuse_protocol_internal_utils.assert)(assetInfo != null, "Asset is not supported");
+		const estimation = await _defuse_protocol_internal_utils.poaBridge.httpClient.getWithdrawalEstimate({
+			token: _defuse_protocol_internal_utils.utils.getTokenAccountId(args.withdrawalParams.assetId),
 			address: args.withdrawalParams.destinationAddress,
 			chain: require_poa_bridge_utils.toPoaNetwork(assetInfo.blockchain)
 		}, {
-			baseURL: __defuse_protocol_internal_utils.configsByEnvironment[this.env].poaBridgeBaseURL,
+			baseURL: _defuse_protocol_internal_utils.configsByEnvironment[this.env].poaBridgeBaseURL,
 			logger: args.logger
 		});
 		const relayerFee = BigInt(estimation.withdrawalFee);
-		(0, __defuse_protocol_internal_utils.assert)(relayerFee > 0n, `Invalid POA bridge relayer fee: expected > 0, got ${relayerFee}`);
+		(0, _defuse_protocol_internal_utils.assert)(relayerFee > 0n, `Invalid POA bridge relayer fee: expected > 0, got ${relayerFee}`);
 		return {
 			amount: relayerFee,
 			quote: null,
 			underlyingFees: { [require_route_enum.RouteEnum.PoaBridge]: { relayerFee } }
 		};
 	}
-	async waitForWithdrawalCompletion(args) {
-		return { hash: (await __defuse_protocol_internal_utils.poaBridge.waitForWithdrawalCompletion({
-			txHash: args.tx.hash,
-			withdrawalCriteria: { assetId: args.withdrawalParams.assetId },
-			signal: args.signal ?? new AbortController().signal,
-			retryOptions: args.retryOptions,
-			baseURL: __defuse_protocol_internal_utils.configsByEnvironment[this.env].poaBridgeBaseURL,
-			logger: args.logger
-		})).destinationTxHash };
+	createWithdrawalIdentifier(args) {
+		const assetInfo = this.parseAssetId(args.withdrawalParams.assetId);
+		(0, _defuse_protocol_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 withdrawal = findMatchingWithdrawal((await this.getWithdrawalStatusWithRetry(args)).withdrawals, args.withdrawalParams.assetId);
+		if (withdrawal == null) return { status: "pending" };
+		if (withdrawal.status === "PENDING") return { status: "pending" };
+		if (withdrawal.status === "COMPLETED") return {
+			status: "completed",
+			txHash: withdrawal.data.transfer_tx_hash
+		};
+		return {
+			status: "failed",
+			reason: withdrawal.status
+		};
+	}
+	async getWithdrawalStatusWithRetry(args) {
+		const startTime = Date.now();
+		while (true) try {
+			return await _defuse_protocol_internal_utils.poaBridge.httpClient.getWithdrawalStatus({ withdrawal_hash: args.tx.hash }, {
+				baseURL: _defuse_protocol_internal_utils.configsByEnvironment[this.env].poaBridgeBaseURL,
+				logger: args.logger
+			});
+		} catch (err) {
+			if (!isWithdrawalNotFoundError(err)) throw err;
+			if (Date.now() - startTime >= NOT_FOUND_RETRY_TIMEOUT_MS) return { withdrawals: [] };
+			args.logger?.warn("Withdrawal not indexed yet, retrying...");
+			await sleep(NOT_FOUND_RETRY_INTERVAL_MS);
+		}
 	}
 	/**
 	* Gets supported tokens with caching to avoid frequent API calls.
@@ -104,14 +136,35 @@ var PoaBridge = class {
 		const cacheKey = chains.sort().join(",");
 		const cached = this.supportedTokensCache.get(cacheKey);
 		if (cached != null) return cached;
-		const data = await __defuse_protocol_internal_utils.poaBridge.httpClient.getSupportedTokens({ chains }, {
-			baseURL: __defuse_protocol_internal_utils.configsByEnvironment[this.env].poaBridgeBaseURL,
+		const data = await _defuse_protocol_internal_utils.poaBridge.httpClient.getSupportedTokens({ chains }, {
+			baseURL: _defuse_protocol_internal_utils.configsByEnvironment[this.env].poaBridgeBaseURL,
 			logger
 		});
 		this.supportedTokensCache.set(cacheKey, data);
 		return data;
 	}
 };
+/**
+* Finds a withdrawal matching the given assetId.
+*
+* NOTE: Currently only matches by assetId. This means multiple withdrawals
+* of the same token in a single transaction are not supported.
+* POA API doesn't currently support this case either. When support is added,
+* matching could be done by sorting both API results and withdrawal params by
+* amount (fees are equal for same token, so relative ordering is preserved).
+*/
+function findMatchingWithdrawal(withdrawals, assetId) {
+	return withdrawals.find((w) => `nep141:${w.data.near_token_id}` === assetId);
+}
+const NOT_FOUND_RETRY_TIMEOUT_MS = 3 * 1e3;
+const NOT_FOUND_RETRY_INTERVAL_MS = 1e3;
+const RPC_ERR_MSG_WITHDRAWALS_NOT_FOUND = "Withdrawals not found";
+function isWithdrawalNotFoundError(err) {
+	return err instanceof _defuse_protocol_internal_utils.RpcRequestError && err.details === RPC_ERR_MSG_WITHDRAWALS_NOT_FOUND;
+}
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
 
 //#endregion
 exports.PoaBridge = PoaBridge;

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

@@ -1,26 +1,31 @@
+import { InvalidDestinationAddressForWithdrawalError, MinWithdrawalAmountError, UnsupportedAssetIdError } from "../../classes/errors.js";
 import { RouteEnum } from "../../constants/route-enum.js";
 import { getUnderlyingFee } from "../../lib/estimate-fee.js";
-import { InvalidDestinationAddressForWithdrawalError, MinWithdrawalAmountError, UnsupportedAssetIdError } from "../../classes/errors.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 { POA_TOKENS_ROUTABLE_THROUGH_OMNI_BRIDGE } from "../../constants/poa-tokens-routable-through-omni-bridge.js";
 import { contractIdToCaip2, createWithdrawIntentPrimitive, toPoaNetwork } from "./poa-bridge-utils.js";
-import { assert, configsByEnvironment, poaBridge, utils } from "@defuse-protocol/internal-utils";
+import { RpcRequestError, assert, configsByEnvironment, poaBridge, utils } from "@defuse-protocol/internal-utils";
 import TTLCache from "@isaacs/ttlcache";
 
 //#region src/bridges/poa-bridge/poa-bridge.ts
 var PoaBridge = class {
-	constructor({ env }) {
+	constructor({ env, routeMigratedPoaTokensThroughOmniBridge }) {
+		this.route = RouteEnum.PoaBridge;
 		this.supportedTokensCache = new TTLCache({ ttl: 30 * 1e3 });
 		this.env = env;
+		this.routeMigratedPoaTokensThroughOmniBridge = routeMigratedPoaTokensThroughOmniBridge ?? false;
 	}
 	is(routeConfig) {
 		return routeConfig.route === RouteEnum.PoaBridge;
 	}
 	async supports(params) {
 		if (params.routeConfig != null && !this.is(params.routeConfig)) return false;
-		const isValid = this.parseAssetId(params.assetId) != null;
+		const assetInfo = this.parseAssetId(params.assetId);
+		const isValid = assetInfo != null;
 		if (!isValid && params.routeConfig != null) throw new UnsupportedAssetIdError(params.assetId, "`assetId` does not match `routeConfig`.");
+		if (this.routeMigratedPoaTokensThroughOmniBridge && assetInfo != null && POA_TOKENS_ROUTABLE_THROUGH_OMNI_BRIDGE[assetInfo.contractId] !== void 0 && params.routeConfig === void 0) return false;
 		return isValid;
 	}
 	parseAssetId(assetId) {
@@ -84,15 +89,42 @@ var PoaBridge = class {
 			underlyingFees: { [RouteEnum.PoaBridge]: { relayerFee } }
 		};
 	}
-	async waitForWithdrawalCompletion(args) {
-		return { hash: (await poaBridge.waitForWithdrawalCompletion({
-			txHash: args.tx.hash,
-			withdrawalCriteria: { assetId: args.withdrawalParams.assetId },
-			signal: args.signal ?? new AbortController().signal,
-			retryOptions: args.retryOptions,
-			baseURL: configsByEnvironment[this.env].poaBridgeBaseURL,
-			logger: args.logger
-		})).destinationTxHash };
+	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 withdrawal = findMatchingWithdrawal((await this.getWithdrawalStatusWithRetry(args)).withdrawals, args.withdrawalParams.assetId);
+		if (withdrawal == null) return { status: "pending" };
+		if (withdrawal.status === "PENDING") return { status: "pending" };
+		if (withdrawal.status === "COMPLETED") return {
+			status: "completed",
+			txHash: withdrawal.data.transfer_tx_hash
+		};
+		return {
+			status: "failed",
+			reason: withdrawal.status
+		};
+	}
+	async getWithdrawalStatusWithRetry(args) {
+		const startTime = Date.now();
+		while (true) try {
+			return await poaBridge.httpClient.getWithdrawalStatus({ withdrawal_hash: args.tx.hash }, {
+				baseURL: configsByEnvironment[this.env].poaBridgeBaseURL,
+				logger: args.logger
+			});
+		} catch (err) {
+			if (!isWithdrawalNotFoundError(err)) throw err;
+			if (Date.now() - startTime >= NOT_FOUND_RETRY_TIMEOUT_MS) return { withdrawals: [] };
+			args.logger?.warn("Withdrawal not indexed yet, retrying...");
+			await sleep(NOT_FOUND_RETRY_INTERVAL_MS);
+		}
 	}
 	/**
 	* Gets supported tokens with caching to avoid frequent API calls.
@@ -110,6 +142,27 @@ var PoaBridge = class {
 		return data;
 	}
 };
+/**
+* Finds a withdrawal matching the given assetId.
+*
+* NOTE: Currently only matches by assetId. This means multiple withdrawals
+* of the same token in a single transaction are not supported.
+* POA API doesn't currently support this case either. When support is added,
+* matching could be done by sorting both API results and withdrawal params by
+* amount (fees are equal for same token, so relative ordering is preserved).
+*/
+function findMatchingWithdrawal(withdrawals, assetId) {
+	return withdrawals.find((w) => `nep141:${w.data.near_token_id}` === assetId);
+}
+const NOT_FOUND_RETRY_TIMEOUT_MS = 3 * 1e3;
+const NOT_FOUND_RETRY_INTERVAL_MS = 1e3;
+const RPC_ERR_MSG_WITHDRAWALS_NOT_FOUND = "Withdrawals not found";
+function isWithdrawalNotFoundError(err) {
+	return err instanceof RpcRequestError && err.details === RPC_ERR_MSG_WITHDRAWALS_NOT_FOUND;
+}
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
 
 //#endregion
 export { PoaBridge };

package/dist/src/classes/errors.cjs

@@ -1,8 +1,8 @@
 const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
-let __defuse_protocol_internal_utils = require("@defuse-protocol/internal-utils");
+let _defuse_protocol_internal_utils = require("@defuse-protocol/internal-utils");
 
 //#region src/classes/errors.ts
-var FeeExceedsAmountError = class extends __defuse_protocol_internal_utils.BaseError {
+var FeeExceedsAmountError = class extends _defuse_protocol_internal_utils.BaseError {
 	constructor(feeEstimation, amount) {
 		super("Amount too small to pay fee.", {
 			metaMessages: [`Required fee: ${feeEstimation.amount}`, `Withdrawal amount: ${amount}`],
@@ -12,7 +12,7 @@ var FeeExceedsAmountError = class extends __defuse_protocol_internal_utils.BaseE
 		this.amount = amount;
 	}
 };
-var MinWithdrawalAmountError = class extends __defuse_protocol_internal_utils.BaseError {
+var MinWithdrawalAmountError = class extends _defuse_protocol_internal_utils.BaseError {
 	constructor(minAmount, requestedAmount, assetId) {
 		super("Withdrawal amount is below minimum required by the bridge.", {
 			metaMessages: [
@@ -27,7 +27,7 @@ var MinWithdrawalAmountError = class extends __defuse_protocol_internal_utils.Ba
 		this.assetId = assetId;
 	}
 };
-var UnsupportedDestinationMemoError = class extends __defuse_protocol_internal_utils.BaseError {
+var UnsupportedDestinationMemoError = class extends _defuse_protocol_internal_utils.BaseError {
 	constructor(blockchain, assetId) {
 		super("Destination memo is not supported for this blockchain.", {
 			details: "Destination memo is only supported for XRP Ledger withdrawals.",
@@ -38,7 +38,7 @@ var UnsupportedDestinationMemoError = class extends __defuse_protocol_internal_u
 		this.assetId = assetId;
 	}
 };
-var TrustlineNotFoundError = class extends __defuse_protocol_internal_utils.BaseError {
+var TrustlineNotFoundError = class extends _defuse_protocol_internal_utils.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.",
@@ -56,7 +56,7 @@ var TrustlineNotFoundError = class extends __defuse_protocol_internal_utils.Base
 		this.tokenAddress = tokenAddress;
 	}
 };
-var UnsupportedAssetIdError = class extends __defuse_protocol_internal_utils.BaseError {
+var UnsupportedAssetIdError = class extends _defuse_protocol_internal_utils.BaseError {
 	constructor(assetId, details) {
 		super("Asset ID is not supported.", {
 			details,
@@ -66,7 +66,7 @@ var UnsupportedAssetIdError = class extends __defuse_protocol_internal_utils.Bas
 		this.assetId = assetId;
 	}
 };
-var InvalidDestinationAddressForWithdrawalError = class extends __defuse_protocol_internal_utils.BaseError {
+var InvalidDestinationAddressForWithdrawalError = class extends _defuse_protocol_internal_utils.BaseError {
 	constructor(destinationAddress, destinationChain) {
 		super(`Invalid destination address.`, {
 			metaMessages: [`Destination address: ${destinationAddress}`, `Destination chain: ${destinationChain}`],

package/dist/src/constants/poa-tokens-routable-through-omni-bridge.cjs

@@ -0,0 +1,17 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+let omni_bridge_sdk = require("omni-bridge-sdk");
+
+//#region src/constants/poa-tokens-routable-through-omni-bridge.ts
+/**
+* These tokens can be routed through either PoA Bridge or Omni Bridge
+* depending on the SDK configuration. Use the `routeMigratedPoaTokensThroughOmniBridge`
+* feature flag to enable Omni Bridge routing for these tokens.
+*/
+const POA_TOKENS_ROUTABLE_THROUGH_OMNI_BRIDGE = {
+	"sol-57d087fd8c460f612f8701f5499ad8b2eec5ab68.omft.near": omni_bridge_sdk.ChainKind.Sol,
+	"sol-c58e6539c2f2e097c251f8edf11f9c03e581f8d4.omft.near": omni_bridge_sdk.ChainKind.Sol,
+	"sol-b9c68f94ec8fd160137af8cdfe5e61cd68e2afba.omft.near": omni_bridge_sdk.ChainKind.Sol
+};
+
+//#endregion
+exports.POA_TOKENS_ROUTABLE_THROUGH_OMNI_BRIDGE = POA_TOKENS_ROUTABLE_THROUGH_OMNI_BRIDGE;

package/dist/src/constants/poa-tokens-routable-through-omni-bridge.d.cts

@@ -0,0 +1,12 @@
+import { ChainKind } from "omni-bridge-sdk";
+
+//#region src/constants/poa-tokens-routable-through-omni-bridge.d.ts
+
+/**
+ * These tokens can be routed through either PoA Bridge or Omni Bridge
+ * depending on the SDK configuration. Use the `routeMigratedPoaTokensThroughOmniBridge`
+ * feature flag to enable Omni Bridge routing for these tokens.
+ */
+declare const POA_TOKENS_ROUTABLE_THROUGH_OMNI_BRIDGE: Record<string, ChainKind>;
+//#endregion
+export { POA_TOKENS_ROUTABLE_THROUGH_OMNI_BRIDGE };

package/dist/src/constants/poa-tokens-routable-through-omni-bridge.d.ts

@@ -0,0 +1,12 @@
+import { ChainKind } from "omni-bridge-sdk";
+
+//#region src/constants/poa-tokens-routable-through-omni-bridge.d.ts
+
+/**
+ * These tokens can be routed through either PoA Bridge or Omni Bridge
+ * depending on the SDK configuration. Use the `routeMigratedPoaTokensThroughOmniBridge`
+ * feature flag to enable Omni Bridge routing for these tokens.
+ */
+declare const POA_TOKENS_ROUTABLE_THROUGH_OMNI_BRIDGE: Record<string, ChainKind>;
+//#endregion
+export { POA_TOKENS_ROUTABLE_THROUGH_OMNI_BRIDGE };

package/dist/src/constants/poa-tokens-routable-through-omni-bridge.js

@@ -0,0 +1,16 @@
+import { ChainKind } from "omni-bridge-sdk";
+
+//#region src/constants/poa-tokens-routable-through-omni-bridge.ts
+/**
+* These tokens can be routed through either PoA Bridge or Omni Bridge
+* depending on the SDK configuration. Use the `routeMigratedPoaTokensThroughOmniBridge`
+* feature flag to enable Omni Bridge routing for these tokens.
+*/
+const POA_TOKENS_ROUTABLE_THROUGH_OMNI_BRIDGE = {
+	"sol-57d087fd8c460f612f8701f5499ad8b2eec5ab68.omft.near": ChainKind.Sol,
+	"sol-c58e6539c2f2e097c251f8edf11f9c03e581f8d4.omft.near": ChainKind.Sol,
+	"sol-b9c68f94ec8fd160137af8cdfe5e61cd68e2afba.omft.near": ChainKind.Sol
+};
+
+//#endregion
+export { POA_TOKENS_ROUTABLE_THROUGH_OMNI_BRIDGE };

package/dist/src/constants/withdrawal-timing.cjs

@@ -0,0 +1,57 @@
+
+//#region src/constants/withdrawal-timing.ts
+/**
+* Withdrawal timing p99 values (in seconds) by CAIP-2 chain identifier.
+* Used to derive CompletionStats for chain-aware polling.
+*/
+const WITHDRAWAL_P99_BY_CHAIN = {
+	"eip155:1": 1852,
+	"eip155:56": 36,
+	"solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp": 1387,
+	"eip155:8453": 651,
+	"tron:27Lqcw": 2358,
+	"eip155:42161": 928,
+	"bip122:000000000019d6689c085ae165831e93": 3656,
+	"eip155:137": 410,
+	"xrpl:0": 2276,
+	"bip122:00040fe8ec8471911baa1db1266ea15d": 2093,
+	"tvm:-239": 53,
+	"near:mainnet": 356,
+	"bip122:12a765e31ffd4059bada1e25190f6e98": 2385,
+	"eip155:143": 22,
+	"eip155:43114": 657,
+	"stellar:pubnet": 50,
+	"eip155:10": 23,
+	"bip122:1a91e3dace36e2be3bf030a65679fe82": 1970,
+	"sui:mainnet": 752,
+	"eip155:80085": 579,
+	"eip155:100": 3308,
+	"aptos:mainnet": 394,
+	"cip34:1-764824073": 807
+};
+/**
+* Default stats for chains without timing data.
+* Conservative 2-hour timeout with gradual phase transitions.
+*/
+const DEFAULT_WITHDRAWAL_STATS = {
+	p50: 6e4,
+	p90: 6e5,
+	p99: 72e5
+};
+/**
+* Returns CompletionStats for the given chain.
+* Derives p50/p90 from p99 using reasonable ratios with minimum floors.
+*/
+function getWithdrawalStatsForChain(caip2) {
+	const p99Seconds = WITHDRAWAL_P99_BY_CHAIN[caip2];
+	if (p99Seconds == null) return DEFAULT_WITHDRAWAL_STATS;
+	const p99 = p99Seconds * 1e3;
+	return {
+		p50: Math.max(5e3, p99 * .15),
+		p90: Math.max(3e4, p99 * .5),
+		p99
+	};
+}
+
+//#endregion
+exports.getWithdrawalStatsForChain = getWithdrawalStatsForChain;