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

package/pools/liquidityPool/getLiquidityPoolInfo.ts

@@ -0,0 +1,91 @@
+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");
+		// @ts-ignore
+		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;

package/pools/stabilityPool/calculateRAACRewards.ts

@@ -0,0 +1,36 @@
+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/index";
+import { StabilityPool } from "../../typechain-types";
+
+async function calculateRAACRewards(
+	chainId: ChainId,
+	address: string,
+	signer: Signer
+) {
+	if (!signer) {
+		throw new Error("Wallet not connected");
+	}
+
+	try {
+		const stabilityPoolAddress = getContractAddress(chainId, "stabilitypool");
+		const stabilityPoolABI = getABI("stabilitypool");
+
+		const stabilityPoolContract = new ethers.Contract(
+			stabilityPoolAddress,
+			stabilityPoolABI,
+			signer
+		) as any as StabilityPool;
+
+		const calculateRAACRewards =
+			await stabilityPoolContract.calculateRaacRewards(address);
+
+		return ethers.formatEther(calculateRAACRewards);
+	} catch (error: any) {
+		throw new Error(`Error calculating RAAC rewards: ${error.message}`);
+	}
+}
+
+export default calculateRAACRewards;

package/pools/stabilityPool/depositNFTToStabilityPool.ts

@@ -0,0 +1,67 @@
+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/index";
+import { StabilityPool } from "../../typechain-types";
+
+async function depositNFTToStabilityPool(
+	chainId: ChainId,
+	tokenId: string,
+	signer: Signer
+) {
+	if (!signer) {
+		throw new Error("Wallet not connected");
+	}
+
+	try {
+		const stabilityPoolAddress = getContractAddress(chainId, "stabilitypool");
+		const abi = getABI("stabilitypool");
+		const stabilityPoolContract = new ethers.Contract(
+			stabilityPoolAddress,
+			abi,
+			signer
+		) as any as StabilityPool;
+
+		const RAACNFTAddress = getContractAddress(chainId, "raacnft");
+		const raacNFTABI = getABI("raacnft");
+		const raacNFTContract = new ethers.Contract(
+			RAACNFTAddress,
+			raacNFTABI,
+			signer
+		);
+
+		const owner = await raacNFTContract.ownerOf(tokenId);
+		if (owner.toLowerCase() !== (await signer.getAddress()).toLowerCase()) {
+			throw new Error(`Signer does not own NFT #${tokenId}`);
+		}
+
+		// approve the disposal of the NFT
+		const approvalTx = await raacNFTContract.approve(
+			stabilityPoolAddress,
+			tokenId,
+			{
+				nonce: await signer.getNonce(),
+			}
+		);
+		await approvalTx.wait();
+		console.log(`Approved stability pool to transfer NFT #${tokenId}`);
+
+		const tx = await stabilityPoolContract.depositNFT(RAACNFTAddress, tokenId, {
+			nonce: await signer.getNonce(),
+		});
+
+		console.log(`Deposit NFT transaction sent to Stability Pool:`, tx.hash);
+		const receipt = await tx.wait();
+		console.log(
+			`Deposited token ${tokenId} to Stability Pool successfully:`,
+			receipt?.hash
+		);
+		return receipt;
+	} catch (error: any) {
+		console.error(`Error depositing NFT to Stability Pool:`, error);
+		throw new Error(`NFT Deposit to Stability Pool failed: ${error.message}`);
+	}
+}
+
+export default depositNFTToStabilityPool;

package/pools/stabilityPool/depositToStabilityPool.ts

@@ -0,0 +1,47 @@
+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/index";
+import { StabilityPool } from "../../typechain-types";
+
+async function depositToStabilityPool(
+	chainId: ChainId,
+	amount: string,
+	signer: Signer
+) {
+	if (!signer) {
+		throw new Error("Wallet not connected");
+	}
+
+	try {
+		const stabilityPoolAddress = getContractAddress(chainId, "stabilitypool");
+		const abi = getABI("stabilitypool");
+		const stabilityPoolContract = new ethers.Contract(
+			stabilityPoolAddress,
+			abi,
+			signer
+		) as any as StabilityPool;
+
+		const amountInWei = ethers.parseEther(amount);
+		const { maxFeePerGas } = await estimateGasPrice(signer);
+
+		const tx = await stabilityPoolContract.deposit(amountInWei.toString(), {
+			maxFeePerGas,
+			nonce: await signer.getNonce(),
+		});
+
+		console.log(`Deposit transaction sent to Stability Pool:`, tx.hash);
+		const receipt = await tx.wait();
+		console.log(
+			`Deposited ${amount} to Stability Pool successfully:`,
+			receipt?.hash
+		);
+		return receipt;
+	} catch (error: any) {
+		console.error(`Error depositing to Stability Pool:`, error);
+		throw new Error(`Deposit to Stability Pool failed: ${error.message}`);
+	}
+}
+
+export default depositToStabilityPool;

package/pools/stabilityPool/getRawUserDepositsInStabilityPool.ts

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

package/pools/stabilityPool/getStabilityPoolInfo.ts

@@ -0,0 +1,111 @@
+import { ethers, Provider } from "ethers";
+import { getContractAddress } from "../../utils/contracts";
+import { getABI } from "../../utils/artifacts";
+import { ChainId } from "../../configs/chains/index";
+import { StabilityPool } from "../../typechain-types";
+
+async function getStabilityPoolInfo(
+	chainId: ChainId,
+	address: string,
+	provider: Provider
+) {
+	try {
+		const stabilityPoolAddress = getContractAddress(chainId, "stabilitypool");
+		const abi = getABI("stabilitypool");
+		const stabilityPoolContract = new ethers.Contract(
+			stabilityPoolAddress,
+			abi,
+			provider
+		) as any as StabilityPool;
+
+		const handleError = (operation: string) => (error: any) => {
+			if (error.code === "BAD_DATA") {
+				console.log(
+					`BAD_DATA from getStabilityPoolInfo - ${operation}:`,
+					error.message
+				);
+				return 0n;
+			}
+			throw error;
+		};
+
+		console.log(await stabilityPoolContract.deToken());
+
+		// Fetch data from StabilityPool
+		const [totalDeposits, totalAllocation] = await Promise.all([
+			stabilityPoolContract
+				.getTotalDeposits()
+				.catch(handleError("getTotalDeposits")),
+
+			stabilityPoolContract
+				.raacToken()
+				.then(async (raacTokenAddress) => {
+					const raacTokenAbi = getABI("raactoken"); // Ensure you have the correct ABI
+					const raacTokenContract = new ethers.Contract(
+						raacTokenAddress,
+						raacTokenAbi,
+						provider
+					);
+					return raacTokenContract
+						.balanceOf(stabilityPoolAddress)
+						.catch(handleError("raacToken balanceOf"));
+				})
+				.catch(handleError("raacToken")),
+		]);
+
+		let userDeposit = 0n;
+		let pendingRewards = 0n;
+		if (address) {
+			[userDeposit, pendingRewards] = await Promise.all([
+				stabilityPoolContract
+					.getUserDeposit(address)
+					.catch(handleError("getUserDeposit")),
+				stabilityPoolContract
+					.getPendingRewards(address)
+					.catch(handleError("getPendingRewards")),
+			]);
+		}
+
+		// Fetch RAAC Minter information if needed for APY calculation
+		const raacMinterAddress = getContractAddress(chainId, "raacminter");
+		let apy: bigint = 0n;
+
+		if (raacMinterAddress && raacMinterAddress !== ethers.ZeroAddress) {
+			const raacMinterABI = getABI("raacminter");
+			const raacMinterContract = new ethers.Contract(
+				raacMinterAddress as string,
+				raacMinterABI,
+				provider
+			);
+
+			const [emissionRate, totalSupply] = await Promise.all([
+				raacMinterContract.emissionRate().catch(handleError("emissionRate")),
+				raacMinterContract
+					.getTotalSupply()
+					.catch(handleError("getTotalSupply")),
+			]);
+
+			// APY Calculation
+			// Assuming emissionRate is per block and BLOCKS_PER_YEAR is known
+			const BLOCKS_PER_YEAR = 2102400n; // Approximate number of blocks per year (Ethereum ~15 sec/block)
+			const emissionRatePerYear = emissionRate * BLOCKS_PER_YEAR;
+			apy =
+				totalSupply > 0n ? (emissionRatePerYear * 10000n) / totalSupply : 0n;
+		}
+
+		const result = {
+			totalDeposits: ethers.formatEther(totalDeposits ?? 0n),
+			totalAllocation: (totalAllocation ?? 0n).toString(),
+			userDeposit: ethers.formatEther(userDeposit ?? 0n),
+			pendingRewards: ethers.formatEther(pendingRewards ?? 0n),
+			apy: parseFloat((apy ?? 0n).toString()) / 100, // APY in percentage
+		};
+
+		return result;
+	} catch (error: any) {
+		console.error("Error fetching stability pool info:", error);
+		throw error;
+	}
+}
+
+export default getStabilityPoolInfo;

package/pools/stabilityPool/getStabilityPoolTotalDeposits.ts

@@ -0,0 +1,27 @@
+import { BrowserProvider, ethers, Provider } from "ethers";
+import { getContractAddress } from "../../utils/contracts";
+import { getABI } from "../../utils/artifacts";
+import { ChainId } from "../../configs/chains/index";
+import { StabilityPool } from "../../typechain-types";
+
+async function getStabilityPoolTotalDeposits(
+	chainId: ChainId,
+	provider: Provider
+) {
+	try {
+		const stabilityPoolAddress = getContractAddress(chainId, "stabilitypool");
+		const abi = getABI("stabilitypool");
+		const stabilityPoolContract = new ethers.Contract(
+			stabilityPoolAddress,
+			abi,
+			provider
+		) as any as StabilityPool;
+		const totalDeposits = await stabilityPoolContract.getTotalDeposits();
+		return totalDeposits;
+	} catch (error: any) {
+		console.error("Error fetching total deposits:", error);
+		throw error;
+	}
+}
+
+export default getStabilityPoolTotalDeposits;

package/pools/stabilityPool/withdrawFromStabilityPool.ts

@@ -0,0 +1,47 @@
+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/index";
+import { StabilityPool } from "../../typechain-types";
+
+async function withdrawFromStabilityPool(
+	chainId: ChainId,
+	amount: string,
+	signer: Signer
+) {
+	if (!signer) {
+		throw new Error("Wallet not connected");
+	}
+
+	try {
+		const stabilityPoolAddress = getContractAddress(chainId, "stabilitypool");
+		const abi = getABI("stabilitypool");
+		const stabilityPoolContract = new ethers.Contract(
+			stabilityPoolAddress,
+			abi,
+			signer
+		) as any as StabilityPool;
+
+		const amountInWei = ethers.parseEther(amount);
+		const { maxFeePerGas } = await estimateGasPrice(signer);
+
+		const tx = await stabilityPoolContract.withdraw(amountInWei.toString(), {
+			maxFeePerGas,
+			nonce: await signer.getNonce(),
+		});
+
+		console.log(`Withdrawal transaction sent to Stability Pool:`, tx.hash);
+		const receipt = await tx.wait();
+		console.log(
+			`Withdrawn ${amount} from Stability Pool successfully:`,
+			receipt?.hash
+		);
+		return receipt;
+	} catch (error: any) {
+		console.error(`Error withdrawing from Stability Pool:`, error);
+		throw new Error(`Withdrawal from Stability Pool failed: ${error.message}`);
+	}
+}
+
+export default withdrawFromStabilityPool;

package/scripts/index.ts

@@ -0,0 +1,236 @@
+import { ethers, parseEther, Provider, WebSocketProvider } from "ethers";
+import chains, { ChainId } from "../configs/chains";
+//node --env-file=../.env -r ts-node/register ./test.ts
+
+import RPCLibrary from "../RPCLibrary";
+import { getContractAddress } from "../utils/contracts";
+import { getABI } from "../utils/artifacts";
+import {
+	BaseVRFv2Consumer,
+	DEToken,
+	IndexToken,
+	LendingPool,
+	MockVRFCoordinatorV2,
+	RAACHousePrices,
+	RAACNFT,
+} from "../typechain-types";
+
+const chainId = 8453;
+const config = chains[chainId];
+
+const TEST_MNEMONIC = process.env.TEST_MNEMONIC as string;
+
+async function getProvider() {
+	return new ethers.JsonRpcProvider(config.rpcs[0]);
+}
+async function createWallet(mnemonic: string, provider: Provider) {
+	const wallet = ethers.Wallet.fromPhrase(mnemonic, provider);
+
+	console.info(`[${chainId}]: Loaded wallet from mnemonic: ${wallet.address}`);
+
+	// the signer is the wallet
+	return wallet;
+}
+
+async function setup() {
+	const provider = await getProvider();
+	const signer = await createWallet(TEST_MNEMONIC, provider);
+
+	const rpc = new RPCLibrary();
+	rpc.address = signer.address;
+	rpc.provider = provider;
+	rpc.chainId = chainId;
+
+	// send myself some CRVUSD
+	await rpc.wallet.assets.mintAsset(
+		chainId,
+		"crvusd",
+		10000000n,
+		signer.address,
+		signer
+	);
+
+	// // set the base uri to instruxi data gateway
+	await rpc.nfts.setBaseUri(
+		chainId,
+		"https://gateway-staging.instruxi.dev/api/v1/vnft/metadata/public/1/0x0000000000000000000000000000",
+		signer
+	);
+
+	// // // set the oracle address of the RAACHousePrice. TEmporarily simulating that I AM THE ORACLE
+	await rpc.contracts.housePrices.setOracle(chainId, signer.address, signer);
+
+	// // // set price for 3 houses
+	const housePriceAddress = getContractAddress(chainId, "raachouseprices");
+	const housePriceABI = getABI("raachouseprices");
+	const housePriceContract = new ethers.Contract(
+		housePriceAddress,
+		housePriceABI,
+		signer
+	) as any as RAACHousePrices;
+
+	const raacNFTAddress = getContractAddress(chainId, "raacnft");
+	const raacNFTABI = getABI("raacnft");
+	const raacNFTContract = new ethers.Contract(
+		raacNFTAddress,
+		raacNFTABI,
+		signer
+	) as any as RAACNFT;
+
+	const countTokens = 3;
+
+	// // Generate 10 house prices between 100K and 2M
+	const housePrices = [];
+	for (let i = 1; i <= countTokens; i++) {
+		const price = Math.floor(Math.random() * (2000000 - 100000) + 100000);
+		housePrices.push(price);
+	}
+
+	// // Mint the new properties
+	for (let i = 1; i <= countTokens; i++) {
+		const tx = await raacNFTContract.minterMint(signer.address, i);
+		await tx.wait();
+		console.log("Minted NFT", i);
+	}
+
+	// set house prices
+	for (let i = 1; i <= countTokens; i++) {
+		const tx = await housePriceContract.setHousePrice(
+			i,
+			parseEther(housePrices[i - 1].toString())
+		);
+		await tx.wait();
+		console.log("Price set for house", i);
+	}
+
+	// confirm the house prices are set
+	for (let i = 1; i <= countTokens; i++) {
+		const price = await rpc.nfts.getHousePrice(chainId, i, provider);
+		console.log("Price for house", i, price);
+		if (price !== housePrices[i - 1].toString() + ".0") {
+			throw new Error("Price not set correctly");
+		}
+	}
+
+	// Generate some random NFT and set price only: not purchased yet
+	let nftIdStart = countTokens + 1;
+	let nftIdEnd = countTokens + 10;
+	for (let i = nftIdStart; i <= nftIdEnd; i++) {
+		const price = Math.floor(Math.random() * (2000000 - 100000) + 100000);
+		const tx = await housePriceContract.setHousePrice(
+			i,
+			parseEther(price.toString())
+		);
+		await tx.wait();
+		console.log("Price set for house", i);
+	}
+
+	/// Temporary fix for stabillity pool setStabilityPool
+
+	const stabilityPoolAddress = getContractAddress(chainId, "stabilitypool");
+
+	const deTokenAddress = getContractAddress(chainId, "detoken");
+	const deTokenABI = getABI("detoken");
+	const deTokenContract = new ethers.Contract(
+		deTokenAddress,
+		deTokenABI,
+		signer
+	) as any as DEToken;
+
+	const tx = await deTokenContract.setStabilityPool(stabilityPoolAddress);
+	await tx.wait();
+
+	console.log("Stability pool set to", stabilityPoolAddress);
+
+	fulfillRequest();
+}
+
+const execute = async () => {
+	const provider = await getProvider();
+	const signer = await createWallet(TEST_MNEMONIC, provider);
+
+	const rpc = new RPCLibrary();
+	rpc.address = signer.address;
+	rpc.provider = provider;
+	rpc.chainId = chainId;
+	console.log(
+		await rpc.contracts.indexToken.getNextRandomNFT(chainId, provider)
+	);
+};
+
+const updateNFTPrice = async (id: string, price: string) => {
+	const provider = await getProvider();
+	const signer = await createWallet(TEST_MNEMONIC, provider);
+
+	const rpc = new RPCLibrary();
+	rpc.address = signer.address;
+	rpc.provider = provider;
+	rpc.chainId = chainId;
+
+	const housePriceAddress = getContractAddress(chainId, "raachouseprices");
+	const housePriceABI = getABI("raachouseprices");
+	const housePriceContract = new ethers.Contract(
+		housePriceAddress,
+		housePriceABI,
+		signer
+	) as any as RAACHousePrices;
+
+	let tx;
+
+	tx = await housePriceContract.setHousePrice(id, ethers.parseEther(price));
+	console.log(await rpc.nfts.getHousePrice(chainId, parseInt(id), provider));
+};
+
+const fulfillRequest = async () => {
+	const provider = await getProvider();
+	const signer = await createWallet(TEST_MNEMONIC, provider);
+
+	const rpc = new RPCLibrary();
+	rpc.address = signer.address;
+	rpc.provider = provider;
+	rpc.chainId = chainId;
+
+	const indexTokenAddress = getContractAddress(chainId, "indextoken");
+	const indexTokenABI = getABI("indextoken");
+	const indexTokenContract = new ethers.Contract(
+		indexTokenAddress,
+		indexTokenABI,
+		signer
+	) as any as IndexToken;
+
+	const vrfCoordinatorAddress = "0x9d4454B023096f34B160D6B654540c56A1F81688";
+	const vrfCoordinatorABI = getABI("mockvrfcoordinator");
+	const vrfCoordinatorContract = new ethers.Contract(
+		vrfCoordinatorAddress,
+		vrfCoordinatorABI,
+		signer
+	) as any as MockVRFCoordinatorV2;
+
+	const vrfConsumerAddress = "0x5eb3Bc0a489C5A8288765d2336659EbCA68FCd00";
+	const vrfConsumerABI = getABI("vrfconsumer");
+	const vrfConsumerContract = new ethers.Contract(
+		vrfConsumerAddress,
+		vrfConsumerABI,
+		signer
+	) as any as BaseVRFv2Consumer;
+
+	await vrfCoordinatorContract.fulfillRandomWordsWithOverride(
+		await vrfConsumerContract.lastRequestId(),
+		vrfConsumerAddress,
+		[12]
+	);
+
+	const nextRandom = await vrfConsumerContract.getRequestStatus();
+	console.log("Next random number", nextRandom);
+
+	const redemptionToken = await rpc.contracts.indexToken.getNextRandomNFT(
+		chainId,
+		provider
+	);
+	console.log("Redemption token", redemptionToken);
+};
+
+// execute();
+// setup();
+fulfillRequest();
+// updateNFTPrice("7", "1650000");