@defuse-protocol/intents-sdk 0.43.3 → 0.45.0

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/public-rpc-urls.cjs

@@ -11,7 +11,9 @@ const PUBLIC_EVM_RPC_URLS = {
 	[require_caip2.Chains.Optimism]: ["https://optimism-rpc.publicnode.com"],
 	[require_caip2.Chains.Avalanche]: ["https://avalanche-c-chain-rpc.publicnode.com"],
 	[require_caip2.Chains.LayerX]: ["https://rpc.xlayer.tech"],
-	[require_caip2.Chains.Adi]: ["https://rpc.adifoundation.ai"]
+	[require_caip2.Chains.Adi]: ["https://rpc.adifoundation.ai"],
+	[require_caip2.Chains.Plasma]: ["https://rpc.plasma.to"],
+	[require_caip2.Chains.Scroll]: ["https://rpc.scroll.io"]
 };
 const PUBLIC_STELLAR_RPC_URLS = {
 	soroban: ["https://mainnet.sorobanrpc.com"],

package/dist/src/constants/public-rpc-urls.js

@@ -11,7 +11,9 @@ const PUBLIC_EVM_RPC_URLS = {
 	[Chains.Optimism]: ["https://optimism-rpc.publicnode.com"],
 	[Chains.Avalanche]: ["https://avalanche-c-chain-rpc.publicnode.com"],
 	[Chains.LayerX]: ["https://rpc.xlayer.tech"],
-	[Chains.Adi]: ["https://rpc.adifoundation.ai"]
+	[Chains.Adi]: ["https://rpc.adifoundation.ai"],
+	[Chains.Plasma]: ["https://rpc.plasma.to"],
+	[Chains.Scroll]: ["https://rpc.scroll.io"]
 };
 const PUBLIC_STELLAR_RPC_URLS = {
 	soroban: ["https://mainnet.sorobanrpc.com"],

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;

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

@@ -0,0 +1,56 @@
+//#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
+export { getWithdrawalStatsForChain };

package/dist/src/core/withdrawal-watcher.cjs

@@ -0,0 +1,83 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+const require_withdrawal_timing = require('../constants/withdrawal-timing.cjs');
+let _defuse_protocol_internal_utils = require("@defuse-protocol/internal-utils");
+
+//#region src/core/withdrawal-watcher.ts
+const MAX_CONSECUTIVE_ERRORS = 3;
+async function watchWithdrawal(args) {
+	const stats = require_withdrawal_timing.getWithdrawalStatsForChain(args.wid.landingChain);
+	let consecutiveErrors = 0;
+	try {
+		return await (0, _defuse_protocol_internal_utils.poll)(async () => {
+			try {
+				const status = await args.bridge.describeWithdrawal({
+					...args.wid,
+					logger: args.logger
+				});
+				consecutiveErrors = 0;
+				if (status.status === "completed") return status.txHash != null ? { hash: status.txHash } : { hash: null };
+				if (status.status === "failed") throw new WithdrawalFailedError(status.reason);
+				return _defuse_protocol_internal_utils.POLL_PENDING;
+			} catch (err) {
+				if (err instanceof WithdrawalFailedError) throw err;
+				consecutiveErrors++;
+				if (consecutiveErrors >= MAX_CONSECUTIVE_ERRORS) throw new WithdrawalWatchError(err);
+				args.logger?.warn(`Transient error (${consecutiveErrors}/${MAX_CONSECUTIVE_ERRORS}): ${err}`);
+				return _defuse_protocol_internal_utils.POLL_PENDING;
+			}
+		}, {
+			stats,
+			signal: args.signal
+		});
+	} catch (err) {
+		if (err instanceof _defuse_protocol_internal_utils.PollTimeoutError) throw new WithdrawalWatchError(err);
+		throw err;
+	}
+}
+async function createWithdrawalIdentifiers(args) {
+	const indexes = /* @__PURE__ */ new Map();
+	const results = [];
+	for (const w of args.withdrawalParams) {
+		const bridge = await findBridgeForWithdrawal(args.bridges, w);
+		if (bridge == null) throw new BridgeNotFoundError();
+		const currentIndex = indexes.get(bridge.route) ?? 0;
+		indexes.set(bridge.route, currentIndex + 1);
+		const wid = bridge.createWithdrawalIdentifier({
+			withdrawalParams: w,
+			index: currentIndex,
+			tx: args.intentTx
+		});
+		results.push({
+			bridge,
+			wid
+		});
+	}
+	return results;
+}
+async function findBridgeForWithdrawal(bridges, params) {
+	for (const bridge of bridges) if (await bridge.supports(params)) return bridge;
+}
+var BridgeNotFoundError = class extends _defuse_protocol_internal_utils.BaseError {
+	constructor() {
+		super("Bridge adapter not found", { name: "BridgeNotFoundError" });
+	}
+};
+var WithdrawalFailedError = class extends _defuse_protocol_internal_utils.BaseError {
+	constructor(reason) {
+		super(`Withdrawal failed: ${reason}`, { name: "WithdrawalFailedError" });
+	}
+};
+var WithdrawalWatchError = class extends _defuse_protocol_internal_utils.BaseError {
+	constructor(cause) {
+		super("Withdrawal watch failed", {
+			name: "WithdrawalWatchError",
+			cause
+		});
+	}
+};
+
+//#endregion
+exports.WithdrawalFailedError = WithdrawalFailedError;
+exports.WithdrawalWatchError = WithdrawalWatchError;
+exports.createWithdrawalIdentifiers = createWithdrawalIdentifiers;
+exports.watchWithdrawal = watchWithdrawal;

package/dist/src/core/withdrawal-watcher.d.cts

@@ -0,0 +1,18 @@
+import { BaseError, ILogger } from "@defuse-protocol/internal-utils";
+
+//#region src/core/withdrawal-watcher.d.ts
+
+type WithdrawalFailedErrorType = WithdrawalFailedError & {
+  name: "WithdrawalFailedError";
+};
+declare class WithdrawalFailedError extends BaseError {
+  constructor(reason: string);
+}
+type WithdrawalWatchErrorType = WithdrawalWatchError & {
+  name: "WithdrawalWatchError";
+};
+declare class WithdrawalWatchError extends BaseError {
+  constructor(cause: unknown);
+}
+//#endregion
+export { WithdrawalFailedError, WithdrawalFailedErrorType, WithdrawalWatchError, WithdrawalWatchErrorType };

package/dist/src/core/withdrawal-watcher.d.ts

@@ -0,0 +1,18 @@
+import { BaseError, ILogger } from "@defuse-protocol/internal-utils";
+
+//#region src/core/withdrawal-watcher.d.ts
+
+type WithdrawalFailedErrorType = WithdrawalFailedError & {
+  name: "WithdrawalFailedError";
+};
+declare class WithdrawalFailedError extends BaseError {
+  constructor(reason: string);
+}
+type WithdrawalWatchErrorType = WithdrawalWatchError & {
+  name: "WithdrawalWatchError";
+};
+declare class WithdrawalWatchError extends BaseError {
+  constructor(cause: unknown);
+}
+//#endregion
+export { WithdrawalFailedError, WithdrawalFailedErrorType, WithdrawalWatchError, WithdrawalWatchErrorType };

package/dist/src/core/withdrawal-watcher.js

@@ -0,0 +1,79 @@
+import { getWithdrawalStatsForChain } from "../constants/withdrawal-timing.js";
+import { BaseError, POLL_PENDING, PollTimeoutError, poll } from "@defuse-protocol/internal-utils";
+
+//#region src/core/withdrawal-watcher.ts
+const MAX_CONSECUTIVE_ERRORS = 3;
+async function watchWithdrawal(args) {
+	const stats = getWithdrawalStatsForChain(args.wid.landingChain);
+	let consecutiveErrors = 0;
+	try {
+		return await poll(async () => {
+			try {
+				const status = await args.bridge.describeWithdrawal({
+					...args.wid,
+					logger: args.logger
+				});
+				consecutiveErrors = 0;
+				if (status.status === "completed") return status.txHash != null ? { hash: status.txHash } : { hash: null };
+				if (status.status === "failed") throw new WithdrawalFailedError(status.reason);
+				return POLL_PENDING;
+			} catch (err) {
+				if (err instanceof WithdrawalFailedError) throw err;
+				consecutiveErrors++;
+				if (consecutiveErrors >= MAX_CONSECUTIVE_ERRORS) throw new WithdrawalWatchError(err);
+				args.logger?.warn(`Transient error (${consecutiveErrors}/${MAX_CONSECUTIVE_ERRORS}): ${err}`);
+				return POLL_PENDING;
+			}
+		}, {
+			stats,
+			signal: args.signal
+		});
+	} catch (err) {
+		if (err instanceof PollTimeoutError) throw new WithdrawalWatchError(err);
+		throw err;
+	}
+}
+async function createWithdrawalIdentifiers(args) {
+	const indexes = /* @__PURE__ */ new Map();
+	const results = [];
+	for (const w of args.withdrawalParams) {
+		const bridge = await findBridgeForWithdrawal(args.bridges, w);
+		if (bridge == null) throw new BridgeNotFoundError();
+		const currentIndex = indexes.get(bridge.route) ?? 0;
+		indexes.set(bridge.route, currentIndex + 1);
+		const wid = bridge.createWithdrawalIdentifier({
+			withdrawalParams: w,
+			index: currentIndex,
+			tx: args.intentTx
+		});
+		results.push({
+			bridge,
+			wid
+		});
+	}
+	return results;
+}
+async function findBridgeForWithdrawal(bridges, params) {
+	for (const bridge of bridges) if (await bridge.supports(params)) return bridge;
+}
+var BridgeNotFoundError = class extends BaseError {
+	constructor() {
+		super("Bridge adapter not found", { name: "BridgeNotFoundError" });
+	}
+};
+var WithdrawalFailedError = class extends BaseError {
+	constructor(reason) {
+		super(`Withdrawal failed: ${reason}`, { name: "WithdrawalFailedError" });
+	}
+};
+var WithdrawalWatchError = class extends BaseError {
+	constructor(cause) {
+		super("Withdrawal watch failed", {
+			name: "WithdrawalWatchError",
+			cause
+		});
+	}
+};
+
+//#endregion
+export { WithdrawalFailedError, WithdrawalWatchError, createWithdrawalIdentifiers, watchWithdrawal };

package/dist/src/intents/expirable-nonce.cjs

@@ -1,5 +1,5 @@
 const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
-let __scure_base = require("@scure/base");
+let _scure_base = require("@scure/base");
 let valibot = require("valibot");
 valibot = require_rolldown_runtime.__toESM(valibot);
 let near_api_js_lib_utils_serialize = require("near-api-js/lib/utils/serialize");
@@ -65,11 +65,11 @@ let VersionedNonceBuilder;
 		result.set(VERSIONED_MAGIC_PREFIX, 0);
 		result.set([LATEST_VERSION], 4);
 		result.set(borshBytes, 5);
-		return __scure_base.base64.encode(result);
+		return _scure_base.base64.encode(result);
 	}
 	_VersionedNonceBuilder.encodeNonce = encodeNonce;
 	function decodeNonce(encoded) {
-		const bytes = __scure_base.base64.decode(encoded);
+		const bytes = _scure_base.base64.decode(encoded);
 		if (bytes.length !== 32) throw new Error("Nonce too short");
 		const prefix = bytes.slice(0, 4);
 		const version = bytes[4];

package/dist/src/intents/intent-executer-impl/intent-executer.cjs

@@ -1,7 +1,7 @@
 const require_rolldown_runtime = require('../../../_virtual/rolldown_runtime.cjs');
 const require_intent_hash = require('../intent-hash.cjs');
 const require_intent_payload_factory = require('../intent-payload-factory.cjs');
-let __defuse_protocol_internal_utils = require("@defuse-protocol/internal-utils");
+let _defuse_protocol_internal_utils = require("@defuse-protocol/internal-utils");
 
 //#region src/intents/intent-executer-impl/intent-executer.ts
 var IntentExecuter = class {
@@ -14,7 +14,7 @@ var IntentExecuter = class {
 		this.onBeforePublishIntent = args.onBeforePublishIntent;
 	}
 	async signAndSendIntent({ relayParams: relayParamsFactory, salt, signedIntents, ...intentParams }) {
-		const verifyingContract = __defuse_protocol_internal_utils.configsByEnvironment[this.env].contractID;
+		const verifyingContract = _defuse_protocol_internal_utils.configsByEnvironment[this.env].contractID;
 		let intentPayload = require_intent_payload_factory.defaultIntentPayloadFactory(salt, {
 			verifying_contract: verifyingContract,
 			...intentParams
@@ -44,8 +44,11 @@ var IntentExecuter = class {
 			...relayParams
 		}, { logger: this.logger }) };
 	}
-	async waitForSettlement(ticket) {
-		return this.intentRelayer.waitForSettlement(ticket, { logger: this.logger });
+	async waitForSettlement(ticket, ctx) {
+		return this.intentRelayer.waitForSettlement(ticket, {
+			logger: this.logger,
+			signal: ctx?.signal
+		});
 	}
 };
 async function mergeIntentPayloads(defaultPayload, intentPayloadFactory, salt) {

package/dist/src/intents/intent-executer-impl/intent-executer.js

@@ -43,8 +43,11 @@ var IntentExecuter = class {
 			...relayParams
 		}, { logger: this.logger }) };
 	}
-	async waitForSettlement(ticket) {
-		return this.intentRelayer.waitForSettlement(ticket, { logger: this.logger });
+	async waitForSettlement(ticket, ctx) {
+		return this.intentRelayer.waitForSettlement(ticket, {
+			logger: this.logger,
+			signal: ctx?.signal
+		});
 	}
 };
 async function mergeIntentPayloads(defaultPayload, intentPayloadFactory, salt) {

package/dist/src/intents/intent-hash.cjs

@@ -6,7 +6,7 @@ const require_raw_ed25519 = require('./intent-hashes/raw-ed25519.cjs');
 const require_webauthn = require('./intent-hashes/webauthn.cjs');
 const require_ton_connect = require('./intent-hashes/ton-connect.cjs');
 const require_sep53 = require('./intent-hashes/sep53.cjs');
-let __scure_base = require("@scure/base");
+let _scure_base = require("@scure/base");
 
 //#region src/intents/intent-hash.ts
 /**
@@ -41,7 +41,7 @@ async function computeIntentHashHashBytes(signed) {
 }
 async function computeIntentHash(multiPayload) {
 	const hashBytes = await computeIntentHashHashBytes(multiPayload);
-	return __scure_base.base58.encode(hashBytes);
+	return _scure_base.base58.encode(hashBytes);
 }
 
 //#endregion