Create an L2 token for the Standard Bridge

// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;

// Import the standard ERC20 implementation from OpenZeppelin
import { ERC20 } from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import { IERC165 } from "@openzeppelin/contracts/utils/introspection/IERC165.sol";

/**
* @title ILegacyMintableERC20
* @notice Legacy interface for the StandardL2ERC20 contract.
*/
interface ILegacyMintableERC20 {
function mint(address _to, uint256 _amount) external;
function burn(address _from, uint256 _amount) external;

function l1Token() external view returns (address);
function l2Bridge() external view returns (address);
}

/**
* @title IOptimismMintableERC20
* @notice Interface for the OptimismMintableERC20 contract.
*/
interface IOptimismMintableERC20 {
function remoteToken() external view returns (address);
function bridge() external view returns (address);
function mint(address _to, uint256 _amount) external;
function burn(address _from, uint256 _amount) external;
}

/**
* @title Simplified Semver for tutorial
* @notice Simple contract to track semantic versioning
*/
contract Semver {
string public version;

// Simple function to convert uint to string for version numbers
function toString(uint256 value) internal pure returns (string memory) {
    // This function handles numbers from 0 to 999 which is sufficient for versioning
    if (value == 0) {
        return "0";
    }
    
    uint256 temp = value;
    uint256 digits;
    
    while (temp != 0) {
        digits++;
        temp /= 10;
    }
    
    bytes memory buffer = new bytes(digits);
    
    while (value != 0) {
        digits -= 1;
        buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
        value /= 10;
    }
    
    return string(buffer);
}

constructor(uint256 major, uint256 minor, uint256 patch) {
    version = string(abi.encodePacked(
        toString(major),
        ".",
        toString(minor),
        ".",
        toString(patch)
    ));
}
}

/**
* @title MyCustomL2Token
* @notice A custom L2 token based on OptimismMintableERC20 that can be deposited 
*         from L1 to L2, but cannot be withdrawn from L2 to L1.
*/
contract MyCustomL2Token is IOptimismMintableERC20, ILegacyMintableERC20, ERC20, Semver {
/// @notice Address of the corresponding token on the remote chain.
address public immutable REMOTE_TOKEN;

/// @notice Address of the StandardBridge on this network.
address public immutable BRIDGE;

/// @notice Emitted whenever tokens are minted for an account.
/// @param account Address of the account tokens are being minted for.
/// @param amount  Amount of tokens minted.
event Mint(address indexed account, uint256 amount);

/// @notice Emitted whenever tokens are burned from an account.
/// @param account Address of the account tokens are being burned from.
/// @param amount  Amount of tokens burned.
event Burn(address indexed account, uint256 amount);

/// @notice A modifier that only allows the bridge to call
modifier onlyBridge() {
    require(msg.sender == BRIDGE, "MyCustomL2Token: only bridge can mint and burn");
    _;
}

/// @param _bridge      Address of the L2 standard bridge.
/// @param _remoteToken Address of the corresponding L1 token.
/// @param _name        ERC20 name.
/// @param _symbol      ERC20 symbol.
constructor(
    address _bridge,
    address _remoteToken,
    string memory _name,
    string memory _symbol
)
    ERC20(_name, _symbol)
    Semver(1, 0, 0)
{
    REMOTE_TOKEN = _remoteToken;
    BRIDGE = _bridge;
}

/// @notice Allows the StandardBridge on this network to mint tokens.
/// @param _to     Address to mint tokens to.
/// @param _amount Amount of tokens to mint.
function mint(
    address _to,
    uint256 _amount
)
    external
    virtual
    override(IOptimismMintableERC20, ILegacyMintableERC20)
    onlyBridge
{
    _mint(_to, _amount);
    emit Mint(_to, _amount);
}

/// @notice Burns tokens from an account.
/// @dev This function always reverts to prevent withdrawals to L1.
/// @param _from   Address to burn tokens from.
/// @param _amount Amount of tokens to burn.
function burn(
    address _from,
    uint256 _amount
)
    external
    virtual
    override(IOptimismMintableERC20, ILegacyMintableERC20)
    onlyBridge
{
    // Instead of calling _burn(_from, _amount), we revert
    // This makes it impossible to withdraw tokens back to L1
    revert("MyCustomL2Token: withdrawals are not allowed");
    
    // Note: The following line would normally execute but is unreachable
    // _burn(_from, _amount);
    // emit Burn(_from, _amount);
}

/// @notice ERC165 interface check function.
/// @param _interfaceId Interface ID to check.
/// @return Whether or not the interface is supported by this contract.
function supportsInterface(bytes4 _interfaceId) external pure virtual returns (bool) {
    bytes4 iface1 = type(IERC165).interfaceId;
    // Interface corresponding to the legacy L2StandardERC20
    bytes4 iface2 = type(ILegacyMintableERC20).interfaceId;
    // Interface corresponding to the updated OptimismMintableERC20
    bytes4 iface3 = type(IOptimismMintableERC20).interfaceId;
    return _interfaceId == iface1 || _interfaceId == iface2 || _interfaceId == iface3;
}

/// @notice Legacy getter for the remote token. Use REMOTE_TOKEN going forward.
function l1Token() public view override returns (address) {
    return REMOTE_TOKEN;
}

/// @notice Legacy getter for the bridge. Use BRIDGE going forward.
function l2Bridge() public view override returns (address) {
    return BRIDGE;
}

/// @notice Getter for REMOTE_TOKEN.
function remoteToken() public view override returns (address) {
    return REMOTE_TOKEN;
}

/// @notice Getter for BRIDGE.
function bridge() public view override returns (address) {
    return BRIDGE;
}
}

/// @notice Burns tokens from an account.
/// @dev This function always reverts to prevent withdrawals to L1.
/// @param _from   Address to burn tokens from.
/// @param _amount Amount of tokens to burn.
function burn(
    address _from,
    uint256 _amount
)
    external
    virtual
    override(IOptimismMintableERC20, ILegacyMintableERC20)
    onlyBridge
{
    // Instead of calling _burn(_from, _amount), we revert
    // This makes it impossible to withdraw tokens back to L1
    revert("MyCustomL2Token: withdrawals are not allowed");
    
    // Note: The following line would normally execute but is unreachable
    // _burn(_from, _amount);
    // emit Burn(_from, _amount);
}

_bridge:      "0x4200000000000000000000000000000000000010" // L2 Standard Bridge address
_remoteToken: "<L1 ERC-20 address>"                        // Your L1 token address
_name:        "My Custom L2 Token"                         // Your token name
_symbol:      "MCL2T"                                      // Your token symbol