@recoillink/sdk 0.0.0-stage → 45.0.1

package/dist/warp/WarpCore.js

@@ -0,0 +1,1144 @@
+import { ProtocolType, assert, convertDecimalsToIntegerString, convertToProtocolAddress, isEVMLike, isValidAddress, isZeroishAddress, rootLogger, } from '@recoillink/utils';
+import { Keypair } from '@solana/web3.js';
+import { ChainTechnicalStack } from '../metadata/chainMetadataTypes.js';
+import { ProviderType } from '../providers/ProviderType.js';
+import { estimateTransactionFeeEthersV5ForGasUnits, } from '../providers/transactionFeeEstimators.js';
+import { Token } from '../token/Token.js';
+import { TokenAmount } from '../token/TokenAmount.js';
+import { parseTokenConnectionId } from '../token/TokenConnection.js';
+import { tokenIdentifiersEqual } from '../token/TokenMetadata.js';
+import { ERC4626_COLLATERAL_STANDARDS, LOCKBOX_STANDARDS, MINT_LIMITED_STANDARDS, TOKEN_COLLATERALIZED_STANDARDS, TOKEN_STANDARD_TO_PROVIDER_TYPE, TokenStandard, XERC20_STANDARDS, } from '../token/TokenStandard.js';
+import { TokenType } from '../token/config.js';
+import { EVM_TRANSFER_REMOTE_GAS_ESTIMATE, } from '../token/adapters/EvmTokenAdapter.js';
+import { isHypCrossCollateralAdapter, isPredicateCapableAdapter, } from '../token/adapters/ITokenAdapter.js';
+import { EvmQuotedTransferProvider } from '../quoted-calls/EvmQuotedTransferProvider.js';
+import { resolveDestinationToken } from './resolveDestinationToken.js';
+import { messageAmountFromLocal } from '../utils/decimals.js';
+import { WarpCoreConfigSchema, WarpTxCategory, } from './types.js';
+const DESTINATION_COLLATERAL_EXEMPT_TOKEN_TYPES = new Set([
+    TokenType.collateralCctp,
+    TokenType.collateralOft,
+]);
+// CCTP/OFT both map to EvmHypCollateral, so standard alone cannot distinguish
+// protocol-backed collateral from escrowed collateral.
+function isDestinationCollateralExemptToken(token) {
+    return (token.tokenType !== undefined &&
+        DESTINATION_COLLATERAL_EXEMPT_TOKEN_TYPES.has(token.tokenType));
+}
+export class WarpCore {
+    multiProvider;
+    tokens;
+    localFeeConstants;
+    interchainFeeConstants;
+    routeBlacklist;
+    logger;
+    constructor(multiProvider, tokens, options) {
+        this.multiProvider = multiProvider;
+        this.tokens = tokens;
+        this.localFeeConstants = options?.localFeeConstants || [];
+        this.interchainFeeConstants = options?.interchainFeeConstants || [];
+        this.routeBlacklist = options?.routeBlacklist || [];
+        this.logger =
+            options?.logger ||
+                rootLogger.child({
+                    module: 'WarpCore',
+                });
+    }
+    /**
+     * Takes the serialized representation of a warp config and returns a WarpCore instance
+     * @param multiProvider the MultiProviderAdapter containing chain metadata
+     * @param config the config object of type WarpCoreConfig
+     */
+    static FromConfig(multiProvider, config) {
+        const parsedConfig = WarpCoreConfigSchema.parse(config);
+        const tokens = parsedConfig.tokens.map((token) => new Token({
+            ...token,
+            addressOrDenom: token.addressOrDenom ?? '',
+            connections: undefined,
+        }, parsedConfig.options));
+        parsedConfig.tokens.forEach((config, i) => {
+            for (const connection of config.connections || []) {
+                const token1 = tokens[i];
+                assert(token1, `Token config missing at index ${i}`);
+                const { chainName, addressOrDenom } = parseTokenConnectionId(connection.token);
+                // If token1 has a warpRouteId, token2 must share it — disambiguates
+                // tokens at the same address (e.g. M0 Portal: mUSD, wM, USDSC)
+                const token2 = tokens.find((token) => token.chainName === chainName &&
+                    tokenIdentifiersEqual(token.addressOrDenom, addressOrDenom) &&
+                    (!token1.warpRouteId || token.warpRouteId === token1.warpRouteId));
+                assert(token2, `Connected token not found: ${chainName} ${addressOrDenom}`);
+                token1.addConnection({
+                    ...connection,
+                    token: token2,
+                });
+            }
+        });
+        return new WarpCore(multiProvider, tokens, parsedConfig.options);
+    }
+    /**
+     * Queries the token router for an interchain gas quote (i.e. IGP fee).
+     * and for token fee quote if it exists.
+     * Sender is only required for Sealevel origins.
+     */
+    async getInterchainTransferFee({ originTokenAmount, destination, sender, recipient, destinationToken, }) {
+        this.logger.debug(`Fetching interchain transfer quote to ${destination}`);
+        const { amount, token: originToken } = originTokenAmount;
+        const originName = originToken.chainName;
+        const destinationName = this.multiProvider.getChainName(destination);
+        let gasAmount;
+        let gasAddressOrDenom;
+        let feeAmount;
+        let feeTokenAddress;
+        // Check constant quotes first
+        const defaultQuote = this.interchainFeeConstants.find((q) => q.origin === originName && q.destination === destinationName);
+        if (defaultQuote) {
+            gasAmount = BigInt(defaultQuote.amount.toString());
+            gasAddressOrDenom = defaultQuote.addressOrDenom;
+        }
+        else {
+            // Otherwise, compute IGP quote via the adapter
+            let quote;
+            const destinationDomainId = this.multiProvider.getDomainId(destination);
+            if (this.isCrossCollateralTransfer(originToken, destinationToken)) {
+                const resolvedDestinationToken = this.resolveDestinationToken({
+                    originToken,
+                    destination,
+                    destinationToken,
+                });
+                assert(resolvedDestinationToken.addressOrDenom, 'Destination token missing addressOrDenom');
+                const crossCollateralAdapter = originToken.getHypAdapter(this.multiProvider, destinationName);
+                assert(isHypCrossCollateralAdapter(crossCollateralAdapter), 'Adapter does not implement IHypCrossCollateralAdapter');
+                quote = await crossCollateralAdapter.quoteTransferRemoteToGas({
+                    destination: destinationDomainId,
+                    recipient,
+                    amount,
+                    targetRouter: resolvedDestinationToken.addressOrDenom,
+                    sender,
+                });
+            }
+            else {
+                const hypAdapter = originToken.getHypAdapter(this.multiProvider, destinationName);
+                quote = await hypAdapter.quoteTransferRemoteGas({
+                    destination: destinationDomainId,
+                    sender,
+                    customHook: originToken.igpTokenAddressOrDenom,
+                    recipient,
+                    amount,
+                });
+            }
+            gasAmount = BigInt(quote.igpQuote.amount);
+            gasAddressOrDenom = quote.igpQuote.addressOrDenom;
+            feeAmount = quote.tokenFeeQuote?.amount;
+            feeTokenAddress = quote.tokenFeeQuote?.addressOrDenom;
+        }
+        let igpToken;
+        if (!gasAddressOrDenom || isZeroishAddress(gasAddressOrDenom)) {
+            // An empty/undefined addressOrDenom indicates the native token
+            igpToken = Token.FromChainMetadataNativeToken(this.multiProvider.getChainMetadata(originName));
+        }
+        else {
+            const searchResult = this.findToken(originName, gasAddressOrDenom);
+            assert(searchResult, `Fee token ${gasAddressOrDenom} is unknown`);
+            igpToken = searchResult;
+        }
+        let feeTokenAmount;
+        if (feeAmount) {
+            // empty address or zero address is native route
+            if (!feeTokenAddress || isZeroishAddress(feeTokenAddress)) {
+                const nativeToken = Token.FromChainMetadataNativeToken(this.multiProvider.getChainMetadata(originName));
+                feeTokenAmount = new TokenAmount(feeAmount, nativeToken);
+            }
+            else {
+                // for non-native routes, fees will be in the current route token
+                feeTokenAmount = new TokenAmount(feeAmount, originToken);
+            }
+        }
+        this.logger.debug(`Quoted interchain transfer fee: ${gasAmount} ${igpToken.symbol}`);
+        return {
+            igpQuote: new TokenAmount(gasAmount, igpToken),
+            tokenFeeQuote: feeTokenAmount,
+        };
+    }
+    /**
+     * Simulates a transfer to estimate 'local' gas fees on the origin chain
+     */
+    async getLocalTransferFee({ originToken, destination, sender, recipient: recipientOverride, senderPubKey, interchainFee, tokenFeeQuote, attestation, amount, destinationToken, quotedCalls, }) {
+        this.logger.debug(`Estimating local transfer gas to ${destination}`);
+        const originMetadata = this.multiProvider.getChainMetadata(originToken.chainName);
+        const destinationMetadata = this.multiProvider.getChainMetadata(destination);
+        // Check constant quotes first
+        const defaultQuote = this.localFeeConstants.find((q) => q.origin === originMetadata.name &&
+            q.destination === destinationMetadata.name);
+        if (defaultQuote) {
+            return { gasUnits: 0, gasPrice: 0, fee: Number(defaultQuote.amount) };
+        }
+        // Form transactions to estimate local gas with. Prefer the real recipient:
+        // a recipient-gated origin (allowlist hook / fee program) rejects a
+        // placeholder and the estimate would fail for an otherwise valid transfer.
+        const recipient = recipientOverride ??
+            convertToProtocolAddress(sender, destinationMetadata.protocol, destinationMetadata.bech32Prefix);
+        // Use a small but viable amount for gas estimation when none is provided.
+        // Must survive on-chain decimal truncation (e.g. 18→6 decimals) to avoid
+        // reverts like "HypNativeMinter: destination amount < 1". Compute minimum
+        // as 10^(originDecimals - destDecimals) so destination gets exactly 1 unit.
+        const estimationAmount = amount ??
+            (() => {
+                const destToken = originToken.getConnectionForChain(destinationMetadata.name)?.token;
+                const decimalDiff = destToken
+                    ? Math.max(0, originToken.decimals - destToken.decimals)
+                    : 0;
+                return BigInt(10) ** BigInt(decimalDiff);
+            })();
+        const txs = await this.getTransferRemoteTxs({
+            originTokenAmount: originToken.amount(estimationAmount),
+            destination,
+            sender,
+            recipient,
+            interchainFee,
+            tokenFeeQuote,
+            attestation,
+            destinationToken,
+            quotedCalls,
+        });
+        // Starknet does not support gas estimation without starknet account
+        if (originToken.protocol === ProtocolType.Starknet) {
+            return { gasUnits: 0n, gasPrice: 0n, fee: 0n };
+        }
+        // Seismic's shielded execution zeroes msg.sender for unsigned eth_call/
+        // eth_estimateGas, so any handler logic keyed on msg.sender (e.g. HypERC20's
+        // _burn(msg.sender, ...)) reverts during this probe. Recovering msg.sender
+        // requires a signed estimate (see SeismicSigner). The adapter may hold that
+        // signer for token reads, but fee estimation is not routed through it: a
+        // signed estimate costs a signature per quote. The actual transferRemote
+        // signer is Seismic-aware, so the real send still works.
+        // Use the same hard-coded gas-unit estimate as the multi-tx branch below
+        // (with real on-chain fee data) instead of eth_estimateGas, so callers like
+        // getMaxTransferAmount/validateTransfer still get a conservative non-zero
+        // fee rather than treating the transfer as free.
+        if (originMetadata.technicalStack === ChainTechnicalStack.Seismic) {
+            const provider = this.multiProvider.getEthersV5Provider(originMetadata.name);
+            return estimateTransactionFeeEthersV5ForGasUnits({
+                provider,
+                gasUnits: EVM_TRANSFER_REMOTE_GAS_ESTIMATE,
+            });
+        }
+        // Typically the transfers require a single transaction
+        if (txs.length === 1) {
+            try {
+                return await this.multiProvider.estimateTransactionFee({
+                    chainNameOrId: originMetadata.name,
+                    transaction: txs[0],
+                    sender,
+                    senderPubKey,
+                });
+            }
+            catch (error) {
+                this.logger.error(`Failed to estimate local gas fee for ${originToken.symbol} transfer`, error);
+                throw new Error('Gas estimation failed, balance may be insufficient', {
+                    cause: error,
+                });
+            }
+        }
+        // On ethereum, sometimes 2 txs are required (one approve, one transferRemote)
+        else if (txs.length >= 2 && isEVMLike(originToken.protocol)) {
+            const provider = this.multiProvider.getEthersV5Provider(originMetadata.name);
+            // We use a hard-coded const as an estimate for the transferRemote because we
+            // cannot reliably simulate the tx when an approval tx is required first
+            return estimateTransactionFeeEthersV5ForGasUnits({
+                provider,
+                gasUnits: EVM_TRANSFER_REMOTE_GAS_ESTIMATE,
+            });
+        }
+        else {
+            throw new Error('Cannot estimate local gas for multiple transactions');
+        }
+    }
+    /**
+     * Similar to getLocalTransferFee in that it estimates local gas fees
+     * but it also resolves the native token and returns a TokenAmount
+     * @todo: rename to getLocalTransferFee for consistency (requires breaking change)
+     */
+    async getLocalTransferFeeAmount({ originToken, destination, sender, recipient, senderPubKey, interchainFee, tokenFeeQuote, attestation, amount, destinationToken, quotedCalls, }) {
+        const originMetadata = this.multiProvider.getChainMetadata(originToken.chainName);
+        // If there's no native token, we can't represent local gas
+        if (!originMetadata.nativeToken)
+            throw new Error(`No native token found for ${originMetadata.name}`);
+        this.logger.debug(`Using native token ${originMetadata.nativeToken.symbol} for local gas fee`);
+        const localFee = await this.getLocalTransferFee({
+            originToken,
+            destination,
+            sender,
+            recipient,
+            senderPubKey,
+            interchainFee,
+            tokenFeeQuote,
+            attestation,
+            amount,
+            destinationToken,
+            quotedCalls,
+        });
+        // Get the local gas token. This assumes the chain's native token will pay for local gas
+        // This will need to be smarter if more complex scenarios on Cosmos are supported
+        const localGasToken = Token.FromChainMetadataNativeToken(originMetadata);
+        return localGasToken.amount(localFee.fee);
+    }
+    /**
+     * Gets a list of populated transactions required to transfer a token to a remote chain
+     * Typically just 1 transaction but sometimes more, like when an approval is required first
+     */
+    async getTransferRemoteTxs({ originTokenAmount, destination, sender, recipient, interchainFee, tokenFeeQuote, attestation, destinationToken, quotedCalls, quotedTransfer, }) {
+        const provider = quotedTransfer ??
+            (quotedCalls ? new EvmQuotedTransferProvider(quotedCalls) : undefined);
+        // Quoted transfers and attestation are mutually exclusive: the quoted path
+        // calls transferRemote, not transferRemoteWithAttestation. Composing them
+        // would require new contract support; surface a clear error rather than
+        // silently dropping the attestation.
+        assert(!(provider && attestation), 'quoted transfer and attestation cannot be used together. The quoted path does not support attestation-gated transfers.');
+        if (provider) {
+            const tokenProtocol = originTokenAmount.token.protocol;
+            // EVM-family protocols (Ethereum, Tron) share the EvmQuotedTransferProvider
+            // wire format, so allow them to match each other; otherwise require
+            // strict equality with the provider's declared protocol.
+            const protocolMatches = provider.protocol === tokenProtocol ||
+                (isEVMLike(provider.protocol) && isEVMLike(tokenProtocol));
+            assert(protocolMatches, `Quoted-transfer provider protocol (${provider.protocol}) does not match origin token protocol (${tokenProtocol})`);
+            return provider.buildQuotedTransferTxs({
+                warpCore: this,
+                originTokenAmount,
+                destination,
+                sender,
+                recipient,
+                destinationToken,
+            });
+        }
+        // Check if this is a CrossCollateralRouter transfer
+        if (destinationToken &&
+            this.isCrossCollateralTransfer(originTokenAmount.token, destinationToken)) {
+            return this.getCrossCollateralTransferTxs({
+                originTokenAmount,
+                destination,
+                sender,
+                recipient,
+                destinationToken,
+                attestation,
+                interchainFee,
+                tokenFeeQuote,
+            });
+        }
+        // Standard warp route transfer
+        const transactions = [];
+        const { token, amount } = originTokenAmount;
+        const destinationName = this.multiProvider.getChainName(destination);
+        const destinationDomainId = this.multiProvider.getDomainId(destination);
+        const providerType = TOKEN_STANDARD_TO_PROVIDER_TYPE[token.standard];
+        const hypAdapter = token.getHypAdapter(this.multiProvider, destinationName);
+        if (!interchainFee) {
+            // Only re-fetch when the IGP quote is missing. tokenFeeQuote may legitimately
+            // be undefined for routes that have no token fee — treating its absence as a
+            // reason to re-fetch would overwrite a valid pinned interchainFee.
+            const transferFee = await this.getInterchainTransferFee({
+                originTokenAmount,
+                destination,
+                sender,
+                recipient,
+                destinationToken,
+            });
+            interchainFee = transferFee.igpQuote;
+            tokenFeeQuote = transferFee.tokenFeeQuote;
+        }
+        const interchainGas = {
+            igpQuote: {
+                amount: interchainFee.amount,
+                addressOrDenom: interchainFee.token.addressOrDenom,
+            },
+            tokenFeeQuote: tokenFeeQuote && {
+                amount: tokenFeeQuote.amount,
+                addressOrDenom: tokenFeeQuote.token.addressOrDenom,
+            },
+        };
+        // Include the ERC20 fee (tokenFeeQuote) in the approval threshold so that
+        // allowance checks account for hookFee charged by the feeHook contract.
+        const feeQuote = tokenFeeQuote?.amount ?? 0n;
+        const [isApproveRequired, isRevokeApprovalRequired] = await Promise.all([
+            this.isApproveRequired({
+                originTokenAmount: originTokenAmount.plus(feeQuote),
+                owner: sender,
+            }),
+            hypAdapter.isRevokeApprovalRequired(sender, originTokenAmount.token.addressOrDenom),
+        ]);
+        const preTransferRemoteTxs = [];
+        // if the approval is required and the current allowance is not 0 we reset
+        // the allowance before setting the right approval as some tokens don't allow
+        // to override an already existing allowance. USDT is one of these tokens
+        // see: https://etherscan.io/token/0xdac17f958d2ee523a2206206994597c13d831ec7#code#L205
+        if (isApproveRequired && isRevokeApprovalRequired) {
+            preTransferRemoteTxs.push([0, WarpTxCategory.Revoke]);
+        }
+        if (isApproveRequired) {
+            const amountToApprove = amount + feeQuote;
+            preTransferRemoteTxs.push([
+                amountToApprove.toString(),
+                WarpTxCategory.Approval,
+            ]);
+        }
+        for (const [approveAmount, txCategory] of preTransferRemoteTxs) {
+            this.logger.info(`${txCategory} required for transfer of ${token.symbol}`);
+            const approveTxReq = await hypAdapter.populateApproveTx({
+                weiAmountOrId: approveAmount,
+                recipient: token.addressOrDenom,
+                interchainGas,
+            });
+            this.logger.debug(`${txCategory} tx for ${token.symbol} populated`);
+            const approveTx = {
+                category: txCategory,
+                type: providerType,
+                transaction: approveTxReq,
+            };
+            transactions.push(approveTx);
+        }
+        // if the interchain fee is of protocol starknet we also have
+        // to approve the transfer of this fee token
+        if (interchainFee.token.protocol === ProtocolType.Starknet) {
+            const interchainFeeAdapter = interchainFee.token.getAdapter(this.multiProvider);
+            const isRequired = await interchainFeeAdapter.isApproveRequired(sender, token.addressOrDenom, interchainFee.amount);
+            this.logger.debug(`Approval is${isRequired ? '' : ' not'} required for interchain fee of ${interchainFee.token.symbol}`);
+            if (isRequired) {
+                const txCategory = WarpTxCategory.Approval;
+                this.logger.info(`${txCategory} required for transfer of ${interchainFee.token.symbol}`);
+                const approveTxReq = await interchainFeeAdapter.populateApproveTx({
+                    weiAmountOrId: interchainFee.amount,
+                    recipient: token.addressOrDenom,
+                });
+                this.logger.debug(`${txCategory} tx for ${interchainFee.token.symbol} populated`);
+                const approveTx = {
+                    category: txCategory,
+                    type: providerType,
+                    transaction: approveTxReq,
+                };
+                transactions.push(approveTx);
+            }
+        }
+        const extraSignerKeypairs = providerType === ProviderType.SolanaWeb3
+            ? [Keypair.generate()]
+            : undefined;
+        if (attestation) {
+            assert(isPredicateCapableAdapter(hypAdapter), 'Attestation provided but adapter does not support predicate transfers');
+        }
+        const transferTxReq = await hypAdapter.populateTransferRemoteTx({
+            weiAmountOrId: amount.toString(),
+            destination: destinationDomainId,
+            fromAccountOwner: sender,
+            recipient,
+            interchainGas,
+            customHook: token.igpTokenAddressOrDenom,
+            attestation,
+            extraSigners: extraSignerKeypairs,
+        });
+        this.logger.debug(`Remote transfer tx for ${token.symbol} populated`);
+        const transferTx = {
+            category: WarpTxCategory.Transfer,
+            type: providerType,
+            transaction: transferTxReq,
+            ...(extraSignerKeypairs && { extraSigners: extraSignerKeypairs }),
+        };
+        transactions.push(transferTx);
+        return transactions;
+    }
+    /**
+     * Check if this is a CrossCollateralRouter transfer.
+     * Returns true if both tokens are CrossCollateralRouter tokens.
+     */
+    isCrossCollateralTransfer(originToken, destinationToken) {
+        if (!destinationToken)
+            return false;
+        return (originToken.isCrossCollateralToken() &&
+            destinationToken.isCrossCollateralToken());
+    }
+    /**
+     * Executes a CrossCollateralRouter transfer between different collateral routers.
+     * Uses transferRemoteTo for both same-chain and cross-chain transfers.
+     * Same-chain: calls handle() directly on target router (atomic, no relay needed).
+     */
+    async getCrossCollateralTransferTxs({ originTokenAmount, destination, sender, recipient, destinationToken, attestation, interchainFee, tokenFeeQuote, }) {
+        const transactions = [];
+        const { token: originToken, amount } = originTokenAmount;
+        const destinationName = this.multiProvider.getChainName(destination);
+        const resolvedDestinationToken = this.resolveDestinationToken({
+            originToken,
+            destination,
+            destinationToken,
+        });
+        assert(originToken.collateralAddressOrDenom, 'Origin token missing collateralAddressOrDenom');
+        assert(resolvedDestinationToken.addressOrDenom, 'Destination token missing addressOrDenom');
+        const providerType = TOKEN_STANDARD_TO_PROVIDER_TYPE[originToken.standard];
+        const adapter = originToken.getHypAdapter(this.multiProvider, destinationName);
+        assert(isHypCrossCollateralAdapter(adapter), 'Adapter does not implement IHypCrossCollateralAdapter');
+        // Use pre-computed fees when provided (e.g. when attestation is present and the
+        // msg_value was signed over the original quote). Re-quoting could produce a
+        // different value and cause the attestation check to fail on-chain.
+        // Mirror the standard path (line ~517): only re-quote when interchainFee is absent.
+        // tokenFeeQuote may legitimately be undefined (no token fee on this route) and that
+        // is not a reason to re-quote — doing so would overwrite a valid pinned interchainFee.
+        let transferQuote;
+        if (interchainFee) {
+            transferQuote = {
+                igpQuote: {
+                    amount: interchainFee.amount,
+                    addressOrDenom: interchainFee.token.addressOrDenom,
+                },
+                ...(tokenFeeQuote && {
+                    tokenFeeQuote: {
+                        amount: tokenFeeQuote.amount,
+                        addressOrDenom: tokenFeeQuote.token.addressOrDenom,
+                    },
+                }),
+            };
+        }
+        else {
+            transferQuote = await adapter.quoteTransferRemoteToGas({
+                destination: this.multiProvider.getDomainId(destination),
+                recipient,
+                amount,
+                targetRouter: resolvedDestinationToken.addressOrDenom,
+                sender,
+            });
+        }
+        const igpDenom = transferQuote.igpQuote.addressOrDenom;
+        assert(!igpDenom || isZeroishAddress(igpDenom) || igpDenom === 'lamport', `CrossCollateralRouter transferRemoteTo requires native IGP fee; got ${igpDenom}`);
+        const tokenFeeAmount = transferQuote.tokenFeeQuote?.amount ?? 0n;
+        const totalDebit = amount + tokenFeeAmount;
+        const [isApproveRequired, isRevokeApprovalRequired] = await Promise.all([
+            adapter.isApproveRequired(sender, originToken.addressOrDenom, totalDebit),
+            adapter.isRevokeApprovalRequired(sender, originToken.addressOrDenom),
+        ]);
+        if (isApproveRequired && isRevokeApprovalRequired) {
+            const revokeTxReq = await adapter.populateApproveTx({
+                weiAmountOrId: 0,
+                recipient: originToken.addressOrDenom,
+            });
+            transactions.push({
+                category: WarpTxCategory.Revoke,
+                type: providerType,
+                transaction: revokeTxReq,
+            });
+        }
+        if (isApproveRequired) {
+            const approveTxReq = await adapter.populateApproveTx({
+                weiAmountOrId: totalDebit,
+                recipient: originToken.addressOrDenom,
+            });
+            transactions.push({
+                category: WarpTxCategory.Approval,
+                type: providerType,
+                transaction: approveTxReq,
+            });
+        }
+        // transferRemoteTo works for both same-chain and cross-chain.
+        // Same-chain: calls handle() directly on target router (atomic, no relay needed).
+        const destinationDomainId = this.multiProvider.getDomainId(destination);
+        const originDomainId = this.multiProvider.getDomainId(originToken.chainName);
+        const isLocalTransfer = destinationDomainId === originDomainId;
+        const extraSignerKeypairs = providerType === ProviderType.SolanaWeb3 && !isLocalTransfer
+            ? [Keypair.generate()]
+            : undefined;
+        const txReq = await adapter.populateTransferRemoteToTx({
+            destination: destinationDomainId,
+            recipient,
+            amount,
+            targetRouter: resolvedDestinationToken.addressOrDenom,
+            interchainGas: transferQuote,
+            fromAccountOwner: sender,
+            extraSigners: extraSignerKeypairs,
+            attestation,
+        });
+        transactions.push({
+            category: WarpTxCategory.Transfer,
+            type: providerType,
+            transaction: txReq,
+            ...(extraSignerKeypairs && { extraSigners: extraSignerKeypairs }),
+        });
+        return transactions;
+    }
+    /**
+     * Display-time fee quote for an offchain-quoted transfer. Caller constructs
+     * a `QuotedTransferProvider` (EVM or Sealevel) and passes it in; WarpCore
+     * dispatches to the provider's `getQuotedTransferFee` without per-VM
+     * branching.
+     *
+     * Mirrors `getTransferRemoteTxs({ quotedTransfer })` — same provider
+     * instance can drive both display and submit so the UI doesn't need
+     * separate state for each.
+     */
+    async getQuotedTransferFee(args) {
+        return args.quotedTransfer.getQuotedTransferFee({
+            warpCore: this,
+            originTokenAmount: args.originTokenAmount,
+            destination: args.destination,
+            sender: args.sender,
+            recipient: args.recipient,
+            destinationToken: args.destinationToken,
+        });
+    }
+    /**
+     * Fetch local and interchain fee estimates for a remote transfer
+     */
+    async estimateTransferRemoteFees({ originTokenAmount, destination, recipient, sender, senderPubKey, attestation, destinationToken, }) {
+        this.logger.debug('Fetching remote transfer fee estimates');
+        const { token: originToken } = originTokenAmount;
+        // Handle CrossCollateralRouter fee estimation
+        if (this.isCrossCollateralTransfer(originToken, destinationToken)) {
+            return this.estimateCrossCollateralFees({
+                originTokenAmount,
+                destination,
+                destinationToken,
+                recipient,
+                sender,
+                senderPubKey,
+                attestation,
+            });
+        }
+        // First get interchain gas quote (aka IGP quote)
+        // Start with this because it's used in the local fee estimation
+        const { igpQuote, tokenFeeQuote } = await this.getInterchainTransferFee({
+            originTokenAmount,
+            destination,
+            sender,
+            recipient,
+        });
+        // Next, get the local gas quote
+        const localQuote = await this.getLocalTransferFeeAmount({
+            originToken: originTokenAmount.token,
+            destination,
+            sender,
+            recipient,
+            senderPubKey,
+            interchainFee: igpQuote,
+            tokenFeeQuote,
+            attestation,
+            // Only pass amount for predicate flows — it feeds the attested msg_value into
+            // eth_estimateGas. For non-predicate flows, let getLocalTransferFee use its
+            // minimal-amount fallback so simulation doesn't fail on large balances or
+            // placeholder senders (e.g. 0x...dead) that have no ETH.
+            amount: attestation ? originTokenAmount.amount : undefined,
+        });
+        return {
+            interchainQuote: igpQuote,
+            localQuote,
+            tokenFeeQuote,
+        };
+    }
+    /**
+     * Estimate fees for a CrossCollateralRouter transfer.
+     */
+    async estimateCrossCollateralFees({ originTokenAmount, destination, destinationToken, recipient, sender, senderPubKey, attestation, }) {
+        const { token: originToken } = originTokenAmount;
+        const resolvedDestinationToken = this.resolveDestinationToken({
+            originToken,
+            destination,
+            destinationToken,
+        });
+        const { igpQuote: interchainQuote, tokenFeeQuote } = await this.getInterchainTransferFee({
+            originTokenAmount,
+            destination,
+            sender,
+            recipient,
+            destinationToken: resolvedDestinationToken,
+        });
+        const localQuote = await this.getLocalTransferFeeAmount({
+            originToken,
+            destination,
+            sender,
+            recipient,
+            senderPubKey,
+            interchainFee: interchainQuote,
+            tokenFeeQuote,
+            attestation,
+            amount: attestation ? originTokenAmount.amount : undefined,
+            destinationToken: resolvedDestinationToken,
+        });
+        return {
+            interchainQuote,
+            localQuote,
+            tokenFeeQuote,
+        };
+    }
+    /**
+     * Computes the max transferrable amount of the from the given
+     * token balance, accounting for local and interchain gas fees
+     */
+    async getMaxTransferAmount({ balance, destination, recipient, sender, senderPubKey, feeEstimate, destinationToken, }) {
+        const originToken = balance.token;
+        if (!feeEstimate) {
+            // Get IGP and token fee quotes using the full balance so amount-dependent fees
+            // (e.g. percentage-based token fees) are correctly computed and subtracted.
+            const { igpQuote: interchainQuote, tokenFeeQuote } = await this.getInterchainTransferFee({
+                originTokenAmount: balance,
+                destination,
+                recipient,
+                sender,
+                destinationToken,
+            });
+            // Estimate local gas with no amount so getLocalTransferFee uses its minimal-amount
+            // fallback — avoids eth_estimateGas failures on native token routes where simulating
+            // the full balance leaves nothing to cover gas.
+            const localQuote = await this.getLocalTransferFeeAmount({
+                originToken,
+                destination,
+                sender,
+                recipient,
+                senderPubKey,
+                interchainFee: interchainQuote,
+                tokenFeeQuote,
+                destinationToken,
+            });
+            feeEstimate = { interchainQuote, localQuote, tokenFeeQuote };
+        }
+        const { localQuote, interchainQuote, tokenFeeQuote } = feeEstimate;
+        let maxAmount = balance;
+        if (originToken.isFungibleWith(localQuote.token)) {
+            maxAmount = maxAmount.minus(localQuote.amount);
+        }
+        if (originToken.isFungibleWith(interchainQuote.token)) {
+            maxAmount = maxAmount.minus(interchainQuote.amount);
+        }
+        if (originToken.isFungibleWith(tokenFeeQuote?.token)) {
+            const { tokenFeeQuote: newFeeQuote } = await this.getInterchainTransferFee({
+                originTokenAmount: maxAmount,
+                destination,
+                recipient,
+                sender,
+                destinationToken,
+            });
+            // Because tokenFeeQuote is calculated based on the amount, we need to recalculate
+            // the tokenFeeQuote after subtracting the localQuote and IGP to get max transfer amount
+            // to be as close as possible
+            maxAmount = maxAmount.minus(newFeeQuote?.amount || 0n);
+        }
+        if (maxAmount.amount > 0)
+            return maxAmount;
+        else
+            return originToken.amount(0);
+    }
+    async getTokenCollateral(token) {
+        if (LOCKBOX_STANDARDS.includes(token.standard) ||
+            ERC4626_COLLATERAL_STANDARDS.includes(token.standard)) {
+            const adapter = token.getHypAdapter(this.multiProvider);
+            const tokenCollateral = await adapter.getBridgedSupply();
+            assert(tokenCollateral !== undefined, `getBridgedSupply returned undefined for ${token.symbol} on ${token.chainName}`);
+            return tokenCollateral;
+        }
+        else {
+            const adapter = token.getAdapter(this.multiProvider);
+            const tokenCollateral = await adapter.getBalance(token.addressOrDenom);
+            return tokenCollateral;
+        }
+    }
+    /**
+     * Checks if destination chain's collateral is sufficient to cover the transfer
+     */
+    async isDestinationCollateralSufficient({ originTokenAmount, destination, destinationToken, }) {
+        const { token: originToken, amount } = originTokenAmount;
+        this.logger.debug(`Checking collateral for ${originToken.symbol} to ${destination}`);
+        const resolvedDestinationToken = this.resolveDestinationToken({
+            originToken,
+            destination,
+            destinationToken,
+        });
+        if (isDestinationCollateralExemptToken(resolvedDestinationToken)) {
+            this.logger.debug(`${resolvedDestinationToken.symbol} uses ${resolvedDestinationToken.tokenType}, skipping destination collateral check`);
+            return true;
+        }
+        if (!TOKEN_COLLATERALIZED_STANDARDS.includes(resolvedDestinationToken.standard)) {
+            this.logger.debug(`${resolvedDestinationToken.symbol} is not collateralized, skipping`);
+            return true;
+        }
+        const destinationBalance = await this.getTokenCollateral(resolvedDestinationToken);
+        // Legacy fallback: when both scales are undefined but decimals differ,
+        // we can't use message-space comparison because messageAmountFromLocal
+        // with identity scale would compare raw local units across different
+        // decimal spaces. Fall back to decimal conversion instead.
+        // Well-configured routes should have scale set — verifyScale() catches
+        // this at deploy time. Misconfigured routes that reach the message-space
+        // path below may produce incorrect results.
+        if (originToken.decimals !== resolvedDestinationToken.decimals &&
+            originToken.scale === undefined &&
+            resolvedDestinationToken.scale === undefined) {
+            const destinationBalanceInOriginDecimals = BigInt(convertDecimalsToIntegerString(resolvedDestinationToken.decimals, originToken.decimals, destinationBalance.toString()));
+            const isSufficient = destinationBalanceInOriginDecimals >= amount;
+            this.logger.debug(`${originTokenAmount.token.symbol} to ${destination} has ${isSufficient ? 'sufficient' : 'INSUFFICIENT'} collateral`);
+            return isSufficient;
+        }
+        const requiredMessageAmount = messageAmountFromLocal(amount, originToken.scale);
+        const availableMessageAmount = messageAmountFromLocal(destinationBalance, resolvedDestinationToken.scale);
+        const isSufficient = availableMessageAmount >= requiredMessageAmount;
+        this.logger.debug(`${originTokenAmount.token.symbol} to ${destination} has ${isSufficient ? 'sufficient' : 'INSUFFICIENT'} collateral`);
+        return isSufficient;
+    }
+    /**
+     * Checks if a token transfer requires an approval tx first
+     */
+    async isApproveRequired({ originTokenAmount, owner, }) {
+        const { token, amount } = originTokenAmount;
+        const adapter = token.getAdapter(this.multiProvider);
+        const isRequired = await adapter.isApproveRequired(owner, token.addressOrDenom, amount);
+        this.logger.debug(`Approval is${isRequired ? '' : ' not'} required for transfer of ${token.symbol}`);
+        return isRequired;
+    }
+    /**
+     * Ensure the remote token transfer would be valid for the given chains, amount, sender, and recipient
+     */
+    async validateTransfer({ originTokenAmount, destination, recipient, sender, senderPubKey, attestation, destinationToken, }) {
+        const chainError = this.validateChains(originTokenAmount.token.chainName, destination);
+        if (chainError)
+            return chainError;
+        const recipientError = this.validateRecipient(recipient, destination);
+        if (recipientError)
+            return recipientError;
+        const resolvedDestinationToken = (() => {
+            try {
+                return this.resolveDestinationToken({
+                    originToken: originTokenAmount.token,
+                    destination,
+                    destinationToken,
+                });
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : 'Invalid destination token';
+                return { error: message };
+            }
+        })();
+        if ('error' in resolvedDestinationToken) {
+            return { destinationToken: resolvedDestinationToken.error };
+        }
+        const amountError = await this.validateAmount(originTokenAmount, destination, recipient, resolvedDestinationToken);
+        if (amountError)
+            return amountError;
+        const destinationRateLimitError = await this.validateDestinationRateLimit(originTokenAmount, destination, resolvedDestinationToken);
+        if (destinationRateLimitError)
+            return destinationRateLimitError;
+        const destinationCollateralError = await this.validateDestinationCollateral(originTokenAmount, destination, resolvedDestinationToken);
+        if (destinationCollateralError)
+            return destinationCollateralError;
+        // Quote the interchain transfer fee once and reuse it across the origin
+        // burn-limit and token-balance checks so both use identical values and we
+        // avoid a redundant remote quote.
+        const interchainFee = await this.getInterchainTransferFee({
+            originTokenAmount,
+            destination,
+            sender,
+            recipient,
+            destinationToken: resolvedDestinationToken,
+        });
+        const originCollateralError = await this.validateOriginCollateral(originTokenAmount, destination, recipient, sender, resolvedDestinationToken, interchainFee);
+        if (originCollateralError)
+            return originCollateralError;
+        const balancesError = await this.validateTokenBalances(originTokenAmount, destination, sender, recipient, senderPubKey, attestation, resolvedDestinationToken, interchainFee);
+        if (balancesError)
+            return balancesError;
+        return null;
+    }
+    /**
+     * Ensure the origin and destination chains are valid and known by this WarpCore
+     */
+    validateChains(origin, destination) {
+        if (!origin)
+            return { origin: 'Origin chain required' };
+        if (!destination)
+            return { destination: 'Destination chain required' };
+        const originMetadata = this.multiProvider.tryGetChainMetadata(origin);
+        const destinationMetadata = this.multiProvider.tryGetChainMetadata(destination);
+        if (!originMetadata)
+            return { origin: 'Origin chain metadata missing' };
+        if (!destinationMetadata)
+            return { destination: 'Destination chain metadata missing' };
+        if (this.routeBlacklist.some((bl) => bl.origin === originMetadata.name &&
+            bl.destination === destinationMetadata.name)) {
+            return { destination: 'Route is not currently allowed' };
+        }
+        return null;
+    }
+    /**
+     * Ensure recipient address is valid for the destination chain
+     */
+    validateRecipient(recipient, destination) {
+        const destinationMetadata = this.multiProvider.getChainMetadata(destination);
+        const { protocol, bech32Prefix } = destinationMetadata;
+        // Ensure recip address is valid for the destination chain's protocol
+        if (!isValidAddress(recipient, protocol) || isZeroishAddress(recipient))
+            return { recipient: 'Invalid recipient' };
+        // Also ensure the address denom is correct if the dest protocol is Cosmos
+        if (protocol === ProtocolType.Cosmos ||
+            protocol === ProtocolType.CosmosNative) {
+            if (!bech32Prefix) {
+                this.logger.error(`No bech32 prefix found for chain ${destination}`);
+                return { destination: 'Invalid chain data' };
+            }
+            else if (!recipient.startsWith(bech32Prefix)) {
+                this.logger.error(`Recipient prefix should be ${bech32Prefix}`);
+                return { recipient: 'Invalid recipient prefix' };
+            }
+        }
+        return null;
+    }
+    /**
+     * Ensure token amount is valid
+     */
+    async validateAmount(originTokenAmount, destination, recipient, destinationToken) {
+        if (!originTokenAmount.amount || originTokenAmount.amount < 0n) {
+            const isNft = originTokenAmount.token.isNft();
+            return { amount: isNft ? 'Invalid Token Id' : 'Invalid amount' };
+        }
+        // Check the transfer amount is sufficient on the destination side
+        const originToken = originTokenAmount.token;
+        const resolvedDestinationToken = this.resolveDestinationToken({
+            originToken,
+            destination,
+            destinationToken,
+        });
+        const destinationAdapter = resolvedDestinationToken.getAdapter(this.multiProvider);
+        // Get the min required destination amount
+        const minDestinationTransferAmount = await destinationAdapter.getMinimumTransferAmount(recipient);
+        // Convert the minDestinationTransferAmount to an origin amount
+        const minOriginTransferAmount = originToken.amount(convertDecimalsToIntegerString(resolvedDestinationToken.decimals, originToken.decimals, minDestinationTransferAmount.toString()));
+        if (minOriginTransferAmount.amount > originTokenAmount.amount) {
+            return {
+                amount: `Minimum transfer amount is ${minOriginTransferAmount.getDecimalFormattedAmount()} ${originToken.symbol}`,
+            };
+        }
+        return null;
+    }
+    /**
+     * Ensure the sender has sufficient balances for transfer and interchain gas
+     */
+    async validateTokenBalances(originTokenAmount, destination, sender, recipient, senderPubKey, attestation, destinationToken, interchainFee) {
+        const { token: originToken, amount } = originTokenAmount;
+        const { amount: senderBalance } = await originToken.getBalance(this.multiProvider, sender);
+        const senderBalanceAmount = originTokenAmount.token.amount(senderBalance);
+        // Check 1: Check basic token balance
+        if (amount > senderBalance)
+            return { amount: 'Insufficient balance' };
+        // Check 2: Ensure the balance can cover interchain fee
+        // Slightly redundant with Check 5 but gives more specific error messages
+        const { igpQuote: interchainQuote, tokenFeeQuote } = interchainFee ??
+            (await this.getInterchainTransferFee({
+                originTokenAmount,
+                destination,
+                sender,
+                recipient,
+                destinationToken,
+            }));
+        // Get balance of the IGP fee token, which may be different from the transfer token
+        const interchainQuoteTokenBalance = originToken.isFungibleWith(interchainQuote.token)
+            ? senderBalanceAmount
+            : await interchainQuote.token.getBalance(this.multiProvider, sender);
+        if (interchainQuoteTokenBalance.amount < interchainQuote.amount) {
+            return {
+                amount: `Insufficient ${interchainQuote.token.symbol} for interchain gas`,
+            };
+        }
+        // Check 3: Ensure the balance can cover the token fee which would be the same asset as the originTokenValue
+        // Slightly redundant with Check 5 but gives more specific error messages
+        if (tokenFeeQuote?.amount &&
+            amount + tokenFeeQuote.amount > senderBalance) {
+            return {
+                amount: `Insufficient balance to cover token fee`,
+            };
+        }
+        // Check 4: Simulates the transfer by getting the local gas fee
+        const localQuote = await this.getLocalTransferFeeAmount({
+            originToken,
+            destination,
+            sender,
+            recipient,
+            senderPubKey,
+            interchainFee: interchainQuote,
+            tokenFeeQuote,
+            attestation,
+            amount,
+            destinationToken,
+        });
+        const feeEstimate = { interchainQuote, localQuote };
+        // Check 5: Ensure balances can cover the COMBINED amount and fees
+        const maxTransfer = await this.getMaxTransferAmount({
+            balance: senderBalanceAmount,
+            destination,
+            recipient,
+            sender,
+            senderPubKey,
+            feeEstimate,
+            destinationToken,
+        });
+        if (amount > maxTransfer.amount) {
+            return { amount: 'Insufficient balance for gas and transfer' };
+        }
+        return null;
+    }
+    /**
+     * Ensure the sender has sufficient balances for transfer and interchain gas
+     */
+    async validateDestinationCollateral(originTokenAmount, destination, destinationToken) {
+        const valid = await this.isDestinationCollateralSufficient({
+            originTokenAmount,
+            destination,
+            destinationToken,
+        });
+        if (!valid) {
+            return { amount: 'Insufficient collateral on destination' };
+        }
+        return null;
+    }
+    /**
+     * Ensure the sender has sufficient balances for minting
+     */
+    async validateDestinationRateLimit(originTokenAmount, destination, destinationToken) {
+        const { token: originToken, amount } = originTokenAmount;
+        const resolvedDestinationToken = this.resolveDestinationToken({
+            originToken,
+            destination,
+            destinationToken,
+        });
+        if (!MINT_LIMITED_STANDARDS.includes(resolvedDestinationToken.standard)) {
+            this.logger.debug(`${resolvedDestinationToken.symbol} does not have rate limit constraint, skipping`);
+            return null;
+        }
+        let destinationMintLimit = 0n;
+        if (XERC20_STANDARDS.includes(resolvedDestinationToken.standard)) {
+            const adapter = resolvedDestinationToken.getAdapter(this.multiProvider);
+            destinationMintLimit = await adapter.getMintLimit();
+            if (resolvedDestinationToken.standard === TokenStandard.EvmHypVSXERC20 ||
+                resolvedDestinationToken.standard ===
+                    TokenStandard.EvmHypVSXERC20Lockbox ||
+                resolvedDestinationToken.standard === TokenStandard.TronHypVSXERC20 ||
+                resolvedDestinationToken.standard ===
+                    TokenStandard.TronHypVSXERC20Lockbox) {
+                const bufferCap = await adapter.getMintMaxLimit();
+                const max = bufferCap / 2n;
+                if (destinationMintLimit > max) {
+                    this.logger.debug(`Mint limit ${destinationMintLimit} exceeds max ${max}, using max`);
+                    destinationMintLimit = max;
+                }
+            }
+        }
+        else if (resolvedDestinationToken.standard ===
+            TokenStandard.EvmHypCollateralFiat ||
+            resolvedDestinationToken.standard === TokenStandard.TronHypCollateralFiat) {
+            const adapter = resolvedDestinationToken.getAdapter(this.multiProvider);
+            destinationMintLimit = await adapter.getMintLimit();
+        }
+        // Legacy fallback: when both scales are undefined but decimals differ,
+        // we can't use message-space comparison because messageAmountFromLocal
+        // with identity scale would compare raw local units across different
+        // decimal spaces. Fall back to decimal conversion instead.
+        // Well-configured routes should have scale set — verifyScale() catches
+        // this at deploy time. Misconfigured routes that reach the message-space
+        // path below may produce incorrect results.
+        if (originToken.decimals !== resolvedDestinationToken.decimals &&
+            originToken.scale === undefined &&
+            resolvedDestinationToken.scale === undefined) {
+            const destinationMintLimitInOriginDecimals = BigInt(convertDecimalsToIntegerString(resolvedDestinationToken.decimals, originToken.decimals, destinationMintLimit.toString()));
+            const isSufficient = destinationMintLimitInOriginDecimals >= amount;
+            this.logger.debug(`${originTokenAmount.token.symbol} to ${destination} has ${isSufficient ? 'sufficient' : 'INSUFFICIENT'} rate limits`);
+            if (!isSufficient)
+                return { amount: 'Rate limit exceeded on destination' };
+            return null;
+        }
+        const requiredMessageAmount = messageAmountFromLocal(amount, originToken.scale);
+        const availableMessageAmount = messageAmountFromLocal(destinationMintLimit, resolvedDestinationToken.scale);
+        const isSufficient = availableMessageAmount >= requiredMessageAmount;
+        this.logger.debug(`${originTokenAmount.token.symbol} to ${destination} has ${isSufficient ? 'sufficient' : 'INSUFFICIENT'} rate limits`);
+        if (!isSufficient)
+            return { amount: 'Rate limit exceeded on destination' };
+        return null;
+    }
+    /**
+     * Ensure the sender has sufficient balances for transfer and interchain gas
+     */
+    async validateOriginCollateral(originTokenAmount, destination, recipient, sender, destinationToken, interchainFee) {
+        const { token: originToken, amount } = originTokenAmount;
+        const adapter = originToken.getAdapter(this.multiProvider);
+        if (XERC20_STANDARDS.includes(originToken.standard)) {
+            // The on-chain burn path debits amount + any interchain fee charged in
+            // the same asset being burned (token-denominated hook fee). The IGP /
+            // native gas fee is paid separately and does not count toward the burn
+            // limit, so only add fees fungible with the origin token.
+            const { tokenFeeQuote } = interchainFee ??
+                (await this.getInterchainTransferFee({
+                    originTokenAmount,
+                    destination,
+                    sender,
+                    recipient,
+                    destinationToken,
+                }));
+            const originTokenFee = tokenFeeQuote && originToken.isFungibleWith(tokenFeeQuote.token)
+                ? tokenFeeQuote.amount
+                : 0n;
+            const burnDebit = amount + originTokenFee;
+            const burnLimit = await adapter.getBurnLimit();
+            if (burnLimit < burnDebit) {
+                return { amount: 'Insufficient burn limit on origin' };
+            }
+        }
+        return null;
+    }
+    resolveDestinationToken({ originToken, destination, destinationToken, }) {
+        return resolveDestinationToken({
+            multiProvider: this.multiProvider,
+            originToken,
+            destination,
+            destinationToken,
+        });
+    }
+    /**
+     * Search through token list to find token with matching chain and address
+     */
+    findToken(chainName, addressOrDenom) {
+        if (!addressOrDenom)
+            return null;
+        const results = this.tokens.filter((token) => token.chainName === chainName &&
+            tokenIdentifiersEqual(token.addressOrDenom, addressOrDenom));
+        if (results.length === 1)
+            return results[0];
+        if (results.length > 1)
+            throw new Error(`Ambiguous token search results for ${addressOrDenom}`);
+        // If the token is not found, check to see if it matches the denom of chain's native token
+        // This is a convenience so WarpConfigs don't need to include definitions for native tokens
+        const chainMetadata = this.multiProvider.getChainMetadata(chainName);
+        if (chainMetadata.nativeToken?.denom === addressOrDenom) {
+            return Token.FromChainMetadataNativeToken(chainMetadata);
+        }
+        return null;
+    }
+    /**
+     * Get the list of chains referenced by the tokens in this WarpCore
+     */
+    getTokenChains() {
+        return [...new Set(this.tokens.map((t) => t.chainName)).values()];
+    }
+    /**
+     * Get the subset of tokens whose chain matches the given chainName
+     */
+    getTokensForChain(chainName) {
+        return this.tokens.filter((t) => t.chainName === chainName);
+    }
+    /**
+     * Get the subset of tokens whose chain matches the given chainName
+     * and which are connected to a token on the given destination chain
+     */
+    getTokensForRoute(origin, destination) {
+        return this.tokens.filter((t) => t.chainName === origin && t.getConnectionForChain(destination));
+    }
+    /**
+     * Check if a token supports Predicate attestations
+     * @param token The token to check
+     * @param destination Optional destination chain for the route
+     * @returns True if the token's warp route has a PredicateRouterWrapper configured
+     */
+    async isPredicateSupported(token, destination) {
+        const adapter = token.getHypAdapter(this.multiProvider, destination);
+        if (!isPredicateCapableAdapter(adapter)) {
+            return false;
+        }
+        return adapter.supportsAttestation();
+    }
+}
+//# sourceMappingURL=WarpCore.js.map