    function transfer(address to, uint256 amount) public override returns (bool) {
        _validateTransfer(msg.sender, to);
        return super.transfer(to, amount);
    }

    function transferFrom(address from, address to, uint256 amount) public override returns (bool) {
        _validateTransfer(from, to);
        return super.transferFrom(from, to, amount);
    }

     * @dev Validates transfer restrictions.
     * @param from The sender's address.
     * @param to The recipient's address.
     */
    function _validateTransfer(address from, address to) internal view {
        // Arbitrum chain ID
        uint256 arbitrumChainId = 42161;

        // Check if the transfer is restricted
        if (
            from != owner() && // Exclude owner from restrictions
            from != transferAllowedContract && // Allow transfers to the transferAllowedContract
            to != transferAllowedContract && // Allow transfers to the transferAllowedContract
            isBridgedTokensTransferLocked && // Check if bridged transfers are locked
            // Restrict bridged token holders OR apply Arbitrum-specific restriction
            (isBridgedTokenHolder[from] || block.chainid == arbitrumChainId) &&
            to != lzEndpoint // Allow transfers to LayerZero endpoint
        ) {
            revert BridgedTokensTransferLocked();
        }
    }
        it('user1  transfer TITN tokens to user2 by bridge when transfer disable', async function () {
            // transfer TGT to the merge contract
            await tgt.connect(user1).approve(mergeTgt.address, ethers.utils.parseUnits('100', 18))
            await tgt.connect(user1).transferAndCall(mergeTgt.address, ethers.utils.parseUnits('100', 18), '0x')
            // claim TITN
            const claimableAmount = await mergeTgt.claimableTitnPerUser(user1.address)
            await mergeTgt.connect(user1).claimTitn(claimableAmount)
            // attempt to transfer TITN (spoiler alert: it should fail)
            try {
                await arbTITN.connect(user1).transfer(user2.address, ethers.utils.parseUnits('1', 18))
                expect.fail('Transaction should have reverted')
            } catch (error: any) {
                expect(error.message).to.include('BridgedTokensTransferLocked')
            }
            
            // Minting an initial amount of tokens to ownerA's address in the TITN contract
            const initialAmount = ethers.utils.parseEther('1000000000')
            // Defining the amount of tokens to send and constructing the parameters for the send operation
            const tokensToSend = ethers.utils.parseEther('1')
            // Defining extra message execution options for the send operation
            const options = Options.newOptions().addExecutorLzReceiveOption(200000, 0).toHex().toString()
            const sendParam = [
                eidA,
                ethers.utils.zeroPad(user1.address, 32),
                tokensToSend,
                tokensToSend,
                options,
                '0x',
                '0x',
            ]
            // Fetching the native fee for the token send operation
            const [nativeFee] = await arbTITN.quoteSend(sendParam, false)
            // Executing the send operation from TITN contract
            const startBalanceBOnBase = await baseTITN.balanceOf(user1.address)

            await arbTITN.connect(user1).send(sendParam, [nativeFee, 0], user1.address, { value: nativeFee })
            const finalBalanceBOnBase = await baseTITN.balanceOf(user1.address)
            expect(startBalanceBOnBase).to.eql(ethers.utils.parseEther('0'))
            expect(finalBalanceBOnBase.toString()).to.eql(tokensToSend.toString())

            // Fetching the native fee for the token send operation
            const sendParam2 = [
                eidB,
                ethers.utils.zeroPad(user2.address, 32),
                tokensToSend,
                tokensToSend,
                options,
                '0x',
                '0x',
            ]
            const [nativeFee2] = await baseTITN.quoteSend(sendParam2, false)
            const startBalanceBOnArb = await arbTITN.balanceOf(user2.address)
            await baseTITN.connect(user1).send(sendParam2, [nativeFee, 0], user2.address, { value: nativeFee2 })
            const finalBalanceBOnArb = await arbTITN.balanceOf(user2.address)

            console.log("before user2 balance: ", startBalanceBOnArb);
            console.log("after user2 balance: ", finalBalanceBOnArb);

            expect(startBalanceBOnArb).to.eql(ethers.utils.parseEther('0'))
            expect(finalBalanceBOnArb.toString()).to.eql(tokensToSend.toString())
        })
before user2 balance:  BigNumber { value: "0" }
after user2 balance:  BigNumber { value: "1000000000000000000" }
       user1  transfer TITN tokens to user2 by bridge when transfer disable
