LayerZero V2 ONFT Quickstart

function _debit(address _from, uint256 _tokenId, uint32 /*_dstEid*/) internal virtual override {
    if (_from != ERC721.ownerOf(_tokenId)) revert OnlyNFTOwner(_from, ERC721.ownerOf(_tokenId));
    _burn(_tokenId);
}

function _credit(address _to, uint256 _tokenId, uint32 /*_srcEid*/) internal virtual override {
    _mint(_to, _tokenId);
}

function _debit(address _from, uint256 _tokenId, uint32 /*_dstEid*/) internal virtual override {
    // Lock the token by transferring it to this adapter contract
    innerToken.transferFrom(_from, address(this), _tokenId);
}

function _credit(address _toAddress, uint256 _tokenId, uint32 /*_srcEid*/) internal virtual override {
    // Unlock the token by transferring it back to the user
    innerToken.transferFrom(address(this), _toAddress, _tokenId);
}

npx create-lz-oapp@latest

"resolutions": {
    "@openzeppelin/contracts": "^5.0.1",
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.22;

import { ONFT721 } from "@layerzerolabs/onft-evm/contracts/onft721/ONFT721.sol";

contract MyONFT721 is ONFT721 {
    constructor(
        string memory _name,
        string memory _symbol,
        address _lzEndpoint,
        address _delegate
    ) ONFT721(_name, _symbol, _lzEndpoint, _delegate) {}
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.22;

import { ONFT721Adapter } from "@layerzerolabs/onft-evm/contracts/onft721/ONFT721Adapter.sol";

contract MyONFT721Adapter is ONFT721Adapter {
    constructor(
        address _token,
        address _lzEndpoint,
        address _delegate
    ) ONFT721Adapter(_token, _lzEndpoint, _delegate) {}
}

EndpointV2.setSendLibrary(aONFT, bEid, newLib)
EndpointV2.setReceiveLibrary(aONFT, bEid, newLib, gracePeriod)
EndpointV2.setReceiveLibraryTimeout(aONFT, bEid, lib, gracePeriod)
EndpointV2.setConfig(aONFT, sendLibrary, sendConfig)
EndpointV2.setConfig(aONFT, receiveLibrary, receiveConfig)
EndpointV2.setDelegate(delegate)

uint32 aEid = 1;  // Example endpoint id for Chain A
uint32 bEid = 2;  // Example endpoint id for Chain B

MyONFT721 aONFT;  // Contract deployed on Chain A
MyONFT721 bONFT;  // Contract deployed on Chain B

// Call on both sides for each pathway
// On chain A
aONFT.setPeer(bEid, addressToBytes32(address(bONFT)));
// On chain B
bONFT.setPeer(aEid, addressToBytes32(address(aONFT)));

// Recommended gas setting for ONFT transfers
EnforcedOptionParam[] memory aEnforcedOptions = new EnforcedOptionParam[](1);
// Force 65k gas on the remote (chain B) when bridging from chain A
aEnforcedOptions[0] = EnforcedOptionParam({
    eid: bEid,      // Remote chain id (chain B)
    msgType: SEND,
    options: OptionsBuilder.newOptions().addExecutorLzReceiveOption(100_000, 0) // Gas limit, msg.value
});
aONFT.setEnforcedOptions(aEnforcedOptions);

struct SendParam {
    uint32 dstEid; // Destination LayerZero EndpointV2 ID.
    bytes32 to; // Recipient address.
    uint256 tokenId;
    bytes extraOptions; // Additional options supplied by the caller to be used in the LayerZero message.
    bytes composeMsg; // The composed message for the send() operation.
    bytes onftCmd; // The ONFT command to be executed, unused in default ONFT implementations.
}

// @notice Provides a quote for the send() operation.
// @param _sendParam The parameters for the send() operation.
// @param _payInLzToken Flag indicating whether the caller is paying in the LZ token.
// @return msgFee The calculated LayerZero messaging fee from the send() operation.
function quoteSend(
    SendParam calldata _sendParam,
    bool _payInLzToken
) external view virtual returns (MessagingFee memory msgFee) {
    (bytes memory message, bytes memory options) = _buildMsgAndOptions(_sendParam);
    return _quote(_sendParam.dstEid, message, options, _payInLzToken);
}

function send(
    SendParam calldata _sendParam,   // Parameters for the send() operation.
    MessagingFee calldata _fee,      // The calculated LayerZero messaging fee from the send() operation.
    address _refundAddress           // The address to refund if the transaction fails on the source chain.
) external payable virtual returns (MessagingReceipt memory msgReceipt) {
    _debit(msg.sender, _sendParam.tokenId, _sendParam.dstEid);    // Debit the sender's balance.

    (bytes memory message, bytes memory options) = _buildMsgAndOptions(_sendParam);

    // @dev Sends the message to the LayerZero Endpoint, returning the MessagingReceipt.
    msgReceipt = _lzSend(_sendParam.dstEid, message, options, _fee, _refundAddress);
    emit ONFTSent(msgReceipt.guid, _sendParam.dstEid, msg.sender, _sendParam.tokenId);
}

function _lzReceive(
    Origin calldata _origin,
    bytes32 _guid,
    bytes calldata _message,
    address /*_executor*/, // @dev unused in the default implementation.
    bytes calldata /*_extraData*/ // @dev unused in the default implementation.
) internal virtual override {
    address toAddress = _message.sendTo().bytes32ToAddress();
    uint256 tokenId = _message.tokenId();

    // Mint / unlock the NFT to the recipient
    _credit(toAddress, tokenId, _origin.srcEid);

    // If there's a "composeMsg" for extra logic, handle it here...
    if (_message.isComposed()) {
        // ...
    }

    emit ONFTReceived(_guid, _origin.srcEid, toAddress, tokenId);
}

abstract contract ONFT721Enumerable is ONFT721Core, ERC721Enumerable {
    // Implementation details...
}

npx create-lz-oapp@latest

npx hardhat lz:deploy

npx hardhat lz:oapp:wire --oapp-config layerzero.config.ts

npx hardhat lz:oapp:peers:get --oapp-config layerzero.config.ts

npx hardhat lz:oapp:config:get:default  # Outputs the default OApp config
npx hardhat lz:oapp:config:get          # Outputs Custom OApp Config, Default OApp Config, and Active OApp Config. Each config contains Send & Receive Libraries, Send Uln & Executor Configs, and Receive Executor Configs