@raac/rpc 2.0.0-beta.10 → 2.0.0-beta.11

package/dist/RPCLibrary.js

@@ -149,6 +149,7 @@ const claimRewardFromPool_1 = __importDefault(require("./contracts/feeCollector/
 const getState_1 = require("./contracts/rentStreamer/getState");
 const previewRelease_1 = require("./contracts/rentStreamer/previewRelease");
 const getScheduled_1 = require("./contracts/rentStreamer/getScheduled");
+const getEpochProjection_1 = require("./contracts/rentStreamer/getEpochProjection");
 const sync_1 = require("./contracts/rentStreamer/sync");
 const release_1 = require("./contracts/rentStreamer/release");
 const getRawUserDepositsInLendingPool_1 = __importDefault(require("./pools/lendingPool/getRawUserDepositsInLendingPool"));
@@ -526,6 +527,7 @@ class RPCLibrary {
                 getState: getState_1.getState,
                 previewRelease: previewRelease_1.previewRelease,
                 getScheduled: getScheduled_1.getScheduled,
+                getEpochProjection: getEpochProjection_1.getEpochProjection,
                 sync: sync_1.sync,
                 release: release_1.release,
             },

package/dist/contracts/rentStreamer/getEpochProjection.js

@@ -0,0 +1,91 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEpochProjection = void 0;
+const ethers_1 = require("ethers");
+const chains_1 = __importDefault(require("../../configs/chains"));
+const artifacts_1 = require("../../utils/artifacts");
+const amount_1 = require("../../utils/amount");
+const _helpers_1 = require("./_helpers");
+/** FeeStreamer.WEEK: buckets and the gauge controller's epochs both start on this grid. */
+const WEEK = 7n * 24n * 3600n;
+const BOUNTY_PRECISION = 10n ** BigInt(amount_1.WAD_DECIMALS);
+/** Bucket `index` of `amount` split from a start epoch, as FeeStreamer._append does: equal splits, the remainder in the last. */
+const bucketShare = (amount, numEpochs, index) => {
+    if (index >= numEpochs)
+        return 0n;
+    const split = amount / numEpochs;
+    return index < numEpochs - 1n ? split : amount - split * (numEpochs - 1n);
+};
+/**
+ * Projects what the RWA gauge system receives from the RentStreamer in the current and the next epoch, counting
+ * token sent to the streamer but not yet synced as it will be split: from the current epoch when the current epoch
+ * is not released yet, otherwise from the next one. Reads every value at one block.
+ *
+ * Assumes the current epoch is released before it ends; an unreleased bucket rolls into the next release. Rent sent
+ * after this read adds to later buckets, so the next epoch's figure can still grow.
+ *
+ * @param chainId - The chain/network to use.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns Both epochs' deposited, pending and projected amounts in the streamed token's base units.
+ */
+const getEpochProjection = async (chainId, provider) => {
+    if (!provider) {
+        const rpc = chains_1.default[chainId].rpcs[0];
+        provider = new ethers_1.ethers.JsonRpcProvider(rpc);
+    }
+    const block = await provider.getBlock("latest");
+    if (!block)
+        throw new Error("Could not read the latest block");
+    const overrides = { blockTag: block.number };
+    const currentEpoch = (BigInt(block.timestamp) / WEEK) * WEEK;
+    const nextEpoch = currentEpoch + WEEK;
+    const streamer = await (0, _helpers_1.getRentStreamerContract)(chainId, provider);
+    const [token, distributorAddress, numEpochs, maxBountyFee, killed, processed, lastEpochProcessed, preview, scheduledNext] = await Promise.all([
+        streamer.TOKEN(overrides),
+        streamer.GAUGE_REWARD_DISTRIBUTOR(overrides),
+        streamer.numEpochs(overrides),
+        streamer.maxBountyFee(overrides),
+        streamer.killed(overrides),
+        streamer.processed(overrides),
+        streamer.lastEpochProcessed(overrides),
+        streamer.previewRelease(overrides),
+        streamer.scheduled(nextEpoch, overrides),
+    ]);
+    const erc20 = new ethers_1.ethers.Contract(token, ["function balanceOf(address) view returns (uint256)"], provider);
+    const distributor = new ethers_1.ethers.Contract(distributorAddress, (0, artifacts_1.getABI)("gaugerewardsdistributor"), provider);
+    const [balance, depositedCurrent] = await Promise.all([
+        erc20.balanceOf(await streamer.getAddress(), overrides),
+        distributor.depositedAtEpoch(token, currentEpoch, overrides),
+    ]);
+    const epochs = BigInt(numEpochs);
+    const unsynced = balance - processed;
+    const currentReleased = lastEpochProcessed >= currentEpoch;
+    // previewRelease already counts every unreleased bucket up to now plus the first split of the unsynced amount.
+    const pendingCurrent = killed ? 0n : preview[0];
+    // Unsynced token is split from the current epoch at its release, or from the next epoch once the current one is released.
+    const pendingNext = killed ? 0n : scheduledNext + bucketShare(unsynced, epochs, currentReleased ? 0n : 1n);
+    const amount = (value) => (0, amount_1.toTokenAmount)(chainId, token, value);
+    const project = (epoch, deposited, pending) => {
+        const maxBounty = (pending * maxBountyFee) / BOUNTY_PRECISION;
+        return {
+            epoch: Number(epoch),
+            deposited: amount(deposited),
+            pending: amount(pending),
+            maxBounty: amount(maxBounty),
+            projected: amount(deposited + pending - maxBounty),
+        };
+    };
+    return {
+        token,
+        numEpochs: Number(numEpochs),
+        killed,
+        currentReleased,
+        unsynced: amount(unsynced),
+        current: project(currentEpoch, depositedCurrent, pendingCurrent),
+        next: project(nextEpoch, 0n, pendingNext),
+    };
+};
+exports.getEpochProjection = getEpochProjection;

package/dist/types/RPCLibrary.d.ts

@@ -91,6 +91,7 @@ import claimRewardFromPool from "./contracts/feeCollector/claimRewardFromPool";
 import { getState as getStateRentStreamer } from "./contracts/rentStreamer/getState";
 import { previewRelease as previewReleaseRentStreamer } from "./contracts/rentStreamer/previewRelease";
 import { getScheduled as getScheduledRentStreamer } from "./contracts/rentStreamer/getScheduled";
+import { getEpochProjection as getEpochProjectionRentStreamer } from "./contracts/rentStreamer/getEpochProjection";
 import { sync as syncRentStreamer } from "./contracts/rentStreamer/sync";
 import { release as releaseRentStreamer } from "./contracts/rentStreamer/release";
 import getRawUserDepositsInLendingPool from "./pools/lendingPool/getRawUserDepositsInLendingPool";
@@ -408,6 +409,7 @@ declare class RPCLibrary {
             getState: typeof getStateRentStreamer;
             previewRelease: typeof previewReleaseRentStreamer;
             getScheduled: typeof getScheduledRentStreamer;
+            getEpochProjection: typeof getEpochProjectionRentStreamer;
             sync: typeof syncRentStreamer;
             release: typeof releaseRentStreamer;
         };

package/dist/types/contracts/rentStreamer/getEpochProjection.d.ts

@@ -0,0 +1,40 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../configs/chains";
+import { TokenAmount } from "../../utils/amount";
+export interface RentStreamerEpochAmount {
+    /** Epoch start timestamp. */
+    epoch: number;
+    /** Already deposited into the RWA GaugeRewardsDistributor for this epoch, by any depositor. Always zero for the next epoch. */
+    deposited: TokenAmount;
+    /** What the streamer will release into this epoch from what it holds now, before the keeper bounty. */
+    pending: TokenAmount;
+    /** Keeper bounty on `pending` at the maximum fee. */
+    maxBounty: TokenAmount;
+    /** `deposited + pending - maxBounty`: the least this epoch receives from what is deposited or held now. */
+    projected: TokenAmount;
+}
+export interface RentStreamerEpochProjection {
+    /** Streamed token (USDC). */
+    token: string;
+    numEpochs: number;
+    killed: boolean;
+    /** Whether the current epoch's release already happened. */
+    currentReleased: boolean;
+    /** Token sent to the streamer and not yet split into buckets: balance - processed. */
+    unsynced: TokenAmount;
+    current: RentStreamerEpochAmount;
+    next: RentStreamerEpochAmount;
+}
+/**
+ * Projects what the RWA gauge system receives from the RentStreamer in the current and the next epoch, counting
+ * token sent to the streamer but not yet synced as it will be split: from the current epoch when the current epoch
+ * is not released yet, otherwise from the next one. Reads every value at one block.
+ *
+ * Assumes the current epoch is released before it ends; an unreleased bucket rolls into the next release. Rent sent
+ * after this read adds to later buckets, so the next epoch's figure can still grow.
+ *
+ * @param chainId - The chain/network to use.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns Both epochs' deposited, pending and projected amounts in the streamed token's base units.
+ */
+export declare const getEpochProjection: (chainId: ChainId, provider?: Provider) => Promise<RentStreamerEpochProjection>;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@raac/rpc",
-	"version": "2.0.0-beta.10",
+	"version": "2.0.0-beta.11",
 	"description": "RPC Library for RAAC",
 	"main": "dist/index.js",
 	"types": "dist/types/index.d.ts",