@raac/rpc 1.0.2-beta.2 → 1.0.2-beta.3

package/pools/lendingPool/getLendingPoolInfo.ts

@@ -0,0 +1,157 @@
+import { ethers, Provider } from "ethers";
+import { getContractAddress } from "../../utils/contracts";
+import { getABI } from "../../utils/artifacts";
+import { ChainId } from "../../configs/chains";
+import { LendingPool, ReserveLibrary } from "../../typechain-types";
+import { RawData, Reserve } from "../../custom-types";
+
+// checked
+async function getLendingPoolInfo(
+	chainId: ChainId,
+	address: string,
+	provider: Provider
+) {
+	try {
+		const lendingPoolAddress = getContractAddress(chainId, "lendingpool");
+		const abi = getABI("lendingpool");
+		const lendingPoolContract = new ethers.Contract(
+			lendingPoolAddress,
+			abi,
+			provider
+		) as any as LendingPool;
+
+		const handleError =
+			(operation: string, returnType?: any) => (error: any) => {
+				if (error.code === "BAD_DATA") {
+					console.log(
+						`BAD_DATA from ${operation} - Pool empty?`,
+						error.message
+					);
+					return returnType || null;
+				}
+				throw error;
+			};
+
+		const [
+			reserve,
+			rateData,
+			normalizedIncome,
+			normalizedDebt,
+			liquidationThreshold,
+			healthFactorLiquidationThreshold,
+		] = await Promise.all([
+			(lendingPoolContract.reserve() as Promise<Reserve>).catch(
+				handleError("reserve")
+			),
+			(lendingPoolContract.rateData() as Promise<RawData>).catch(
+				handleError("rateData")
+			),
+			lendingPoolContract
+				.getNormalizedIncome()
+				.catch(handleError("getNormalizedIncome", 0n)),
+			lendingPoolContract
+				.getNormalizedDebt()
+				.catch(handleError("getNormalizedDebt", 0n)),
+			lendingPoolContract
+				.liquidationThreshold()
+				.catch(handleError("liquidationThreshold", 0n)),
+			lendingPoolContract
+				.healthFactorLiquidationThreshold()
+				.catch(handleError("healthFactorLiquidationThreshold", 0n)),
+		]);
+
+		console.log(reserve);
+
+		// Extract data from reserve
+		const totalLiquidity: bigint = reserve?.totalLiquidity ?? 0n;
+		const totalUsage: bigint = reserve?.totalUsage ?? 0n;
+		const liquidityIndex: bigint = reserve?.liquidityIndex ?? 0n;
+		const usageIndex: bigint = reserve?.usageIndex ?? 0n;
+
+		// Compute utilization
+		let utilization = 0n;
+		if (totalLiquidity + totalUsage > 0n) {
+			utilization = (totalUsage * BigInt(1e27)) / (totalLiquidity + totalUsage);
+		}
+
+		// Extract rate data
+		const currentLiquidityRate: bigint = rateData?.currentLiquidityRate ?? 0n;
+		const currentUsageRate: bigint = rateData?.currentUsageRate ?? 0n;
+		const primeRate: bigint = rateData?.primeRate ?? 0n;
+		const baseRate: bigint = rateData?.baseRate ?? 0n;
+		const optimalRate: bigint = rateData?.optimalRate ?? 0n;
+		const maxRate: bigint = rateData?.maxRate ?? 0n;
+		const optimalUtilizationRate: bigint =
+			rateData?.optimalUtilizationRate ?? 0n;
+		const protocolFeeRate: bigint = rateData?.protocolFeeRate ?? 0n;
+
+		// Compute APY
+		let apy: bigint;
+		if (utilization <= optimalUtilizationRate && optimalUtilizationRate > 0) {
+			const rateSlope = primeRate - baseRate;
+			const rateIncrease = (utilization * rateSlope) / optimalUtilizationRate;
+			apy = baseRate + rateIncrease;
+		} else {
+			const excessUtilization = utilization - optimalUtilizationRate;
+			const maxExcessUtilization = BigInt(1e27) - optimalUtilizationRate;
+			const rateSlope = maxRate - primeRate;
+			const rateIncrease =
+				(excessUtilization * rateSlope) / maxExcessUtilization;
+			apy = primeRate + rateIncrease;
+		}
+
+		let userRedeemable = 0n;
+		if (address) {
+			// Fetch user's scaled RToken balance
+			const rTokenAddress = reserve?.reserveRTokenAddress as string;
+			const rTokenABI = getABI("rtoken");
+			const rTokenContract = new ethers.Contract(
+				rTokenAddress,
+				rTokenABI,
+				provider
+			);
+
+			const userScaledBalance = await rTokenContract
+				.balanceOf(address)
+				.catch(handleError("rToken balanceOf"));
+
+			// Compute user's redeemable balance: userRedeemable = userScaledBalance * liquidityIndex / RAY
+			userRedeemable = (userScaledBalance * liquidityIndex) / BigInt(1e27);
+		}
+
+		const result = {
+			totalLiquidity: ethers.formatEther(totalLiquidity),
+			totalBorrow: ethers.formatEther(totalUsage),
+			utilization: (Number(utilization.toString()) / 1e27).toFixed(6), // Utilization as a decimal value between 0 and 1
+			liquidityIndex: (Number(liquidityIndex.toString()) / 1e27).toFixed(6),
+			usageIndex: (Number(usageIndex.toString()) / 1e27).toFixed(6),
+			currentLiquidityRate:
+				(Number(currentLiquidityRate.toString()) / 1e25).toFixed(2) + "%",
+			currentUsageRate:
+				(Number(currentUsageRate.toString()) / 1e25).toFixed(2) + "%",
+			primeRate: (Number(primeRate.toString()) / 1e25).toFixed(2) + "%",
+			baseRate: (Number(baseRate.toString()) / 1e25).toFixed(2) + "%",
+			optimalRate: (Number(optimalRate.toString()) / 1e25).toFixed(2) + "%",
+			maxRate: (Number(maxRate.toString()) / 1e25).toFixed(2) + "%",
+			optimalUtilizationRate: (
+				Number(optimalUtilizationRate.toString()) / 1e27
+			).toFixed(6),
+			protocolFeeRate:
+				(Number(protocolFeeRate.toString()) / 1e25).toFixed(2) + "%",
+			normalizedIncome: (Number(normalizedIncome.toString()) / 1e27).toFixed(6),
+			normalizedDebt: (Number(normalizedDebt.toString()) / 1e27).toFixed(6),
+			apy: (Number(apy.toString()) / 1e25).toFixed(2) + "%",
+			userRedeemable: ethers.formatEther(userRedeemable ?? 0n),
+			liquidationThreshold: Number(liquidationThreshold.toString()) / 10e3,
+			healthFactorLiquidationThreshold:
+				healthFactorLiquidationThreshold.toString(),
+		};
+
+		return result;
+	} catch (error: any) {
+		console.error("Error fetching lending pool info:", error);
+		throw error;
+	}
+}
+
+export default getLendingPoolInfo;

package/pools/lendingPool/getLendingPoolTotalLiquidity.ts

@@ -0,0 +1,32 @@
+import { ethers, Provider } from "ethers";
+import { getContractAddress } from "../../utils/contracts";
+import { getABI } from "../../utils/artifacts";
+import { ChainId } from "../../configs/chains";
+import { LendingPool } from "../../typechain-types";
+import { Reserve } from "../../custom-types";
+
+// The lending pool reserve contains the total liquidity of the lending pool. see getLendingPooInfo.ts
+// @deprecated
+async function getLendingPoolTotalLiquidity(
+	chainId: ChainId,
+	provider: Provider
+) {
+	try {
+		const lendingPoolAddress = getContractAddress(chainId, "lendingpool");
+		const abi = getABI("lendingpool");
+		const lendingPoolContract = new ethers.Contract(
+			lendingPoolAddress,
+			abi,
+			provider
+		) as any as LendingPool;
+
+		const reserve = (await lendingPoolContract.reserve()) as Reserve;
+		const totalLiquidity = reserve.totalLiquidity;
+		return totalLiquidity;
+	} catch (error: any) {
+		console.error("Error fetching total liquidity:", error);
+		throw error;
+	}
+}
+
+export default getLendingPoolTotalLiquidity;

package/pools/lendingPool/getPendingReward.ts

@@ -0,0 +1,32 @@
+import { ethers, Provider } from "ethers";
+import { getContractAddress } from "../../contracts/getContractAddress";
+import { getABI } from "../../utils/artifacts";
+import { ChainId } from "../../configs/chains/index";
+import { LendingPool } from "../../typechain-types";
+
+async function getPendingReward(
+	chainId: ChainId,
+	address: string,
+	provider: Provider
+) {
+	try {
+		const lendingPoolAddress = getContractAddress(chainId, "lendingpool");
+		const lendingPoolABI = getABI("lendingpool");
+		const lendingPoolContract = new ethers.Contract(
+			lendingPoolAddress,
+			lendingPoolABI,
+			provider
+		) as any as LendingPool;
+
+		const reward = await lendingPoolContract.getPendingReward(address);
+
+		console.log(`Pending reward: ${ethers.formatEther(reward)}`);
+
+		return reward;
+	} catch (error: any) {
+		console.error("Error in getPendingReward:", error);
+		throw error;
+	}
+}
+
+export default getPendingReward;

package/pools/lendingPool/getPositionDebt.ts

@@ -0,0 +1,40 @@
+import { ethers, Provider } from "ethers";
+import { getContractAddress } from "../../contracts/getContractAddress";
+import { getABI } from "../../utils/artifacts";
+import { ChainId } from "../../configs/chains/index";
+import { LendingPool } from "../../typechain-types";
+
+/**
+ * @description Get the raw debt of the user on a NFT. Equivant to the original amount borrowed on NFT.
+ * @param chainId
+ * @param address
+ * @param provider
+ * @returns The raw debt of the user on a NFT
+ */
+async function getPositionDebt(
+	chainId: ChainId,
+	address: string,
+	tokenId: string,
+	provider: Provider
+) {
+	try {
+		const lendingPoolAddress = getContractAddress(chainId, "lendingpool");
+		const lendingPoolABI = getABI("lendingpool");
+		const lendingPoolContract = new ethers.Contract(
+			lendingPoolAddress,
+			lendingPoolABI,
+			provider
+		) as any as LendingPool;
+
+		const reward = await lendingPoolContract.getPositionDebt(address, tokenId);
+
+		console.log(`getPositionDebt result: ${ethers.formatEther(reward)}`);
+
+		return reward;
+	} catch (error: any) {
+		console.error("Error in getPositionDebt:", error);
+		throw error;
+	}
+}
+
+export default getPositionDebt;

package/pools/lendingPool/getPositionScaledDebt.ts

@@ -0,0 +1,43 @@
+import { ethers, Provider } from "ethers";
+import { getContractAddress } from "../../contracts/getContractAddress";
+import { getABI } from "../../utils/artifacts";
+import { ChainId } from "../../configs/chains/index";
+import { LendingPool } from "../../typechain-types";
+
+/**
+ * @description Get the scaled debt of the user on a NFT (contains the accured interest)
+ * @param chainId
+ * @param address
+ * @param provider
+ * @returns The  debt of the user on a NFT with the accured interest
+ */
+async function getPositionScaledDebt(
+	chainId: ChainId,
+	address: string,
+	tokenId: string,
+	provider: Provider
+) {
+	try {
+		const lendingPoolAddress = getContractAddress(chainId, "lendingpool");
+		const lendingPoolABI = getABI("lendingpool");
+		const lendingPoolContract = new ethers.Contract(
+			lendingPoolAddress,
+			lendingPoolABI,
+			provider
+		) as any as LendingPool;
+
+		const reward = await lendingPoolContract.getPositionScaledDebt(
+			address,
+			tokenId
+		);
+
+		console.log(`getPositionScaledDebt result: ${ethers.formatEther(reward)}`);
+
+		return reward;
+	} catch (error: any) {
+		console.error("Error in getPositionScaledDebt:", error);
+		throw error;
+	}
+}
+
+export default getPositionScaledDebt;

package/pools/lendingPool/getPositionView.ts

@@ -0,0 +1,52 @@
+import { ethers, Provider } from "ethers";
+import { getContractAddress } from "../../contracts/getContractAddress";
+import { getABI } from "../../utils/artifacts";
+import { ChainId } from "../../configs/chains/index";
+import { ILendingPool, LendingPool } from "../../typechain-types";
+
+export function transformPositionView(
+	positionView: ILendingPool.NFTPositionViewStructOutput
+) {
+	return {
+		rawDebtBalance: ethers.formatEther(positionView?.[0] || 0n),
+		scaledDebtBalance: ethers.formatEther(positionView?.[1] || 0n),
+		healthFactor: (positionView?.[2] || 0n).toString(),
+		isUnderLiquidation: positionView?.[3] || false,
+		liquidationStartTime: (positionView?.[4] || 0n).toString(),
+		positionIndex: (positionView?.[5] || 0n).toString(),
+	};
+}
+
+/**
+ * @description Return all the information about a NFT position
+ * @param chainId
+ * @param address
+ * @param provider
+ * @returns All information about a NFT position
+ */
+async function getPositionView(
+	chainId: ChainId,
+	address: string,
+	tokenId: string,
+	provider: Provider
+) {
+	try {
+		const lendingPoolAddress = getContractAddress(chainId, "lendingpool");
+		const lendingPoolABI = getABI("lendingpool");
+		const lendingPoolContract = new ethers.Contract(
+			lendingPoolAddress,
+			lendingPoolABI,
+			provider
+		) as any as LendingPool;
+
+		const res = await lendingPoolContract.getPositionView(address, tokenId);
+		console.log(`getPositionView result: ${res}`);
+
+		return transformPositionView(res);
+	} catch (error: any) {
+		console.error("Error in getPositionView:", error);
+		throw error;
+	}
+}
+
+export default getPositionView;

package/pools/lendingPool/getPositionsScaledDebt.ts

@@ -0,0 +1,39 @@
+import { ethers, Provider } from "ethers";
+import { getContractAddress } from "../../contracts/getContractAddress";
+import { getABI } from "../../utils/artifacts";
+import { ChainId } from "../../configs/chains/index";
+import { LendingPool } from "../../typechain-types";
+
+/**
+ * @description Get the sum of all the scaled debts of a user over all NFTs
+ * @param chainId
+ * @param address
+ * @param provider
+ * @returns The  debt of the user
+ */
+async function getPositionsScaledDebt(
+	chainId: ChainId,
+	address: string,
+	provider: Provider
+) {
+	try {
+		const lendingPoolAddress = getContractAddress(chainId, "lendingpool");
+		const lendingPoolABI = getABI("lendingpool");
+		const lendingPoolContract = new ethers.Contract(
+			lendingPoolAddress,
+			lendingPoolABI,
+			provider
+		) as any as LendingPool;
+
+		const reward = await lendingPoolContract.getPositionsScaledDebt(address);
+
+		console.log(`getPositionsScaledDebt result: ${ethers.formatEther(reward)}`);
+
+		return reward;
+	} catch (error: any) {
+		console.error("Error in getPositionsScaledDebt:", error);
+		throw error;
+	}
+}
+
+export default getPositionsScaledDebt;

package/pools/lendingPool/getRawUserDepositsInLendingPool.ts

@@ -0,0 +1,33 @@
+import { ethers, Provider } from "ethers";
+import { getContractAddress } from "../../contracts/getContractAddress";
+import { getABI } from "../../utils/artifacts";
+import { ChainId } from "../../configs/chains/index";
+import { LendingPool } from "../../typechain-types";
+
+// Get the amount of RToken RAW deposit in the lending pool, without the accured interest
+async function getRawUserDepositsInLendingPool(
+	chainId: ChainId,
+	address: string,
+	provider: Provider
+) {
+	try {
+		const lendingPoolAddress = getContractAddress(chainId, "lendingpool");
+		const lendingPoolABI = getABI("lendingpool");
+		const lendingPoolContract = new ethers.Contract(
+			lendingPoolAddress,
+			lendingPoolABI,
+			provider
+		) as any as LendingPool;
+
+		const value = await lendingPoolContract.getUserDeposits(address);
+
+		console.log(`User deposits in lending pool: ${ethers.formatEther(value)}`);
+
+		return value;
+	} catch (error: any) {
+		console.error("Error in getRawUserDepositsInLendingPool:", error);
+		throw error;
+	}
+}
+
+export default getRawUserDepositsInLendingPool;

package/pools/lendingPool/getUserCollateralValue.ts

@@ -0,0 +1,39 @@
+import { ethers, Provider } from "ethers";
+import { getContractAddress } from "../../contracts/getContractAddress";
+import { getABI } from "../../utils/artifacts";
+import { ChainId } from "../../configs/chains/index";
+import { LendingPool } from "../../typechain-types";
+
+/**
+ * @description Sum of the prices of all the NFTS
+ * @param chainId
+ * @param address
+ * @param provider
+ * @returns The total value of the collateral
+ */
+async function getUserCollateralValue(
+	chainId: ChainId,
+	address: string,
+	provider: Provider
+) {
+	try {
+		const lendingPoolAddress = getContractAddress(chainId, "lendingpool");
+		const lendingPoolABI = getABI("lendingpool");
+		const lendingPoolContract = new ethers.Contract(
+			lendingPoolAddress,
+			lendingPoolABI,
+			provider
+		) as any as LendingPool;
+
+		const reward = await lendingPoolContract.getUserCollateralValue(address);
+
+		console.log(`getUserCollateralValue result: ${ethers.formatEther(reward)}`);
+
+		return reward;
+	} catch (error: any) {
+		console.error("Error in getUserCollateralValue:", error);
+		throw error;
+	}
+}
+
+export default getUserCollateralValue;

package/pools/lendingPool/initializeLiquidation.ts

@@ -0,0 +1,41 @@
+import { ethers, Provider, Signer } from "ethers";
+import { getContractAddress } from "../../contracts/getContractAddress";
+import { getABI } from "../../utils/artifacts";
+import { ChainId } from "../../configs/chains/index";
+import { LendingPool } from "../../typechain-types";
+
+/**
+ * @description Get the sum of all the scaled debts of a user over all NFTs
+ * @param chainId
+ * @param address
+ * @param provider
+ * @returns The  debt of the user
+ */
+async function initializeLiquidation(
+	chainId: ChainId,
+	address: string,
+	tokenId: string,
+	signer: Signer
+) {
+	try {
+		const lendingPoolAddress = getContractAddress(chainId, "lendingpool");
+		const lendingPoolABI = getABI("lendingpool");
+		const lendingPoolContract = new ethers.Contract(
+			lendingPoolAddress,
+			lendingPoolABI,
+			signer
+		) as any as LendingPool;
+
+		const tx = await lendingPoolContract.initiateLiquidation(address, tokenId);
+		await tx.wait();
+
+		console.log(`initializeLiquidation result: ${tx.hash}`);
+
+		return tx;
+	} catch (error: any) {
+		console.error("Error in initializeLiquidation:", error);
+		throw error;
+	}
+}
+
+export default initializeLiquidation;

package/pools/lendingPool/repayToLendingPool.ts

@@ -0,0 +1,38 @@
+import { ethers, Provider, Signer } from "ethers";
+import { getContractAddress } from "../../contracts/getContractAddress";
+import { getABI } from "../../utils/artifacts";
+import { ChainId } from "../../configs/chains/index";
+import { LendingPool } from "../../typechain-types";
+
+async function repayToLendingPool(
+	chainId: ChainId,
+	tokenId: string,
+	amount: string,
+	signer: Signer
+) {
+	try {
+		const lendingPoolAddress = getContractAddress(chainId, "lendingpool");
+		const lendingPoolABI = getABI("lendingpool");
+		const lendingPoolContract = new ethers.Contract(
+			lendingPoolAddress,
+			lendingPoolABI,
+			signer
+		) as any as LendingPool;
+
+		const amountInWei = ethers.parseEther(amount.toString());
+		console.log("Repaying amount in wei:", amountInWei.toString());
+
+		const tx = await lendingPoolContract.repay(tokenId, amountInWei.toString());
+		const receipt = await tx.wait();
+
+		console.log(`Repaid ${amount} crvUSD to lending pool.`);
+		console.log(`Transaction hash: ${receipt?.hash}`);
+
+		return receipt;
+	} catch (error: any) {
+		console.error("Error in repayToLendingPool:", error);
+		throw error;
+	}
+}
+
+export default repayToLendingPool;

package/pools/lendingPool/withdrawFromLendingPool.ts

@@ -0,0 +1,68 @@
+import { ethers, Signer } from "ethers";
+import { getContractAddress } from "../../contracts/getContractAddress";
+import { getABI } from "../../utils/artifacts";
+import estimateGasPrice from "../../methods/commons/estimateGasPrice";
+import { ChainId } from "../../configs/chains";
+import { ERC20, LendingPool } from "../../typechain-types";
+async function withdrawFromLendingPool(
+	chainId: ChainId,
+	amount: bigint,
+	signer: Signer
+) {
+	try {
+		const lendingPoolAddress = getContractAddress(chainId, "lendingpool");
+		const rtokenAddress = getContractAddress(chainId, "rtoken");
+		const lendingPoolABI = getABI("lendingpool");
+		const assetABI = getABI("rtoken");
+
+		const lendingPoolContract = new ethers.Contract(
+			lendingPoolAddress,
+			lendingPoolABI,
+			signer
+		) as any as LendingPool;
+		const rTokenContract = new ethers.Contract(
+			rtokenAddress,
+			assetABI,
+			signer
+		) as any as ERC20;
+
+		const amountInWei = ethers.parseEther(amount.toString());
+		const { maxFeePerGas } = await estimateGasPrice(signer);
+
+		const userBalance = await rTokenContract.balanceOf(
+			await signer.getAddress()
+		);
+		if (userBalance < amount) {
+			throw new Error(
+				`Insufficient rToken balance. Available: ${ethers.formatEther(
+					userBalance
+				)}, Requested: ${ethers.formatEther(amount)}`
+			);
+		}
+
+		const approveTx = await rTokenContract.approve(
+			lendingPoolAddress,
+			amountInWei
+		);
+		await approveTx.wait();
+		console.log(`Approved LendingPool to spend ${amount} rToken`);
+
+		// const withdraw = await lendingPoolContract.withdraw(amountInWei.toString(), {
+		// maxFeePerGas,
+		// nonce: await signer.getNonce()
+		// });
+
+		const tx = await lendingPoolContract.withdraw(amountInWei);
+		const receipt = await tx.wait();
+
+		console.log(`Withdrawn ${amount} from Lending Pool`);
+		console.log(`Transaction hash: ${receipt?.hash}`);
+
+		return receipt;
+	} catch (error: any) {
+		console.error("Error in withdrawFromLendingPool:", error);
+		throw error;
+	}
+}
+
+export default withdrawFromLendingPool;

package/pools/lendingPool/withdrawNFTFromLendingPool.ts

@@ -0,0 +1,39 @@
+import { ethers, Signer } from "ethers";
+import { getContractAddress } from "../../utils/contracts";
+import { getABI } from "../../utils/artifacts";
+import { ChainId } from "../../configs/chains/index";
+import { LendingPool } from "../../typechain-types";
+
+async function withdrawNFTFromLendingPool(
+	chainId: ChainId,
+	tokenId: string,
+	signer: Signer
+) {
+	if (!signer) {
+		throw new Error("Wallet not connected");
+	}
+
+	try {
+		const lendingPoolAddress = getContractAddress(chainId, "lendingpool");
+		const lendingPoolABI = getABI("lendingpool");
+
+		const lendingPoolContract = new ethers.Contract(
+			lendingPoolAddress,
+			lendingPoolABI,
+			signer
+		) as any as LendingPool;
+
+		const tx = await lendingPoolContract.withdrawNFT(tokenId);
+		await tx.wait();
+
+		console.log(`Withdrawn NFT with token ID ${tokenId} from lending pool`);
+		return tx;
+	} catch (error: any) {
+		console.error("Error withdrawing NFT from lending pool:", error);
+		throw new Error(
+			`Failed to withdraw NFT from lending pool: ${error.message}`
+		);
+	}
+}
+
+export default withdrawNFTFromLendingPool;