@raac/rpc 1.2.0-beta.8 → 1.2.0-beta.9

package/dist/configs/chains/11155111.json

@@ -37,12 +37,12 @@
         "feecollector": {
             "id": "feecollector",
             "name": "Fee Collector",
-            "contract": "0xf460b2436753AEed5Df275CA33528f5C9abB579D"
+            "contract": "0x789f62Ee0471B369b28D4A5345Fe12a70Bd8Be3B"
         },
         "treasury": {
             "id": "treasury",
             "name": "Treasury",
-            "contract": "0xDc1FCd959881533CCFBfB572881CdC6d8a2b35E7"
+            "contract": "0xFE72Afa6e52E041B036B0E28e25ffE5CA5fD6170"
         },
         "pmtreasury": {
             "id": "pmtreasury",
@@ -146,17 +146,22 @@
         "stabilitypool": {
             "id": "stabilitypool",
             "name": "Stability Pool",
-            "contract": "0xd7663c079445A070Ef24405CD5ef1511B9d9E060"
+            "contract": "0x647dE5B6Db7f4a3e0E1f4D9DB478B86b7B430248"
         },
         "lendingpool": {
             "id": "lendingpool",
             "name": "Lending Pool",
-            "contract": "0xefCff23AEed94ae0f23377DFDaB78C3c868eeB33"
+            "contract": "0xd8cd0194c1Dc3287f2666ECEB45A1Ac3450dD38a"
         },
         "crvusdraacpool": {
             "id": "crvusdraacpool",
-            "name": "Curve crvUSD/RAAC twocrypto-ng Pool",
-            "contract": "0xCfDBbad91770fb7Fd57e623A59dcbD14670164c7"
+            "name": "Curve pmUSD/RAAC twocrypto-ng Pool",
+            "contract": "0xAe98A7EF8557491fD34b45036Aada075c9385c6C"
+        },
+        "pmusdireetpool": {
+            "id": "pmusdireetpool",
+            "name": "pmUSD/iREET Mock Pool",
+            "contract": "0x4b9b6D1468846B00dB898698a13E11f2C2347EC1"
         }
     },
     "nfts": {
@@ -192,21 +197,21 @@
         },
         "crvusd": {
             "id": "crvusd",
-            "name": "CRVUSD",
+            "name": "pmUSD",
             "decimals": 18,
-            "contract": "0x8047a14301583CAaf9e2128D5F88F9f435659d35"
+            "contract": "0x970697EF41A89f7448BC658B5308dcADaC2a663c"
         },
         "rtoken": {
             "id": "rtoken",
             "name": "RToken",
             "decimals": 18,
-            "contract": "0xc96c34825aa96A77A4AD884e393960a70c5f1186"
+            "contract": "0x6F713079002a0a485E91fB276E4682CB01d18439"
         },
         "detoken": {
             "id": "detoken",
             "name": "DEToken",
             "decimals": 18,
-            "contract": "0x5841dc06d2C9e0D2605392f669be71Bfe6d04cf7"
+            "contract": "0x7099e48A96eEeCd93c9a1bBA535d8715826df70e"
         },
         "raactoken": {
             "id": "raactoken",
@@ -230,7 +235,7 @@
             "id": "debttoken",
             "name": "Debt Token",
             "decimals": 18,
-            "contract": "0x98db917a623a92a8553Fe59b9f05B8c936aa1E1e"
+            "contract": "0x90f1f1431c46F851c54DD9518a28e4C20AB0aC4c"
         },
         "rwaindextoken": {
             "id": "rwaindextoken",
@@ -250,7 +255,7 @@
             "rwaindextokenadapter": {
                 "id": "rwaindextokenadapter",
                 "name": "RWA Index Token",
-                "contract": "0x5374287a807c5513fC31bc9AECE5aC40f0e37c71",
+                "contract": "0x075c96D803E64f25bA28C7a765F3911BBf773B56",
                 "type": "ERC20"
             }
         },

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

@@ -0,0 +1,135 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUserClaimableRewards = void 0;
+const ethers_1 = require("ethers");
+const chains_1 = __importDefault(require("../../../configs/chains"));
+const getContractAddress_1 = __importStar(require("../../getContractAddress"));
+const GAUGE_ABI = [
+    "function pendingRewards(address account) view returns (uint256)",
+    "function balanceOf(address account) view returns (uint256)", // boosted working balance
+    "function totalSupply() view returns (uint256)", // working supply
+    "function getExtraRewardTokens() view returns (address[])",
+    "function pendingExtraRewards(address token, address account) view returns (uint256)",
+];
+const DISTRIBUTOR_ABI = ["function getClaimableForGauge(address gauge) view returns (uint256)"];
+const ERC20_META_ABI = [
+    "function symbol() view returns (string)",
+    "function decimals() view returns (uint8)",
+];
+/**
+ * The user's TRUE claimable rewards on a gauge.
+ *
+ * The gauge's `pendingRewards()` view only reflects RAAC already pulled into the gauge.
+ * RAAC emitted to the gauge sits in the GaugeRewardsDistributor until a claim pulls it in
+ * (`claimRewardToken`/`claimRewardsFor` call `_pullRewardsFromDistributor` first). So a
+ * user's real claimable also includes their working-balance share of the distributor's
+ * `getClaimableForGauge(gauge)`. This helper combines both, plus any extra reward tokens.
+ *
+ * @param chainId - The chain/network to use.
+ * @param gaugeAddressOrId - Address of the gauge contract or its config ID.
+ * @param accountAddress - Address of the user.
+ * @param provider - Optional ethers.js Provider instance.
+ */
+const getUserClaimableRewards = async (chainId, gaugeAddressOrId, accountAddress, provider) => {
+    if (!provider) {
+        const rpc = chains_1.default[chainId].rpcs[0];
+        provider = new ethers_1.ethers.JsonRpcProvider(rpc);
+    }
+    let gaugeAddress;
+    if ((0, ethers_1.isAddress)(gaugeAddressOrId)) {
+        gaugeAddress = gaugeAddressOrId;
+    }
+    else {
+        // @ts-ignore
+        gaugeAddress = (0, getContractAddress_1.default)(chainId, gaugeAddressOrId.toLowerCase());
+    }
+    const gauge = new ethers_1.ethers.Contract(gaugeAddress, GAUGE_ABI, provider);
+    const [inGauge, working, supply, extraTokens] = await Promise.all([
+        gauge.pendingRewards(accountAddress).then((v) => BigInt(v)).catch(() => 0n),
+        gauge.balanceOf(accountAddress).then((v) => BigInt(v)).catch(() => 0n),
+        gauge.totalSupply().then((v) => BigInt(v)).catch(() => 0n),
+        gauge.getExtraRewardTokens().catch(() => []),
+    ]);
+    // User's share of RAAC still held by the distributor for this gauge.
+    let inDistributor = 0n;
+    try {
+        const distributorAddr = (0, getContractAddress_1.getContractAddress)(chainId, "gaugerewardsdistributor");
+        const distributor = new ethers_1.ethers.Contract(distributorAddr, DISTRIBUTOR_ABI, provider);
+        const gaugeClaimable = BigInt(await distributor.getClaimableForGauge(gaugeAddress));
+        if (supply > 0n && working > 0n && gaugeClaimable > 0n) {
+            inDistributor = (gaugeClaimable * working) / supply;
+        }
+    }
+    catch {
+        /* distributor not configured / no pending */
+    }
+    const raac = inGauge + inDistributor;
+    const extras = [];
+    for (const token of extraTokens) {
+        try {
+            const amount = BigInt(await gauge.pendingExtraRewards(token, accountAddress));
+            if (amount <= 0n)
+                continue;
+            const erc20 = new ethers_1.ethers.Contract(token, ERC20_META_ABI, provider);
+            const [symbol, decimals] = await Promise.all([
+                erc20.symbol().catch(() => "?"),
+                erc20.decimals().then((d) => Number(d)).catch(() => 18),
+            ]);
+            extras.push({
+                token,
+                symbol,
+                decimals,
+                amount,
+                formatted: ethers_1.ethers.formatUnits(amount, decimals),
+            });
+        }
+        catch {
+            /* ignore a single extra token */
+        }
+    }
+    return {
+        gauge: gaugeAddress,
+        inGauge,
+        inDistributor,
+        raac,
+        raacFormatted: ethers_1.ethers.formatEther(raac),
+        extras,
+    };
+};
+exports.getUserClaimableRewards = getUserClaimableRewards;

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

@@ -40,6 +40,7 @@ __exportStar(require("./getRaacAutolockMin"), exports);
 __exportStar(require("./getRawBalanceOf"), exports);
 __exportStar(require("./getRawTotalSupply"), exports);
 __exportStar(require("./getTotalSupply"), exports);
+__exportStar(require("./getUserClaimableRewards"), exports);
 __exportStar(require("./getUserRewardTokenData"), exports);
 __exportStar(require("./getUserWeight"), exports);
 __exportStar(require("./isPaused"), exports);

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

@@ -10,13 +10,16 @@ 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
+ * 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).
  *
- * Returns a series ending at the current (in-progress) epoch so callers can chart
- * "week of X → this gauge received Y RAAC".
+ * 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 gauge - Gauge address (or config key).
@@ -39,6 +42,34 @@ const getGaugeEmissions = async (chainId, gauge, numEpochs = 8, includeUpcoming
     const week = BigInt(weekBn);
     const currentEpoch = BigInt(currentEpochBn);
     const startEpoch = BigInt(startEpochBn) > 0n ? BigInt(startEpochBn) : 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 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 — 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;
@@ -48,10 +79,11 @@ const getGaugeEmissions = async (chainId, gauge, numEpochs = 8, includeUpcoming
     for (let e = from; e <= currentEpoch; e += week)
         epochList.push(e);
     const epochs = await Promise.all(epochList.map(async (e) => {
-        let deposited = 0n;
+        const isCurrent = e === currentEpoch;
+        let depositedSoFar = 0n;
         let relativeWeight = 0n;
         try {
-            deposited = BigInt(await distributor.depositedAtEpoch(rewardToken, e));
+            depositedSoFar = BigInt(await distributor.depositedAtEpoch(rewardToken, e));
         }
         catch {
             /* ignore */
@@ -63,29 +95,33 @@ const getGaugeEmissions = async (chainId, gauge, numEpochs = 8, includeUpcoming
         catch {
             /* no snapshot at this epoch */
         }
-        const gaugeEmissionRaw = (deposited * relativeWeight) / E18;
+        // 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(deposited),
+            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: e === currentEpoch,
+            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 we
-    // project the distributor's deposit from the emission schedule:
-    //   projectedSystem = minterWeekly(nextEpoch) × distributorShareOfMinter
-    //   projectedGauge  = projectedSystem × gaugeRelativeWeight(nextEpoch)
+    // 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;
-        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);
@@ -93,28 +129,12 @@ const getGaugeEmissions = async (chainId, gauge, numEpochs = 8, includeUpcoming
         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 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),
@@ -130,6 +150,7 @@ const getGaugeEmissions = async (chainId, gauge, numEpochs = 8, includeUpcoming
         weekSeconds: Number(week),
         relativeWeightPct: current ? current.relativeWeightPct : 0,
         currentWeekEmission: current ? current.gaugeEmission : "0",
+        currentWeekDepositedSoFar: current ? current.depositedSoFar : "0",
         epochs,
     };
 };

package/dist/types/contracts/governance/gauge/getUserClaimableRewards.d.ts

@@ -0,0 +1,40 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+export interface ClaimableExtraReward {
+    token: string;
+    symbol: string;
+    decimals: number;
+    /** Claimable amount, base units. */
+    amount: bigint;
+    /** Claimable amount, formatted to `decimals`. */
+    formatted: string;
+}
+export interface UserClaimableRewards {
+    gauge: string;
+    /** RAAC already accrued to the user inside the gauge (gauge.pendingRewards). */
+    inGauge: bigint;
+    /** The user's pro-rata share of RAAC still sitting in the distributor for this gauge
+     *  (deposited but not yet pulled in via a claim). */
+    inDistributor: bigint;
+    /** Total claimable RAAC = inGauge + inDistributor, base units. */
+    raac: bigint;
+    /** Total claimable RAAC, formatted (18 decimals). */
+    raacFormatted: string;
+    /** Extra reward tokens claimable by the user. */
+    extras: ClaimableExtraReward[];
+}
+/**
+ * The user's TRUE claimable rewards on a gauge.
+ *
+ * The gauge's `pendingRewards()` view only reflects RAAC already pulled into the gauge.
+ * RAAC emitted to the gauge sits in the GaugeRewardsDistributor until a claim pulls it in
+ * (`claimRewardToken`/`claimRewardsFor` call `_pullRewardsFromDistributor` first). So a
+ * user's real claimable also includes their working-balance share of the distributor's
+ * `getClaimableForGauge(gauge)`. This helper combines both, plus any extra reward tokens.
+ *
+ * @param chainId - The chain/network to use.
+ * @param gaugeAddressOrId - Address of the gauge contract or its config ID.
+ * @param accountAddress - Address of the user.
+ * @param provider - Optional ethers.js Provider instance.
+ */
+export declare const getUserClaimableRewards: (chainId: ChainId, gaugeAddressOrId: string, accountAddress: string, provider?: Provider) => Promise<UserClaimableRewards>;

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

@@ -23,6 +23,7 @@ export * from "./getRaacAutolockMin";
 export * from "./getRawBalanceOf";
 export * from "./getRawTotalSupply";
 export * from "./getTotalSupply";
+export * from "./getUserClaimableRewards";
 export * from "./getUserRewardTokenData";
 export * from "./getUserWeight";
 export * from "./isPaused";

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

@@ -3,8 +3,14 @@ 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). */
+    /** System reward emission attributed to this epoch (formatted). For past epochs this
+     * is the actual deposited amount; for the in-progress epoch it is the FULL scheduled
+     * week emission (not the partial tick deposit). */
     deposited: string;
+    /** RAAC actually deposited into the distributor so far for this epoch (formatted).
+     * For the current epoch this grows via tick() during the week; for past epochs it
+     * equals `deposited`. */
+    depositedSoFar: string;
     /** Gauge relative weight at this epoch, 1e18-scaled (1e18 = 100%). */
     relativeWeight: bigint;
     /** Gauge relative weight as a percentage 0..100. */
@@ -12,7 +18,8 @@ export interface GaugeEpochEmission {
     /** 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(). */
+    /** True for the in-progress (current) epoch — `deposited` is the scheduled full-week
+     * total, while `depositedSoFar` is what has been ticked in so far. */
     isCurrent: boolean;
     /**
      * True for the upcoming (next) epoch preview. Nothing is deposited yet, so `deposited`
@@ -29,19 +36,25 @@ export interface GaugeEmissionsResult {
     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. */
+    /** RAAC allocated to this gauge for the current (in-progress) epoch — the scheduled
+     * full-week total, deterministic from the emission schedule (not the tick deposit). */
     currentWeekEmission: string;
+    /** RAAC deposited into the distributor so far for the current epoch (tick-based). */
+    currentWeekDepositedSoFar: 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
+ * 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).
  *
- * Returns a series ending at the current (in-progress) epoch so callers can chart
- * "week of X → this gauge received Y RAAC".
+ * 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 gauge - Gauge address (or config key).

package/package.json

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