aftermath-ts-sdk 1.2.51 → 1.2.52-perps.4

package/dist/packages/farms/farmsStakedPosition.js

@@ -19,10 +19,24 @@ const fixedUtils_1 = require("../../general/utils/fixedUtils");
 const utils_1 = require("../../general/utils");
 const dayjs_1 = __importDefault(require("dayjs"));
 const farms_1 = require("./farms");
+/**
+ * The `FarmsStakedPosition` class represents a user's individual staked position
+ * in a particular staking pool. It provides methods to query position details,
+ * calculate potential rewards, lock/unlock stake, and build transactions
+ * for depositing, unstaking, or harvesting rewards.
+ */
 class FarmsStakedPosition extends caller_1.Caller {
     // =========================================================================
     //  Constructor
     // =========================================================================
+    /**
+     * Creates a `FarmsStakedPosition` instance for a user's staked position in a farm.
+     *
+     * @param stakedPosition - The on-chain data object representing the user's staked position.
+     * @param trueLastHarvestRewardsTimestamp - Optionally overrides the last harvest time from the on-chain data.
+     * @param config - Optional configuration for the underlying `Caller`.
+     * @param Provider - Optional `AftermathApi` instance for transaction building.
+     */
     constructor(stakedPosition, trueLastHarvestRewardsTimestamp = undefined, config, Provider) {
         super(config, "farms");
         this.stakedPosition = stakedPosition;
@@ -33,33 +47,86 @@ class FarmsStakedPosition extends caller_1.Caller {
         // =========================================================================
         //  Getters
         // =========================================================================
+        /**
+         * Returns the version of the farm system that this position belongs to (1 or 2).
+         */
+        this.version = () => {
+            return this.stakedPosition.version;
+        };
+        /**
+         * Checks whether the position is still locked, based on the current time and the lock parameters.
+         *
+         * @param inputs - Contains a `FarmsStakingPool` instance to check for system constraints.
+         * @returns `true` if the position is locked; otherwise, `false`.
+         */
         this.isLocked = (inputs) => {
             return !this.isUnlocked(inputs);
         };
+        /**
+         * Checks whether the position has a non-zero lock duration.
+         *
+         * @returns `true` if the position was created with a lock duration > 0.
+         */
         this.isLockDuration = () => {
             return this.stakedPosition.lockDurationMs > 0;
         };
+        /**
+         * Computes the timestamp (in ms) at which this position's lock will end.
+         *
+         * @returns The unlock timestamp (lock start + lock duration).
+         */
         this.unlockTimestamp = () => {
             return (this.stakedPosition.lockStartTimestamp +
                 this.stakedPosition.lockDurationMs);
         };
+        /**
+         * Computes the user's accrued rewards for each reward coin in this position,
+         * returned as a `CoinsToBalance` object keyed by coin type.
+         *
+         * @param inputs - Contains a reference to the `FarmsStakingPool`.
+         * @returns A mapping from `coinType` to the amount of earned rewards.
+         */
         this.rewardCoinsToClaimableBalance = (inputs) => {
             return this.stakedPosition.rewardCoins.reduce((acc, coin) => (Object.assign(Object.assign({}, acc), { [coin.coinType]: this.rewardsEarned(Object.assign(Object.assign({}, inputs), { coinType: coin.coinType })) })), {});
         };
+        /**
+         * Lists all reward coin types associated with this position.
+         *
+         * @returns An array of `CoinType` strings representing the reward coins.
+         */
         this.rewardCoinTypes = () => {
             return this.stakedPosition.rewardCoins.map((coin) => coin.coinType);
         };
+        /**
+         * Returns only the reward coin types that currently have a non-zero claimable balance.
+         *
+         * @param inputs - Contains a reference to the `FarmsStakingPool`.
+         * @returns An array of `CoinType` strings that have pending rewards > 0.
+         */
         this.nonZeroRewardCoinTypes = (inputs) => {
             return Object.entries(this.rewardCoinsToClaimableBalance(inputs))
                 .filter(([, val]) => val > BigInt(0))
                 .map(([key]) => key);
         };
+        /**
+         * Retrieves the reward coin record for a specific coin type in this position.
+         *
+         * @param inputs - Must contain a `coinType` string to look up.
+         * @throws If the coin type is not found in this position.
+         * @returns The reward coin object from the position.
+         */
         this.rewardCoin = (inputs) => {
             const foundCoin = this.stakedPosition.rewardCoins.find((coin) => coin.coinType === inputs.coinType);
             if (!foundCoin)
                 throw new Error("Invalid coin type");
             return foundCoin;
         };
+        /**
+         * Checks if this position has any claimable rewards across all reward coin types.
+         *
+         * @param inputs - Contains a reference to the `FarmsStakingPool`.
+         * @returns `true` if there are unclaimed rewards; otherwise, `false`.
+         */
         this.hasClaimableRewards = (inputs) => {
             const { stakingPool } = inputs;
             return (utils_1.Helpers.sumBigInt(this.rewardCoinTypes().map((coinType) => this.rewardsEarned({
@@ -70,27 +137,82 @@ class FarmsStakedPosition extends caller_1.Caller {
         // =========================================================================
         //  Calculations
         // =========================================================================
+        /**
+         * Calculates the current amount of earned rewards for a specific coin type,
+         * factoring in any emission constraints and the pool's actual reward availability.
+         *
+         * @param inputs - Contains the `coinType` to check and a reference to the `FarmsStakingPool`.
+         * @returns The total `BigInt` amount of rewards earned for the specified coin type.
+         */
         this.rewardsEarned = (inputs) => {
-            if (inputs.stakingPool.rewardCoin(inputs).actualRewards === BigInt(0) ||
-                inputs.stakingPool.rewardCoin(inputs).actualRewards <
-                    inputs.stakingPool.rewardCoin(inputs).emissionRate)
+            if (inputs.stakingPool.rewardCoin(inputs).actualRewards === BigInt(0))
                 return BigInt(0);
             this.updatePosition(inputs);
             const rewardCoin = this.rewardCoin(inputs);
             const totalRewards = rewardCoin.multiplierRewardsAccumulated +
                 rewardCoin.baseRewardsAccumulated;
-            return totalRewards < farms_1.Farms.constants.minimalRewardsToClaim ||
-                totalRewards > inputs.stakingPool.rewardCoin(inputs).actualRewards
+            // If below the minimum threshold to claim, show 0. If the total rewards
+            // exceed what's actually in the pool, we clamp it to 0 or a logic fallback.
+            if (totalRewards < farms_1.Farms.constants.minRewardsToClaim) {
+                return BigInt(0);
+            }
+            // Additional clamp to handle overshoot beyond actual pool reserves
+            return totalRewards >
+                inputs.stakingPool.rewardCoin(inputs).actualRewards
                 ? BigInt(0)
                 : totalRewards;
         };
-        // Updates the amount of rewards that can be harvested from `self` + the position's
-        // debt. If the position's lock duration has elapsed, it will be unlocked.
+        /**
+         * Updates the position's reward calculations based on the pool's current
+         * emission state, effectively "syncing" the on-chain logic into this local
+         * representation. Also checks if the lock duration has elapsed.
+         *
+         * @param inputs - Contains a reference to the `FarmsStakingPool`.
+         * @remarks This method is typically called before computing `rewardsEarned()`.
+         */
         this.updatePosition = (inputs) => {
-            const currentTimestamp = (0, dayjs_1.default)().valueOf();
-            // i. Increase the vault's `rewardsAccumulatedPerShare` values.
             const stakingPool = new farmsStakingPool_1.FarmsStakingPool(utils_1.Helpers.deepCopy(inputs.stakingPool.stakingPool), this.config);
+            // If the lock multiplier is valid, proceed. If not, adjust the staked position
+            // to the pool's maximum allowed lock multiplier or duration.
+            if (this.stakedPosition.lockDurationMs <=
+                stakingPool.stakingPool.maxLockDurationMs &&
+                this.stakedPosition.lockMultiplier <=
+                    stakingPool.stakingPool.maxLockMultiplier) {
+                // Lock multiplier is valid; do nothing special
+            }
+            else {
+                // The position's lock duration or multiplier exceeds the pool's max allowed -> clamp
+                stakingPool.stakingPool.stakedAmountWithMultiplier -=
+                    this.stakedPosition.stakedAmountWithMultiplier;
+                // ii. Update the `lock_duration` and `lock_multiplier` related fields.
+                this.stakedPosition.lockDurationMs =
+                    stakingPool.stakingPool.maxLockDurationMs;
+                this.stakedPosition.lockMultiplier =
+                    stakingPool.stakingPool.maxLockMultiplier;
+                this.stakedPosition.stakedAmountWithMultiplier =
+                    (this.stakedPosition.stakedAmount *
+                        (this.stakedPosition.lockMultiplier -
+                            fixedUtils_1.FixedUtils.fixedOneB)) /
+                        fixedUtils_1.FixedUtils.fixedOneB;
+                this.stakedPosition.rewardCoins = [
+                    ...this.stakedPosition.rewardCoins.map((rewardCoin) => {
+                        const currentDebtPerShare = stakingPool.rewardCoin({
+                            coinType: rewardCoin.coinType,
+                        }).rewardsAccumulatedPerShare;
+                        return Object.assign(Object.assign({}, rewardCoin), { multiplierRewardsDebt: (this.stakedPosition.stakedAmountWithMultiplier *
+                                currentDebtPerShare) /
+                                fixedUtils_1.FixedUtils.fixedOneB });
+                    }),
+                ];
+                // iii. Increase the `Vault`'s `total_staked_amount_with_multiplier` to account for the
+                //  positions new lock multiplier.
+                stakingPool.stakingPool.stakedAmountWithMultiplier +=
+                    this.stakedPosition.stakedAmountWithMultiplier;
+            }
+            const currentTimestamp = (0, dayjs_1.default)().valueOf();
+            // Accumulate any newly emitted rewards in the pool’s state
             stakingPool.emitRewards();
+            // Update position’s base + multiplier rewards using the updated pool info
             for (const [rewardCoinIndex, rewardCoin,] of stakingPool.stakingPool.rewardCoins.entries()) {
                 //******************************************************************************************//
                 //                      debt (i.e. total_rewards_from_time_t0_to_th-1)                      //
@@ -113,27 +235,12 @@ class FarmsStakedPosition extends caller_1.Caller {
                     });
                 }
                 const stakedPositionRewardCoin = this.stakedPosition.rewardCoins[rewardCoinIndex];
-                // NOTE: `total_rewards_from_time_t0` contains the amount of rewards a position would receive
-                //  -- from time t0 to the current time -- given the vault's current state when, in reality,
-                //  we need to calculate just the rewards that have accumulated since the last time the
-                //  position's `rewards_accumulated` was updated [labeled time th-1].
-                //
-                let [totalBaseRewardsFromTimeT0, totalMultiplierRewardsFromTimeT0] = this.calcTotalRewardsFromTimeT0({
+                const [totalBaseRewardsFromTimeT0, totalMultiplierRewardsFromTimeT0,] = this.calcTotalRewardsFromTimeT0({
                     rewardsAccumulatedPerShare: rewardCoin.rewardsAccumulatedPerShare,
                     multiplierRewardsDebt: stakedPositionRewardCoin.multiplierRewardsDebt,
                     emissionEndTimestamp: stakingPool.stakingPool.emissionEndTimestamp,
                 });
-                // NOTE: Every time a position's `rewards_accumulated` is updated, a snapshot of the total
-                //  rewards received from time t0 is taken and stored as the position's `debt` field. Here,
-                //  the debt is subtracted from `total_rewards_from_time_t0` in order to calculate the amount
-                //  of rewards that have been accumulated since the last time `rewards_accumulated` was
-                //  updated.
-                //
-                //  `pending_rewards_at_time_th_minus_1` is added to the resulting value to account for all
-                //  rewards that had accumulated up until the last time `update_position` was updated.
-                //
-                // iia. Allocate rewards to this position that have been emitted since the last time this
-                //  function was called.
+                // Add newly accrued rewards since the last update
                 this.stakedPosition.rewardCoins[rewardCoinIndex].baseRewardsAccumulated =
                     totalBaseRewardsFromTimeT0 -
                         stakedPositionRewardCoin.baseRewardsDebt +
@@ -142,22 +249,21 @@ class FarmsStakedPosition extends caller_1.Caller {
                     totalMultiplierRewardsFromTimeT0 -
                         stakedPositionRewardCoin.multiplierRewardsDebt +
                         stakedPositionRewardCoin.multiplierRewardsAccumulated;
-                // iib. Set the position's current debt to the total rewards attributed to this position given
-                //  the vault's current state. This allows the next `update_position` call to disregard
-                //  all rewards accumulated up until this point -- preventing double emission cases.
+                // Update debts to the new total from time t0
                 this.stakedPosition.rewardCoins[rewardCoinIndex].baseRewardsDebt =
                     totalBaseRewardsFromTimeT0;
                 this.stakedPosition.rewardCoins[rewardCoinIndex].multiplierRewardsDebt = totalMultiplierRewardsFromTimeT0;
             }
-            // iii. Remove the position's lock multiplier + bonus staked amount if the position is no
-            //  longer locked.
+            // Check if this position’s lock has expired
             if (this.unlockTimestamp() < currentTimestamp) {
                 this.unlock();
             }
             this.stakedPosition.lastHarvestRewardsTimestamp = currentTimestamp;
         };
-        // Removes a positions `lock_duration_ms` and `lock_multiplier`. Updates the vault's
-        //  `staked_amount_with_multiplier` to account for the lost `lock_multiplier`.
+        /**
+         * Removes the lock multiplier from this position if the current time is beyond the lock duration,
+         * reverting `lockMultiplier` to 1.0 (fixedOneB).
+         */
         this.unlock = () => {
             // ia. Remove position's `multiplier_staked_amount` from the pool.
             // afterburner_vault::decrease_stake_with_multiplier(vault, self.multiplier_staked_amount);
@@ -166,29 +272,21 @@ class FarmsStakedPosition extends caller_1.Caller {
             this.stakedPosition.lockDurationMs = 0;
             this.stakedPosition.lockMultiplier = fixedUtils_1.FixedUtils.fixedOneB;
         };
+        /**
+         * Determines if this position is unlocked based on the lock end timestamp, the emission end timestamp,
+         * or a forced unlock condition in the pool.
+         */
         this.isUnlocked = (inputs) => {
             const { stakingPool } = inputs;
-            // let emitted_rewards = stakingPool.calc_emitted_rewards();
-            // let total_rewards = stakingPool.stakingPool.rewardCoins.map(
-            // 	(coin) => coin.rewards
-            // );
-            // let length = emitted_rewards.length;
-            // let index = 0;
-            // let no_rewards_are_remaining = true;
-            // while (index < length && no_rewards_are_remaining) {
-            // 	let emitted = emitted_rewards[index];
-            // 	let total = total_rewards[index];
-            // 	if (emitted < total) no_rewards_are_remaining = false;
-            // 	index = index + 1;
-            // }
-            return (this.unlockTimestamp() <= (0, dayjs_1.default)().valueOf() ||
-                stakingPool.stakingPool.emissionEndTimestamp <= (0, dayjs_1.default)().valueOf() ||
-                // no_rewards_are_remaining
+            const currentTime = (0, dayjs_1.default)().valueOf();
+            // If lock has expired, the emission has ended, or the pool is forcibly unlocked, then it is unlocked
+            return (this.unlockTimestamp() <= currentTime ||
+                stakingPool.stakingPool.emissionEndTimestamp <= currentTime ||
                 stakingPool.stakingPool.isUnlocked);
         };
-        // =========================================================================
-        //  Private Helpers
-        // =========================================================================
+        /**
+         * Provides access to the `Farms` provider in the `AftermathApi`.
+         */
         this.useProvider = () => {
             var _a;
             const provider = (_a = this.Provider) === null || _a === void 0 ? void 0 : _a.Farms();
@@ -200,62 +298,101 @@ class FarmsStakedPosition extends caller_1.Caller {
         this.trueLastHarvestRewardsTimestamp =
             trueLastHarvestRewardsTimestamp !== null && trueLastHarvestRewardsTimestamp !== void 0 ? trueLastHarvestRewardsTimestamp : stakedPosition.lastHarvestRewardsTimestamp;
     }
-    // public calcTotalApr = (inputs: {
-    // 	rewardsUsd: number;
-    // 	stakeUsd: number;
-    // }): Apr => {
-    // 	const { rewardsUsd, stakeUsd } = inputs;
-    // 	dayjs.extend(duration);
-    // 	const oneYearMs = dayjs.duration(1, "year").asMilliseconds();
-    // 	const timeSinceLastHarvestMs =
-    // 		dayjs().valueOf() - this.trueLastHarvestRewardsTimestamp;
-    // 	const rewardsUsdOneYear =
-    // 		timeSinceLastHarvestMs > 0
-    // 			? rewardsUsd * (oneYearMs / timeSinceLastHarvestMs)
-    // 			: 0;
-    // 	const apr = stakeUsd > 0 ? rewardsUsdOneYear / stakeUsd : 0;
-    // 	return apr < 0 ? 0 : isNaN(apr) ? 0 : apr;
-    // };
     // =========================================================================
     //  Transactions
     // =========================================================================
     // =========================================================================
     //  Staking Transactions
     // =========================================================================
+    /**
+     * Builds a transaction to deposit additional principal into this staked position.
+     *
+     * @param inputs - Contains `depositAmount`, the `walletAddress` performing the deposit, and optional sponsorship.
+     * @returns A transaction object (or bytes) that can be signed and executed to increase stake.
+     */
     getDepositPrincipalTransaction(inputs) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.useProvider().fetchBuildDepositPrincipalTx(Object.assign(Object.assign({}, inputs), { stakedPositionId: this.stakedPosition.objectId, stakeCoinType: this.stakedPosition.stakeCoinType, stakingPoolId: this.stakedPosition.stakingPoolObjectId }));
+            const args = Object.assign(Object.assign({}, inputs), { stakedPositionId: this.stakedPosition.objectId, stakeCoinType: this.stakedPosition.stakeCoinType, stakingPoolId: this.stakedPosition.stakingPoolObjectId });
+            return this.version() === 1
+                ? this.useProvider().fetchBuildDepositPrincipalTxV1(args)
+                : this.useProvider().fetchBuildDepositPrincipalTxV2(args);
         });
     }
+    /**
+     * Builds a transaction to unstake this entire position, optionally claiming SUI as afSUI.
+     *
+     * @param inputs - Contains `walletAddress`, the `FarmsStakingPool` reference, and optional `claimSuiAsAfSui`.
+     * @returns A transaction that can be signed and executed to fully withdraw principal and possibly rewards.
+     */
     getUnstakeTransaction(inputs) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.useProvider().fetchBuildUnstakeTx(Object.assign(Object.assign({}, inputs), { stakedPositionId: this.stakedPosition.objectId, stakeCoinType: this.stakedPosition.stakeCoinType, stakingPoolId: this.stakedPosition.stakingPoolObjectId, withdrawAmount: this.stakedPosition.stakedAmount, rewardCoinTypes: this.nonZeroRewardCoinTypes(inputs) }));
+            const args = Object.assign(Object.assign({}, inputs), { stakedPositionId: this.stakedPosition.objectId, stakeCoinType: this.stakedPosition.stakeCoinType, stakingPoolId: this.stakedPosition.stakingPoolObjectId, withdrawAmount: this.stakedPosition.stakedAmount, rewardCoinTypes: this.nonZeroRewardCoinTypes(inputs) });
+            return this.version() === 1
+                ? this.useProvider().fetchBuildUnstakeTxV1(args)
+                : this.useProvider().fetchBuildUnstakeTxV2(args);
         });
     }
     // =========================================================================
     //  Locking Transactions
     // =========================================================================
+    /**
+     * Builds a transaction to lock this position for a specified duration, increasing its lock multiplier (if any).
+     *
+     * @param inputs - Contains the `lockDurationMs` and the `walletAddress`.
+     * @returns A transaction that can be signed and executed to lock the position.
+     */
     getLockTransaction(inputs) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.useProvider().buildLockTx(Object.assign(Object.assign({}, inputs), { stakedPositionId: this.stakedPosition.objectId, stakeCoinType: this.stakedPosition.stakeCoinType, stakingPoolId: this.stakedPosition.stakingPoolObjectId }));
+            const args = Object.assign(Object.assign({}, inputs), { stakedPositionId: this.stakedPosition.objectId, stakeCoinType: this.stakedPosition.stakeCoinType, stakingPoolId: this.stakedPosition.stakingPoolObjectId });
+            return this.version() === 1
+                ? this.useProvider().buildLockTxV1(args)
+                : this.useProvider().buildLockTxV2(args);
         });
     }
+    /**
+     * Builds a transaction to re-lock this position (renew lock duration) at the current multiplier.
+     *
+     * @param inputs - Contains the `walletAddress`.
+     * @returns A transaction that can be signed and executed to extend or refresh the lock.
+     */
     getRenewLockTransaction(inputs) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.useProvider().buildRenewLockTx(Object.assign(Object.assign({}, inputs), { stakedPositionId: this.stakedPosition.objectId, stakeCoinType: this.stakedPosition.stakeCoinType, stakingPoolId: this.stakedPosition.stakingPoolObjectId }));
+            const args = Object.assign(Object.assign({}, inputs), { stakedPositionId: this.stakedPosition.objectId, stakeCoinType: this.stakedPosition.stakeCoinType, stakingPoolId: this.stakedPosition.stakingPoolObjectId });
+            return this.version() === 1
+                ? this.useProvider().buildRenewLockTxV1(args)
+                : this.useProvider().buildRenewLockTxV2(args);
         });
     }
+    /**
+     * Builds a transaction to unlock this position, removing any lock-based multiplier.
+     *
+     * @param inputs - Contains the `walletAddress`.
+     * @returns A transaction that can be signed and executed to unlock the position immediately.
+     */
     getUnlockTransaction(inputs) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.useProvider().buildUnlockTx(Object.assign(Object.assign({}, inputs), { stakedPositionId: this.stakedPosition.objectId, stakeCoinType: this.stakedPosition.stakeCoinType, stakingPoolId: this.stakedPosition.stakingPoolObjectId }));
+            const args = Object.assign(Object.assign({}, inputs), { stakedPositionId: this.stakedPosition.objectId, stakeCoinType: this.stakedPosition.stakeCoinType, stakingPoolId: this.stakedPosition.stakingPoolObjectId });
+            return this.version() === 1
+                ? this.useProvider().buildUnlockTxV1(args)
+                : this.useProvider().buildUnlockTxV2(args);
         });
     }
     // =========================================================================
     //  Reward Harvesting Transactions
     // =========================================================================
+    /**
+     * Builds a transaction to harvest (claim) the rewards from this position,
+     * optionally receiving SUI as afSUI.
+     *
+     * @param inputs - Includes the `walletAddress`, the `FarmsStakingPool`, and optional `claimSuiAsAfSui`.
+     * @returns A transaction that can be signed and executed to claim accrued rewards.
+     */
     getHarvestRewardsTransaction(inputs) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.useProvider().fetchBuildHarvestRewardsTx(Object.assign(Object.assign({}, inputs), { stakedPositionIds: [this.stakedPosition.objectId], stakeCoinType: this.stakedPosition.stakeCoinType, stakingPoolId: this.stakedPosition.stakingPoolObjectId, rewardCoinTypes: this.nonZeroRewardCoinTypes(inputs) }));
+            const args = Object.assign(Object.assign({}, inputs), { stakedPositionIds: [this.stakedPosition.objectId], stakeCoinType: this.stakedPosition.stakeCoinType, stakingPoolId: this.stakedPosition.stakingPoolObjectId, rewardCoinTypes: this.nonZeroRewardCoinTypes(inputs) });
+            return this.version() === 1
+                ? this.useProvider().fetchBuildHarvestRewardsTxV1(args)
+                : this.useProvider().fetchBuildHarvestRewardsTxV2(args);
         });
     }
     // =========================================================================
@@ -264,79 +401,48 @@ class FarmsStakedPosition extends caller_1.Caller {
     // =========================================================================
     //  Calculations
     // =========================================================================
-    // Calculates a position's accrued rewards [from time t0] given a vault's
-    //  `rewardsAccumulatedPerShare`. If the position is beyond its lock duration, we need to only
-    //  apply the lock multiplier rewards to the time spent locked.
+    /**
+     * Calculates the total base + multiplier rewards from time t0 for this position,
+     * ensuring that multiplier rewards only apply during the locked period.
+     *
+     * @param inputs - Contains updated `rewardsAccumulatedPerShare`, the position’s `multiplierRewardsDebt`, and the pool’s `emissionEndTimestamp`.
+     * @returns A tuple `[baseRewards, multiplierRewards]`.
+     */
     calcTotalRewardsFromTimeT0(inputs) {
         const { rewardsAccumulatedPerShare, multiplierRewardsDebt, emissionEndTimestamp, } = inputs;
         const currentTimestamp = (0, dayjs_1.default)().valueOf();
         const lastRewardTimestamp = this.stakedPosition.lastHarvestRewardsTimestamp;
         const lockEndTimestamp = this.unlockTimestamp();
         const principalStakedAmount = this.stakedPosition.stakedAmount;
-        // Base [e.g. principal] staked amount receives full (unaltered) rewards.
-        const rewardsAttributedToPrincipal = (principalStakedAmount * rewardsAccumulatedPerShare) /
+        const baseRewards = (principalStakedAmount * rewardsAccumulatedPerShare) /
             fixedUtils_1.FixedUtils.fixedOneB;
-        const totalRewardsAttributedToLockMultiplier = (this.stakedPosition.stakedAmountWithMultiplier *
+        const totalMultiplierRewards = (this.stakedPosition.stakedAmountWithMultiplier *
             rewardsAccumulatedPerShare) /
             fixedUtils_1.FixedUtils.fixedOneB;
-        // The position should only receive multiplied rewards for the time that was spent locked since
-        //  the last harvest. This case occurs when the user calls `pending_rewards` after the position's
-        //  lock duration has expired.
-        const rewardsAttributedToLockMultiplier = (() => {
-            return currentTimestamp <= lockEndTimestamp
-                ? //*********************************************************************************************//
-                    //                                              v                                              //
-                    //  |-------------------------------------------+-------------------------------------------|  //
-                    //  last_reward_timestamp_ms           current_timestamp_ms             lock_end_timestamp_ms  //
-                    //*********************************************************************************************//
-                    totalRewardsAttributedToLockMultiplier
-                : lockEndTimestamp <= lastRewardTimestamp
-                    ? //*********************************************************************************************//
-                        //                   emission_end_timestamp_ms       lock_end_timestamp_ms                  v  //
-                        //  |----------------------------+-----------------------------+----------------------------|  //
-                        //  last_reward_timestamp_ms                                             current_timestamp_ms  //
-                        //*********************************************************************************************//
-                        //
-                        // NOTE: if the lock period was longer than the rewards emission, the position receives the full
-                        //  multiplier rewards
-                        multiplierRewardsDebt
-                    : emissionEndTimestamp <= lockEndTimestamp
-                        ? totalRewardsAttributedToLockMultiplier
-                        : (() => {
-                            //*********************************************************************************************//
-                            //                    lock_end_timestamp_ms        emission_end_timestamp_ms                v  //
-                            //  |----------------------------+-----------------------------+----------------------------|  //
-                            //  last_reward_timestamp_ms                                             current_timestamp_ms  //
-                            //*********************************************************************************************//
-                            //
-                            // NOTE: there is no enforced ordering of `emission_end_timestamp_ms` and `current_timestamp_ms`
-                            //  by the time we get to this branch.
-                            // Multiplier staked amount receives (altered) rewards dependent on the total time the
-                            //  position was locked since the last harvest.
-                            const timeSpentLockedSinceLastHarvestMs = lockEndTimestamp - lastRewardTimestamp;
-                            const timeSinceLastHarvestMs = currentTimestamp - lastRewardTimestamp;
-                            // ********************************************************************************************//
-                            //  / timeSpentLockedSinceLastHarvestMs \                                                //
-                            // | ----------------------------------------- | x totalRewardsAttributedToLockMultiplier //
-                            //  \       timeSinceLastHarvest        /                                                //
-                            // ********************************************************************************************//
-                            // Only disperse the multiplied rewards that were received while this position was locked.
-                            //
-                            // We are assigning this value to the total_multiplier_rewards later and this number should
-                            // never decrease, so we use max() here.
-                            const possibleMultiplierRewardsDebt = (totalRewardsAttributedToLockMultiplier *
-                                BigInt(Math.floor(timeSpentLockedSinceLastHarvestMs))) /
-                                BigInt(Math.floor(timeSinceLastHarvestMs));
-                            return possibleMultiplierRewardsDebt >
-                                multiplierRewardsDebt
-                                ? possibleMultiplierRewardsDebt
-                                : multiplierRewardsDebt;
-                        })();
+        const multiplierRewards = (() => {
+            // If position is fully locked throughout the last harvest period
+            if (currentTimestamp <= lockEndTimestamp) {
+                return totalMultiplierRewards;
+            }
+            // If lock ended before or at the last harvest, fallback to previously calculated debt
+            if (lockEndTimestamp <= lastRewardTimestamp) {
+                return multiplierRewardsDebt;
+            }
+            // If emission ended while still locked, or fully locked within emission window
+            if (emissionEndTimestamp <= lockEndTimestamp) {
+                return totalMultiplierRewards;
+            }
+            // Otherwise, partial locking scenario
+            const timeSpentLockedSinceLastHarvestMs = lockEndTimestamp - lastRewardTimestamp;
+            const timeSinceLastHarvestMs = currentTimestamp - lastRewardTimestamp;
+            const possibleMultiplierRewardsDebt = (totalMultiplierRewards *
+                BigInt(Math.floor(timeSpentLockedSinceLastHarvestMs))) /
+                BigInt(Math.floor(timeSinceLastHarvestMs));
+            return possibleMultiplierRewardsDebt > multiplierRewardsDebt
+                ? possibleMultiplierRewardsDebt
+                : multiplierRewardsDebt;
         })();
-        return [
-            rewardsAttributedToPrincipal,
-            rewardsAttributedToLockMultiplier,
-        ];
+        return [baseRewards, multiplierRewards];
     }
 }
 exports.FarmsStakedPosition = FarmsStakedPosition;