@raac/rpc 1.0.0

package/configs/createConfig.ts

@@ -0,0 +1,91 @@
+import { ChainId } from "./chains";
+
+function createConfig(chainId: ChainId) {
+	return {
+		chainId: chainId,
+		name: "Local",
+		rpcs: ["http://54.159.212.213:8545"],
+		contracts: {
+			raachouseprices: {
+				id: "raachouseprices",
+				name: "RAAC House Prices",
+				contract: "",
+			},
+			raacminter: {
+				id: "raacminter",
+				name: "RAAC Minter",
+				contract: "",
+			},
+
+			auctionfactory: {
+				id: "auctionfactory",
+				name: "Auction Factory",
+				contract: "",
+			},
+			zenofactory: {
+				id: "zenofactory",
+				name: "Zeno Factory",
+				contract: "",
+			},
+		},
+		pools: {
+			stabilitypool: {
+				id: "stabilitypool",
+				name: "Stability Pool",
+				contract: "",
+			},
+			lendingpool: {
+				id: "lendingpool",
+				name: "Lending Pool",
+				contract: "",
+			},
+		},
+		nfts: {
+			raacnft: {
+				id: "raacnft",
+				name: "RAAC NFT",
+				contract: "",
+			},
+		},
+		assets: {
+			eth: {
+				id: "eth",
+				name: "ETH",
+				decimals: 18,
+				contract: "0x0000000000000000000000000000000000000000",
+			},
+			crvusd: {
+				id: "crvusd",
+				name: "CRVUSD",
+				decimals: 18,
+				contract: "",
+			},
+			rtoken: {
+				id: "rtoken",
+				name: "RToken",
+				decimals: 18,
+				contract: "",
+			},
+			detoken: {
+				id: "detoken",
+				name: "DEtoken",
+				decimals: 18,
+				contract: "",
+			},
+			raactoken: {
+				id: "raactoken",
+				name: "RAAC",
+				decimals: 18,
+				contract: "",
+			},
+			veraac: {
+				id: "veraac",
+				name: "VERAAC",
+				decimals: 18,
+				contract: "",
+			},
+		},
+	};
+}
+
+export default createConfig;

package/configs/index.ts

@@ -0,0 +1,51 @@
+// let fs;
+// let path;
+// let fileURLToPath;
+
+// if (typeof window === 'undefined') {
+//   // Server-side
+// //   fs = import('fs');
+//   path = import('path');
+//   fileURLToPath = import('url').fileURLToPath;
+// }
+
+import { Chain } from "./chains/chain";
+import chains, { ChainId } from "./chains/index";
+
+function getChainsConfig() {
+	//   if (typeof window === 'undefined') {
+	//     // Server-side logic
+	//     const __filename = fileURLToPath(import.meta.url);
+	//     const __dirname = path.dirname(__filename);
+	//     const chainsDir = `${__dirname}/chains`;
+	//     const chainsFiles = fs.readdirSync(chainsDir).filter(file => file.endsWith('.json'));
+
+	//     const chains = {};
+	//     for(const chainFileName of chainsFiles) {
+	//       const chainId = chainFileName.split('.')[0];
+	//       const chainConfig = fs.readFileSync(`${chainsDir}/${chainFileName}`, 'utf8');
+	//       chains[chainId] = JSON.parse(chainConfig);
+	//     }
+	//     return chains;
+	//   } else {
+	//     const chainConfigs = {
+	//         8453: chain8453,
+	//     };
+	//     // Client-side logic via API ?
+	//     return chainConfigs;
+	//   }
+
+	return chains;
+}
+
+function setChainConfig(chainId: ChainId, config: any) {
+	chains[chainId] = config;
+}
+
+function getChainConfig(chainId: ChainId) {
+	const chains = getChainsConfig();
+	return chains[chainId];
+}
+
+export default { getChainsConfig, getChainConfig, setChainConfig };
+export { getChainsConfig, getChainConfig, setChainConfig };

package/contracts/crvUSDToken/getBalance.ts

@@ -0,0 +1,23 @@
+import { ethers } from "ethers";
+import 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: keyof typeof configs,
+	contractAddress: string,
+	address: string
+) => {
+	const rpc = configs[chainId].rpcs[0] as string;
+	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/crvUSDToken/getTotalSupply.ts

@@ -0,0 +1,36 @@
+import { ethers, Provider } from "ethers";
+import configs, { ConfigKeys } 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: ConfigKeys,
+	contractAddress: string,
+	provider: Provider
+) => {
+	console.log("Getting total supply for", contractAddress, "on chain", chainId);
+	if (!provider) {
+		console.log("Chain ID", chainId);
+		if (!chainId) {
+			throw new Error("Contract address not found in any chain configuration");
+		}
+		const rpc = configs[chainId].rpcs[0];
+		provider = new ethers.JsonRpcProvider(rpc);
+	}
+
+	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/getContract.ts

@@ -0,0 +1,21 @@
+import { ethers, Signer } from "ethers";
+import getContractAddress from "./getContractAddress";
+import { ChainId } from "../configs/chains/index";
+import { ContractType } from "../utils/artifacts";
+
+export default async function getContract(
+	chainId: ChainId,
+	contractName: ContractType,
+	signer: Signer
+) {
+	if (!signer) {
+		throw new Error("Signer is required");
+	}
+	const contractAddress = getContractAddress(chainId, contractName);
+
+	// You'll need to import the ABI for the contract. This is just a placeholder.
+	const abi: any[] = []; // Replace with actual ABI
+
+	const contract = new ethers.Contract(contractAddress, abi, signer);
+	return contract;
+}

package/contracts/getContractAddress.ts

@@ -0,0 +1,61 @@
+import { Chain } from "../configs/chains/chain";
+import configs, { ChainId } from "../configs/chains";
+import { ContractType } from "../utils/artifacts";
+
+/**
+ * Get the contract address for a given asset on a specific chain
+ * @param {number} chainId
+ * @param {string} contractName
+ * @returns {string}
+ */
+export const getContractAddress = (
+	chainId: ChainId,
+	contractName: ContractType
+) => {
+	const normalizedContractName = contractName.toLowerCase();
+
+	if (!chainId) {
+		throw new Error("Chain ID is required");
+	}
+
+	const config = configs[chainId];
+
+	if (!config) {
+		throw new Error(`Chain configuration not found for chainId: ${chainId}`);
+	}
+
+	const lookupKeys = [
+		"contracts",
+		"assets",
+		"pools",
+		"nfts",
+	] as (keyof Chain)[];
+
+	let address = null;
+	for (const key of lookupKeys) {
+		// @ts-ignore
+		if (config[key] && config[key][normalizedContractName]) {
+			// @ts-ignore
+			address =
+				// @ts-ignore
+				config[key][normalizedContractName].contract ||
+				// @ts-ignore
+				config[key][normalizedContractName];
+			break;
+		}
+	}
+
+	if (!address) {
+		console.error(
+			`Contract address not found for ${normalizedContractName} on chain ${chainId}`
+		);
+		console.error("Available contracts:", Object.keys(config.contracts));
+		throw new Error(
+			`Contract ${normalizedContractName} not found for chain ID: ${chainId}`
+		);
+	}
+
+	return address;
+};
+
+export default getContractAddress;

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: -1, 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/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 - 1n
+		);
+
+		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,45 @@
+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 - 1n);
+
+		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/index.ts

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

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;