@raac/rpc 1.0.0 → 1.0.1

package/dist/pools/stabilityPool/calculateRAACRewards.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ethers_1 = require("ethers");
+const contracts_1 = require("../../utils/contracts");
+const artifacts_1 = require("../../utils/artifacts");
+async function calculateRAACRewards(chainId, address, signer) {
+    if (!signer) {
+        throw new Error("Wallet not connected");
+    }
+    try {
+        const stabilityPoolAddress = (0, contracts_1.getContractAddress)(chainId, "stabilitypool");
+        const stabilityPoolABI = (0, artifacts_1.getABI)("stabilitypool");
+        const stabilityPoolContract = new ethers_1.ethers.Contract(stabilityPoolAddress, stabilityPoolABI, signer);
+        const calculateRAACRewards = await stabilityPoolContract.calculateRaacRewards(address);
+        return ethers_1.ethers.formatEther(calculateRAACRewards);
+    }
+    catch (error) {
+        throw new Error(`Error calculating RAAC rewards: ${error.message}`);
+    }
+}
+exports.default = calculateRAACRewards;

package/dist/pools/stabilityPool/depositToStabilityPool.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 depositToStabilityPool(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.deposit(amountInWei.toString(), {
+            maxFeePerGas,
+            nonce: await signer.getNonce(),
+        });
+        console.log(`Deposit transaction sent to Stability Pool:`, tx.hash);
+        const receipt = await tx.wait();
+        console.log(`Deposited ${amount} to Stability Pool successfully:`, receipt?.hash);
+        return receipt;
+    }
+    catch (error) {
+        console.error(`Error depositing to Stability Pool:`, error);
+        throw new Error(`Deposit to Stability Pool failed: ${error.message}`);
+    }
+}
+exports.default = depositToStabilityPool;

package/dist/pools/stabilityPool/getStabilityPoolInfo.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ethers_1 = require("ethers");
+const contracts_1 = require("../../utils/contracts");
+const artifacts_1 = require("../../utils/artifacts");
+async function getStabilityPoolInfo(chainId, address, provider) {
+    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, 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, exchangeRate, totalRAACRewards] = await Promise.all([
+            stabilityPoolContract
+                .getTotalDeposits()
+                .catch(handleError("getTotalDeposits")),
+            stabilityPoolContract
+                .getTotalAllocation()
+                .catch(handleError("getTotalAllocation")),
+            stabilityPoolContract
+                .getExchangeRate()
+                .catch(handleError("getExchangeRate")),
+            stabilityPoolContract
+                .raacToken()
+                .then(async (raacTokenAddress) => {
+                const raacTokenAbi = (0, artifacts_1.getABI)("raactoken"); // Ensure you have the correct ABI
+                const raacTokenContract = new ethers_1.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 = await stabilityPoolContract
+            .raacMinter()
+            .catch(handleError("raacMinter"));
+        let apy = 0n;
+        if (raacMinterAddress && raacMinterAddress !== ethers_1.ethers.ZeroAddress) {
+            const raacMinterABI = (0, artifacts_1.getABI)("raacminter");
+            const raacMinterContract = new ethers_1.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_1.ethers.formatEther(totalDeposits ?? 0n),
+            totalAllocation: (totalAllocation ?? 0n).toString(),
+            exchangeRate: ethers_1.ethers.formatUnits(exchangeRate ?? 0n, 18),
+            totalRAACRewards: ethers_1.ethers.formatEther(totalRAACRewards ?? 0n),
+            userDeposit: ethers_1.ethers.formatEther(userDeposit ?? 0n),
+            pendingRewards: ethers_1.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;
+    }
+}
+exports.default = getStabilityPoolInfo;

package/dist/pools/stabilityPool/getStabilityPoolTotalDeposits.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ethers_1 = require("ethers");
+const contracts_1 = require("../../utils/contracts");
+const artifacts_1 = require("../../utils/artifacts");
+async function getStabilityPoolTotalDeposits(chainId, provider) {
+    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, provider);
+        const totalDeposits = await stabilityPoolContract.getTotalDeposits();
+        return totalDeposits;
+    }
+    catch (error) {
+        console.error("Error fetching total deposits:", error);
+        throw error;
+    }
+}
+exports.default = getStabilityPoolTotalDeposits;

package/dist/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?.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/dist/scripts/index.js

@@ -0,0 +1,83 @@
+"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 chains_1 = __importDefault(require("../configs/chains"));
+//node --env-file=../.env -r ts-node/register ./test.ts
+const RPCLibrary_1 = __importDefault(require("../RPCLibrary"));
+const contracts_1 = require("../utils/contracts");
+const artifacts_1 = require("../utils/artifacts");
+const chainId = 8453;
+const config = chains_1.default[chainId];
+const TEST_MNEMONIC = process.env.TEST_MNEMONIC;
+async function getProvider() {
+    return new ethers_1.ethers.JsonRpcProvider(config.rpcs[0]);
+}
+async function createWallet(mnemonic, provider) {
+    const wallet = ethers_1.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_1.default();
+    rpc.address = signer.address;
+    rpc.provider = provider;
+    rpc.chainId = chainId;
+    // send myself some CRVUSD
+    await rpc.wallet.assets.mintAsset(chainId, "crvusd", 10000n, signer.address, signer);
+    // // set the base uri to localhost:3000
+    await rpc.nfts.setBaseUri(chainId, "https://localhost:3000", 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 = (0, contracts_1.getContractAddress)(chainId, "raachouseprices");
+    const housePriceABI = (0, artifacts_1.getABI)("raachouseprices");
+    const housePriceContract = new ethers_1.ethers.Contract(housePriceAddress, housePriceABI, signer);
+    let tx = await housePriceContract.setHousePrice(1, (0, ethers_1.parseEther)("100"));
+    await tx.wait();
+    console.log("Price set for house 1");
+    tx = await housePriceContract.setHousePrice(2, (0, ethers_1.parseEther)("200"));
+    await tx.wait();
+    console.log("Price set for house 2");
+    tx = await housePriceContract.setHousePrice(3, (0, ethers_1.parseEther)("300"));
+    await tx.wait();
+    console.log("Price set for house 3");
+    // make sure that prices are set
+    let price = await rpc.nfts.getHousePrice(chainId, 1, provider);
+    if (price !== "100.0") {
+        throw new Error("Price not set correctly");
+    }
+    price = await rpc.nfts.getHousePrice(chainId, 2, provider);
+    if (price !== "200.0") {
+        throw new Error("Price not set correctly");
+    }
+    price = await rpc.nfts.getHousePrice(chainId, 3, provider);
+    if (price !== "300.0") {
+        throw new Error("Price not set correctly");
+    }
+}
+const execute = async () => {
+    const provider = await getProvider();
+    const signer = await createWallet(TEST_MNEMONIC, provider);
+    const rpc = new RPCLibrary_1.default();
+    rpc.address = signer.address;
+    rpc.provider = provider;
+    rpc.chainId = chainId;
+    const balance = await rpc.wallet.assets.getBalance(chainId, "detoken", signer.address, provider);
+    console.log("Balance: ", balance);
+    const rtokenBalance = await rpc.wallet.assets.getBalance(chainId, "rtoken", signer.address, provider);
+    console.log("RToken Balance: ", rtokenBalance);
+    const stabilityPoolAddress = (0, contracts_1.getContractAddress)(chainId, "stabilitypool");
+    const allowance = await rpc.wallet.assets.getAllowance(chainId, "detoken", signer.address, stabilityPoolAddress, provider);
+    console.log("Allowance: ", allowance);
+    // withdraw
+    // await rpc.pools.stabilityPool.withdrawFromStabilityPool(chainId, "4", signer);
+    // console.log("Withdrawn from stability pool");
+};
+execute();
+// setup();

package/dist/tests/test.js

@@ -0,0 +1,32 @@
+"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 chains_1 = __importDefault(require("../configs/chains"));
+//node --env-file=../.env -r ts-node/register ./test.ts
+const RPCLibrary_1 = __importDefault(require("../RPCLibrary"));
+const chainId = 8453;
+const config = chains_1.default[chainId];
+const TEST_MNEMONIC = process.env.TEST_MNEMONIC;
+async function getProvider() {
+    return new ethers_1.ethers.JsonRpcProvider(config.rpcs[0]);
+}
+async function createWallet(mnemonic, provider) {
+    const wallet = ethers_1.ethers.Wallet.fromPhrase(mnemonic, provider);
+    console.info(`[${chainId}]: Loaded wallet from mnemonic: ${wallet.address}`);
+    // the signer is the wallet
+    return wallet;
+}
+async function test() {
+    const provider = await getProvider();
+    const signer = await createWallet(TEST_MNEMONIC, provider);
+    const rpc = new RPCLibrary_1.default();
+    rpc.address = signer.address;
+    rpc.provider = provider;
+    rpc.chainId = chainId;
+    console.log(await rpc.wallet.assets.getBalance(chainId, "rtoken", rpc.address, provider));
+    console.log(await rpc.contracts.minter.get(chainId, signer));
+}
+test();

package/dist/types/RPCLibrary.d.ts

@@ -0,0 +1,139 @@
+import { Eip1193Provider, ethers, JsonRpcSigner, Provider, Signer } from "ethers";
+import checkAllowance from "./methods/commons/checkAllowance";
+import { getChainsConfig, setChainConfig } from "./configs/index";
+import getAsset from "./assets/getAsset";
+import getSupply from "./assets/getSupply";
+import getAssets from "./assets/getAssets";
+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";
+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";
+import depositNFTToLendingPool from "./pools/lendingPool/depositNFTToLendingPool";
+import withdrawNFTFromLendingPool from "./pools/lendingPool/withdrawNFTFromLendingPool";
+import getHousePrice from "./pools/lendingPool/getHousePrice";
+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";
+import getContractAddress from "./contracts/getContractAddress";
+import getContract from "./contracts/getContract";
+import getLatestPrice from "./contracts/housePrices/getLatestPrice";
+import setOracle from "./contracts/housePrices/setOracle";
+import tick from "./minter/tick";
+import get from "./minter/get";
+import getApy from "./minter/getApy";
+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";
+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";
+declare class RPCLibrary {
+    signer: Signer | null;
+    isConnected: boolean;
+    address: JsonRpcSigner | string;
+    chainId: ChainId | bigint | null;
+    privateKey: any;
+    assets: {
+        getAsset: typeof getAsset;
+        getAssets: typeof getAssets;
+        getSupply: typeof getSupply;
+    };
+    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: {
+            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;
+        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);
+    getWallet(privateKey: string, provider: Provider): Promise<ethers.JsonRpcSigner | ethers.Wallet>;
+    getProvider(chainId: ChainId): Promise<ethers.BrowserProvider | ethers.JsonRpcProvider>;
+    getSigner(chainId: ChainId, address: string): Promise<ethers.JsonRpcSigner>;
+    connectWallet(): Promise<void>;
+    checkConnection(): Promise<void>;
+    mineBlock(wallet: Eip1193Provider): Promise<void>;
+}
+export default RPCLibrary;

package/dist/types/assets/getAsset.d.ts

@@ -0,0 +1,5 @@
+import { ChainId } from "../configs/chains";
+import { AssetType } from "../utils/artifacts";
+import { Provider } from "ethers";
+declare function getAsset(chainId: ChainId, assetId: AssetType, provider: Provider): Promise<any>;
+export default getAsset;

package/dist/types/assets/getAssets.d.ts

@@ -0,0 +1,4 @@
+import { Provider } from "ethers";
+import { ChainId } from "../configs/chains";
+declare function getAssets(chainId: ChainId, provider: Provider): Promise<{}>;
+export default getAssets;

package/dist/types/assets/getSupply.d.ts

@@ -0,0 +1,5 @@
+import { Provider } from "ethers";
+import { ChainId } from "../configs/chains";
+import { AssetType } from "../utils/artifacts";
+declare function getSupply(chainId: ChainId, assetId: AssetType, provider: Provider): Promise<string | 0>;
+export default getSupply;

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

@@ -0,0 +1,11 @@
+import { Chain8453 } from "./chain";
+declare const chains: {
+    8453: Chain8453;
+};
+export default chains;
+export declare const configs: {
+    8453: Chain8453;
+};
+export type Configs = typeof chains;
+export type ConfigKeys = keyof Configs;
+export type ChainId = ConfigKeys | string | number;

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

@@ -0,0 +1,86 @@
+import { ChainId } from "./chains";
+declare function createConfig(chainId: ChainId): {
+    chainId: ChainId;
+    name: string;
+    rpcs: string[];
+    contracts: {
+        raachouseprices: {
+            id: string;
+            name: string;
+            contract: string;
+        };
+        raacminter: {
+            id: string;
+            name: string;
+            contract: string;
+        };
+        auctionfactory: {
+            id: string;
+            name: string;
+            contract: string;
+        };
+        zenofactory: {
+            id: string;
+            name: string;
+            contract: string;
+        };
+    };
+    pools: {
+        stabilitypool: {
+            id: string;
+            name: string;
+            contract: string;
+        };
+        lendingpool: {
+            id: string;
+            name: string;
+            contract: string;
+        };
+    };
+    nfts: {
+        raacnft: {
+            id: string;
+            name: string;
+            contract: string;
+        };
+    };
+    assets: {
+        eth: {
+            id: string;
+            name: string;
+            decimals: number;
+            contract: string;
+        };
+        crvusd: {
+            id: string;
+            name: string;
+            decimals: number;
+            contract: string;
+        };
+        rtoken: {
+            id: string;
+            name: string;
+            decimals: number;
+            contract: string;
+        };
+        detoken: {
+            id: string;
+            name: string;
+            decimals: number;
+            contract: string;
+        };
+        raactoken: {
+            id: string;
+            name: string;
+            decimals: number;
+            contract: string;
+        };
+        veraac: {
+            id: string;
+            name: string;
+            decimals: number;
+            contract: string;
+        };
+    };
+};
+export default createConfig;

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

@@ -0,0 +1,13 @@
+import { ChainId } from "./chains/index";
+declare function getChainsConfig(): {
+    8453: import("./chains/chain").Chain8453;
+};
+declare function setChainConfig(chainId: ChainId, config: any): void;
+declare function getChainConfig(chainId: ChainId): any;
+declare const _default: {
+    getChainsConfig: typeof getChainsConfig;
+    getChainConfig: typeof getChainConfig;
+    setChainConfig: typeof setChainConfig;
+};
+export default _default;
+export { getChainsConfig, getChainConfig, setChainConfig };

package/dist/types/contracts/crvUSDToken/getBalance.d.ts

@@ -0,0 +1,2 @@
+import configs from "../../configs/chains";
+export declare const getBalance: (chainId: keyof typeof configs, contractAddress: string, address: string) => Promise<string>;

package/dist/types/contracts/crvUSDToken/getTotalSupply.d.ts

@@ -0,0 +1,10 @@
+import { Provider } from "ethers";
+import { ConfigKeys } from "../../configs/chains";
+/**
+ *
+ * @param {string} contractAddress
+ * @param {number} chainId
+ * @param {ethers.JsonRpcProvider} [provider]
+ * @returns {Promise<string>}
+ */
+export declare const getTotalSupply: (chainId: ConfigKeys, contractAddress: string, provider: Provider) => Promise<string>;

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

@@ -0,0 +1,4 @@
+import { ethers, Signer } from "ethers";
+import { ChainId } from "../configs/chains/index";
+import { ContractType } from "../utils/artifacts";
+export default function getContract(chainId: ChainId, contractName: ContractType, signer: Signer): Promise<ethers.Contract>;

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

@@ -0,0 +1,10 @@
+import { 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 declare const getContractAddress: (chainId: ChainId, contractName: ContractType) => any;
+export default getContractAddress;

package/dist/types/contracts/housePrices/getLatestPrice.d.ts

@@ -0,0 +1,10 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../configs/chains/index";
+declare function getLatestPrice(chainId: ChainId, tokenId: string, provider: Provider): Promise<{
+    price: bigint;
+    timestamp: bigint;
+} | {
+    price: number;
+    timestamp: number;
+}>;
+export default getLatestPrice;

package/dist/types/contracts/housePrices/setOracle.d.ts

@@ -0,0 +1,4 @@
+import { ethers, Signer } from "ethers";
+import { ChainId } from "../../configs/chains/index";
+declare function setOracle(chainId: ChainId, newOracleAddress: string, signer: Signer): Promise<ethers.ContractTransactionResponse>;
+export default setOracle;

package/dist/types/contracts/rcrvUSDToken/getBalance.d.ts

@@ -0,0 +1,2 @@
+import { ChainId } from "../../configs/chains";
+export declare const getBalance: (chainId: ChainId, contractAddress: string, address: string) => Promise<string>;

package/dist/types/contracts/rcrvUSDToken/getTotalSupply.d.ts

@@ -0,0 +1,10 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../configs/chains";
+/**
+ *
+ * @param {string} contractAddress
+ * @param {number} chainId
+ * @param {ethers.JsonRpcProvider} [provider]
+ * @returns {Promise<string>}
+ */
+export declare const getTotalSupply: (chainId: ChainId, contractAddress: string, provider: Provider) => Promise<string>;