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

package/methods/approveToken.ts

@@ -0,0 +1,47 @@
+import { ethers, Signer } from "ethers";
+import { getContractAddress } from "../contracts/getContractAddress";
+import estimateGasPrice from "./commons/estimateGasPrice";
+import { ChainId } from "../configs/chains/index";
+import { ContractType } from "../utils/artifacts";
+import { ERC20 } from "../typechain-types";
+
+const approveToken = async (
+	chainId: ChainId,
+	tokenSymbol: ContractType,
+	spender: string,
+	amount: string,
+	signer: Signer
+) => {
+	if (!signer) {
+		throw new Error("Wallet not connected");
+	}
+
+	const tokenAddress = getContractAddress(chainId, tokenSymbol) as any as ERC20;
+	const tokenABI = [
+		"function approve(address spender, uint256 amount) public returns (bool)",
+	];
+	const tokenContract = new ethers.Contract(tokenAddress, tokenABI, signer);
+
+	try {
+		const amountInWei = ethers.parseEther(amount);
+		const { maxFeePerGas } = await estimateGasPrice(signer);
+
+		const tx = await tokenContract.approve(spender, amountInWei, {
+			maxFeePerGas,
+			// maxPriorityFeePerGas
+		});
+
+		console.log(`Approval transaction sent:`, tx.hash);
+		const receipt = await tx.wait();
+		console.log(
+			`Approved ${amount} ${tokenSymbol} for ${spender} successfully:`,
+			receipt.transactionHash
+		);
+		return receipt;
+	} catch (error: any) {
+		console.error(`Approval error:`, error);
+		throw new Error(`Token approval failed: ${error.message}`);
+	}
+};
+
+export default approveToken;

package/methods/commons/checkAllowance.ts

@@ -0,0 +1,36 @@
+import { Provider } from "ethers";
+import { getContract, getContractAddress } from "../../utils/contracts";
+import { ContractType } from "../../utils/artifacts";
+import { ChainId } from "../../configs/chains/index";
+import { ERC20 } from "../../typechain-types";
+
+const checkAllowance = async (
+	chainId: ChainId,
+	tokenId: ContractType,
+	address: string,
+	spenderAddress: string,
+	provider: Provider
+) => {
+	let tokenAddress = getContractAddress(chainId, tokenId as string);
+	console.log(
+		`[commons/checkAllowance] Checking allowance for ${address} to ${spenderAddress} on ${chainId} ${tokenId}:${tokenAddress}`
+	);
+
+	try {
+		const tokenContract = getContract(
+			chainId,
+			tokenId,
+			provider
+		) as any as ERC20;
+		const allowance = await tokenContract.allowance(address, spenderAddress);
+		return allowance;
+	} catch (error: any) {
+		console.error(`Error calling allowance: ${error}`);
+		throw new Error(
+			`[commons/checkAllowance] ${chainId} ${tokenId}:${tokenAddress} ${address} ${spenderAddress} ${error}`
+		);
+	}
+};
+
+export default checkAllowance;
+export { checkAllowance };

package/methods/commons/estimateGasPrice.ts

@@ -0,0 +1,26 @@
+import { Provider, Signer } from "ethers";
+
+export const estimateGasPrice = async (signer: Signer) => {
+	const provider = signer.provider as Provider;
+	try {
+		const feeData = await provider.getFeeData();
+		const maxPriorityFeePerGas = feeData.maxPriorityFeePerGas;
+		// Fix for maxFeePerGas cannot be less than maxPriorityFeePerGas (The total must be the larger of the two
+		const maxFeePerGas = maxPriorityFeePerGas && feeData.maxFeePerGas && 
+			feeData.maxFeePerGas < maxPriorityFeePerGas ? 
+			maxPriorityFeePerGas : feeData.maxFeePerGas;
+		return {
+			maxFeePerGas,
+			maxPriorityFeePerGas,
+		};
+	} catch (error: any) {
+		console.log("Error getting gas price", error);
+		if ((provider as any)?.getGasPrice) {
+			const gasPrice = await (provider as any).getGasPrice();
+			return { gasPrice };
+		}
+		return { gasPrice: 0 };
+	}
+};
+
+export default estimateGasPrice;

package/methods/debug/mintToken.js

@@ -0,0 +1,83 @@
+import { ethers } from "ethers";
+
+import { getContractAddress } from "../../contracts/getContractAddress";
+import estimateGasPrice from "../commons/estimateGasPrice";
+
+import crvUSDTokenArtifact from "../../artifacts/Tokens/crvUSDToken.sol/crvUSDToken.json"; // assert { type: "json" };
+import spcrvUSDTokenArtifact from "../../artifacts/Tokens/spcrvUSDToken.sol/spcrvUSDToken.json"; // assert { type: "json" };
+import RAACTokenArtifact from "../../artifacts/Tokens/RAACToken.sol/RAACToken.json"; // assert { type: "json" };
+import veRAACTokenArtifact from "../../artifacts/Tokens/veRAACToken.sol/veRAACToken.json"; // assert { type: "json" };
+import rcrvUSDTokenArtifact from "../../artifacts/Tokens/rCRVUSDToken.sol/rCRVUSDToken.json"; // assert { type: "json" };
+import RAACLendingPoolArtifact from "../../artifacts/LendingPool/RAACLendingPool.sol/RAACLendingPool.json"; // assert { type: "json" };
+import RAACStabilityPoolArtifact from "../../artifacts/StabilityPool/StabilityPool.sol/StabilityPool.json"; // assert { type: "json" };
+import LiquidityPoolArtifact from "../../artifacts/LiquidityPool/LiquidityPool.sol/LiquidityPool.json"; // assert { type: "json" };
+import RTokenArtifact from "../../artifacts/Tokens/RToken.sol/RToken.json"; // assert { type: "json" };
+import RAACNFTArtifact from "../../artifacts/Tokens/RAACNFT.sol/RAACNFT.json"; // assert { type: "json" };
+
+const CRVUSD_ABI = crvUSDTokenArtifact.abi;
+const SPCRVUSD_ABI = spcrvUSDTokenArtifact.abi;
+const VERAAC_ABI = veRAACTokenArtifact.abi;
+const RCRVUSD_ABI = rcrvUSDTokenArtifact.abi;
+const RAACLENDINGPOOL_ABI = RAACLendingPoolArtifact.abi;
+const RAACSTABILITYPOOL_ABI = RAACStabilityPoolArtifact.abi;
+const LIQUIDITYPOOL_ABI = LiquidityPoolArtifact.abi;
+const RAAC_ABI = RAACNFTArtifact.abi;
+const RTOKEN_ABI = RTokenArtifact.abi;
+
+const mintToken = async (chainId, assetId, amount, signer) => {
+	if (!signer) {
+		throw new Error("Wallet not connected");
+	}
+	const normalizedAssetId = assetId.toLowerCase();
+	const contractAddress = getContractAddress(chainId, normalizedAssetId);
+	let contract;
+
+	try {
+		switch (normalizedAssetId) {
+			case "crvusd":
+				contract = new ethers.Contract(contractAddress, CRVUSD_ABI, signer);
+				break;
+			case "spcrvusd":
+				contract = new ethers.Contract(contractAddress, SPCRVUSD_ABI, signer);
+				break;
+			case "rcrvusd":
+				contract = new ethers.Contract(contractAddress, RCRVUSD_ABI, signer);
+				break;
+			case "rtoken":
+				contract = new ethers.Contract(contractAddress, RTOKEN_ABI, signer);
+				break;
+			case "raacnft":
+				contract = new ethers.Contract(contractAddress, RAACNFT_ABI, signer);
+				break;
+			case "veraac":
+				contract = new ethers.Contract(contractAddress, VERAAC_ABI, signer);
+				break;
+			default:
+				throw new Error(`Unsupported asset: ${normalizedAssetId}`);
+		}
+
+		const { maxFeePerGas } = await estimateGasPrice(signer);
+		const tx = await contract.mint(
+			await signer.getAddress(),
+			ethers.parseEther(amount),
+			{
+				maxFeePerGas,
+				// maxPriorityFeePerGas
+			}
+		);
+		console.log(`Minting transaction sent for ${normalizedAssetId}:`, tx.hash);
+		const receipt = await tx.wait();
+		console.log(
+			`Minted ${amount} ${normalizedAssetId} successfully:`,
+			receipt.transactionHash
+		);
+		return receipt;
+	} catch (error: any){
+		console.error(`Minting error for ${normalizedAssetId}:`, error);
+		throw new Error(
+			`Minting failed for ${normalizedAssetId}: ${error.message}`
+		);
+	}
+};
+
+export default mintToken;

package/methods/getAssetBalance.ts

@@ -0,0 +1,48 @@
+import { ethers, Provider, Signer } from "ethers";
+import { getContractAddress } from "../contracts/getContractAddress";
+import { ChainId } from "../configs/chains/index";
+import { AssetType, ContractType } from "../utils/artifacts";
+import { ERC20 } from "../typechain-types";
+
+const getAssetBalance = async (
+	chainId: ChainId,
+	address: string,
+	assetId: AssetType,
+	signer: Signer
+) => {
+	if (!signer) {
+		throw new Error("Wallet not connected");
+	}
+	try {
+		if (assetId === "eth") {
+			const provider = signer.provider as Provider;
+			// handle getBalance do not exist in ethers.js, check if not under the other method TODO FIXME
+			const balance = (await provider.getBalance(address)).toString();
+			return balance;
+		}
+		// @ts-ignore
+		const tokenAddress = getContractAddress(chainId, assetId);
+		const abi = ["function balanceOf(address) view returns (uint256)"];
+		const contract = new ethers.Contract(
+			tokenAddress,
+			abi,
+			signer
+		) as any as ERC20;
+
+		const balance = await contract.balanceOf(address);
+
+		return ethers.formatEther(balance);
+	} catch (error: any) {
+		console.error(`Error in getAssetBalance for ${assetId}:`, error);
+		if (error.code === "BAD_DATA") {
+			console.error(
+				"Contract might not have balanceOf function. Check the contract address and ABI."
+			);
+		}
+		throw new Error(`Failed to fetch balance for ${assetId}: ${error.message}`);
+	}
+};
+
+export default getAssetBalance;
+
+export { getAssetBalance };

package/methods/getAssetsBalance.ts

@@ -0,0 +1,9 @@
+import { Signer } from "ethers";
+
+const getAssetBalance = async (
+	chainId: number,
+	address: string,
+	signer: Signer
+) => {};
+
+export default getAssetBalance;

package/minter/get.ts

@@ -0,0 +1,150 @@
+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 { RAACMinter } from "../typechain-types";
+
+async function get(chainId: ChainId, signer: Signer) {
+	if (!signer) {
+		throw new Error("Wallet not connected");
+	}
+
+	try {
+		const raacMinterAddress = getContractAddress(chainId, "raacminter");
+		const raacMinterABI = getABI("raacminter");
+		// console.log(raacMinterAddress);
+		// console.log(raacMinterABI);
+
+		const raacMinterContract = new ethers.Contract(
+			raacMinterAddress,
+			raacMinterABI,
+			signer
+		) as any as RAACMinter;
+
+		const handleError = (operation: string) => (error: any) => {
+			if (error.code === "BAD_DATA") {
+				console.log(`BAD_DATA from getMinter - ${operation}:`, error.message);
+				return BigInt(0);
+			}
+			throw error;
+		};
+
+		const { maxFeePerGas } = await estimateGasPrice(signer);
+
+		const [
+			emissionRate,
+			benchmarkRate,
+			minEmissionRate,
+			maxEmissionRate,
+			utilizationTarget,
+			excessTokens,
+			lastUpdateBlock,
+			raacToken,
+			stabilityPool,
+			lendingPool,
+			owner,
+			BLOCKS_PER_DAY,
+		] = await Promise.all([
+			raacMinterContract.emissionRate().catch(handleError("emissionRate")),
+			raacMinterContract.benchmarkRate().catch(handleError("benchmarkRate")),
+			raacMinterContract
+				.minEmissionRate()
+				.catch(handleError("minEmissionRate")),
+			raacMinterContract
+				.maxEmissionRate()
+				.catch(handleError("maxEmissionRate")),
+			raacMinterContract
+				.utilizationTarget()
+				.catch(handleError("utilizationTarget")),
+			raacMinterContract.excessTokens().catch(handleError("excessTokens")),
+			raacMinterContract
+				.lastUpdateBlock()
+				.catch(handleError("lastUpdateBlock")),
+			raacMinterContract.raacToken().catch(handleError("raacToken")),
+			raacMinterContract.stabilityPool().catch(handleError("stabilityPool")),
+			raacMinterContract.lendingPool().catch(handleError("lendingPool")),
+			raacMinterContract.owner().catch(handleError("owner")),
+			raacMinterContract.BLOCKS_PER_DAY().catch(handleError("BLOCKS_PER_DAY")),
+		]);
+
+		const result = {
+			emissionRate,
+			benchmarkRate,
+			minEmissionRate,
+			maxEmissionRate,
+			utilizationTarget,
+			excessTokens,
+			lastUpdateBlock,
+			raacToken,
+			stabilityPool,
+			lendingPool,
+			owner,
+			BLOCKS_PER_DAY,
+		};
+
+		// Call all readable values from the RAACMinter contract
+		// result.emissionRate = await raacMinterContract.emissionRate();
+		// result.benchmarkRate = await raacMinterContract.benchmarkRate();
+		// result.minEmissionRate = await raacMinterContract.minEmissionRate();
+		// result.maxEmissionRate = await raacMinterContract.maxEmissionRate();
+		// result.utilizationTarget = await raacMinterContract.utilizationTarget();
+		// result.excessTokens = await raacMinterContract.excessTokens();
+		// result.lastUpdateBlock = await raacMinterContract.lastUpdateBlock();
+		// result.raacToken = await raacMinterContract.raacToken();
+		// result.stabilityPool = await raacMinterContract.stabilityPool();
+		// result.lendingPool = await raacMinterContract.lendingPool();
+		// result.owner = await raacMinterContract.owner();
+		// result.BLOCKS_PER_DAY = await raacMinterContract.BLOCKS_PER_DAY();
+
+		// APY:
+		const blocksPerYear = result.BLOCKS_PER_DAY * 365n;
+		const emissionRatePerYear = result.emissionRate * blocksPerYear;
+		console.log("emissionRatePerYear", emissionRatePerYear);
+		const totalSupply = await raacMinterContract.getTotalSupply();
+		console.log("totalSupply", totalSupply);
+
+		const apy = (emissionRatePerYear * 10000n) / totalSupply;
+		console.log("apy", apy);
+
+		// const BLOCKS_PER_YEAR = 2628000; // Assuming 6500 blocks per day * 365 days
+		// const emissionRatePerYear = result.emissionRate * BLOCKS_PER_YEAR;
+		// console.log("emissionRatePerYear", emissionRatePerYear);
+		// const totalSupply = await raacMinterContract.raacToken().totalSupply();
+
+		// if (totalSupply.gt(0)) {
+		//     const apy = emissionRatePerYear * 10000 / totalSupply;
+		//     result.apy = apy / 100; // Convert to percentage
+		// } else {
+		//     result.apy = 0;
+		// }
+		// Constants
+		// result.PRECISION = await raacMinterContract.PRECISION();
+		// result.BLOCKS_PER_YEAR = await raacMinterContract.BLOCKS_PER_YEAR();
+		// result.INITIAL_EMISSION_RATE = await raacMinterContract.INITIAL_EMISSION_RATE();
+
+		// const params = await raacMinterContract.getParameters();
+		// result.parameters = {
+		// minEmissionRate: params[0],
+		// maxEmissionRate: params[1],
+		// utilizationTarget: params[2],
+		// adjustmentSpeed: params[3],
+		// benchmarkRate: params[4],
+		// emissionRate: params[5],
+		// excessTokens: params[6]
+		// };
+
+		// const tick = await raacMinterContract.tick();
+		// address, {
+		//   maxFeePerGas,
+		//   nonce: await signer.getNonce()
+		// });
+
+		// console.log(tick);
+		return result;
+	} catch (error: any) {
+		throw new Error(`Error calculating RAAC rewards: ${error.message}`);
+	}
+}
+
+export default get;

package/minter/getApy.ts

@@ -0,0 +1,37 @@
+import { ethers, Provider, Signer } from "ethers";
+import { getContractAddress } from "../utils/contracts";
+import { getABI } from "../utils/artifacts";
+import { ChainId } from "../configs/chains/index";
+import { RAACMinter } from "../typechain-types";
+
+async function getApy(chainId: ChainId, provider: Provider) {
+	if (!provider) {
+		throw new Error("Wallet not connected");
+	}
+
+	try {
+		const raacMinterAddress = getContractAddress(chainId, "raacminter");
+		const raacMinterABI = getABI("raacminter");
+		const raacMinterContract = new ethers.Contract(
+			raacMinterAddress,
+			raacMinterABI,
+			provider
+		) as any as RAACMinter;
+
+		const result = { emissionRate: 0n, BLOCKS_PER_DAY: 0n };
+		result.emissionRate = await raacMinterContract.emissionRate();
+		result.BLOCKS_PER_DAY = await raacMinterContract.BLOCKS_PER_DAY();
+
+		// APY:
+		const blocksPerYear = result.BLOCKS_PER_DAY * 365n;
+		const emissionRatePerYear = result.emissionRate * blocksPerYear;
+		const totalSupply = await raacMinterContract.getTotalSupply();
+
+		const apy = (emissionRatePerYear * 10000n) / totalSupply;
+		return apy;
+	} catch (error: any) {
+		throw new Error(`Error calculating RAAC rewards: ${error.message}`);
+	}
+}
+
+export default getApy;

package/minter/tick.ts

@@ -0,0 +1,40 @@
+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 { RAACMinter } from "../typechain-types";
+
+async function tick(chainId: ChainId, signer: Signer) {
+	if (!signer) {
+		throw new Error("Wallet not connected");
+	}
+
+	try {
+		const raacMinterAddress = getContractAddress(chainId, "raacminter");
+		const raacMinterABI = getABI("raacminter");
+
+		const raacMinterContract = new ethers.Contract(
+			raacMinterAddress,
+			raacMinterABI,
+			signer
+		) as any as RAACMinter;
+
+		const { maxFeePerGas } = await estimateGasPrice(signer);
+
+		console.log({ maxFeePerGas });
+		const tick = await raacMinterContract.tick({
+			maxFeePerGas,
+			nonce: await signer.getNonce(),
+		});
+
+		if (tick.wait) {
+			await tick.wait();
+		}
+		return tick;
+	} catch (error: any) {
+		throw new Error(`Error calculating RAAC rewards: ${error.message}`);
+	}
+}
+
+export default tick;

package/nfts/getAllTokens.ts

@@ -0,0 +1,51 @@
+import { ethers, Provider } from "ethers";
+import { getContractAddress } from "../utils/contracts";
+import { getABI } from "../utils/artifacts";
+import { ChainId } from "../configs/chains/index";
+import { RAACNFT } from "../typechain-types";
+
+async function getAllTokens(
+	chainId: ChainId,
+	provider: Provider,
+	pagination?: { offset: number; limit: number }
+) {
+	try {
+		const raacNFTAddress = getContractAddress(chainId, "raacnft");
+		const raacNFTABI = getABI("raacnft");
+
+		const raacNFTContract = new ethers.Contract(
+			raacNFTAddress,
+			raacNFTABI,
+			provider
+		) as any as RAACNFT;
+
+		const totalSupply = await raacNFTContract.totalSupply();
+		if (totalSupply === 0n) {
+			return [];
+		}
+
+		let tokens: bigint[] = [];
+		if (pagination) {
+			const offset = pagination?.offset || 0;
+			const limit = pagination?.limit || 10;
+
+			const start = offset;
+			const end = Math.min(offset + limit, Number(totalSupply)) || totalSupply;
+			console.log(offset, limit, start, end);
+
+			tokens = await raacNFTContract["getAllTokens(uint256,uint256)"](
+				start,
+				end
+			);
+		} else {
+			tokens = await raacNFTContract["getAllTokens()"]();
+		}
+
+		return tokens;
+	} catch (error: any) {
+		console.error("Error getting all tokens:", error);
+		throw new Error(`Failed to get all tokens: ${error.message}`);
+	}
+}
+
+export default getAllTokens;

package/nfts/getBaseUri.ts

@@ -0,0 +1,32 @@
+import { ethers, Provider, Signer } from "ethers";
+import { getContractAddress } from "../utils/contracts";
+import { getABI } from "../utils/artifacts";
+import { ChainId } from "../configs/chains/index";
+import { RAACNFT } from "../typechain-types";
+
+async function getBaseUri(chainId: ChainId, provider: Provider) {
+	if (!provider) {
+		throw new Error("Wallet not connected");
+	}
+
+	try {
+		const raacNFTAddress = getContractAddress(chainId, "raacnft");
+		const raacNFTABI = getABI("raacnft");
+
+		const raacNFTContract = new ethers.Contract(
+			raacNFTAddress,
+			raacNFTABI,
+			provider
+		) as any as RAACNFT;
+
+		const uri = await raacNFTContract.baseURI();
+
+		console.log(`Retrieved base uri: ${uri}`);
+		return uri;
+	} catch (error: any) {
+		console.error("Error adding new batch:", error);
+		throw new Error(`Failed to add new batch: ${error.message}`);
+	}
+}
+
+export default getBaseUri;

package/nfts/getHousePrice.ts

@@ -0,0 +1,30 @@
+import { ethers, Provider } from "ethers";
+import { getContractAddress } from "../utils/contracts";
+import { getABI } from "../utils/artifacts";
+import { ChainId } from "../configs/chains/index";
+import { RAACNFT } from "../typechain-types";
+
+async function getHousePrice(
+	chainId: ChainId,
+	tokenId: number,
+	provider: Provider
+) {
+	try {
+		const raacNFTAddress = getContractAddress(chainId, "raacnft");
+		const raacNFTABI = getABI("raacnft");
+
+		const raacNFTContract = new ethers.Contract(
+			raacNFTAddress,
+			raacNFTABI,
+			provider
+		) as any as RAACNFT;
+
+		const price = await raacNFTContract.getHousePrice(tokenId);
+		return ethers.formatEther(price);
+	} catch (error: any) {
+		console.error("Error getting house price:", error);
+		throw new Error(`Failed to get house price: ${error.message}`);
+	}
+}
+
+export default getHousePrice;

package/nfts/getMintFeePercentage.ts

@@ -0,0 +1,33 @@
+import { Contract, ethers, Provider, Signer } from "ethers";
+import { getContractAddress } from "../utils/contracts";
+import { getABI } from "../utils/artifacts";
+import { ChainId } from "../configs/chains/index";
+import { RAACNFT } from "../typechain-types";
+
+async function getMintFeePercentage(chainId: ChainId, provider: Provider) {
+	if (!provider) {
+		throw new Error("Wallet not connected");
+	}
+
+	try {
+		const raacNFTAddress = getContractAddress(chainId, "raacnft");
+		const raacNFTABI = getABI("raacnft");
+
+		const raacNFTContract = new ethers.Contract(
+			raacNFTAddress,
+			raacNFTABI,
+			provider
+		) as any as RAACNFT;
+
+		const percentage =
+			(await raacNFTContract.MINT_FEE_PERCENTAGE()) / BigInt(10e5);
+
+		console.log(`Retrieved mint fee percentage: ${percentage}`);
+		return percentage;
+	} catch (error: any) {
+		console.log("Error retrieving mint fee percentage", error);
+		throw new Error(`Failed to retrieve mint fee percentage: ${error.message}`);
+	}
+}
+
+export default getMintFeePercentage;

package/nfts/getMintPrice.ts

@@ -0,0 +1,46 @@
+import { Contract, ethers, Provider, Signer } from "ethers";
+import { getContractAddress } from "../utils/contracts";
+import { getABI } from "../utils/artifacts";
+import { ChainId } from "../configs/chains/index";
+import { RAACNFT } from "../typechain-types";
+
+// This is the total price: includes the mint price and the mint fee
+async function getMintPrice(
+	chainId: ChainId,
+	tokenId: string | number,
+	provider: Provider
+) {
+	if (!provider) {
+		throw new Error("Wallet not connected");
+	}
+
+	try {
+		const raacNFTAddress = getContractAddress(chainId, "raacnft");
+		const raacNFTABI = getABI("raacnft");
+
+		const raacNFTContract = new ethers.Contract(
+			raacNFTAddress,
+			raacNFTABI,
+			provider
+		) as any as RAACNFT;
+
+		const price = await raacNFTContract.getMintPrice(tokenId);
+		const token = await raacNFTContract.token();
+		const tokenContract = new Contract(
+			token,
+			["function decimals() view returns (uint8)"],
+			provider
+		);
+		const decimals = await tokenContract.decimals();
+
+		const formattedValue = ethers.formatUnits(price, await decimals.decimals());
+
+		console.log(`Retrieved house price for ${tokenId}: ${formattedValue}`);
+		return { price, decimals };
+	} catch (error: any) {
+		console.error("Error retrieving mint price for " + tokenId, error);
+		throw new Error(`Failed retrieve mint price: ${error.message}`);
+	}
+}
+
+export default getMintPrice;