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

package/pools/stabilityPool/getStabilityPoolInfo.js

@@ -0,0 +1,109 @@
+import { ethers } from "ethers";
+import getContractAddress from "../../contracts/getContractAddress";
+import { getABI } from "../../utils/artifacts";
+
+async function getStabilityPoolInfo(
+	chainId,
+	address,
+	provider
+) {
+	try {
+		const stabilityPoolAddress = getContractAddress(chainId, "stabilitypool");
+		const abi = getABI("stabilitypool");
+		const stabilityPoolContract = new ethers.Contract(
+			stabilityPoolAddress,
+			abi,
+			provider
+		);
+
+		const handleError = (operation) => (error) => {
+			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 = 0n;
+
+		if (raacMinterAddress && raacMinterAddress !== ethers.ZeroAddress) {
+			const raacMinterABI = getABI("raacminter");
+			const raacMinterContract = new ethers.Contract(
+				raacMinterAddress,
+				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) {
+		console.error("Error fetching stability pool info:", error);
+		throw error;
+	}
+}
+
+export default getStabilityPoolInfo;

package/pools/stabilityPool/getStabilityPoolTotalDeposits.js

@@ -0,0 +1,25 @@
+import { ethers } from "ethers";
+import getContractAddress from "../../contracts/getContractAddress";
+import { getABI } from "../../utils/artifacts";
+
+async function getStabilityPoolTotalDeposits(
+	chainId,
+	provider
+) {
+	try {
+		const stabilityPoolAddress = getContractAddress(chainId, "stabilitypool");
+		const abi = getABI("stabilitypool");
+		const stabilityPoolContract = new ethers.Contract(
+			stabilityPoolAddress,
+			abi,
+			provider
+		);
+		const totalDeposits = await stabilityPoolContract.getTotalDeposits();
+		return totalDeposits;
+	} catch (error) {
+		console.error("Error fetching total deposits:", error);
+		throw error;
+	}
+}
+
+export default getStabilityPoolTotalDeposits;

package/pools/stabilityPool/methods/commons/estimateGasPrice.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.estimateGasPrice = void 0;
+const estimateGasPrice = async (signer) => {
+    const provider = signer.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) {
+        console.log("Error getting gas price", error);
+        if (provider === null || provider === void 0 ? void 0 : provider.getGasPrice) {
+            const gasPrice = await provider.getGasPrice();
+            return { gasPrice };
+        }
+        return { gasPrice: 0 };
+    }
+};
+exports.estimateGasPrice = estimateGasPrice;
+exports.default = exports.estimateGasPrice;

package/pools/stabilityPool/pools/stabilityPool/withdrawFromStabilityPool.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ethers_1 = require("ethers");
+const contracts_1 = require("../../utils/contracts");
+const artifacts_1 = require("../../utils/artifacts");
+const estimateGasPrice_1 = __importDefault(require("../../methods/commons/estimateGasPrice"));
+async function withdrawFromStabilityPool(chainId, amount, signer) {
+    if (!signer) {
+        throw new Error("Wallet not connected");
+    }
+    try {
+        const stabilityPoolAddress = (0, contracts_1.getContractAddress)(chainId, "stabilitypool");
+        const abi = (0, artifacts_1.getABI)("stabilitypool");
+        const stabilityPoolContract = new ethers_1.ethers.Contract(stabilityPoolAddress, abi, signer);
+        const amountInWei = ethers_1.ethers.parseEther(amount);
+        const { maxFeePerGas } = await (0, estimateGasPrice_1.default)(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 === null || receipt === void 0 ? void 0 : receipt.hash);
+        return receipt;
+    }
+    catch (error) {
+        console.error(`Error withdrawing from Stability Pool:`, error);
+        throw new Error(`Withdrawal from Stability Pool failed: ${error.message}`);
+    }
+}
+exports.default = withdrawFromStabilityPool;

package/pools/stabilityPool/utils/artifacts.js

@@ -0,0 +1,74 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ABIS = exports.getABI = void 0;
+const crvUSDToken_json_1 = __importDefault(require("../artifacts/mocks/core/tokens/crvUSDToken.sol/crvUSDToken.json")); // assert { type: "json" };
+const veRAACToken_json_1 = __importDefault(require("../artifacts/core/tokens/veRAACToken.sol/veRAACToken.json")); // assert { type: "json" };
+const RToken_json_1 = __importDefault(require("../artifacts/core/tokens/RToken.sol/RToken.json")); // assert { type: "json" };
+const LendingPool_json_1 = __importDefault(require("../artifacts/core/pools/LendingPool/LendingPool.sol/LendingPool.json")); // assert { type: "json" };
+const StabilityPool_json_1 = __importDefault(require("../artifacts/core/pools/StabilityPool/StabilityPool.sol/StabilityPool.json")); // assert { type: "json" };
+// import LiquidityPoolArtifact from "../artifacts/LiquidityPool/LiquidityPool.sol/LiquidityPool.json"; // assert { type: "json" };
+const RAACNFT_json_1 = __importDefault(require("../artifacts/core/tokens/RAACNFT.sol/RAACNFT.json")); // assert { type: "json" };
+const DEToken_json_1 = __importDefault(require("../artifacts/core/tokens/DEToken.sol/DEToken.json")); // assert { type: "json" };
+const RAACToken_json_1 = __importDefault(require("../artifacts/core/tokens/RAACToken.sol/RAACToken.json")); // assert { type: "json" };
+const RAACMinter_json_1 = __importDefault(require("../artifacts/core/minters/RAACMinter/RAACMinter.sol/RAACMinter.json")); // assert { type: "json" };
+const RAACHousePrices_json_1 = __importDefault(require("../artifacts/core/primitives/RAACHousePrices.sol/RAACHousePrices.json")); // assert { type: "json" };
+const AuctionFactory_json_1 = __importDefault(require("../artifacts/zeno/AuctionFactory.sol/AuctionFactory.json")); // assert { type: "json" };
+const Auction_json_1 = __importDefault(require("../artifacts/zeno/Auction.sol/Auction.json")); // assert { type: "json" };
+const ZenoFactory_json_1 = __importDefault(require("../artifacts/zeno/ZenoFactory.sol/ZenoFactory.json")); // assert { type: "json" };
+const Zeno_json_1 = __importDefault(require("../artifacts/zeno/Zeno.sol/Zeno.json")); // assert { type: "json" };
+const FeeCollector_json_1 = __importDefault(require("../artifacts/core/collectors/FeeCollector.sol/FeeCollector.json")); // assert { type: "json" };
+const IndexToken_json_1 = __importDefault(require("../artifacts/core/tokens/IndexToken.sol/IndexToken.json")); // assert { type: "json" };
+const MockVRFCoordinatorV2_json_1 = __importDefault(require("../artifacts/mocks/core/oracles/MockVRFCoordinatorV2.sol/MockVRFCoordinatorV2.json")); // assert { type: "json" };
+const BaseVRFv2Consumer_json_1 = __importDefault(require("../artifacts/core/oracles/BaseVRFv2Consumer.sol/BaseVRFv2Consumer.json")); // assert { type: "json" };
+const CRVUSD_ABI = crvUSDToken_json_1.default.abi;
+const RToken_json_2 = __importDefault(require("../artifacts/core/tokens/RToken.sol/RToken.json")); // assert { type: "json" }; // TODO: Isnt this same as rcrvusd?
+const RTOKEN_ABI = RToken_json_2.default.abi;
+const VERAAC_ABI = veRAACToken_json_1.default.abi;
+const RCRVUSD_ABI = RToken_json_1.default.abi;
+const DETOKEN_ABI = DEToken_json_1.default.abi;
+const RAACLENDINGPOOL_ABI = LendingPool_json_1.default.abi;
+const RAACSTABILITYPOOL_ABI = StabilityPool_json_1.default.abi;
+// const LIQUIDITYPOOL_ABI = LiquidityPoolArtifact.abi;
+const RAACMINTER_ABI = RAACMinter_json_1.default.abi;
+const RAACNFT_ABI = RAACNFT_json_1.default.abi;
+const RAACToken_ABI = RAACToken_json_1.default.abi;
+const RAACHOUSEPRICES_ABI = RAACHousePrices_json_1.default.abi;
+const FEECOLLECTOR_ABI = FeeCollector_json_1.default.abi;
+const ABIS = {
+    // Tokens
+    crvusd: CRVUSD_ABI,
+    // RAAC
+    raacnft: RAACNFT_ABI,
+    raactoken: RAACToken_ABI,
+    veraac: VERAAC_ABI,
+    // Pools tokens
+    rcrvusd: RCRVUSD_ABI,
+    rtoken: RTOKEN_ABI,
+    detoken: DETOKEN_ABI,
+    // Pools
+    lendingpool: RAACLENDINGPOOL_ABI,
+    stabilitypool: RAACSTABILITYPOOL_ABI,
+    // liquiditypool: LIQUIDITYPOOL_ABI,
+    raacminter: RAACMINTER_ABI,
+    // contracts
+    // contracts#raacHousePrices
+    raachouseprices: RAACHOUSEPRICES_ABI,
+    feecollector: FEECOLLECTOR_ABI,
+    // contracts#auction
+    auction: Auction_json_1.default.abi,
+    auctionfactory: AuctionFactory_json_1.default.abi,
+    zeno: Zeno_json_1.default.abi,
+    zenofactory: ZenoFactory_json_1.default.abi,
+    indextoken: IndexToken_json_1.default.abi,
+    mockvrfcoordinator: MockVRFCoordinatorV2_json_1.default.abi,
+    vrfconsumer: BaseVRFv2Consumer_json_1.default.abi,
+    eth: [],
+};
+exports.ABIS = ABIS;
+const getABI = (name) => {
+    return ABIS[name];
+};
+exports.getABI = getABI;

package/pools/stabilityPool/utils/contracts.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getContractAddress = exports.getContract = exports.getConfig = exports.setOverrideConfig = exports.getConfigs = void 0;
+const configs_1 = require("../configs");
+const chains_1 = require("../configs/chains");
+const artifacts_1 = require("./artifacts");
+const ethers_1 = require("ethers");
+let _config;
+let _configs;
+const getConfigs = () => {
+    if (!_configs) {
+        _configs = (0, configs_1.getChainsConfig)();
+    }
+    return _configs;
+};
+exports.getConfigs = getConfigs;
+const setOverrideConfig = (chainId, newConfig) => {
+    if (!_configs) {
+        _configs = (0, exports.getConfigs)();
+    }
+    // FIXME: configs is not defined here.
+    if (!chains_1.configs[chainId]) {
+        // @ts-ignore
+        chains_1.configs[chainId] = {};
+    }
+    chains_1.configs[chainId] = {
+        ...chains_1.configs[chainId],
+        ...newConfig,
+        contracts: {
+            ...chains_1.configs[chainId].contracts,
+            ...newConfig.contracts,
+        },
+    };
+};
+exports.setOverrideConfig = setOverrideConfig;
+const getConfig = (chainId) => {
+    const configs = (0, exports.getConfigs)();
+    if (!configs[chainId]) {
+        throw new Error(`Unsupported chain ID: ${chainId}. Has ${JSON.stringify(Object.keys(configs))}`);
+    }
+    return configs[chainId];
+};
+exports.getConfig = getConfig;
+const getContract = (chainId, contractName, provider) => {
+    const normalizedContractName = contractName.toLowerCase();
+    const address = (0, exports.getContractAddress)(chainId, normalizedContractName);
+    const abi = (0, artifacts_1.getABI)(normalizedContractName);
+    return new ethers_1.ethers.Contract(address, abi, provider);
+};
+exports.getContract = getContract;
+const getContractAddress = (chainId, contractName) => {
+    var _a;
+    const normalizedContractName = contractName.toLowerCase();
+    const config = (0, exports.getConfig)(chainId);
+    if (!config) {
+        throw new Error(`Unsupported chain ID: ${chainId}`);
+    }
+    const chainKeys = ["contracts", "assets", "pools", "nfts"];
+    const keys = Object.keys(config).filter((key) => chainKeys.includes(key));
+    let address = null;
+    for (const key of keys) {
+        if (config[key] && config[key][normalizedContractName]) {
+            address = (_a = config[key][normalizedContractName]) === null || _a === void 0 ? void 0 : _a.contract;
+            break;
+        }
+    }
+    if (!address) {
+        const hasIds = keys
+            .map((key) => `${key}: ${Object.keys(config[key]).join(", ")}`)
+            .join("\n");
+        throw new Error(`Contract ${normalizedContractName} not found for chain ID: ${chainId}.\nHas:\n${hasIds}`);
+    }
+    return address;
+};
+exports.getContractAddress = getContractAddress;
+exports.default = {
+    getContract: exports.getContract,
+    getContractAddress: exports.getContractAddress,
+    setOverrideConfig: exports.setOverrideConfig,
+    getConfig: exports.getConfig,
+    getConfigs: exports.getConfigs,
+};

package/pools/stabilityPool/withdrawFromStabilityPool.js

@@ -0,0 +1,45 @@
+import { ethers, Signer } from "ethers";
+import getContractAddress from "../../contracts/getContractAddress";
+import { getABI } from "../../utils/artifacts";
+import estimateGasPrice from "../../methods/commons/estimateGasPrice";
+
+async function withdrawFromStabilityPool(
+	chainId,
+	amount,
+	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
+		);
+
+		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) {
+		console.error(`Error withdrawing from Stability Pool:`, error);
+		throw new Error(`Withdrawal from Stability Pool failed: ${error.message}`);
+	}
+}
+
+export default withdrawFromStabilityPool;

package/scripts/index.js

@@ -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");