    function deployRemoteInterchainToken(
        string calldata originalChainName,
        bytes32 salt,
        address minter,
        string memory destinationChain,
        uint256 gasValue
    ) external payable returns (bytes32 tokenId) {
        string memory tokenName;
        string memory tokenSymbol;
        uint8 tokenDecimals;
        bytes memory minter_ = new bytes(0);

        {
            bytes32 chainNameHash_;
            if (bytes(originalChainName).length == 0) {
                chainNameHash_ = chainNameHash;
            } else {
                chainNameHash_ = keccak256(bytes(originalChainName));
            }

            address sender = msg.sender;
            salt = interchainTokenSalt(chainNameHash_, sender, salt);
            tokenId = interchainTokenService.interchainTokenId(TOKEN_FACTORY_DEPLOYER, salt);

            IInterchainToken token = IInterchainToken(interchainTokenService.interchainTokenAddress(tokenId));

            tokenName = token.name();
            tokenSymbol = token.symbol();
            tokenDecimals = token.decimals();

            if (minter != address(0)) {
                if (!token.isMinter(minter)) revert NotMinter(minter);

                minter_ = minter.toBytes();
            }
        }

        tokenId = _deployInterchainToken(salt, destinationChain, tokenName, tokenSymbol, tokenDecimals, minter_, gasValue);
    }
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;

import "forge-std/Test.sol";

// Mock MKR token with bytes32 name and symbol
contract MKR {
    bytes32 public constant name = "Maker";
    bytes32 public constant symbol = "MKR";
    uint8 public constant decimals = 18;
    uint256 public totalSupply;
    mapping(address => uint256) public balanceOf;

    constructor(uint256 _totalSupply) {
        totalSupply = _totalSupply;
        balanceOf[msg.sender] = _totalSupply;
    }

    // Other ERC20 functions omitted for brevity
}

// Interface representing how the original code expects ERC20 tokens to behave
interface IERC20WithStringMetadata {
    function name() external view returns (string memory);
    function symbol() external view returns (string memory);
    function decimals() external view returns (uint8);
}

// Simplified InterchainTokenFactory to demonstrate the bug
contract SimplifiedInterchainTokenFactory {
    function deployRemoteInterchainToken(address tokenAddress) external view returns (string memory, string memory, uint8) {
        // This function attempts to read name and symbol as strings, which will fail for MKR
        IERC20WithStringMetadata token = IERC20WithStringMetadata(tokenAddress);
        string memory tokenName = token.name();
        string memory tokenSymbol = token.symbol();
        uint8 tokenDecimals = token.decimals();

        return (tokenName, tokenSymbol, tokenDecimals);
    }
}

contract InterchainTokenFactoryTest is Test {
    MKR public token;
    SimplifiedInterchainTokenFactory public factory;

    function setUp() public {
        token = new MKR(1000000 * 10**18);
        factory = new SimplifiedInterchainTokenFactory();
    }

    function testDeployRemoteInterchainTokenFails() public {
        vm.expectRevert();
        factory.deployRemoteInterchainToken(address(token));
    }
}
