lampamazaza-new-intents-sdk 0.47.1

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

@@ -0,0 +1,76 @@
+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 lampamazaza_internal_utils = require("lampamazaza-internal-utils");
+
+//#region src/bridges/poa-bridge/poa-bridge-utils.ts
+function createWithdrawIntentPrimitive(params) {
+	const { contractId: tokenAccountId } = lampamazaza_internal_utils.utils.parseDefuseAssetId(params.assetId);
+	return {
+		intent: "ft_withdraw",
+		token: tokenAccountId,
+		receiver_id: tokenAccountId,
+		amount: params.amount.toString(),
+		memo: createWithdrawMemo({
+			receiverAddress: params.destinationAddress,
+			xrpMemo: params.destinationMemo
+		}),
+		min_gas: require_poa_constants.MIN_GAS_AMOUNT
+	};
+}
+function createWithdrawMemo({ receiverAddress, xrpMemo }) {
+	const memo = ["WITHDRAW_TO", receiverAddress.toLowerCase().startsWith("bitcoincash:") ? receiverAddress.slice(12) : receiverAddress];
+	if (xrpMemo != null && xrpMemo !== "") memo.push(xrpMemo);
+	return memo.join(":");
+}
+const caip2Mapping = {
+	[require_caip2.Chains.Ethereum]: "eth:1",
+	[require_caip2.Chains.Base]: "eth:8453",
+	[require_caip2.Chains.Arbitrum]: "eth:42161",
+	[require_caip2.Chains.Bitcoin]: "btc:mainnet",
+	[require_caip2.Chains.BitcoinCash]: "bch:mainnet",
+	[require_caip2.Chains.Solana]: "sol:mainnet",
+	[require_caip2.Chains.Dogecoin]: "doge:mainnet",
+	[require_caip2.Chains.XRPL]: "xrp:mainnet",
+	[require_caip2.Chains.Zcash]: "zec:mainnet",
+	[require_caip2.Chains.Gnosis]: "eth:100",
+	[require_caip2.Chains.Berachain]: "eth:80094",
+	[require_caip2.Chains.Tron]: "tron:mainnet",
+	[require_caip2.Chains.Sui]: "sui:mainnet",
+	[require_caip2.Chains.Aptos]: "aptos:mainnet",
+	[require_caip2.Chains.Cardano]: "cardano:mainnet",
+	[require_caip2.Chains.Litecoin]: "ltc:mainnet",
+	[require_caip2.Chains.Starknet]: "starknet:mainnet"
+};
+function toPoaNetwork(caip2) {
+	if (caip2Mapping[caip2] == null) throw new Error(`Unsupported POA Bridge chain = ${caip2}`);
+	return caip2Mapping[caip2];
+}
+const tokenPrefixMapping = {
+	eth: require_caip2.Chains.Ethereum,
+	base: require_caip2.Chains.Base,
+	arb: require_caip2.Chains.Arbitrum,
+	btc: require_caip2.Chains.Bitcoin,
+	bch: require_caip2.Chains.BitcoinCash,
+	sol: require_caip2.Chains.Solana,
+	doge: require_caip2.Chains.Dogecoin,
+	xrp: require_caip2.Chains.XRPL,
+	zec: require_caip2.Chains.Zcash,
+	gnosis: require_caip2.Chains.Gnosis,
+	bera: require_caip2.Chains.Berachain,
+	tron: require_caip2.Chains.Tron,
+	sui: require_caip2.Chains.Sui,
+	aptos: require_caip2.Chains.Aptos,
+	cardano: require_caip2.Chains.Cardano,
+	ltc: require_caip2.Chains.Litecoin,
+	starknet: require_caip2.Chains.Starknet
+};
+function contractIdToCaip2(contractId) {
+	for (const [prefix, caip2] of Object.entries(tokenPrefixMapping)) if (contractId.startsWith(`${prefix}.`) || contractId.startsWith(`${prefix}-`)) return caip2;
+	throw new Error(`Unsupported POA Bridge contractId = ${contractId}`);
+}
+
+//#endregion
+exports.contractIdToCaip2 = contractIdToCaip2;
+exports.createWithdrawIntentPrimitive = createWithdrawIntentPrimitive;
+exports.toPoaNetwork = toPoaNetwork;

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

@@ -0,0 +1,73 @@
+import { Chains } from "../../lib/caip2.js";
+import { MIN_GAS_AMOUNT } from "./poa-constants.js";
+import { utils } from "lampamazaza-internal-utils";
+
+//#region src/bridges/poa-bridge/poa-bridge-utils.ts
+function createWithdrawIntentPrimitive(params) {
+	const { contractId: tokenAccountId } = utils.parseDefuseAssetId(params.assetId);
+	return {
+		intent: "ft_withdraw",
+		token: tokenAccountId,
+		receiver_id: tokenAccountId,
+		amount: params.amount.toString(),
+		memo: createWithdrawMemo({
+			receiverAddress: params.destinationAddress,
+			xrpMemo: params.destinationMemo
+		}),
+		min_gas: MIN_GAS_AMOUNT
+	};
+}
+function createWithdrawMemo({ receiverAddress, xrpMemo }) {
+	const memo = ["WITHDRAW_TO", receiverAddress.toLowerCase().startsWith("bitcoincash:") ? receiverAddress.slice(12) : receiverAddress];
+	if (xrpMemo != null && xrpMemo !== "") memo.push(xrpMemo);
+	return memo.join(":");
+}
+const caip2Mapping = {
+	[Chains.Ethereum]: "eth:1",
+	[Chains.Base]: "eth:8453",
+	[Chains.Arbitrum]: "eth:42161",
+	[Chains.Bitcoin]: "btc:mainnet",
+	[Chains.BitcoinCash]: "bch:mainnet",
+	[Chains.Solana]: "sol:mainnet",
+	[Chains.Dogecoin]: "doge:mainnet",
+	[Chains.XRPL]: "xrp:mainnet",
+	[Chains.Zcash]: "zec:mainnet",
+	[Chains.Gnosis]: "eth:100",
+	[Chains.Berachain]: "eth:80094",
+	[Chains.Tron]: "tron:mainnet",
+	[Chains.Sui]: "sui:mainnet",
+	[Chains.Aptos]: "aptos:mainnet",
+	[Chains.Cardano]: "cardano:mainnet",
+	[Chains.Litecoin]: "ltc:mainnet",
+	[Chains.Starknet]: "starknet:mainnet"
+};
+function toPoaNetwork(caip2) {
+	if (caip2Mapping[caip2] == null) throw new Error(`Unsupported POA Bridge chain = ${caip2}`);
+	return caip2Mapping[caip2];
+}
+const tokenPrefixMapping = {
+	eth: Chains.Ethereum,
+	base: Chains.Base,
+	arb: Chains.Arbitrum,
+	btc: Chains.Bitcoin,
+	bch: Chains.BitcoinCash,
+	sol: Chains.Solana,
+	doge: Chains.Dogecoin,
+	xrp: Chains.XRPL,
+	zec: Chains.Zcash,
+	gnosis: Chains.Gnosis,
+	bera: Chains.Berachain,
+	tron: Chains.Tron,
+	sui: Chains.Sui,
+	aptos: Chains.Aptos,
+	cardano: Chains.Cardano,
+	ltc: Chains.Litecoin,
+	starknet: Chains.Starknet
+};
+function contractIdToCaip2(contractId) {
+	for (const [prefix, caip2] of Object.entries(tokenPrefixMapping)) if (contractId.startsWith(`${prefix}.`) || contractId.startsWith(`${prefix}-`)) return caip2;
+	throw new Error(`Unsupported POA Bridge contractId = ${contractId}`);
+}
+
+//#endregion
+export { contractIdToCaip2, createWithdrawIntentPrimitive, toPoaNetwork };

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

@@ -0,0 +1,175 @@
+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_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 lampamazaza_internal_utils = require("lampamazaza-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({ envConfig, routeMigratedPoaTokensThroughOmniBridge }) {
+		this.route = require_route_enum.RouteEnum.PoaBridge;
+		this.supportedTokensCache = new _isaacs_ttlcache.default({ ttl: 30 * 1e3 });
+		this.envConfig = envConfig;
+		this.routeMigratedPoaTokensThroughOmniBridge = routeMigratedPoaTokensThroughOmniBridge ?? false;
+	}
+	getPoaBridgeBaseURL() {
+		if (!this.envConfig.poaBridgeBaseURL) throw new Error("POA Bridge is not available in this environment: poaBridgeBaseURL is not configured");
+		return this.envConfig.poaBridgeBaseURL;
+	}
+	is(routeConfig) {
+		return routeConfig.route === require_route_enum.RouteEnum.PoaBridge;
+	}
+	async supports(params) {
+		if (params.routeConfig != null && !this.is(params.routeConfig)) return false;
+		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) {
+		if (!this.envConfig.poaTokenFactoryContractID) return null;
+		const parsed = require_parse_defuse_asset_id.parseDefuseAssetId(assetId);
+		if (!parsed.contractId.endsWith(`.${this.envConfig.poaTokenFactoryContractID}`)) return null;
+		let blockchain;
+		try {
+			blockchain = require_poa_bridge_utils.contractIdToCaip2(parsed.contractId);
+		} catch {
+			throw new require_errors.UnsupportedAssetIdError(assetId, "Asset belongs to unknown blockchain.");
+		}
+		return Object.assign(parsed, {
+			blockchain,
+			bridgeName: require_bridge_name_enum.BridgeNameEnum.Poa,
+			address: ""
+		});
+	}
+	createWithdrawalIntents(args) {
+		const relayerFee = require_estimate_fee.getUnderlyingFee(args.feeEstimation, require_route_enum.RouteEnum.PoaBridge, "relayerFee");
+		(0, lampamazaza_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,
+			destinationMemo: args.withdrawalParams.destinationMemo
+		});
+		return Promise.resolve([intent]);
+	}
+	/**
+	* Validates minimum withdrawal amount for POA bridge tokens.
+	* Checks the bridge's supported tokens API to ensure the withdrawal amount
+	* meets the minimum required amount for the specific token and blockchain.
+	* @throws {MinWithdrawalAmountError} If the amount is below the minimum required
+	*/
+	async validateWithdrawal(args) {
+		const assetInfo = this.parseAssetId(args.assetId);
+		(0, lampamazaza_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);
+		if (tokenInfo != null) {
+			const minWithdrawalAmount = BigInt(tokenInfo.min_withdrawal_amount);
+			if (args.amount < minWithdrawalAmount) throw new require_errors.MinWithdrawalAmountError(minWithdrawalAmount, args.amount, args.assetId);
+		}
+	}
+	async estimateWithdrawalFee(args) {
+		const assetInfo = this.parseAssetId(args.withdrawalParams.assetId);
+		(0, lampamazaza_internal_utils.assert)(assetInfo != null, "Asset is not supported");
+		const estimation = await lampamazaza_internal_utils.poaBridge.httpClient.getWithdrawalEstimate({
+			token: lampamazaza_internal_utils.utils.getTokenAccountId(args.withdrawalParams.assetId),
+			address: args.withdrawalParams.destinationAddress,
+			chain: require_poa_bridge_utils.toPoaNetwork(assetInfo.blockchain)
+		}, {
+			baseURL: this.getPoaBridgeBaseURL(),
+			logger: args.logger
+		});
+		const relayerFee = BigInt(estimation.withdrawalFee);
+		(0, lampamazaza_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 } }
+		};
+	}
+	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 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 lampamazaza_internal_utils.poaBridge.httpClient.getWithdrawalStatus({ withdrawal_hash: args.tx.hash }, {
+				baseURL: this.getPoaBridgeBaseURL(),
+				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.
+	* Cache expires after 30 seconds using TTL cache.
+	*/
+	async getCachedSupportedTokens(chains, logger) {
+		const cacheKey = chains.sort().join(",");
+		const cached = this.supportedTokensCache.get(cacheKey);
+		if (cached != null) return cached;
+		const data = await lampamazaza_internal_utils.poaBridge.httpClient.getSupportedTokens({ chains }, {
+			baseURL: this.getPoaBridgeBaseURL(),
+			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 lampamazaza_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

@@ -0,0 +1,173 @@
+import { InvalidDestinationAddressForWithdrawalError, MinWithdrawalAmountError, UnsupportedAssetIdError } from "../../classes/errors.js";
+import { RouteEnum } from "../../constants/route-enum.js";
+import { 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 { 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 { RpcRequestError, assert, poaBridge, utils } from "lampamazaza-internal-utils";
+import TTLCache from "@isaacs/ttlcache";
+
+//#region src/bridges/poa-bridge/poa-bridge.ts
+var PoaBridge = class {
+	constructor({ envConfig, routeMigratedPoaTokensThroughOmniBridge }) {
+		this.route = RouteEnum.PoaBridge;
+		this.supportedTokensCache = new TTLCache({ ttl: 30 * 1e3 });
+		this.envConfig = envConfig;
+		this.routeMigratedPoaTokensThroughOmniBridge = routeMigratedPoaTokensThroughOmniBridge ?? false;
+	}
+	getPoaBridgeBaseURL() {
+		if (!this.envConfig.poaBridgeBaseURL) throw new Error("POA Bridge is not available in this environment: poaBridgeBaseURL is not configured");
+		return this.envConfig.poaBridgeBaseURL;
+	}
+	is(routeConfig) {
+		return routeConfig.route === RouteEnum.PoaBridge;
+	}
+	async supports(params) {
+		if (params.routeConfig != null && !this.is(params.routeConfig)) return false;
+		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) {
+		if (!this.envConfig.poaTokenFactoryContractID) return null;
+		const parsed = parseDefuseAssetId(assetId);
+		if (!parsed.contractId.endsWith(`.${this.envConfig.poaTokenFactoryContractID}`)) return null;
+		let blockchain;
+		try {
+			blockchain = contractIdToCaip2(parsed.contractId);
+		} catch {
+			throw new UnsupportedAssetIdError(assetId, "Asset belongs to unknown blockchain.");
+		}
+		return Object.assign(parsed, {
+			blockchain,
+			bridgeName: BridgeNameEnum.Poa,
+			address: ""
+		});
+	}
+	createWithdrawalIntents(args) {
+		const relayerFee = getUnderlyingFee(args.feeEstimation, RouteEnum.PoaBridge, "relayerFee");
+		assert(relayerFee > 0n, `Invalid POA bridge relayer fee: expected > 0, got ${relayerFee}`);
+		const intent = createWithdrawIntentPrimitive({
+			...args.withdrawalParams,
+			amount: args.withdrawalParams.amount + relayerFee,
+			destinationMemo: args.withdrawalParams.destinationMemo
+		});
+		return Promise.resolve([intent]);
+	}
+	/**
+	* Validates minimum withdrawal amount for POA bridge tokens.
+	* Checks the bridge's supported tokens API to ensure the withdrawal amount
+	* meets the minimum required amount for the specific token and blockchain.
+	* @throws {MinWithdrawalAmountError} If the amount is below the minimum required
+	*/
+	async validateWithdrawal(args) {
+		const assetInfo = this.parseAssetId(args.assetId);
+		assert(assetInfo != null, "Asset is not supported");
+		if (validateAddress(args.destinationAddress, assetInfo.blockchain) === false) throw new InvalidDestinationAddressForWithdrawalError(args.destinationAddress, assetInfo.blockchain);
+		const { tokens } = await this.getCachedSupportedTokens([toPoaNetwork(assetInfo.blockchain)], args.logger);
+		const tokenInfo = tokens.find((token) => token.intents_token_id === args.assetId);
+		if (tokenInfo != null) {
+			const minWithdrawalAmount = BigInt(tokenInfo.min_withdrawal_amount);
+			if (args.amount < minWithdrawalAmount) throw new MinWithdrawalAmountError(minWithdrawalAmount, args.amount, args.assetId);
+		}
+	}
+	async estimateWithdrawalFee(args) {
+		const assetInfo = this.parseAssetId(args.withdrawalParams.assetId);
+		assert(assetInfo != null, "Asset is not supported");
+		const estimation = await poaBridge.httpClient.getWithdrawalEstimate({
+			token: utils.getTokenAccountId(args.withdrawalParams.assetId),
+			address: args.withdrawalParams.destinationAddress,
+			chain: toPoaNetwork(assetInfo.blockchain)
+		}, {
+			baseURL: this.getPoaBridgeBaseURL(),
+			logger: args.logger
+		});
+		const relayerFee = BigInt(estimation.withdrawalFee);
+		assert(relayerFee > 0n, `Invalid POA bridge relayer fee: expected > 0, got ${relayerFee}`);
+		return {
+			amount: relayerFee,
+			quote: null,
+			underlyingFees: { [RouteEnum.PoaBridge]: { relayerFee } }
+		};
+	}
+	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: this.getPoaBridgeBaseURL(),
+				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.
+	* Cache expires after 30 seconds using TTL cache.
+	*/
+	async getCachedSupportedTokens(chains, logger) {
+		const cacheKey = chains.sort().join(",");
+		const cached = this.supportedTokensCache.get(cacheKey);
+		if (cached != null) return cached;
+		const data = await poaBridge.httpClient.getSupportedTokens({ chains }, {
+			baseURL: this.getPoaBridgeBaseURL(),
+			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 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/bridges/poa-bridge/poa-constants.cjs

@@ -0,0 +1,6 @@
+
+//#region src/bridges/poa-bridge/poa-constants.ts
+const MIN_GAS_AMOUNT = "17050000000000";
+
+//#endregion
+exports.MIN_GAS_AMOUNT = MIN_GAS_AMOUNT;

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

@@ -0,0 +1,5 @@
+//#region src/bridges/poa-bridge/poa-constants.ts
+const MIN_GAS_AMOUNT = "17050000000000";
+
+//#endregion
+export { MIN_GAS_AMOUNT };

package/dist/src/classes/errors.cjs

@@ -0,0 +1,87 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+let lampamazaza_internal_utils = require("lampamazaza-internal-utils");
+
+//#region src/classes/errors.ts
+var FeeExceedsAmountError = class extends lampamazaza_internal_utils.BaseError {
+	constructor(feeEstimation, amount) {
+		super("Amount too small to pay fee.", {
+			metaMessages: [`Required fee: ${feeEstimation.amount}`, `Withdrawal amount: ${amount}`],
+			name: "FeeExceedsAmountError"
+		});
+		this.feeEstimation = feeEstimation;
+		this.amount = amount;
+	}
+};
+var MinWithdrawalAmountError = class extends lampamazaza_internal_utils.BaseError {
+	constructor(minAmount, requestedAmount, assetId) {
+		super("Withdrawal amount is below minimum required by the bridge.", {
+			metaMessages: [
+				`Asset ID: ${assetId}`,
+				`Minimum amount: ${minAmount}`,
+				`Requested amount: ${requestedAmount}`
+			],
+			name: "MinWithdrawalAmountError"
+		});
+		this.minAmount = minAmount;
+		this.requestedAmount = requestedAmount;
+		this.assetId = assetId;
+	}
+};
+var UnsupportedDestinationMemoError = class extends lampamazaza_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.",
+			metaMessages: [`Blockchain: ${blockchain}`, `Asset ID: ${assetId}`],
+			name: "UnsupportedDestinationMemoError"
+		});
+		this.blockchain = blockchain;
+		this.assetId = assetId;
+	}
+};
+var TrustlineNotFoundError = class extends lampamazaza_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.",
+			metaMessages: [
+				`Blockchain: ${blockchain}`,
+				`Asset ID: ${assetId}`,
+				`Destination address: ${destinationAddress}`,
+				`Token address: ${tokenAddress}`
+			],
+			name: "TrustlineNotFoundError"
+		});
+		this.destinationAddress = destinationAddress;
+		this.assetId = assetId;
+		this.blockchain = blockchain;
+		this.tokenAddress = tokenAddress;
+	}
+};
+var UnsupportedAssetIdError = class extends lampamazaza_internal_utils.BaseError {
+	constructor(assetId, details) {
+		super("Asset ID is not supported.", {
+			details,
+			metaMessages: [`Asset ID: ${assetId}`],
+			name: "UnsupportedAssetIdError"
+		});
+		this.assetId = assetId;
+	}
+};
+var InvalidDestinationAddressForWithdrawalError = class extends lampamazaza_internal_utils.BaseError {
+	constructor(destinationAddress, destinationChain) {
+		super(`Invalid destination address.`, {
+			metaMessages: [`Destination address: ${destinationAddress}`, `Destination chain: ${destinationChain}`],
+			name: "InvalidDestinationAddressForWithdrawalError",
+			details: `Destination address ${destinationAddress} is not valid for withdrawal to ${destinationChain}.`
+		});
+		this.destinationAddress = destinationAddress;
+		this.destinationChain = destinationChain;
+	}
+};
+
+//#endregion
+exports.FeeExceedsAmountError = FeeExceedsAmountError;
+exports.InvalidDestinationAddressForWithdrawalError = InvalidDestinationAddressForWithdrawalError;
+exports.MinWithdrawalAmountError = MinWithdrawalAmountError;
+exports.TrustlineNotFoundError = TrustlineNotFoundError;
+exports.UnsupportedAssetIdError = UnsupportedAssetIdError;
+exports.UnsupportedDestinationMemoError = UnsupportedDestinationMemoError;

package/dist/src/classes/errors.d.cts

@@ -0,0 +1,48 @@
+import { FeeEstimation } from "../shared-types.cjs";
+import { BaseError } from "lampamazaza-internal-utils";
+
+//#region src/classes/errors.d.ts
+type FeeExceedsAmountErrorType = FeeExceedsAmountError & {
+  name: "FeeExceedsAmountError";
+};
+declare class FeeExceedsAmountError extends BaseError {
+  feeEstimation: FeeEstimation;
+  amount: bigint;
+  constructor(feeEstimation: FeeEstimation, amount: bigint);
+}
+type MinWithdrawalAmountErrorType = MinWithdrawalAmountError & {
+  name: "MinWithdrawalAmountError";
+};
+declare class MinWithdrawalAmountError extends BaseError {
+  minAmount: bigint;
+  requestedAmount: bigint;
+  assetId: string;
+  constructor(minAmount: bigint, requestedAmount: bigint, assetId: string);
+}
+type UnsupportedDestinationMemoErrorType = UnsupportedDestinationMemoError & {
+  name: "UnsupportedDestinationMemoError";
+};
+declare class UnsupportedDestinationMemoError extends BaseError {
+  blockchain: string;
+  assetId: string;
+  constructor(blockchain: string, assetId: string);
+}
+type TrustlineNotFoundErrorType = TrustlineNotFoundError & {
+  name: "TrustlineNotFoundError";
+};
+declare class TrustlineNotFoundError extends BaseError {
+  destinationAddress: string;
+  assetId: string;
+  blockchain: string;
+  tokenAddress: string;
+  constructor(destinationAddress: string, assetId: string, blockchain: string, tokenAddress: string);
+}
+type UnsupportedAssetIdErrorType = UnsupportedAssetIdError & {
+  name: "UnsupportedAssetIdError";
+};
+declare class UnsupportedAssetIdError extends BaseError {
+  assetId: string;
+  constructor(assetId: string, details: string);
+}
+//#endregion
+export { FeeExceedsAmountError, FeeExceedsAmountErrorType, MinWithdrawalAmountError, MinWithdrawalAmountErrorType, TrustlineNotFoundError, TrustlineNotFoundErrorType, UnsupportedAssetIdError, UnsupportedAssetIdErrorType, UnsupportedDestinationMemoError, UnsupportedDestinationMemoErrorType };