@evvm/testnet-contracts 2.1.0 → 2.1.2

package/contracts/p2pSwap/P2PSwap.sol

@@ -559,7 +559,7 @@ contract P2PSwap is StakingServiceHooks {
      * @param _nonce_Evvm Nonce for EVVM payment transaction
      * @param _priority_Evvm Whether to use priority (async) processing
      * @param _signature_Evvm Signature for EVVM payment authorization
-     * @param _amountOut Maximum output amount for fee calculation (testing parameter)
+     * @param maxFillFixedFee Maximum output amount for fee calculation (testing parameter)
      */
     function dispatchOrder_fillFixedFee(
         address user,
@@ -568,7 +568,7 @@ contract P2PSwap is StakingServiceHooks {
         uint256 _nonce_Evvm,
         bool _priority_Evvm,
         bytes memory _signature_Evvm,
-        uint256 _amountOut ///@dev for testing purposes
+        uint256 maxFillFixedFee
     ) external {
         if (
             !SignatureUtils.verifyMessageSignedForDispatchOrder(
@@ -598,9 +598,8 @@ contract P2PSwap is StakingServiceHooks {
         }
 
         (uint256 fee, uint256 fee10) = calculateFillFixedFee(
-            metadata.tokenB,
             ordersInsideMarket[market][metadata.orderId].amountB,
-            _amountOut
+            maxFillFixedFee
         );
 
         if (
@@ -704,19 +703,17 @@ contract P2PSwap is StakingServiceHooks {
     /**
      * @notice Calculates fixed trading fee with maximum limit constraints
      * @dev Compares proportional fee with maximum output, applies 10% reduction if needed
-     * @param token Token address for fee calculation (currently unused)
      * @param amount Order amount for proportional fee calculation
-     * @param _amountOut Maximum output amount for fee limiting (testing parameter)
+     * @param maxFillFixedFee Maximum output amount for fee limiting
      * @return fee The final calculated fee amount
      * @return fee10 10% of the fee amount for specific calculations
      */
     function calculateFillFixedFee(
-        address token,
         uint256 amount,
-        uint256 _amountOut
+        uint256 maxFillFixedFee
     ) internal view returns (uint256 fee, uint256 fee10) {
-        if (calculateFillPropotionalFee(amount) > _amountOut) {
-            fee = _amountOut;
+        if (calculateFillPropotionalFee(amount) > maxFillFixedFee) {
+            fee = maxFillFixedFee;
             fee10 = (fee * 1000) / 10_000;
         } else {
             fee = calculateFillPropotionalFee(amount);

package/contracts/treasuryTwoChains/TreasuryExternalChainStation.sol

@@ -3,6 +3,34 @@
 
 pragma solidity ^0.8.0;
 
+/**
+ _____                                                       
+/__   \_ __ ___  __ _ ___ _   _ _ __ _   _                   
+  / /\| '__/ _ \/ _` / __| | | | '__| | | |                  
+ / /  | | |  __| (_| \__ | |_| | |  | |_| |                  
+ \/   |_|  \___|\__,_|___/\__,_|_|   \__, |                  
+                                     |___/                   
+   ___ _           _       __ _        _   _                 
+  / __| |__   __ _(_)_ __ / _| |_ __ _| |_(_) ___  _ __      
+ / /  | '_ \ / _` | | '_ \\ \| __/ _` | __| |/ _ \| '_ \     
+/ /___| | | | (_| | | | | _\ | || (_| | |_| | (_) | | | |    
+\____/|_| |_|\__,_|_|_| |_\__/\__\__,_|\__|_|\___/|_| |_|    
+                                                             
+                                                             
+                                                             
+ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ 
+|_____|_____|_____|_____|_____|_____|_____|_____|_____|_____|
+                                                             
+    ______     __                        __        __          _     
+   / _____  __/ /____  _________  ____ _/ /  _____/ /_  ____ _(_____ 
+  / __/ | |/_/ __/ _ \/ ___/ __ \/ __ `/ /  / ___/ __ \/ __ `/ / __ \
+ / /____>  </ /_/  __/ /  / / / / /_/ / /  / /__/ / / / /_/ / / / / /
+/_____/_/|_|\__/\___/_/  /_/ /_/\__,_/_/   \___/_/ /_/\__,_/_/_/ /_/ 
+                                                                      
+ * @title Treasury Cross-Chain Host Station Contract
+ * @author Mate labs
+ */
+
 import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 import {ErrorsLib} from "@evvm/testnet-contracts/contracts/treasuryTwoChains/lib/ErrorsLib.sol";
 import {ExternalChainStationStructs} from "@evvm/testnet-contracts/contracts/treasuryTwoChains/lib/ExternalChainStationStructs.sol";
@@ -10,9 +38,11 @@ import {ExternalChainStationStructs} from "@evvm/testnet-contracts/contracts/tre
 import {SafeTransferLib} from "@solady/utils/SafeTransferLib.sol";
 
 import {SignatureUtils} from "@evvm/testnet-contracts/contracts/treasuryTwoChains/lib/SignatureUtils.sol";
+import {PayloadUtils} from "@evvm/testnet-contracts/contracts/treasuryTwoChains/lib/PayloadUtils.sol";
 
 import {IMailbox} from "@hyperlane-xyz/core/contracts/interfaces/IMailbox.sol";
 
+import {MessagingParams, MessagingReceipt} from "@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/ILayerZeroEndpointV2.sol";
 import {OApp, Origin, MessagingFee} from "@layerzerolabs/oapp-evm/contracts/oapp/OApp.sol";
 import {OAppOptionsType3} from "@layerzerolabs/oapp-evm/contracts/oapp/libs/OAppOptionsType3.sol";
 import {OptionsBuilder} from "@layerzerolabs/oapp-evm/contracts/oapp/libs/OptionsBuilder.sol";
@@ -29,27 +59,58 @@ contract TreasuryExternalChainStation is
     OAppOptionsType3,
     AxelarExecutable
 {
+    /// @notice Admin address management with time-delayed proposals
+    /// @dev Stores current admin, proposed admin, and acceptance timestamp
     AddressTypeProposal admin;
 
+    /// @notice Fisher executor address management with time-delayed proposals
+    /// @dev Fisher executor can process cross-chain bridge transactions
     AddressTypeProposal fisherExecutor;
 
+    /// @notice Hyperlane protocol configuration for cross-chain messaging
+    /// @dev Contains domain ID, host chain address, and mailbox contract address
     HyperlaneConfig hyperlane;
 
+    /// @notice LayerZero protocol configuration for omnichain messaging
+    /// @dev Contains endpoint ID, host chain address, and endpoint contract address
     LayerZeroConfig layerZero;
 
+    /// @notice Axelar protocol configuration for cross-chain communication
+    /// @dev Contains chain name, host chain address, gas service, and gateway addresses
     AxelarConfig axelar;
 
+    /// @notice Pending proposal for changing host chain addresses across all protocols
+    /// @dev Used for coordinated updates to host chain addresses with time delay
+    ChangeHostChainAddressParams hostChainAddressChangeProposal;
+
+    /// @notice Unique identifier for the EVVM instance this station belongs to
+    /// @dev Immutable value set at deployment for signature verification
     uint256 immutable EVVM_ID;
 
+    /// @notice Tracks the next nonce for Fisher bridge operations per user address
+    /// @dev Prevents replay attacks in Fisher bridge transactions
     mapping(address => uint256) nextFisherExecutionNonce;
 
-    bytes _options =
+    /// @notice LayerZero execution options with gas limit configuration
+    /// @dev Pre-built options for LayerZero message execution (200k gas limit)
+    bytes options =
         OptionsBuilder.addExecutorLzReceiveOption(
             OptionsBuilder.newOptions(),
-            50000,
+            200_000,
             0
         );
 
+    /// @notice One-time fuse for setting initial host chain addresses
+    /// @dev Prevents multiple calls to _setHostChainAddress after initial setup
+    bytes1 fuseSetHostChainAddress = 0x01;
+
+    /// @notice Emitted when Fisher bridge sends tokens from external to host chain
+    /// @param from Original sender address on external chain
+    /// @param addressToReceive Recipient address on host chain
+    /// @param tokenAddress Token contract address (address(0) for ETH)
+    /// @param priorityFee Fee paid for priority processing
+    /// @param amount Amount of tokens transferred
+    /// @param nonce Sequential nonce for the Fisher bridge operation
     event FisherBridgeSend(
         address indexed from,
         address indexed addressToReceive,
@@ -59,6 +120,8 @@ contract TreasuryExternalChainStation is
         uint256 nonce
     );
 
+    /// @notice Restricts function access to the current admin only
+    /// @dev Validates caller against admin.current address
     modifier onlyAdmin() {
         if (msg.sender != admin.current) {
             revert();
@@ -66,6 +129,8 @@ contract TreasuryExternalChainStation is
         _;
     }
 
+    /// @notice Restricts function access to the current Fisher executor only
+    /// @dev Validates caller against fisherExecutor.current address for bridge operations
     modifier onlyFisherExecutor() {
         if (msg.sender != fisherExecutor.current) {
             revert();
@@ -73,6 +138,11 @@ contract TreasuryExternalChainStation is
         _;
     }
 
+    /// @notice Initializes the External Chain Station with cross-chain protocol configurations
+    /// @dev Sets up Hyperlane, LayerZero, and Axelar configurations for multi-protocol support
+    /// @param _admin Initial admin address with full administrative privileges
+    /// @param _crosschainConfig Configuration struct containing all cross-chain protocol settings
+    /// @param _evvmId Unique identifier for the EVVM instance this station serves
     constructor(
         address _admin,
         CrosschainConfig memory _crosschainConfig,
@@ -108,10 +178,16 @@ contract TreasuryExternalChainStation is
         EVVM_ID = _evvmId;
     }
 
-    function setHostChainAddress(
+    /// @notice One-time setup of host chain station address across all protocols
+    /// @dev Can only be called once (protected by fuseSetHostChainAddress)
+    /// @param hostChainStationAddress Address-type representation for Hyperlane and LayerZero
+    /// @param hostChainStationAddressString String representation for Axelar protocol
+    function _setHostChainAddress(
         address hostChainStationAddress,
         string memory hostChainStationAddressString
     ) external onlyAdmin {
+        if (fuseSetHostChainAddress != 0x01) revert();
+
         hyperlane.hostChainStationAddress = bytes32(
             uint256(uint160(hostChainStationAddress))
         );
@@ -123,20 +199,27 @@ contract TreasuryExternalChainStation is
             layerZero.hostChainStationEid,
             layerZero.hostChainStationAddress
         );
+
+        fuseSetHostChainAddress = 0x00;
     }
 
-    /**
-     * @notice Withdraw ETH or ERC20 tokens
-     * @param token Token address (address(0) for ETH)
-     * @param amount Amount to withdraw
-     */
+    /// @notice Deposits ERC20 tokens and sends them to host chain via selected protocol
+    /// @dev Supports Hyperlane (0x01), LayerZero (0x02), and Axelar (0x03) protocols
+    /// @param toAddress Recipient address on the host chain
+    /// @param token ERC20 token contract address to deposit and transfer
+    /// @param amount Amount of tokens to deposit and send to host chain
+    /// @param protocolToExecute Protocol selector: 0x01=Hyperlane, 0x02=LayerZero, 0x03=Axelar
     function depositERC20(
         address toAddress,
         address token,
         uint256 amount,
         bytes1 protocolToExecute
     ) external payable {
-        bytes memory payload = encodePayload(token, toAddress, amount);
+        bytes memory payload = PayloadUtils.encodePayload(
+            token,
+            toAddress,
+            amount
+        );
         verifyAndDepositERC20(token, amount);
         if (protocolToExecute == 0x01) {
             // 0x01 = Hyperlane
@@ -150,12 +233,12 @@ contract TreasuryExternalChainStation is
             );
         } else if (protocolToExecute == 0x02) {
             // 0x02 = LayerZero
-            uint256 fee = quoteLayerZero(toAddress, token, amount);
+            uint256 quote = quoteLayerZero(toAddress, token, amount);
             _lzSend(
                 layerZero.hostChainStationEid,
                 payload,
-                _options,
-                MessagingFee(fee, 0),
+                options,
+                MessagingFee(quote, 0),
                 msg.sender // Refund any excess fees to the sender.
             );
         } else if (protocolToExecute == 0x03) {
@@ -178,6 +261,11 @@ contract TreasuryExternalChainStation is
         }
     }
 
+    /// @notice Deposits native ETH and sends it to host chain via selected protocol
+    /// @dev msg.value must cover both the amount and protocol fees
+    /// @param toAddress Recipient address on the host chain
+    /// @param amount Amount of ETH to send to host chain (must be <= msg.value - fees)
+    /// @param protocolToExecute Protocol selector: 0x01=Hyperlane, 0x02=LayerZero, 0x03=Axelar
     function depositCoin(
         address toAddress,
         uint256 amount,
@@ -185,7 +273,11 @@ contract TreasuryExternalChainStation is
     ) external payable {
         if (msg.value < amount) revert ErrorsLib.InsufficientBalance();
 
-        bytes memory payload = encodePayload(address(0), toAddress, amount);
+        bytes memory payload = PayloadUtils.encodePayload(
+            address(0),
+            toAddress,
+            amount
+        );
 
         if (protocolToExecute == 0x01) {
             // 0x01 = Hyperlane
@@ -207,7 +299,7 @@ contract TreasuryExternalChainStation is
             _lzSend(
                 layerZero.hostChainStationEid,
                 payload,
-                _options,
+                options,
                 MessagingFee(fee, 0),
                 msg.sender // Refund any excess fees to the sender.
             );
@@ -231,6 +323,14 @@ contract TreasuryExternalChainStation is
         }
     }
 
+    /// @notice Receives and validates Fisher bridge transactions from host chain
+    /// @dev Verifies signature and increments nonce but doesn't transfer tokens (receive-only)
+    /// @param from Original sender address from host chain
+    /// @param addressToReceive Intended recipient address on this chain
+    /// @param tokenAddress Token contract address (address(0) for ETH)
+    /// @param priorityFee Fee amount for priority processing
+    /// @param amount Amount of tokens being received
+    /// @param signature ECDSA signature proving transaction authorization
     function fisherBridgeReceive(
         address from,
         address addressToReceive,
@@ -255,6 +355,14 @@ contract TreasuryExternalChainStation is
         nextFisherExecutionNonce[from]++;
     }
 
+    /// @notice Processes Fisher bridge ERC20 token transfers to host chain
+    /// @dev Validates signature, deposits tokens, and emits tracking event
+    /// @param from Original sender address initiating the bridge transaction
+    /// @param addressToReceive Recipient address on the host chain
+    /// @param tokenAddress ERC20 token contract address to bridge
+    /// @param priorityFee Fee amount for priority processing
+    /// @param amount Amount of tokens to bridge to host chain
+    /// @param signature ECDSA signature proving transaction authorization
     function fisherBridgeSendERC20(
         address from,
         address addressToReceive,
@@ -290,6 +398,13 @@ contract TreasuryExternalChainStation is
         );
     }
 
+    /// @notice Processes Fisher bridge ETH transfers to host chain
+    /// @dev Validates signature and exact payment (amount + priority fee)
+    /// @param from Original sender address initiating the bridge transaction
+    /// @param addressToReceive Recipient address on the host chain
+    /// @param priorityFee Fee amount for priority processing
+    /// @param amount Amount of ETH to bridge to host chain
+    /// @param signature ECDSA signature proving transaction authorization
     function fisherBridgeSendCoin(
         address from,
         address addressToReceive,
@@ -326,6 +441,13 @@ contract TreasuryExternalChainStation is
     }
 
     // Hyperlane Specific Functions //
+    
+    /// @notice Calculates the fee required for Hyperlane cross-chain message dispatch
+    /// @dev Queries the Hyperlane mailbox for accurate fee estimation
+    /// @param toAddress Recipient address on the destination chain
+    /// @param token Token contract address being transferred
+    /// @param amount Amount of tokens being transferred
+    /// @return Fee amount in native currency required for the Hyperlane message
     function getQuoteHyperlane(
         address toAddress,
         address token,
@@ -335,10 +457,15 @@ contract TreasuryExternalChainStation is
             IMailbox(hyperlane.mailboxAddress).quoteDispatch(
                 hyperlane.hostChainStationDomainId,
                 hyperlane.hostChainStationAddress,
-                encodePayload(token, toAddress, amount)
+                PayloadUtils.encodePayload(token, toAddress, amount)
             );
     }
 
+    /// @notice Handles incoming Hyperlane messages from the host chain
+    /// @dev Validates origin, sender authorization, and processes the payload
+    /// @param _origin Source chain domain ID where the message originated
+    /// @param _sender Address of the message sender (must be host chain station)
+    /// @param _data Encoded payload containing transfer instructions
     function handle(
         uint32 _origin,
         bytes32 _sender,
@@ -358,6 +485,12 @@ contract TreasuryExternalChainStation is
 
     // LayerZero Specific Functions //
 
+    /// @notice Calculates the fee required for LayerZero cross-chain message
+    /// @dev Queries LayerZero endpoint for accurate native fee estimation
+    /// @param toAddress Recipient address on the destination chain
+    /// @param token Token contract address being transferred
+    /// @param amount Amount of tokens being transferred
+    /// @return Native fee amount required for the LayerZero message
     function quoteLayerZero(
         address toAddress,
         address token,
@@ -365,13 +498,17 @@ contract TreasuryExternalChainStation is
     ) public view returns (uint256) {
         MessagingFee memory fee = _quote(
             layerZero.hostChainStationEid,
-            encodePayload(token, toAddress, amount),
-            _options,
+            PayloadUtils.encodePayload(token, toAddress, amount),
+            options,
             false
         );
         return fee.nativeFee;
     }
 
+    /// @notice Handles incoming LayerZero messages from the host chain
+    /// @dev Validates origin chain and sender, then processes the transfer payload
+    /// @param _origin Origin information containing source endpoint ID and sender
+    /// @param message Encoded payload containing transfer instructions
     function _lzReceive(
         Origin calldata _origin,
         bytes32 /*_guid*/,
@@ -389,8 +526,46 @@ contract TreasuryExternalChainStation is
         decodeAndGive(message);
     }
 
+    /// @notice Sends LayerZero messages to the destination chain
+    /// @dev Handles fee payment and message dispatch through LayerZero endpoint
+    /// @param _dstEid Destination endpoint ID (target chain)
+    /// @param _message Encoded message payload to send
+    /// @param _options Execution options for the destination chain
+    /// @param _fee Messaging fee structure (native + LZ token fees)
+    /// @param _refundAddress Address to receive excess fees
+    /// @return receipt Messaging receipt with transaction details
+    function _lzSend(
+        uint32 _dstEid,
+        bytes memory _message,
+        bytes memory _options,
+        MessagingFee memory _fee,
+        address _refundAddress
+    ) internal override returns (MessagingReceipt memory receipt) {
+        // @dev Push corresponding fees to the endpoint, any excess is sent back to the _refundAddress from the endpoint.
+        uint256 messageValue = _fee.nativeFee;
+        if (_fee.lzTokenFee > 0) _payLzToken(_fee.lzTokenFee);
+
+        return
+            // solhint-disable-next-line check-send-result
+            endpoint.send{value: messageValue}(
+                MessagingParams(
+                    _dstEid,
+                    _getPeerOrRevert(_dstEid),
+                    _message,
+                    _options,
+                    _fee.lzTokenFee > 0
+                ),
+                _refundAddress
+            );
+    }
+
     // Axelar Specific Functions //
 
+    /// @notice Handles incoming Axelar messages from the host chain
+    /// @dev Validates source chain and address, then processes the transfer payload
+    /// @param _sourceChain Source blockchain name (must match configured host chain)
+    /// @param _sourceAddress Source contract address (must match host chain station)
+    /// @param _payload Encoded payload containing transfer instructions
     function _execute(
         bytes32 /*commandId*/,
         string calldata _sourceChain,
@@ -406,11 +581,9 @@ contract TreasuryExternalChainStation is
         decodeAndGive(_payload);
     }
 
-    /**
-     * @notice Proposes a new admin address with 1-day time delay
-     * @dev Part of the time-delayed governance system for admin changes
-     * @param _newOwner Address of the proposed new admin
-     */
+    /// @notice Proposes a new admin address with 1-day time delay
+    /// @dev Part of the time-delayed governance system for admin changes
+    /// @param _newOwner Address of the proposed new admin (cannot be zero or current admin)
     function proposeAdmin(address _newOwner) external onlyAdmin {
         if (_newOwner == address(0) || _newOwner == admin.current) revert();
 
@@ -418,19 +591,15 @@ contract TreasuryExternalChainStation is
         admin.timeToAccept = block.timestamp + 1 days;
     }
 
-    /**
-     * @notice Cancels a pending admin change proposal
-     * @dev Allows current admin to reject proposed admin changes
-     */
+    /// @notice Cancels a pending admin change proposal
+    /// @dev Allows current admin to reject proposed admin changes and reset proposal state
     function rejectProposalAdmin() external onlyAdmin {
         admin.proposal = address(0);
         admin.timeToAccept = 0;
     }
 
-    /**
-     * @notice Accepts a pending admin proposal and becomes the new admin
-     * @dev Can only be called by the proposed admin after the time delay
-     */
+    /// @notice Accepts a pending admin proposal and becomes the new admin
+    /// @dev Can only be called by the proposed admin after the 1-day time delay
     function acceptAdmin() external {
         if (block.timestamp < admin.timeToAccept) revert();
 
@@ -440,8 +609,13 @@ contract TreasuryExternalChainStation is
 
         admin.proposal = address(0);
         admin.timeToAccept = 0;
+
+        _transferOwnership(admin.current);
     }
 
+    /// @notice Proposes a new Fisher executor address with 1-day time delay
+    /// @dev Fisher executor handles cross-chain bridge transaction processing
+    /// @param _newFisherExecutor Address of the proposed new Fisher executor
     function proposeFisherExecutor(
         address _newFisherExecutor
     ) external onlyAdmin {
@@ -454,11 +628,15 @@ contract TreasuryExternalChainStation is
         fisherExecutor.timeToAccept = block.timestamp + 1 days;
     }
 
+    /// @notice Cancels a pending Fisher executor change proposal
+    /// @dev Allows current admin to reject Fisher executor changes and reset proposal state
     function rejectProposalFisherExecutor() external onlyAdmin {
         fisherExecutor.proposal = address(0);
         fisherExecutor.timeToAccept = 0;
     }
 
+    /// @notice Accepts a pending Fisher executor proposal
+    /// @dev Can only be called by the proposed Fisher executor after the 1-day time delay
     function acceptFisherExecutor() external {
         if (block.timestamp < fisherExecutor.timeToAccept) revert();
 
@@ -470,11 +648,72 @@ contract TreasuryExternalChainStation is
         fisherExecutor.timeToAccept = 0;
     }
 
+    /// @notice Proposes new host chain addresses for all protocols with 1-day time delay
+    /// @dev Updates addresses across Hyperlane, LayerZero, and Axelar simultaneously
+    /// @param hostChainStationAddress Address-type representation for Hyperlane and LayerZero
+    /// @param hostChainStationAddressString String representation for Axelar protocol
+    function proposeHostChainAddress(
+        address hostChainStationAddress,
+        string memory hostChainStationAddressString
+    ) external onlyAdmin {
+        if (fuseSetHostChainAddress == 0x01) revert();
+
+        hostChainAddressChangeProposal = ChangeHostChainAddressParams({
+            porposeAddress_AddressType: hostChainStationAddress,
+            porposeAddress_StringType: hostChainStationAddressString,
+            timeToAccept: block.timestamp + 1 days
+        });
+    }
+
+    /// @notice Cancels a pending host chain address change proposal
+    /// @dev Resets the host chain address proposal to default state
+    function rejectProposalHostChainAddress() external onlyAdmin {
+        hostChainAddressChangeProposal = ChangeHostChainAddressParams({
+            porposeAddress_AddressType: address(0),
+            porposeAddress_StringType: "",
+            timeToAccept: 0
+        });
+    }
+
+    /// @notice Accepts pending host chain address changes across all protocols
+    /// @dev Updates Hyperlane, LayerZero, and Axelar configurations simultaneously
+    function acceptHostChainAddress() external {
+        if (block.timestamp < hostChainAddressChangeProposal.timeToAccept)
+            revert();
+
+        hyperlane.hostChainStationAddress = bytes32(
+            uint256(
+                uint160(
+                    hostChainAddressChangeProposal.porposeAddress_AddressType
+                )
+            )
+        );
+        layerZero.hostChainStationAddress = bytes32(
+            uint256(
+                uint160(
+                    hostChainAddressChangeProposal.porposeAddress_AddressType
+                )
+            )
+        );
+        axelar.hostChainStationAddress = hostChainAddressChangeProposal
+            .porposeAddress_StringType;
+
+        _setPeer(
+            layerZero.hostChainStationEid,
+            layerZero.hostChainStationAddress
+        );
+    }
+
     // Getter functions //
+    
+    /// @notice Returns the complete admin configuration including proposals and timelock
+    /// @return Current admin address, proposed admin, and acceptance timestamp
     function getAdmin() external view returns (AddressTypeProposal memory) {
         return admin;
     }
 
+    /// @notice Returns the complete Fisher executor configuration including proposals and timelock
+    /// @return Current Fisher executor address, proposed executor, and acceptance timestamp
     function getFisherExecutor()
         external
         view
@@ -483,12 +722,18 @@ contract TreasuryExternalChainStation is
         return fisherExecutor;
     }
 
+    /// @notice Returns the next nonce for Fisher bridge operations for a specific user
+    /// @dev Used to prevent replay attacks in cross-chain bridge transactions
+    /// @param user Address to query the next Fisher execution nonce for
+    /// @return Next sequential nonce value for the user's Fisher bridge operations
     function getNextFisherExecutionNonce(
         address user
     ) external view returns (uint256) {
         return nextFisherExecutionNonce[user];
     }
 
+    /// @notice Returns the complete Hyperlane protocol configuration
+    /// @return Hyperlane configuration including domain ID, host chain address, and mailbox
     function getHyperlaneConfig()
         external
         view
@@ -497,6 +742,8 @@ contract TreasuryExternalChainStation is
         return hyperlane;
     }
 
+    /// @notice Returns the complete LayerZero protocol configuration
+    /// @return LayerZero configuration including endpoint ID, host chain address, and endpoint
     function getLayerZeroConfig()
         external
         view
@@ -505,25 +752,35 @@ contract TreasuryExternalChainStation is
         return layerZero;
     }
 
+    /// @notice Returns the complete Axelar protocol configuration
+    /// @return Axelar configuration including chain name, addresses, gas service, and gateway
     function getAxelarConfig() external view returns (AxelarConfig memory) {
         return axelar;
     }
 
+    /// @notice Returns the LayerZero execution options configuration
+    /// @return Encoded options bytes for LayerZero message execution (200k gas limit)
     function getOptions() external view returns (bytes memory) {
-        return _options;
+        return options;
     }
 
     // Internal Functions //
 
+    /// @notice Decodes cross-chain payload and executes the token transfer
+    /// @dev Handles both ETH (address(0)) and ERC20 token transfers to recipients
+    /// @param payload Encoded transfer data containing token, recipient, and amount
     function decodeAndGive(bytes memory payload) internal {
-        (address token, address toAddress, uint256 amount) = decodePayload(
-            payload
-        );
+        (address token, address toAddress, uint256 amount) = PayloadUtils
+            .decodePayload(payload);
         if (token == address(0))
-            SafeTransferLib.safeTransferETH(msg.sender, amount);
+            SafeTransferLib.safeTransferETH(toAddress, amount);
         else IERC20(token).transfer(toAddress, amount);
     }
 
+    /// @notice Validates and deposits ERC20 tokens from the caller
+    /// @dev Verifies token approval and executes transferFrom to this contract
+    /// @param token ERC20 token contract address (cannot be address(0))
+    /// @param amount Amount of tokens to deposit and hold in this contract
     function verifyAndDepositERC20(address token, uint256 amount) internal {
         if (token == address(0)) revert();
         if (IERC20(token).allowance(msg.sender, address(this)) < amount)
@@ -532,20 +789,13 @@ contract TreasuryExternalChainStation is
         IERC20(token).transferFrom(msg.sender, address(this), amount);
     }
 
-    function encodePayload(
-        address token,
-        address toAddress,
-        uint256 amount
-    ) internal pure returns (bytes memory payload) {
-        payload = abi.encode(token, toAddress, amount);
-    }
+    /// @notice Disabled ownership transfer function for security
+    /// @dev Ownership changes must go through the time-delayed admin proposal system
+    function transferOwnership(
+        address newOwner
+    ) public virtual override onlyOwner {}
 
-    function decodePayload(
-        bytes memory payload
-    ) internal pure returns (address token, address toAddress, uint256 amount) {
-        (token, toAddress, amount) = abi.decode(
-            payload,
-            (address, address, uint256)
-        );
-    }
+    /// @notice Disabled ownership renouncement function for security
+    /// @dev Prevents accidental loss of administrative control over the contract
+    function renounceOwnership() public virtual override onlyOwner {}
 }