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

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

@@ -1,19 +1,36 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.deposit = exports.getTransferableBalance = exports.getRewardTokens = exports.getRewardTokenInfo = exports.getAvailableBalance = exports.getGaugeRewardTokens = exports.isRewardTokenApproved = exports.isTokenApproved = void 0;
-var isTokenApproved_1 = require("./isTokenApproved");
-Object.defineProperty(exports, "isTokenApproved", { enumerable: true, get: function () { return isTokenApproved_1.isTokenApproved; } });
-var isRewardTokenApproved_1 = require("./isRewardTokenApproved");
-Object.defineProperty(exports, "isRewardTokenApproved", { enumerable: true, get: function () { return isRewardTokenApproved_1.isRewardTokenApproved; } });
-var getGaugeRewardTokens_1 = require("./getGaugeRewardTokens");
-Object.defineProperty(exports, "getGaugeRewardTokens", { enumerable: true, get: function () { return getGaugeRewardTokens_1.getGaugeRewardTokens; } });
-var getAvailableBalance_1 = require("./getAvailableBalance");
-Object.defineProperty(exports, "getAvailableBalance", { enumerable: true, get: function () { return getAvailableBalance_1.getAvailableBalance; } });
-var getRewardTokenInfo_1 = require("./getRewardTokenInfo");
-Object.defineProperty(exports, "getRewardTokenInfo", { enumerable: true, get: function () { return getRewardTokenInfo_1.getRewardTokenInfo; } });
-var getRewardTokens_1 = require("./getRewardTokens");
-Object.defineProperty(exports, "getRewardTokens", { enumerable: true, get: function () { return getRewardTokens_1.getRewardTokens; } });
-var getTransferableBalance_1 = require("./getTransferableBalance");
-Object.defineProperty(exports, "getTransferableBalance", { enumerable: true, get: function () { return getTransferableBalance_1.getTransferableBalance; } });
-var deposit_1 = require("./deposit");
-Object.defineProperty(exports, "deposit", { enumerable: true, get: function () { return deposit_1.deposit; } });
+// Auto-generated barrel: re-exports every method in this namespace.
+__exportStar(require("./claimAll"), exports);
+__exportStar(require("./claimForGauge"), exports);
+__exportStar(require("./deposit"), exports);
+__exportStar(require("./getClaimableForGauge"), exports);
+__exportStar(require("./getClaimedAtEpoch"), exports);
+__exportStar(require("./getDepositedAtEpoch"), exports);
+__exportStar(require("./getDustLastProcessedEpoch"), exports);
+__exportStar(require("./getGaugeController"), exports);
+__exportStar(require("./getLastClaimedEpoch"), exports);
+__exportStar(require("./getMaxClaimBound"), exports);
+__exportStar(require("./getPeriodDuration"), exports);
+__exportStar(require("./getRewardToken"), exports);
+__exportStar(require("./getRewardTokenInfo"), exports);
+__exportStar(require("./getRewardTokenStats"), exports);
+__exportStar(require("./setController"), exports);
+__exportStar(require("./setLastClaimedEpoch"), exports);
+__exportStar(require("./setMaxClaimBound"), exports);
+__exportStar(require("./withdrawDust"), exports);
+__exportStar(require("./withdrawRemovedGaugeRewards"), exports);

package/dist/contracts/governance/distributor/setController.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setController = void 0;
+const ethers_1 = require("ethers");
+const artifacts_1 = require("../../../utils/artifacts");
+const _helpers_1 = require("../gaugeSystems/_helpers");
+const _helpers_2 = require("../_helpers");
+/**
+ * Points the distributor at a different GaugeController. Requires DEFAULT_ADMIN_ROLE.
+ *
+ * @param chainId - The chain/network to use.
+ * @param gaugeSystem - Gauge system id ("raacgauges" or "rwagauges") or a GaugeRewardsDistributor address.
+ * @param controller - Address of the new controller.
+ * @param signer - An ethers.js Signer instance (required).
+ * @returns The transaction after it has been mined.
+ */
+const setController = async (chainId, gaugeSystem, controller, signer) => {
+    if (!signer)
+        throw new Error("Signer is required");
+    const address = (0, _helpers_1.resolveGaugeDistributor)(chainId, gaugeSystem);
+    const contract = new ethers_1.ethers.Contract(address, (0, artifacts_1.getABI)("gaugerewardsdistributor"), signer);
+    try {
+        const tx = await contract.setController(controller);
+        await tx.wait();
+        return tx;
+    }
+    catch (error) {
+        throw (0, _helpers_2.toGovernanceTxError)("Failed to set controller", error);
+    }
+};
+exports.setController = setController;

package/dist/contracts/governance/distributor/setLastClaimedEpoch.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setLastClaimedEpoch = void 0;
+const ethers_1 = require("ethers");
+const artifacts_1 = require("../../../utils/artifacts");
+const _helpers_1 = require("../gaugeSystems/_helpers");
+const _helpers_2 = require("../_helpers");
+/**
+ * Bootstraps a new gauge's claim checkpoint. Requires CONTROLLER_ROLE; the controller calls it from `addGauge`.
+ *
+ * @param chainId - The chain/network to use.
+ * @param gaugeSystem - Gauge system id ("raacgauges" or "rwagauges") or a GaugeRewardsDistributor address.
+ * @param gaugeAddressOrId - Address or config id of the gauge.
+ * @param signer - An ethers.js Signer instance (required).
+ * @returns The transaction after it has been mined.
+ */
+const setLastClaimedEpoch = async (chainId, gaugeSystem, gaugeAddressOrId, signer) => {
+    if (!signer)
+        throw new Error("Signer is required");
+    const address = (0, _helpers_1.resolveGaugeDistributor)(chainId, gaugeSystem);
+    const gaugeAddress = (0, _helpers_1.resolveGauge)(chainId, gaugeAddressOrId);
+    const contract = new ethers_1.ethers.Contract(address, (0, artifacts_1.getABI)("gaugerewardsdistributor"), signer);
+    try {
+        const tx = await contract.setLastClaimedEpoch(gaugeAddress);
+        await tx.wait();
+        return tx;
+    }
+    catch (error) {
+        throw (0, _helpers_2.toGovernanceTxError)("Failed to set last claimed epoch", error);
+    }
+};
+exports.setLastClaimedEpoch = setLastClaimedEpoch;

package/dist/contracts/governance/distributor/setMaxClaimBound.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setMaxClaimBound = void 0;
+const ethers_1 = require("ethers");
+const artifacts_1 = require("../../../utils/artifacts");
+const _helpers_1 = require("../gaugeSystems/_helpers");
+const _helpers_2 = require("../_helpers");
+/**
+ * Caps how many epochs a claim walks per call (MAX_EPOCHS). Requires DISTRIBUTOR_ADMIN.
+ *
+ * @param chainId - The chain/network to use.
+ * @param gaugeSystem - Gauge system id ("raacgauges" or "rwagauges") or a GaugeRewardsDistributor address.
+ * @param enabled - True to cap claim walks.
+ * @param signer - An ethers.js Signer instance (required).
+ * @returns The transaction after it has been mined.
+ */
+const setMaxClaimBound = async (chainId, gaugeSystem, enabled, signer) => {
+    if (!signer)
+        throw new Error("Signer is required");
+    const address = (0, _helpers_1.resolveGaugeDistributor)(chainId, gaugeSystem);
+    const contract = new ethers_1.ethers.Contract(address, (0, artifacts_1.getABI)("gaugerewardsdistributor"), signer);
+    try {
+        const tx = await contract.setMaxClaimBound(enabled);
+        await tx.wait();
+        return tx;
+    }
+    catch (error) {
+        throw (0, _helpers_2.toGovernanceTxError)("Failed to set max claim bound", error);
+    }
+};
+exports.setMaxClaimBound = setMaxClaimBound;

package/dist/contracts/governance/distributor/withdrawDust.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withdrawDust = void 0;
+const ethers_1 = require("ethers");
+const artifacts_1 = require("../../../utils/artifacts");
+const _helpers_1 = require("../gaugeSystems/_helpers");
+const _helpers_2 = require("../_helpers");
+/**
+ * Sweeps leftover rewards from fully settled epochs to a recipient. Requires DEFAULT_ADMIN_ROLE. Reverts when there is nothing new to sweep.
+ *
+ * @param chainId - The chain/network to use.
+ * @param gaugeSystem - Gauge system id ("raacgauges" or "rwagauges") or a GaugeRewardsDistributor address.
+ * @param recipient - Address that receives the dust.
+ * @param signer - An ethers.js Signer instance (required).
+ * @returns The transaction after it has been mined.
+ */
+const withdrawDust = async (chainId, gaugeSystem, recipient, signer) => {
+    if (!signer)
+        throw new Error("Signer is required");
+    const address = (0, _helpers_1.resolveGaugeDistributor)(chainId, gaugeSystem);
+    const contract = new ethers_1.ethers.Contract(address, (0, artifacts_1.getABI)("gaugerewardsdistributor"), signer);
+    try {
+        const tx = await contract.withdrawDust(recipient);
+        await tx.wait();
+        return tx;
+    }
+    catch (error) {
+        throw (0, _helpers_2.toGovernanceTxError)("Failed to withdraw dust", error);
+    }
+};
+exports.withdrawDust = withdrawDust;

package/dist/contracts/governance/distributor/withdrawRemovedGaugeRewards.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withdrawRemovedGaugeRewards = void 0;
+const ethers_1 = require("ethers");
+const artifacts_1 = require("../../../utils/artifacts");
+const _helpers_1 = require("../gaugeSystems/_helpers");
+const _helpers_2 = require("../_helpers");
+/**
+ * Redirects a removed gauge's unclaimed entitlement to a recipient. Requires CONTROLLER_ROLE: the controller calls it from `removeGauge`, so admins normally use `governance.controller.removeGauge`.
+ *
+ * @param chainId - The chain/network to use.
+ * @param gaugeSystem - Gauge system id ("raacgauges" or "rwagauges") or a GaugeRewardsDistributor address.
+ * @param gaugeAddressOrId - Address or config id of the gauge.
+ * @param recipient - Address that receives the redirected rewards.
+ * @param signer - An ethers.js Signer instance (required).
+ * @returns The transaction after it has been mined.
+ */
+const withdrawRemovedGaugeRewards = async (chainId, gaugeSystem, gaugeAddressOrId, recipient, signer) => {
+    if (!signer)
+        throw new Error("Signer is required");
+    const address = (0, _helpers_1.resolveGaugeDistributor)(chainId, gaugeSystem);
+    const gaugeAddress = (0, _helpers_1.resolveGauge)(chainId, gaugeAddressOrId);
+    const contract = new ethers_1.ethers.Contract(address, (0, artifacts_1.getABI)("gaugerewardsdistributor"), signer);
+    try {
+        const tx = await contract.withdrawRemovedGaugeRewards(gaugeAddress, recipient);
+        await tx.wait();
+        return tx;
+    }
+    catch (error) {
+        throw (0, _helpers_2.toGovernanceTxError)("Failed to withdraw removed gauge rewards", error);
+    }
+};
+exports.withdrawRemovedGaugeRewards = withdrawRemovedGaugeRewards;

package/dist/contracts/governance/gauge/_apy.js

@@ -0,0 +1,122 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadGaugeApyState = exports.toApyPct = exports.SECONDS_PER_YEAR = 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");
+exports.SECONDS_PER_YEAR = 365n * 24n * 60n * 60n;
+const E18 = 10n ** 18n;
+const E36 = 10n ** 36n;
+const ERC20_DECIMALS_ABI = ["function decimals() view returns (uint8)"];
+const priceOf = (prices, token) => {
+    const target = token.toLowerCase();
+    const entry = Object.entries(prices.rewardTokenPricesUSD ?? {}).find(([key]) => key.toLowerCase() === target);
+    return entry && Number.isFinite(entry[1]) ? entry[1] : null;
+};
+const toReward = (token, kind, yearly, decimals, active, prices) => {
+    const priceUSD = priceOf(prices, token);
+    const yearlyRewards = ethers_1.ethers.formatUnits(yearly, decimals);
+    return {
+        token,
+        kind,
+        yearlyRewards,
+        priceUSD,
+        yearlyRewardsUSD: priceUSD === null ? null : Number(yearlyRewards) * priceUSD,
+        active,
+    };
+};
+/** Annualized percentage: yearly USD over staked USD, or null when nothing is staked or the staking token has no price. */
+const toApyPct = (yearlyUSD, stakedUnits, stakingTokenPriceUSD) => {
+    const stakedUSD = stakedUnits * stakingTokenPriceUSD;
+    return stakedUSD > 0 ? (yearlyUSD / stakedUSD) * 100 : null;
+};
+exports.toApyPct = toApyPct;
+/**
+ * Loads the gauge state an APY calculation needs: supplies, boost bounds and each reward token's yearly emission.
+ *
+ * @param chainId - The chain/network to use.
+ * @param gaugeAddressOrId - Address of the gauge contract or its config ID.
+ * @param prices - USD prices for the staking token and reward tokens.
+ * @param options - Reward source selection.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The loaded state.
+ */
+const loadGaugeApyState = async (chainId, gaugeAddressOrId, prices, options = {}, provider) => {
+    if (!provider) {
+        const rpc = chains_1.default[chainId].rpcs[0];
+        provider = new ethers_1.ethers.JsonRpcProvider(rpc);
+    }
+    if (!prices || !Number.isFinite(prices.stakingTokenPriceUSD)) {
+        throw new Error("prices.stakingTokenPriceUSD is required");
+    }
+    const rewardSource = options.rewardSource ?? "epoch";
+    const gauge = (0, _helpers_1.resolveGauge)(chainId, gaugeAddressOrId);
+    const gaugeContract = new ethers_1.ethers.Contract(gauge, (0, artifacts_1.getABI)("basegauge"), provider);
+    const [data, controllerAddress, extraTokens, [, periodEnd], block] = await Promise.all([
+        gaugeContract.gaugeData(),
+        gaugeContract.gaugeController(),
+        gaugeContract.getExtraRewardTokens(),
+        gaugeContract.getPeriodBoundaries(),
+        provider.getBlock("latest"),
+    ]);
+    if (!block)
+        throw new Error("Failed to read the latest block");
+    const now = BigInt(block.timestamp);
+    const controller = new ethers_1.ethers.Contract(controllerAddress, (0, artifacts_1.getABI)("gaugecontroller"), provider);
+    const stakingTokenContract = new ethers_1.ethers.Contract(data.stakingToken, ERC20_DECIMALS_ABI, provider);
+    const [minBoost, maxBoost, stakingDecimals, mainData] = await Promise.all([
+        controller.MIN_BOOST(),
+        controller.MAX_BOOST(),
+        stakingTokenContract.decimals().then((d) => Number(d)),
+        gaugeContract.getGaugeRewardTokenData(data.rewardToken),
+    ]);
+    const rewards = [];
+    if (rewardSource === "epoch") {
+        const distributor = new ethers_1.ethers.Contract(data.rewardDistributor, (0, artifacts_1.getABI)("gaugerewardsdistributor"), provider);
+        const [week, currentEpoch] = await Promise.all([controller.WEEK(), controller.getCurrentEpoch()]);
+        const lastEpoch = currentEpoch - week;
+        const [deposited, [relativeWeight]] = await Promise.all([
+            distributor.depositedAtEpoch(data.rewardToken, lastEpoch),
+            controller.getGaugeRelativeWeightView(gauge, lastEpoch),
+        ]);
+        const perEpoch = (deposited * relativeWeight) / E18;
+        rewards.push(toReward(data.rewardToken, "main", (perEpoch * exports.SECONDS_PER_YEAR) / week, Number(mainData.decimals), perEpoch > 0n, prices));
+    }
+    else {
+        // rate is 18-decimal-normalized tokens per second scaled by 1e36 (ray-divided wad) and only streams until the period ends.
+        const active = now < periodEnd && mainData.rate > 0n;
+        const yearly = active ? (mainData.rate * exports.SECONDS_PER_YEAR) / E36 : 0n;
+        rewards.push(toReward(data.rewardToken, "main", yearly, 18, active, prices));
+    }
+    const extras = await Promise.all([...extraTokens].map(async (token) => {
+        const extra = await gaugeContract.extraRewardTokenData(token);
+        // Extra rate is 18-decimal-normalized tokens per second scaled by 1e18.
+        const active = extra.isActive && now < extra.periodFinish && extra.rate > 0n;
+        const yearly = active ? (extra.rate * exports.SECONDS_PER_YEAR) / E18 : 0n;
+        return toReward(token, "extra", yearly, 18, active, prices);
+    }));
+    rewards.push(...extras);
+    const sumUSD = (kind) => rewards.filter((r) => r.kind === kind).reduce((sum, r) => sum + (r.yearlyRewardsUSD ?? 0), 0);
+    return {
+        provider,
+        now,
+        gauge,
+        gaugeContract,
+        controller,
+        stakingToken: data.stakingToken,
+        stakingDecimals,
+        totalSupply: data.totalSupply,
+        workingSupply: data.workingSupply,
+        minBoost,
+        maxBoost,
+        rewardSource,
+        rewards,
+        mainYearlyUSD: sumUSD("main"),
+        extraYearlyUSD: sumUSD("extra"),
+    };
+};
+exports.loadGaugeApyState = loadGaugeApyState;

package/dist/contracts/governance/gauge/_tokens.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGaugeTokens = exports.ERC4626_ABI = exports.ERC20_ABI = void 0;
+const ethers_1 = require("ethers");
+const GAUGE_ABI = [
+    "function gaugeData() view returns (uint256 gaugeInitialStartTime, uint256 periodDuration, uint256 periodIndex, address stakingToken, uint256 totalSupply, uint256 workingSupply, address rewardDistributor, address rewardToken, uint256 lastUpdateTime)",
+];
+const VAULT_ABI = ["function asset() view returns (address)", "function totalAssets() view returns (uint256)"];
+exports.ERC20_ABI = [
+    "function symbol() view returns (string)",
+    "function decimals() view returns (uint8)",
+    "function balanceOf(address) view returns (uint256)",
+    "function allowance(address owner, address spender) view returns (uint256)",
+    "function approve(address spender, uint256 amount) returns (bool)",
+];
+exports.ERC4626_ABI = [
+    "function deposit(uint256 assets, address receiver) returns (uint256 shares)",
+    "function redeem(uint256 shares, address receiver, address owner) returns (uint256 assets)",
+];
+/**
+ * Reads a gauge's staking token from the gauge and whether it wraps another token. A staking token counts as a wrapper
+ * when it exposes a non-zero `asset()` and a working `totalAssets()`, the same test the subgraph uses for its `wrapped` flag.
+ */
+const getGaugeTokens = async (gaugeAddress, runner) => {
+    const gauge = new ethers_1.ethers.Contract(gaugeAddress, GAUGE_ABI, runner);
+    const stakingToken = (await gauge.gaugeData()).stakingToken;
+    const vault = new ethers_1.ethers.Contract(stakingToken, VAULT_ABI, runner);
+    try {
+        const [asset] = await Promise.all([vault.asset(), vault.totalAssets()]);
+        return { stakingToken, underlying: asset === ethers_1.ethers.ZeroAddress ? null : asset };
+    }
+    catch {
+        return { stakingToken, underlying: null };
+    }
+};
+exports.getGaugeTokens = getGaugeTokens;

package/dist/contracts/governance/gauge/addRewardToken.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addRewardToken = void 0;
+const ethers_1 = require("ethers");
+const artifacts_1 = require("../../../utils/artifacts");
+const _helpers_1 = require("../gaugeSystems/_helpers");
+/**
+ * Registers a new reward token on the gauge (requires GAUGE_ADMIN).
+ * @param chainId - The chain/network to use.
+ * @param gaugeAddressOrId - Address of the gauge contract or its config ID.
+ * @param token - Address of the reward token to add.
+ * @param signer - An ethers.js Signer instance (required).
+ */
+const addRewardToken = async (chainId, gaugeAddressOrId, token, signer) => {
+    if (!signer)
+        throw new Error("Signer is required");
+    const gaugeAddress = (0, _helpers_1.resolveGauge)(chainId, gaugeAddressOrId);
+    const abi = (0, artifacts_1.getABI)("basegauge");
+    const contract = new ethers_1.ethers.Contract(gaugeAddress, abi, signer);
+    const tx = await contract.addRewardToken(token);
+    await tx.wait();
+    return tx;
+};
+exports.addRewardToken = addRewardToken;

package/dist/contracts/governance/gauge/approveGaugeToken.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.approveGaugeToken = void 0;
+const ethers_1 = require("ethers");
+const _helpers_1 = require("../gaugeSystems/_helpers");
+const _tokens_1 = require("./_tokens");
+/**
+ * Approves the contract that pulls a gauge token: the staking token to the gauge, or for a wrapped gauge the underlying
+ * to the wrapper.
+ *
+ * @param chainId - The chain/network to use.
+ * @param gaugeAddressOrId - Address of the gauge contract or its config ID.
+ * @param token - "staking" to stake, "underlying" to wrap.
+ * @param amount - Allowance to set, base units.
+ * @param signer - An ethers.js Signer instance (required).
+ * @returns The mined transaction.
+ */
+const approveGaugeToken = async (chainId, gaugeAddressOrId, token, amount, signer) => {
+    if (!signer)
+        throw new Error("Signer is required");
+    const gauge = (0, _helpers_1.resolveGauge)(chainId, gaugeAddressOrId);
+    const { stakingToken, underlying } = await (0, _tokens_1.getGaugeTokens)(gauge, signer);
+    if (token === "underlying" && !underlying) {
+        throw new Error(`Gauge ${gauge} does not take a wrapped token`);
+    }
+    const [address, spender] = token === "staking" ? [stakingToken, gauge] : [underlying, stakingToken];
+    const tx = await new ethers_1.ethers.Contract(address, _tokens_1.ERC20_ABI, signer).approve(spender, amount);
+    await tx.wait();
+    return tx;
+};
+exports.approveGaugeToken = approveGaugeToken;

package/dist/contracts/governance/gauge/claimExtraReward.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.claimExtraReward = void 0;
+const ethers_1 = require("ethers");
+const artifacts_1 = require("../../../utils/artifacts");
+const _helpers_1 = require("../gaugeSystems/_helpers");
+/**
+ * Claims a single extra reward token for the caller on the given gauge.
+ * @param chainId - The chain/network to use.
+ * @param gaugeAddressOrId - Address of the gauge contract or its config ID.
+ * @param token - Address of the extra reward token to claim.
+ * @param signer - An ethers.js Signer instance (required).
+ */
+const claimExtraReward = async (chainId, gaugeAddressOrId, token, signer) => {
+    if (!signer)
+        throw new Error("Signer is required");
+    const gaugeAddress = (0, _helpers_1.resolveGauge)(chainId, gaugeAddressOrId);
+    const abi = (0, artifacts_1.getABI)("basegauge");
+    const contract = new ethers_1.ethers.Contract(gaugeAddress, abi, signer);
+    const tx = await contract.claimExtraReward(token);
+    await tx.wait();
+    return tx;
+};
+exports.claimExtraReward = claimExtraReward;

package/dist/contracts/governance/gauge/claimExtraRewards.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.claimExtraRewards = void 0;
+const ethers_1 = require("ethers");
+const artifacts_1 = require("../../../utils/artifacts");
+const _helpers_1 = require("../gaugeSystems/_helpers");
+/**
+ * Claims all extra reward tokens for the caller on the given gauge.
+ * @param chainId - The chain/network to use.
+ * @param gaugeAddressOrId - Address of the gauge contract or its config ID.
+ * @param signer - An ethers.js Signer instance (required).
+ */
+const claimExtraRewards = async (chainId, gaugeAddressOrId, signer) => {
+    if (!signer)
+        throw new Error("Signer is required");
+    const gaugeAddress = (0, _helpers_1.resolveGauge)(chainId, gaugeAddressOrId);
+    const abi = (0, artifacts_1.getABI)("basegauge");
+    const contract = new ethers_1.ethers.Contract(gaugeAddress, abi, signer);
+    const tx = await contract.claimExtraRewards();
+    await tx.wait();
+    return tx;
+};
+exports.claimExtraRewards = claimExtraRewards;

package/dist/contracts/governance/gauge/claimOnBehalfOf.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.claimOnBehalfOf = void 0;
+const ethers_1 = require("ethers");
+const artifacts_1 = require("../../../utils/artifacts");
+const _helpers_1 = require("../gaugeSystems/_helpers");
+/**
+ * Claims a specific token amount on behalf of a user (requires CLAIM_FOR_ROLE).
+ * @param chainId - The chain/network to use.
+ * @param gaugeAddressOrId - Address of the gauge contract or its config ID.
+ * @param token - Address of the reward token.
+ * @param amount - The amount to claim.
+ * @param user - Address of the user on whose behalf the claim is made.
+ * @param signer - An ethers.js Signer instance (required).
+ */
+const claimOnBehalfOf = async (chainId, gaugeAddressOrId, token, amount, user, signer) => {
+    if (!signer)
+        throw new Error("Signer is required");
+    const gaugeAddress = (0, _helpers_1.resolveGauge)(chainId, gaugeAddressOrId);
+    const abi = (0, artifacts_1.getABI)("basegauge");
+    const contract = new ethers_1.ethers.Contract(gaugeAddress, abi, signer);
+    const tx = await contract.claimOnBehalfOf(token, amount, user);
+    await tx.wait();
+    return tx;
+};
+exports.claimOnBehalfOf = claimOnBehalfOf;

package/dist/contracts/governance/gauge/claimRewardToken.js

@@ -1,39 +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.claimRewardToken = void 0;
 const ethers_1 = require("ethers");
 const artifacts_1 = require("../../../utils/artifacts");
-const getContractAddress_1 = __importDefault(require("../../getContractAddress"));
+const _helpers_1 = require("../gaugeSystems/_helpers");
 /**
- * Claims a specific reward token from a gauge.
+ * Claims the caller's main reward token from a gauge, pulling the gauge's share from its distributor first. Reverts while the gauge or its controller is paused.
  *
  * @param chainId - The chain/network to use.
  * @param gaugeAddressOrId - Address of the gauge contract or ID of the gauge.
- * @param tokenAddress - Address of the reward token to claim.
  * @param signer - An ethers.js Signer instance (must be connected to wallet).
  * @returns Transaction receipt after the claim is made.
  */
-const claimRewardToken = async (chainId, gaugeAddressOrId, tokenAddress, signer) => {
+const claimRewardToken = async (chainId, gaugeAddressOrId, signer) => {
     if (!signer) {
         throw new Error("Signer is required");
     }
-    let gaugeAddress;
+    const gaugeAddress = (0, _helpers_1.resolveGauge)(chainId, gaugeAddressOrId);
     try {
-        if ((0, ethers_1.isAddress)(gaugeAddressOrId)) {
-            gaugeAddress = gaugeAddressOrId;
-        }
-        else {
-            // @ts-ignore
-            gaugeAddress = (0, getContractAddress_1.default)(chainId, gaugeAddressOrId.toLowerCase());
-        }
         const gaugeABI = (0, artifacts_1.getABI)("basegauge");
         const contract = new ethers_1.ethers.Contract(gaugeAddress, gaugeABI, signer);
-        const tx = await contract.claimRewardToken(tokenAddress);
+        const tx = await contract.claimRewardToken();
         await tx.wait();
-        console.log(`Claimed reward token ${tokenAddress} from gauge: ${gaugeAddress}`);
+        console.log(`Claimed main reward token from gauge: ${gaugeAddress}`);
         return tx;
     }
     catch (error) {

package/dist/contracts/governance/gauge/claimRewardsFor.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.claimRewardsFor = void 0;
+const ethers_1 = require("ethers");
+const artifacts_1 = require("../../../utils/artifacts");
+const _helpers_1 = require("../gaugeSystems/_helpers");
+/**
+ * Claims rewards on behalf of a user (requires DISTRIBUTOR_ROLE).
+ * @param chainId - The chain/network to use.
+ * @param gaugeAddressOrId - Address of the gauge contract or its config ID.
+ * @param user - Address of the user whose rewards are claimed.
+ * @param signer - An ethers.js Signer instance (required).
+ */
+const claimRewardsFor = async (chainId, gaugeAddressOrId, user, signer) => {
+    if (!signer)
+        throw new Error("Signer is required");
+    const gaugeAddress = (0, _helpers_1.resolveGauge)(chainId, gaugeAddressOrId);
+    const abi = (0, artifacts_1.getABI)("basegauge");
+    const contract = new ethers_1.ethers.Contract(gaugeAddress, abi, signer);
+    const tx = await contract.claimRewardsFor(user);
+    await tx.wait();
+    return tx;
+};
+exports.claimRewardsFor = claimRewardsFor;

package/dist/contracts/governance/gauge/depositRewardToken.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.depositRewardToken = void 0;
+const ethers_1 = require("ethers");
+const artifacts_1 = require("../../../utils/artifacts");
+const _helpers_1 = require("../gaugeSystems/_helpers");
+/**
+ * Deposits an amount of a reward token into the gauge for distribution.
+ * @param chainId - The chain/network to use.
+ * @param gaugeAddressOrId - Address of the gauge contract or its config ID.
+ * @param token - Address of the reward token to deposit.
+ * @param amount - The amount to deposit.
+ * @param signer - An ethers.js Signer instance (required).
+ */
+const depositRewardToken = async (chainId, gaugeAddressOrId, token, amount, signer) => {
+    if (!signer)
+        throw new Error("Signer is required");
+    const gaugeAddress = (0, _helpers_1.resolveGauge)(chainId, gaugeAddressOrId);
+    const abi = (0, artifacts_1.getABI)("basegauge");
+    const contract = new ethers_1.ethers.Contract(gaugeAddress, abi, signer);
+    const tx = await contract.depositRewardToken(token, amount);
+    await tx.wait();
+    return tx;
+};
+exports.depositRewardToken = depositRewardToken;

package/dist/contracts/governance/gauge/getAllPendingExtraRewards.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.getAllPendingExtraRewards = 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");
+/**
+ * Gets all pending extra rewards for a user across all extra reward tokens.
+ * @param chainId - The chain/network to use.
+ * @param gaugeAddressOrId - Address of the gauge contract or its config ID.
+ * @param user - Address of the user.
+ * @param provider - Optional ethers.js Provider instance.
+ */
+const getAllPendingExtraRewards = async (chainId, gaugeAddressOrId, user, provider) => {
+    if (!provider) {
+        const rpc = chains_1.default[chainId].rpcs[0];
+        provider = new ethers_1.ethers.JsonRpcProvider(rpc);
+    }
+    const gaugeAddress = (0, _helpers_1.resolveGauge)(chainId, gaugeAddressOrId);
+    const abi = (0, artifacts_1.getABI)("basegauge");
+    const contract = new ethers_1.ethers.Contract(gaugeAddress, abi, provider);
+    const [tokens, amounts] = await contract.allPendingExtraRewards(user);
+    return { tokens, amounts };
+};
+exports.getAllPendingExtraRewards = getAllPendingExtraRewards;