@raac/rpc 1.2.0-beta.1 → 1.2.0-beta.11

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;