Aavegotchi bridge (Polygon <> Gotchichain)

contracts/Aavegotchi/facets/AavegotchiFacet.sol

@@ -4,7 +4,7 @@ pragma solidity 0.8.1;
 import {LibAavegotchi, AavegotchiInfo} from "../libraries/LibAavegotchi.sol";
 
 import {LibStrings} from "../../shared/libraries/LibStrings.sol";
-import {AppStorage, Modifiers} from "../libraries/LibAppStorage.sol";
+import {AppStorage, Modifiers, Aavegotchi} from "../libraries/LibAppStorage.sol";
 import {LibGotchiLending} from "../libraries/LibGotchiLending.sol";
 // import "hardhat/console.sol";
 import {LibMeta} from "../../shared/libraries/LibMeta.sol";
@@ -40,6 +40,13 @@ contract AavegotchiFacet is Modifiers {
         aavegotchiInfo_ = LibAavegotchi.getAavegotchi(_tokenId);
     }
 
+    ///@notice Query details relating to an NFT
+    ///@param _tokenId the identifier of the NFT to query
+    ///@return aavegotchi_ an Aavegotchi struct containing details about the aavegotchi
+    function getAavegotchiData(uint256 _tokenId) external view returns (Aavegotchi memory aavegotchi_) {
+        aavegotchi_ = s.aavegotchis[_tokenId];
+    }
+
     ///@notice returns the time an NFT was claimed
     ///@dev will return 0 if the NFT is still an unclaimed portal
     ///@param _tokenId the identifier of the NFT

contracts/Aavegotchi/facets/DAOFacet.sol

@@ -31,6 +31,8 @@ contract DAOFacet is Modifiers {
     event ItemModifiersSet(uint256 _wearableId, int8[6] _traitModifiers, uint8 _rarityScoreModifier);
     event RemoveExperience(uint256[] _tokenIds, uint256[] _xpValues);
     event UpdateItemPrice(uint256 _itemId, uint256 _priceInWei);
+    event LayerZeroBridgeAdded(address _newLayerZeroBridge);
+    event LayerZeroBridgeRemoved(address _layerZeroBridgeToRemove);
 
     /***********************************|
    |             Read Functions         |
@@ -417,4 +419,18 @@ contract DAOFacet is Modifiers {
             emit UpdateItemPrice(itemId, _newPrices[i]);
         }
     }
+
+    ///@notice Allow the DAO to add an address as a Layer Zero bridge
+    ///@param _newLayerZeroBridge The address to be added as Layer Zero bridge
+    function addLayerZeroBridgeAddress(address _newLayerZeroBridge) external onlyDaoOrOwner {
+        s.layerZeroBridgeAddresses[_newLayerZeroBridge] = true;
+        emit LayerZeroBridgeAdded(_newLayerZeroBridge);
+    }
+
+    ///@notice Allow the DAO to remove an address that was an Layer Zero bridge
+    ///@param _layerZeroBridgeToRemove The address to be removed fron being a Layer Zero bridge
+    function removeLayerZeroBridgeAddress(address _layerZeroBridgeToRemove) external onlyDaoOrOwner {
+        s.layerZeroBridgeAddresses[_layerZeroBridgeToRemove] = false;
+        emit LayerZeroBridgeRemoved(_layerZeroBridgeToRemove);
+    }
 }

contracts/Aavegotchi/facets/PolygonXGotchichainBridgeFacet.sol

@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.1;
+
+import {Aavegotchi} from "../libraries/LibAppStorage.sol";
+import {Modifiers} from "../libraries/LibAppStorage.sol";
+import {LibItems} from "../libraries/LibItems.sol";
+
+contract PolygonXGotchichainBridgeFacet is Modifiers {
+
+    function setAavegotchiMetadata(uint _id, Aavegotchi memory _aavegotchi) external onlyLayerZeroBridge {
+        s.aavegotchis[_id] = _aavegotchi;
+        for (uint i; i < _aavegotchi.equippedWearables.length; i++) {
+            if (_aavegotchi.equippedWearables[i] != 0) {
+                uint wearableId = _aavegotchi.equippedWearables[i];
+                LibItems.addToParent(address(this), _id, wearableId, 1);
+            }
+        }
+    }
+
+    function mintWithId(address _toAddress, uint _tokenId) external onlyLayerZeroBridge() {
+        s.aavegotchis[_tokenId].owner = _toAddress;
+        s.tokenIds.push(uint32(_tokenId));
+        s.ownerTokenIdIndexes[_toAddress][_tokenId] = s.ownerTokenIds[_toAddress].length;
+        s.ownerTokenIds[_toAddress].push(uint32(_tokenId));
+    }
+
+    function removeItemsFromOwner(address _owner, uint256[] calldata _tokenIds, uint256[] calldata _tokenAmounts) external onlyLayerZeroBridge() {
+        for (uint256 i; i < _tokenIds.length; i++) {
+            uint256 tokenId = _tokenIds[i];
+            uint256 tokenAmount = _tokenAmounts[i];
+            LibItems.removeFromOwner(_owner, tokenId, tokenAmount);
+        }
+    }
+
+
+    function addItemsToOwner(address _owner, uint256[] calldata _tokenIds, uint256[] calldata _tokenAmounts) external onlyLayerZeroBridge() {
+        for (uint256 i; i < _tokenIds.length; i++) {
+            uint256 tokenId = _tokenIds[i];
+            uint256 tokenAmount = _tokenAmounts[i];
+            LibItems.addToOwner(_owner, tokenId, tokenAmount);
+        }
+    }
+
+}

contracts/Aavegotchi/facets/ShopFacet.sol

@@ -3,7 +3,6 @@ pragma solidity 0.8.1;
 
 import {Modifiers, AppStorage, ItemType, Haunt} from "../libraries/LibAppStorage.sol";
 import {LibAavegotchi} from "../libraries/LibAavegotchi.sol";
-// import "hardhat/console.sol";
 import {IERC20} from "../../shared/interfaces/IERC20.sol";
 import {LibERC721} from "../../shared/libraries/LibERC721.sol";
 import {LibERC1155} from "../../shared/libraries/LibERC1155.sol";

contracts/Aavegotchi/libraries/LibAppStorage.sol

@@ -339,6 +339,7 @@ struct AppStorage {
     mapping(address => mapping(uint256 => uint256[])) erc721TokenToBuyOrderIds; // erc721 token address => erc721TokenId => buyOrderIds
     mapping(address => mapping(uint256 => mapping(uint256 => uint256))) erc721TokenToBuyOrderIdIndexes; // erc721 token address => erc721TokenId => buyOrderId => index
     mapping(address => mapping(uint256 => mapping(address => uint256))) buyerToBuyOrderId; // erc721 token address => erc721TokenId => sender => buyOrderId
+    mapping(address => bool) layerZeroBridgeAddresses;
 }
 
 library LibAppStorage {
@@ -405,6 +406,15 @@ contract Modifiers {
         _;
     }
 
+    modifier onlyLayerZeroBridge() {
+        address sender = LibMeta.msgSender();
+        require(
+            s.layerZeroBridgeAddresses[sender], 
+            "LibAppStorage: Do not have access"
+        );
+        _;
+    }
+
     modifier onlyPeriphery() {
         address sender = LibMeta.msgSender();
         require(sender == s.wearableDiamond, "LibAppStorage: Not wearable diamond");

contracts/PolygonXGotchichainBridge/BridgeGotchichainSide.sol

@@ -0,0 +1,93 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.1;
+
+import {Aavegotchi} from "../Aavegotchi/libraries/LibAppStorage.sol";
+import "./ProxyONFT721.sol";
+import "../Aavegotchi/facets/AavegotchiFacet.sol";
+import "../Aavegotchi/facets/PolygonXGotchichainBridgeFacet.sol";
+
+contract BridgeGotchichainSide is ProxyONFT721 {
+
+    constructor(
+        uint256 _minGasToTransfer,
+        address _lzEndpoint,
+        address _proxyToken
+    ) ProxyONFT721(_minGasToTransfer, _lzEndpoint, _proxyToken) {} 
+
+    function estimateSendBatchFee(uint16 _dstChainId, bytes memory _toAddress, uint[] memory _tokenIds, bool _useZro, bytes memory _adapterParams) public view override returns (uint nativeFee, uint zroFee) {
+        Aavegotchi[] memory aavegotchis = new Aavegotchi[](_tokenIds.length);
+        for (uint i = 0; i < _tokenIds.length; i++) {
+            aavegotchis[i] = AavegotchiFacet(address(token)).getAavegotchiData(_tokenIds[i]);
+        }
+        bytes memory payload = abi.encode(_toAddress, _tokenIds, aavegotchis);
+        return lzEndpoint.estimateFees(_dstChainId, address(this), payload, _useZro, _adapterParams);
+    }
+
+    function _send(address _from, uint16 _dstChainId, bytes memory _toAddress, uint[] memory _tokenIds, address payable _refundAddress, address _zroPaymentAddress, bytes memory _adapterParams) internal override {
+        // allow 1 by default
+        require(_tokenIds.length > 0, "LzApp: tokenIds[] is empty");
+        require(_tokenIds.length == 1 || _tokenIds.length <= dstChainIdToBatchLimit[_dstChainId], "ONFT721: batch size exceeds dst batch limit");
+
+        Aavegotchi[] memory aavegotchis = new Aavegotchi[](_tokenIds.length);
+        for (uint i = 0; i < _tokenIds.length; i++) {
+            _debitFrom(_from, _dstChainId, _toAddress, _tokenIds[i]);
+            aavegotchis[i] = AavegotchiFacet(address(token)).getAavegotchiData(_tokenIds[i]);
+        }
+
+        bytes memory payload = abi.encode(_toAddress, _tokenIds, aavegotchis);
+
+        _checkGasLimit(_dstChainId, FUNCTION_TYPE_SEND, _adapterParams, dstChainIdToTransferGas[_dstChainId] * _tokenIds.length);
+        _lzSend(_dstChainId, payload, _refundAddress, _zroPaymentAddress, _adapterParams, msg.value);
+        emit SendToChain(_dstChainId, _from, _toAddress, _tokenIds);
+    }
+
+    function _nonblockingLzReceive(
+        uint16 _srcChainId,
+        bytes memory _srcAddress,
+        uint64 /*_nonce*/,
+        bytes memory _payload
+    ) internal virtual override {
+        // decode and load the toAddress
+        (bytes memory toAddressBytes, uint[] memory tokenIds, Aavegotchi[] memory aavegotchis) = abi.decode(_payload, (bytes, uint[], Aavegotchi[]));
+        address toAddress;
+        assembly {
+            toAddress := mload(add(toAddressBytes, 20))
+        }
+        uint nextIndex = _creditTill(_srcChainId, toAddress, 0, tokenIds);
+        if (nextIndex < tokenIds.length) {
+            // not enough gas to complete transfers, store to be cleared in another tx
+            bytes32 hashedPayload = keccak256(_payload);
+            storedCredits[hashedPayload] = StoredCredit(_srcChainId, toAddress, nextIndex, true);
+            emit CreditStored(hashedPayload, _payload);
+        }
+
+        _updateAavegotchiMetadata(toAddress, tokenIds, aavegotchis);
+
+        emit ReceiveFromChain(_srcChainId, _srcAddress, toAddress, tokenIds);
+    }
+
+    function _creditTo(uint16, address _toAddress, uint _tokenId) internal override {
+        try token.ownerOf(_tokenId) {
+            token.safeTransferFrom(address(this), _toAddress, _tokenId);
+        } catch Error(string memory reason) {
+            if (_compare(reason, "AavegotchiFacet: invalid _tokenId")) {
+                PolygonXGotchichainBridgeFacet(address(token)).mintWithId(_toAddress, _tokenId);
+            }
+            // @todo: what to do?
+        }
+    }
+
+    function _updateAavegotchiMetadata(address newOwner, uint[] memory tokenIds, Aavegotchi[] memory aavegotchis) internal {
+        for (uint i = 0; i < tokenIds.length; i++) {
+            aavegotchis[i].owner = newOwner;
+            PolygonXGotchichainBridgeFacet(address(token)).setAavegotchiMetadata(tokenIds[i], aavegotchis[i]);
+        }
+    }
+
+    function _compare(string memory str1, string memory str2) internal pure returns (bool) {
+        if (bytes(str1).length != bytes(str2).length) {
+            return false;
+        }
+        return keccak256(abi.encodePacked(str1)) == keccak256(abi.encodePacked(str2));
+    }
+}

contracts/PolygonXGotchichainBridge/BridgePolygonSide.sol

@@ -0,0 +1,79 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.1;
+
+import {Aavegotchi} from "../Aavegotchi/libraries/LibAppStorage.sol";
+import "./ProxyONFT721.sol";
+import "../Aavegotchi/facets/AavegotchiFacet.sol";
+import "../Aavegotchi/facets/PolygonXGotchichainBridgeFacet.sol";
+
+contract BridgePolygonSide is ProxyONFT721 {
+    constructor(
+        uint256 _minGasToTransfer,
+        address _lzEndpoint,
+        address _proxyToken
+    ) ProxyONFT721(_minGasToTransfer, _lzEndpoint, _proxyToken) {} 
+
+    function estimateSendBatchFee(uint16 _dstChainId, bytes memory _toAddress, uint[] memory _tokenIds, bool _useZro, bytes memory _adapterParams) public view override returns (uint nativeFee, uint zroFee) {
+        Aavegotchi[] memory aavegotchis = new Aavegotchi[](_tokenIds.length);
+        for (uint i = 0; i < _tokenIds.length; i++) {
+            aavegotchis[i] = AavegotchiFacet(address(token)).getAavegotchiData(_tokenIds[i]);
+        }
+        bytes memory payload = abi.encode(_toAddress, _tokenIds, aavegotchis);
+        return lzEndpoint.estimateFees(_dstChainId, address(this), payload, _useZro, _adapterParams);
+    }
+
+    function _send(address _from, uint16 _dstChainId, bytes memory _toAddress, uint[] memory _tokenIds, address payable _refundAddress, address _zroPaymentAddress, bytes memory _adapterParams) internal override {
+        // allow 1 by default
+        require(_tokenIds.length > 0, "LzApp: tokenIds[] is empty");
+        require(_tokenIds.length == 1 || _tokenIds.length <= dstChainIdToBatchLimit[_dstChainId], "ONFT721: batch size exceeds dst batch limit");
+
+        Aavegotchi[] memory aavegotchis = new Aavegotchi[](_tokenIds.length);
+        for (uint i = 0; i < _tokenIds.length; i++) {
+            _debitFrom(_from, _dstChainId, _toAddress, _tokenIds[i]);
+            aavegotchis[i] = AavegotchiFacet(address(token)).getAavegotchiData(_tokenIds[i]);
+        }
+
+        bytes memory payload = abi.encode(_toAddress, _tokenIds, aavegotchis);
+
+        _checkGasLimit(_dstChainId, FUNCTION_TYPE_SEND, _adapterParams, dstChainIdToTransferGas[_dstChainId] * _tokenIds.length);
+        _lzSend(_dstChainId, payload, _refundAddress, _zroPaymentAddress, _adapterParams, msg.value);
+        emit SendToChain(_dstChainId, _from, _toAddress, _tokenIds);
+    }
+
+    function _nonblockingLzReceive(
+        uint16 _srcChainId,
+        bytes memory _srcAddress,
+        uint64 /*_nonce*/,
+        bytes memory _payload
+    ) internal virtual override {
+        // decode and load the toAddress
+        (bytes memory toAddressBytes, uint[] memory tokenIds, Aavegotchi[] memory aavegotchis) = abi.decode(_payload, (bytes, uint[], Aavegotchi[]));
+        address toAddress;
+        assembly {
+            toAddress := mload(add(toAddressBytes, 20))
+        }
+        uint nextIndex = _creditTill(_srcChainId, toAddress, 0, tokenIds);
+        if (nextIndex < tokenIds.length) {
+            // not enough gas to complete transfers, store to be cleared in another tx
+            bytes32 hashedPayload = keccak256(_payload);
+            storedCredits[hashedPayload] = StoredCredit(_srcChainId, toAddress, nextIndex, true);
+            emit CreditStored(hashedPayload, _payload);
+        }
+
+        _updateAavegotchiMetadata(toAddress, tokenIds, aavegotchis);
+
+        emit ReceiveFromChain(_srcChainId, _srcAddress, toAddress, tokenIds);
+    }
+
+    function _creditTo(uint16, address _toAddress, uint _tokenId) internal override {
+        token.safeTransferFrom(address(this), _toAddress, _tokenId);
+    }
+
+    function _updateAavegotchiMetadata(address newOwner, uint[] memory tokenIds, Aavegotchi[] memory aavegotchis) internal {
+        for (uint i = 0; i < tokenIds.length; i++) {
+            aavegotchis[i].owner = newOwner;
+            PolygonXGotchichainBridgeFacet(address(token)).setAavegotchiMetadata(tokenIds[i], aavegotchis[i]);
+        }
+    }
+
+}

contracts/PolygonXGotchichainBridge/ItemsBridgeGotchichainSide.sol

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.1;
+
+import {Aavegotchi} from "../Aavegotchi/libraries/LibAppStorage.sol";
+import "./ProxyONFT1155.sol";
+import "../Aavegotchi/facets/AavegotchiFacet.sol";
+import "../Aavegotchi/facets/PolygonXGotchichainBridgeFacet.sol";
+
+contract ItemsBridgeGotchichainSide is ProxyONFT1155 {
+    constructor(address _lzEndpoint, address _proxyToken) ProxyONFT1155(_lzEndpoint, _proxyToken) {}
+
+    function estimateSendBatchFee(
+        uint16 _dstChainId,
+        bytes memory _toAddress,
+        uint[] memory _tokenIds,
+        uint[] memory _amounts,
+        bool _useZro,
+        bytes memory _adapterParams
+    ) public view override returns (uint nativeFee, uint zroFee) {
+        bytes memory payload = abi.encode(_toAddress, _tokenIds, _amounts);
+        return lzEndpoint.estimateFees(_dstChainId, address(this), payload, _useZro, _adapterParams);
+    }
+
+    function _debitFrom(address _from, uint16, bytes memory, uint[] memory _tokenIds, uint[] memory _amounts) internal override {
+        require(_from == _msgSender(), "ItemsBridgePolygonSide: owner is not send caller");
+        PolygonXGotchichainBridgeFacet(address(token)).removeItemsFromOwner(_from, _tokenIds, _amounts);
+    }
+
+    function _creditTo(uint16, address _toAddress, uint[] memory _tokenIds, uint[] memory _amounts) internal override {
+        PolygonXGotchichainBridgeFacet(address(token)).addItemsToOwner(_toAddress, _tokenIds, _amounts);
+    }
+
+    function _updateAavegotchiMetadata(address newOwner, uint[] memory tokenIds, Aavegotchi[] memory aavegotchis) internal {
+        for (uint i = 0; i < tokenIds.length; i++) {
+            aavegotchis[i].owner = newOwner;
+            PolygonXGotchichainBridgeFacet(address(token)).setAavegotchiMetadata(tokenIds[i], aavegotchis[i]);
+        }
+    }
+}

contracts/PolygonXGotchichainBridge/ItemsBridgePolygonSide.sol

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.1;
+
+import {Aavegotchi} from "../Aavegotchi/libraries/LibAppStorage.sol";
+import "./ProxyONFT1155.sol";
+import "../Aavegotchi/facets/AavegotchiFacet.sol";
+import "../Aavegotchi/facets/PolygonXGotchichainBridgeFacet.sol";
+
+contract ItemsBridgePolygonSide is ProxyONFT1155 {
+    constructor(address _lzEndpoint, address _proxyToken) ProxyONFT1155(_lzEndpoint, _proxyToken) {}
+
+    function estimateSendBatchFee(
+        uint16 _dstChainId,
+        bytes memory _toAddress,
+        uint[] memory _tokenIds,
+        uint[] memory _amounts,
+        bool _useZro,
+        bytes memory _adapterParams
+    ) public view override returns (uint nativeFee, uint zroFee) {
+        bytes memory payload = abi.encode(_toAddress, _tokenIds, _amounts);
+        return lzEndpoint.estimateFees(_dstChainId, address(this), payload, _useZro, _adapterParams);
+    }
+
+    function _debitFrom(address _from, uint16, bytes memory, uint[] memory _tokenIds, uint[] memory _amounts) internal override {
+        require(_from == _msgSender(), "ItemsBridgePolygonSide: owner is not send caller");
+        PolygonXGotchichainBridgeFacet(address(token)).removeItemsFromOwner(_from, _tokenIds, _amounts);
+    }
+
+    function _creditTo(uint16, address _toAddress, uint[] memory _tokenIds, uint[] memory _amounts) internal override {
+        PolygonXGotchichainBridgeFacet(address(token)).addItemsToOwner(_toAddress, _tokenIds, _amounts);
+    }
+
+    function _updateAavegotchiMetadata(address newOwner, uint[] memory tokenIds, Aavegotchi[] memory aavegotchis) internal {
+        for (uint i = 0; i < tokenIds.length; i++) {
+            aavegotchis[i].owner = newOwner;
+            PolygonXGotchichainBridgeFacet(address(token)).setAavegotchiMetadata(tokenIds[i], aavegotchis[i]);
+        }
+    }
+}