Polygon Adapter

constructor(
    IRootChainManager _rootChainManager,
    IFxStateSender _fxStateSender,
    DepositManager _depositManager,
    address _erc20Predicate,
    address _l1Matic,
    WETH9Interface _l1Weth,
    IERC20 _l1Usdc,
    ITokenMessenger _cctpTokenMessenger,
    address _adapterStore,
    uint32 _oftDstEid,
    uint256 _oftFeeCap
)

IRootChainManager public immutable ROOT_CHAIN_MANAGER;
IFxStateSender public immutable FX_STATE_SENDER;
DepositManager public immutable DEPOSIT_MANAGER;
address public immutable ERC20_PREDICATE;
address public immutable L1_MATIC;
WETH9Interface public immutable L1_WETH;

function relayMessage(address target, bytes calldata message) external payable override {
    FX_STATE_SENDER.sendMessageToChild(target, message);
    emit MessageRelayed(target, message);
}

function relayTokens(
    address l1Token,
    address l2Token,
    uint256 amount,
    address to
) external payable override {
    address oftMessenger = _getOftMessenger(l1Token);

    // 1. WETH: Unwrap and bridge native ETH
    if (l1Token == address(L1_WETH)) {
        L1_WETH.withdraw(amount);
        ROOT_CHAIN_MANAGER.depositEtherFor{ value: amount }(to);
    }
    // 2. USDC: Use Circle CCTP
    else if (_isCCTPEnabled() && l1Token == address(usdcToken)) {
        _transferUsdc(to, amount);
    }
    // 3. OFT tokens: Use LayerZero
    else if (oftMessenger != address(0)) {
        _transferViaOFT(IERC20(l1Token), IOFT(oftMessenger), to, amount);
    }
    // 4. MATIC: Use Plasma bridge
    else if (l1Token == L1_MATIC) {
        IERC20(l1Token).safeIncreaseAllowance(address(DEPOSIT_MANAGER), amount);
        DEPOSIT_MANAGER.depositERC20ForUser(l1Token, to, amount);
    }
    // 5. Other ERC20s: Use PoS bridge
    else {
        IERC20(l1Token).safeIncreaseAllowance(ERC20_PREDICATE, amount);
        ROOT_CHAIN_MANAGER.depositFor(to, l1Token, abi.encode(amount));
    }
    emit TokensRelayed(l1Token, l2Token, amount, to);
}

interface IFxStateSender {
    /**
     * @notice Send arbitrary message to Polygon.
     * @param _receiver Address on Polygon to receive message.
     * @param _data Message to send to _receiver on Polygon.
     */
    function sendMessageToChild(address _receiver, bytes calldata _data) external;
}

// In Polygon_SpokePool.sol
function processMessageFromRoot(
    uint256 /* stateId */,
    address rootMessageSender,
    bytes calldata data
) external {
    require(msg.sender == address(FX_CHILD), "Only FxChild");
    require(rootMessageSender == hubPool, "Only HubPool");
    
    // Execute admin function
    (bool success, ) = address(this).call(data);
    require(success, "Call failed");
}

interface IRootChainManager {
    /**
     * @notice Send msg.value of ETH to Polygon
     * @param user Recipient of ETH on Polygon.
     */
    function depositEtherFor(address user) external payable;

    /**
     * @notice Send ERC20 tokens to Polygon.
     * @param user Recipient of L2 equivalent tokens on Polygon.
     * @param rootToken L1 Address of token to send.
     * @param depositData Data to pass to L2 including amount. Should be abi.encode(amount).
     */
    function depositFor(
        address user,
        address rootToken,
        bytes calldata depositData
    ) external;
}

IERC20(l1Token).safeIncreaseAllowance(ERC20_PREDICATE, amount);
ROOT_CHAIN_MANAGER.depositFor(to, l1Token, abi.encode(amount));

interface DepositManager {
    /**
     * @notice Send tokens to Polygon. Only used to send MATIC.
     * @param token L1 token to send. Should be MATIC.
     * @param user Recipient of L2 equivalent tokens on Polygon.
     * @param amount Amount of token to send.
     */
    function depositERC20ForUser(address token, address user, uint256 amount) external;
}

if (l1Token == L1_MATIC) {
    IERC20(l1Token).safeIncreaseAllowance(address(DEPOSIT_MANAGER), amount);
    DEPOSIT_MANAGER.depositERC20ForUser(l1Token, to, amount);
}

else if (_isCCTPEnabled() && l1Token == address(usdcToken)) {
    _transferUsdc(to, amount);
}

address oftMessenger = _getOftMessenger(l1Token);
if (oftMessenger != address(0)) {
    _transferViaOFT(IERC20(l1Token), IOFT(oftMessenger), to, amount);
}

// On HubPool
bytes memory functionData = abi.encodeCall(
    SpokePool.setEnableRoute,
    (originToken, destinationChainId, enabled)
);

hubPool.relaySpokePoolAdminFunction(
    137,  // Polygon chain ID
    functionData
);

// Internally calls:
// Polygon_Adapter.relayMessage(spokePoolAddress, functionData)
// -> FX_STATE_SENDER.sendMessageToChild(spokePoolAddress, functionData)

// WETH is unwrapped and bridged as native ETH
hubPool.relayTokens(
    WETH_L1,
    WETH_POLYGON,  // Receives ETH on Polygon, wrapped by recipient
    5 ether,
    spokePoolAddress
);

// Internally:
// 1. L1_WETH.withdraw(5 ether) -> converts WETH to ETH
// 2. ROOT_CHAIN_MANAGER.depositEtherFor{value: 5 ether}(spokePoolAddress)

// USDC uses Circle CCTP automatically
hubPool.relayTokens(
    USDC_L1,
    USDC_POLYGON,
    10000e6,  // 10,000 USDC
    spokePoolAddress
);

// Uses Circle's TokenMessenger for native USDC

// MATIC uses Plasma bridge
hubPool.relayTokens(
    MATIC_L1,  // 0x7D1AfA7B718fb893dB30A3aBc0Cfc608AaCfeBB0
    MATIC_POLYGON,  // Native token on Polygon
    1000 ether,
    spokePoolAddress
);

// Uses DepositManager.depositERC20ForUser()

// Example: USDT (not using CCTP)
hubPool.relayTokens(
    USDT_L1,
    USDT_POLYGON,
    5000e6,
    spokePoolAddress
);

// Uses RootChainManager PoS bridge
// Approves ERC20_PREDICATE, calls ROOT_CHAIN_MANAGER.depositFor()

// Correct
IERC20(token).safeIncreaseAllowance(ERC20_PREDICATE, amount);
ROOT_CHAIN_MANAGER.depositFor(user, token, data);

// Wrong - will revert
IERC20(token).safeIncreaseAllowance(address(ROOT_CHAIN_MANAGER), amount);

require(msg.sender == address(FX_CHILD), "Only FxChild");
require(rootMessageSender == hubPool, "Only HubPool");