   function _lzCustomWithdraw(
        address _asset,
        LZSendParam memory _lzSendParam,
        uint128 _lzSendGas,
        uint128 _lzSendVal,
        uint128 _lzComposeGas,
        uint128 _lzComposeVal,
        uint16 _lzComposeMsgType
    ) private {
        PrepareLzCallReturn memory prepareLzCallReturn = _prepareLzSend(_asset, _lzSendParam, _lzSendGas, _lzSendVal);

        TapiocaOmnichainEngineHelper _toeHelper = new TapiocaOmnichainEngineHelper();
        PrepareLzCallReturn memory prepareLzCallReturn2 = _toeHelper.prepareLzCall(
            ITapiocaOmnichainEngine(_asset),
            PrepareLzCallData({
                dstEid: _lzSendParam.sendParam.dstEid,
                recipient: _lzSendParam.sendParam.to,
                amountToSendLD: 0,
                minAmountToCreditLD: 0,
                msgType: _lzComposeMsgType,
                composeMsgData: ComposeMsgData({
                    index: 0,
                    gas: _lzComposeGas,
                    value: prepareLzCallReturn.msgFee.nativeFee.toUint128(),
                    data: _lzSendParam.sendParam.composeMsg,
                    prevData: bytes(""),
                    prevOptionsData: bytes("")
                }),
                lzReceiveGas: _lzSendGas + _lzComposeGas,
                lzReceiveValue: _lzComposeVal
            })
        );

        if (msg.value < prepareLzCallReturn2.msgFee.nativeFee) {
            revert Magnetar_GasMismatch(prepareLzCallReturn2.msgFee.nativeFee, msg.value);
        }

        IOftSender(_asset).sendPacket{value: prepareLzCallReturn2.msgFee.nativeFee}(
            prepareLzCallReturn2.lzSendParam, prepareLzCallReturn2.composeMsg
        );
    }
lzSendParam_ = LZSendParam({
    sendParam: sendParam_,
    fee: msgFee_,
    extraOptions: oftMsgOptions_,
    refundAddress: address(msg.sender)
});

prepareLzCallReturn_ = PrepareLzCallReturn({
    composeMsg: composeMsg_,
    composeOptions: composeOptions_,
    sendParam: sendParam_,
    msgFee: msgFee_,
    lzSendParam: lzSendParam_,
    oftMsgOptions: oftMsgOptions_
});
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;

import "forge-std/Test.sol";
import "forge-std/console.sol";

contract Helper {
    function prepare() public returns (address) {
        return msg.sender;
    }
}

contract Magnetar {

    function compose() public returns (address) {
        Helper help = new Helper();
        return help.prepare();
    }
}

contract CounterTest is Test {

    using stdStorage for StdStorage;
    StdStorage stdlib;

    function setUp() public {

    }

    function testWhoSend() public {

        address user = vm.addr(1234);

        vm.startPrank(user);
        
        Magnetar mag = new Magnetar();

        address refundAddress = mag.compose();

        console.log("refund address is user", refundAddress == user);
        console.log("refund address is contract", refundAddress == address(mag));
    }

}
forge test -vv
Running 1 test for test/Counter.t.sol:CounterTest
[PASS] testWhoSend() (gas: 196196)
Logs:
  refund address is user false
  refund address is contract true
lzSendParam_ = LZSendParam({
    sendParam: sendParam_,
    fee: msgFee_,
    extraOptions: oftMsgOptions_,
    refundAddress: refundAddress // change here
});

prepareLzCallReturn_ = PrepareLzCallReturn({
    composeMsg: composeMsg_,
    composeOptions: composeOptions_,
    sendParam: sendParam_,
    msgFee: msgFee_,
    lzSendParam: lzSendParam_,
    oftMsgOptions: oftMsgOptions_
});
