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

package/contracts/housePrices/getLatestPrice.ts

@@ -0,0 +1,38 @@
+import { ethers, Provider } from "ethers";
+import { getContractAddress } from "../../utils/contracts";
+import { getABI } from "../../utils/artifacts";
+import { ChainId } from "../../configs/chains/index";
+import { RAACHousePrices } from "../../typechain-types";
+
+async function getLatestPrice(
+	chainId: ChainId,
+	tokenId: string,
+	provider: Provider
+) {
+	try {
+		const raacHousePricesAddress = getContractAddress(
+			chainId,
+			"raachouseprices"
+		);
+		const raacHousePricesABI = getABI("raachouseprices");
+
+		const raacHousePricesContract = new ethers.Contract(
+			raacHousePricesAddress,
+			raacHousePricesABI,
+			provider
+		) as any as RAACHousePrices;
+
+		const [price, timestamp] = await raacHousePricesContract.getLatestPrice(
+			tokenId
+		);
+
+		return { price, timestamp };
+	} catch (error: any) {
+		console.error("Error getting latest price:", error);
+		return { price: -1n, timestamp: -1 };
+		// console.error('Error getting latest price:', error);
+		// throw new Error(`Failed to get latest price: ${error.message}`);
+	}
+}
+
+export default getLatestPrice;

package/contracts/housePrices/setOracle.ts

@@ -0,0 +1,40 @@
+import { ethers, Signer } from "ethers";
+import { getContractAddress } from "../../utils/contracts";
+import { getABI } from "../../utils/artifacts";
+import { ChainId } from "../../configs/chains/index";
+import { RAACHousePrices } from "../../typechain-types";
+
+async function setOracle(
+	chainId: ChainId,
+	newOracleAddress: string,
+	signer: Signer
+) {
+	if (!signer) {
+		throw new Error("Wallet not connected");
+	}
+
+	try {
+		const raacHousePricesAddress = getContractAddress(
+			chainId,
+			"raachouseprices"
+		);
+		const raacHousePricesABI = getABI("raachouseprices");
+
+		const raacHousePricesContract = new ethers.Contract(
+			raacHousePricesAddress,
+			raacHousePricesABI,
+			signer
+		) as any as RAACHousePrices;
+
+		const tx = await raacHousePricesContract.setOracle(newOracleAddress);
+		await tx.wait();
+
+		console.log(`Oracle address updated to: ${newOracleAddress}`);
+		return tx;
+	} catch (error: any) {
+		console.error("Error setting oracle:", error);
+		throw new Error(`Failed to set oracle: ${error.message}`);
+	}
+}
+
+export default setOracle;

package/contracts/indexToken/getNextRandomNFT.ts

@@ -0,0 +1,38 @@
+import { ethers, Provider } from "ethers";
+import { getContractAddress } from "../../contracts/getContractAddress";
+import { getABI } from "../../utils/artifacts";
+import { ChainId } from "../../configs/chains/index";
+import { IndexToken } from "../../typechain-types";
+
+async function getNextRandomNFT(chainId: ChainId, provider: Provider) {
+	try {
+		const indexTokenAddress = getContractAddress(chainId, "indextoken");
+		const indexTokenABI = getABI("indextoken");
+		const indexTokenContract = new ethers.Contract(
+			indexTokenAddress,
+			indexTokenABI,
+			provider
+		) as any as IndexToken;
+
+		const totalNFTs = await indexTokenContract.getTokensLength();
+		if (totalNFTs === 0n) {
+			return {
+				nftContract: null,
+				tokenId: null,
+			};
+		}
+		const redemptionToken = await indexTokenContract.getNextRandomNFT();
+
+		const token = {
+			nftContract: redemptionToken[0],
+			tokenId: redemptionToken[1],
+		};
+
+		return token;
+	} catch (error: any) {
+		console.error("Error in claimReward:", error);
+		throw error;
+	}
+}
+
+export default getNextRandomNFT;

package/contracts/indexToken/redeemNFT.ts

@@ -0,0 +1,65 @@
+import { ethers, parseEther, Signer } from "ethers";
+import { getContractAddress } from "../getContractAddress";
+import { getABI } from "../../utils/artifacts";
+import { ChainId } from "../../configs/chains/index";
+import { IndexToken } from "../../typechain-types";
+import getNextRandomNFT from "./getNextRandomNFT";
+import getBalance from "../../wallet/assets/getBalance";
+
+async function redeemNFT(chainId: ChainId, signer: Signer) {
+	try {
+		const indexTokenAddress = getContractAddress(chainId, "indextoken");
+		const indexTokenABI = getABI("indextoken");
+		const indexTokenContract = new ethers.Contract(
+			indexTokenAddress,
+			indexTokenABI,
+			signer
+		) as any as IndexToken;
+
+		const redemptionToken = await getNextRandomNFT(chainId, signer.provider);
+		if (redemptionToken === null) {
+			console.log("No NFTs to redeem");
+			return;
+		}
+
+		const price = await indexTokenContract.getNFTPrice(
+			redemptionToken.nftContract,
+			redemptionToken.tokenId
+		);
+		console.log(
+			`Redeeming NFT ${redemptionToken.nftContract} ${redemptionToken.tokenId} for ${price} INDEX`
+		);
+
+		const balance = parseEther(
+			(
+				await getBalance(
+					chainId,
+					"indextoken",
+					await signer.getAddress(),
+					signer.provider
+				)
+			).toString()
+		);
+		if (balance < price) {
+			console.log(
+				`Insufficient balance to redeem NFT. Balance: ${balance}, Required: ${price}`
+			);
+			return;
+		}
+
+		const tx = await indexTokenContract.redeem(price);
+		const receipt = await tx.wait();
+
+		console.log(
+			`Redeemed NFT ${redemptionToken.nftContract} ${redemptionToken.tokenId} for ${price} INDEX`
+		);
+		console.log(`Transaction hash: ${receipt?.hash}`);
+
+		return receipt;
+	} catch (error: any) {
+		console.error("Error in redeemNFT:", error);
+		throw error;
+	}
+}
+
+export default redeemNFT;

package/contracts/rcrvUSDToken/getBalance.ts

@@ -0,0 +1,23 @@
+import { ethers } from "ethers";
+import { ChainId, configs } from "../../configs/chains";
+import { ERC20 } from "../../typechain-types";
+
+const BALANCE_OF_ABI =
+	"function balanceOf(address account) view returns (uint256)";
+
+export const getBalance = async (
+	chainId: ChainId,
+	contractAddress: string,
+	address: string
+) => {
+	const rpc = configs[chainId].rpcs[0];
+	const provider = new ethers.JsonRpcProvider(rpc);
+
+	const contract = new ethers.Contract(
+		contractAddress,
+		[BALANCE_OF_ABI],
+		provider
+	) as any as ERC20;
+	const balance = await contract.balanceOf(address);
+	return ethers.formatEther(balance);
+};

package/contracts/rcrvUSDToken/getTotalSupply.ts

@@ -0,0 +1,39 @@
+import { ethers, Provider } from "ethers";
+import configs, { ChainId } from "../../configs/chains";
+import { ERC20 } from "../../typechain-types";
+
+const TOTAL_SUPPLY_ABI = "function totalSupply() view returns (uint256)";
+
+/**
+ *
+ * @param {string} contractAddress
+ * @param {number} chainId
+ * @param {ethers.JsonRpcProvider} [provider]
+ * @returns {Promise<string>}
+ */
+export const getTotalSupply = async (
+	chainId: ChainId,
+	contractAddress: string,
+	provider: Provider
+) => {
+	if (!provider) {
+		if (!chainId) {
+			throw new Error("Contract address not found in any chain configuration");
+		}
+		const rpc = configs[chainId].rpcs[0];
+		provider = new ethers.JsonRpcProvider(rpc);
+	}
+
+	console.log(
+		`Getting total supply for ${contractAddress} on ${
+			(await provider.getNetwork()).chainId
+		} using provider ${provider}`
+	);
+	const contract = new ethers.Contract(
+		contractAddress,
+		[TOTAL_SUPPLY_ABI],
+		provider
+	) as any as ERC20;
+	const totalSupply = await contract.totalSupply();
+	return ethers.formatEther(totalSupply);
+};

package/contracts/zeno/createAuction.ts

@@ -0,0 +1,57 @@
+import { ethers, Signer } from "ethers";
+import { getContractAddress } from "../../utils/contracts";
+import { getABI } from "../../utils/artifacts";
+import { ChainId } from "../../configs/chains/index";
+import { AuctionFactory } from "../../typechain-types";
+
+async function createAuction(
+	chainId: ChainId,
+	zenoAddress: string,
+	usdcAddress: string,
+	businessAddress: string,
+	auctionStartTime: bigint,
+	auctionEndTime: bigint,
+	startingPrice: bigint,
+	reservePrice: bigint,
+	totalZenoAllocated: bigint,
+	signer: Signer
+) {
+	if (!signer) {
+		throw new Error("Wallet not connected");
+	}
+
+	try {
+		const auctionFactoryAddress = getContractAddress(chainId, "auctionfactory");
+		const auctionFactoryABI = getABI("auctionfactory");
+
+		const auctionFactoryContract = new ethers.Contract(
+			auctionFactoryAddress,
+			auctionFactoryABI,
+			signer
+		) as any as AuctionFactory;
+
+		const tx = await auctionFactoryContract.createAuction(
+			zenoAddress,
+			usdcAddress,
+			businessAddress,
+			auctionStartTime,
+			auctionEndTime,
+			startingPrice,
+			reservePrice,
+			totalZenoAllocated
+		);
+		await tx.wait();
+
+		const auctionsCount = await auctionFactoryContract.getAuctionCount();
+		const auctionAddress = await auctionFactoryContract.getAuction(
+			auctionsCount - BigInt(1)
+		);
+
+		console.log(`Zeno auction created at address: ${auctionAddress}`);
+	} catch (error: any) {
+		console.error("Error creating zeno auction:", error);
+		throw new Error(`Failed to create zeno auction: ${error.message}`);
+	}
+}
+
+export default createAuction;

package/contracts/zeno/createZeno.ts

@@ -0,0 +1,47 @@
+import { ethers, Signer } from "ethers";
+import { getContractAddress } from "../../utils/contracts";
+import { getABI } from "../../utils/artifacts";
+import { ChainId } from "../../configs/chains/index";
+import { ZENOFactory } from "../../typechain-types";
+
+async function createZeno(
+	chainId: ChainId,
+	usdcAddress: string,
+	maturityDate: string,
+	signer: Signer
+) {
+	if (!signer) {
+		throw new Error("Wallet not connected");
+	}
+
+	try {
+		const zenoFactoryAddress = getContractAddress(chainId, "zenofactory");
+		const zenoFactoryABI = getABI("zenofactory");
+
+		const zenoFactoryContract = new ethers.Contract(
+			zenoFactoryAddress,
+			zenoFactoryABI,
+			signer
+		) as any as ZENOFactory;
+
+		const tx = await zenoFactoryContract.createZENOContract(
+			usdcAddress,
+			maturityDate
+		);
+		await tx.wait();
+
+		const zenosCount = await zenoFactoryContract.getZENOCount();
+		const zenoAddress = await zenoFactoryContract.getZENO(
+			zenosCount - BigInt(1)
+		);
+
+		console.log(`Zeno created at address: ${zenoAddress}`);
+
+		return zenoAddress;
+	} catch (error: any) {
+		console.error("Error creating zeno:", error);
+		throw new Error(`Failed to create zeno: ${error.message}`);
+	}
+}
+
+export default createZeno;

package/contracts/zeno/getAuctions.ts

@@ -0,0 +1,38 @@
+import { ethers, Signer } from "ethers";
+import { getContractAddress } from "../../utils/contracts";
+import { getABI } from "../../utils/artifacts";
+import { ChainId } from "../../configs/chains/index";
+import { AuctionFactory } from "../../typechain-types";
+
+async function getAuctions(chainId: ChainId, signer: Signer) {
+	if (!signer) {
+		throw new Error("Wallet not connected");
+	}
+
+	try {
+		const auctionFactoryAddress = getContractAddress(chainId, "auctionfactory");
+		const auctionFactoryABI = getABI("auctionfactory");
+
+		const auctionFactoryContract = new ethers.Contract(
+			auctionFactoryAddress,
+			auctionFactoryABI,
+			signer
+		) as any as AuctionFactory;
+
+		const auctionsCount = await auctionFactoryContract.getAuctionCount();
+		const auctions = [];
+
+		for (let i = 0; i < auctionsCount; i++) {
+			const auction = await auctionFactoryContract.getAuctionDetails(i);
+			auctions.push(auction);
+		}
+
+		console.log(`Auctions: ${auctions}`);
+		return auctions;
+	} catch (error: any) {
+		console.error("Error getting auctions:", error);
+		throw new Error(`Failed to get auctions: ${error.message}`);
+	}
+}
+
+export default getAuctions;

package/contracts/zeno/getZenos.ts

@@ -0,0 +1,38 @@
+import { ethers, Signer } from "ethers";
+import { getContractAddress } from "../../utils/contracts";
+import { getABI } from "../../utils/artifacts";
+import { ChainId } from "../../configs/chains/index";
+import { ZENO, ZENOFactory } from "../../typechain-types";
+
+async function getZenos(chainId: ChainId, signer: Signer) {
+	if (!signer) {
+		throw new Error("Wallet not connected");
+	}
+
+	try {
+		const zenoFactoryAddress = getContractAddress(chainId, "zenofactory");
+		const zenoFactoryABI = getABI("zenofactory");
+
+		const zenoFactoryContract = new ethers.Contract(
+			zenoFactoryAddress,
+			zenoFactoryABI,
+			signer
+		) as any as ZENOFactory;
+
+		const zenosCount = await zenoFactoryContract.getZENOCount();
+		const zenos = [];
+
+		for (let i = 0; i < zenosCount; i++) {
+			const zeno = await zenoFactoryContract.getZENODetails(i);
+			zenos.push(zeno);
+		}
+
+		console.log(`Zenos: ${zenos}`);
+		return zenos;
+	} catch (error: any) {
+		console.error("Error getting zenos:", error);
+		throw new Error(`Failed to get zenos: ${error.message}`);
+	}
+}
+
+export default getZenos;

package/custom-types.d.ts

@@ -0,0 +1,20 @@
+export type Reserve = {
+	reserveRTokenAddress: string;
+	reserveAssetAddress: string;
+	reserveDebtTokenAddress: string;
+	totalLiquidity: bigint;
+	totalUsage: bigint;
+	liquidityIndex: bigint;
+	usageIndex: bigint;
+	lastUpdateTimestamp: bigint;
+};
+export type RawData = {
+	currentLiquidityRate: bigint;
+	currentUsageRate: bigint;
+	primeRate: bigint;
+	baseRate: bigint;
+	optimalRate: bigint;
+	maxRate: bigint;
+	optimalUtilizationRate: bigint;
+	protocolFeeRate: bigint;
+};

package/dist/configs/chains/11155111.json

@@ -0,0 +1,132 @@
+{
+    "chainId": 11155111,
+    "name": "sepolia",
+    "rpcs": ["https://sepolia.infura.io/v3/38126531f7b3458d80e5a822dfbf5854"],
+    "nativeCurrency": {
+        "name": "ETH",
+        "symbol": "ETH",
+        "decimals": 18
+    },
+    "blockExplorer": [
+        {
+            "name": "Etherscan",
+            "url": "https://sepolia.etherscan.io"
+        }
+    ],
+    "contracts": {
+        "raachouseprices": {
+            "id": "raachouseprices",
+            "name": "RAAC House Prices",
+            "contract": "0xA151fE9b3F225Ed575D0775c3Db096F14Ead5A0c"
+        },
+        "raacprimerateoracle": {
+            "id": "raacprimerateoracle",
+            "name": "RAAC Prime Rate Oracle",
+            "contract": "0xB710417257e2bcf66759149812e9B5dA97cEcaFF"
+        },
+        "auctionfactory": {
+            "id": "auctionfactory",
+            "name": "Auction Factory",
+            "contract": "0xC644A84734A7329eE46d3B6704746179d272f990"
+        },
+        "zenofactory": {
+            "id": "zenofactory",
+            "name": "Zeno Factory",
+            "contract": "0xa9eE59A113bCB4B2CC10f802D1efF0Bae1Ab91D2"
+        },
+        "raacminter": {
+            "id": "raacminter",
+            "name": "RAAC Minter",
+            "contract": "0xC9D00720F535dBDBf94472066A3fBba05471aA1f"
+        },
+        "feecollector": {
+            "id": "feecollector",
+            "name": "Fee Collector",
+            "contract": "0x0a4c1755e9d76cdE0361EB6cDF77824cb06C8a98"
+        },
+        "treasury": {
+            "id": "treasury",
+            "name": "Treasury",
+            "contract": "0xEaA6082460b2a1Cb2059551A5e368d7bB410D94c"
+        },
+        "repairfund": {
+            "id": "repairfund",
+            "name": "Repair Fund",
+            "contract": "0x39184F690a71C2978Af392caE86853006D4df97b"
+        },
+        "releaseorchestrator": {
+            "id": "releaseorchestrator",
+            "name": "Release Orchestrator",
+            "contract": "0x3758d904c69d2C56b89f4b5BbD2c1B1D74773830"
+        }
+    },
+    "pools": {
+        "stabilitypool": {
+            "id": "stabilitypool",
+            "name": "Stability Pool",
+            "contract": "0xCDc21F23A946Ab63bdF941677AE19dC5aBdD5011"
+        },
+        "lendingpool": {
+            "id": "lendingpool",
+            "name": "Lending Pool",
+            "contract": "0x98981d5Ae694d8a63d008c1763716ae26e36A9A7"
+        }
+    },
+    "nfts": {
+        "raacnft": {
+            "id": "raacnft",
+            "name": "RAAC NFT",
+            "contract": "0xc986D2750327EA6454d16cE2cD00BA62421dd0bC"
+        }
+    },
+    "assets": {
+        "eth": {
+            "id": "eth",
+            "name": "ETH",
+            "decimals": 18,
+            "contract": "0x0000000000000000000000000000000000000000"
+        },
+        "crvusd": {
+            "id": "crvusd",
+            "name": "CRVUSD",
+            "decimals": 18,
+            "contract": "0x0eeFb2Edd6865fdDA929dDAEB87701C34CE6B1A3"
+        },
+        "rtoken": {
+            "id": "rtoken",
+            "name": "RToken",
+            "decimals": 18,
+            "contract": "0x9c0Aae91BeA71737EE802cb29EAA15a279cE58E6"
+        },
+        "detoken": {
+            "id": "detoken",
+            "name": "DEToken",
+            "decimals": 18,
+            "contract": "0x8F499A9303e90a3Df10D6B3C435f78B6b6c0b503"
+        },
+        "raactoken": {
+            "id": "raactoken",
+            "name": "RAAC",
+            "decimals": 18,
+            "contract": "0x1503F1fE0c451214D9555F524E12984858202cC6"
+        },
+        "veraac": {
+            "id": "veraac",
+            "name": "VERAAC",
+            "decimals": 18,
+            "contract": "0x2a2d358cdC342f58911Fb8d569E6aA66f564e0D2"
+        },
+        "debttoken": {
+            "id": "debttoken",
+            "name": "Debt Token",
+            "decimals": 18,
+            "contract": "0xf6e002A1E60955d006C5EC1c4Eb74677B73Fba13"
+        },
+        "indextoken": {
+            "id": "indextoken",
+            "name": "Index Token",
+            "decimals": 18,
+            "contract": "0x3A663C401AdF767d710C7f0133DF40eA18F24863"
+        }
+    }
+}

package/dist/configs/chains/index.js

@@ -7,9 +7,11 @@ exports.configs = void 0;
 // @ts-ignore
 const _8453_json_1 = __importDefault(require("./8453.json")); // assert { type: "json" };
 const _17000_json_1 = __importDefault(require("./17000.json")); // assert { type: "json" };
+const _11155111_json_1 = __importDefault(require("./11155111.json")); // assert { type: "json" };
 const chains = {
     8453: _8453_json_1.default,
     17000: _17000_json_1.default, // the interface is the same for all the chains, so taking this
+    11155111: _11155111_json_1.default,
 };
 exports.default = chains;
 exports.configs = chains;

package/dist/methods/commons/estimateGasPrice.js

@@ -5,9 +5,14 @@ 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: feeData.maxFeePerGas,
-            maxPriorityFeePerGas: feeData.maxPriorityFeePerGas,
+            maxFeePerGas,
+            maxPriorityFeePerGas,
         };
     }
     catch (error) {

package/dist/types/configs/chains/index.d.ts

@@ -1,12 +1,14 @@
-import { Chain8453 } from "./chain";
+import { Chain8453, Chain11155111 } from "./chain";
 declare const chains: {
     8453: Chain8453;
     17000: Chain8453;
+    11155111: Chain11155111;
 };
 export default chains;
 export declare const configs: {
     8453: Chain8453;
     17000: Chain8453;
+    11155111: Chain11155111;
 };
 export type Configs = typeof chains;
 export type ConfigKeys = keyof Configs;

package/dist/types/configs/index.d.ts

@@ -2,6 +2,7 @@ import { ChainId } from "./chains/index";
 declare function getChainsConfig(): {
     8453: import("./chains/chain").Chain8453;
     17000: import("./chains/chain").Chain8453;
+    11155111: import("./chains/chain").Chain11155111;
 };
 declare function setChainConfig(chainId: ChainId, config: any): void;
 declare function getChainConfig(chainId: ChainId): any;

package/dist/types/utils/contracts.d.ts

@@ -4,6 +4,7 @@ import { ethers, Provider } from "ethers";
 export declare const getConfigs: () => {
     8453: import("../configs/chains/chain").Chain8453;
     17000: import("../configs/chains/chain").Chain8453;
+    11155111: import("../configs/chains/chain").Chain11155111;
 };
 export declare const setOverrideConfig: (chainId: ChainId, newConfig: any) => void;
 export declare const getConfig: (chainId: ChainId) => any;
@@ -17,6 +18,7 @@ declare const _default: {
     getConfigs: () => {
         8453: import("../configs/chains/chain").Chain8453;
         17000: import("../configs/chains/chain").Chain8453;
+        11155111: import("../configs/chains/chain").Chain11155111;
     };
 };
 export default _default;

package/index.ts

@@ -0,0 +1,3 @@
+import RPCLibrary from "./RPCLibrary";
+
+export default RPCLibrary;