Omnichain Applications (OApps) & Design Patterns

// PSEUDOCODE: Batch send with fee distribution

// Override fee check from equivalency to minimum threshold
function _payNative(uint256 _nativeFee) internal override returns (uint256 nativeFee) {
    if (msg.value < _nativeFee) revert NotEnoughNative(msg.value);
    return _nativeFee;
}

function quoteBatch(uint32[] memory dstEids, bytes memory message) public view returns (MessagingFee memory totalFee) {
    // Sum fees for all destinations
    for (uint i = 0; i < dstEids.length; i++) {
        MessagingFee memory fee = _quote(dstEids[i], message, options, false);
        totalFee.nativeFee += fee.nativeFee;
        totalFee.lzTokenFee += fee.lzTokenFee;
    }
}

function sendBatch(uint32[] memory dstEids, bytes memory message) external payable {
    // Validate total fee upfront
    MessagingFee memory totalFee = quoteBatch(dstEids, message);
    require(msg.value >= totalFee.nativeFee, "Insufficient fee");

    // Distribute to each destination
    for (uint i = 0; i < dstEids.length; i++) {
        MessagingFee memory fee = _quote(dstEids[i], message, options, false);
        _lzSend(dstEids[i], message, options, fee, payable(msg.sender));
    }
}

// PSEUDOCODE: This pattern organizes your call logic into separate internal functions
// instead of putting all logic directly inside _lzReceive

// Define message type constants
bytes32 constant PUSH = keccak256("PUSH");           // A->B standard message
bytes32 constant PING_PONG = keccak256("PING_PONG"); // A->B->A ping-pong message

function _lzReceive(Origin calldata origin, bytes32 guid, bytes calldata message, address, bytes calldata)
    internal override {
    (bytes32 msgType, bytes memory businessLogic) = abi.decode(message, (bytes32, bytes));

    if (msgType == PING_PONG) {
        _lzReceiveAndReturn(origin, businessLogic);    // Move ping pong logic to separate function
    } else {
        _lzReceiveOnly(businessLogic);                 // Move standard logic to separate function
    }
}

function _lzReceiveAndReturn(Origin calldata origin, bytes memory _message) internal {
    // Process incoming message (your business logic here)
    processMessage(_message);

    // Send response back to source chain (nested _lzSend call)
    bytes memory response = abi.encode(PUSH, generateResponse(_message));
    _lzSend(origin.srcEid, response, options, MessagingFee(0, 0), payable(address(this)));
}

function _lzReceiveOnly(bytes memory payload) internal {
    // Standard message processing without return message (your business logic here)
    processMessage(payload);
}