@recoillink/sdk 0.0.0-stage → 45.0.1

package/dist/token/configUtils.js

@@ -0,0 +1,735 @@
+import { constants } from 'ethers';
+import { zeroAddress } from 'viem';
+import { HypXERC20Lockbox__factory, HypXERC20__factory, } from '@recoillink/core';
+import { ProtocolType } from '@recoillink/provider-sdk';
+import { addressToBytes32, assert, deepCopy, intersection, isAddressEvm, isCosmosIbcDenomAddress, isEVMLike, isObjEmpty, objFilter, objMap, promiseObjAll, sortArraysInObject, transformObj, } from '@recoillink/utils';
+import { isProxy } from '../deploy/proxy.js';
+import { IsmType } from '../ism/types.js';
+import { TokenFeeType, } from '../fee/types.js';
+import { EvmHookReader } from '../hook/EvmHookReader.js';
+import { collectHybridHookNodes, mapHybridHookNodes } from '../hook/utils.js';
+import { EvmIsmReader } from '../ism/EvmIsmReader.js';
+import { resolveRouterMapConfig, } from '../router/types.js';
+import { normalizeScale } from '../utils/decimals.js';
+import { DelayedFlowRemoteIsmsSourceType, collectHybridIsmNodes, completeHybridIsmNodes, ismTreeContainsHybridHookIsm, } from '../utils/ism.js';
+import { EvmWarpRouteReader } from './EvmWarpRouteReader.js';
+import { TokenType, gasOverhead } from './config.js';
+import { deriveTokenMetadata } from './tokenMetadataUtils.js';
+import { ContractVerificationStatus, OwnerStatus, isAtomicLocalRebalancingBridgeTokenConfig, isCollateralTokenConfig, isCrossCollateralTokenConfig, isDepositAddressTokenConfig, isMovableCollateralTokenConfig, isNativeTokenConfig, isOftTokenConfig, isSyntheticRebaseTokenConfig, isSyntheticTokenConfig, isXERC20TokenConfig, } from './types.js';
+/**
+ * Gets gas configuration for a chain
+ */
+const getGasConfig = (warpDeployConfig, chain) => {
+    const chainDeployConfig = warpDeployConfig[chain];
+    assert(chainDeployConfig, `Deploy config not found for chain ${chain}. Unable to get gas config`);
+    return (chainDeployConfig.gas?.toString() ||
+        gasOverhead(chainDeployConfig.type).toString());
+};
+/**
+ * Returns default router addresses and gas values for cross-chain communication.
+ * For each remote chain:
+ * - Sets up router addresses for message routing
+ * - Configures gas values for message processing
+ */
+export function getDefaultRemoteRouterAndDestinationGasConfig(multiProvider, chain, deployedRoutersAddresses, warpDeployConfig) {
+    const remoteRouters = {};
+    const destinationGas = {};
+    if (isAtomicLocalRebalancingBridgeTokenConfig(warpDeployConfig[chain])) {
+        return [remoteRouters, destinationGas];
+    }
+    const otherChains = multiProvider.getRemoteChains(chain).filter((remoteChain) => !isAtomicLocalRebalancingBridgeTokenConfig(warpDeployConfig[remoteChain]) &&
+        // Include chains that specify foreignDeployment so that they can be enrolled
+        // in the current deployment/update
+        (Object.keys(deployedRoutersAddresses).includes(remoteChain) ||
+            Boolean(warpDeployConfig[remoteChain]?.foreignDeployment)));
+    for (const otherChain of otherChains) {
+        const domainId = multiProvider.getDomainId(otherChain);
+        remoteRouters[domainId] = {
+            address: 
+            // Include chains that specify foreignDeployment so that the gas configuration
+            // can be in the current deployment/update
+            deployedRoutersAddresses[otherChain] ??
+                warpDeployConfig[otherChain].foreignDeployment,
+        };
+        destinationGas[domainId] = getGasConfig(warpDeployConfig, otherChain);
+    }
+    return [remoteRouters, destinationGas];
+}
+export function resolveAndValidateRebalanceConfig(multiProvider, chain, config) {
+    assert(isCrossCollateralTokenConfig(config), `Expected cross-collateral config for ${chain}`);
+    const remoteRouters = resolveRouterMapConfig(multiProvider, config.remoteRouters ?? {});
+    const crossCollateralRouters = resolveRouterMapConfig(multiProvider, config.crossCollateralRouters ?? {});
+    const rebalanceTargets = resolveRouterMapConfig(multiProvider, config.rebalanceTargets ?? {});
+    const rebalanceRecipients = resolveRouterMapConfig(multiProvider, config.rebalanceRecipients ?? {});
+    const observableDomains = new Set([
+        multiProvider.getDomainId(chain),
+        ...Object.keys(remoteRouters).map(Number),
+        ...Object.keys(crossCollateralRouters).map(Number),
+    ]);
+    for (const domain of [
+        ...Object.keys(rebalanceTargets),
+        ...Object.keys(rebalanceRecipients),
+    ].map(Number)) {
+        assert(observableDomains.has(domain), `Rebalance domain ${domain} on ${chain} must be the local domain or have an enrolled router`);
+    }
+    return { rebalanceTargets, rebalanceRecipients };
+}
+export function resolveWarpDeployConfigRouterKeys(multiProvider, warpDeployConfig) {
+    const resolvedWarpDeployConfig = structuredClone(warpDeployConfig);
+    for (const chainConfig of Object.values(resolvedWarpDeployConfig)) {
+        if (chainConfig.destinationGas) {
+            chainConfig.destinationGas = resolveRouterMapConfig(multiProvider, chainConfig.destinationGas);
+        }
+        if (chainConfig.remoteRouters) {
+            chainConfig.remoteRouters = resolveRouterMapConfig(multiProvider, chainConfig.remoteRouters);
+        }
+        if (isMovableCollateralTokenConfig(chainConfig) &&
+            chainConfig.allowedRebalancingBridges) {
+            chainConfig.allowedRebalancingBridges = resolveRouterMapConfig(multiProvider, chainConfig.allowedRebalancingBridges);
+        }
+    }
+    return resolvedWarpDeployConfig;
+}
+export function getRouterAddressesFromWarpCoreConfig(warpCoreConfig) {
+    return Object.fromEntries(warpCoreConfig.tokens
+        // Removing IBC denom addresses because they are on the same
+        // chain as the actual warp token but they are only used
+        // used to pay the IGP hook
+        .filter((token) => token.addressOrDenom &&
+        !isCosmosIbcDenomAddress(token.addressOrDenom))
+        .map((token) => [token.chainName, token.addressOrDenom]));
+}
+/**
+ * Gets the chain names from a WarpCoreConfig
+ */
+export function getChainsFromWarpCoreConfig(warpCoreConfig) {
+    return warpCoreConfig.tokens.map((token) => token.chainName);
+}
+/**
+ * Checks if a WarpCoreConfig includes all specified chains
+ * @param config - The warp core config to check
+ * @param chains - Array of chain names that must all be present
+ * @returns true if the config spans all specified chains
+ */
+export function warpCoreConfigMatchesChains(config, chains) {
+    const configChains = new Set(getChainsFromWarpCoreConfig(config));
+    return chains.every((chain) => configChains.has(chain));
+}
+/**
+ * Filters a map of WarpCoreConfigs to only include routes that span all specified chains
+ * @param configMap - Record of route IDs to WarpCoreConfig
+ * @param chains - Array of chain names that must all be present in each route
+ * @returns Filtered record containing only routes that span all specified chains.
+ * If `chains` is empty, returns `configMap` unchanged (treated as no filter).
+ */
+export function filterWarpCoreConfigMapByChains(configMap, chains) {
+    if (chains.length === 0) {
+        return configMap;
+    }
+    return objFilter(configMap, (_, config) => warpCoreConfigMatchesChains(config, chains));
+}
+function mergeApprovedTokens(a, b) {
+    if (!a && !b) {
+        return undefined;
+    }
+    const byNormalized = new Map();
+    for (const token of [...(a ?? []), ...(b ?? [])]) {
+        const key = token.toLowerCase();
+        if (!byNormalized.has(key)) {
+            byNormalized.set(key, token);
+        }
+    }
+    return Array.from(byNormalized.values());
+}
+/**
+ * Canonicalizes `allowedRebalancingBridges` keys to domain ids, mirroring
+ * remoteRouters/destinationGas, so a name-keyed source config does not read as
+ * drift against the domain-id-keyed on-chain state.
+ *
+ * A source config may key the same destination by both chain name and domain
+ * id; both canonicalize to one key. Bridges are merged by bridge identity —
+ * unioning approvedTokens — so a bridge listed under both keys does not expand
+ * to a duplicate that reads as permanent drift against the deduplicated
+ * on-chain state. Keys the resolver does not recognize are kept as-is rather
+ * than erroring the whole route check.
+ */
+export function canonicalizeAllowedRebalancingBridges(allowedRebalancingBridges, resolveDomainId) {
+    const canonicalized = {};
+    for (const [domainOrChain, bridges] of Object.entries(allowedRebalancingBridges)) {
+        const canonicalKey = resolveDomainId(domainOrChain)?.toString() ?? domainOrChain;
+        const byBridge = new Map();
+        for (const bridge of [...(canonicalized[canonicalKey] ?? []), ...bridges]) {
+            const bridgeKey = bridge.bridge.toLowerCase();
+            const existing = byBridge.get(bridgeKey);
+            if (!existing) {
+                byBridge.set(bridgeKey, bridge);
+                continue;
+            }
+            const approvedTokens = mergeApprovedTokens(existing.approvedTokens, bridge.approvedTokens);
+            byBridge.set(bridgeKey, {
+                ...existing,
+                ...(approvedTokens ? { approvedTokens } : {}),
+            });
+        }
+        canonicalized[canonicalKey] = Array.from(byBridge.values());
+    }
+    return canonicalized;
+}
+/**
+ * Canonicalizes the keys of a domain-or-chain-name keyed map to domain ids,
+ * mirroring canonicalizeAllowedRebalancingBridges, so a name-keyed source
+ * config does not read as drift against the domain-id-keyed on-chain state.
+ * When two source keys collapse to the same domain their values are combined
+ * via `merge`. Keys the resolver does not recognize are kept as-is rather than
+ * erroring the whole route check.
+ */
+export function canonicalizeDomainKeyedMap(map, resolveDomainId, merge) {
+    const canonicalized = {};
+    for (const [domainOrChain, value] of Object.entries(map)) {
+        const canonicalKey = resolveDomainId(domainOrChain)?.toString() ?? domainOrChain;
+        canonicalized[canonicalKey] = merge(canonicalized[canonicalKey], value);
+    }
+    return canonicalized;
+}
+export function mergeRebalanceTargets(existing, incoming) {
+    const byTarget = new Map();
+    for (const target of [...(existing ?? []), ...incoming]) {
+        const key = target.toLowerCase();
+        if (!byTarget.has(key)) {
+            byTarget.set(key, target);
+        }
+    }
+    return Array.from(byTarget.values());
+}
+/**
+ * Expands a Warp deploy config with additional data
+ *
+ * @param multiProvider
+ * @param warpDeployConfig - The warp deployment config
+ * @param deployedRoutersAddresses - Addresses of deployed routers for each chain
+ * @param virtualConfig - Optional virtual config to include in the warpDeployConfig
+ * @returns A promise resolving to an expanded Warp deploy config with derived and virtual metadata
+ */
+/**
+ * Collects the DelayedFlowRouterHookIsm addresses deployed on every chain
+ * other than `chain`, keyed by chain name as lowercase bytes32 — the expected
+ * `remoteIsms` pairing for `chain`'s own instance. Read from the derived
+ * on-chain configs (nested derived ISM nodes carry their address), so no
+ * extra RPC calls are needed.
+ */
+function collectRemoteDelayedFlowIsms(chain, expandedOnChainWarpConfig) {
+    const remoteIsms = {};
+    for (const [remoteChain, remoteConfig] of Object.entries(expandedOnChainWarpConfig)) {
+        if (remoteChain === chain)
+            continue;
+        if (typeof remoteConfig.interchainSecurityModule !== 'object')
+            continue;
+        for (const node of collectHybridIsmNodes(remoteConfig.interchainSecurityModule)) {
+            if (node.type !== IsmType.DELAYED_FLOW_ROUTER)
+                continue;
+            if (!('address' in node) || typeof node.address !== 'string')
+                continue;
+            remoteIsms[remoteChain] = addressToBytes32(node.address).toLowerCase();
+        }
+    }
+    return remoteIsms;
+}
+/**
+ * Mirrors the completed hybrid ISM leaf into its hook-tree declaration. The
+ * route preflight requires exactly one identical leaf on both surfaces; using
+ * the already-completed ISM node here keeps warpRouter/default ownership and
+ * derived remoteIsms resolution single-sourced.
+ */
+export function completeHybridHookNodesFromIsm(hook, completedIsm) {
+    const hookNodes = collectHybridHookNodes(hook);
+    const ismNodes = collectHybridIsmNodes(completedIsm);
+    assert(hookNodes.length === 1 && ismNodes.length === 1, `Expected exactly one hybrid hook/ISM node on each config surface, found ${hookNodes.length} hook node(s) and ${ismNodes.length} ISM node(s)`);
+    const completedNode = ismNodes[0];
+    assert(hookNodes[0].type === completedNode.type, `Hybrid hook/ISM type mismatch: hook has ${hookNodes[0].type}, ISM has ${completedNode.type}`);
+    return mapHybridHookNodes(hook, () => completedNode);
+}
+export async function expandWarpDeployConfig(params) {
+    const { multiProvider, warpDeployConfig, deployedRoutersAddresses, expandedOnChainWarpConfig, validateScale = true, } = params;
+    const derivedTokenMetadata = await deriveTokenMetadata(multiProvider, warpDeployConfig, { validateScale });
+    // If the token is on an EVM chain check if it is deployed as a proxy
+    // to expand the proxy config too
+    const isDeployedAsProxyByChain = await promiseObjAll(objMap(deployedRoutersAddresses, async (chain, address) => {
+        if (!isEVMLike(multiProvider.getProtocol(chain))) {
+            return false;
+        }
+        return isProxy(multiProvider.getProvider(chain), address);
+    }));
+    return promiseObjAll(objMap(warpDeployConfig, async (chain, config) => {
+        const [remoteRouters, destinationGas] = getDefaultRemoteRouterAndDestinationGasConfig(multiProvider, chain, deployedRoutersAddresses, warpDeployConfig);
+        const chainConfig = {
+            // Default Expansion
+            name: derivedTokenMetadata.getName(chain),
+            symbol: derivedTokenMetadata.getSymbol(chain),
+            decimals: derivedTokenMetadata.getDecimals(chain),
+            scale: derivedTokenMetadata.getScale(chain),
+            remoteRouters,
+            destinationGas,
+            hook: zeroAddress,
+            interchainSecurityModule: zeroAddress,
+            proxyAdmin: isDeployedAsProxyByChain[chain]
+                ? { owner: config.owner }
+                : undefined,
+            isNft: false,
+            // User-specified config takes precedence
+            ...config,
+        };
+        if (chainConfig.proxyAdmin) {
+            chainConfig.proxyAdmin = {
+                ...chainConfig.proxyAdmin,
+                owner: config.ownerOverrides?.proxyAdmin ??
+                    chainConfig.proxyAdmin.owner ??
+                    config.owner,
+            };
+        }
+        // Hybrid hook/ISM trees: complete the expected nodes with the values
+        // the warp deploy machinery manages (warpRouter = the token itself;
+        // remoteIsms = the cross-chain DelayedFlowRouterHookIsm pairing, read
+        // from the other chains' derived on-chain trees). Deploy wires the
+        // explicitly declared single hybrid instance as BOTH the token's ISM
+        // (in-tree) and its hook.
+        if (typeof config.interchainSecurityModule === 'object' &&
+            ismTreeContainsHybridHookIsm(config.interchainSecurityModule)) {
+            const routerAddress = deployedRoutersAddresses[chain];
+            assert(routerAddress, `Missing deployed router address for ${chain}, which declares a hybrid hook/ISM`);
+            const remoteDelayedFlowIsms = expandedOnChainWarpConfig
+                ? collectRemoteDelayedFlowIsms(chain, expandedOnChainWarpConfig)
+                : undefined;
+            const completedIsm = completeHybridIsmNodes(config.interchainSecurityModule, routerAddress, {
+                type: DelayedFlowRemoteIsmsSourceType.Resolved,
+                derived: remoteDelayedFlowIsms,
+            }, config.owner, multiProvider);
+            chainConfig.interchainSecurityModule = completedIsm;
+            if (config.hook === undefined) {
+                const completedHybridNodes = collectHybridIsmNodes(completedIsm);
+                assert(completedHybridNodes.length === 1, `Expected exactly one hybrid hook/ISM node on ${chain}, found ${completedHybridNodes.length}`);
+                chainConfig.hook = completedHybridNodes[0];
+            }
+            else if (typeof config.hook === 'object' &&
+                collectHybridHookNodes(config.hook).length > 0) {
+                chainConfig.hook = completeHybridHookNodesFromIsm(config.hook, completedIsm);
+            }
+        }
+        // Properly set the remote routers addresses to their 32 bytes representation
+        // as that is how they are set on chain
+        const formattedRemoteRouters = objMap(chainConfig.remoteRouters ?? {}, (_domainId, { address }) => ({
+            address: addressToBytes32(address),
+        }));
+        chainConfig.remoteRouters = formattedRemoteRouters;
+        const selfDomain = multiProvider.getDomainId(chain).toString();
+        const ccrGasDomains = isCrossCollateralTokenConfig(chainConfig)
+            ? Object.keys(chainConfig.crossCollateralRouters ?? {}).filter((domain) => domain !== selfDomain)
+            : [];
+        const gasDomainsToKeep = new Set([
+            ...Object.keys(formattedRemoteRouters),
+            ...ccrGasDomains,
+        ]);
+        // CrossCollateralRouter may require destination gas for CCR-only domains
+        // that are not present in Router._routers.
+        if (isCrossCollateralTokenConfig(chainConfig)) {
+            for (const domain of ccrGasDomains) {
+                gasDomainsToKeep.add(domain);
+                // Ensure CCR-only destinations get destinationGas defaults so
+                // warp check/apply can enforce gas config on enrolled CCR domains.
+                if (!chainConfig.destinationGas?.[domain]) {
+                    chainConfig.destinationGas = {
+                        ...chainConfig.destinationGas,
+                        [domain]: chainConfig.gas?.toString() ||
+                            gasOverhead(chainConfig.type).toString(),
+                    };
+                }
+            }
+        }
+        const remoteGasDomainsToKeep = intersection(new Set(Object.keys(chainConfig.destinationGas ?? {})), gasDomainsToKeep);
+        // If the deploy config specified a custom config for remote routers
+        // we should not have all the gas settings set
+        const formattedDestinationGas = objFilter(chainConfig.destinationGas ?? {}, (domainId, _gasSetting) => remoteGasDomainsToKeep.has(domainId));
+        chainConfig.destinationGas = formattedDestinationGas;
+        // allowedRebalancingBridges keys accept either a chain name or a domain
+        // id (RemoteRouterDomainOrChainNameSchema). The on-chain reader emits
+        // domain-id keys, so canonicalize to domain ids here — as we do for
+        // remoteRouters/destinationGas — so a name-keyed source config does not
+        // read as drift against on-chain state.
+        if (isMovableCollateralTokenConfig(chainConfig) &&
+            chainConfig.allowedRebalancingBridges) {
+            chainConfig.allowedRebalancingBridges =
+                canonicalizeAllowedRebalancingBridges(chainConfig.allowedRebalancingBridges, (domainOrChain) => multiProvider.tryGetDomainId(domainOrChain) ?? undefined);
+        }
+        // rebalanceTargets/rebalanceRecipients keys likewise accept a chain name
+        // or a domain id (RemoteRouterDomainOrChainNameSchema) while the on-chain
+        // reader emits domain-id keys, so canonicalize them the same way to avoid
+        // a false ConfigMismatch on a name-keyed source config.
+        if (isCrossCollateralTokenConfig(chainConfig)) {
+            const resolveDomainId = (domainOrChain) => multiProvider.tryGetDomainId(domainOrChain) ?? undefined;
+            if (chainConfig.rebalanceTargets) {
+                chainConfig.rebalanceTargets = canonicalizeDomainKeyedMap(chainConfig.rebalanceTargets, resolveDomainId, mergeRebalanceTargets);
+            }
+            if (chainConfig.rebalanceRecipients) {
+                chainConfig.rebalanceRecipients = canonicalizeDomainKeyedMap(chainConfig.rebalanceRecipients, resolveDomainId, (_existing, incoming) => incoming);
+            }
+        }
+        const protocol = multiProvider.getProtocol(chain);
+        const isEVMChain = isEVMLike(protocol);
+        // Expand EVM warpDeployConfig virtual to the control states (states that we expect)
+        // For contractVerificationStatus, all values should be 'verified'
+        // For ownerStatus, all values should be 'active or 'gnosisSafe'
+        if (isEVMChain &&
+            expandedOnChainWarpConfig?.[chain]?.contractVerificationStatus) {
+            // For most cases, we set to Verified
+            chainConfig.contractVerificationStatus = objMap(expandedOnChainWarpConfig[chain].contractVerificationStatus ?? {}, (_, status) => {
+                switch (status) {
+                    case ContractVerificationStatus.Skipped:
+                    case ContractVerificationStatus.Verified:
+                        return status; // Pass through the status so diffs will be shown
+                    case ContractVerificationStatus.Unverified:
+                    case ContractVerificationStatus.Error:
+                        return ContractVerificationStatus.Verified;
+                }
+            });
+        }
+        if (isEVMChain && expandedOnChainWarpConfig?.[chain]?.ownerStatus) {
+            // For 'active' or 'gnosis-safe', we set their actual state as the control because they are both acceptable.
+            // For other cases, we expect 'active'. Accepting an Inactive owner (e.g.
+            // a nonce-less governance ICA on Tron/AltVM) is a governance decision
+            // handled by the caller via `acceptedInactiveOwners` in
+            // `checkWarpRouteDeployConfig`, not here.
+            chainConfig.ownerStatus = objMap(expandedOnChainWarpConfig[chain].ownerStatus ?? {}, (_ownerAddress, status) => {
+                switch (status) {
+                    // Skipped for local e2e testing
+                    case OwnerStatus.Skipped:
+                    case OwnerStatus.Active:
+                    case OwnerStatus.GnosisSafe:
+                        return status; // Pass through the status so diffs will be shown
+                    case OwnerStatus.Error:
+                    case OwnerStatus.Inactive:
+                        return OwnerStatus.Active;
+                }
+            });
+        }
+        // Expand the hook config only if we have an explicit config in the deploy config
+        // (not just an address string for EVM - those are left as-is to avoid deriving)
+        if (chainConfig.hook && typeof chainConfig.hook !== 'string') {
+            switch (protocol) {
+                case ProtocolType.Tron:
+                case ProtocolType.Ethereum: {
+                    const reader = new EvmHookReader(multiProvider, chain);
+                    chainConfig.hook = await reader.deriveHookConfig(chainConfig.hook);
+                    break;
+                }
+                default: {
+                    // For non-EVM chains: config objects are kept as-is (no recursive expansion support)
+                    // TODO: Handle HookConfig objects (nested config expansion) when Artifact API adds support
+                    break;
+                }
+            }
+        }
+        // Expand the ism config only if we have an explicit config in the deploy config
+        // (not just an address string for EVM - those are left as-is to avoid deriving)
+        if (chainConfig.interchainSecurityModule &&
+            typeof chainConfig.interchainSecurityModule !== 'string') {
+            switch (protocol) {
+                case ProtocolType.Tron:
+                case ProtocolType.Ethereum: {
+                    const reader = new EvmIsmReader(multiProvider, chain);
+                    chainConfig.interchainSecurityModule = await reader.deriveIsmConfig(chainConfig.interchainSecurityModule);
+                    break;
+                }
+                default: {
+                    // For non-EVM chains: config objects are kept as-is (no recursive expansion support)
+                    // TODO: Handle IsmConfig objects (nested config expansion) when Artifact API adds support
+                    break;
+                }
+            }
+        }
+        if (chainConfig.tokenFee) {
+            const routerAddress = deployedRoutersAddresses[chain];
+            assert(routerAddress, `Missing deployed router address for ${chain}`);
+            chainConfig.tokenFee = await resolveTokenFeeAddress(chainConfig.tokenFee, routerAddress, chainConfig, multiProvider.getProvider(chain));
+        }
+        return chainConfig;
+    }));
+}
+export function normalizeWarpDeployConfigForCheck(params) {
+    const { multiProvider, warpDeployConfig } = params;
+    return objMap(warpDeployConfig, (_chain, config) => {
+        if (isDepositAddressTokenConfig(config)) {
+            return {
+                ...config,
+                mailbox: constants.AddressZero,
+                interchainSecurityModule: constants.AddressZero,
+                remoteRouters: {},
+                destinationGas: undefined,
+            };
+        }
+        if (!isOftTokenConfig(config)) {
+            return config;
+        }
+        return {
+            ...config,
+            mailbox: constants.AddressZero,
+            hook: constants.AddressZero,
+            interchainSecurityModule: constants.AddressZero,
+            remoteRouters: {},
+            destinationGas: undefined,
+            domainMappings: resolveRouterMapConfig(multiProvider, config.domainMappings),
+            extraOptions: config.extraOptions === '0x' ? undefined : config.extraOptions,
+        };
+    });
+}
+/**
+ * Resolves the fee token address based on the warp route token type.
+ * - Native tokens: fee token is AddressZero
+ * - Collateral tokens: fee token is the collateral token address
+ * - xERC20 / xERC20Lockbox tokens: the fee token is read on-chain from the
+ *   deployed router's immutable wrappedToken() rather than trusting
+ *   tokenConfig.token. Plain xERC20 wrappedToken() returns the wrapped xERC20,
+ *   while xERC20Lockbox wrappedToken() returns the underlying wrapped ERC20,
+ *   NOT the lockbox address stored in tokenConfig.token. wrappedToken() (not
+ *   token()) is used because it is an immutable getter present across router
+ *   versions: on legacy routers (e.g. 6.1.0) token() reverts, and fee
+ *   resolution runs at plan time BEFORE the router is upgraded, so reading
+ *   token() there would revert when adding a fee in the same warp apply that
+ *   also upgrades the contract. In current routers token() == wrappedToken(),
+ *   so the resolved fee token still matches the router's fee==token() check.
+ * - Synthetic tokens: fee token is the router address (the HypERC20 itself)
+ */
+async function getFeeTokenAddress(routerAddress, tokenConfig, provider) {
+    if (isNativeTokenConfig(tokenConfig)) {
+        return constants.AddressZero;
+    }
+    if (tokenConfig.type === TokenType.XERC20Lockbox) {
+        return HypXERC20Lockbox__factory.connect(routerAddress, provider).wrappedToken();
+    }
+    if (isXERC20TokenConfig(tokenConfig)) {
+        return HypXERC20__factory.connect(routerAddress, provider).wrappedToken();
+    }
+    if (isCollateralTokenConfig(tokenConfig) ||
+        isCrossCollateralTokenConfig(tokenConfig)) {
+        return tokenConfig.token;
+    }
+    if (isSyntheticTokenConfig(tokenConfig) ||
+        isSyntheticRebaseTokenConfig(tokenConfig)) {
+        return routerAddress;
+    }
+    throw new Error(`Unsupported token type for fee resolution`);
+}
+/**
+ * Applies an already-resolved fee token to a (possibly nested) fee config.
+ * Pure and synchronous: every nesting level of a routing fee shares the same
+ * router/token, so the fee token is resolved once by the caller and threaded
+ * through here without additional RPC calls.
+ */
+function applyFeeTokenAddress(feeConfig, feeToken) {
+    const owner = feeConfig.owner;
+    assert(owner, `Owner is required to resolve ${feeConfig.type} fee config`);
+    if (feeConfig.type === TokenFeeType.RoutingFee) {
+        return {
+            ...feeConfig,
+            owner,
+            token: feeToken,
+            feeContracts: objMap(feeConfig.feeContracts, (_chain, subFee) => applyFeeTokenAddress(subFee, feeToken)),
+        };
+    }
+    if (feeConfig.type === TokenFeeType.CrossCollateralRoutingFee) {
+        return {
+            ...feeConfig,
+            owner,
+            feeContracts: objMap(feeConfig.feeContracts, (_chain, destinationConfig) => objMap(destinationConfig, (_router, subFee) => applyFeeTokenAddress(subFee, feeToken))),
+        };
+    }
+    return {
+        ...feeConfig,
+        owner,
+        token: feeToken,
+    };
+}
+export async function resolveTokenFeeAddress(feeConfig, routerAddress, tokenConfig, provider) {
+    const feeToken = await getFeeTokenAddress(routerAddress, tokenConfig, provider);
+    return applyFeeTokenAddress(feeConfig, feeToken);
+}
+export async function expandVirtualWarpDeployConfig(params) {
+    const { multiProvider, onChainWarpConfig, deployedRoutersAddresses } = params;
+    return promiseObjAll(objMap(onChainWarpConfig, async (chain, config) => {
+        const warpReader = new EvmWarpRouteReader(multiProvider, chain);
+        const warpVirtualConfig = await warpReader.deriveWarpRouteVirtualConfig(chain, deployedRoutersAddresses[chain]);
+        return {
+            ...warpVirtualConfig,
+            ...config,
+            hook: config.hook ?? zeroAddress,
+        };
+    }));
+}
+const transformWarpDeployConfigToCheck = (obj, propPath) => {
+    // Needed to check if we are currently inside the remoteRouters object
+    const maybeRemoteRoutersKey = propPath[propPath.length - 3];
+    const parentObjectKey = propPath[propPath.length - 2];
+    const parentKey = propPath[propPath.length - 1];
+    // Remove the address and ownerOverrides fields if we are not inside the
+    // remoteRouters property
+    if ((parentKey === 'address' &&
+        maybeRemoteRoutersKey !== 'remoteRouters' &&
+        parentObjectKey !== 'proxyAdmin') ||
+        parentKey === 'ownerOverrides') {
+        return undefined;
+    }
+    if (typeof obj === 'string' && parentKey !== 'type' && isAddressEvm(obj)) {
+        return obj.toLowerCase();
+    }
+    return obj;
+};
+const sortArraysInConfigToCheck = (a, b) => {
+    if (a.type && b.type) {
+        if (a.type < b.type)
+            return -1;
+        if (a.type > b.type)
+            return 1;
+        return 0;
+    }
+    // Sort allowedRebalancingBridges by bridge address
+    if (a.bridge && b.bridge) {
+        if (a.bridge < b.bridge)
+            return -1;
+        if (a.bridge > b.bridge)
+            return 1;
+        return 0;
+    }
+    // Sort xERC20 extraBridges by the bridge they hold limits for. The derived
+    // side is ordered by the events the token emitted and the expected side by
+    // whoever wrote the deploy config, so without this the same set of bridges
+    // in two orders diffs index by index and reports drift that is not there.
+    if (a.lockbox && b.lockbox) {
+        if (a.lockbox < b.lockbox)
+            return -1;
+        if (a.lockbox > b.lockbox)
+            return 1;
+        return 0;
+    }
+    if (a < b)
+        return -1;
+    if (a > b)
+        return 1;
+    return 0;
+};
+const FIELDS_TO_IGNORE = new Set([
+    // gas is removed because the destinationGas is the result of
+    // expanding the config based on the gas value for each chain
+    // see `expandWarpDeployConfig` function
+    'gas',
+    // Removing symbol and token metadata as they are not critical for
+    // checking, even if they are set "incorrectly" they do not affect how
+    // the warp route works
+    'symbol',
+    'name',
+    // Timelocks are validated by warpCheck against the actual ProxyAdmin owner.
+    'timelock',
+]);
+// Nested LinearFee sub-fee owners are intentionally excluded from the warp
+// check. A LinearFee owner's only lever is setFee (bps), and bps is compared
+// directly, so its owner carries no additional security-relevant authority.
+// Collapsing nested LinearFee owners to a fixed sentinel on both sides of the
+// diff makes that owner drift invisible while the top-level RoutingFee owner
+// (which controls setFeeContract routing and claim) still diffs normally.
+//
+// OffchainQuotedLinearFee owners are NOT collapsed: that owner additionally
+// controls addQuoteSigner/removeQuoteSigner, a live pricing authority, so its
+// drift must remain visible and is always compared against the real owner.
+const IGNORED_SUB_FEE_OWNER = constants.AddressZero;
+function normalizeCrossCollateralFeeContractsForCheck(destinationConfig) {
+    return Object.fromEntries(Object.entries(destinationConfig).map(([router, nestedFee]) => [
+        router,
+        normalizeTokenFeeForCheck(nestedFee, true),
+    ]));
+}
+function normalizeTokenFeeForCheck(feeConfig, isNested = false) {
+    if (!feeConfig)
+        return feeConfig;
+    const tokenConfig = 'token' in feeConfig && feeConfig.token ? { token: feeConfig.token } : {};
+    const owner = isNested ? IGNORED_SUB_FEE_OWNER : feeConfig.owner;
+    if (feeConfig.type === TokenFeeType.RoutingFee) {
+        const normalizedFeeContracts = Object.fromEntries(Object.entries(feeConfig.feeContracts).map(([chain, nestedFee]) => [
+            chain,
+            normalizeTokenFeeForCheck(nestedFee, true),
+        ]));
+        return {
+            type: TokenFeeType.RoutingFee,
+            owner,
+            ...tokenConfig,
+            feeContracts: normalizedFeeContracts,
+        };
+    }
+    if (feeConfig.type === TokenFeeType.CrossCollateralRoutingFee) {
+        const normalizedFeeContracts = Object.fromEntries(Object.keys(feeConfig.feeContracts).map((chain) => [
+            chain,
+            normalizeCrossCollateralFeeContractsForCheck(feeConfig.feeContracts[chain]),
+        ]));
+        return {
+            type: TokenFeeType.CrossCollateralRoutingFee,
+            owner,
+            feeContracts: normalizedFeeContracts,
+        };
+    }
+    if (feeConfig.type === TokenFeeType.OffchainQuotedLinearFee) {
+        // OQLF owner controls quote-signer management, so compare the real owner
+        // even when nested rather than collapsing to the sentinel.
+        return {
+            type: feeConfig.type,
+            owner: feeConfig.owner,
+            bps: feeConfig.bps,
+            ...tokenConfig,
+            quoteSigners: feeConfig.quoteSigners,
+        };
+    }
+    if (feeConfig.type === TokenFeeType.LinearFee) {
+        return {
+            type: feeConfig.type,
+            owner,
+            bps: feeConfig.bps,
+            ...tokenConfig,
+        };
+    }
+    return feeConfig;
+}
+/**
+ * transforms the provided {@link HypTokenRouterConfig}, removing the address, totalSupply and ownerOverrides
+ * field where they are not required for the config comparison
+ */
+export function transformConfigToCheck(obj) {
+    const filteredObj = Object.fromEntries(Object.entries(obj).filter(([key, _value]) => !FIELDS_TO_IGNORE.has(key)));
+    const clonedTokenConfig = deepCopy(filteredObj);
+    if (isMovableCollateralTokenConfig(clonedTokenConfig)) {
+        clonedTokenConfig.allowedRebalancers = clonedTokenConfig.allowedRebalancers
+            ?.length
+            ? clonedTokenConfig.allowedRebalancers
+            : undefined;
+        clonedTokenConfig.allowedRebalancingBridges = !isObjEmpty(clonedTokenConfig.allowedRebalancingBridges ?? {})
+            ? clonedTokenConfig.allowedRebalancingBridges
+            : undefined;
+    }
+    if (clonedTokenConfig.tokenFee) {
+        clonedTokenConfig.tokenFee = normalizeTokenFeeForCheck(clonedTokenConfig.tokenFee);
+    }
+    // normalizeScale(undefined) -> {1n,1n}, matching EvmWarpRouteReader.fetchScale's
+    // identity-collapse so both sides of the diff agree symmetrically.
+    clonedTokenConfig.scale = normalizeScale(clonedTokenConfig.scale);
+    return sortArraysInObject(transformObj(clonedTokenConfig, transformWarpDeployConfigToCheck), sortArraysInConfigToCheck);
+}
+/**
+ * Splits warp deploy config into existing and extended configurations based on warp core chains
+ * for the warp apply process.
+ */
+export function splitWarpCoreAndExtendedConfigs(warpDeployConfig, warpCoreChains) {
+    return Object.entries(warpDeployConfig).reduce(([existing, extended], [chain, config]) => {
+        if (warpCoreChains.includes(chain)) {
+            existing[chain] = config;
+        }
+        else {
+            extended[chain] = config;
+        }
+        return [existing, extended];
+    }, [{}, {}]);
+}
+//# sourceMappingURL=configUtils.js.map