P3 connector added

contracts/polygon/connectors/fluidity/P1/helper.sol

@@ -1,9 +1,9 @@
 // SPDX-License-Identifier: GPL-3.0
 pragma solidity ^0.8.6;
 
-import { DSMath } from "../../common/math.sol";
-import { Basic } from "../../common/basic.sol";
-import { TokenInterface } from "../../common/interfaces.sol";
+import { DSMath } from "../../../common/math.sol";
+import { Basic } from "../../../common/basic.sol";
+import { TokenInterface } from "../../../common/interfaces.sol";
 import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 import "./interface.sol";
 

contracts/polygon/connectors/fluidity/P1/main.sol

@@ -8,7 +8,7 @@ pragma solidity ^0.8.6;
 
 import { Events } from "./events.sol";
 import { Helpers } from "./helper.sol";
-import { TokenInterface } from "../../common/interfaces.sol";
+import { TokenInterface } from "../../../common/interfaces.sol";
 
 abstract contract FluidityResolver is Events, Helpers {
 	/**

contracts/polygon/connectors/fluidity/P3/events.sol

@@ -0,0 +1,100 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity ^0.8.6;
+
+import { Helpers } from "./helper.sol";
+
+contract Events {
+	event LogSupply(
+		address indexed token,
+		address from,
+		uint256 value,
+		uint256 getId,
+		uint256 setId
+	);
+
+	event LogWithdraw(uint96 indexed NFTID);
+
+	event LogTransferPosition(uint96 indexed NFTID);
+
+	event LogAddLiquidity(
+		uint96 indexed NFTID,
+		uint256 amount0,
+		uint256 amount1,
+		uint256 minAmount0,
+		uint256 minAmount1,
+		uint256 deadline,
+		uint256[] getId,
+		uint256[] setId
+	);
+
+	event LogRemoveLiquidity(
+		uint96 indexed NFTID,
+		uint256 liquidity,
+		uint256 amount0Min,
+		uint256 amount1Min,
+		uint256[] getId,
+		uint256[] setID
+	);
+
+	event LogBorrow(
+		uint96 NFTID,
+		address token,
+		uint256 amount_,
+		uint256 getId,
+		uint256 setId
+	);
+
+	event LogPayback(
+		uint96 NFTID,
+		address token,
+		uint256 amount_,
+		uint256 getId,
+		uint256 setId
+	);
+
+	event LogCollectFees(uint96 NFTID, uint256[] setId);
+
+	event LogDepositNFT(uint96 NFTID);
+
+	event LogWithdrawNFT(uint96 NFTID);
+
+	event LogStake(
+		address rewardToken,
+		uint256 startTime,
+		uint256 endTime,
+		address refundee,
+		uint96 indexed NFTID
+	);
+
+	event LogUnStake(
+		address rewardToken,
+		uint256 startTime,
+		uint256 endTime,
+		address refundee,
+		uint96 indexed NFTID
+	);
+
+	event LogClaimStakingRewards(address rewardToken, uint96 NFTID);
+
+	event LogClaimBorrowingRewards(BorrowingReward[] rewards_, uint96 NFTID);
+
+	event LogClaimBorrowingRewards(
+		uint96 NFTID,
+		address[] rewardTokens_,
+		uint256[] rewardAmounts_
+	);
+
+	event LogLiquidate0(
+		uint256 paybackAmount0,
+		uint256 paybackAmount1,
+		uint256 incentiveAmount0,
+		uint256 incentiveAmount1
+	);
+
+	event LogLiquidate1(
+		uint256 paybackAmount0,
+		uint256 paybackAmount1,
+		uint256 incentiveAmount0,
+		uint256 incentiveAmount1
+	);
+}

contracts/polygon/connectors/fluidity/P3/helper.sol

@@ -0,0 +1,67 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity ^0.8.6;
+
+import { DSMath } from "../../../common/math.sol";
+import { Basic } from "../../../common/basic.sol";
+import {TokenInterface} from "../../../common/interfaces.sol";
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import "./interface.sol";
+
+abstract contract Helpers is DSMath, Basic {
+	using SafeERC20 for IERC20;
+
+	INFT internal constant nftManager =
+		INFT(0xC36442b4a4522E871399CD717aBDD847Ab11FE88);
+
+	IProtocolModule internal constant protocolModule =
+		IProtocolModule(0xf0404BC3673B271B40b554F92879BC15A7100bA0);
+
+	struct BorrowingReward {
+        address token;
+        address[] rewardTokens;
+        uint256[] rewardAmounts;
+    }
+
+	 struct Liquidate0Parameters {
+        uint96 NFTID;
+        uint256 liquidityDecreasePercentage;
+        uint256 paybackAmount0Max;
+        uint256 paybackAmount1Max;
+    }
+
+    struct Liquidate0Variables {
+        uint256 tokenAmount0;
+        uint256 tokenAmount1;
+        uint256 paybackAmount0;
+        uint256 paybackAmount1;
+        uint256 incentiveAmount0;
+        uint256 incentiveAmount1;
+        uint256 paybackAmount0WithIncentive;
+        uint256 paybackAmount1WithIncentive;
+    }
+
+	 struct Liquidate1Parameters {
+        uint96 NFTID;
+        uint256[] amounts;
+    }
+
+    struct Liquidate1Variables {
+        uint256 paybackInUsd;
+        uint256 toPaybackInUsd;
+        uint256 fee0InUsd;
+        uint256 fee1InUsd;
+        uint256 feeInUsd;
+        uint256 collateralWithoutFeeInUsd;
+        uint256 exactAmount0;
+        uint256 exactAmount1;
+        address[] markets;
+        uint256[] paybackAmts;
+    }
+
+	struct BorrowingReward {
+        address token;
+        address[] rewardTokens;
+        uint256[] rewardAmounts;
+    }
+
+}

contracts/polygon/connectors/fluidity/P3/interface.sol

@@ -0,0 +1,114 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity ^0.8.6;
+
+import { Helpers } from "./helper.sol";
+interface INFT {
+	function safeTransferFrom(
+		address token,
+		address from,
+		address to,
+		uint256 value
+	) external;
+}
+
+
+interface IProtocolModule {
+	function withdraw(uint96 NFTID_) external;
+
+	function transferPosition(uint96 NFTID_, address to_) external;
+
+	function addLiquidity(
+		uint96 NFTID_,
+		uint256 amount0_,
+		uint256 amount1_,
+		uint256 minAmount0_,
+		uint256 minAmount1_,
+		uint256 deadline_
+	) external returns (uint256 exactAmount0_, uint256 exactAmount1_);
+
+	function removeLiquidity(
+		uint96 NFTID_,
+		uint256 liquidity_,
+		uint256 amount0Min_,
+		uint256 amount1Min_
+	) external returns (uint256 exactAmount0_, uint256 exactAmount1_);
+
+	function borrow(
+		uint96 NFTID_,
+		address token_,
+		uint256 amount_
+	) external;
+
+	function payback(
+		uint96 NFTID_,
+		address token_,
+		uint256 amount_
+	) external;
+
+	function collectFees(uint96 NFTID_)
+		external
+		returns (uint256 amount0_, uint256 amount1_);
+
+	function depositNFT(uint96 NFTID_)
+        external;
+
+	function withdrawNFT(uint96 NFTID_)
+        external;
+
+	function stake(
+        address rewardToken_,
+        uint256 startTime_,
+        uint256 endTime_,
+        address refundee_,
+        uint96 NFTID_
+    ) external;
+
+	function unstake(
+        address rewardToken_,
+        uint256 startTime_,
+        uint256 endTime_,
+        address refundee_,
+        uint96 NFTID_
+    ) external;
+
+
+	function claimStakingRewards(address rewardToken_, uint96 NFTID_)
+        public
+        returns (uint256 rewards_);
+
+	function claimBorrowingRewards(uint96 NFTID_)
+	public
+	returns (BorrowingReward[] memory);
+
+	function claimBorrowingRewards(uint96 NFTID_, address token_)
+        public
+        
+        returns (
+            address[] memory rewardTokens_,
+            uint256[] memory rewardAmounts_
+        );
+
+	 function liquidate0(Liquidate0Parameters memory liquidate0Parameters_)
+        external
+        returns (
+            uint256,
+            uint256,
+            uint256,
+            uint256
+        );
+
+	function liquidate1(Liquidate1Parameters memory liquidate1Parameters_)
+        external
+        returns (
+            uint256,
+            uint256,
+            address[] memory,
+            uint256[] memory
+        );
+
+	
+
+
+
+	
+}

contracts/polygon/connectors/fluidity/P3/main.sol

@@ -0,0 +1,329 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity ^0.8.6;
+
+/**
+ * @title Fluidity.
+ * @dev
+ */
+
+import { Events } from "./events.sol";
+import { Helpers } from "./helper.sol";
+//import { TokenInterface } from "../../common/interfaces.sol";
+import {TokenInterface} from "../../../common/interfaces.sol";
+
+abstract contract FluidityResolver is Events, Helpers {
+	function supplyNft(
+		address token,
+		address from,
+		uint256 value,
+		uint256 getId,
+		uint256 setId
+	)
+		public
+		returns (
+			//payable
+			string memory _eventName,
+			bytes memory _eventParam
+		)
+	{
+		uint256 value_ = getUint(getId, value);
+		TokenInterface tokenContract = TokenInterface(token_);
+		value_ = value_ == type(uint256).max
+			? tokenContract.balanceOf(address(this))
+			: value_;
+		approve(tokenContract, address(protocolModule), value_);
+
+		nftManager.safeTransferFrom(
+			token,
+			from,
+			address(protocolModule),
+			value_
+		);
+
+		_eventName = "LogSupply(address,address,uint256,uint256,uint256)";
+		_eventParam = abi.encode(token, from, value_, getId, setId);
+	}
+
+	function withdrawNFT(uint96 NFTID)
+		public
+		returns (
+			//payable
+			string memory _eventName,
+			bytes memory _eventParam
+		)
+	{
+		protocolModule.withdraw(NFTID);
+
+		_eventName = "LogWithdraw(uint256)";
+		_eventParam = abi.encode(NFTID);
+	}
+
+	function transferPosition(uint96 NFTID, address to)
+		public
+		returns (string memory _eventName, bytes memory _eventParam)
+	{
+		protocolModule.transferPosition(NFTID, to);
+
+		_eventName = "LogTransferPosition(uint96)";
+		_eventParam = abi.encode(NFTID);
+	}
+
+	function addLiquidity(
+		uint96 NFTID,
+		uint256 amount0,
+		uint256 amount1,
+		uint256 minAmount0,
+		uint256 minAmount1,
+		uint256 deadline,
+		uint256[] memory getId,
+		uint256[] memory setId
+	) public returns (string memory _eventName, bytes memory _eventParam) {
+		amount0_ = getUint(getId[0], amount0);
+		amount1_ = getUint(getId[1], amount1);
+		(uint256 exactAmount0_, uint256 exactAmount1_) = protocolModule
+			.addLiquidity(
+				NFTID,
+				amount0_,
+				amount1_,
+				minAmount0,
+				minAmount1,
+				deadline
+			);
+
+		setUint(setId[0], exactAmount0_);
+		setUint(setId[1], exactAmount1_);
+
+		_eventName = "LogAddLiquidity(uint96,uint256,uint256,uint256,uint256,uint256,uint256[],uint256[])";
+		_eventParam = abi.encode(
+			NFTID,
+			amount0_,
+			amount1_,
+			minAmount0,
+			minAmount1,
+			deadline,
+			getId,
+			setId
+		);
+	}
+
+	// get id
+	function removeLiquidity(
+		uint96 NFTID,
+		uint256 liquidity,
+		uint256 amount0Min,
+		uint256 amount1Min,
+		uint256 getId,
+		uint256[] memory setId
+	) public returns (string memory _eventName, bytes memory _eventParam) {
+		uint256 liquidity_ = getUint(getId, liquidity);
+		(uint256 exactAmount0_, uint256 exactAmount1_) = protocolModule
+			.removeLiquidity(NFTID, liquidity_, amount0Min, amount1Min);
+
+		setUint(setId[0], exactAmount0_);
+		setUint(setId[1], exactAmount1_);
+
+		_eventName = "LogRemoveLiquidity(uint96,uint256,uint256,uint256,uint256[],uint256[])";
+		_eventParam = abi.encode(
+			NFTID,
+			liquidity_,
+			amount0Min,
+			amount1Min,
+			getId,
+			setId
+		);
+	}
+
+	function borrow(
+		uint96 NFTID,
+		address token,
+		uint256 amount,
+		uint256 getId,
+		uint256 setId
+	) public returns (string memory _eventName, bytes memory _eventParam) {
+		uint256 amount_ = getUint(getId, amount);
+		protocolModule.borrow(NFTID, token, amount);
+		setUint(setId, amount_);
+		_eventName = "LogBorrow(uint96,address,uint256,uint256,uint256)";
+		_eventParam = abi.encode(NFTID, token, amount_, getId, setId);
+	}
+
+	function payback(
+		uint96 NFTID,
+		address token,
+		uint256 amount
+	) public returns (string memory _eventName, bytes memory _eventParam) {
+		uint256 amount_ = getUint(getId, amount);
+		(uint256 amount0_, uint256 amount1_) = protocolModule.payback(
+			NFTID,
+			token,
+			amount
+		);
+		setUint(setId, amount_);
+		_eventName = "LogPayback(uint96,address,uint256,uint256,uint256)";
+		_eventParam = abi.encode(NFTID, token, amount_, getId, setId);
+	}
+
+	function collectFees(uint96 NFTID, uint256[] memory setId)
+		public
+		returns (string memory _eventName, bytes memory _eventParam)
+	{
+		(uint256 amount0_, uint256 amount1_) = protocolModule.collectFees(
+			NFTID
+		);
+		setUint(setId[0], amount0_);
+		setUint(setId[1], amount1_);
+		_eventName = "LogCollectFees(uint96,uint256[])";
+		_eventParam = abi.encode(NFTID, setId);
+	}
+
+	function depositNftToStaker(uint96 NFTID)
+		public
+		returns (string memory _eventName, bytes memory _eventParam)
+	{
+		protocolModule.depositNFT(NFTID);
+		_eventName = "LogDepositNFT(uint96)";
+		_eventParam = abi.encode(NFTID);
+	}
+
+	function withdrawNftFromStaker(uint96 NFID)
+		public
+		returns (string memory _eventName, bytes memory _eventParam)
+	{
+		protocolModule.withdrawNFT(NFTID);
+		_eventName = "LogWithdrawNFT(uint96)";
+		_eventParam = abi.encode(NFTID);
+	}
+
+	function stake(
+		address rewardToken,
+		uint256 startTime,
+		uint256 endTime,
+		address refundee,
+		uint96 NFTID
+	) public returns (string memory _eventName, bytes memory _eventParam) {
+		protocolModule.stake(rewardToken, startTime, endTime, refundee, NFTID);
+		_eventName = "LogStake(address,uint256,uint256,address,uint96)";
+		_eventParam = abi.encode(
+			rewardToken,
+			startTime,
+			endTime,
+			refundee,
+			NFTID
+		);
+	}
+
+	function unstake(
+		address rewardToken,
+		uint256 startTime,
+		uint256 endTime,
+		address refundee,
+		uint96 NFTID
+	) public returns (string memory _eventName, bytes memory _eventParam) {
+		protocolModule.unstake(
+			rewardToken,
+			startTime,
+			endTime,
+			refundee,
+			NFTID
+		);
+		_eventName = "LogUnStake(address,uint256,uint256,address,uint96)";
+		_eventParam = abi.encode(
+			rewardToken,
+			startTime,
+			endTime,
+			refundee,
+			NFTID
+		);
+	}
+
+	function claimStakingRewards(address rewardToken, uint96 NFTID)
+		public
+		returns (string memory _eventName, bytes memory _eventParam)
+	{
+		uint256 rewards_ = protocolModule.claimStakingRewards(
+			rewardToken,
+			NFTID
+		);
+		_eventName = "LogClaimStakingRewards(address,uint96)";
+		_eventParam = abi.encode(rewardToken, NFTID);
+	}
+
+	function claimBorrowingRewards(uint96 NFTID)
+		public
+		returns (string memory _eventName, bytes memory _eventParam)
+	{
+		BorrowingReward[] memory rewards_ = protocolModule
+			.claimBorrowingRewards(NFTID);
+
+		_eventName = "LogClaimBorrowingRewards(BorrowingReward[],uint96)";
+		_eventParam = abi.encode(rewards_, NFTID);
+	}
+
+	function claimBorrowingRewards(uint96 NFTID, address token)
+		public
+		returns (string memory _eventName, bytes memory _eventParam)
+	{
+		(
+			address[] memory rewardTokens_,
+			uint256[] memory rewardAmounts_
+		) = protocolModule.claimBorrowingRewards(NFTID, token);
+
+		_eventName = "LogClaimBorrowingRewards(uint96,address[],uint256[])";
+		_eventParam = abi.encode(NFTID, rewardTokens_, rewardAmounts_);
+	}
+
+	function liquidate0(
+		Liquidate0Parameters memory liquidate0Parameters_,
+		uint256[] setId
+	) public returns (string memory _eventName, bytes memory _eventParam) {
+		Liquidate0Variables memory liquidate0Variables_;
+		(
+			uint256 paybackAmount0,
+			uint256 paybackAmount1,
+			uint256 incentiveAmount0,
+			uint256 incentiveAmount1
+		) = protocolModule.liquidate0(liquidate0Parameters_);
+
+		setUint(setId[0], paybackAmount0);
+		setUint(setId[1], paybackAmount1);
+		setUint(setId[2], incentiveAmount0);
+		setUint(setId[3], incentiveAmount1);
+
+		_eventName = "LogLiquidate0(uint256,uint256,uint256,uint256)";
+		_eventParam = abi.encode(
+			paybackAmount0,
+			paybackAmount1,
+			incentiveAmount0,
+			incentiveAmount1,
+			setId
+		);
+	}
+
+	function liquidate1(
+		Liquidate1Parameters memory liquidate1Parameters_,
+		uint256[] setId
+	) public returns (string memory _eventName, bytes memory _eventParam) {
+		(
+			uint256 exactAmount0,
+			uint256 exactAmount1,
+			address[] memory markets,
+			uint256[] memory paybackAmts
+		) = protocolModule.liquidate1(liquidate1Parameters_);
+
+		setUint(setID[0], exactAmount0);
+		setUint(setID[1], exactAmount1);
+
+		_eventName = "LogLiquidate1(uint256,uint256,uint256,uint256)";
+		_eventParam = abi.encode(
+			paybackAmount0,
+			paybackAmount1,
+			incentiveAmount0,
+			incentiveAmount1,
+			setId
+		);
+	}
+}
+
+contract ConnectV2FluidityP3 is FluidityResolver {
+	string public constant name = "FluidityP3";
+}