temp

packages/protocol/contracts/L1/TaikoL1.sol

@@ -20,6 +20,7 @@ import {TaikoErrors} from "./TaikoErrors.sol";
 import {TaikoData} from "./TaikoData.sol";
 import {TaikoEvents} from "./TaikoEvents.sol";
 
+/// @custom:security-contact [email protected]
 contract TaikoL1 is
     EssentialContract,
     ICrossChainSync,
@@ -31,6 +32,10 @@ contract TaikoL1 is
     TaikoData.State public state;
     uint256[100] private __gap;
 
+    constructor() {
+        _disableInitializers();
+    }
+
     receive() external payable {
         depositEtherToL2();
     }

packages/protocol/contracts/L1/TaikoToken.sol

@@ -17,7 +17,12 @@ import {
     SafeCastUpgradeable
 } from "@openzeppelin/contracts-upgradeable/utils/math/SafeCastUpgradeable.sol";
 
+library LibTaikoTokenConfig {
+    uint8 public constant DECIMALS = uint8(8);
+}
+
 /// @dev This is Taiko's governance and fee token.
+/// @custom:security-contact [email protected]
 contract TaikoToken is EssentialContract, ERC20Upgradeable, IMintableERC20 {
     using LibMath for uint256;
     using SafeCastUpgradeable for uint256;
@@ -41,6 +46,9 @@ contract TaikoToken is EssentialContract, ERC20Upgradeable, IMintableERC20 {
     /*********************
      * External Functions*
      *********************/
+    constructor() {
+        _disableInitializers();
+    }
 
     /// @dev Initializer to be called after being deployed behind a proxy.
     ///      Based on our simulation in simulate/tokenomics/index.js, both
@@ -59,9 +67,14 @@ contract TaikoToken is EssentialContract, ERC20Upgradeable, IMintableERC20 {
         ERC20Upgradeable.__ERC20_init({
             name_: _name,
             symbol_: _symbol,
-            decimals_: 8
+            decimals_: LibTaikoTokenConfig.DECIMALS
         });
 
+        // __ERC20Burnable_init();
+        // __ERC20Snapshot_init();
+        // __ERC20Permit_init(_name);
+        // __ERC20Votes_init();
+
         for (uint256 i = 0; i < _premintRecipients.length; ++i) {
             _mint(_premintRecipients[i], _premintAmounts[i]);
         }

packages/protocol/contracts/L2/TaikoL2.sol

@@ -16,6 +16,7 @@ import {
     SafeCastUpgradeable
 } from "@openzeppelin/contracts-upgradeable/utils/math/SafeCastUpgradeable.sol";
 
+/// @custom:security-contact [email protected]
 contract TaikoL2 is EssentialContract, TaikoL2Signer, ICrossChainSync {
     using SafeCastUpgradeable for uint256;
     using LibMath for uint256;
@@ -87,6 +88,10 @@ contract TaikoL2 is EssentialContract, TaikoL2Signer, ICrossChainSync {
      * Constructor         *
      **********************/
 
+    constructor() {
+        _disableInitializers();
+    }
+
     function init(
         address _addressManager,
         EIP1559Params calldata _param1559

packages/protocol/contracts/bridge/Bridge.sol

@@ -21,6 +21,7 @@ import {LibBridgeStatus} from "./libs/LibBridgeStatus.sol";
  * Bridge contract which is deployed on both L1 and L2. Mostly a thin wrapper
  * which calls the library implementations. See _IBridge_ for more details.
  * @dev The code hash for the same address on L1 and L2 may be different.
+ * @custom:security-contact [email protected]
  */
 contract Bridge is EssentialContract, IBridge, BridgeErrors {
     using LibBridgeData for Message;
@@ -47,6 +48,10 @@ contract Bridge is EssentialContract, IBridge, BridgeErrors {
      * External Functions*
      *********************/
 
+    constructor() {
+        _disableInitializers();
+    }
+
     /// Allow Bridge to receive ETH from the TokenVault or EtherVault.
     receive() external payable {
         if (

packages/protocol/contracts/bridge/BridgedERC20.sol

@@ -18,6 +18,7 @@ import {EssentialContract} from "../common/EssentialContract.sol";
 import {ERC20Upgradeable} from "../thirdparty/ERC20Upgradeable.sol";
 import {BridgeErrors} from "./BridgeErrors.sol";
 
+/// @custom:security-contact [email protected]
 contract BridgedERC20 is
     EssentialContract,
     IERC20Upgradeable,
@@ -32,6 +33,10 @@ contract BridgedERC20 is
     event BridgeMint(address indexed account, uint256 amount);
     event BridgeBurn(address indexed account, uint256 amount);
 
+    constructor() {
+        _disableInitializers();
+    }
+
     /// @dev Initializer to be called after being deployed behind a proxy.
     // Intention is for a different BridgedERC20 Contract to be deployed
     // per unique _srcToken i.e. one for USDC, one for USDT etc.

packages/protocol/contracts/bridge/EtherVault.sol

@@ -19,6 +19,7 @@ import {LibAddress} from "../libs/LibAddress.sol";
 import {BridgeErrors} from "./BridgeErrors.sol";
 
 /**
+ * @custom:security-contact [email protected]
  * EtherVault is a special vault contract that:
  * - Is initialized with 2^128 Ether.
  * - Allows the contract owner to authorize addresses.
@@ -56,6 +57,9 @@ contract EtherVault is EssentialContract, BridgeErrors {
     /*********************
      * External Functions*
      *********************/
+    constructor() {
+        _disableInitializers();
+    }
 
     receive() external payable {
         // EthVault's balance must == 0 OR the sender isAuthorized.

packages/protocol/contracts/bridge/TokenVault.sol

@@ -26,7 +26,8 @@ import {Strings} from "@openzeppelin/contracts/utils/Strings.sol";
  * It also manages the mapping between canonical ERC20 tokens and their bridged
  * tokens.
  * @dev Ether is held by Bridges on L1 and by the EtherVault on L2,
- * not TokenVaults.
+ *      not TokenVaults.
+ * @custom:security-contact [email protected]
  */
 contract TokenVault is EssentialContract {
     using SafeERC20Upgradeable for ERC20Upgradeable;
@@ -132,6 +133,9 @@ contract TokenVault is EssentialContract {
     /*********************
      * External Functions*
      *********************/
+    constructor() {
+        _disableInitializers();
+    }
 
     function init(address addressManager) external initializer {
         EssentialContract._init(addressManager);

packages/protocol/contracts/common/AddressManager.sol

@@ -39,9 +39,7 @@ interface IAddressManager {
     ) external view returns (address);
 }
 
-/**
- * @title AddressManager
- */
+/// @custom:security-contact [email protected]
 contract AddressManager is OwnableUpgradeable, IAddressManager {
     mapping(uint256 domain => mapping(bytes32 name => address addr))
         private addresses;
@@ -53,6 +51,10 @@ contract AddressManager is OwnableUpgradeable, IAddressManager {
         address _oldAddress
     );
 
+    constructor() {
+        _disableInitializers();
+    }
+
     /// @dev Initializer to be called after being deployed behind a proxy.
     function init() external initializer {
         OwnableUpgradeable.__Ownable_init();

packages/protocol/contracts/gov/TaikoGovernor.sol

@@ -0,0 +1,175 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.18;
+
+import {
+    GovernorUpgradeable,
+    IGovernorUpgradeable
+} from "@openzeppelin/contracts-upgradeable/governance/GovernorUpgradeable.sol";
+import {
+    GovernorSettingsUpgradeable
+} from "@openzeppelin/contracts-upgradeable/governance/extensions/GovernorSettingsUpgradeable.sol";
+import {
+    GovernorCountingSimpleUpgradeable
+} from "@openzeppelin/contracts-upgradeable/governance/extensions/GovernorCountingSimpleUpgradeable.sol";
+import {
+    GovernorVotesUpgradeable
+} from "@openzeppelin/contracts-upgradeable/governance/extensions/GovernorVotesUpgradeable.sol";
+import {
+    GovernorVotesQuorumFractionUpgradeable,
+    IVotesUpgradeable
+} from "@openzeppelin/contracts-upgradeable/governance/extensions/GovernorVotesQuorumFractionUpgradeable.sol";
+import {
+    GovernorTimelockControlUpgradeable,
+    TimelockControllerUpgradeable
+} from "@openzeppelin/contracts-upgradeable/governance/extensions/GovernorTimelockControlUpgradeable.sol";
+import {
+    Initializable
+} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
+import {
+    OwnableUpgradeable
+} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
+
+import {LibTaikoTokenConfig} from "../L1/TaikoToken.sol";
+
+/// @custom:security-contact [email protected]
+contract TaikoGovernor is
+    Initializable,
+    GovernorUpgradeable,
+    GovernorSettingsUpgradeable,
+    GovernorCountingSimpleUpgradeable,
+    GovernorVotesUpgradeable,
+    GovernorVotesQuorumFractionUpgradeable,
+    GovernorTimelockControlUpgradeable,
+    OwnableUpgradeable
+{
+    /// @custom:oz-upgrades-unsafe-allow constructor
+    constructor() {
+        _disableInitializers();
+    }
+
+    function initialize(
+        IVotesUpgradeable _token,
+        TimelockControllerUpgradeable _timelock
+    ) public initializer {
+        __Governor_init("TaikoGovernor");
+        __GovernorSettings_init(
+            7200 /* 7200 block = 1 day */,
+            100800 /* 2 week */,
+            LibTaikoTokenConfig.DECIMALS
+        );
+        __GovernorCountingSimple_init();
+        __GovernorVotes_init(_token);
+        __GovernorVotesQuorumFraction_init(4);
+        __GovernorTimelockControl_init(_timelock);
+        __Ownable_init();
+    }
+
+    // The following functions are overrides required by Solidity.
+    function propose(
+        address[] memory targets,
+        uint256[] memory values,
+        bytes[] memory calldatas,
+        string memory description
+    )
+        public
+        override(GovernorUpgradeable, IGovernorUpgradeable)
+        returns (uint256)
+    {
+        return super.propose(targets, values, calldatas, description);
+    }
+
+    function votingDelay()
+        public
+        view
+        override(IGovernorUpgradeable, GovernorSettingsUpgradeable)
+        returns (uint256)
+    {
+        return super.votingDelay();
+    }
+
+    function votingPeriod()
+        public
+        view
+        override(IGovernorUpgradeable, GovernorSettingsUpgradeable)
+        returns (uint256)
+    {
+        return super.votingPeriod();
+    }
+
+    function quorum(
+        uint256 blockNumber
+    )
+        public
+        view
+        override(IGovernorUpgradeable, GovernorVotesQuorumFractionUpgradeable)
+        returns (uint256)
+    {
+        return super.quorum(blockNumber);
+    }
+
+    function state(
+        uint256 proposalId
+    )
+        public
+        view
+        override(GovernorUpgradeable, GovernorTimelockControlUpgradeable)
+        returns (ProposalState)
+    {
+        return super.state(proposalId);
+    }
+
+    function proposalThreshold()
+        public
+        view
+        override(GovernorUpgradeable, GovernorSettingsUpgradeable)
+        returns (uint256)
+    {
+        return super.proposalThreshold();
+    }
+
+    function supportsInterface(
+        bytes4 interfaceId
+    )
+        public
+        view
+        override(GovernorUpgradeable, GovernorTimelockControlUpgradeable)
+        returns (bool)
+    {
+        return super.supportsInterface(interfaceId);
+    }
+
+    function _execute(
+        uint256 proposalId,
+        address[] memory targets,
+        uint256[] memory values,
+        bytes[] memory calldatas,
+        bytes32 descriptionHash
+    )
+        internal
+        override(GovernorUpgradeable, GovernorTimelockControlUpgradeable)
+    {
+        super._execute(proposalId, targets, values, calldatas, descriptionHash);
+    }
+
+    function _cancel(
+        address[] memory targets,
+        uint256[] memory values,
+        bytes[] memory calldatas,
+        bytes32 descriptionHash
+    )
+        internal
+        override(GovernorUpgradeable, GovernorTimelockControlUpgradeable)
+        returns (uint256)
+    {
+        return super._cancel(targets, values, calldatas, descriptionHash);
+    }
+
+    function _executor()
+        internal
+        view
+        override(GovernorUpgradeable, GovernorTimelockControlUpgradeable)
+        returns (address)
+    {
+        return super._executor();
+    }
+}

packages/protocol/contracts/signal/SignalService.sol

@@ -11,6 +11,7 @@ import {ISignalService} from "./ISignalService.sol";
 import {ICrossChainSync} from "../common/ICrossChainSync.sol";
 import {LibSecureMerkleTrie} from "../thirdparty/LibSecureMerkleTrie.sol";
 
+/// @custom:security-contact [email protected]
 contract SignalService is ISignalService, EssentialContract {
     struct SignalProof {
         uint256 height;
@@ -21,6 +22,10 @@ contract SignalService is ISignalService, EssentialContract {
     error B_NULL_APP_ADDR();
     error B_WRONG_CHAIN_ID();
 
+    constructor() {
+        _disableInitializers();
+    }
+
     /// @dev Initializer to be called after being deployed behind a proxy.
     function init(address _addressManager) external initializer {
         EssentialContract._init(_addressManager);