Otherdeed Flashclaim

contracts/interfaces/IPoolPositionMover.sol

@@ -8,4 +8,11 @@ pragma solidity 0.8.10;
  **/
 interface IPoolPositionMover {
     function movePositionFromBendDAO(uint256[] calldata loanIds) external;
+
+    function claimOtherExpandedAndSupply(
+        uint256[] calldata otherdeedIds,
+        uint256[] calldata kodaIds,
+        uint256[] calldata kodaOtherdeedIds,
+        bytes32[][] calldata merkleProofs
+    ) external;
 }

contracts/interfaces/IVesselClaim.sol

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.10;
+
+interface IVesselClaim {
+    function claimVesselsAndKodas(
+        uint256[] calldata otherdeedIds,
+        uint256[] calldata kodaIds,
+        uint256[] calldata kodaOtherdeedIds,
+        bytes32[][] calldata merkleProofs
+    ) external;
+
+    function claimVessels(uint256[] calldata otherdeedIds) external;
+}

contracts/mocks/MockVessel.sol

@@ -0,0 +1,48 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.10;
+
+import {MintableERC721} from "./tokens/MintableERC721.sol";
+
+contract MockVessel is MintableERC721 {
+
+    MintableERC721 immutable KODA;
+    MintableERC721 immutable OTHRE;
+    MintableERC721 immutable OTHR;
+
+    constructor(MintableERC721 otherdeed, MintableERC721 kodaAddress, MintableERC721 otherdeedExpAddress) MintableERC721("VESSEL", "VSL", "") {
+        OTHR = otherdeed;
+        KODA = kodaAddress;
+        OTHRE = otherdeedExpAddress;
+    }
+
+    function claimVesselsAndKodas(
+        uint256[] calldata otherdeedIds,
+        uint256[] calldata kodaIds,
+        uint256[] calldata kodaOtherdeedIds,
+        bytes32[][] calldata merkleProofs
+    )
+    external {
+
+        for (uint256 index = 0; index < otherdeedIds.length; index++) {
+            mintTokenId(msg.sender, otherdeedIds[index]);
+            OTHRE.mintTokenId(msg.sender, otherdeedIds[index]);
+
+            OTHR.transferFrom(msg.sender, 0x000000000000000000000000000000000000dEaD, otherdeedIds[index]);
+        }
+
+        for (uint256 index = 0; index < kodaIds.length; index++) {
+            KODA.mintTokenId(msg.sender, kodaIds[index]);
+        }
+    }
+
+
+    function claimVessels(uint256[] calldata otherdeedIds)
+    external {
+        for (uint256 index = 0; index < otherdeedIds.length; index++) {
+            mintTokenId(msg.sender, otherdeedIds[index]);
+            OTHRE.mintTokenId(msg.sender, otherdeedIds[index]);
+
+            OTHR.transferFrom(msg.sender, 0x000000000000000000000000000000000000dEaD, otherdeedIds[index]);
+        }
+    }
+}

contracts/mocks/tokens/Land.sol

@@ -1182,7 +1182,7 @@ contract Land is ERC721Enumerable, Ownable {
         MAX_FUTURE_LANDS = amount.future;
 
         betaNftIdCurrent = amount.alpha; //beta starts after alpha
-        mintIndexPublicSaleAndContributors = amount.alpha + amount.beta; //public sale starts after beta
+        mintIndexPublicSaleAndContributors = 0; //public sale starts after beta
 
         RESERVED_CONTRIBUTORS_AMOUNT = 10000;
 
@@ -1214,7 +1214,8 @@ contract Land is ERC721Enumerable, Ownable {
             totalSupply() + 1 <= collectionSize,
             "exceed collectionSize"
         );
-        _safeMint(_to, mintIndexPublicSaleAndContributors++);
+        _safeMint(_to, mintIndexPublicSaleAndContributors);
+        mintIndexPublicSaleAndContributors++;
     }
 
     function mint(uint256 count, address to) public virtual {
@@ -1223,8 +1224,9 @@ contract Land is ERC721Enumerable, Ownable {
             "exceed collectionSize"
         );
         for (uint256 i = 0; i < count; i++) {
-            mintIndexPublicSaleAndContributors++;
+
             _safeMint(to, mintIndexPublicSaleAndContributors);
+            mintIndexPublicSaleAndContributors++;
         }
     }
 

contracts/mocks/tokens/MintableERC721.sol

@@ -88,6 +88,12 @@ contract MintableERC721 is Context, ERC721Enumerable {
         }
     }
 
+    function mintTokenId(address to, uint256 _tokenId) public virtual {
+        // We cannot just use balanceOf to create the new tokenId because tokens
+        // can be burned (destroyed), so we need a separate counter.
+        _mint(to, _tokenId);
+    }
+
     function setBaseURI(string memory baseTokenURI) external {
         _baseTokenURI = baseTokenURI;
     }

contracts/protocol/libraries/logic/PositionMoverLogic.sol

@@ -2,16 +2,20 @@
 pragma solidity 0.8.10;
 
 import {INToken} from "../../../interfaces/INToken.sol";
+import {IVesselClaim} from "../../../interfaces/IVesselClaim.sol";
 import {IPoolAddressesProvider} from "../../../interfaces/IPoolAddressesProvider.sol";
 import {DataTypes} from "../types/DataTypes.sol";
 import {IPToken} from "../../../interfaces/IPToken.sol";
 import {IERC20} from "../../../dependencies/openzeppelin/contracts/IERC20.sol";
+import {IERC721} from "../../../dependencies/openzeppelin/contracts/IERC721.sol";
+
 import {Errors} from "../helpers/Errors.sol";
 import {ValidationLogic} from "./ValidationLogic.sol";
 import {SupplyLogic} from "./SupplyLogic.sol";
 import {BorrowLogic} from "./BorrowLogic.sol";
 import {ReserveLogic} from "./ReserveLogic.sol";
 import {ReserveConfiguration} from "../configuration/ReserveConfiguration.sol";
+import {UserConfiguration} from "../configuration/UserConfiguration.sol";
 import {Address} from "../../../dependencies/openzeppelin/contracts/Address.sol";
 import {ILendPoolLoan} from "../../../dependencies/benddao/contracts/interfaces/ILendPoolLoan.sol";
 import {ILendPool} from "../../../dependencies/benddao/contracts/interfaces/ILendPool.sol";
@@ -25,6 +29,7 @@ import {BDaoDataTypes} from "../../../dependencies/benddao/contracts/libraries/t
 library PositionMoverLogic {
     using ReserveConfiguration for DataTypes.ReserveConfigurationMap;
     using ReserveLogic for DataTypes.ReserveData;
+    using UserConfiguration for DataTypes.UserConfigurationMap;
 
     struct PositionMoverVars {
         address weth;
@@ -35,6 +40,10 @@ library PositionMoverLogic {
     }
 
     event PositionMoved(address asset, uint256 tokenId, address user);
+    event ReserveUsedAsCollateralDisabled(
+        address indexed reserve,
+        address indexed user
+    );
 
     function executeMovePositionFromBendDAO(
         DataTypes.PoolStorage storage ps,
@@ -148,4 +157,127 @@ library PositionMoverLogic {
             })
         );
     }
+
+    function executeClaimOtherdeedAndSupply(
+        mapping(address => DataTypes.ReserveData) storage reservesData,
+        mapping(uint256 => address) storage reservesList,
+        DataTypes.UserConfigurationMap storage userConfig,
+        DataTypes.OtherdeedClaimParams memory params
+    ) external returns (uint256) {
+        DataTypes.ReserveData storage reserve = reservesData[params.otherdeed];
+        DataTypes.ReserveCache memory reserveCache = reserve.cache();
+
+        ValidationLogic.validateWithdrawERC721(
+            reservesData,
+            reserveCache,
+            params.otherdeed,
+            params.otherdeedIds
+        );
+
+        DataTypes.TimeLockParams memory timeLockParams;
+
+        (
+            uint64 oldCollateralizedBalance,
+            uint64 newCollateralizedBalance
+        ) = INToken(reserveCache.xTokenAddress).burn(
+                msg.sender,
+                address(this),
+                params.otherdeedIds,
+                timeLockParams
+            );
+
+        bool isWithdrawCollateral = (newCollateralizedBalance <
+            oldCollateralizedBalance);
+
+        if (isWithdrawCollateral) {
+            if (newCollateralizedBalance == 0) {
+                userConfig.setUsingAsCollateral(reserve.id, false);
+                emit ReserveUsedAsCollateralDisabled(
+                    params.otherdeed,
+                    msg.sender
+                );
+            }
+        }
+
+        IERC721(params.otherdeed).setApprovalForAll(params.vessel, true);
+
+        if (params.kodaIds.length == 0) {
+            IVesselClaim(params.vessel).claimVessels(params.otherdeedIds);
+        } else {
+            IVesselClaim(params.vessel).claimVesselsAndKodas(
+                params.otherdeedIds,
+                params.kodaIds,
+                params.kodaOtherdeedIds,
+                params.merkleProofs
+            );
+        }
+
+        IERC721(params.otherdeed).setApprovalForAll(params.vessel, false);
+
+        SupplyLogic.executeSupplyERC721(
+            reservesData,
+            userConfig,
+            DataTypes.ExecuteSupplyERC721Params({
+                asset: params.otherdeedExpanded,
+                tokenData: _getTokenData(params.otherdeedIds),
+                onBehalfOf: msg.sender,
+                payer: address(this),
+                referralCode: 0x0
+            })
+        );
+
+        SupplyLogic.executeSupplyERC721(
+            reservesData,
+            userConfig,
+            DataTypes.ExecuteSupplyERC721Params({
+                asset: params.vessel,
+                tokenData: _getTokenData(params.otherdeedIds),
+                onBehalfOf: msg.sender,
+                payer: address(this),
+                referralCode: 0x0
+            })
+        );
+
+        if (params.kodaIds.length != 0) {
+            SupplyLogic.executeSupplyERC721(
+                reservesData,
+                userConfig,
+                DataTypes.ExecuteSupplyERC721Params({
+                    asset: params.koda,
+                    tokenData: _getTokenData(params.kodaIds),
+                    onBehalfOf: msg.sender,
+                    payer: address(this),
+                    referralCode: 0x0
+                })
+            );
+        }
+
+        if (isWithdrawCollateral) {
+            if (userConfig.isBorrowingAny()) {
+                ValidationLogic.validateHFAndLtvERC721(
+                    reservesData,
+                    reservesList,
+                    userConfig,
+                    params.otherdeed,
+                    params.otherdeedIds,
+                    msg.sender,
+                    params.reservesCount,
+                    params.oracle
+                );
+            }
+        }
+    }
+
+    function _getTokenData(uint256[] memory tokenIds)
+        internal
+        returns (DataTypes.ERC721SupplyParams[] memory tokenData)
+    {
+        tokenData = new DataTypes.ERC721SupplyParams[](tokenIds.length);
+        for (uint256 index = 0; index < tokenIds.length; index++) {
+            tokenData[index] = DataTypes.ERC721SupplyParams({
+                tokenId: tokenIds[index],
+                useAsCollateral: true
+            });
+        }
+    }
 }

contracts/protocol/libraries/types/DataTypes.sol

@@ -193,6 +193,19 @@ library DataTypes {
         address oracle;
     }
 
+    struct OtherdeedClaimParams {
+        address otherdeed;
+        address otherdeedExpanded;
+        address koda;
+        address vessel;
+        uint256[] otherdeedIds;
+        uint256[] kodaIds;
+        uint256[] kodaOtherdeedIds;
+        bytes32[][] merkleProofs;
+        uint256 reservesCount;
+        address oracle;
+    }
+
     struct ExecuteDecreaseUniswapV3LiquidityParams {
         address user;
         address asset;

contracts/protocol/pool/PoolPositionMover.sol

@@ -26,14 +26,28 @@ contract PoolPositionMover is
     ILendPool internal immutable BENDDAO_LEND_POOL;
     uint256 internal constant POOL_REVISION = 149;
 
+    address immutable OTHERDEED;
+    address immutable OTHERDEED_EXPANDED;
+    address immutable KODA;
+    address immutable VESSEL;
+
     constructor(
         IPoolAddressesProvider addressProvider,
         ILendPoolLoan benddaoLendPoolLoan,
-        ILendPool benddaoLendPool
+        ILendPool benddaoLendPool,
+        address otherdeed,
+        address otherdeedExpanded,
+        address koda,
+        address vessel
     ) {
         ADDRESSES_PROVIDER = addressProvider;
         BENDDAO_LEND_POOL_LOAN = benddaoLendPoolLoan;
         BENDDAO_LEND_POOL = benddaoLendPool;
+
+        OTHERDEED = otherdeed;
+        OTHERDEED_EXPANDED = otherdeedExpanded;
+        KODA = koda;
+        VESSEL = vessel;
     }
 
     function movePositionFromBendDAO(uint256[] calldata loanIds)
@@ -51,6 +65,33 @@ contract PoolPositionMover is
         );
     }
 
+    function claimOtherExpandedAndSupply(
+        uint256[] calldata otherdeedIds,
+        uint256[] calldata kodaIds,
+        uint256[] calldata kodaOtherdeedIds,
+        bytes32[][] calldata merkleProofs
+    ) external nonReentrant {
+        DataTypes.PoolStorage storage ps = poolStorage();
+
+        PositionMoverLogic.executeClaimOtherdeedAndSupply(
+            ps._reserves,
+            ps._reservesList,
+            ps._usersConfig[msg.sender],
+            DataTypes.OtherdeedClaimParams({
+                otherdeed: OTHERDEED,
+                otherdeedExpanded: OTHERDEED_EXPANDED,
+                koda: KODA,
+                vessel: VESSEL,
+                otherdeedIds: otherdeedIds,
+                kodaIds: kodaIds,
+                kodaOtherdeedIds: kodaOtherdeedIds,
+                merkleProofs: merkleProofs,
+                reservesCount: ps._reservesCount,
+                oracle: ADDRESSES_PROVIDER.getPriceOracle()
+            })
+        );
+    }
+
     function getRevision() internal pure virtual override returns (uint256) {
         return POOL_REVISION;
     }