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

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

@@ -0,0 +1,163 @@
+"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 _helpers_1 = require("../gaugeSystems/_helpers");
+const E18 = 10n ** 18n;
+/**
+ * Per-epoch emissions for a gauge. The GaugeController snapshots gauge weights per epoch
+ * and the GaugeRewardsDistributor records the RAAC deposited per epoch, so for a COMPLETED
+ * epoch a gauge's emission is:
+ *   depositedAtEpoch(epoch) × gaugeRelativeWeight(gauge, epoch).
+ *
+ * For the in-progress epoch, `depositedAtEpoch` only reflects what has been ticked in so
+ * far and keeps growing through the week — which is misleading. Since the emission schedule
+ * already determines the full week's emission, the current (and upcoming) epoch instead use
+ *   scheduledWeekEmission(epoch) × gaugeRelativeWeight(gauge, epoch)
+ * where scheduledWeekEmission = minter.calculateScheduledMintableAmount(week) × distributorShare.
+ *
+ * @param chainId - The chain/network to use.
+ * @param gaugeSystem - Gauge system id ("raacgauges" or "rwagauges").
+ * @param gaugeAddressOrId - Address or config id of the gauge.
+ * @param numEpochs - How many epochs to include, ending at the current one (default 8), clamped to the gauge's start.
+ * @param includeUpcoming - Whether to append a projection for the next epoch (default true).
+ * @param provider - Optional ethers.js Provider instance.
+ */
+const getGaugeEmissions = async (chainId, gaugeSystem, gaugeAddressOrId, numEpochs = 8, includeUpcoming = true, provider) => {
+    if (!provider) {
+        const rpc = chains_1.default[chainId].rpcs[0];
+        provider = new ethers_1.ethers.JsonRpcProvider(rpc);
+    }
+    const gauge = (0, _helpers_1.resolveGauge)(chainId, gaugeAddressOrId);
+    const distAddr = (0, _helpers_1.resolveGaugeDistributor)(chainId, gaugeSystem);
+    const controller = new ethers_1.ethers.Contract((0, _helpers_1.resolveGaugeController)(chainId, gaugeSystem), (0, artifacts_1.getABI)("gaugecontroller"), provider);
+    const distributor = new ethers_1.ethers.Contract(distAddr, (0, artifacts_1.getABI)("gaugerewardsdistributor"), provider);
+    const gaugeContract = new ethers_1.ethers.Contract(gauge, (0, artifacts_1.getABI)("basegauge"), provider);
+    const [weekBn, currentEpochBn, gaugeData, rewardToken] = await Promise.all([
+        controller.WEEK(),
+        controller.getCurrentEpoch(),
+        gaugeContract.gaugeData(),
+        distributor.rewardToken(),
+    ]);
+    const week = BigInt(weekBn);
+    const currentEpoch = BigInt(currentEpochBn);
+    const gaugeStart = BigInt(gaugeData.gaugeInitialStartTime ?? gaugeData[0] ?? 0n);
+    const startEpoch = gaugeStart > 0n ? (gaugeStart / week) * week : currentEpoch;
+    // ── Distributor's share of the minter + scheduled-emission helper ─────────
+    // The schedule deterministically sets each week's system emission, so we use it for
+    // the in-progress and upcoming epochs (where depositedAtEpoch is partial/zero).
+    let distShare = 0n; // 1e18-scaled fraction of the minter routed to the distributor
+    let minter = null;
+    try {
+        minter = new ethers_1.ethers.Contract((0, getContractAddress_1.getContractAddress)(chainId, "raacminter"), (0, artifacts_1.getABI)("raacminter"), provider);
+        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 — scheduled emission stays 0 */
+    }
+    const scheduledSystemEmission = async (epochStart) => {
+        if (!minter || distShare === 0n)
+            return 0n;
+        try {
+            const minterWeekly = BigInt(await minter.calculateScheduledMintableAmount(epochStart, epochStart + week));
+            return (minterWeekly * distShare) / E18;
+        }
+        catch {
+            return 0n;
+        }
+    };
+    // 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) => {
+        const isCurrent = e === currentEpoch;
+        let depositedSoFar = 0n;
+        let relativeWeight = 0n;
+        try {
+            depositedSoFar = 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 */
+        }
+        // Past epochs: use the actual deposited. Current (in-progress) epoch: use the
+        // scheduled full-week emission (deposited is still partial/tick-based).
+        let systemEmission = depositedSoFar;
+        if (isCurrent) {
+            const scheduled = await scheduledSystemEmission(e);
+            systemEmission = scheduled > depositedSoFar ? scheduled : depositedSoFar;
+        }
+        const gaugeEmissionRaw = (systemEmission * relativeWeight) / E18;
+        return {
+            epoch: Number(e),
+            deposited: ethers_1.ethers.formatEther(systemEmission),
+            depositedSoFar: ethers_1.ethers.formatEther(depositedSoFar),
+            relativeWeight,
+            relativeWeightPct: Number((relativeWeight * 10000n) / E18) / 100,
+            gaugeEmission: ethers_1.ethers.formatEther(gaugeEmissionRaw),
+            gaugeEmissionRaw,
+            isCurrent,
+        };
+    }));
+    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 the
+    // deposit is projected from the same emission schedule.
+    if (includeUpcoming) {
+        const nextEpoch = currentEpoch + week;
+        let relNext = 0n;
+        try {
+            const [rel] = await controller.getGaugeRelativeWeightView(gauge, nextEpoch);
+            relNext = BigInt(rel);
+        }
+        catch {
+            /* no projected snapshot */
+        }
+        const projectedSystem = await scheduledSystemEmission(nextEpoch);
+        const projectedRaw = (projectedSystem * relNext) / E18;
+        epochs.push({
+            epoch: Number(nextEpoch),
+            deposited: ethers_1.ethers.formatEther(projectedSystem),
+            depositedSoFar: "0",
+            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",
+        currentWeekDepositedSoFar: current ? current.depositedSoFar : "0",
+        epochs,
+    };
+};
+exports.getGaugeEmissions = getGaugeEmissions;

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGaugeRelativeWeight = void 0;
+const ethers_1 = require("ethers");
+const artifacts_1 = require("../../../utils/artifacts");
+const _helpers_1 = require("../gaugeSystems/_helpers");
+const _helpers_2 = require("../_helpers");
+/**
+ * Checkpoints a gauge and computes its relative weight at an epoch. State-changing; use `getGaugeRelativeWeightView` to read without a transaction. Reverts during a global pause.
+ *
+ * @param chainId - The chain/network to use.
+ * @param gaugeSystem - Gauge system id ("raacgauges" or "rwagauges") or a GaugeController address.
+ * @param gaugeAddressOrId - Address or config id of the gauge.
+ * @param epoch - Epoch start timestamp, seconds.
+ * @param signer - An ethers.js Signer instance (required).
+ * @returns The transaction after it has been mined.
+ */
+const getGaugeRelativeWeight = async (chainId, gaugeSystem, gaugeAddressOrId, epoch, signer) => {
+    if (!signer)
+        throw new Error("Signer is required");
+    const address = (0, _helpers_1.resolveGaugeController)(chainId, gaugeSystem);
+    const gaugeAddress = (0, _helpers_1.resolveGauge)(chainId, gaugeAddressOrId);
+    const contract = new ethers_1.ethers.Contract(address, (0, artifacts_1.getABI)("gaugecontroller"), signer);
+    try {
+        const tx = await contract.getGaugeRelativeWeight(gaugeAddress, epoch);
+        await tx.wait();
+        return tx;
+    }
+    catch (error) {
+        throw (0, _helpers_2.toGovernanceTxError)("Failed to checkpoint gauge relative weight", error);
+    }
+};
+exports.getGaugeRelativeWeight = getGaugeRelativeWeight;

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

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGaugeRelativeWeightView = void 0;
+const ethers_1 = require("ethers");
+const chains_1 = __importDefault(require("../../../configs/chains"));
+const artifacts_1 = require("../../../utils/artifacts");
+const _helpers_1 = require("../gaugeSystems/_helpers");
+/**
+ * Returns a gauge's relative weight at an epoch without checkpointing.
+ *
+ * @param chainId - The chain/network to use.
+ * @param gaugeSystem - Gauge system id ("raacgauges" or "rwagauges") or a GaugeController address.
+ * @param gaugeAddressOrId - Address or config id of the gauge.
+ * @param epoch - Epoch start timestamp, seconds.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns relativeWeight (1e18 = 100%) and the total weight at that epoch.
+ */
+const getGaugeRelativeWeightView = async (chainId, gaugeSystem, gaugeAddressOrId, epoch, provider) => {
+    if (!provider) {
+        const rpc = chains_1.default[chainId].rpcs[0];
+        provider = new ethers_1.ethers.JsonRpcProvider(rpc);
+    }
+    const address = (0, _helpers_1.resolveGaugeController)(chainId, gaugeSystem);
+    const gaugeAddress = (0, _helpers_1.resolveGauge)(chainId, gaugeAddressOrId);
+    const contract = new ethers_1.ethers.Contract(address, (0, artifacts_1.getABI)("gaugecontroller"), provider);
+    const [relativeWeight, totalWeight] = await contract.getGaugeRelativeWeightView(gaugeAddress, epoch);
+    return { relativeWeight, totalWeight };
+};
+exports.getGaugeRelativeWeightView = getGaugeRelativeWeightView;

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

@@ -6,23 +6,25 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getGaugeWeight = void 0;
 const ethers_1 = require("ethers");
 const chains_1 = __importDefault(require("../../../configs/chains"));
-const getContractAddress_1 = require("../../getContractAddress");
-const GET_GAUGE_WEIGHT_ABI = "function getGaugeWeight(address gauge) view returns (uint256)";
+const artifacts_1 = require("../../../utils/artifacts");
+const _helpers_1 = require("../gaugeSystems/_helpers");
 /**
- * Gets the weight of a gauge.
+ * Returns a gauge's weight at the current epoch.
  *
  * @param chainId - The chain/network to use.
- * @param gaugeAddress - Address of the gauge.
+ * @param gaugeSystem - Gauge system id ("raacgauges" or "rwagauges") or a GaugeController address.
+ * @param gaugeAddressOrId - Address or config id of the gauge.
  * @param provider - Optional ethers.js Provider instance.
- * @returns Weight of the gauge formatted in ether units.
+ * @returns The weight formatted in ether units.
  */
-const getGaugeWeight = async (chainId, gaugeAddress, provider) => {
+const getGaugeWeight = async (chainId, gaugeSystem, gaugeAddressOrId, provider) => {
     if (!provider) {
         const rpc = chains_1.default[chainId].rpcs[0];
         provider = new ethers_1.ethers.JsonRpcProvider(rpc);
     }
-    const contractAddress = (0, getContractAddress_1.getContractAddress)(chainId, "gaugecontroller");
-    const contract = new ethers_1.ethers.Contract(contractAddress, [GET_GAUGE_WEIGHT_ABI], provider);
+    const address = (0, _helpers_1.resolveGaugeController)(chainId, gaugeSystem);
+    const gaugeAddress = (0, _helpers_1.resolveGauge)(chainId, gaugeAddressOrId);
+    const contract = new ethers_1.ethers.Contract(address, (0, artifacts_1.getABI)("gaugecontroller"), provider);
     const weight = await contract.getGaugeWeight(gaugeAddress);
     return ethers_1.ethers.formatEther(weight);
 };

package/dist/contracts/governance/gaugeController/getLastVoteTime.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.getLastVoteTime = void 0;
+const ethers_1 = require("ethers");
+const chains_1 = __importDefault(require("../../../configs/chains"));
+const artifacts_1 = require("../../../utils/artifacts");
+const _helpers_1 = require("../gaugeSystems/_helpers");
+/**
+ * Returns when a user last voted on a gauge.
+ *
+ * @param chainId - The chain/network to use.
+ * @param gaugeSystem - Gauge system id ("raacgauges" or "rwagauges") or a GaugeController address.
+ * @param user - Address of the user.
+ * @param gaugeAddressOrId - Address or config id of the gauge.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The last vote timestamp, seconds.
+ */
+const getLastVoteTime = async (chainId, gaugeSystem, user, gaugeAddressOrId, provider) => {
+    if (!provider) {
+        const rpc = chains_1.default[chainId].rpcs[0];
+        provider = new ethers_1.ethers.JsonRpcProvider(rpc);
+    }
+    const address = (0, _helpers_1.resolveGaugeController)(chainId, gaugeSystem);
+    const gaugeAddress = (0, _helpers_1.resolveGauge)(chainId, gaugeAddressOrId);
+    const contract = new ethers_1.ethers.Contract(address, (0, artifacts_1.getABI)("gaugecontroller"), provider);
+    return contract.lastVoteTime(user, gaugeAddress);
+};
+exports.getLastVoteTime = getLastVoteTime;

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

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMaxVoteBuckets = void 0;
+const ethers_1 = require("ethers");
+const chains_1 = __importDefault(require("../../../configs/chains"));
+const artifacts_1 = require("../../../utils/artifacts");
+const _helpers_1 = require("../gaugeSystems/_helpers");
+/**
+ * Returns the per-vote decay-bucket cap. 0 means exact (one entry per lock).
+ *
+ * @param chainId - The chain/network to use.
+ * @param gaugeSystem - Gauge system id ("raacgauges" or "rwagauges") or a GaugeController address.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The bucket cap.
+ */
+const getMaxVoteBuckets = async (chainId, gaugeSystem, provider) => {
+    if (!provider) {
+        const rpc = chains_1.default[chainId].rpcs[0];
+        provider = new ethers_1.ethers.JsonRpcProvider(rpc);
+    }
+    const address = (0, _helpers_1.resolveGaugeController)(chainId, gaugeSystem);
+    const contract = new ethers_1.ethers.Contract(address, (0, artifacts_1.getABI)("gaugecontroller"), provider);
+    return contract.maxVoteBuckets();
+};
+exports.getMaxVoteBuckets = getMaxVoteBuckets;

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

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNextEpoch = void 0;
+const ethers_1 = require("ethers");
+const chains_1 = __importDefault(require("../../../configs/chains"));
+const artifacts_1 = require("../../../utils/artifacts");
+const _helpers_1 = require("../gaugeSystems/_helpers");
+/**
+ * Returns the start timestamp of the controller's next epoch. Votes cast now take effect at this epoch.
+ *
+ * @param chainId - The chain/network to use.
+ * @param gaugeSystem - Gauge system id ("raacgauges" or "rwagauges") or a GaugeController address.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The next epoch timestamp, seconds.
+ */
+const getNextEpoch = async (chainId, gaugeSystem, provider) => {
+    if (!provider) {
+        const rpc = chains_1.default[chainId].rpcs[0];
+        provider = new ethers_1.ethers.JsonRpcProvider(rpc);
+    }
+    const address = (0, _helpers_1.resolveGaugeController)(chainId, gaugeSystem);
+    const contract = new ethers_1.ethers.Contract(address, (0, artifacts_1.getABI)("gaugecontroller"), provider);
+    return contract.getNextEpoch();
+};
+exports.getNextEpoch = getNextEpoch;

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

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRegisteredGaugeList = void 0;
+const ethers_1 = require("ethers");
+const chains_1 = __importDefault(require("../../../configs/chains"));
+const artifacts_1 = require("../../../utils/artifacts");
+const _helpers_1 = require("../gaugeSystems/_helpers");
+/**
+ * Returns every gauge registered on the controller, from `addGauge` until `removeGauge`, emergency-paused ones included.
+ *
+ * @param chainId - The chain/network to use.
+ * @param gaugeSystem - Gauge system id ("raacgauges" or "rwagauges") or a GaugeController address.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The registered gauge addresses.
+ */
+const getRegisteredGaugeList = async (chainId, gaugeSystem, provider) => {
+    if (!provider) {
+        const rpc = chains_1.default[chainId].rpcs[0];
+        provider = new ethers_1.ethers.JsonRpcProvider(rpc);
+    }
+    const address = (0, _helpers_1.resolveGaugeController)(chainId, gaugeSystem);
+    const contract = new ethers_1.ethers.Contract(address, (0, artifacts_1.getABI)("gaugecontroller"), provider);
+    return [...(await contract.getRegisteredGaugeList())];
+};
+exports.getRegisteredGaugeList = getRegisteredGaugeList;

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

@@ -6,22 +6,23 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getTotalWeight = void 0;
 const ethers_1 = require("ethers");
 const chains_1 = __importDefault(require("../../../configs/chains"));
-const getContractAddress_1 = require("../../getContractAddress");
-const GET_TOTAL_WEIGHT_ABI = "function getTotalWeight() view returns (uint256)";
+const artifacts_1 = require("../../../utils/artifacts");
+const _helpers_1 = require("../gaugeSystems/_helpers");
 /**
- * Gets the total weight of all active gauges.
+ * Returns the sum of all gauge weights at the current epoch.
  *
  * @param chainId - The chain/network to use.
+ * @param gaugeSystem - Gauge system id ("raacgauges" or "rwagauges") or a GaugeController address.
  * @param provider - Optional ethers.js Provider instance.
- * @returns Total weight of all active gauges formatted in ether units.
+ * @returns The total weight formatted in ether units.
  */
-const getTotalWeight = async (chainId, provider) => {
+const getTotalWeight = async (chainId, gaugeSystem, provider) => {
     if (!provider) {
         const rpc = chains_1.default[chainId].rpcs[0];
         provider = new ethers_1.ethers.JsonRpcProvider(rpc);
     }
-    const contractAddress = (0, getContractAddress_1.getContractAddress)(chainId, "gaugecontroller");
-    const contract = new ethers_1.ethers.Contract(contractAddress, [GET_TOTAL_WEIGHT_ABI], provider);
+    const address = (0, _helpers_1.resolveGaugeController)(chainId, gaugeSystem);
+    const contract = new ethers_1.ethers.Contract(address, (0, artifacts_1.getABI)("gaugecontroller"), provider);
     const totalWeight = await contract.getTotalWeight();
     return ethers_1.ethers.formatEther(totalWeight);
 };

package/dist/contracts/governance/gaugeController/getUserGaugeVotePower.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.getUserGaugeVotePower = void 0;
+const ethers_1 = require("ethers");
+const chains_1 = __importDefault(require("../../../configs/chains"));
+const artifacts_1 = require("../../../utils/artifacts");
+const _helpers_1 = require("../gaugeSystems/_helpers");
+/**
+ * Returns the vote power a user has allocated to a gauge.
+ *
+ * @param chainId - The chain/network to use.
+ * @param gaugeSystem - Gauge system id ("raacgauges" or "rwagauges") or a GaugeController address.
+ * @param user - Address of the user.
+ * @param gaugeAddressOrId - Address or config id of the gauge.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The allocated vote power.
+ */
+const getUserGaugeVotePower = async (chainId, gaugeSystem, user, gaugeAddressOrId, provider) => {
+    if (!provider) {
+        const rpc = chains_1.default[chainId].rpcs[0];
+        provider = new ethers_1.ethers.JsonRpcProvider(rpc);
+    }
+    const address = (0, _helpers_1.resolveGaugeController)(chainId, gaugeSystem);
+    const gaugeAddress = (0, _helpers_1.resolveGauge)(chainId, gaugeAddressOrId);
+    const contract = new ethers_1.ethers.Contract(address, (0, artifacts_1.getABI)("gaugecontroller"), provider);
+    return contract.getUserGaugeVotePower(user, gaugeAddress);
+};
+exports.getUserGaugeVotePower = getUserGaugeVotePower;

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

@@ -6,24 +6,25 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getUserVotePowerRemaining = void 0;
 const ethers_1 = require("ethers");
 const chains_1 = __importDefault(require("../../../configs/chains"));
-const getContractAddress_1 = require("../../getContractAddress");
-const GET_USER_VOTE_POWER_REMAINING_ABI = "function getUserVotePowerRemaining(address user) view returns (uint256)";
+const artifacts_1 = require("../../../utils/artifacts");
+const _helpers_1 = require("../gaugeSystems/_helpers");
 /**
- * Get user's remaining voting power available.
+ * Returns the vote weight a user has not yet allocated, in basis points.
  *
  * @param chainId - The chain/network to use.
- * @param userAddress - Address of the user.
+ * @param gaugeSystem - Gauge system id ("raacgauges" or "rwagauges") or a GaugeController address.
+ * @param user - Address of the user.
  * @param provider - Optional ethers.js Provider instance.
- * @returns Remaining voting power in basis points (0-10000).
+ * @returns The remaining vote weight.
  */
-const getUserVotePowerRemaining = async (chainId, userAddress, provider) => {
+const getUserVotePowerRemaining = async (chainId, gaugeSystem, user, provider) => {
     if (!provider) {
         const rpc = chains_1.default[chainId].rpcs[0];
         provider = new ethers_1.ethers.JsonRpcProvider(rpc);
     }
-    const contractAddress = (0, getContractAddress_1.getContractAddress)(chainId, "gaugecontroller");
-    const contract = new ethers_1.ethers.Contract(contractAddress, [GET_USER_VOTE_POWER_REMAINING_ABI], provider);
-    const remaining = await contract.getUserVotePowerRemaining(userAddress);
+    const address = (0, _helpers_1.resolveGaugeController)(chainId, gaugeSystem);
+    const contract = new ethers_1.ethers.Contract(address, (0, artifacts_1.getABI)("gaugecontroller"), provider);
+    const remaining = await contract.getUserVotePowerRemaining(user);
     return Number(remaining);
 };
 exports.getUserVotePowerRemaining = getUserVotePowerRemaining;

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

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVeToken = void 0;
+const ethers_1 = require("ethers");
+const chains_1 = __importDefault(require("../../../configs/chains"));
+const artifacts_1 = require("../../../utils/artifacts");
+const _helpers_1 = require("../gaugeSystems/_helpers");
+/**
+ * Returns the voting escrow token the controller reads vote power from.
+ *
+ * @param chainId - The chain/network to use.
+ * @param gaugeSystem - Gauge system id ("raacgauges" or "rwagauges") or a GaugeController address.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The veToken address.
+ */
+const getVeToken = async (chainId, gaugeSystem, provider) => {
+    if (!provider) {
+        const rpc = chains_1.default[chainId].rpcs[0];
+        provider = new ethers_1.ethers.JsonRpcProvider(rpc);
+    }
+    const address = (0, _helpers_1.resolveGaugeController)(chainId, gaugeSystem);
+    const contract = new ethers_1.ethers.Contract(address, (0, artifacts_1.getABI)("gaugecontroller"), provider);
+    return contract.veToken();
+};
+exports.getVeToken = getVeToken;

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

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVoteUserLocks = void 0;
+const ethers_1 = require("ethers");
+const chains_1 = __importDefault(require("../../../configs/chains"));
+const artifacts_1 = require("../../../utils/artifacts");
+const _helpers_1 = require("../gaugeSystems/_helpers");
+/**
+ * Returns the per-lock entries backing a user's vote on a gauge.
+ *
+ * @param chainId - The chain/network to use.
+ * @param gaugeSystem - Gauge system id ("raacgauges" or "rwagauges") or a GaugeController address.
+ * @param user - Address of the user.
+ * @param gaugeAddressOrId - Address or config id of the gauge.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns Each entry's locked amount and unlock time.
+ */
+const getVoteUserLocks = async (chainId, gaugeSystem, user, gaugeAddressOrId, provider) => {
+    if (!provider) {
+        const rpc = chains_1.default[chainId].rpcs[0];
+        provider = new ethers_1.ethers.JsonRpcProvider(rpc);
+    }
+    const address = (0, _helpers_1.resolveGaugeController)(chainId, gaugeSystem);
+    const gaugeAddress = (0, _helpers_1.resolveGauge)(chainId, gaugeAddressOrId);
+    const contract = new ethers_1.ethers.Contract(address, (0, artifacts_1.getABI)("gaugecontroller"), provider);
+    const entries = await contract.getVoteUserLocks(user, gaugeAddress);
+    return entries.map(([locked, unlockTime]) => ({ locked, unlockTime }));
+};
+exports.getVoteUserLocks = getVoteUserLocks;

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

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVoteUserPower = void 0;
+const ethers_1 = require("ethers");
+const chains_1 = __importDefault(require("../../../configs/chains"));
+const artifacts_1 = require("../../../utils/artifacts");
+const _helpers_1 = require("../gaugeSystems/_helpers");
+/**
+ * Returns the total vote weight a user has allocated across gauges, in basis points.
+ *
+ * @param chainId - The chain/network to use.
+ * @param gaugeSystem - Gauge system id ("raacgauges" or "rwagauges") or a GaugeController address.
+ * @param user - Address of the user.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The allocated vote weight.
+ */
+const getVoteUserPower = async (chainId, gaugeSystem, user, provider) => {
+    if (!provider) {
+        const rpc = chains_1.default[chainId].rpcs[0];
+        provider = new ethers_1.ethers.JsonRpcProvider(rpc);
+    }
+    const address = (0, _helpers_1.resolveGaugeController)(chainId, gaugeSystem);
+    const contract = new ethers_1.ethers.Contract(address, (0, artifacts_1.getABI)("gaugecontroller"), provider);
+    return contract.voteUserPower(user);
+};
+exports.getVoteUserPower = getVoteUserPower;

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

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVoteUserSlope = void 0;
+const ethers_1 = require("ethers");
+const chains_1 = __importDefault(require("../../../configs/chains"));
+const artifacts_1 = require("../../../utils/artifacts");
+const _helpers_1 = require("../gaugeSystems/_helpers");
+/**
+ * Reads a user's vote on a gauge from the public `voteUserSlopes` mapping.
+ *
+ * @param chainId - The chain/network to use.
+ * @param gaugeSystem - Gauge system id ("raacgauges" or "rwagauges") or a GaugeController address.
+ * @param user - Address of the user.
+ * @param gaugeAddressOrId - Address or config id of the gauge.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns locked amount, vote power and the vote timestamp.
+ */
+const getVoteUserSlope = async (chainId, gaugeSystem, user, gaugeAddressOrId, provider) => {
+    if (!provider) {
+        const rpc = chains_1.default[chainId].rpcs[0];
+        provider = new ethers_1.ethers.JsonRpcProvider(rpc);
+    }
+    const address = (0, _helpers_1.resolveGaugeController)(chainId, gaugeSystem);
+    const gaugeAddress = (0, _helpers_1.resolveGauge)(chainId, gaugeAddressOrId);
+    const contract = new ethers_1.ethers.Contract(address, (0, artifacts_1.getABI)("gaugecontroller"), provider);
+    const [locked, power, voteTs] = await contract.voteUserSlopes(user, gaugeAddress);
+    return { locked, power, voteTs };
+};
+exports.getVoteUserSlope = getVoteUserSlope;