Bridging your custom ERC-20 token using 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