diff --git a/package.json b/package.json
index 9a9847d..05932f3 100644
--- a/package.json
+++ b/package.json
@@ -9,6 +9,6 @@
   ],
   "packageManager": "yarn@4.6.0",
   "resolutions": {
-    "hardhat": "2.28.3"
+    "hardhat": "2.26"
   }
 }
diff --git a/packages/bridge-contracts/contracts/oft/GoodDollarOFTAdapter.sol b/packages/bridge-contracts/contracts/oft/GoodDollarOFTAdapter.sol
index ed5ab56..4a3c2c5 100644
--- a/packages/bridge-contracts/contracts/oft/GoodDollarOFTAdapter.sol
+++ b/packages/bridge-contracts/contracts/oft/GoodDollarOFTAdapter.sol
@@ -2,54 +2,157 @@
 pragma solidity >=0.8.0;
 
 import { IERC20, IERC20Metadata } from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
-import { OFTCoreUpgradeable } from "@layerzerolabs/oft-evm-upgradeable/contracts/oft/OFTCoreUpgradeable.sol";
+import "@layerzerolabs/oft-evm-upgradeable/contracts/oft/OFTCoreUpgradeable.sol";
 import { IMintableBurnable } from "@layerzerolabs/oft-evm/contracts/interfaces/IMintableBurnable.sol";
+import { INameService } from "@gooddollar/goodprotocol/contracts/utils/DAOUpgradeableContract.sol";
+import { UUPSUpgradeable } from "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
+
+interface IIdentity {
+    function isWhitelisted(address) external view returns (bool);
+}
 
 /**
  * @title GoodDollarOFTAdapter
  * @notice Upgradeable OFT adapter that uses mint/burn mechanisms for cross-chain transfers
  * @dev Inherits from OFTCoreUpgradeable (which already includes OwnableUpgradeable) and implements mint/burn logic similar to MintBurnOFTAdapter
  */
-contract GoodDollarOFTAdapter is OFTCoreUpgradeable {
+contract GoodDollarOFTAdapter is UUPSUpgradeable, OFTCoreUpgradeable {
+    using OFTMsgCodec for bytes;
+    using OFTMsgCodec for bytes32;
+    /// @dev Struct for storing bridge fees
+    struct BridgeFees {
+        uint256 minFee;
+        uint256 maxFee;
+        uint256 fee; // Fee in basis points (0-10000, where 10000 = 100%)
+    }
+
+    /// @dev Struct for storing account limits
+    struct AccountLimit {
+        uint256 lastTransferReset;
+        uint256 bridged24Hours;
+    }
+
+    /// @dev Struct for storing bridge daily limits
+    struct BridgeDailyLimit {
+        uint256 lastTransferReset;
+        uint256 bridged24Hours;
+    }
+
+    /// @dev Struct for storing bridge limits
+    struct BridgeLimits {
+        uint256 dailyLimit;
+        uint256 txLimit;
+        uint256 accountDailyLimit;
+        uint256 minAmount;
+        bool onlyWhitelisted;
+    }
+
     /// @dev The underlying ERC20 token
     IERC20 internal innerToken;
     
     /// @dev The contract responsible for minting and burning tokens
     IMintableBurnable public minterBurner;
 
+    /// @dev Bridge fees configuration
+    BridgeFees public bridgeFees;
+
+    /// @dev Address to receive bridge fees
+    address public feeRecipient;
+
+    /// @dev Bridge limits structure
+    BridgeLimits public bridgeLimits;
+
+    /// @dev Bridge daily limit tracking
+    BridgeDailyLimit public bridgeDailyLimit;
+
+    /// @dev Account-specific daily limit tracking
+    mapping(address => AccountLimit) public accountsDailyLimit;
+
+    struct FailedReceiveRequest {
+        bool failed;
+        address toAddress;
+        uint64 timestamp;
+        uint256 amount;
+        uint32 srcEid;
+    }
+    /// @dev A mapping for failed requests
+    mapping(bytes32 => FailedReceiveRequest) public failedReceiveRequests;
+
+    uint64 public constant OPTIMISTIC_WINDOW = 3 days;
+
+    /// @dev A boolean for whether the bridge is closed
+    bool public isClosed;
+
+    /// @dev NameService for identity checks (optional, can be address(0))
+    INameService public nameService;
+
+    /// @dev Error for bridge limits violations
+    error BRIDGE_LIMITS(string reason);
+
+    /// @dev Error for bridge limits violations
+    error BRIDGE_NOT_ALLOWED(string reason);
+
+    /// @dev Event emitted when bridge fees are updated
+    event BridgeFeesSet(uint256 minFee, uint256 maxFee, uint256 fee);
+
+    /// @dev Event emitted when fee recipient is updated
+    event FeeRecipientSet(address indexed feeRecipient);
+
+    /// @dev Event emitted when fees are collected
+    event FeeCollected(address indexed recipient, uint256 amount);
+
+    /// @dev Event emitted when bridge limits are updated
+    event BridgeLimitsSet(
+        uint256 dailyLimit,
+        uint256 txLimit,
+        uint256 accountDailyLimit,
+        uint256 minAmount,
+        bool onlyWhitelisted
+    );
+
+    /// @dev Event emitted when bridge pause status changes
+    event BridgePaused(bool isPaused);
+
+    /// @dev Event emitted when a failed receive request is made
+    event ReceiveRequestFailed(bytes32 indexed guid, address toAddress, uint256 amount, uint32 srcEid);
+
+    /// @dev Event emitted when a failed receive request is approved
+    event FailedReceiveRequestApproved(bytes32 indexed guid);
+
     /**
-     * @dev Constructor for the upgradeable contract
-     * @param _token The address of the underlying ERC20 token (used to get decimals)
+     * @dev Constructor for the upgradeable implementation; token is used for decimals, init is disabled.
+     * @param _token The underlying ERC20 token (used to get decimals for parent)
      * @param _lzEndpoint The LayerZero endpoint address
-     * @dev The constructor is called when deploying the implementation contract
-     * @dev The token address is only used here to get decimals for the parent constructor
      */
     constructor(address _token, address _lzEndpoint) 
         OFTCoreUpgradeable(IERC20Metadata(_token).decimals(), _lzEndpoint) 
     {
-        // Disable initialization in the constructor to prevent initialization of the implementation
         _disableInitializers();
     }
 
     /**
      * @notice Initializes the GoodDollarOFTAdapter contract
-     * @param _token The address of the underlying ERC20 token
+     * @param _token The underlying ERC20 token
      * @param _minterBurner The contract responsible for minting and burning tokens
      * @param _owner The contract owner
-     * @dev The LayerZero endpoint is set in the constructor and cannot be changed per proxy
+     * @param _feeRecipient The address to receive bridge fees
      */
     function initialize(
         address _token,
         IMintableBurnable _minterBurner,
-        address _owner
+        address _owner,
+        address _feeRecipient
     ) public initializer {
-        // Initialize parent contracts
-        // __OFTCore_init already initializes OwnableUpgradeable through OAppCoreUpgradeable
+        __UUPSUpgradeable_init();
+        __Ownable_init();
+        __OAppSender_init(_owner);
+        __OAppReceiver_init(_owner);
         __OFTCore_init(_owner);
-        
-        // Set state variables
+        _transferOwnership(_owner);
+
         innerToken = IERC20(_token);
         minterBurner = _minterBurner;
+        feeRecipient = _feeRecipient;
     }
 
     /**
@@ -68,6 +171,236 @@ contract GoodDollarOFTAdapter is OFTCoreUpgradeable {
         return false;
     }
 
+    /**
+     * @notice Sets the bridge fees configuration
+     * @param _fees The bridge fees struct containing minFee, maxFee, and fee (in basis points)
+     */
+    function setBridgeFees(BridgeFees memory _fees) external onlyOwner {
+        require(_fees.fee <= 10000, 'invalid fee');
+        bridgeFees = _fees;
+        emit BridgeFeesSet(_fees.minFee, _fees.maxFee, _fees.fee);
+    }
+
+    /**
+     * @notice Sets the fee recipient address
+     * @param _feeRecipient The address to receive bridge fees
+     */
+    function setFeeRecipient(address _feeRecipient) external onlyOwner {
+        feeRecipient = _feeRecipient;
+        emit FeeRecipientSet(_feeRecipient);
+    }
+
+    /**
+     * @notice Calculates the fee amount from the given amount
+     * @param amount The amount to calculate fee from
+     * @return fee The calculated fee amount (enforced to be between minFee and maxFee if set)
+     */
+    function _takeFee(uint256 amount) internal view returns (uint256 fee) {
+        fee = (amount * bridgeFees.fee) / 10000;
+        if (bridgeFees.minFee > 0 && fee < bridgeFees.minFee) {
+            fee = bridgeFees.minFee;
+        }
+        if (bridgeFees.maxFee > 0 && fee > bridgeFees.maxFee) {
+            fee = bridgeFees.maxFee;
+        }
+    }
+
+    /**
+     * @notice Sets the bridge limits configuration
+     * @param _limits The bridge limits struct
+     */
+    function setBridgeLimits(BridgeLimits memory _limits) external onlyOwner {
+        bridgeLimits = _limits;
+        emit BridgeLimitsSet(
+            _limits.dailyLimit,
+            _limits.txLimit,
+            _limits.accountDailyLimit,
+            _limits.minAmount,
+            _limits.onlyWhitelisted
+        );
+    }
+
+    /**
+     * @notice Sets the NameService contract for identity checks
+     * @param _nameService The NameService contract address (can be address(0))
+     */
+    function setNameService(INameService _nameService) external onlyOwner {
+        nameService = _nameService;
+    }
+
+    /**
+     * @notice Function for pausing/unpausing the bridge
+     * @param _isPaused Whether to pause the bridge or not
+     */
+    function pauseBridge(bool _isPaused) external onlyOwner {
+        isClosed = _isPaused;
+        emit BridgePaused(_isPaused);
+    }
+
+    /**
+     * @notice Approves a failed receive request with optimistic window or by owner
+     */
+    function approveFailedRequest(bytes32 _guid) external {
+        FailedReceiveRequest memory request = failedReceiveRequests[_guid];
+        require(request.timestamp + OPTIMISTIC_WINDOW < block.timestamp || msg.sender == owner(), 'optimistic period not ended or not owner');
+        require(request.failed, 'request not failed');
+        _credit(request.toAddress, request.amount, request.srcEid);
+        delete failedReceiveRequests[_guid];
+        emit FailedReceiveRequestApproved(_guid);
+    }
+
+    /**
+     * @notice Bridge closed / whitelist check only (no limit checks).
+     * @dev Revert on this path does not store to failedReceiveRequests.
+     */
+    function _checkBridgeClosedAndWhitelisted(address _from) internal view returns (bool ok, string memory reason) {
+        if (isClosed) return (false, 'closed');
+        if (bridgeLimits.onlyWhitelisted && address(nameService) != address(0)) {
+            IIdentity id = IIdentity(nameService.getAddress("IDENTITY"));
+            if (address(id) != address(0) && !id.isWhitelisted(_from)) {
+                return (false, 'not whitelisted');
+            }
+        }
+        return (true, '');
+    }
+
+    /**
+     * @notice Bridge limits check only (minAmount, accountDailyLimit, txLimit, dailyLimit).
+     * @dev Assumes daily limit resets have already been applied. Failure on receive is stored in failedReceiveRequests.
+     */
+    function _checkBridgeLimits(address _from, uint256 _amount) internal view returns (bool ok, string memory reason) {
+        if (_amount < bridgeLimits.minAmount) return (false, 'minAmount');
+
+        uint256 account24hours = accountsDailyLimit[_from].bridged24Hours;
+        if (accountsDailyLimit[_from].lastTransferReset < block.timestamp - 1 days) {
+            account24hours = _amount;
+        } else {
+            account24hours += _amount;
+        }
+        if (account24hours > bridgeLimits.accountDailyLimit) return (false, 'accountDailyLimit');
+
+        if (_amount > bridgeLimits.txLimit) return (false, 'txLimit');
+
+        if (bridgeDailyLimit.lastTransferReset < block.timestamp - 1 days) {
+            if (_amount > bridgeLimits.dailyLimit) return (false, 'dailyLimit');
+        } else {
+            if (bridgeDailyLimit.bridged24Hours + _amount > bridgeLimits.dailyLimit) return (false, 'dailyLimit');
+        }
+        return (true, '');
+    }
+
+    /**
+     * @notice Resets bridge and account daily limit counters if the 24h window has elapsed.
+     * @param _address The account address for which to reset account daily limit.
+     */
+    function _resetDailyLimitsIfNeeded(address _address) internal {
+        if (bridgeDailyLimit.lastTransferReset < block.timestamp - 1 days) {
+            bridgeDailyLimit.lastTransferReset = block.timestamp;
+            bridgeDailyLimit.bridged24Hours = 0;
+        }
+
+        if (accountsDailyLimit[_address].lastTransferReset < block.timestamp - 1 days) {
+            accountsDailyLimit[_address].lastTransferReset = block.timestamp;
+            accountsDailyLimit[_address].bridged24Hours = 0;
+        }
+    }
+
+    /**
+     * @notice Enforces transfer limits: bridge closed/whitelisted check then bridge limits check.
+     * @dev Used on send path. Resets daily windows, then checks; on success updates counters.
+     */
+    function _enforceLimits(address _address, uint256 _amount) internal returns (bool isValid, string memory reason) {
+        _resetDailyLimitsIfNeeded(_address);
+        (isValid, reason) = _checkBridgeClosedAndWhitelisted(_address);
+        if (!isValid) return (false, reason);
+        (isValid, reason) = _checkBridgeLimits(_address, _amount);
+        if (!isValid) return (false, reason);
+
+        bridgeDailyLimit.bridged24Hours += _amount;
+        accountsDailyLimit[_address].bridged24Hours += _amount;
+        return (true, '');
+    }
+    
+    /**
+     * @notice Overrides the default _send function to enforce limits on sending side
+     */
+    function _send(
+        SendParam calldata _sendParam,
+        MessagingFee calldata _fee,
+        address _refundAddress
+    ) internal virtual override returns (MessagingReceipt memory msgReceipt, OFTReceipt memory oftReceipt) {
+        /// @dev revert if sending to zero address
+        require(_sendParam.to.bytes32ToAddress() != address(0), 'GoodDollarOFTAdapter: sending to zero address');
+        (bool isValid, string memory reason) = _enforceLimits(_sendParam.to.bytes32ToAddress(), _sendParam.amountLD);
+        if (!isValid) {
+            revert BRIDGE_LIMITS(reason);
+        }
+        (msgReceipt, oftReceipt) = super._send(_sendParam, _fee, _refundAddress);
+    }
+
+    /**
+     * @notice Overrides the default _lzReceive function to enforce limits on receiving side.
+     * @dev Bridge closed/whitelisted check: revert only. Bridge limits check: store in failedReceiveRequests then revert.
+     */
+    function _lzReceive(
+        Origin calldata _origin,
+        bytes32 _guid,
+        bytes calldata _message,
+        address _executor,
+        bytes calldata _extraData
+    ) internal virtual override {
+        address toAddress = _message.sendTo().bytes32ToAddress();
+        uint256 amountLD = _toLD(_message.amountSD());
+
+        (bool ok, string memory reason) = _checkBridgeClosedAndWhitelisted(toAddress);
+        if (!ok) {
+            revert BRIDGE_NOT_ALLOWED(reason);
+        }
+
+        _resetDailyLimitsIfNeeded(toAddress);
+
+        (ok, reason) = _checkBridgeLimits(toAddress, amountLD);
+        if (!ok) {
+            failedReceiveRequests[_guid] = FailedReceiveRequest(
+                true,
+                toAddress,
+                uint64(block.timestamp),
+                amountLD,
+                _origin.srcEid
+            );
+            emit ReceiveRequestFailed(_guid, toAddress, amountLD, _origin.srcEid);
+        } else{
+            bridgeDailyLimit.bridged24Hours += amountLD;
+            accountsDailyLimit[toAddress].bridged24Hours += amountLD;
+            super._lzReceive(_origin, _guid, _message, _executor, _extraData);
+        }
+    }
+    /**
+     * @notice Mints tokens to the specified address upon receiving them
+     * @param _to The address to credit the tokens to
+     * @param _amountLD The amount of tokens to credit in local decimals
+     * @return amountReceivedLD The amount of tokens actually received in local decimals
+     * @dev Fees are deducted on the destination chain
+     */
+    function _credit(
+        address _to,
+        uint256 _amountLD,
+        uint32 /* _srcEid */
+    ) internal virtual override returns (uint256 amountReceivedLD) {
+        uint256 fee = _takeFee(_amountLD);
+        uint256 recipientAmount = _amountLD - fee;
+        bool success = minterBurner.mint(_to, recipientAmount);
+        require(success, "GoodDollarOFTAdapter: Mint failed");
+
+        if (fee > 0 && feeRecipient != address(0)) {
+            bool feeSuccess = minterBurner.mint(feeRecipient, fee);
+            require(feeSuccess, "GoodDollarOFTAdapter: Fee mint failed");
+            emit FeeCollected(feeRecipient, fee);
+        }
+        
+        return _amountLD;
+    }
+    
     /**
      * @notice Burns tokens from the sender's balance to prepare for sending
      * @param _from The address to debit the tokens from
@@ -84,31 +417,24 @@ contract GoodDollarOFTAdapter is OFTCoreUpgradeable {
         uint32 _dstEid
     ) internal virtual override returns (uint256 amountSentLD, uint256 amountReceivedLD) {
         (amountSentLD, amountReceivedLD) = _debitView(_amountLD, _minAmountLD, _dstEid);
-        // Burns tokens from the caller
         minterBurner.burn(_from, amountSentLD);
     }
 
-    /**
-     * @notice Mints tokens to the specified address upon receiving them
-     * @param _to The address to credit the tokens to
-     * @param _amountLD The amount of tokens to credit in local decimals
-     * @param _srcEid The source chain ID
-     * @return amountReceivedLD The amount of tokens actually received in local decimals
-     */
-    function _credit(
-        address _to,
-        uint256 _amountLD,
-        uint32 _srcEid
-    ) internal virtual override returns (uint256 amountReceivedLD) {
-        if (_to == address(0x0)) _to = address(0xdead); // _mint(...) does not support address(0x0)
-        
-        // Mint tokens to recipient
-        bool success = minterBurner.mint(_to, _amountLD);
-        require(success, "GoodDollarOFTAdapter: Mint failed");
-        
-        return _amountLD;
+    function generateGuid(
+        uint64 _nonce,
+        uint32 _srcEid,
+        address _sender,
+        uint32 _dstEid,
+        bytes32 _receiver
+    ) public pure returns (bytes32) {
+        return keccak256(abi.encodePacked(_nonce, _srcEid, _toBytes32(_sender), _dstEid, _receiver));
     }
-    
+
+    function _toBytes32(address _address) internal pure returns (bytes32) {
+        return bytes32(uint256(uint160(_address)));
+    }
+
+    function _authorizeUpgrade(address) internal virtual override onlyOwner {}
     /**
      * @dev This empty reserved space is put in place to allow future versions to add new
      * variables without shifting down storage in the inheritance chain.
diff --git a/packages/bridge-contracts/contracts/oft/GoodDollarMinterBurner.sol b/packages/bridge-contracts/contracts/oft/GoodDollarOFTMinterBurner.sol
similarity index 69%
rename from packages/bridge-contracts/contracts/oft/GoodDollarMinterBurner.sol
rename to packages/bridge-contracts/contracts/oft/GoodDollarOFTMinterBurner.sol
index 22df674..5ab9492 100644
--- a/packages/bridge-contracts/contracts/oft/GoodDollarMinterBurner.sol
+++ b/packages/bridge-contracts/contracts/oft/GoodDollarOFTMinterBurner.sol
@@ -4,28 +4,15 @@ pragma solidity >=0.8;
 import {ISuperGoodDollar} from "./interfaces/ISuperGoodDollar.sol";
 import {DAOUpgradeableContract, INameService} from "@gooddollar/goodprotocol/contracts/utils/DAOUpgradeableContract.sol";
 
-interface IIdentity {
-    function isWhitelisted(address) external view returns (bool);
-}
-
 /**
- * @title GoodDollarMinterBurner
- * @dev DAO-upgradeable contract that handles minting and burning of GoodDollar tokens for OFT
- * 
- * This contract is used by the GoodDollarOFTAdapter to mint and burn tokens during
- * cross-chain transfers via LayerZero. It is upgradeable and controlled by the DAO.
- * 
- * Key functionalities:
- * - Mint tokens when receiving cross-chain transfers
- * - Burn tokens when sending cross-chain transfers
- * - Manage operators (like OFT adapter) that can mint/burn
- * - Pause functionality for emergency situations
- * - Upgradeable via DAO governance
+ * @title GoodDollarOFTMinterBurner
+ * @dev DAO-upgradeable contract that handles minting and burning of GoodDollar tokens for OFT; used by
+ * GoodDollarOFTAdapter for cross-chain transfers via LayerZero.
  */
-contract GoodDollarMinterBurner is DAOUpgradeableContract {
+contract GoodDollarOFTMinterBurner is DAOUpgradeableContract {
     ISuperGoodDollar public token;
     mapping(address => bool) public operators;
-    
+
     bool public paused;
 
     event OperatorSet(address indexed operator, bool status);
@@ -33,30 +20,32 @@ contract GoodDollarMinterBurner is DAOUpgradeableContract {
     event Unpaused(address indexed account);
     event TokensMinted(address indexed to, uint256 amount, address indexed operator);
     event TokensBurned(address indexed from, uint256 amount, address indexed operator);
-    
+
     modifier onlyOperators() {
         require(operators[msg.sender] || msg.sender == avatar, "Not authorized");
         require(!paused, "Contract is paused");
         _;
     }
-    
+
     /**
      * @dev Initialize the MinterBurner contract
      * @param _nameService The NameService contract for DAO integration
+     * @param _adapter The OFT adapter address that should be authorized as operator
      */
-    function initialize(
-        INameService _nameService
-    ) public initializer {
+    function initialize(INameService _nameService, address _adapter) public initializer {
+        require(_adapter != address(0), "adapter required");
+
         setDAO(_nameService);
         token = ISuperGoodDollar(address(nativeToken()));
+
+        operators[_adapter] = true;
+        emit OperatorSet(_adapter, true);
     }
 
     /**
      * @dev Set or remove an operator that can mint/burn tokens
      * @param _operator The address of the operator (e.g., OFT adapter)
      * @param _status True to enable, false to disable
-     * 
-     * Only the DAO avatar can call this function.
      */
     function setOperator(address _operator, bool _status) external {
         _onlyAvatar();
@@ -64,20 +53,15 @@ contract GoodDollarMinterBurner is DAOUpgradeableContract {
         emit OperatorSet(_operator, _status);
     }
 
-
     /**
      * @dev Burn tokens from an address
      * @param _from The address to burn tokens from
      * @param _amount The amount of tokens to burn
      * @return success True if the burn was successful
-     * 
-     * Only authorized operators (like OFT adapter) or the DAO avatar can call this.
-     * Note: Limits are NOT enforced on the sending side (burning), matching MessagePassingBridge behavior.
-     * Limits are only enforced on the receiving side (minting) when tokens are received.
      */
     function burn(address _from, uint256 _amount) external onlyOperators returns (bool) {
         token.burnFrom(_from, _amount);
-        
+
         emit TokensBurned(_from, _amount, msg.sender);
         return true;
     }
@@ -87,8 +71,6 @@ contract GoodDollarMinterBurner is DAOUpgradeableContract {
      * @param _to The address to mint tokens to
      * @param _amount The amount of tokens to mint
      * @return success True if the mint was successful
-     * 
-     * Only authorized operators (like OFT adapter) or the DAO avatar can call this.
      */
     function mint(address _to, uint256 _amount) external onlyOperators returns (bool) {
         bool success = token.mint(_to, _amount);
@@ -99,9 +81,7 @@ contract GoodDollarMinterBurner is DAOUpgradeableContract {
     }
 
     /**
-     * @dev Pause all mint and burn operations
-     * 
-     * Only the DAO avatar can call this. Useful for emergency situations.
+     * @dev Pause all mint and burn operations (emergency use)
      */
     function pause() external {
         _onlyAvatar();
@@ -112,8 +92,6 @@ contract GoodDollarMinterBurner is DAOUpgradeableContract {
 
     /**
      * @dev Unpause mint and burn operations
-     * 
-     * Only the DAO avatar can call this.
      */
     function unpause() external {
         _onlyAvatar();
@@ -128,4 +106,5 @@ contract GoodDollarMinterBurner is DAOUpgradeableContract {
      * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
      */
     uint256[50] private __gap;
-}
\ No newline at end of file
+}
+
diff --git a/packages/bridge-contracts/contracts/test/ControllerMock.sol b/packages/bridge-contracts/contracts/test/ControllerMock.sol
new file mode 100644
index 0000000..ef33334
--- /dev/null
+++ b/packages/bridge-contracts/contracts/test/ControllerMock.sol
@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.0;
+
+contract ControllerMock {
+    address public avatar;
+
+    constructor(address _avatar) {
+        avatar = _avatar;
+    }
+
+    function setAvatar(address _avatar) external {
+        avatar = _avatar;
+    }
+}
+
diff --git a/packages/bridge-contracts/contracts/test/LayerZeroEndpointMock.sol b/packages/bridge-contracts/contracts/test/LayerZeroEndpointMock.sol
new file mode 100644
index 0000000..53e461a
--- /dev/null
+++ b/packages/bridge-contracts/contracts/test/LayerZeroEndpointMock.sol
@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.0;
+
+/**
+ * @dev Placeholder contract to provide a non-zero endpoint address for OFT adapter constructor.
+ * Tests that revert before LayerZero calls do not require any endpoint logic.
+ */
+contract LayerZeroEndpointMock {
+    // OAppCoreUpgradeable expects endpoint.setDelegate(_delegate) during initialization.
+    function setDelegate(address) external {}
+}
+
diff --git a/packages/bridge-contracts/contracts/test/MockGoodDollar.sol b/packages/bridge-contracts/contracts/test/MockGoodDollar.sol
new file mode 100644
index 0000000..7df5a4a
--- /dev/null
+++ b/packages/bridge-contracts/contracts/test/MockGoodDollar.sol
@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.0;
+
+import { ERC20 } from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+
+/**
+ * @dev Minimal token implementing mint() and burnFrom() as expected by GoodDollarOFTMinterBurner.
+ * burnFrom() respects allowances like standard ERC20Burnable.
+ */
+contract MockGoodDollar is ERC20 {
+    constructor(string memory name_, string memory symbol_) ERC20(name_, symbol_) {}
+
+    function mint(address to, uint256 amount) external returns (bool) {
+        _mint(to, amount);
+        return true;
+    }
+
+    function burnFrom(address account, uint256 amount) external {
+        uint256 currentAllowance = allowance(account, msg.sender);
+        require(currentAllowance >= amount, "ERC20: insufficient allowance");
+        unchecked {
+            _approve(account, msg.sender, currentAllowance - amount);
+        }
+        _burn(account, amount);
+    }
+}
+
diff --git a/packages/bridge-contracts/contracts/test/NameServiceMock.sol b/packages/bridge-contracts/contracts/test/NameServiceMock.sol
new file mode 100644
index 0000000..3d9ce85
--- /dev/null
+++ b/packages/bridge-contracts/contracts/test/NameServiceMock.sol
@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.0;
+
+/**
+ * @dev Minimal NameService mock compatible with GoodProtocol's DAOContract.
+ * DAOContract only requires getAddress(string) to resolve CONTROLLER and GOODDOLLAR.
+ */
+contract NameServiceMock {
+    mapping(bytes32 => address) private addresses;
+
+    function setAddress(string memory key, address value) external {
+        addresses[keccak256(bytes(key))] = value;
+    }
+
+    function getAddress(string memory key) external view returns (address) {
+        return addresses[keccak256(bytes(key))];
+    }
+}
+
diff --git a/packages/bridge-contracts/package.json b/packages/bridge-contracts/package.json
index 5450d03..2057ed1 100644
--- a/packages/bridge-contracts/package.json
+++ b/packages/bridge-contracts/package.json
@@ -54,7 +54,7 @@
     "eth-proof": "^2.1.6",
     "ethereum-waffle": "^3.4.4",
     "ethers": "^5.*",
-    "hardhat": "2.*",
+    "hardhat": "2.26",
     "hardhat-contract-sizer": "^2.6.1",
     "hardhat-deploy": "^1.0.4",
     "hardhat-gas-reporter": "^1.0.9",
diff --git a/packages/bridge-contracts/test/GoodDollarOFT.e2e.test.ts b/packages/bridge-contracts/test/GoodDollarOFT.e2e.test.ts
new file mode 100644
index 0000000..025eed0
--- /dev/null
+++ b/packages/bridge-contracts/test/GoodDollarOFT.e2e.test.ts
@@ -0,0 +1,384 @@
+import { ethers, network, upgrades } from 'hardhat';
+import { expect } from 'chai';
+import { loadFixture } from '@nomicfoundation/hardhat-network-helpers';
+import { GoodDollarOFTAdapter } from '../typechain-types';
+import { SignerWithAddress } from '@nomiclabs/hardhat-ethers/signers';
+import contracts from '@gooddollar/goodprotocol/releases/deployment.json';
+import * as networkHelpers from "@nomicfoundation/hardhat-network-helpers";
+
+const CELO_CHAIN_URL = 'https://forno.celo.org';
+/**
+ * Fork tests for GoodDollarOFTAdapter on Celo production
+ * 
+ * These tests fork the Celo mainnet and test against real deployed contracts.
+ * Run with: npx hardhat test test/GoodDollarOFTAdapter.fork.test.ts --network celo_fork
+ * 
+ * Make sure to set FORK_BLOCK_NUMBER in .env if you want to fork from a specific block
+ */
+describe('GoodDollarOFTAdapter Fork Tests (Celo Production)', () => {
+  let signers: SignerWithAddress[];
+  let celoContracts: any;
+  let owner: SignerWithAddress;
+  let user: SignerWithAddress;
+  let feeRecipient: SignerWithAddress;
+
+  // Production Celo addresses from goodprotocol
+  const PRODUCTION_CELO = 'production-celo';
+  const CELO_LZ_ENDPOINT = '0x1a44076050125825900e736c501f859c50fE728c'; // From deployMessageBridge.ts
+
+  after(async function () {
+    await networkHelpers.reset();
+  });
+  before(async function () {
+    await networkHelpers.reset(CELO_CHAIN_URL);
+
+    signers = await ethers.getSigners();
+    [owner, user, feeRecipient] = signers;
+
+    // Load Celo production contracts from goodprotocol deployment.json
+    celoContracts = contracts[PRODUCTION_CELO];
+    if (!celoContracts) {
+      throw new Error(`${PRODUCTION_CELO} contracts not found in deployment.json`);
+    }
+
+    console.log('GoodDollar token:', celoContracts.GoodDollar);
+    console.log('NameService:', celoContracts.NameService);
+  });
+
+  const setupFixture = async () => {
+    // Get deployed contracts on Celo
+    const goodDollarAddress = celoContracts.GoodDollar;
+    const nameServiceAddress = celoContracts.NameService;
+
+    // Get token contract
+    const tokenAbi = [
+      'function decimals() external view returns (uint8)',
+      'function balanceOf(address) external view returns (uint256)',
+      'function totalSupply() external view returns (uint256)',
+      'function symbol() external view returns (string)',
+      'function name() external view returns (string)',
+    ];
+    const token = await ethers.getContractAt(tokenAbi, goodDollarAddress);
+
+    // Get NameService contract
+    const nameServiceAbi = [
+      'function getAddress(string) external view returns (address)',
+      'function avatar() external view returns (address)',
+    ];
+    const nameService = await ethers.getContractAt(nameServiceAbi, nameServiceAddress);
+
+    // Deploy minter/burner without initializing yet (adapter address is required)
+    const MinterBurnerFactory = await ethers.getContractFactory('GoodDollarOFTMinterBurner');
+    const minterBurner = await MinterBurnerFactory.deploy();
+    await minterBurner.deployed();
+
+    // Deploy adapter using upgrades plugin with constructor args
+    const AdapterFactory = await ethers.getContractFactory('GoodDollarOFTAdapter');
+    const adapter = (await upgrades.deployProxy(
+      AdapterFactory,
+      [goodDollarAddress, minterBurner.address, owner.address, feeRecipient.address],
+      {
+        kind: 'uups',
+        constructorArgs: [goodDollarAddress, CELO_LZ_ENDPOINT],
+        unsafeAllow: [
+          'constructor',
+          'state-variable-immutable',
+          'duplicate-initializer-call',
+        ],
+      }
+    )) as GoodDollarOFTAdapter;
+
+    // Now that adapter exists, initialize the minter/burner and authorize adapter as operator
+    await minterBurner.initialize(nameService.address, adapter.address);
+
+    return {
+      token,
+      nameService,
+      goodDollarAddress,
+      nameServiceAddress,
+      minterBurner,
+      adapter,
+    };
+  };
+
+  describe('OFT Adapter Deployment on Fork', () => {
+    it('Should deploy GoodDollarOFTAdapter with production token', async function () {
+      const { goodDollarAddress } = await loadFixture(setupFixture);
+
+      // Deploy MinterBurner using production NameService
+      // Note: This requires NameService to have GOODDOLLAR registered
+      const MinterBurnerFactory = await ethers.getContractFactory('GoodDollarOFTMinterBurner');
+      const minterBurner = await MinterBurnerFactory.deploy();
+      await minterBurner.deployed();
+
+      // Deploy adapter using upgrades plugin with constructor args
+      const AdapterFactory = await ethers.getContractFactory('GoodDollarOFTAdapter');
+      
+      console.log('Deploying adapter...');
+      const adapter = (await upgrades.deployProxy(
+        AdapterFactory,
+        [goodDollarAddress, minterBurner.address, owner.address, feeRecipient.address],
+        {
+          kind: 'uups',
+          constructorArgs: [goodDollarAddress, CELO_LZ_ENDPOINT],
+          unsafeAllow: [
+            'constructor', 
+            'state-variable-immutable',
+            'duplicate-initializer-call',
+          ],
+        }
+      )) as GoodDollarOFTAdapter;
+      console.log('Adapter deployed:', adapter.address);
+
+      // Initialize minter/burner after adapter deployment
+      await minterBurner.initialize(celoContracts.NameService, adapter.address);
+
+      // Verify deployment
+      expect(await adapter.token()).to.equal(goodDollarAddress);
+      expect(await adapter.minterBurner()).to.equal(minterBurner.address);
+      expect(await adapter.owner()).to.equal(owner.address);
+      expect(await adapter.approvalRequired()).to.be.false;
+
+      console.log('Adapter deployed:', {
+        address: adapter.address,
+        token: await adapter.token(),
+        minterBurner: await adapter.minterBurner(),
+      });
+    });
+  });
+
+  describe('OFT Adapter Configuration', () => {
+    let adapter: GoodDollarOFTAdapter;
+    let minterBurner: any;
+
+    beforeEach(async function () {
+      const { adapter: fixtureAdapter, minterBurner: fixtureMinterBurner } = await loadFixture(setupFixture);
+      adapter = fixtureAdapter;
+      minterBurner = fixtureMinterBurner;
+    });
+
+    it('Should set bridge fees', async function () {
+      const fees = {
+        minFee: ethers.utils.parseEther('1'),
+        maxFee: ethers.utils.parseEther('100'),
+        fee: 100, // 1% in basis points
+      };
+
+      await expect(adapter.setBridgeFees(fees))
+        .to.emit(adapter, 'BridgeFeesSet')
+        .withArgs(fees.minFee, fees.maxFee, fees.fee);
+
+      const storedFees = await adapter.bridgeFees();
+      expect(storedFees.minFee).to.equal(fees.minFee);
+      expect(storedFees.maxFee).to.equal(fees.maxFee);
+      expect(storedFees.fee).to.equal(fees.fee);
+    });
+
+    it('Should set fee recipient', async function () {
+      await expect(adapter.setFeeRecipient(feeRecipient.address))
+        .to.emit(adapter, 'FeeRecipientSet')
+        .withArgs(feeRecipient.address);
+
+      expect(await adapter.feeRecipient()).to.equal(feeRecipient.address);
+    });
+
+    it('Should set bridge limits', async function () {
+      const limits = {
+        dailyLimit: ethers.utils.parseEther('1000000'),
+        txLimit: ethers.utils.parseEther('10000'),
+        accountDailyLimit: ethers.utils.parseEther('100000'),
+        minAmount: ethers.utils.parseEther('100'),
+        onlyWhitelisted: false,
+      };
+
+      await expect(adapter.setBridgeLimits(limits))
+        .to.emit(adapter, 'BridgeLimitsSet')
+        .withArgs(
+          limits.dailyLimit,
+          limits.txLimit,
+          limits.accountDailyLimit,
+          limits.minAmount,
+          limits.onlyWhitelisted
+        );
+
+      const storedLimits = await adapter.bridgeLimits();
+      expect(storedLimits.dailyLimit).to.equal(limits.dailyLimit);
+      expect(storedLimits.txLimit).to.equal(limits.txLimit);
+      expect(storedLimits.accountDailyLimit).to.equal(limits.accountDailyLimit);
+      expect(storedLimits.minAmount).to.equal(limits.minAmount);
+      expect(storedLimits.onlyWhitelisted).to.equal(limits.onlyWhitelisted);
+    });
+
+    it('Should pause/unpause bridge', async function () {
+      await expect(adapter.pauseBridge(true))
+        .to.emit(adapter, 'BridgePaused')
+        .withArgs(true);
+
+      expect(await adapter.isClosed()).to.be.true;
+
+      await expect(adapter.pauseBridge(false))
+        .to.emit(adapter, 'BridgePaused')
+        .withArgs(false);
+
+      expect(await adapter.isClosed()).to.be.false;
+    });
+  });
+
+  describe('Bridge limits enforcement (send)', () => {
+    let adapter: GoodDollarOFTAdapter;
+    let minterBurner: any;
+
+    const makeSendParam = (amountLD: any) => ({
+      dstEid: 1,
+      to: ethers.utils.hexZeroPad(user.address, 32),
+      amountLD,
+      minAmountLD: amountLD,
+      extraOptions: '0x',
+      composeMsg: '0x',
+      oftCmd: '0x',
+    });
+    const messagingFee = { nativeFee: 0, lzTokenFee: 0 };
+
+    beforeEach(async function () {
+      const { adapter: fixtureAdapter, minterBurner: fixtureMinterBurner } = await loadFixture(setupFixture);
+      adapter = fixtureAdapter;
+      minterBurner = fixtureMinterBurner;
+
+      await adapter.setBridgeLimits({
+        dailyLimit: ethers.utils.parseEther('1000000'),
+        txLimit: ethers.utils.parseEther('10000'),
+        accountDailyLimit: ethers.utils.parseEther('100000'),
+        minAmount: ethers.utils.parseEther('100'),
+        onlyWhitelisted: false,
+      });
+    });
+
+    it('Should revert with minAmount when amount is below minAmount', async function () {
+      await expect(
+        adapter.connect(user).send(makeSendParam(ethers.utils.parseEther('50')), messagingFee, user.address, { value: 0 })
+      ).to.be.revertedWithCustomError(adapter, 'BRIDGE_LIMITS').withArgs('minAmount');
+    });
+
+    it('Should revert with txLimit when amount exceeds txLimit', async function () {
+      await expect(
+        adapter.connect(user).send(makeSendParam(ethers.utils.parseEther('20000')), messagingFee, user.address, { value: 0 })
+      ).to.be.revertedWithCustomError(adapter, 'BRIDGE_LIMITS').withArgs('txLimit');
+    });
+
+    it('Should revert with accountDailyLimit when account daily limit exceeded', async function () {
+      const amount = ethers.utils.parseEther('100001');
+      await expect(
+        adapter.connect(user).send(makeSendParam(amount), messagingFee, user.address, { value: 0 })
+      ).to.be.revertedWithCustomError(adapter, 'BRIDGE_LIMITS').withArgs('accountDailyLimit');
+    });
+
+    it('Should revert with dailyLimit when bridge daily limit exceeded', async function () {
+      await adapter.setBridgeLimits({
+        dailyLimit: ethers.utils.parseEther('1000'),
+        txLimit: ethers.utils.parseEther('10000'),
+        accountDailyLimit: ethers.utils.parseEther('100000'),
+        minAmount: ethers.utils.parseEther('100'),
+        onlyWhitelisted: false,
+      });
+      const amount = ethers.utils.parseEther('1001');
+      await expect(
+        adapter.connect(user).send(makeSendParam(amount), messagingFee, user.address, { value: 0 })
+      ).to.be.revertedWithCustomError(adapter, 'BRIDGE_LIMITS').withArgs('dailyLimit');
+    });
+  });
+
+  describe('Fee Calculation (_takeFee) Tests', () => {
+    let adapter: GoodDollarOFTAdapter;
+    let minterBurner: any;
+    let token: any;
+
+    beforeEach(async function () {
+      const { adapter: fixtureAdapter, minterBurner: fixtureMinterBurner, token: fixtureToken } = await loadFixture(setupFixture);
+      adapter = fixtureAdapter;
+      minterBurner = fixtureMinterBurner;
+      token = fixtureToken;
+
+      // Set fee recipient
+      await adapter.setFeeRecipient(feeRecipient.address);
+    });
+
+    it('Should calculate fee as percentage of amount', async function () {
+      // Set fee to 1% (100 basis points)
+      await adapter.setBridgeFees({
+        minFee: ethers.utils.parseEther('0'),
+        maxFee: ethers.utils.parseEther('0'),
+        fee: 100, // 1%
+      });
+
+      // Fee calculation: amount * fee / 10000
+      // For 1000 tokens with 1% fee: 1000 * 100 / 10000 = 10 tokens
+      const amount = ethers.utils.parseEther('1000');
+      const expectedFee = amount.mul(100).div(10000);
+      
+      // We can't directly call _takeFee, but we can verify the logic
+      // by checking the fee calculation matches expected formula
+      expect(expectedFee).to.equal(ethers.utils.parseEther('10'));
+    });
+
+    it('Should enforce minFee when calculated fee is below minFee', async function () {
+      // Set fee to 0.1% with minFee of 5 tokens
+      await adapter.setBridgeFees({
+        minFee: ethers.utils.parseEther('5'),
+        maxFee: ethers.utils.parseEther('0'),
+        fee: 10, // 0.1%
+      });
+
+      // For 1000 tokens: 1000 * 10 / 10000 = 1 token (below minFee of 5)
+      // So fee should be 5 tokens (minFee)
+      const amount = ethers.utils.parseEther('1000');
+      const calculatedFee = amount.mul(10).div(10000);
+      const minFee = ethers.utils.parseEther('5');
+      
+      // The actual fee should be minFee (5) since calculated (1) < minFee (5)
+      expect(calculatedFee.lt(minFee)).to.be.true;
+    });
+
+    it('Should enforce maxFee when calculated fee exceeds maxFee', async function () {
+      // Set fee to 10% with maxFee of 50 tokens
+      await adapter.setBridgeFees({
+        minFee: ethers.utils.parseEther('0'),
+        maxFee: ethers.utils.parseEther('50'),
+        fee: 1000, // 10%
+      });
+
+      // For 1000 tokens: 1000 * 1000 / 10000 = 100 tokens (above maxFee of 50)
+      // So fee should be 50 tokens (maxFee)
+      const amount = ethers.utils.parseEther('1000');
+      const calculatedFee = amount.mul(1000).div(10000);
+      const maxFee = ethers.utils.parseEther('50');
+      
+      // The actual fee should be maxFee (50) since calculated (100) > maxFee (50)
+      expect(calculatedFee.gt(maxFee)).to.be.true;
+    });
+
+    it('Should handle zero fee', async function () {
+      await adapter.setBridgeFees({
+        minFee: ethers.utils.parseEther('0'),
+        maxFee: ethers.utils.parseEther('0'),
+        fee: 0, // 0%
+      });
+
+      const amount = ethers.utils.parseEther('1000');
+      const expectedFee = amount.mul(0).div(10000);
+      expect(expectedFee).to.equal(ethers.utils.parseEther('0'));
+    });
+
+    it('Should handle 100% fee (10000 basis points)', async function () {
+      await adapter.setBridgeFees({
+        minFee: ethers.utils.parseEther('0'),
+        maxFee: ethers.utils.parseEther('0'),
+        fee: 10000, // 100%
+      });
+
+      const amount = ethers.utils.parseEther('1000');
+      const expectedFee = amount.mul(10000).div(10000);
+      expect(expectedFee).to.equal(amount);
+    });
+  });
+});
+
diff --git a/packages/bridge-contracts/test/GoodDollarOFT.test.ts b/packages/bridge-contracts/test/GoodDollarOFT.test.ts
new file mode 100644
index 0000000..1657625
--- /dev/null
+++ b/packages/bridge-contracts/test/GoodDollarOFT.test.ts
@@ -0,0 +1,247 @@
+import { ethers, upgrades } from "hardhat";
+import { expect } from "chai";
+import { loadFixture, time } from "@nomicfoundation/hardhat-network-helpers";
+
+describe("OFT (unit, no fork)", () => {
+  async function fixture() {
+    const [owner, user, feeRecipient, avatar] = await ethers.getSigners();
+
+    // Mocks for DAO stack used by GoodDollarMinterBurner
+    const NameService = await ethers.getContractFactory("NameServiceMock");
+    const nameService = await NameService.deploy();
+    await nameService.deployed();
+
+    const Controller = await ethers.getContractFactory("ControllerMock");
+    const controller = await Controller.deploy(avatar.address);
+    await controller.deployed();
+
+    const Token = await ethers.getContractFactory("MockGoodDollar");
+    const token = await Token.deploy("GoodDollar", "G$");
+    await token.deployed();
+
+    // Wire NameService keys expected by DAOContract
+    await nameService.setAddress("CONTROLLER", controller.address);
+    await nameService.setAddress("GOODDOLLAR", token.address);
+
+    const Endpoint = await ethers.getContractFactory("LayerZeroEndpointMock");
+    const endpoint = await Endpoint.deploy();
+    await endpoint.deployed();
+
+    // Deploy minter/burner (do not initialize yet; adapter address is required)
+    const MinterBurner = await ethers.getContractFactory("GoodDollarOFTMinterBurner");
+    const minterBurner = await MinterBurner.deploy();
+    await minterBurner.deployed();
+
+    // Deploy adapter via UUPS proxy (implementation disables initializers)
+    const Adapter = await ethers.getContractFactory("GoodDollarOFTAdapter");
+    const adapter = await upgrades.deployProxy(
+      Adapter,
+      [token.address, minterBurner.address, owner.address, feeRecipient.address],
+      {
+        kind: "uups",
+        constructorArgs: [token.address, endpoint.address],
+        unsafeAllow: ["constructor", "state-variable-immutable", "duplicate-initializer-call"],
+      }
+    );
+
+    // Now that adapter exists, initialize the minter/burner and authorize adapter as operator
+    await minterBurner.initialize(nameService.address, adapter.address);
+
+    return { owner, user, feeRecipient, avatar, nameService, controller, token, endpoint, minterBurner, adapter };
+  }
+
+  describe("GoodDollarOFTMinterBurner", () => {
+    it("initializes token from NameService GOODDOLLAR", async () => {
+      const { minterBurner, token } = await loadFixture(fixture);
+      expect(await minterBurner.token()).to.equal(token.address);
+    });
+
+    it("authorizes the adapter as operator on initialize", async () => {
+      const { minterBurner, adapter } = await loadFixture(fixture);
+      expect(await minterBurner.operators(adapter.address)).to.equal(true);
+    });
+
+    it("only avatar can setOperator", async () => {
+      const { minterBurner, user, avatar, adapter } = await loadFixture(fixture);
+
+      await expect(minterBurner.connect(user).setOperator(adapter.address, true)).to.be.revertedWith(
+        "only avatar can call this method"
+      );
+
+      await expect(minterBurner.connect(avatar).setOperator(adapter.address, true))
+        .to.emit(minterBurner, "OperatorSet")
+        .withArgs(adapter.address, true);
+    });
+
+    it("operators can mint/burn; burn requires allowance", async () => {
+      const { minterBurner, token, user, avatar, owner } = await loadFixture(fixture);
+
+      await minterBurner.connect(avatar).setOperator(owner.address, true);
+
+      const amount = ethers.utils.parseEther("10");
+
+      await expect(minterBurner.connect(owner).mint(user.address, amount)).to.emit(
+        minterBurner,
+        "TokensMinted"
+      );
+
+      await token.connect(user).approve(minterBurner.address, amount);
+
+      await expect(minterBurner.connect(owner).burn(user.address, amount)).to.emit(
+        minterBurner,
+        "TokensBurned"
+      );
+    });
+
+    it("pause blocks operator mint/burn", async () => {
+      const { minterBurner, token, user, avatar, owner } = await loadFixture(fixture);
+
+      await minterBurner.connect(avatar).setOperator(owner.address, true);
+      await minterBurner.connect(avatar).pause();
+
+      await expect(minterBurner.connect(owner).mint(user.address, 1)).to.be.revertedWith(
+        "Contract is paused"
+      );
+
+      await token.connect(user).approve(minterBurner.address, 1);
+      await expect(minterBurner.connect(owner).burn(user.address, 1)).to.be.revertedWith(
+        "Contract is paused"
+      );
+    });
+  });
+
+  describe("GoodDollarOFTAdapter basic config", () => {
+    it("deploys and initializes", async () => {
+      const { adapter, token, minterBurner, feeRecipient, owner } = await loadFixture(fixture);
+      expect(await adapter.token()).to.equal(token.address);
+      expect(await adapter.minterBurner()).to.equal(minterBurner.address);
+      expect(await adapter.owner()).to.equal(owner.address);
+      expect(await adapter.feeRecipient()).to.equal(feeRecipient.address);
+      expect(await adapter.approvalRequired()).to.equal(false);
+    });
+
+    it("sets bridge fees / feeRecipient / limits / pause", async () => {
+      const { adapter, feeRecipient } = await loadFixture(fixture);
+
+      const fees = {
+        minFee: ethers.utils.parseEther("1"),
+        maxFee: ethers.utils.parseEther("100"),
+        fee: 100,
+      };
+      await expect(adapter.setBridgeFees(fees))
+        .to.emit(adapter, "BridgeFeesSet")
+        .withArgs(fees.minFee, fees.maxFee, fees.fee);
+
+      await expect(adapter.setFeeRecipient(feeRecipient.address))
+        .to.emit(adapter, "FeeRecipientSet")
+        .withArgs(feeRecipient.address);
+
+      const limits = {
+        dailyLimit: ethers.utils.parseEther("1000000"),
+        txLimit: ethers.utils.parseEther("10000"),
+        accountDailyLimit: ethers.utils.parseEther("100000"),
+        minAmount: ethers.utils.parseEther("100"),
+        onlyWhitelisted: false,
+      };
+      await expect(adapter.setBridgeLimits(limits))
+        .to.emit(adapter, "BridgeLimitsSet")
+        .withArgs(
+          limits.dailyLimit,
+          limits.txLimit,
+          limits.accountDailyLimit,
+          limits.minAmount,
+          limits.onlyWhitelisted
+        );
+
+      await expect(adapter.pauseBridge(true)).to.emit(adapter, "BridgePaused").withArgs(true);
+      expect(await adapter.isClosed()).to.equal(true);
+    });
+  });
+
+  describe("Bridge limits enforcement (send) - reverts before LZ", () => {
+    const messagingFee = { nativeFee: 0, lzTokenFee: 0 };
+
+    const makeSendParam = (to: string, amountLD: any) => ({
+      dstEid: 1,
+      to: ethers.utils.hexZeroPad(to, 32),
+      amountLD,
+      minAmountLD: amountLD,
+      extraOptions: "0x",
+      composeMsg: "0x",
+      oftCmd: "0x",
+    });
+
+    it("reverts with minAmount / txLimit / accountDailyLimit / dailyLimit", async () => {
+      const { adapter, user } = await loadFixture(fixture);
+
+      await adapter.setBridgeLimits({
+        dailyLimit: ethers.utils.parseEther("1000"),
+        txLimit: ethers.utils.parseEther("100"),
+        accountDailyLimit: ethers.utils.parseEther("200"),
+        minAmount: ethers.utils.parseEther("10"),
+        onlyWhitelisted: false,
+      });
+
+      await expect(
+        adapter
+          .connect(user)
+          .send(makeSendParam(user.address, ethers.utils.parseEther("1")), messagingFee, user.address, { value: 0 })
+      ).to.be.revertedWithCustomError(adapter, "BRIDGE_LIMITS").withArgs("minAmount");
+
+      await expect(
+        adapter
+          .connect(user)
+          .send(makeSendParam(user.address, ethers.utils.parseEther("101")), messagingFee, user.address, { value: 0 })
+      ).to.be.revertedWithCustomError(adapter, "BRIDGE_LIMITS").withArgs("txLimit");
+
+      await expect(
+        adapter
+          .connect(user)
+          .send(makeSendParam(user.address, ethers.utils.parseEther("201")), messagingFee, user.address, { value: 0 })
+      ).to.be.revertedWithCustomError(adapter, "BRIDGE_LIMITS").withArgs("accountDailyLimit");
+
+      // dailyLimit check on new window: amount > dailyLimit (raise other limits so dailyLimit is the first failure)
+      await adapter.setBridgeLimits({
+        dailyLimit: ethers.utils.parseEther("1000"),
+        txLimit: ethers.utils.parseEther("10000"),
+        accountDailyLimit: ethers.utils.parseEther("10000"),
+        minAmount: ethers.utils.parseEther("10"),
+        onlyWhitelisted: false,
+      });
+      await expect(
+        adapter
+          .connect(user)
+          .send(makeSendParam(user.address, ethers.utils.parseEther("1001")), messagingFee, user.address, { value: 0 })
+      ).to.be.revertedWithCustomError(adapter, "BRIDGE_LIMITS").withArgs("dailyLimit");
+    });
+
+    it("resets daily windows after 24h", async () => {
+      const { adapter, user } = await loadFixture(fixture);
+
+      await adapter.setBridgeLimits({
+        dailyLimit: ethers.utils.parseEther("1000"),
+        txLimit: ethers.utils.parseEther("1000"),
+        accountDailyLimit: ethers.utils.parseEther("1000"),
+        minAmount: ethers.utils.parseEther("1"),
+        onlyWhitelisted: false,
+      });
+
+      // First send passes limits but will likely revert deeper in LayerZero.
+      // We only care that it does NOT revert with BRIDGE_LIMITS before LZ.
+      await expect(
+        adapter
+          .connect(user)
+          .send(makeSendParam(user.address, ethers.utils.parseEther("10")), messagingFee, user.address, { value: 0 })
+      ).to.not.be.revertedWithCustomError(adapter, "BRIDGE_LIMITS");
+
+      await time.increase(24 * 60 * 60 + 1);
+
+      await expect(
+        adapter
+          .connect(user)
+          .send(makeSendParam(user.address, ethers.utils.parseEther("10")), messagingFee, user.address, { value: 0 })
+      ).to.not.be.revertedWithCustomError(adapter, "BRIDGE_LIMITS");
+    });
+  });
+});
+
diff --git a/packages/bridge-contracts/typechain-types/contracts/test/index.ts b/packages/bridge-contracts/typechain-types/contracts/test/index.ts
index 07eb006..0a02660 100644
--- a/packages/bridge-contracts/typechain-types/contracts/test/index.ts
+++ b/packages/bridge-contracts/typechain-types/contracts/test/index.ts
@@ -8,6 +8,10 @@ export type { testTokenSol };
 import type * as votingMockSol from "./VotingMock.sol";
 export type { votingMockSol };
 export type { ConsensusMock } from "./ConsensusMock";
+export type { ControllerMock } from "./ControllerMock";
+export type { LayerZeroEndpointMock } from "./LayerZeroEndpointMock";
+export type { MockGoodDollar } from "./MockGoodDollar";
+export type { NameServiceMock } from "./NameServiceMock";
 export type { TestRLPParser } from "./TestRLPParser";
 export type { TokenBridgeTest } from "./TokenBridgeTest";
 export type { VerifierTest } from "./VerifierTest";
diff --git a/packages/bridge-contracts/typechain-types/hardhat.d.ts b/packages/bridge-contracts/typechain-types/hardhat.d.ts
index 1e1a43a..ce8e719 100644
--- a/packages/bridge-contracts/typechain-types/hardhat.d.ts
+++ b/packages/bridge-contracts/typechain-types/hardhat.d.ts
@@ -156,18 +156,6 @@ declare module "hardhat/types/runtime" {
       name: "UniswapPair",
       signerOrOptions?: ethers.Signer | FactoryOptions
     ): Promise<Contracts.UniswapPair__factory>;
-    getContractFactory(
-      name: "IFeesFormula",
-      signerOrOptions?: ethers.Signer | FactoryOptions
-    ): Promise<Contracts.IFeesFormula__factory>;
-    getContractFactory(
-      name: "IGoodDollarCustom",
-      signerOrOptions?: ethers.Signer | FactoryOptions
-    ): Promise<Contracts.IGoodDollarCustom__factory>;
-    getContractFactory(
-      name: "ISuperGoodDollar",
-      signerOrOptions?: ethers.Signer | FactoryOptions
-    ): Promise<Contracts.ISuperGoodDollar__factory>;
     getContractFactory(
       name: "DAOContract",
       signerOrOptions?: ethers.Signer | FactoryOptions
@@ -344,10 +332,6 @@ declare module "hardhat/types/runtime" {
       name: "UUPSUpgradeable",
       signerOrOptions?: ethers.Signer | FactoryOptions
     ): Promise<Contracts.UUPSUpgradeable__factory>;
-    getContractFactory(
-      name: "IERC20PermitUpgradeable",
-      signerOrOptions?: ethers.Signer | FactoryOptions
-    ): Promise<Contracts.IERC20PermitUpgradeable__factory>;
     getContractFactory(
       name: "ContextUpgradeable",
       signerOrOptions?: ethers.Signer | FactoryOptions
@@ -376,10 +360,6 @@ declare module "hardhat/types/runtime" {
       name: "IBeacon",
       signerOrOptions?: ethers.Signer | FactoryOptions
     ): Promise<Contracts.IBeacon__factory>;
-    getContractFactory(
-      name: "ERC1967Proxy",
-      signerOrOptions?: ethers.Signer | FactoryOptions
-    ): Promise<Contracts.ERC1967Proxy__factory>;
     getContractFactory(
       name: "ERC1967Upgrade",
       signerOrOptions?: ethers.Signer | FactoryOptions
@@ -404,18 +384,6 @@ declare module "hardhat/types/runtime" {
       name: "IERC20",
       signerOrOptions?: ethers.Signer | FactoryOptions
     ): Promise<Contracts.IERC20__factory>;
-    getContractFactory(
-      name: "IERC721Metadata",
-      signerOrOptions?: ethers.Signer | FactoryOptions
-    ): Promise<Contracts.IERC721Metadata__factory>;
-    getContractFactory(
-      name: "IERC721",
-      signerOrOptions?: ethers.Signer | FactoryOptions
-    ): Promise<Contracts.IERC721__factory>;
-    getContractFactory(
-      name: "IERC777",
-      signerOrOptions?: ethers.Signer | FactoryOptions
-    ): Promise<Contracts.IERC777__factory>;
     getContractFactory(
       name: "IERC165",
       signerOrOptions?: ethers.Signer | FactoryOptions
@@ -488,10 +456,6 @@ declare module "hardhat/types/runtime" {
       name: "GoodDollarMinterBurner",
       signerOrOptions?: ethers.Signer | FactoryOptions
     ): Promise<Contracts.GoodDollarMinterBurner__factory>;
-    getContractFactory(
-      name: "IIdentity",
-      signerOrOptions?: ethers.Signer | FactoryOptions
-    ): Promise<Contracts.IIdentity__factory>;
     getContractFactory(
       name: "GoodDollarOFTAdapter",
       signerOrOptions?: ethers.Signer | FactoryOptions
@@ -500,6 +464,10 @@ declare module "hardhat/types/runtime" {
       name: "IIdentity",
       signerOrOptions?: ethers.Signer | FactoryOptions
     ): Promise<Contracts.IIdentity__factory>;
+    getContractFactory(
+      name: "GoodDollarOFTMinterBurner",
+      signerOrOptions?: ethers.Signer | FactoryOptions
+    ): Promise<Contracts.GoodDollarOFTMinterBurner__factory>;
     getContractFactory(
       name: "ISuperGoodDollar",
       signerOrOptions?: ethers.Signer | FactoryOptions
@@ -508,10 +476,26 @@ declare module "hardhat/types/runtime" {
       name: "ConsensusMock",
       signerOrOptions?: ethers.Signer | FactoryOptions
     ): Promise<Contracts.ConsensusMock__factory>;
+    getContractFactory(
+      name: "ControllerMock",
+      signerOrOptions?: ethers.Signer | FactoryOptions
+    ): Promise<Contracts.ControllerMock__factory>;
+    getContractFactory(
+      name: "LayerZeroEndpointMock",
+      signerOrOptions?: ethers.Signer | FactoryOptions
+    ): Promise<Contracts.LayerZeroEndpointMock__factory>;
+    getContractFactory(
+      name: "MockGoodDollar",
+      signerOrOptions?: ethers.Signer | FactoryOptions
+    ): Promise<Contracts.MockGoodDollar__factory>;
     getContractFactory(
       name: "Multicall",
       signerOrOptions?: ethers.Signer | FactoryOptions
     ): Promise<Contracts.Multicall__factory>;
+    getContractFactory(
+      name: "NameServiceMock",
+      signerOrOptions?: ethers.Signer | FactoryOptions
+    ): Promise<Contracts.NameServiceMock__factory>;
     getContractFactory(
       name: "TestRLPParser",
       signerOrOptions?: ethers.Signer | FactoryOptions
@@ -725,21 +709,6 @@ declare module "hardhat/types/runtime" {
       address: string,
       signer?: ethers.Signer
     ): Promise<Contracts.UniswapPair>;
-    getContractAt(
-      name: "IFeesFormula",
-      address: string,
-      signer?: ethers.Signer
-    ): Promise<Contracts.IFeesFormula>;
-    getContractAt(
-      name: "IGoodDollarCustom",
-      address: string,
-      signer?: ethers.Signer
-    ): Promise<Contracts.IGoodDollarCustom>;
-    getContractAt(
-      name: "ISuperGoodDollar",
-      address: string,
-      signer?: ethers.Signer
-    ): Promise<Contracts.ISuperGoodDollar>;
     getContractAt(
       name: "DAOContract",
       address: string,
@@ -960,11 +929,6 @@ declare module "hardhat/types/runtime" {
       address: string,
       signer?: ethers.Signer
     ): Promise<Contracts.UUPSUpgradeable>;
-    getContractAt(
-      name: "IERC20PermitUpgradeable",
-      address: string,
-      signer?: ethers.Signer
-    ): Promise<Contracts.IERC20PermitUpgradeable>;
     getContractAt(
       name: "ContextUpgradeable",
       address: string,
@@ -1000,11 +964,6 @@ declare module "hardhat/types/runtime" {
       address: string,
       signer?: ethers.Signer
     ): Promise<Contracts.IBeacon>;
-    getContractAt(
-      name: "ERC1967Proxy",
-      address: string,
-      signer?: ethers.Signer
-    ): Promise<Contracts.ERC1967Proxy>;
     getContractAt(
       name: "ERC1967Upgrade",
       address: string,
@@ -1035,21 +994,6 @@ declare module "hardhat/types/runtime" {
       address: string,
       signer?: ethers.Signer
     ): Promise<Contracts.IERC20>;
-    getContractAt(
-      name: "IERC721Metadata",
-      address: string,
-      signer?: ethers.Signer
-    ): Promise<Contracts.IERC721Metadata>;
-    getContractAt(
-      name: "IERC721",
-      address: string,
-      signer?: ethers.Signer
-    ): Promise<Contracts.IERC721>;
-    getContractAt(
-      name: "IERC777",
-      address: string,
-      signer?: ethers.Signer
-    ): Promise<Contracts.IERC777>;
     getContractAt(
       name: "IERC165",
       address: string,
@@ -1140,11 +1084,6 @@ declare module "hardhat/types/runtime" {
       address: string,
       signer?: ethers.Signer
     ): Promise<Contracts.GoodDollarMinterBurner>;
-    getContractAt(
-      name: "IIdentity",
-      address: string,
-      signer?: ethers.Signer
-    ): Promise<Contracts.IIdentity>;
     getContractAt(
       name: "GoodDollarOFTAdapter",
       address: string,
@@ -1155,6 +1094,11 @@ declare module "hardhat/types/runtime" {
       address: string,
       signer?: ethers.Signer
     ): Promise<Contracts.IIdentity>;
+    getContractAt(
+      name: "GoodDollarOFTMinterBurner",
+      address: string,
+      signer?: ethers.Signer
+    ): Promise<Contracts.GoodDollarOFTMinterBurner>;
     getContractAt(
       name: "ISuperGoodDollar",
       address: string,
@@ -1165,11 +1109,31 @@ declare module "hardhat/types/runtime" {
       address: string,
       signer?: ethers.Signer
     ): Promise<Contracts.ConsensusMock>;
+    getContractAt(
+      name: "ControllerMock",
+      address: string,
+      signer?: ethers.Signer
+    ): Promise<Contracts.ControllerMock>;
+    getContractAt(
+      name: "LayerZeroEndpointMock",
+      address: string,
+      signer?: ethers.Signer
+    ): Promise<Contracts.LayerZeroEndpointMock>;
+    getContractAt(
+      name: "MockGoodDollar",
+      address: string,
+      signer?: ethers.Signer
+    ): Promise<Contracts.MockGoodDollar>;
     getContractAt(
       name: "Multicall",
       address: string,
       signer?: ethers.Signer
     ): Promise<Contracts.Multicall>;
+    getContractAt(
+      name: "NameServiceMock",
+      address: string,
+      signer?: ethers.Signer
+    ): Promise<Contracts.NameServiceMock>;
     getContractAt(
       name: "TestRLPParser",
       address: string,
diff --git a/packages/bridge-contracts/typechain-types/index.ts b/packages/bridge-contracts/typechain-types/index.ts
index a714a9d..f0c06a1 100644
--- a/packages/bridge-contracts/typechain-types/index.ts
+++ b/packages/bridge-contracts/typechain-types/index.ts
@@ -84,12 +84,6 @@ export type { UniswapFactory } from "./@gooddollar/goodprotocol/contracts/Interf
 export { UniswapFactory__factory } from "./factories/@gooddollar/goodprotocol/contracts/Interfaces.sol/UniswapFactory__factory";
 export type { UniswapPair } from "./@gooddollar/goodprotocol/contracts/Interfaces.sol/UniswapPair";
 export { UniswapPair__factory } from "./factories/@gooddollar/goodprotocol/contracts/Interfaces.sol/UniswapPair__factory";
-export type { IFeesFormula } from "./@gooddollar/goodprotocol/contracts/token/IFeesFormula";
-export { IFeesFormula__factory } from "./factories/@gooddollar/goodprotocol/contracts/token/IFeesFormula__factory";
-export type { IGoodDollarCustom } from "./@gooddollar/goodprotocol/contracts/token/superfluid/ISuperGoodDollar.sol/IGoodDollarCustom";
-export { IGoodDollarCustom__factory } from "./factories/@gooddollar/goodprotocol/contracts/token/superfluid/ISuperGoodDollar.sol/IGoodDollarCustom__factory";
-export type { ISuperGoodDollar } from "./@gooddollar/goodprotocol/contracts/token/superfluid/ISuperGoodDollar.sol/ISuperGoodDollar";
-export { ISuperGoodDollar__factory } from "./factories/@gooddollar/goodprotocol/contracts/token/superfluid/ISuperGoodDollar.sol/ISuperGoodDollar__factory";
 export type { DAOContract } from "./@gooddollar/goodprotocol/contracts/utils/DAOContract";
 export { DAOContract__factory } from "./factories/@gooddollar/goodprotocol/contracts/utils/DAOContract__factory";
 export type { DAOUpgradeableContract } from "./@gooddollar/goodprotocol/contracts/utils/DAOUpgradeableContract";
@@ -178,8 +172,6 @@ export type { Initializable } from "./@openzeppelin/contracts-upgradeable/proxy/
 export { Initializable__factory } from "./factories/@openzeppelin/contracts-upgradeable/proxy/utils/Initializable__factory";
 export type { UUPSUpgradeable } from "./@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable";
 export { UUPSUpgradeable__factory } from "./factories/@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable__factory";
-export type { IERC20PermitUpgradeable } from "./@openzeppelin/contracts-upgradeable/token/ERC20/extensions/IERC20PermitUpgradeable";
-export { IERC20PermitUpgradeable__factory } from "./factories/@openzeppelin/contracts-upgradeable/token/ERC20/extensions/IERC20PermitUpgradeable__factory";
 export type { ContextUpgradeable } from "./@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable";
 export { ContextUpgradeable__factory } from "./factories/@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable__factory";
 export type { ERC165Upgradeable } from "./@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable";
@@ -204,12 +196,6 @@ export type { IERC20Permit } from "./@openzeppelin/contracts/token/ERC20/extensi
 export { IERC20Permit__factory } from "./factories/@openzeppelin/contracts/token/ERC20/extensions/IERC20Permit__factory";
 export type { IERC20 } from "./@openzeppelin/contracts/token/ERC20/IERC20";
 export { IERC20__factory } from "./factories/@openzeppelin/contracts/token/ERC20/IERC20__factory";
-export type { IERC721Metadata } from "./@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata";
-export { IERC721Metadata__factory } from "./factories/@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata__factory";
-export type { IERC721 } from "./@openzeppelin/contracts/token/ERC721/IERC721";
-export { IERC721__factory } from "./factories/@openzeppelin/contracts/token/ERC721/IERC721__factory";
-export type { IERC777 } from "./@openzeppelin/contracts/token/ERC777/IERC777";
-export { IERC777__factory } from "./factories/@openzeppelin/contracts/token/ERC777/IERC777__factory";
 export type { IERC165 } from "./@openzeppelin/contracts/utils/introspection/IERC165";
 export { IERC165__factory } from "./factories/@openzeppelin/contracts/utils/introspection/IERC165__factory";
 export type { BlockHeaderRegistry } from "./contracts/blockRegistry/BlockHeaderRegistry";
@@ -236,14 +222,26 @@ export type { LZHandlerUpgradeable } from "./contracts/messagePassingBridge/LZHa
 export { LZHandlerUpgradeable__factory } from "./factories/contracts/messagePassingBridge/LZHandlerUpgradeable__factory";
 export type { MessagePassingBridge } from "./contracts/messagePassingBridge/MessagePassingBridge.sol/MessagePassingBridge";
 export { MessagePassingBridge__factory } from "./factories/contracts/messagePassingBridge/MessagePassingBridge.sol/MessagePassingBridge__factory";
-export type { GoodDollarMinterBurner } from "./contracts/oft/GoodDollarMinterBurner.sol/GoodDollarMinterBurner";
-export { GoodDollarMinterBurner__factory } from "./factories/contracts/oft/GoodDollarMinterBurner.sol/GoodDollarMinterBurner__factory";
+export type { GoodDollarMinterBurner } from "./contracts/oft/GoodDollarMinterBurner";
+export { GoodDollarMinterBurner__factory } from "./factories/contracts/oft/GoodDollarMinterBurner__factory";
 export type { GoodDollarOFTAdapter } from "./contracts/oft/GoodDollarOFTAdapter.sol/GoodDollarOFTAdapter";
 export { GoodDollarOFTAdapter__factory } from "./factories/contracts/oft/GoodDollarOFTAdapter.sol/GoodDollarOFTAdapter__factory";
+export type { GoodDollarOFTMinterBurner } from "./contracts/oft/GoodDollarOFTMinterBurner";
+export { GoodDollarOFTMinterBurner__factory } from "./factories/contracts/oft/GoodDollarOFTMinterBurner__factory";
+export type { ISuperGoodDollar } from "./contracts/oft/interfaces/ISuperGoodDollar";
+export { ISuperGoodDollar__factory } from "./factories/contracts/oft/interfaces/ISuperGoodDollar__factory";
 export type { ConsensusMock } from "./contracts/test/ConsensusMock";
 export { ConsensusMock__factory } from "./factories/contracts/test/ConsensusMock__factory";
+export type { ControllerMock } from "./contracts/test/ControllerMock";
+export { ControllerMock__factory } from "./factories/contracts/test/ControllerMock__factory";
+export type { LayerZeroEndpointMock } from "./contracts/test/LayerZeroEndpointMock";
+export { LayerZeroEndpointMock__factory } from "./factories/contracts/test/LayerZeroEndpointMock__factory";
+export type { MockGoodDollar } from "./contracts/test/MockGoodDollar";
+export { MockGoodDollar__factory } from "./factories/contracts/test/MockGoodDollar__factory";
 export type { Multicall } from "./contracts/test/MultiCall.sol/Multicall";
 export { Multicall__factory } from "./factories/contracts/test/MultiCall.sol/Multicall__factory";
+export type { NameServiceMock } from "./contracts/test/NameServiceMock";
+export { NameServiceMock__factory } from "./factories/contracts/test/NameServiceMock__factory";
 export type { TestRLPParser } from "./contracts/test/TestRLPParser";
 export { TestRLPParser__factory } from "./factories/contracts/test/TestRLPParser__factory";
 export type { TestToken } from "./contracts/test/TestToken.sol/TestToken";
diff --git a/yarn.lock b/yarn.lock
index 9b48e5f..dfa99ea 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -2124,7 +2124,7 @@ __metadata:
     eth-proof: "npm:^2.1.6"
     ethereum-waffle: "npm:^3.4.4"
     ethers: "npm:^5.*"
-    hardhat: "npm:2.*"
+    hardhat: "npm:2.26"
     hardhat-contract-sizer: "npm:^2.6.1"
     hardhat-deploy: "npm:^1.0.4"
     hardhat-gas-reporter: "npm:^1.0.9"
@@ -3183,67 +3183,67 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@nomicfoundation/edr-darwin-arm64@npm:0.12.0-next.22":
-  version: 0.12.0-next.22
-  resolution: "@nomicfoundation/edr-darwin-arm64@npm:0.12.0-next.22"
-  checksum: 10/cc63789c5a496f5fa81cad2454113644d3404b715c2909d4a718ed42ff68eecedf698b09fa7d818b2c9d214bb22e10671fe5c03fff7208be33f7094a179c7fdb
+"@nomicfoundation/edr-darwin-arm64@npm:0.11.3":
+  version: 0.11.3
+  resolution: "@nomicfoundation/edr-darwin-arm64@npm:0.11.3"
+  checksum: 10/f784703e65a609a10dbcfd2b8f61639df35c1b0064c302fe8af048d8a0a772e6f59c1aff295d9420b3f2399c2bf4a224b9b57621eea70586d0113fe751a7fe1a
   languageName: node
   linkType: hard
 
-"@nomicfoundation/edr-darwin-x64@npm:0.12.0-next.22":
-  version: 0.12.0-next.22
-  resolution: "@nomicfoundation/edr-darwin-x64@npm:0.12.0-next.22"
-  checksum: 10/5497062c12560a80222026365b831005dd6341957393ab18fbfb0816f5139a9f50bd6679058cd987155ef8d055c0f78a8a1c107d1d3bbbe570dd48ad458fc9f3
+"@nomicfoundation/edr-darwin-x64@npm:0.11.3":
+  version: 0.11.3
+  resolution: "@nomicfoundation/edr-darwin-x64@npm:0.11.3"
+  checksum: 10/007561da9c7a36dec43bd72681124645df51513e29d34571d9cf9c4e674706f6c7da98bcd764315622213b3046e5be0e2809ecec0fea71293d46f60e4e367473
   languageName: node
   linkType: hard
 
-"@nomicfoundation/edr-linux-arm64-gnu@npm:0.12.0-next.22":
-  version: 0.12.0-next.22
-  resolution: "@nomicfoundation/edr-linux-arm64-gnu@npm:0.12.0-next.22"
-  checksum: 10/840580f689211d64296176bbe1aa9a915bc0861fcc986a3aff63ef06f13319528c00c23b35a8501de0c40db4215fb5d9da43660f1fcf93c078a70a19be94c177
+"@nomicfoundation/edr-linux-arm64-gnu@npm:0.11.3":
+  version: 0.11.3
+  resolution: "@nomicfoundation/edr-linux-arm64-gnu@npm:0.11.3"
+  checksum: 10/b89fdd171c9dd37e84e22e28e1a52b32707693c311c4207115d7efb7fc98ebc21094ac65e8f0f8f2436b23cc89dadf69839e5836df0ef6b8c0d78799b9430bca
   languageName: node
   linkType: hard
 
-"@nomicfoundation/edr-linux-arm64-musl@npm:0.12.0-next.22":
-  version: 0.12.0-next.22
-  resolution: "@nomicfoundation/edr-linux-arm64-musl@npm:0.12.0-next.22"
-  checksum: 10/3906d6bb396f52567370c981c2570538ab178af471644c900c59e2911d2a65695d72a1ee12e50817ed4faad022650d78ccf2928b580d42bdce9887cb924a15c6
+"@nomicfoundation/edr-linux-arm64-musl@npm:0.11.3":
+  version: 0.11.3
+  resolution: "@nomicfoundation/edr-linux-arm64-musl@npm:0.11.3"
+  checksum: 10/3135e7887c34c4eb58eb32fd04858d8294971da814e10a2b3ede4eaabb2f4b117616d780d4c86a0201d50601f00707704d935fc1f62aa8ba22698e7e14551a63
   languageName: node
   linkType: hard
 
-"@nomicfoundation/edr-linux-x64-gnu@npm:0.12.0-next.22":
-  version: 0.12.0-next.22
-  resolution: "@nomicfoundation/edr-linux-x64-gnu@npm:0.12.0-next.22"
-  checksum: 10/643b58910f43d609b75edd09ced48a42f2f69e79b14ab287393fbbc94b40ac9f7c1b10b129f5ea5e8cb1e6e2f9c7ef831c5634fff32b74aa77e92bffa80f6a98
+"@nomicfoundation/edr-linux-x64-gnu@npm:0.11.3":
+  version: 0.11.3
+  resolution: "@nomicfoundation/edr-linux-x64-gnu@npm:0.11.3"
+  checksum: 10/88c89467277cee59a5130b09f29d01a618b38b03456555f2035af6546e7a19f4002e5874fdbe50290a7f3ea0589b33f3e14cfdd2fc3ac791b5432c0daf1b0d80
   languageName: node
   linkType: hard
 
-"@nomicfoundation/edr-linux-x64-musl@npm:0.12.0-next.22":
-  version: 0.12.0-next.22
-  resolution: "@nomicfoundation/edr-linux-x64-musl@npm:0.12.0-next.22"
-  checksum: 10/fe764a03bf81e9430d61a54bcbd7fbd14ad787bd175c2d4c518e730fd55294f3c4c2b5df16e30d8e88b5657927570450e5b913b2682f7c9174d85865a616aa2b
+"@nomicfoundation/edr-linux-x64-musl@npm:0.11.3":
+  version: 0.11.3
+  resolution: "@nomicfoundation/edr-linux-x64-musl@npm:0.11.3"
+  checksum: 10/8bcdf0812cfb049bf233fcd6c4f98d63e652ff29386ed40ff1ebfc42767c817c41ca8b26db1eb26fe9839648284747c5614b2a3cc5a7f1df0de7c9a37a8bad06
   languageName: node
   linkType: hard
 
-"@nomicfoundation/edr-win32-x64-msvc@npm:0.12.0-next.22":
-  version: 0.12.0-next.22
-  resolution: "@nomicfoundation/edr-win32-x64-msvc@npm:0.12.0-next.22"
-  checksum: 10/8a04621a153369b0f8654be8af3d9ea64c6d78daaf7b11cfc99aebb53c05ad7e06876f9d729ce7edb7889648e6a3416e5515441e1fa9df066bc9b16c247be432
+"@nomicfoundation/edr-win32-x64-msvc@npm:0.11.3":
+  version: 0.11.3
+  resolution: "@nomicfoundation/edr-win32-x64-msvc@npm:0.11.3"
+  checksum: 10/000ee9ab48fe93d0fc0cb61d06fee51c0b9894c24f068deea117f933bc44ed108e8dbe13b54a6f88287bd609206b353a71a0f81ce6d1e81950922c1a85341a91
   languageName: node
   linkType: hard
 
-"@nomicfoundation/edr@npm:0.12.0-next.22":
-  version: 0.12.0-next.22
-  resolution: "@nomicfoundation/edr@npm:0.12.0-next.22"
+"@nomicfoundation/edr@npm:^0.11.3":
+  version: 0.11.3
+  resolution: "@nomicfoundation/edr@npm:0.11.3"
   dependencies:
-    "@nomicfoundation/edr-darwin-arm64": "npm:0.12.0-next.22"
-    "@nomicfoundation/edr-darwin-x64": "npm:0.12.0-next.22"
-    "@nomicfoundation/edr-linux-arm64-gnu": "npm:0.12.0-next.22"
-    "@nomicfoundation/edr-linux-arm64-musl": "npm:0.12.0-next.22"
-    "@nomicfoundation/edr-linux-x64-gnu": "npm:0.12.0-next.22"
-    "@nomicfoundation/edr-linux-x64-musl": "npm:0.12.0-next.22"
-    "@nomicfoundation/edr-win32-x64-msvc": "npm:0.12.0-next.22"
-  checksum: 10/a009a8c1e7af76ad68093fa845f8238be785ac6084da7c08df070cc1eb84e50ee86f7d69d37c1ecb3b9a64229314324f81a4719299430e181e390283cfea9fc4
+    "@nomicfoundation/edr-darwin-arm64": "npm:0.11.3"
+    "@nomicfoundation/edr-darwin-x64": "npm:0.11.3"
+    "@nomicfoundation/edr-linux-arm64-gnu": "npm:0.11.3"
+    "@nomicfoundation/edr-linux-arm64-musl": "npm:0.11.3"
+    "@nomicfoundation/edr-linux-x64-gnu": "npm:0.11.3"
+    "@nomicfoundation/edr-linux-x64-musl": "npm:0.11.3"
+    "@nomicfoundation/edr-win32-x64-msvc": "npm:0.11.3"
+  checksum: 10/e1b79c91342c5c27c3e29332852539dcee46e2b55d98e31bc959e1938393347c62ace92475ab9002ead67c792913451fde89cbc93fc4eeeb0c6dc004b440550e
   languageName: node
   linkType: hard
 
@@ -12462,13 +12462,13 @@ __metadata:
   languageName: node
   linkType: hard
 
-"hardhat@npm:2.28.3":
-  version: 2.28.3
-  resolution: "hardhat@npm:2.28.3"
+"hardhat@npm:2.26":
+  version: 2.26.5
+  resolution: "hardhat@npm:2.26.5"
   dependencies:
     "@ethereumjs/util": "npm:^9.1.0"
     "@ethersproject/abi": "npm:^5.1.2"
-    "@nomicfoundation/edr": "npm:0.12.0-next.22"
+    "@nomicfoundation/edr": "npm:^0.11.3"
     "@nomicfoundation/solidity-analyzer": "npm:^0.1.0"
     "@sentry/node": "npm:^5.18.1"
     adm-zip: "npm:^0.4.16"
@@ -12515,7 +12515,7 @@ __metadata:
       optional: true
   bin:
     hardhat: internal/cli/bootstrap.js
-  checksum: 10/588c385bb51d04000bd6c54c1c6dc058fc2911e147e50f1c1b98c8d921d0c81cf5489f8efcb82e2fd89f1ce847aec66220b2866de78f2db896f76ebfe704368f
+  checksum: 10/4c8dee9e25f93410966ac72c7166963e3191b7f20cbf2f982b39ee0ffc31008311ec3915eae095a4dea4b5672766fdf69c30580f52a40a15ba4fe267ff268c3a
   languageName: node
   linkType: hard