@raac/rpc 1.0.0

package/README.md

@@ -0,0 +1 @@
+# rpc

package/RPCLibrary.ts

@@ -0,0 +1,358 @@
+import {
+	AddressLike,
+	Eip1193Provider,
+	ethers,
+	JsonRpcSigner,
+	Provider,
+	Signer,
+	Wallet,
+} from "ethers";
+// import { getContractAddress,getConfig } from './utils/contracts.js';
+// Commons
+import checkAllowance from "./methods/commons/checkAllowance";
+import estimateGasPrice from "./methods/commons/estimateGasPrice";
+
+import {
+	getChainsConfig,
+	getChainConfig,
+	setChainConfig,
+} from "./configs/index";
+
+// Assets
+import getAsset from "./assets/getAsset";
+import getSupply from "./assets/getSupply";
+import getAssets from "./assets/getAssets";
+// Pools
+// Pools#StabilityPool
+import getStabilityPoolInfo from "./pools/stabilityPool/getStabilityPoolInfo";
+import depositToStabilityPool from "./pools/stabilityPool/depositToStabilityPool";
+import withdrawFromStabilityPool from "./pools/stabilityPool/withdrawFromStabilityPool";
+import calculateRAACRewards from "./pools/stabilityPool/calculateRAACRewards";
+import getStabilityPoolTotalDeposits from "./pools/stabilityPool/getStabilityPoolTotalDeposits";
+
+// Pools#LendingPool
+import getLendingPoolInfo from "./pools/lendingPool/getLendingPoolInfo";
+import depositToLendingPool from "./pools/lendingPool/depositToLendingPool";
+import withdrawFromLendingPool from "./pools/lendingPool/withdrawFromLendingPool";
+import getLendingPoolTotalLiquidity from "./pools/lendingPool/getLendingPoolTotalLiquidity";
+import borrowFromLendingPool from "./pools/lendingPool/borrowFromLendingPool";
+import repayToLendingPool from "./pools/lendingPool/repayToLendingPool";
+
+// Pools#LiquidityPool
+// import getLiquidityPoolInfo from "./pools/liquidityPool/getLiquidityPoolInfo";
+
+import depositNFTToLendingPool from "./pools/lendingPool/depositNFTToLendingPool";
+import withdrawNFTFromLendingPool from "./pools/lendingPool/withdrawNFTFromLendingPool";
+
+import getHousePrice from "./pools/lendingPool/getHousePrice";
+
+// NFTs
+import mintNFT from "./nfts/mint";
+import getNFTHousePrice from "./nfts/getHousePrice";
+import addNewNFTBatch from "./nfts/addNewBatch";
+import setNFTBaseUri from "./nfts/setBaseUri";
+import getNFTCurrentBatchSize from "./nfts/getCurrentBatchSize";
+import getOwnedNFTs from "./nfts/getOwnedNFTs";
+// Contracts
+import getContractAddress from "./contracts/getContractAddress";
+import getContract from "./contracts/getContract";
+// House Prices
+import getLatestPrice from "./contracts/housePrices/getLatestPrice";
+import setOracle from "./contracts/housePrices/setOracle";
+
+// Minter
+import tick from "./minter/tick";
+import get from "./minter/get";
+import getApy from "./minter/getApy";
+
+// Wallet
+// Wallet#Assets
+import mintAsset from "./wallet/assets/mintAsset";
+import burnAsset from "./wallet/assets/burnAsset";
+import approveAsset from "./wallet/assets/approveAsset";
+import getWalletAssets from "./wallet/assets/getAssets";
+import getWalletAsset from "./wallet/assets/getAsset";
+import getWalletAllowance from "./wallet/assets/getAllowance";
+import getWalletBalance from "./wallet/assets/getBalance";
+import transferAsset from "./wallet/assets/transferAsset";
+
+// Zeno auctions
+import getAuctions from "./contracts/zeno/getAuctions";
+import createAuction from "./contracts/zeno/createAuction";
+import createZeno from "./contracts/zeno/createZeno";
+import getZenos from "./contracts/zeno/getZenos";
+import { ChainId } from "./configs/chains";
+import getDepositedNFTs from "./nfts/getDepositedNFTs";
+
+class RPCLibrary {
+	signer: Signer | null;
+	isConnected: boolean;
+	address: JsonRpcSigner | string;
+	chainId: ChainId | bigint | null;
+	privateKey: any;
+
+	// valid
+	assets: {
+		getAsset: typeof getAsset;
+		getAssets: typeof getAssets;
+		getSupply: typeof getSupply;
+	};
+	// valid
+	wallet: {
+		assets: {
+			getBalance: typeof getWalletBalance;
+			getAllowance: typeof getWalletAllowance;
+			getAsset: typeof getWalletAsset;
+			getAssets: typeof getWalletAssets;
+			transferAsset: typeof transferAsset;
+			approveAsset: typeof approveAsset;
+			mintAsset: typeof mintAsset;
+			burnAsset: typeof burnAsset;
+		};
+	};
+	nfts: {
+		mint: typeof mintNFT;
+		getHousePrice: typeof getNFTHousePrice;
+		getOwnedNFTs: typeof getOwnedNFTs;
+		getDepositedNFTs: typeof getDepositedNFTs;
+		addNewBatch: typeof addNewNFTBatch;
+		setBaseUri: typeof setNFTBaseUri;
+		getCurrentBatchSize: typeof getNFTCurrentBatchSize;
+	};
+	contracts: {
+		housePrices: {
+			getLatestPrice: typeof getLatestPrice;
+			setOracle: typeof setOracle;
+		};
+		minter: { tick: typeof tick; get: typeof get; getApy: typeof getApy };
+		getContractAddress: typeof getContractAddress;
+		getContract: typeof getContract;
+	};
+	pools: {
+		stabilityPool: {
+			getStabilityPoolInfo: typeof getStabilityPoolInfo;
+			depositToStabilityPool: typeof depositToStabilityPool;
+			withdrawFromStabilityPool: typeof withdrawFromStabilityPool;
+			calculateRAACRewards: typeof calculateRAACRewards;
+		};
+		// LendingPool
+		lendingPool: {
+			repayToLendingPool: typeof repayToLendingPool;
+			borrowFromLendingPool: typeof borrowFromLendingPool;
+			getHousePrice: typeof getHousePrice;
+			depositNFTToLendingPool: typeof depositNFTToLendingPool;
+			withdrawNFTFromLendingPool: typeof withdrawNFTFromLendingPool;
+			getLendingPoolInfo: typeof getLendingPoolInfo;
+		};
+		depositToLendingPool: typeof depositToLendingPool;
+		withdrawFromLendingPool: typeof withdrawFromLendingPool;
+		getLendingPoolTotalLiquidity: typeof getLendingPoolTotalLiquidity;
+		calculateRAACRewards: typeof calculateRAACRewards;
+		repayToLendingPool: typeof repayToLendingPool;
+		borrowFromLendingPool: typeof borrowFromLendingPool;
+		getHousePrice: typeof getHousePrice;
+		// StabilityPool
+		getStabilityPoolTotalDeposits: typeof getStabilityPoolTotalDeposits;
+		getStabilityPoolInfo: typeof getStabilityPoolInfo;
+		depositToStabilityPool: typeof depositToStabilityPool;
+		withdrawFromStabilityPool: typeof withdrawFromStabilityPool;
+	};
+	zeno: {
+		createAuction: typeof createAuction;
+		getAuctions: typeof getAuctions;
+		createZeno: typeof createZeno;
+		getZenos: typeof getZenos;
+	};
+	provider: any;
+
+	estimateGasPrice: any;
+	checkAllowance!: typeof checkAllowance;
+	getChainsConfig!: typeof getChainsConfig;
+	setChainsConfig!: typeof setChainConfig;
+
+	constructor(privateKey?: string) {
+		this.signer = null;
+		this.isConnected = false;
+		this.address = "";
+		this.chainId = null;
+
+		this.privateKey = privateKey;
+
+		this.assets = {
+			getAsset,
+			getAssets,
+			getSupply,
+		};
+		this.wallet = {
+			assets: {
+				getBalance: getWalletBalance,
+				getAllowance: getWalletAllowance,
+				getAsset: getWalletAsset,
+				getAssets: getWalletAssets,
+				transferAsset,
+				approveAsset,
+				mintAsset,
+				burnAsset,
+			},
+		};
+
+		this.nfts = {
+			mint: mintNFT,
+			getHousePrice: getNFTHousePrice,
+			getOwnedNFTs,
+			getDepositedNFTs,
+			addNewBatch: addNewNFTBatch,
+			setBaseUri: setNFTBaseUri,
+			getCurrentBatchSize: getNFTCurrentBatchSize,
+		};
+		this.contracts = {
+			housePrices: {
+				getLatestPrice,
+				setOracle,
+			},
+			minter: {
+				tick,
+				get,
+				getApy,
+			},
+			getContractAddress,
+			getContract,
+		};
+
+		this.pools = {
+			stabilityPool: {
+				getStabilityPoolInfo,
+				depositToStabilityPool,
+				withdrawFromStabilityPool,
+				calculateRAACRewards,
+			},
+			// LendingPool
+			lendingPool: {
+				repayToLendingPool,
+				borrowFromLendingPool,
+				getHousePrice,
+				depositNFTToLendingPool,
+				withdrawNFTFromLendingPool,
+				getLendingPoolInfo,
+			},
+			depositToLendingPool,
+			withdrawFromLendingPool,
+			getLendingPoolTotalLiquidity,
+			calculateRAACRewards,
+			repayToLendingPool,
+			borrowFromLendingPool,
+			getHousePrice,
+			// StabilityPool
+			getStabilityPoolTotalDeposits,
+			getStabilityPoolInfo,
+			depositToStabilityPool,
+			withdrawFromStabilityPool,
+		};
+		this.zeno = {
+			createAuction,
+			getAuctions,
+			createZeno,
+			getZenos,
+		};
+	}
+
+	async getWallet(privateKey: string, provider: Provider) {
+		if (typeof window !== "undefined" && window.ethereum) {
+			// Browser environment with MetaMask
+			await window.ethereum.request({ method: "eth_requestAccounts" });
+			const browserProvider = new ethers.BrowserProvider(window.ethereum);
+			const signer = await browserProvider.getSigner();
+			return signer;
+		} else {
+			const wallet = new ethers.Wallet(privateKey, provider);
+			return wallet;
+		}
+	}
+
+	async getProvider(chainId: ChainId) {
+		if (
+			typeof globalThis !== "undefined" &&
+			globalThis.window &&
+			typeof globalThis.window.ethereum !== "undefined"
+		) {
+			const provider = new ethers.BrowserProvider(globalThis.window.ethereum);
+			return provider;
+		}
+
+		const config = getChainConfig(chainId);
+		const rpcs = config.rpcs;
+		const provider = new ethers.JsonRpcProvider(rpcs[0]);
+		return provider;
+	}
+
+	async getSigner(chainId: ChainId, address: string) {
+		const provider = await this.getProvider(chainId);
+		const signer = await provider.getSigner(address);
+		return signer;
+	}
+
+	async connectWallet() {
+		if (
+			typeof globalThis !== "undefined" &&
+			globalThis.window &&
+			typeof globalThis.window.ethereum !== "undefined"
+		) {
+			try {
+				await globalThis.window.ethereum.request({
+					method: "eth_requestAccounts",
+				});
+				const provider = new ethers.BrowserProvider(globalThis.window.ethereum);
+				const network = await provider.getNetwork();
+				this.chainId = network.chainId;
+				this.signer = await provider.getSigner();
+				this.address = await this.signer.getAddress();
+				this.isConnected = true;
+			} catch (error: any) {
+				console.error("Failed to connect wallet:", error);
+				throw new Error(`Failed to connect wallet: ${error.message}`);
+			}
+		} else if (this.provider) {
+			// For non-browser environments, use the provider passed to the constructor
+			try {
+				const network = await this.provider.getNetwork();
+				this.chainId = network.chainId;
+				this.signer = new ethers.Wallet(this.privateKey, this.provider);
+				this.address = await this.signer.getAddress();
+				this.isConnected = true;
+			} catch (error: any) {
+				console.error("Failed to connect wallet:", error);
+				throw new Error(`Failed to connect wallet: ${error.message}`);
+			}
+		} else {
+			throw new Error("No provider available");
+		}
+	}
+
+	async checkConnection() {
+		if (typeof window.ethereum !== "undefined") {
+			const provider = new ethers.BrowserProvider(window.ethereum);
+			const network = await provider.getNetwork();
+			this.chainId = network.chainId;
+			const accounts = await provider.listAccounts();
+			if (accounts.length > 0) {
+				this.signer = await provider.getSigner();
+				this.isConnected = true;
+				this.address = accounts[0];
+			}
+		}
+	}
+
+	// Mine a block
+	async mineBlock(wallet: Eip1193Provider) {
+		const provider = new ethers.BrowserProvider(wallet);
+		await provider.send("evm_mine", []);
+		// await provider.send('evm_mine', []);
+	}
+}
+
+RPCLibrary.prototype.checkAllowance = checkAllowance;
+RPCLibrary.prototype.estimateGasPrice = estimateGasPrice;
+RPCLibrary.prototype.getChainsConfig = getChainsConfig;
+RPCLibrary.prototype.setChainsConfig = setChainConfig;
+
+export default RPCLibrary;

package/assets/getAsset.ts

@@ -0,0 +1,26 @@
+import getSupply from "./getSupply";
+import { getConfig } from "../utils/contracts";
+import { ChainId } from "../configs/chains";
+import { AssetType } from "../utils/artifacts";
+import { Provider } from "ethers";
+
+async function getAsset(
+	chainId: ChainId,
+	assetId: AssetType,
+	provider: Provider
+) {
+	try {
+		const { assets } = getConfig(chainId);
+		const asset = Object.values(assets).find((asset) => asset.id === assetId);
+		if (!asset) {
+			throw new Error(`Asset ${assetId} not found on chain ${chainId}`);
+		}
+		asset.supply = await getSupply(chainId, assetId, provider);
+		return asset;
+	} catch (error: any) {
+		console.error(`Error getting asset ${assetId}:`, error);
+		return 0;
+	}
+}
+
+export default getAsset;

package/assets/getAssets.ts

@@ -0,0 +1,30 @@
+import { Provider } from "ethers";
+import { ChainId } from "../configs/chains";
+import { getConfig } from "../utils/contracts";
+
+async function getAssets(chainId: ChainId, provider: Provider) {
+	const { assets } = getConfig(chainId);
+	const responses: any = {};
+
+	const assetIds = Object.keys(assets);
+	const assetPromises = assetIds.map(async (assetId) => {
+		// @ts-ignore
+		const asset = await this.getAsset(chainId, assetId, provider);
+		responses[assetId] = {
+			// @ts-ignore
+			...assets[assetId],
+			...asset,
+		};
+		return responses[assetId];
+	});
+	const assetsPromise = await Promise.all(assetPromises);
+
+	const response = {};
+	for (const asset of assetsPromise) {
+		// @ts-ignore
+		response[asset.id] = asset;
+	}
+	return response;
+}
+
+export default getAssets;

package/assets/getSupply.ts

@@ -0,0 +1,23 @@
+import { ethers, Provider } from "ethers";
+import { getContractAddress } from "../utils/contracts";
+import { ChainId } from "../configs/chains";
+import { AssetType } from "../utils/artifacts";
+
+async function getSupply(
+	chainId: ChainId,
+	assetId: AssetType,
+	provider: Provider
+) {
+	try {
+		const SUPPLY_ABI = ["function totalSupply() view returns (uint256)"];
+		const contractAddress = getContractAddress(chainId, assetId);
+		const contract = new ethers.Contract(contractAddress, SUPPLY_ABI, provider);
+		const supply = await contract.totalSupply();
+		return ethers.formatEther(supply);
+	} catch (error: any) {
+		console.error(`Error getting supply for asset ${assetId}:`, error);
+		return 0;
+	}
+}
+
+export default getSupply;

package/configs/chains/8453.json

@@ -0,0 +1,116 @@
+{
+	"chainId": 8453,
+	"name": "localhost",
+	"rpcs": ["http://127.0.0.1:8545"],
+	"nativeCurrency": {
+		"name": "ETH",
+		"symbol": "ETH",
+		"decimals": 18
+	},
+	"blockExplorer": [
+		{
+			"name": "Etherscan",
+			"url": "https://etherscan.io"
+		}
+	],
+	"contracts": {
+		"raachouseprices": {
+			"id": "raachouseprices",
+			"name": "RAAC House Prices",
+			"contract": "0x1B0a4142A467852271efC5DA8B6128D9f7e811dC"
+		},
+
+		"auctionfactory": {
+			"id": "auctionfactory",
+			"name": "Auction Factory",
+			"contract": "0xC644A84734A7329eE46d3B6704746179d272f990"
+		},
+		"zenofactory": {
+			"id": "zenofactory",
+			"name": "Zeno Factory",
+			"contract": "0xa9eE59A113bCB4B2CC10f802D1efF0Bae1Ab91D2"
+		},
+		"raacminter": {
+			"id": "raacminter",
+			"name": "RAAC Minter",
+			"contract": "0xa04684348f68cd82A028F51D643c60CA40b5dDa3"
+		},
+		"feecollector": {
+			"id": "feecollector",
+			"name": "Fee Collector",
+			"contract": "0x2AefD948d5F971F58B129b32B4AFf43fd3288D4b"
+		},
+		"treasury": {
+			"id": "treasury",
+			"name": "Treasury",
+			"contract": "0xF6B8c7b1F3886655A7F224F7b1F5EC5F7F5C0D1f"
+		},
+		"repairfund": {
+			"id": "repairfund",
+			"name": "Repair Fund",
+			"contract": "0x8d231e53b16005960f5227Cc245279d523188dBE"
+		},
+		"releaseorchestrator": {
+			"id": "releaseorchestrator",
+			"name": "Release Orchestrator",
+			"contract": "0xc9B0b1D3508Edb263699aEDf7100a266bE973Ff9"
+		}
+	},
+	"pools": {
+		"stabilitypool": {
+			"id": "stabilitypool",
+			"name": "Stability Pool",
+			"contract": "0x009a664dDE58c58F8d3006e23115106b7e5F144F"
+		},
+		"lendingpool": {
+			"id": "lendingpool",
+			"name": "Lending Pool",
+			"contract": "0x2e0c587b6D3723874b0B0cc994d42969455e14fc"
+		}
+	},
+	"nfts": {
+		"raacnft": {
+			"id": "raacnft",
+			"name": "RAAC NFT",
+			"contract": "0xF31622C2c5464605154c43b9e62dBa3e9De76C72"
+		}
+	},
+	"assets": {
+		"eth": {
+			"id": "eth",
+			"name": "ETH",
+			"decimals": 18,
+			"contract": "0x0000000000000000000000000000000000000000"
+		},
+		"crvusd": {
+			"id": "crvusd",
+			"name": "CRVUSD",
+			"decimals": 18,
+			"contract": "0x5130220647908B7d9d8cC8c05Ac5683a799A4471"
+		},
+		"rtoken": {
+			"id": "rtoken",
+			"name": "RToken",
+			"decimals": 18,
+			"contract": "0xB59dFCD4968540C9FE7D67Bb5C86AfD8f26A0Ab0"
+		},
+		"detoken": {
+			"id": "detoken",
+			"name": "DEToken",
+			"decimals": 18,
+			"contract": "0x848a59daCE7e021e18aB0f5cb03B7C4Fd9A79244"
+		},
+		"raactoken": {
+			"id": "raactoken",
+			"name": "RAAC",
+			"decimals": 18,
+			"contract": "0x97c72eEB8640Ce4646743dD07548B1Df85Be33F9"
+		},
+		"veraac": {
+			"id": "veraac",
+			"name": "VERAAC",
+			"decimals": 18,
+			"contract": "0x81bf888E0BD2B4184189FC165CE97531e3EC2F11"
+		}
+	}
+}

package/configs/chains/chain.d.ts

@@ -0,0 +1,87 @@
+export interface Chain {
+	chainId: number;
+	name: string;
+	rpcs: string[];
+	contracts: Contracts;
+	pools: Pools;
+	nfts: Nfts;
+	assets: Assets;
+	nativeCurrency: NativeCurrency;
+	blockExplorer: BlockExplorer[];
+}
+
+export interface BlockExplorer {
+	name: string;
+	url: string;
+}
+
+export interface Chain8453 extends Chain {
+	contracts: Contracts8453;
+	pools: Pools8453;
+	nfts: Nfts8453;
+	assets: Assets8453;
+}
+
+export interface NativeCurrency {
+	name: string;
+	symbol: string;
+	decimals: number;
+}
+
+export interface Contracts {
+	[contract: string]: DeployedContract;
+}
+
+export interface Contracts8453 {
+	raachouseprices: DeployedContract;
+	raacminter: DeployedContract;
+	auctionfactory: DeployedContract;
+	zenofactory: DeployedContract;
+	feecollector: DeployedContract;
+	treasury: DeployedContract;
+	repairfund: DeployedContract;
+	releaseorchestrator: DeployedContract;
+}
+
+export interface Pools {
+	[pool: string]: DeployedContract;
+}
+
+export interface Pools8453 {
+	stabilitypool: DeployedContract;
+	lendingpool: DeployedContract;
+}
+
+export interface Nfts {
+	[nft: string]: DeployedContract;
+}
+
+export interface Nfts8453 {
+	raacnft: DeployedContract;
+}
+
+export interface Assets {
+	[asset: string]: Asset;
+}
+
+export interface Assets8453 {
+	eth: Asset;
+	crvusd: Asset;
+	rtoken: Asset;
+	detoken: Asset;
+	raactoken: Asset;
+	veraac: Asset;
+}
+
+export interface DeployedContract {
+	id: string;
+	name: string;
+	contract: string;
+}
+
+export interface Asset {
+	id: string;
+	name: string;
+	decimals: number;
+	contract: string;
+}

package/configs/chains/index.ts

@@ -0,0 +1,13 @@
+// @ts-ignore
+import chain8453 from "./8453.json"; // assert { type: "json" };
+import { Chain, Chain8453 } from "./chain";
+
+const chains = {
+	8453: chain8453 as Chain8453,
+};
+
+export default chains;
+export const configs = chains;
+export type Configs = typeof chains;
+export type ConfigKeys = keyof Configs;
+export type ChainId = ConfigKeys | string | number;

package/configs/chains/list.json

@@ -0,0 +1,3 @@
+[
+    "8453"
+]