@towns-protocol/contracts 0.0.302

package/src/tokens/mainnet/claimer/IAuthorizedClaimers.sol

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// This contract is used to authorize claimers to claim rewards on the authorizer's behalf
+interface IAuthorizedClaimersBase {
+    // Errors
+    error AuthorizedClaimers_ClaimerAlreadyAuthorized();
+    error AuthorizedClaimers_InvalidSignature();
+    error AuthorizedClaimers_ExpiredSignature();
+
+    // Events
+    event AuthorizedClaimerChanged(address indexed authorizer, address indexed claimer);
+    event AuthorizedClaimerRemoved(address indexed authorizer);
+}
+
+interface IAuthorizedClaimers is IAuthorizedClaimersBase {
+    // Authorize a claimer to claim rewards on the callers behalf
+    function authorizeClaimer(address claimer) external;
+
+    // Authorize a claimer to claim rewards on the authorizer's behalf
+    function authorizeClaimerBySig(
+        address owner,
+        address claimer,
+        uint256 nonce,
+        uint256 expiry,
+        uint8 v,
+        bytes32 r,
+        bytes32 s
+    ) external;
+
+    // Get the authorized claimer for the authorizer
+    function getAuthorizedClaimer(address authorizer) external view returns (address);
+
+    // Remove the authorized claimer for the caller
+    function removeAuthorizedClaimer() external;
+}

package/src/tokens/mainnet/delegation/ProxyBatchDelegation.sol

@@ -0,0 +1,86 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.23;
+
+// interfaces
+
+import {ICrossDomainMessenger} from "src/base/registry/facets/mainnet/ICrossDomainMessenger.sol";
+import {IMainnetDelegation, IMainnetDelegationBase} from "src/base/registry/facets/mainnet/IMainnetDelegation.sol";
+import {IVotesEnumerable} from "src/diamond/facets/governance/votes/enumerable/IVotesEnumerable.sol";
+import {IAuthorizedClaimers} from "src/tokens/mainnet/claimer/IAuthorizedClaimers.sol";
+
+// libraries
+import {SafeTransferLib} from "solady/utils/SafeTransferLib.sol";
+
+// contracts
+
+contract ProxyBatchDelegation is IMainnetDelegationBase {
+    using SafeTransferLib for address;
+
+    address public immutable MESSENGER;
+    address public immutable BASE_REGISTRY;
+
+    address public immutable TOWNS;
+    address public immutable CLAIMER_MANAGER;
+
+    constructor(address _towns, address _claimers, address _messenger, address _target) {
+        TOWNS = _towns;
+        CLAIMER_MANAGER = _claimers;
+        MESSENGER = _messenger;
+        BASE_REGISTRY = _target;
+    }
+
+    function relayDelegationDigest(uint32 minGasLimit) external {
+        DelegationMsg[] memory msgs = _getDelegationMsgs();
+        bytes32 digest = _digest(msgs);
+
+        ICrossDomainMessenger(MESSENGER).sendMessage(
+            BASE_REGISTRY,
+            abi.encodeCall(IMainnetDelegation.setDelegationDigest, digest),
+            minGasLimit
+        );
+    }
+
+    function getEncodedMsgs() external view returns (bytes memory encodedMsgs) {
+        DelegationMsg[] memory msgs = _getDelegationMsgs();
+        encodedMsgs = abi.encode(msgs);
+    }
+
+    /// @dev Generates the digest of the delegation messages
+    function _digest(DelegationMsg[] memory msgs) internal pure returns (bytes32 digest) {
+        digest = keccak256(abi.encode(keccak256(abi.encode(msgs))));
+    }
+
+    /// @dev Gathers the delegation messages
+    function _getDelegationMsgs() internal view returns (DelegationMsg[] memory msgs) {
+        address[] memory allDelegators = IVotesEnumerable(TOWNS).getDelegators();
+        uint256 length = allDelegators.length;
+        msgs = new DelegationMsg[](length);
+
+        for (uint256 i; i < length; ++i) {
+            address delegator = allDelegators[i];
+            msgs[i].delegator = delegator;
+            msgs[i].delegatee = _delegates(TOWNS, delegator);
+            msgs[i].quantity = TOWNS.balanceOf(delegator);
+            msgs[i].claimer = IAuthorizedClaimers(CLAIMER_MANAGER).getAuthorizedClaimer(delegator);
+        }
+    }
+
+    /// @dev Returns the delegate that `account` has chosen.
+    /// Returns zero if the `token` does not exist.
+    function _delegates(address token, address account) internal view returns (address delegatee) {
+        /// @solidity memory-safe-assembly
+        assembly {
+            mstore(0x14, account) // Store the `account` argument.
+            mstore(0x00, 0x587cde1e000000000000000000000000) // `delegates(address)`.
+            delegatee := mul(
+                // The arguments of `mul` are evaluated from right to left.
+                mload(0x20),
+                and(
+                    // The arguments of `and` are evaluated from right to left.
+                    gt(returndatasize(), 0x1f), // At least 32 bytes returned.
+                    staticcall(gas(), token, 0x10, 0x24, 0x20, 0x20)
+                )
+            )
+        }
+    }
+}

package/src/tokens/migration/ITokenMigration.sol

@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+// libraries
+
+// contracts
+
+interface ITokenMigrationBase {
+    // Errors
+    error TokenMigration__InvalidBalance();
+    error TokenMigration__InvalidAllowance();
+    error TokenMigration__NotEnoughTokenBalance();
+    error TokenMigration__InvalidTokens();
+
+    // Events
+    event TokensMigrated(address indexed account, uint256 amount);
+    event EmergencyWithdraw(address indexed token, address indexed to, uint256 amount);
+}
+
+interface ITokenMigration is ITokenMigrationBase {
+    /// @notice Migrates tokens from old token to new token for the specified account
+    /// @param account The address of the account to migrate tokens for
+    /// @dev The account must have a non-zero balance of old tokens and have approved this contract
+    function migrate(address account) external;
+
+    /// @notice Allows the owner to withdraw tokens from the contract
+    /// @dev Only callable by contract owner
+    function emergencyWithdraw(IERC20 token, address to) external;
+
+    /// @notice Returns the token pair
+    function tokens() external view returns (IERC20 oldToken, IERC20 newToken);
+}

package/src/tokens/migration/TokenMigrationFacet.sol

@@ -0,0 +1,86 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {ITokenMigration} from "./ITokenMigration.sol";
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+// libraries
+import {TokenMigrationStorage} from "./TokenMigrationStorage.sol";
+import {Validator} from "../../utils/libraries/Validator.sol";
+import {CustomRevert} from "src/utils/libraries/CustomRevert.sol";
+import {SafeTransferLib} from "solady/utils/SafeTransferLib.sol";
+
+// contracts
+import {Facet} from "@towns-protocol/diamond/src/facets/Facet.sol";
+import {OwnableBase} from "@towns-protocol/diamond/src/facets/ownable/OwnableBase.sol";
+import {PausableBase} from "@towns-protocol/diamond/src/facets/pausable/PausableBase.sol";
+
+contract TokenMigrationFacet is OwnableBase, PausableBase, Facet, ITokenMigration {
+    using SafeTransferLib for address;
+
+    function __TokenMigrationFacet_init(
+        IERC20 oldToken,
+        IERC20 newToken
+    ) external onlyInitializing {
+        _validateTokens(oldToken, newToken);
+
+        TokenMigrationStorage.Layout storage ds = TokenMigrationStorage.layout();
+        (ds.oldToken, ds.newToken) = (oldToken, newToken);
+        _pause();
+    }
+
+    /// @inheritdoc ITokenMigration
+    function migrate(address account) external whenNotPaused {
+        Validator.checkAddress(account);
+
+        TokenMigrationStorage.Layout storage ds = TokenMigrationStorage.layout();
+
+        (IERC20 oldToken, IERC20 newToken) = (ds.oldToken, ds.newToken);
+
+        uint256 currentBalance = oldToken.balanceOf(account);
+        if (currentBalance == 0) {
+            CustomRevert.revertWith(TokenMigration__InvalidBalance.selector);
+        }
+
+        if (oldToken.allowance(account, address(this)) < currentBalance) {
+            CustomRevert.revertWith(TokenMigration__InvalidAllowance.selector);
+        }
+
+        // check that contract has enough balance of new token
+        uint256 newTokenBalance = newToken.balanceOf(address(this));
+        if (newTokenBalance < currentBalance) {
+            CustomRevert.revertWith(TokenMigration__NotEnoughTokenBalance.selector);
+        }
+
+        // Transfer old tokens from user to this contract
+        address(oldToken).safeTransferFrom(account, address(this), currentBalance);
+
+        // Transfer new tokens to user
+        address(newToken).safeTransfer(account, currentBalance);
+
+        emit TokensMigrated(account, currentBalance);
+    }
+
+    /// @inheritdoc ITokenMigration
+    function emergencyWithdraw(IERC20 token, address to) external onlyOwner whenPaused {
+        uint256 balance = token.balanceOf(address(this));
+        address(token).safeTransfer(to, balance);
+        emit EmergencyWithdraw(address(token), to, balance);
+    }
+
+    /// @inheritdoc ITokenMigration
+    function tokens() external view returns (IERC20 oldToken, IERC20 newToken) {
+        return (TokenMigrationStorage.layout().oldToken, TokenMigrationStorage.layout().newToken);
+    }
+
+    // =============================================================
+    //                           Internal
+    // =============================================================
+
+    function _validateTokens(IERC20 oldToken, IERC20 newToken) internal pure {
+        if (address(oldToken) == address(0) || address(newToken) == address(0)) {
+            CustomRevert.revertWith(TokenMigration__InvalidTokens.selector);
+        }
+    }
+}

package/src/tokens/migration/TokenMigrationStorage.sol

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+// libraries
+
+// contracts
+
+library TokenMigrationStorage {
+    // keccak256(abi.encode(uint256(keccak256("token.migration.storage")) - 1)) &
+    // ~bytes32(uint256(0xff))
+    bytes32 public constant STORAGE_SLOT =
+        0x70042d58ab6ffbb7e110198cb4fbcbe6957a43f69f02f904ebed551d03013400;
+
+    struct Layout {
+        IERC20 oldToken;
+        IERC20 newToken;
+    }
+
+    function layout() internal pure returns (Layout storage l) {
+        assembly {
+            l.slot := STORAGE_SLOT
+        }
+    }
+}

package/src/tokens/towns/base/IERC7802.sol

@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {IERC165} from "@openzeppelin/contracts/interfaces/IERC165.sol";
+
+/// @title IERC7802
+/// @notice Defines the interface for crosschain ERC20 transfers.
+interface IERC7802 is IERC165 {
+    /// @notice Emitted when a crosschain transfer mints tokens.
+    /// @param to       Address of the account tokens are being minted for.
+    /// @param amount   Amount of tokens minted.
+    /// @param sender   Address of the account that finalized the crosschain transfer.
+    event CrosschainMint(address indexed to, uint256 amount, address indexed sender);
+
+    /// @notice Emitted when a crosschain transfer burns tokens.
+    /// @param from     Address of the account tokens are being burned from.
+    /// @param amount   Amount of tokens burned.
+    /// @param sender   Address of the account that initiated the crosschain transfer.
+    event CrosschainBurn(address indexed from, uint256 amount, address indexed sender);
+
+    /// @notice Mint tokens through a crosschain transfer.
+    /// @param _to     Address to mint tokens to.
+    /// @param _amount Amount of tokens to mint.
+    function crosschainMint(address _to, uint256 _amount) external;
+
+    /// @notice Burn tokens through a crosschain transfer.
+    /// @param _from   Address to burn tokens from.
+    /// @param _amount Amount of tokens to burn.
+    function crosschainBurn(address _from, uint256 _amount) external;
+}

package/src/tokens/towns/base/IOptimismMintableERC20.sol

@@ -0,0 +1,31 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+
+/// @title IOptimismMintableERC20
+/// @notice This interface is available on the OptimismMintableERC20 contract.
+///         We declare it as a separate interface so that it can be used in
+///         custom implementations of OptimismMintableERC20.
+interface IOptimismMintableERC20 is IERC165 {
+    function remoteToken() external view returns (address);
+
+    function bridge() external returns (address);
+
+    function mint(address _to, uint256 _amount) external;
+
+    function burn(address _from, uint256 _amount) external;
+}
+
+/// @custom:legacy
+/// @title ILegacyMintableERC20
+/// @notice This interface was available on the legacy L2StandardERC20 contract.
+///         It remains available on the OptimismMintableERC20 contract for
+///         backwards compatibility.
+interface ILegacyMintableERC20 is IERC165 {
+    function l1Token() external view returns (address);
+
+    function mint(address _to, uint256 _amount) external;
+
+    function burn(address _from, uint256 _amount) external;
+}

package/src/tokens/towns/base/ISemver.sol

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+/// @title ISemver
+/// @notice ISemver is a simple contract for ensuring that contracts are
+///         versioned using semantic versioning.
+interface ISemver {
+    /// @notice Getter for the semantic version of the contract. This is not
+    ///         meant to be used onchain but instead meant to be used by offchain
+    ///         tooling.
+    /// @return Semver contract version as a string.
+    function version() external view returns (string memory);
+}

package/src/tokens/towns/base/Towns.sol

@@ -0,0 +1,283 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+import {IVotes} from "@openzeppelin/contracts/governance/utils/IVotes.sol";
+import {IERC6372} from "@openzeppelin/contracts/interfaces/IERC6372.sol";
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+import {IERC20Permit} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol";
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+
+import {IERC7802} from "src/tokens/towns/base/IERC7802.sol";
+import {ILegacyMintableERC20, IOptimismMintableERC20} from "src/tokens/towns/base/IOptimismMintableERC20.sol";
+import {ISemver} from "src/tokens/towns/base/ISemver.sol";
+
+// libraries
+
+import {TownsLib} from "./TownsLib.sol";
+import {CustomRevert} from "src/utils/libraries/CustomRevert.sol";
+
+// contracts
+import {IntrospectionBase} from "@towns-protocol/diamond/src/facets/introspection/IntrospectionBase.sol";
+
+import {LockBase} from "src/tokens/lock/LockBase.sol";
+import {Ownable} from "solady/auth/Ownable.sol";
+import {ERC20Votes} from "solady/tokens/ERC20Votes.sol";
+import {Initializable} from "solady/utils/Initializable.sol";
+import {UUPSUpgradeable} from "solady/utils/UUPSUpgradeable.sol";
+
+contract Towns is
+    IOptimismMintableERC20,
+    IERC7802,
+    ISemver,
+    IntrospectionBase,
+    LockBase,
+    Initializable,
+    ERC20Votes,
+    UUPSUpgradeable,
+    Ownable
+{
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                          Errors                            */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    error DelegateeSameAsCurrent();
+    error TransferLockEnabled();
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                  Constants & Immutables                    */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @notice The name of the token
+    string internal constant NAME = "Towns";
+
+    /// @notice The symbol of the token
+    string internal constant SYMBOL = "TOWNS";
+
+    /// @notice The name hash of the token
+    bytes32 internal constant NAME_HASH = keccak256(bytes(NAME));
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                        Modifiers                           */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @notice A modifier that only allows the bridge to call
+    modifier onlyL2StandardBridge() {
+        if (msg.sender != TownsLib.L2_STANDARD_BRIDGE) {
+            CustomRevert.revertWith(Unauthorized.selector);
+        }
+        _;
+    }
+
+    /// @notice A modifier that only allows the super chain to call
+    modifier onlyL2SuperChainBridge() {
+        if (msg.sender != TownsLib.SUPERCHAIN_TOKEN_BRIDGE) {
+            CustomRevert.revertWith(Unauthorized.selector);
+        }
+        _;
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                      Initialization                        */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    constructor() {
+        _disableInitializers();
+    }
+
+    function initialize(address _remoteToken, address _owner) external initializer {
+        // set the owner
+        _initializeOwner(_owner);
+
+        // set the remote token
+        TownsLib.initializeRemoteToken(_remoteToken);
+
+        // initialize the lock
+        __LockBase_init(30 days);
+
+        // add interface
+        _addInterface(type(IERC20).interfaceId);
+        _addInterface(type(IERC20Metadata).interfaceId);
+        _addInterface(type(IERC20Permit).interfaceId);
+        _addInterface(type(IERC6372).interfaceId);
+        _addInterface(type(IERC165).interfaceId);
+        _addInterface(type(IVotes).interfaceId);
+        _addInterface(type(IOptimismMintableERC20).interfaceId);
+        _addInterface(type(ILegacyMintableERC20).interfaceId);
+        _addInterface(type(ISemver).interfaceId);
+        _addInterface(type(IERC7802).interfaceId);
+    }
+
+    /// @notice Semantic version
+    /// @custom:semver 1.0.0-beta.12
+    function version() external view virtual returns (string memory) {
+        return "1.0.0-beta.12";
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                        Bridge                              */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @custom:legacy
+    /// @notice Legacy getter for the remote token. Use REMOTE_TOKEN going forward.
+    function l1Token() external view returns (address) {
+        return TownsLib.layout().remoteToken;
+    }
+
+    /// @custom:legacy
+    /// @notice Legacy getter for the bridge. Use BRIDGE going forward.
+    function l2Bridge() external pure returns (address) {
+        return TownsLib.L2_STANDARD_BRIDGE;
+    }
+
+    /// @custom:legacy
+    /// @notice Legacy getter for REMOTE_TOKEN
+    function remoteToken() external view returns (address) {
+        return TownsLib.layout().remoteToken;
+    }
+
+    /// @custom:legacy
+    /// @notice Legacy getter for L2_STANDARD_BRIDGE.
+    function bridge() external pure returns (address) {
+        return TownsLib.L2_STANDARD_BRIDGE;
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                      Super Chain                           */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @notice Allows the SuperchainTokenBridge to mint tokens.
+    /// @param _to     Address to mint tokens to.
+    /// @param _amount Amount of tokens to mint.
+    function crosschainMint(address _to, uint256 _amount) external onlyL2SuperChainBridge {
+        _mint(_to, _amount);
+        emit CrosschainMint(_to, _amount, msg.sender);
+    }
+
+    /// @notice Allows the SuperchainTokenBridge to burn tokens.
+    /// @param _from   Address to burn tokens from.
+    /// @param _amount Amount of tokens to burn.
+    function crosschainBurn(address _from, uint256 _amount) external onlyL2SuperChainBridge {
+        _burn(_from, _amount);
+        emit CrosschainBurn(_from, _amount, msg.sender);
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                     Introspection                          */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @inheritdoc IERC165
+    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
+        return _supportsInterface(interfaceId);
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                           Lock                               */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    function isLockActive(address account) external view virtual returns (bool) {
+        return _isLockActive(account);
+    }
+
+    function lockExpiration(address account) external view virtual returns (uint256) {
+        return _lockExpiration(account);
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                         Overrides                          */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    function name() public pure override returns (string memory) {
+        return NAME;
+    }
+
+    function symbol() public pure override returns (string memory) {
+        return SYMBOL;
+    }
+
+    function decimals() public pure override returns (uint8) {
+        return 18;
+    }
+
+    /// @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 override(IOptimismMintableERC20) onlyL2StandardBridge {
+        _mint(to, amount);
+    }
+
+    /// @notice Allows the StandardBridge on this network to burn tokens.
+    /// @param from     Address to burn tokens from.
+    /// @param amount Amount of tokens to burn.
+    function burn(
+        address from,
+        uint256 amount
+    ) external override(IOptimismMintableERC20) onlyL2StandardBridge {
+        _burn(from, amount);
+    }
+
+    /// @notice Clock used for flagging checkpoints, overridden to implement timestamp based
+    /// checkpoints (and voting).
+    function clock() public view override returns (uint48) {
+        return uint48(block.timestamp);
+    }
+
+    /// @notice Machine-readable description of the clock as specified in EIP-6372.
+    function CLOCK_MODE() public pure override returns (string memory) {
+        return "mode=timestamp";
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                     Internal Overrides                     */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    function _beforeTokenTransfer(address from, address to, uint256 amount) internal override {
+        if (from != address(0) && _isLockActive(from)) {
+            // allow transferring at minting time
+            CustomRevert.revertWith(TransferLockEnabled.selector);
+        }
+
+        super._beforeTokenTransfer(from, to, amount);
+    }
+
+    function _delegate(address account, address delegatee) internal override {
+        address currentDelegatee = delegates(account);
+
+        // revert if the delegatee is the same as the current delegatee
+        if (currentDelegatee == delegatee) {
+            CustomRevert.revertWith(DelegateeSameAsCurrent.selector);
+        }
+
+        // if the delegatee is the zero address, initialize disable lock
+        if (delegatee == address(0)) {
+            _disableLock(account);
+        } else {
+            _enableLock(account);
+        }
+
+        super._delegate(account, delegatee);
+    }
+
+    /// @dev Override the name hash to be a constant value for performance in EIP-712
+    function _constantNameHash() internal pure override returns (bytes32) {
+        return NAME_HASH;
+    }
+
+    /// @dev This allows Permit2 to be used without prior approval.
+    function _givePermit2InfiniteAllowance() internal pure override returns (bool) {
+        return true;
+    }
+
+    /// @dev Override the default lock check to disable it.
+    function _canLock() internal pure override returns (bool) {
+        return false;
+    }
+
+    /// @notice Override the default upgrade check to only allow the owner.
+    function _authorizeUpgrade(address newImplementation) internal override onlyOwner {}
+}

package/src/tokens/towns/base/TownsDeployer.sol

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+// libraries
+import {Create2Utils} from "../../../utils/libraries/Create2Utils.sol";
+
+// contracts
+import {ERC1967Proxy} from "@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol";
+import {Towns} from "src/tokens/towns/base/Towns.sol";
+
+contract TownsDeployer {
+    constructor(address l1Token, address owner, bytes32 implementationSalt, bytes32 proxySalt) {
+        address implementation = Create2Utils.create2Deploy(
+            implementationSalt,
+            type(Towns).creationCode
+        );
+
+        // Create proxy initialization bytecode
+        bytes memory proxyBytecode = abi.encodePacked(
+            type(ERC1967Proxy).creationCode,
+            abi.encode(
+                implementation,
+                abi.encodePacked(Towns.initialize.selector, abi.encode(l1Token, owner))
+            )
+        );
+
+        // Deploy proxy using create2
+        Create2Utils.create2Deploy(proxySalt, proxyBytecode);
+    }
+}