ERC-7786 based crosschain bridge for ERC-721 tokens

contracts/crosschain/bridges/BridgeERC721.sol

@@ -0,0 +1,81 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.26;
+
+import {IERC721} from "../../interfaces/IERC721.sol";
+import {IERC721Receiver} from "../../interfaces/IERC721Receiver.sol";
+import {IERC721Errors} from "../../interfaces/draft-IERC6093.sol";
+import {BridgeERC721Core} from "./BridgeERC721Core.sol";
+
+/**
+ * @dev This is a variant of {BridgeERC721Core} that implements the bridge logic for ERC-721 tokens that do not expose
+ * a crosschain mint and burn mechanism. Instead, it takes custody of bridged assets.
+ */
+// slither-disable-next-line locked-ether
+abstract contract BridgeERC721 is IERC721Receiver, BridgeERC721Core {
+    IERC721 private immutable _token;
+
+    error BridgeERC721Unauthorized(address caller);
+
+    constructor(IERC721 token_) {
+        _token = token_;
+    }
+
+    /// @dev Return the address of the ERC721 token this bridge operates on.
+    function token() public view virtual returns (IERC721) {
+        return _token;
+    }
+
+    /**
+     * @dev Transfer `amount` tokens to a crosschain receiver.
+     *
+     * Note: The `to` parameter is the full InteroperableAddress (chain ref + address).
+     */
+    function crosschainTransferFrom(address from, bytes memory to, uint256 tokenId) public virtual returns (bytes32) {
+        // Permission is handled using the ERC721's allowance system. This check replicates `ERC721._isAuthorized`.
+        address spender = _msgSender();
+        require(
+            from == spender || token().isApprovedForAll(from, spender) || token().getApproved(tokenId) == spender,
+            IERC721Errors.ERC721InsufficientApproval(spender, tokenId)
+        );
+
+        // This call verifies that `from` is the owner of `tokenId`
+        // Note: do not use safeTransferFrom here! Using it would trigger the `onERC721Received` which we don't want.
+        token().transferFrom(from, address(this), tokenId);
+
+        // Perform the crosschain transfer and return the handler
+        return _crosschainTransfer(from, to, tokenId);
+    }
+
+    /**
+     * @dev Transfer a token received using an ERC-721 safeTransferFrom
+     *
+     * Note: The `data` must contain the `to` as a full InteroperableAddress (chain ref + address).
+     */
+    function onERC721Received(
+        address /*operator*/,
+        address from,
+        uint256 tokenId,
+        bytes calldata data // this is the to
+    ) public virtual override returns (bytes4) {
+        // TODO: should this consider _msgSender() ?
+        require(msg.sender == address(_token), BridgeERC721Unauthorized(msg.sender));
+        _crosschainTransfer(from, data, tokenId);
+        return IERC721Receiver.onERC721Received.selector;
+    }
+
+    /// @dev "Locking" tokens is done by taking custody
+    function _onSend(address from, uint256 tokenId) internal virtual override {
+        // Do nothing, token movement is handled by `crosschainTransfer` and `onERC721Received`
+    }
+
+    /**
+     * @dev "Unlocking" tokens is done by releasing custody
+     *
+     * NOTE: `safeTransferFrom` will revert if the receiver is a contract that doesn't implement {IERC721Receiver}
+     * This can be retried by at the ERC-7786 gateway level.
+     */
+    function _onReceive(address to, uint256 tokenId) internal virtual override {
+        token().safeTransferFrom(address(this), to, tokenId);
+    }
+}

contracts/crosschain/bridges/BridgeERC721Core.sol

@@ -0,0 +1,69 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.26;
+
+import {InteroperableAddress} from "../../utils/draft-InteroperableAddress.sol";
+import {Context} from "../../utils/Context.sol";
+import {ERC7786Recipient} from "../ERC7786Recipient.sol";
+import {CrosschainLinked} from "../CrosschainLinked.sol";
+
+/**
+ * @dev Base contract for bridging ERC-721 between chains using an ERC-7786 gateway.
+ *
+ * In order to use this contract, two functions must be implemented to link it to the token:
+ * * {_onSend}: called when a crosschain transfer is going out. Must take the sender tokens or revert.
+ * * {_onReceive}: called when a crosschain transfer is coming in. Must give tokens to the receiver.
+ *
+ * This base contract is used by the {BridgeERC721}, which interfaces with legacy ERC-721 tokens. It is also used by
+ * the {ERC721Crosschain} extension, which embeds the bridge logic directly in the token contract.
+ */
+abstract contract BridgeERC721Core is Context, CrosschainLinked {
+    using InteroperableAddress for bytes;
+
+    event CrosschainERC721TransferSent(bytes32 indexed sendId, address indexed from, bytes to, uint256 tokenId);
+    event CrosschainERC721TransferReceived(bytes32 indexed receiveId, bytes from, address indexed to, uint256 tokenId);
+
+    /**
+     * @dev Internal crosschain transfer function.
+     *
+     * Note: The `to` parameter is the full InteroperableAddress (chain ref + address).
+     */
+    function _crosschainTransfer(address from, bytes memory to, uint256 tokenId) internal virtual returns (bytes32) {
+        _onSend(from, tokenId);
+
+        (bytes2 chainType, bytes memory chainReference, bytes memory addr) = to.parseV1();
+        bytes memory chain = InteroperableAddress.formatV1(chainType, chainReference, hex"");
+
+        bytes32 sendId = _sendMessageToCounterpart(
+            chain,
+            abi.encode(InteroperableAddress.formatEvmV1(block.chainid, from), addr, tokenId),
+            new bytes[](0)
+        );
+
+        emit CrosschainERC721TransferSent(sendId, from, to, tokenId);
+
+        return sendId;
+    }
+
+    /// @inheritdoc ERC7786Recipient
+    function _processMessage(
+        address /*gateway*/,
+        bytes32 receiveId,
+        bytes calldata /*sender*/,
+        bytes calldata payload
+    ) internal virtual override {
+        // split payload
+        (bytes memory from, bytes memory toBinary, uint256 tokenId) = abi.decode(payload, (bytes, bytes, uint256));
+        address to = address(bytes20(toBinary));
+
+        _onReceive(to, tokenId);
+
+        emit CrosschainERC721TransferReceived(receiveId, from, to, tokenId);
+    }
+
+    /// @dev Virtual function: implementation is required to handle token being burnt or locked on the source chain.
+    function _onSend(address from, uint256 tokenId) internal virtual;
+
+    /// @dev Virtual function: implementation is required to handle token being minted or unlocked on the destination chain.
+    function _onReceive(address to, uint256 tokenId) internal virtual;
+}

contracts/token/ERC721/extensions/ERC721Crosschain.sol

@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.26;
+
+import {ERC721} from "../ERC721.sol";
+import {BridgeERC721Core} from "../../../crosschain/bridges/BridgeERC721Core.sol";
+
+/**
+ * @dev Extension of {ERC721} that makes it natively cross-chain using the ERC-7786 based {BridgeERC721Core}.
+ *
+ * This extension makes the token compatible with:
+ * * {ERC721Crosschain} instances on other chains,
+ * * {ERC721} instances on other chains that are bridged using {BridgeERC721},
+ */
+// slither-disable-next-line locked-ether
+abstract contract ERC721Crosschain is ERC721, BridgeERC721Core {
+    /// @dev TransferFrom variant of {crosschainTransferFrom}, using ERC721 allowance from the sender to the caller.
+    function crosschainTransferFrom(address from, bytes memory to, uint256 tokenId) public virtual returns (bytes32) {
+        // operator (_msgSender) permission over `from` is checked in `_onSend`
+        return _crosschainTransfer(from, to, tokenId);
+    }
+
+    /// @dev "Locking" tokens is achieved through burning
+    function _onSend(address from, uint256 tokenId) internal virtual override {
+        address previousOwner = _update(address(0), tokenId, _msgSender());
+        if (previousOwner == address(0)) {
+            revert ERC721NonexistentToken(tokenId);
+        } else if (previousOwner != from) {
+            revert ERC721IncorrectOwner(from, tokenId, previousOwner);
+        }
+    }
+
+    /// @dev "Unlocking" tokens is achieved through minting
+    function _onReceive(address to, uint256 tokenId) internal virtual override {
+        _mint(to, tokenId);
+    }
+}