@raac/rpc 1.0.0

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@raac/rpc",
+  "version": "1.0.0",
+  "description": "RPC Library for RAAC ",
+  "main": "RPCLibrary.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "sync": "bash sync-contracts.sh"
+  },
+  "keywords": [
+    "RAAC",
+    "RPC",
+    "blockchain",
+    "DeFi"
+  ],
+  "author": "RAAC",
+  "license": "MIT",
+  "dependencies": {
+    "ethers": "^6.0.0"
+  },
+  "devDependencies": {
+    "eslint": "^8.0.0",
+    "ts-node": "^10.9.2",
+    "ts-node-dev": "^2.0.0",
+    "typescript": "^5.7.3"
+  }
+}

package/pools/lendingPool/borrowFromLendingPool.ts

@@ -0,0 +1,39 @@
+import { ethers, Signer } from "ethers";
+import { getContractAddress } from "../../contracts/getContractAddress";
+import { getABI } from "../../utils/artifacts";
+import { ChainId } from "../../configs/chains/index";
+import { LendingPool } from "../../typechain-types";
+
+// checked
+async function borrowFromLendingPool(
+	chainId: ChainId,
+	tokenId: number | 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 tx = await lendingPoolContract.borrow(amount);
+		const receipt = await tx.wait();
+
+		console.log(
+			`Borrowed ${ethers.formatEther(amount)} against NFT #${tokenId}`
+		);
+		console.log(`Transaction hash: ${receipt?.hash}`);
+
+		return receipt;
+	} catch (error: any) {
+		console.error("Error in borrowFromLendingPool:", error);
+		throw error;
+	}
+}
+
+export default borrowFromLendingPool;

package/pools/lendingPool/depositNFTToLendingPool.ts

@@ -0,0 +1,70 @@
+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 { LendingPool } from "../../typechain-types";
+
+//checked
+async function depositNFTToLendingPool(
+	chainId: ChainId,
+	tokenId: number | string,
+	signer: Signer
+) {
+	if (!signer) {
+		throw new Error("Wallet not connected");
+	}
+
+	try {
+		const lendingPoolAddress = getContractAddress(chainId, "lendingpool");
+		const nftAddress = getContractAddress(chainId, "raacnft");
+		const lendingPoolABI = getABI("lendingpool");
+		const nftABI = getABI("raacnft");
+
+		const lendingPoolContract = new ethers.Contract(
+			lendingPoolAddress,
+			lendingPoolABI,
+			signer
+		) as any as LendingPool;
+		const nftContract = new ethers.Contract(nftAddress, nftABI, signer);
+
+		const { maxFeePerGas } = await estimateGasPrice(signer);
+
+		// Check if the signer owns the NFT
+		const owner = await nftContract.ownerOf(tokenId);
+		if (owner.toLowerCase() !== (await signer.getAddress()).toLowerCase()) {
+			throw new Error(`Signer does not own NFT #${tokenId}`);
+		}
+
+		// Approve the lending pool to transfer the NFT
+		const approveTx = await nftContract.approve(lendingPoolAddress, tokenId, {
+			maxFeePerGas,
+			nonce: await signer.getNonce(),
+		});
+		await approveTx.wait();
+		console.log(`Approved lending pool to transfer NFT #${tokenId}`);
+
+		console.log(lendingPoolContract);
+		// Deposit (stake) the NFT
+		const depositTx = await lendingPoolContract.depositNFT(tokenId, {
+			maxFeePerGas,
+			nonce: await signer.getNonce(),
+		});
+
+		console.log(
+			`Deposit transaction sent for NFT #${tokenId}:`,
+			depositTx.hash
+		);
+		const receipt = await depositTx.wait();
+		console.log(
+			`Deposited NFT #${tokenId} to lending pool successfully:`,
+			receipt?.hash
+		);
+		return receipt;
+	} catch (error: any) {
+		console.error(`NFT Deposit to Lending Pool error:`, error);
+		throw new Error(`NFT Deposit to Lending Pool failed: ${error.message}`);
+	}
+}
+
+export default depositNFTToLendingPool;

package/pools/lendingPool/depositToLendingPool.ts

@@ -0,0 +1,52 @@
+import { ethers, Signer } from "ethers";
+import { getContractAddress } from "../../utils/contracts";
+import { getABI } from "../../utils/artifacts";
+import estimateGasPrice from "../../methods/commons/estimateGasPrice";
+import { ChainId } from "../../configs/chains";
+import { LendingPool } from "../../typechain-types";
+
+// checked
+async function depositToLendingPool(
+	chainId: ChainId,
+	amount: 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 amountInWei = ethers.parseEther(amount);
+		const { maxFeePerGas } = await estimateGasPrice(signer);
+
+		const depositTx = await lendingPoolContract.deposit(
+			amountInWei.toString(),
+			{
+				maxFeePerGas,
+				nonce: await signer.getNonce(),
+			}
+		);
+
+		console.log(`Deposit transaction sent for rcrvusd:`, depositTx.hash);
+		const receipt = await depositTx.wait();
+		console.log(
+			`Deposited ${amount} rcrvusd to lending pool successfully:`,
+			receipt?.hash
+		);
+		return receipt;
+	} catch (error: any) {
+		console.error(`Lending Pool Deposit error:`, error);
+		throw new Error(`Lending Pool Deposit failed: ${error.message}`);
+	}
+}
+
+export default depositToLendingPool;

package/pools/lendingPool/getHousePrice.ts

@@ -0,0 +1,46 @@
+import { ethers, Signer } from "ethers";
+import { getContractAddress } from "../../contracts/getContractAddress";
+import { getABI } from "../../utils/artifacts";
+import { ChainId } from "../../configs/chains/index";
+import { RAACHousePrices } from "../../typechain-types";
+
+// checked
+async function getHousePrice(
+	chainId: ChainId,
+	tokenId: number | string,
+	signer: Signer
+) {
+	console.log(chainId, tokenId, signer);
+	if (!signer) {
+		throw new Error("Wallet not connected");
+	}
+
+	try {
+		const raacHousePricesAddress = getContractAddress(
+			chainId,
+			"raachouseprices"
+		) as any as RAACHousePrices;
+		const raacHousePricesABI = getABI("raachouseprices");
+
+		const raacHousePricesContract = new ethers.Contract(
+			raacHousePricesAddress,
+			raacHousePricesABI,
+			signer
+		);
+
+		const housePrice = await raacHousePricesContract.getLatestPrice(tokenId);
+		console.log({ housePrice });
+
+		console.log(
+			`House price for token ID ${tokenId}: ${ethers.formatEther(
+				housePrice
+			)} ETH`
+		);
+		return housePrice;
+	} catch (error: any) {
+		console.error(`Error getting house price for token ID ${tokenId}:`, error);
+		throw new Error(`Failed to get house price: ${error.message}`);
+	}
+}
+
+export default getHousePrice;

package/pools/lendingPool/getLendingPoolInfo.ts

@@ -0,0 +1,153 @@
+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,
+			totalVaultDeposits,
+		] = 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
+				.totalVaultDeposits()
+				.catch(handleError("totalVaultDeposits", 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),
+			totalVaultDeposits: ethers.formatEther(totalVaultDeposits),
+		};
+
+		console.log(result);
+
+		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/repayToLendingPool.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 { ERC20, LendingPool } from "../../typechain-types";
+async function repayToLendingPool(
+	chainId: ChainId,
+	tokenId: string | number,
+	amount: bigint,
+	signer: Provider
+) {
+	try {
+		const lendingPoolAddress = getContractAddress(chainId, "lendingpool");
+		const crvUSDAddress = getContractAddress(chainId, "rcrvusd");
+		const lendingPoolABI = getABI("lendingpool");
+		const crvUSDABI = getABI("crvusd");
+
+		const lendingPoolContract = new ethers.Contract(
+			lendingPoolAddress,
+			lendingPoolABI,
+			signer
+		) as any as LendingPool;
+		const crvUSDTokenContract = new ethers.Contract(
+			crvUSDAddress,
+			crvUSDABI,
+			signer
+		) as any as ERC20;
+
+		const approveTx = await crvUSDTokenContract.approve(
+			lendingPoolAddress,
+			amount
+		);
+		await approveTx.wait();
+		console.log(
+			`Approved lendingPoolContract to spend ${ethers.formatEther(
+				amount
+			)} crvUSD`
+		);
+		const tx = await lendingPoolContract.repay(amount);
+		const receipt = await tx.wait();
+
+		console.log(`Repaid ${ethers.formatEther(amount)} for NFT #${tokenId}`);
+		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 rcrvUSD 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} rcrvUSD`);
+
+		// 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: number,
+	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;

package/pools/liquidityPool/getLiquidityPoolInfo.ts

@@ -0,0 +1,90 @@
+import { ethers, Provider } from "ethers";
+import { getContractAddress } from "../../utils/contracts";
+import { getABI } from "../../utils/artifacts";
+import { ChainId } from "../../configs/chains/index";
+
+async function getLiquidityPoolInfo(
+	chainId: ChainId,
+	address: string,
+	provider: Provider
+) {
+	try {
+		const liquidityPoolAddress = getContractAddress(chainId, "liquiditypool");
+		const abi = getABI("liquiditypool");
+		const liquidityPoolContract = new ethers.Contract(
+			liquidityPoolAddress,
+			abi,
+			provider
+		);
+
+		const handleError = (operation: string) => (error: any) => {
+			if (error.code === "BAD_DATA") {
+				console.log(
+					`BAD_DATA from getLiquidityPoolInfo - ${operation}:`,
+					error.message
+				);
+				return 0n;
+			}
+			throw error;
+		};
+
+		// Get all markets
+		const markets = await liquidityPoolContract
+			.getMarkets()
+			.catch(handleError("getMarkets"));
+
+		const result = {
+			markets: {},
+			tvl: "0",
+		};
+
+		for (const market of markets) {
+			const [totalLiquidity, userLiquidity, exchangeRate] = await Promise.all([
+				liquidityPoolContract
+					.getTotalLiquidity(market)
+					.catch(handleError("getTotalLiquidity")),
+				address
+					? liquidityPoolContract
+							// FIXME: pariedToken not defined.
+							// @ts-ignore
+							.getUserLiquidity(pairedToken, address)
+							.catch(handleError("getUserLiquidity"))
+					: [0n, 0n, 0n],
+				liquidityPoolContract
+					// @ts-ignore
+					.getExchangeRate(pairedToken)
+					.catch(handleError("getExchangeRate")),
+			]);
+
+			// @ts-ignore
+			result.markets[pairedToken] = {
+				totalLiquidity: {
+					raac: ethers.formatEther(totalLiquidity[0] ?? 0n),
+					paired: ethers.formatEther(totalLiquidity[1] ?? 0n),
+				},
+				userLiquidity: {
+					raac: ethers.formatEther(userLiquidity[0] ?? 0n),
+					paired: ethers.formatEther(userLiquidity[1] ?? 0n),
+					lpAmount: ethers.formatEther(userLiquidity[2] ?? 0n),
+				},
+				exchangeRate: {
+					raacPerPaired: ethers.formatEther(exchangeRate[0] ?? 0n),
+					pairedPerRaac: ethers.formatEther(exchangeRate[1] ?? 0n),
+				},
+			};
+		}
+
+		const tvl = await liquidityPoolContract
+			.getTotalValueLocked()
+			.catch(handleError("getTotalValueLocked"));
+		result.tvl = ethers.formatEther(tvl ?? 0n);
+
+		console.log("getLiquidityPoolInfo result:", result);
+		return result;
+	} catch (error: any) {
+		console.error("Error fetching liquidity pool info:", error);
+		throw error;
+	}
+}
+
+export default getLiquidityPoolInfo;