@raac/rpc 1.2.0-beta.6 → 1.2.0-beta.7

package/dist/configs/chains/11155111.json

@@ -298,8 +298,11 @@
             "id": "RAAC_RcrvUSD",
             "name": "RAAC RcrvUSD Gauge",
             "type": "RAACGauge",
-            "contract": "0xE8eBe8294542d47f481c17036C8165CB8935554a",
-            "stakingToken": "0x062a641EF54810B321f123487fFf083cadB50989"
+            "contract": "0xc6e49678e7a7D797Cb11EE5D2834A3896200096D",
+            "stakingToken": "0xa610498F28448Eb379BFD3179381F6f094ad110b",
+            "wrapped": true,
+            "underlying": "0x062a641EF54810B321f123487fFf083cadB50989",
+            "wrapper": "0xa610498F28448Eb379BFD3179381F6f094ad110b"
         },
         "raac_crvusd_lp": {
             "id": "RAAC_crvUSD_LP",
@@ -307,6 +310,14 @@
             "type": "RAACGauge",
             "contract": "0x04F3e12A814b21B9F947c726be512719a41b980f",
             "stakingToken": "0xCfDBbad91770fb7Fd57e623A59dcbD14670164c7"
+        },
+        "raac_rcrvusd_old": {
+            "id": "RAAC_RcrvUSD_old",
+            "name": "RAAC RcrvUSD Gauge (deprecated)",
+            "type": "RAACGauge",
+            "contract": "0xE8eBe8294542d47f481c17036C8165CB8935554a",
+            "stakingToken": "0x062a641EF54810B321f123487fFf083cadB50989",
+            "_note": "Replaced by raac_rcrvusd (wrapped). Active state is read on-chain; reclaim stuck votes via removePowerFromGauge."
         }
     }
 }

package/dist/contracts/governance/gaugeController/getGaugeEmissions.js

@@ -0,0 +1,136 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGaugeEmissions = void 0;
+const ethers_1 = require("ethers");
+const chains_1 = __importDefault(require("../../../configs/chains"));
+const getContractAddress_1 = require("../../getContractAddress");
+const artifacts_1 = require("../../../utils/artifacts");
+const E18 = 10n ** 18n;
+/**
+ * Per-epoch emissions actually received by a gauge: the GaugeController snapshots
+ * gauge weights per epoch, and the GaugeRewardsDistributor records the RAAC deposited
+ * per epoch. A gauge's emission for an epoch is therefore
+ *   depositedAtEpoch(epoch) × gaugeRelativeWeight(gauge, epoch).
+ *
+ * Returns a series ending at the current (in-progress) epoch so callers can chart
+ * "week of X → this gauge received Y RAAC".
+ *
+ * @param chainId - The chain/network to use.
+ * @param gauge - Gauge address (or config key).
+ * @param numEpochs - How many epochs to include, ending at the current one (default 8).
+ * @param provider - Optional ethers.js Provider instance.
+ */
+const getGaugeEmissions = async (chainId, gauge, numEpochs = 8, includeUpcoming = true, provider) => {
+    if (!provider) {
+        const rpc = chains_1.default[chainId].rpcs[0];
+        provider = new ethers_1.ethers.JsonRpcProvider(rpc);
+    }
+    const controller = new ethers_1.ethers.Contract((0, getContractAddress_1.getContractAddress)(chainId, "gaugecontroller"), (0, artifacts_1.getABI)("gaugecontroller"), provider);
+    const distributor = new ethers_1.ethers.Contract((0, getContractAddress_1.getContractAddress)(chainId, "gaugerewardsdistributor"), (0, artifacts_1.getABI)("gaugerewardsdistributor"), provider);
+    const [weekBn, currentEpochBn, startEpochBn, rewardToken] = await Promise.all([
+        controller.WEEK(),
+        controller.getCurrentEpoch(),
+        distributor.startEpoch(),
+        distributor.rewardToken(),
+    ]);
+    const week = BigInt(weekBn);
+    const currentEpoch = BigInt(currentEpochBn);
+    const startEpoch = BigInt(startEpochBn) > 0n ? BigInt(startEpochBn) : currentEpoch;
+    // Window: [currentEpoch - (numEpochs-1)*week .. currentEpoch], clamped to startEpoch.
+    const span = BigInt(Math.max(1, numEpochs) - 1) * week;
+    let from = currentEpoch - span;
+    if (from < startEpoch)
+        from = startEpoch;
+    const epochList = [];
+    for (let e = from; e <= currentEpoch; e += week)
+        epochList.push(e);
+    const epochs = await Promise.all(epochList.map(async (e) => {
+        let deposited = 0n;
+        let relativeWeight = 0n;
+        try {
+            deposited = BigInt(await distributor.depositedAtEpoch(rewardToken, e));
+        }
+        catch {
+            /* ignore */
+        }
+        try {
+            const [rel] = await controller.getGaugeRelativeWeightView(gauge, e);
+            relativeWeight = BigInt(rel);
+        }
+        catch {
+            /* no snapshot at this epoch */
+        }
+        const gaugeEmissionRaw = (deposited * relativeWeight) / E18;
+        return {
+            epoch: Number(e),
+            deposited: ethers_1.ethers.formatEther(deposited),
+            relativeWeight,
+            relativeWeightPct: Number((relativeWeight * 10000n) / E18) / 100,
+            gaugeEmission: ethers_1.ethers.formatEther(gaugeEmissionRaw),
+            gaugeEmissionRaw,
+            isCurrent: e === currentEpoch,
+        };
+    }));
+    const current = epochs[epochs.length - 1];
+    // ── Upcoming-epoch preview ────────────────────────────────────────────────
+    // Votes cast this epoch take effect at nextEpoch, so getGaugeRelativeWeightView
+    // at nextEpoch already reflects current voting. Nothing is deposited yet, so we
+    // project the distributor's deposit from the emission schedule:
+    //   projectedSystem = minterWeekly(nextEpoch) × distributorShareOfMinter
+    //   projectedGauge  = projectedSystem × gaugeRelativeWeight(nextEpoch)
+    if (includeUpcoming) {
+        const nextEpoch = currentEpoch + week;
+        let relNext = 0n;
+        let minterWeekly = 0n;
+        let distShare = 0n; // 1e18-scaled fraction of the minter routed to the distributor
+        try {
+            const [rel] = await controller.getGaugeRelativeWeightView(gauge, nextEpoch);
+            relNext = BigInt(rel);
+        }
+        catch {
+            /* no projected snapshot */
+        }
+        try {
+            const minter = new ethers_1.ethers.Contract((0, getContractAddress_1.getContractAddress)(chainId, "raacminter"), (0, artifacts_1.getABI)("raacminter"), provider);
+            minterWeekly = BigInt(await minter.calculateScheduledMintableAmount(nextEpoch, nextEpoch + week));
+            // distributor's share of the minter's weighted distribution
+            const distAddr = (0, getContractAddress_1.getContractAddress)(chainId, "gaugerewardsdistributor");
+            const [info, totalWeight] = await Promise.all([
+                minter.poolInfo(distAddr),
+                minter.totalWeight(),
+            ]);
+            const poolWeight = BigInt(info.weight ?? info[0] ?? 0n);
+            const exists = Boolean(info.exists ?? info[1]);
+            const tw = BigInt(totalWeight);
+            distShare = exists && tw > 0n ? (poolWeight * E18) / tw : 0n;
+        }
+        catch {
+            /* minter not readable — projection stays 0 */
+        }
+        const projectedSystem = (minterWeekly * distShare) / E18;
+        const projectedRaw = (projectedSystem * relNext) / E18;
+        epochs.push({
+            epoch: Number(nextEpoch),
+            deposited: ethers_1.ethers.formatEther(projectedSystem),
+            relativeWeight: relNext,
+            relativeWeightPct: Number((relNext * 10000n) / E18) / 100,
+            gaugeEmission: ethers_1.ethers.formatEther(projectedRaw),
+            gaugeEmissionRaw: projectedRaw,
+            isCurrent: false,
+            isProjected: true,
+        });
+    }
+    return {
+        gauge,
+        rewardToken,
+        currentEpoch: Number(currentEpoch),
+        weekSeconds: Number(week),
+        relativeWeightPct: current ? current.relativeWeightPct : 0,
+        currentWeekEmission: current ? current.gaugeEmission : "0",
+        epochs,
+    };
+};
+exports.getGaugeEmissions = getGaugeEmissions;

package/dist/contracts/governance/gaugeController/index.js

@@ -25,6 +25,7 @@ __exportStar(require("./getCurrentEpoch"), exports);
 __exportStar(require("./getGauge"), exports);
 __exportStar(require("./getGaugeRelativeWeight"), exports);
 __exportStar(require("./getGaugeRelativeWeightView"), exports);
+__exportStar(require("./getGaugeEmissions"), exports);
 __exportStar(require("./getGaugeWeight"), exports);
 __exportStar(require("./getLastVoteTime"), exports);
 __exportStar(require("./getNextEpoch"), exports);

package/dist/types/contracts/governance/gaugeController/getGaugeEmissions.d.ts

@@ -0,0 +1,51 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+export interface GaugeEpochEmission {
+    /** Epoch (Unix-week) start timestamp, seconds. */
+    epoch: number;
+    /** Reward token deposited into the distributor for this epoch (formatted). */
+    deposited: string;
+    /** Gauge relative weight at this epoch, 1e18-scaled (1e18 = 100%). */
+    relativeWeight: bigint;
+    /** Gauge relative weight as a percentage 0..100. */
+    relativeWeightPct: number;
+    /** RAAC this gauge received/was allocated for this epoch = deposited × relativeWeight. */
+    gaugeEmission: string;
+    gaugeEmissionRaw: bigint;
+    /** True for the in-progress (current) epoch — `deposited` may still grow via tick(). */
+    isCurrent: boolean;
+    /**
+     * True for the upcoming (next) epoch preview. Nothing is deposited yet, so `deposited`
+     * is the PROJECTED system emission for that week (schedule × distributor share) and
+     * `gaugeEmission` is the projection from the gauge's weight at `nextEpoch` — i.e. what
+     * this gauge would receive if voting stays as it currently stands.
+     */
+    isProjected?: boolean;
+}
+export interface GaugeEmissionsResult {
+    gauge: string;
+    rewardToken: string;
+    currentEpoch: number;
+    weekSeconds: number;
+    /** Current-epoch gauge relative weight as a percentage 0..100. */
+    relativeWeightPct: number;
+    /** RAAC allocated to this gauge for the current (in-progress) epoch. */
+    currentWeekEmission: string;
+    /** Per-epoch series, oldest → newest, ending at the current epoch. */
+    epochs: GaugeEpochEmission[];
+}
+/**
+ * Per-epoch emissions actually received by a gauge: the GaugeController snapshots
+ * gauge weights per epoch, and the GaugeRewardsDistributor records the RAAC deposited
+ * per epoch. A gauge's emission for an epoch is therefore
+ *   depositedAtEpoch(epoch) × gaugeRelativeWeight(gauge, epoch).
+ *
+ * Returns a series ending at the current (in-progress) epoch so callers can chart
+ * "week of X → this gauge received Y RAAC".
+ *
+ * @param chainId - The chain/network to use.
+ * @param gauge - Gauge address (or config key).
+ * @param numEpochs - How many epochs to include, ending at the current one (default 8).
+ * @param provider - Optional ethers.js Provider instance.
+ */
+export declare const getGaugeEmissions: (chainId: ChainId, gauge: string, numEpochs?: number, includeUpcoming?: boolean, provider?: Provider) => Promise<GaugeEmissionsResult>;

package/dist/types/contracts/governance/gaugeController/index.d.ts

@@ -8,6 +8,7 @@ export * from "./getCurrentEpoch";
 export * from "./getGauge";
 export * from "./getGaugeRelativeWeight";
 export * from "./getGaugeRelativeWeightView";
+export * from "./getGaugeEmissions";
 export * from "./getGaugeWeight";
 export * from "./getLastVoteTime";
 export * from "./getNextEpoch";

package/package.json

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