@raac/rpc 1.2.0-beta.4 → 1.2.0-beta.5

package/dist/minter/get.js

@@ -1,119 +1,51 @@
 "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");
+const _helpers_1 = require("./_helpers");
+/**
+ * Read the RAAC minter's global state. Mirrors the new RAACMinter contract — the
+ * old emissionRate / benchmarkRate / BLOCKS_PER_DAY / stabilityPool / lendingPool
+ * fields no longer exist; emissions are now driven by a time-based geometric
+ * schedule (see `EmissionSchedule.sol`) and routed through weighted distribution
+ * pools (see `getDistributionPools`).
+ */
+async function get(chainId, provider) {
+    const contract = await (0, _helpers_1.getMinterContract)(chainId, provider);
+    const [raacToken, mintingStartAtTimestamp, lastUpdateBlockTimestamp, excessTokens, maxSupply, totalWeight, paused,] = await Promise.all([
+        contract.raacToken(),
+        contract.mintingStartAtTimestamp(),
+        contract.lastUpdateBlockTimestamp(),
+        contract.excessTokens(),
+        contract.MAX_SUPPLY(),
+        contract.totalWeight(),
+        contract.paused(),
+    ]);
+    const distributionPools = [];
+    for (let i = 0;; i++) {
+        try {
+            distributionPools.push(await contract.distributionPools(i));
+        }
+        catch {
+            break;
+        }
     }
-    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,
+    return {
+        raacToken,
+        mintingStartAtTimestamp: Number(mintingStartAtTimestamp),
+        lastUpdateBlockTimestamp: Number(lastUpdateBlockTimestamp),
+        excessTokens: ethers_1.ethers.formatEther(excessTokens),
+        maxSupply: ethers_1.ethers.formatEther(maxSupply),
+        totalWeight,
+        distributionPoolCount: distributionPools.length,
+        distributionPools,
+        paused,
+        raw: {
+            mintingStartAtTimestamp,
+            lastUpdateBlockTimestamp,
             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 apy = (emissionRatePerYear * 10000n);
-        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}`);
-    }
+            maxSupply,
+            totalWeight,
+        },
+    };
 }
 exports.default = get;

package/dist/minter/getApy.js

@@ -1,28 +1,64 @@
 "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");
+const _helpers_1 = require("./_helpers");
+const SECONDS_PER_YEAR = 365n * 24n * 60n * 60n;
+/**
+ * Compute APY against current RAAC supply using the new time-based emission
+ * schedule. The minter no longer has a flat `emissionRate` — emissions follow a
+ * geometric schedule (see `EmissionSchedule.sol`). We derive the per-second
+ * emission from `calculateScheduledMintableAmount(now, now + 1)` and the yearly
+ * emission from `calculateScheduledMintableAmount(now, now + 1y)`, then divide
+ * by current total RAAC supply.
+ *
+ * Returns zeros if minting hasn't been activated or supply is 0.
+ */
 async function getApy(chainId, provider) {
-    if (!provider) {
-        throw new Error("Wallet not connected");
+    const contract = await (0, _helpers_1.getMinterContract)(chainId, provider);
+    const [mintingStart, raacTokenAddress] = await Promise.all([
+        contract.mintingStartAtTimestamp(),
+        contract.raacToken(),
+    ]);
+    if (mintingStart === 0n) {
+        return {
+            emissionPerSecond: 0n,
+            yearlyEmission: 0n,
+            totalSupply: 0n,
+            apy: 0,
+            apyBps: 0n,
+        };
     }
-    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;
-        // TODO: Needs to be fixed
-        const apy = (emissionRatePerYear * 10000n);
-        return apy;
+    const runner = contract.runner;
+    if (!runner || !runner.provider) {
+        throw new Error("getApy: minter contract has no provider");
     }
-    catch (error) {
-        throw new Error(`Error calculating RAAC rewards: ${error.message}`);
+    const block = await runner.provider.getBlock("latest");
+    if (!block)
+        throw new Error("getApy: could not fetch latest block");
+    const now = BigInt(block.timestamp);
+    const erc20 = new ethers_1.ethers.Contract(raacTokenAddress, ["function totalSupply() view returns (uint256)"], runner);
+    const [yearlyEmission, totalSupplyResult, perSecond] = await Promise.all([
+        contract.calculateScheduledMintableAmount(now, now + SECONDS_PER_YEAR),
+        erc20.totalSupply(),
+        contract.calculateScheduledMintableAmount(now, now + 1n),
+    ]);
+    const totalSupply = totalSupplyResult;
+    if (totalSupply === 0n) {
+        return {
+            emissionPerSecond: perSecond,
+            yearlyEmission,
+            totalSupply,
+            apy: 0,
+            apyBps: 0n,
+        };
     }
+    const apyBps = (yearlyEmission * 10000n) / totalSupply;
+    return {
+        emissionPerSecond: perSecond,
+        yearlyEmission,
+        totalSupply,
+        apy: Number(apyBps) / 100,
+        apyBps,
+    };
 }
 exports.default = getApy;

package/dist/minter/getDistributionPools.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDistributionPools = void 0;
+const ethers_1 = require("ethers");
+const _helpers_1 = require("./_helpers");
+/**
+ * Returns full distribution-pool table along with each pool's share of
+ * `totalWeight`. Iterates `distributionPools(i)` until it reverts (mirrors how
+ * the contract stores the dynamic array) and reads `poolInfo(pool)` for each.
+ */
+const getDistributionPools = async (chainId, provider) => {
+    const contract = await (0, _helpers_1.getMinterContract)(chainId, provider);
+    const totalWeight = await contract.totalWeight();
+    const pools = [];
+    for (let i = 0;; i++) {
+        try {
+            pools.push(await contract.distributionPools(i));
+        }
+        catch {
+            break;
+        }
+    }
+    return Promise.all(pools.map(async (pool) => {
+        const info = await contract.poolInfo(pool);
+        const weight = info.weight ?? info[0];
+        const exists = info.exists ?? info[1];
+        const pendingRewards = info.pendingRewards ?? info[3];
+        const weightShare = totalWeight === 0n ? 0 : Number((weight * 10000n) / totalWeight) / 10000;
+        return {
+            pool,
+            weight,
+            pendingRewards: ethers_1.ethers.formatEther(pendingRewards),
+            pendingRewardsRaw: pendingRewards,
+            exists,
+            weightShare,
+        };
+    }));
+};
+exports.getDistributionPools = getDistributionPools;

package/dist/minter/getEmissionPerSecond.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEmissionPerSecond = void 0;
+const _helpers_1 = require("./_helpers");
+/**
+ * Returns the current per-second RAAC emission. Derived by sampling
+ * `calculateScheduledMintableAmount(now, now + 1)` at the latest block timestamp.
+ * Returns 0 if minting hasn't been activated yet.
+ */
+const getEmissionPerSecond = async (chainId, provider) => {
+    const contract = await (0, _helpers_1.getMinterContract)(chainId, provider);
+    const mintingStart = await contract.mintingStartAtTimestamp();
+    if (mintingStart === 0n)
+        return 0n;
+    const runner = contract.runner;
+    if (!runner || !runner.provider) {
+        throw new Error("getEmissionPerSecond: minter contract has no provider");
+    }
+    const block = await runner.provider.getBlock("latest");
+    if (!block)
+        throw new Error("getEmissionPerSecond: could not fetch latest block");
+    const now = BigInt(block.timestamp);
+    return contract.calculateScheduledMintableAmount(now, now + 1n);
+};
+exports.getEmissionPerSecond = getEmissionPerSecond;

package/dist/minter/getPoolInfo.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPoolInfo = void 0;
+const ethers_1 = require("ethers");
+const _helpers_1 = require("./_helpers");
+/**
+ * Read the per-pool record from the minter's `poolInfo` mapping.
+ */
+const getPoolInfo = async (chainId, pool, provider) => {
+    const contract = await (0, _helpers_1.getMinterContract)(chainId, provider);
+    const info = await contract.poolInfo(pool);
+    const weight = info.weight ?? info[0];
+    const exists = info.exists ?? info[1];
+    const pendingRewards = info.pendingRewards ?? info[3];
+    return {
+        pool,
+        weight,
+        pendingRewards: ethers_1.ethers.formatEther(pendingRewards),
+        pendingRewardsRaw: pendingRewards,
+        exists,
+    };
+};
+exports.getPoolInfo = getPoolInfo;

package/dist/minter/isPaused.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPaused = void 0;
+const _helpers_1 = require("./_helpers");
+const isPaused = async (chainId, provider) => {
+    const contract = await (0, _helpers_1.getMinterContract)(chainId, provider);
+    return contract.paused();
+};
+exports.isPaused = isPaused;

package/dist/minter/manageDistributionPool.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.manageDistributionPool = void 0;
+const _helpers_1 = require("./_helpers");
+/**
+ * Set the weight of an existing pool, or register a new pool with the given weight.
+ * UPDATER_ROLE only. Pass `weight = 0` to deactivate (still registered, just stops
+ * receiving emissions). Calls `tick()` first to distribute pending emissions.
+ */
+const manageDistributionPool = async (chainId, pool, weight, signer) => {
+    if (!signer)
+        throw new Error("Signer is required");
+    const contract = await (0, _helpers_1.getMinterContract)(chainId, signer);
+    const tx = await contract.manageDistributionPool(pool, weight);
+    await tx.wait();
+    return tx;
+};
+exports.manageDistributionPool = manageDistributionPool;

package/dist/minter/pause.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unpause = exports.pause = void 0;
+const _helpers_1 = require("./_helpers");
+/** PAUSER_ROLE only. */
+const pause = async (chainId, signer) => {
+    if (!signer)
+        throw new Error("Signer is required");
+    const contract = await (0, _helpers_1.getMinterContract)(chainId, signer);
+    const tx = await contract.pause();
+    await tx.wait();
+    return tx;
+};
+exports.pause = pause;
+/** PAUSER_ROLE only. */
+const unpause = async (chainId, signer) => {
+    if (!signer)
+        throw new Error("Signer is required");
+    const contract = await (0, _helpers_1.getMinterContract)(chainId, signer);
+    const tx = await contract.unpause();
+    await tx.wait();
+    return tx;
+};
+exports.unpause = unpause;

package/dist/minter/removeDistributionPool.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeDistributionPool = void 0;
+const _helpers_1 = require("./_helpers");
+/**
+ * Remove a distribution pool. UPDATER_ROLE only.
+ * If `excludeTick` is false (default), `tick()` is called first to drain pending
+ * rewards; the call reverts with `PoolPendingRewardsNotCleared` if pending
+ * rewards remain after that. If `excludeTick` is true, any pending rewards on
+ * the pool roll back into `excessTokens` for future distribution.
+ */
+const removeDistributionPool = async (chainId, pool, excludeTick, signer) => {
+    if (!signer)
+        throw new Error("Signer is required");
+    const contract = await (0, _helpers_1.getMinterContract)(chainId, signer);
+    const tx = await contract.removeDistributionPool(pool, excludeTick);
+    await tx.wait();
+    return tx;
+};
+exports.removeDistributionPool = removeDistributionPool;

package/dist/minter/tick.js

@@ -1,29 +1,17 @@
 "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");
+const _helpers_1 = require("./_helpers");
+/**
+ * Permissionless: triggers minting and pool distribution. Will silently no-op
+ * if `mintingStartAtTimestamp == 0` or `totalSupply >= MAX_SUPPLY`.
+ */
 async function tick(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");
-        const raacMinterContract = new ethers_1.ethers.Contract(raacMinterAddress, raacMinterABI, signer);
-        // const { maxFeePerGas } = await estimateGasPrice(signer);
-        // console.log({ maxFeePerGas });
-        const tick = await raacMinterContract.tick({
-            // maxFeePerGas,
-            nonce: await signer.getNonce(),
-        });
-        if (tick.wait) {
-            await tick.wait();
-        }
-        return tick;
-    }
-    catch (error) {
-        throw new Error(`Error calculating RAAC rewards: ${error.message}`);
-    }
+    if (!signer)
+        throw new Error("Signer is required");
+    const contract = await (0, _helpers_1.getMinterContract)(chainId, signer);
+    const tx = await contract.tick({ nonce: await signer.getNonce() });
+    if (tx.wait)
+        await tx.wait();
+    return tx;
 }
 exports.default = tick;