@raac/rpc 1.0.0 → 1.0.1

package/dist/configs/index.js

@@ -0,0 +1,43 @@
+"use strict";
+// let fs;
+// let path;
+// let fileURLToPath;
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getChainsConfig = getChainsConfig;
+exports.getChainConfig = getChainConfig;
+exports.setChainConfig = setChainConfig;
+const index_1 = __importDefault(require("./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 index_1.default;
+}
+function setChainConfig(chainId, config) {
+    index_1.default[chainId] = config;
+}
+function getChainConfig(chainId) {
+    const chains = getChainsConfig();
+    return chains[chainId];
+}
+exports.default = { getChainsConfig, getChainConfig, setChainConfig };

package/dist/contracts/crvUSDToken/getBalance.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBalance = void 0;
+const ethers_1 = require("ethers");
+const chains_1 = __importDefault(require("../../configs/chains"));
+const BALANCE_OF_ABI = "function balanceOf(address account) view returns (uint256)";
+const getBalance = async (chainId, contractAddress, address) => {
+    const rpc = chains_1.default[chainId].rpcs[0];
+    const provider = new ethers_1.ethers.JsonRpcProvider(rpc);
+    const contract = new ethers_1.ethers.Contract(contractAddress, [BALANCE_OF_ABI], provider);
+    const balance = await contract.balanceOf(address);
+    return ethers_1.ethers.formatEther(balance);
+};
+exports.getBalance = getBalance;

package/dist/contracts/crvUSDToken/getTotalSupply.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTotalSupply = void 0;
+const ethers_1 = require("ethers");
+const chains_1 = __importDefault(require("../../configs/chains"));
+const TOTAL_SUPPLY_ABI = "function totalSupply() view returns (uint256)";
+/**
+ *
+ * @param {string} contractAddress
+ * @param {number} chainId
+ * @param {ethers.JsonRpcProvider} [provider]
+ * @returns {Promise<string>}
+ */
+const getTotalSupply = async (chainId, contractAddress, 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 = chains_1.default[chainId].rpcs[0];
+        provider = new ethers_1.ethers.JsonRpcProvider(rpc);
+    }
+    const contract = new ethers_1.ethers.Contract(contractAddress, [TOTAL_SUPPLY_ABI], provider);
+    const totalSupply = await contract.totalSupply();
+    return ethers_1.ethers.formatEther(totalSupply);
+};
+exports.getTotalSupply = getTotalSupply;

package/dist/contracts/getContract.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = getContract;
+const ethers_1 = require("ethers");
+const getContractAddress_1 = __importDefault(require("./getContractAddress"));
+async function getContract(chainId, contractName, signer) {
+    if (!signer) {
+        throw new Error("Signer is required");
+    }
+    const contractAddress = (0, getContractAddress_1.default)(chainId, contractName);
+    // You'll need to import the ABI for the contract. This is just a placeholder.
+    const abi = []; // Replace with actual ABI
+    const contract = new ethers_1.ethers.Contract(contractAddress, abi, signer);
+    return contract;
+}

package/dist/contracts/getContractAddress.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getContractAddress = void 0;
+const chains_1 = __importDefault(require("../configs/chains"));
+/**
+ * Get the contract address for a given asset on a specific chain
+ * @param {number} chainId
+ * @param {string} contractName
+ * @returns {string}
+ */
+const getContractAddress = (chainId, contractName) => {
+    const normalizedContractName = contractName.toLowerCase();
+    if (!chainId) {
+        throw new Error("Chain ID is required");
+    }
+    const config = chains_1.default[chainId];
+    if (!config) {
+        throw new Error(`Chain configuration not found for chainId: ${chainId}`);
+    }
+    const lookupKeys = [
+        "contracts",
+        "assets",
+        "pools",
+        "nfts",
+    ];
+    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;
+};
+exports.getContractAddress = getContractAddress;
+exports.default = exports.getContractAddress;

package/dist/contracts/housePrices/getLatestPrice.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 getLatestPrice(chainId, tokenId, provider) {
+    try {
+        const raacHousePricesAddress = (0, contracts_1.getContractAddress)(chainId, "raachouseprices");
+        const raacHousePricesABI = (0, artifacts_1.getABI)("raachouseprices");
+        const raacHousePricesContract = new ethers_1.ethers.Contract(raacHousePricesAddress, raacHousePricesABI, provider);
+        const [price, timestamp] = await raacHousePricesContract.getLatestPrice(tokenId);
+        return { price, timestamp };
+    }
+    catch (error) {
+        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}`);
+    }
+}
+exports.default = getLatestPrice;

package/dist/contracts/housePrices/setOracle.js

@@ -0,0 +1,24 @@
+"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 setOracle(chainId, newOracleAddress, signer) {
+    if (!signer) {
+        throw new Error("Wallet not connected");
+    }
+    try {
+        const raacHousePricesAddress = (0, contracts_1.getContractAddress)(chainId, "raachouseprices");
+        const raacHousePricesABI = (0, artifacts_1.getABI)("raachouseprices");
+        const raacHousePricesContract = new ethers_1.ethers.Contract(raacHousePricesAddress, raacHousePricesABI, signer);
+        const tx = await raacHousePricesContract.setOracle(newOracleAddress);
+        await tx.wait();
+        console.log(`Oracle address updated to: ${newOracleAddress}`);
+        return tx;
+    }
+    catch (error) {
+        console.error("Error setting oracle:", error);
+        throw new Error(`Failed to set oracle: ${error.message}`);
+    }
+}
+exports.default = setOracle;

package/dist/contracts/rcrvUSDToken/getBalance.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBalance = void 0;
+const ethers_1 = require("ethers");
+const chains_1 = require("../../configs/chains");
+const BALANCE_OF_ABI = "function balanceOf(address account) view returns (uint256)";
+const getBalance = async (chainId, contractAddress, address) => {
+    const rpc = chains_1.configs[chainId].rpcs[0];
+    const provider = new ethers_1.ethers.JsonRpcProvider(rpc);
+    const contract = new ethers_1.ethers.Contract(contractAddress, [BALANCE_OF_ABI], provider);
+    const balance = await contract.balanceOf(address);
+    return ethers_1.ethers.formatEther(balance);
+};
+exports.getBalance = getBalance;

package/dist/contracts/rcrvUSDToken/getTotalSupply.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTotalSupply = void 0;
+const ethers_1 = require("ethers");
+const chains_1 = __importDefault(require("../../configs/chains"));
+const TOTAL_SUPPLY_ABI = "function totalSupply() view returns (uint256)";
+/**
+ *
+ * @param {string} contractAddress
+ * @param {number} chainId
+ * @param {ethers.JsonRpcProvider} [provider]
+ * @returns {Promise<string>}
+ */
+const getTotalSupply = async (chainId, contractAddress, provider) => {
+    if (!provider) {
+        if (!chainId) {
+            throw new Error("Contract address not found in any chain configuration");
+        }
+        const rpc = chains_1.default[chainId].rpcs[0];
+        provider = new ethers_1.ethers.JsonRpcProvider(rpc);
+    }
+    console.log(`Getting total supply for ${contractAddress} on ${(await provider.getNetwork()).chainId} using provider ${provider}`);
+    const contract = new ethers_1.ethers.Contract(contractAddress, [TOTAL_SUPPLY_ABI], provider);
+    const totalSupply = await contract.totalSupply();
+    return ethers_1.ethers.formatEther(totalSupply);
+};
+exports.getTotalSupply = getTotalSupply;

package/dist/contracts/zeno/createAuction.js

@@ -0,0 +1,25 @@
+"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 createAuction(chainId, zenoAddress, usdcAddress, businessAddress, auctionStartTime, auctionEndTime, startingPrice, reservePrice, totalZenoAllocated, signer) {
+    if (!signer) {
+        throw new Error("Wallet not connected");
+    }
+    try {
+        const auctionFactoryAddress = (0, contracts_1.getContractAddress)(chainId, "auctionfactory");
+        const auctionFactoryABI = (0, artifacts_1.getABI)("auctionfactory");
+        const auctionFactoryContract = new ethers_1.ethers.Contract(auctionFactoryAddress, auctionFactoryABI, signer);
+        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) {
+        console.error("Error creating zeno auction:", error);
+        throw new Error(`Failed to create zeno auction: ${error.message}`);
+    }
+}
+exports.default = createAuction;

package/dist/contracts/zeno/createZeno.js

@@ -0,0 +1,26 @@
+"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 createZeno(chainId, usdcAddress, maturityDate, signer) {
+    if (!signer) {
+        throw new Error("Wallet not connected");
+    }
+    try {
+        const zenoFactoryAddress = (0, contracts_1.getContractAddress)(chainId, "zenofactory");
+        const zenoFactoryABI = (0, artifacts_1.getABI)("zenofactory");
+        const zenoFactoryContract = new ethers_1.ethers.Contract(zenoFactoryAddress, zenoFactoryABI, signer);
+        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) {
+        console.error("Error creating zeno:", error);
+        throw new Error(`Failed to create zeno: ${error.message}`);
+    }
+}
+exports.default = createZeno;

package/dist/contracts/zeno/getAuctions.js

@@ -0,0 +1,28 @@
+"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 getAuctions(chainId, signer) {
+    if (!signer) {
+        throw new Error("Wallet not connected");
+    }
+    try {
+        const auctionFactoryAddress = (0, contracts_1.getContractAddress)(chainId, "auctionfactory");
+        const auctionFactoryABI = (0, artifacts_1.getABI)("auctionfactory");
+        const auctionFactoryContract = new ethers_1.ethers.Contract(auctionFactoryAddress, auctionFactoryABI, signer);
+        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) {
+        console.error("Error getting auctions:", error);
+        throw new Error(`Failed to get auctions: ${error.message}`);
+    }
+}
+exports.default = getAuctions;

package/dist/contracts/zeno/getZenos.js

@@ -0,0 +1,28 @@
+"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 getZenos(chainId, signer) {
+    if (!signer) {
+        throw new Error("Wallet not connected");
+    }
+    try {
+        const zenoFactoryAddress = (0, contracts_1.getContractAddress)(chainId, "zenofactory");
+        const zenoFactoryABI = (0, artifacts_1.getABI)("zenofactory");
+        const zenoFactoryContract = new ethers_1.ethers.Contract(zenoFactoryAddress, zenoFactoryABI, signer);
+        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) {
+        console.error("Error getting zenos:", error);
+        throw new Error(`Failed to get zenos: ${error.message}`);
+    }
+}
+exports.default = getZenos;

package/dist/index.js

@@ -0,0 +1,7 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const RPCLibrary_1 = __importDefault(require("./RPCLibrary"));
+exports.default = RPCLibrary_1.default;

package/dist/methods/approveToken.js

@@ -0,0 +1,35 @@
+"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 getContractAddress_1 = require("../contracts/getContractAddress");
+const estimateGasPrice_1 = __importDefault(require("./commons/estimateGasPrice"));
+const approveToken = async (chainId, tokenSymbol, spender, amount, signer) => {
+    if (!signer) {
+        throw new Error("Wallet not connected");
+    }
+    const tokenAddress = (0, getContractAddress_1.getContractAddress)(chainId, tokenSymbol);
+    const tokenABI = [
+        "function approve(address spender, uint256 amount) public returns (bool)",
+    ];
+    const tokenContract = new ethers_1.ethers.Contract(tokenAddress, tokenABI, signer);
+    try {
+        const amountInWei = ethers_1.ethers.parseEther(amount);
+        const { maxFeePerGas } = await (0, estimateGasPrice_1.default)(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) {
+        console.error(`Approval error:`, error);
+        throw new Error(`Token approval failed: ${error.message}`);
+    }
+};
+exports.default = approveToken;

package/dist/methods/commons/checkAllowance.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkAllowance = void 0;
+const contracts_1 = require("../../utils/contracts");
+const checkAllowance = async (chainId, tokenId, address, spenderAddress, provider) => {
+    let tokenAddress = (0, contracts_1.getContractAddress)(chainId, tokenId);
+    console.log(`[commons/checkAllowance] Checking allowance for ${address} to ${spenderAddress} on ${chainId} ${tokenId}:${tokenAddress}`);
+    try {
+        const tokenContract = (0, contracts_1.getContract)(chainId, tokenId, provider);
+        const allowance = await tokenContract.allowance(address, spenderAddress);
+        return allowance;
+    }
+    catch (error) {
+        console.error(`Error calling allowance: ${error}`);
+        throw new Error(`[commons/checkAllowance] ${chainId} ${tokenId}:${tokenAddress} ${address} ${spenderAddress} ${error}`);
+    }
+};
+exports.checkAllowance = checkAllowance;
+exports.default = checkAllowance;

package/dist/methods/commons/estimateGasPrice.js

@@ -0,0 +1,23 @@
+"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();
+        return {
+            maxFeePerGas: feeData.maxFeePerGas,
+            maxPriorityFeePerGas: feeData.maxPriorityFeePerGas,
+        };
+    }
+    catch (error) {
+        console.log("Error getting gas price", error);
+        if (provider?.getGasPrice) {
+            const gasPrice = await provider.getGasPrice();
+            return { gasPrice };
+        }
+        return { gasPrice: 0 };
+    }
+};
+exports.estimateGasPrice = estimateGasPrice;
+exports.default = exports.estimateGasPrice;

package/dist/methods/getAssetBalance.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAssetBalance = void 0;
+const ethers_1 = require("ethers");
+const getContractAddress_1 = require("../contracts/getContractAddress");
+const getAssetBalance = async (chainId, address, assetId, signer) => {
+    if (!signer) {
+        throw new Error("Wallet not connected");
+    }
+    try {
+        if (assetId === "eth") {
+            const provider = signer.provider;
+            // handle getBalance do not exist in ethers.js, check if not under the other method TODO FIXME
+            const balance = (await provider.getBalance(address)).toString();
+            return balance;
+        }
+        // @ts-ignore
+        const tokenAddress = (0, getContractAddress_1.getContractAddress)(chainId, assetId);
+        const abi = ["function balanceOf(address) view returns (uint256)"];
+        const contract = new ethers_1.ethers.Contract(tokenAddress, abi, signer);
+        const balance = await contract.balanceOf(address);
+        return ethers_1.ethers.formatEther(balance);
+    }
+    catch (error) {
+        console.error(`Error in getAssetBalance for ${assetId}:`, error);
+        if (error.code === "BAD_DATA") {
+            console.error("Contract might not have balanceOf function. Check the contract address and ABI.");
+        }
+        throw new Error(`Failed to fetch balance for ${assetId}: ${error.message}`);
+    }
+};
+exports.getAssetBalance = getAssetBalance;
+exports.default = getAssetBalance;

package/dist/methods/getAssetsBalance.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const getAssetBalance = async (chainId, address, signer) => { };
+exports.default = getAssetBalance;

package/dist/minter/get.js

@@ -0,0 +1,121 @@
+"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 get(chainId, signer) {
+    if (!signer) {
+        throw new Error("Wallet not connected");
+    }
+    try {
+        const raacMinterAddress = (0, contracts_1.getContractAddress)(chainId, "raacminter");
+        const raacMinterABI = (0, artifacts_1.getABI)("raacminter");
+        // console.log(raacMinterAddress);
+        // console.log(raacMinterABI);
+        const raacMinterContract = new ethers_1.ethers.Contract(raacMinterAddress, raacMinterABI, signer);
+        const handleError = (operation) => (error) => {
+            if (error.code === "BAD_DATA") {
+                console.log(`BAD_DATA from getMinter - ${operation}:`, error.message);
+                return BigInt(0);
+            }
+            throw error;
+        };
+        const { maxFeePerGas } = await (0, estimateGasPrice_1.default)(signer);
+        const [emissionRate, benchmarkRate, minEmissionRate, maxEmissionRate, utilizationTarget, excessTokens, lastUpdateBlock, raacToken, stabilityPool, lendingPool, owner, BLOCKS_PER_DAY,] = await Promise.all([
+            raacMinterContract.emissionRate().catch(handleError("emissionRate")),
+            raacMinterContract.benchmarkRate().catch(handleError("benchmarkRate")),
+            raacMinterContract
+                .minEmissionRate()
+                .catch(handleError("minEmissionRate")),
+            raacMinterContract
+                .maxEmissionRate()
+                .catch(handleError("maxEmissionRate")),
+            raacMinterContract
+                .utilizationTarget()
+                .catch(handleError("utilizationTarget")),
+            raacMinterContract.excessTokens().catch(handleError("excessTokens")),
+            raacMinterContract
+                .lastUpdateBlock()
+                .catch(handleError("lastUpdateBlock")),
+            raacMinterContract.raacToken().catch(handleError("raacToken")),
+            raacMinterContract.stabilityPool().catch(handleError("stabilityPool")),
+            raacMinterContract.lendingPool().catch(handleError("lendingPool")),
+            raacMinterContract.owner().catch(handleError("owner")),
+            raacMinterContract.BLOCKS_PER_DAY().catch(handleError("BLOCKS_PER_DAY")),
+        ]);
+        const result = {
+            emissionRate,
+            benchmarkRate,
+            minEmissionRate,
+            maxEmissionRate,
+            utilizationTarget,
+            excessTokens,
+            lastUpdateBlock,
+            raacToken,
+            stabilityPool,
+            lendingPool,
+            owner,
+            BLOCKS_PER_DAY,
+        };
+        // Call all readable values from the RAACMinter contract
+        // result.emissionRate = await raacMinterContract.emissionRate();
+        // result.benchmarkRate = await raacMinterContract.benchmarkRate();
+        // result.minEmissionRate = await raacMinterContract.minEmissionRate();
+        // result.maxEmissionRate = await raacMinterContract.maxEmissionRate();
+        // result.utilizationTarget = await raacMinterContract.utilizationTarget();
+        // result.excessTokens = await raacMinterContract.excessTokens();
+        // result.lastUpdateBlock = await raacMinterContract.lastUpdateBlock();
+        // result.raacToken = await raacMinterContract.raacToken();
+        // result.stabilityPool = await raacMinterContract.stabilityPool();
+        // result.lendingPool = await raacMinterContract.lendingPool();
+        // result.owner = await raacMinterContract.owner();
+        // result.BLOCKS_PER_DAY = await raacMinterContract.BLOCKS_PER_DAY();
+        // APY:
+        const blocksPerYear = result.BLOCKS_PER_DAY * 365n;
+        const emissionRatePerYear = result.emissionRate * blocksPerYear;
+        console.log("emissionRatePerYear", emissionRatePerYear);
+        const totalSupply = await raacMinterContract.getTotalSupply();
+        console.log("totalSupply", totalSupply);
+        const apy = (emissionRatePerYear * 10000n) / totalSupply;
+        console.log("apy", apy);
+        // const BLOCKS_PER_YEAR = 2628000; // Assuming 6500 blocks per day * 365 days
+        // const emissionRatePerYear = result.emissionRate * BLOCKS_PER_YEAR;
+        // console.log("emissionRatePerYear", emissionRatePerYear);
+        // const totalSupply = await raacMinterContract.raacToken().totalSupply();
+        // if (totalSupply.gt(0)) {
+        //     const apy = emissionRatePerYear * 10000 / totalSupply;
+        //     result.apy = apy / 100; // Convert to percentage
+        // } else {
+        //     result.apy = 0;
+        // }
+        // Constants
+        // result.PRECISION = await raacMinterContract.PRECISION();
+        // result.BLOCKS_PER_YEAR = await raacMinterContract.BLOCKS_PER_YEAR();
+        // result.INITIAL_EMISSION_RATE = await raacMinterContract.INITIAL_EMISSION_RATE();
+        // const params = await raacMinterContract.getParameters();
+        // result.parameters = {
+        // minEmissionRate: params[0],
+        // maxEmissionRate: params[1],
+        // utilizationTarget: params[2],
+        // adjustmentSpeed: params[3],
+        // benchmarkRate: params[4],
+        // emissionRate: params[5],
+        // excessTokens: params[6]
+        // };
+        // const tick = await raacMinterContract.tick();
+        // address, {
+        //   maxFeePerGas,
+        //   nonce: await signer.getNonce()
+        // });
+        // console.log(tick);
+        return result;
+    }
+    catch (error) {
+        throw new Error(`Error calculating RAAC rewards: ${error.message}`);
+    }
+}
+exports.default = get;

package/dist/minter/getApy.js

@@ -0,0 +1,28 @@
+"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 getApy(chainId, provider) {
+    if (!provider) {
+        throw new Error("Wallet not connected");
+    }
+    try {
+        const raacMinterAddress = (0, contracts_1.getContractAddress)(chainId, "raacminter");
+        const raacMinterABI = (0, artifacts_1.getABI)("raacminter");
+        const raacMinterContract = new ethers_1.ethers.Contract(raacMinterAddress, raacMinterABI, provider);
+        const result = { emissionRate: 0n, BLOCKS_PER_DAY: 0n };
+        result.emissionRate = await raacMinterContract.emissionRate();
+        result.BLOCKS_PER_DAY = await raacMinterContract.BLOCKS_PER_DAY();
+        // APY:
+        const blocksPerYear = result.BLOCKS_PER_DAY * 365n;
+        const emissionRatePerYear = result.emissionRate * blocksPerYear;
+        const totalSupply = await raacMinterContract.getTotalSupply();
+        const apy = (emissionRatePerYear * 10000n) / totalSupply;
+        return apy;
+    }
+    catch (error) {
+        throw new Error(`Error calculating RAAC rewards: ${error.message}`);
+    }
+}
+exports.default = getApy;