@exponent-labs/exponent-sdk 0.9.0 → 0.9.2

package/src/exponentVaults/kamino-farms.ts

@@ -0,0 +1,538 @@
+import { PublicKey } from "@solana/web3.js"
+
+const U64_MAX = 18_446_744_073_709_551_615n
+const DECIMAL_WAD = 1_000_000_000_000_000_000n
+const BPS_DIV_FACTOR = 10_000n
+const DEFAULT_PUBLIC_KEY = PublicKey.default
+
+export const KAMINO_FARM_ACCOUNT_DISCRIMINATOR_LEN = 8
+export const KAMINO_FARM_GLOBAL_CONFIG_OFFSET = 32
+export const KAMINO_FARM_GLOBAL_CONFIG_TREASURY_FEE_BPS_OFFSET = 32
+export const KAMINO_FARM_TOKEN_MINT_OFFSET = 64
+export const KAMINO_FARM_TOKEN_PROGRAM_OFFSET = 104
+export const KAMINO_FARM_REWARD_INFOS_OFFSET = 184
+export const KAMINO_FARM_REWARD_INFO_SIZE = 704
+export const KAMINO_FARM_REWARD_TOKEN_MINT_OFFSET = 0
+export const KAMINO_FARM_REWARD_TOKEN_PROGRAM_OFFSET = 40
+export const KAMINO_FARM_REWARD_VAULT_OFFSET = 120
+export const KAMINO_FARM_REWARDS_AVAILABLE_OFFSET = 152
+export const KAMINO_FARM_REWARD_SCHEDULE_CURVE_OFFSET = 160
+export const KAMINO_FARM_REWARD_SCHEDULE_CURVE_POINTS = 20
+export const KAMINO_FARM_REWARD_SCHEDULE_CURVE_POINT_SIZE = 16
+export const KAMINO_FARM_LAST_ISSUANCE_TS_OFFSET = 488
+export const KAMINO_FARM_REWARDS_ISSUED_UNCLAIMED_OFFSET = 496
+export const KAMINO_FARM_REWARDS_ISSUED_CUMULATIVE_OFFSET = 504
+export const KAMINO_FARM_REWARD_PER_SHARE_SCALED_OFFSET = 512
+export const KAMINO_FARM_REWARD_TYPE_OFFSET = 536
+export const KAMINO_FARM_REWARDS_PER_SECOND_DECIMALS_OFFSET = 537
+export const KAMINO_FARM_NUM_REWARD_TOKENS_OFFSET = 7224
+export const KAMINO_FARM_TOTAL_STAKED_AMOUNT_OFFSET = 7240
+export const KAMINO_FARM_FARM_VAULT_OFFSET = 7248
+export const KAMINO_FARM_FARM_VAULTS_AUTHORITY_OFFSET = 7280
+export const KAMINO_FARM_FARM_VAULTS_AUTHORITY_BUMP_OFFSET = 7312
+export const KAMINO_FARM_DELEGATE_AUTHORITY_OFFSET = 7320
+export const KAMINO_FARM_TIME_UNIT_OFFSET = 7352
+export const KAMINO_FARM_IS_FARM_DELEGATED_OFFSET = 7354
+export const KAMINO_FARM_DEPOSIT_WARMUP_PERIOD_OFFSET = 7392
+export const KAMINO_FARM_WITHDRAWAL_COOLDOWN_PERIOD_OFFSET = 7396
+export const KAMINO_FARM_TOTAL_ACTIVE_STAKE_SCALED_OFFSET = 7400
+export const KAMINO_FARM_TOTAL_PENDING_STAKE_SCALED_OFFSET = 7416
+export const KAMINO_FARM_TOTAL_PENDING_AMOUNT_OFFSET = 7432
+export const KAMINO_FARM_SCOPE_PRICES_OFFSET = 7528
+export const KAMINO_FARM_SCOPE_ORACLE_PRICE_ID_OFFSET = 7560
+export const KAMINO_FARM_SCOPE_ORACLE_MAX_AGE_OFFSET = 7568
+
+export const KAMINO_FARM_USER_OWNER_OFFSET = 40
+export const KAMINO_FARM_USER_REWARDS_TALLY_SCALED_OFFSET = 80
+export const KAMINO_FARM_USER_REWARDS_ISSUED_UNCLAIMED_OFFSET = 240
+export const KAMINO_FARM_USER_LAST_CLAIM_TS_OFFSET = 320
+export const KAMINO_FARM_USER_ACTIVE_STAKE_SCALED_OFFSET = 400
+export const KAMINO_FARM_USER_PENDING_DEPOSIT_STAKE_SCALED_OFFSET = 416
+export const KAMINO_FARM_USER_PENDING_WITHDRAWAL_UNSTAKE_SCALED_OFFSET = 440
+export const KAMINO_FARM_USER_DELEGATEE_OFFSET = 472
+
+export const KAMINO_SCOPE_ACCOUNT_DISCRIMINATOR_LEN = 8
+export const KAMINO_SCOPE_ORACLE_PRICES_ARRAY_OFFSET = 32
+export const KAMINO_SCOPE_DATED_PRICE_SIZE = 56
+export const KAMINO_SCOPE_PRICE_VALUE_OFFSET = 0
+export const KAMINO_SCOPE_PRICE_EXP_OFFSET = 8
+export const KAMINO_SCOPE_LAST_UPDATED_SLOT_OFFSET = 16
+export const KAMINO_SCOPE_UNIX_TIMESTAMP_OFFSET = 24
+
+export enum KaminoFarmTimeUnit {
+  Seconds = 0,
+  Slots = 1,
+}
+
+export enum KaminoFarmRewardType {
+  Proportional = 0,
+  Constant = 1,
+}
+
+export type KaminoFarmRewardSchedulePoint = {
+  tsStart: bigint
+  rewardPerTimeUnit: bigint
+}
+
+export type KaminoFarmRewardInfoView = {
+  rewardMint: PublicKey
+  tokenProgram: PublicKey
+  rewardsVault: PublicKey
+  rewardsAvailable: bigint
+  rewardScheduleCurve: KaminoFarmRewardSchedulePoint[]
+  lastIssuanceTs: bigint
+  rewardsIssuedUnclaimed: bigint
+  rewardsIssuedCumulative: bigint
+  rewardPerShareScaled: bigint
+  rewardType: KaminoFarmRewardType
+  rewardsPerSecondDecimals: number
+}
+
+export type KaminoFarmStateView = {
+  globalConfig: PublicKey
+  underlyingMint: PublicKey
+  tokenProgram: PublicKey
+  farmVault: PublicKey
+  farmVaultsAuthority: PublicKey
+  farmVaultsAuthorityBump: bigint
+  delegateAuthority: PublicKey
+  timeUnit: KaminoFarmTimeUnit
+  isDelegated: boolean
+  depositWarmupPeriod: number
+  withdrawalCooldownPeriod: number
+  totalStakedAmount: bigint
+  totalActiveStakeScaled: bigint
+  totalPendingStakeScaled: bigint
+  totalPendingAmount: bigint
+  numRewardTokens: number
+  scopePrices: PublicKey
+  scopeOraclePriceId: bigint
+  scopeOracleMaxAge: bigint
+  rewardInfos: KaminoFarmRewardInfoView[]
+}
+
+export type KaminoFarmUserStateView = {
+  owner: PublicKey
+  rewardsTallyScaled: bigint[]
+  rewardsIssuedUnclaimed: bigint[]
+  lastClaimTs: bigint[]
+  activeStakeScaled: bigint
+  pendingDepositStakeScaled: bigint
+  pendingWithdrawalUnstakeScaled: bigint
+  delegatee: PublicKey
+}
+
+export type KaminoScopeDatedPrice = {
+  value: bigint
+  exp: bigint
+  lastUpdatedSlot: bigint
+  unixTimestamp: bigint
+}
+
+export type KaminoFarmProjectedRewards = {
+  projectedRewardInfos: KaminoFarmRewardInfoView[]
+  projectedRewardsTallyScaled: bigint[]
+  projectedRewardsIssuedUnclaimed: bigint[]
+}
+
+function readPubkey(data: Buffer, offset: number): PublicKey {
+  return new PublicKey(data.subarray(offset, offset + 32))
+}
+
+function readU64LE(data: Buffer, offset: number): bigint {
+  return data.readBigUInt64LE(offset)
+}
+
+export function readU128LE(data: Buffer, offset: number): bigint {
+  return data.readBigUInt64LE(offset) + (data.readBigUInt64LE(offset + 8) << 64n)
+}
+
+function tenPow(exp: number): bigint {
+  const POWERS: bigint[] = [
+    1n,
+    10n,
+    100n,
+    1_000n,
+    10_000n,
+    100_000n,
+    1_000_000n,
+    10_000_000n,
+    100_000_000n,
+    1_000_000_000n,
+    10_000_000_000n,
+    100_000_000_000n,
+    1_000_000_000_000n,
+    10_000_000_000_000n,
+    100_000_000_000_000n,
+    1_000_000_000_000_000n,
+    10_000_000_000_000_000n,
+    100_000_000_000_000_000n,
+    1_000_000_000_000_000_000n,
+    10_000_000_000_000_000_000n,
+  ]
+  if (exp < 0 || exp >= POWERS.length) {
+    throw new Error(`Invalid power-of-ten exponent ${exp}`)
+  }
+  return POWERS[exp]
+}
+
+export function decodeKaminoFarmState(data: Buffer): KaminoFarmStateView {
+  const base = KAMINO_FARM_ACCOUNT_DISCRIMINATOR_LEN
+  const numRewardTokens = Number(readU64LE(data, base + KAMINO_FARM_NUM_REWARD_TOKENS_OFFSET))
+  if (numRewardTokens < 0 || numRewardTokens > 10) {
+    throw new Error(`Invalid Kamino farm reward count: ${numRewardTokens}`)
+  }
+
+  const rewardInfos: KaminoFarmRewardInfoView[] = []
+  for (let i = 0; i < numRewardTokens; i += 1) {
+    const rewardBase = base + KAMINO_FARM_REWARD_INFOS_OFFSET + (i * KAMINO_FARM_REWARD_INFO_SIZE)
+    const rewardScheduleCurve: KaminoFarmRewardSchedulePoint[] = []
+    for (let pointIndex = 0; pointIndex < KAMINO_FARM_REWARD_SCHEDULE_CURVE_POINTS; pointIndex += 1) {
+      const pointBase = rewardBase
+        + KAMINO_FARM_REWARD_SCHEDULE_CURVE_OFFSET
+        + (pointIndex * KAMINO_FARM_REWARD_SCHEDULE_CURVE_POINT_SIZE)
+      rewardScheduleCurve.push({
+        tsStart: readU64LE(data, pointBase),
+        rewardPerTimeUnit: readU64LE(data, pointBase + 8),
+      })
+    }
+
+    rewardInfos.push({
+      rewardMint: readPubkey(data, rewardBase + KAMINO_FARM_REWARD_TOKEN_MINT_OFFSET),
+      tokenProgram: readPubkey(data, rewardBase + KAMINO_FARM_REWARD_TOKEN_PROGRAM_OFFSET),
+      rewardsVault: readPubkey(data, rewardBase + KAMINO_FARM_REWARD_VAULT_OFFSET),
+      rewardsAvailable: readU64LE(data, rewardBase + KAMINO_FARM_REWARDS_AVAILABLE_OFFSET),
+      rewardScheduleCurve,
+      lastIssuanceTs: readU64LE(data, rewardBase + KAMINO_FARM_LAST_ISSUANCE_TS_OFFSET),
+      rewardsIssuedUnclaimed: readU64LE(data, rewardBase + KAMINO_FARM_REWARDS_ISSUED_UNCLAIMED_OFFSET),
+      rewardsIssuedCumulative: readU64LE(data, rewardBase + KAMINO_FARM_REWARDS_ISSUED_CUMULATIVE_OFFSET),
+      rewardPerShareScaled: readU128LE(data, rewardBase + KAMINO_FARM_REWARD_PER_SHARE_SCALED_OFFSET),
+      rewardType: data[rewardBase + KAMINO_FARM_REWARD_TYPE_OFFSET] as KaminoFarmRewardType,
+      rewardsPerSecondDecimals: data[rewardBase + KAMINO_FARM_REWARDS_PER_SECOND_DECIMALS_OFFSET],
+    })
+  }
+
+  const delegateAuthority = readPubkey(data, base + KAMINO_FARM_DELEGATE_AUTHORITY_OFFSET)
+  return {
+    globalConfig: readPubkey(data, base + KAMINO_FARM_GLOBAL_CONFIG_OFFSET),
+    underlyingMint: readPubkey(data, base + KAMINO_FARM_TOKEN_MINT_OFFSET),
+    tokenProgram: readPubkey(data, base + KAMINO_FARM_TOKEN_PROGRAM_OFFSET),
+    farmVault: readPubkey(data, base + KAMINO_FARM_FARM_VAULT_OFFSET),
+    farmVaultsAuthority: readPubkey(data, base + KAMINO_FARM_FARM_VAULTS_AUTHORITY_OFFSET),
+    farmVaultsAuthorityBump: readU64LE(data, base + KAMINO_FARM_FARM_VAULTS_AUTHORITY_BUMP_OFFSET),
+    delegateAuthority,
+    timeUnit: data[base + KAMINO_FARM_TIME_UNIT_OFFSET] as KaminoFarmTimeUnit,
+    isDelegated:
+      data[base + KAMINO_FARM_IS_FARM_DELEGATED_OFFSET] !== 0
+      || !delegateAuthority.equals(DEFAULT_PUBLIC_KEY),
+    depositWarmupPeriod: data.readUInt32LE(base + KAMINO_FARM_DEPOSIT_WARMUP_PERIOD_OFFSET),
+    withdrawalCooldownPeriod: data.readUInt32LE(base + KAMINO_FARM_WITHDRAWAL_COOLDOWN_PERIOD_OFFSET),
+    totalStakedAmount: readU64LE(data, base + KAMINO_FARM_TOTAL_STAKED_AMOUNT_OFFSET),
+    totalActiveStakeScaled: readU128LE(data, base + KAMINO_FARM_TOTAL_ACTIVE_STAKE_SCALED_OFFSET),
+    totalPendingStakeScaled: readU128LE(data, base + KAMINO_FARM_TOTAL_PENDING_STAKE_SCALED_OFFSET),
+    totalPendingAmount: readU64LE(data, base + KAMINO_FARM_TOTAL_PENDING_AMOUNT_OFFSET),
+    numRewardTokens,
+    scopePrices: readPubkey(data, base + KAMINO_FARM_SCOPE_PRICES_OFFSET),
+    scopeOraclePriceId: readU64LE(data, base + KAMINO_FARM_SCOPE_ORACLE_PRICE_ID_OFFSET),
+    scopeOracleMaxAge: readU64LE(data, base + KAMINO_FARM_SCOPE_ORACLE_MAX_AGE_OFFSET),
+    rewardInfos,
+  }
+}
+
+export function decodeKaminoFarmUserState(data: Buffer): KaminoFarmUserStateView {
+  const base = KAMINO_FARM_ACCOUNT_DISCRIMINATOR_LEN
+  const rewardsTallyScaled: bigint[] = []
+  const rewardsIssuedUnclaimed: bigint[] = []
+  const lastClaimTs: bigint[] = []
+  for (let i = 0; i < 10; i += 1) {
+    rewardsTallyScaled.push(readU128LE(data, base + KAMINO_FARM_USER_REWARDS_TALLY_SCALED_OFFSET + (i * 16)))
+    rewardsIssuedUnclaimed.push(readU64LE(data, base + KAMINO_FARM_USER_REWARDS_ISSUED_UNCLAIMED_OFFSET + (i * 8)))
+    lastClaimTs.push(readU64LE(data, base + KAMINO_FARM_USER_LAST_CLAIM_TS_OFFSET + (i * 8)))
+  }
+
+  return {
+    owner: readPubkey(data, base + KAMINO_FARM_USER_OWNER_OFFSET),
+    rewardsTallyScaled,
+    rewardsIssuedUnclaimed,
+    lastClaimTs,
+    activeStakeScaled: readU128LE(data, base + KAMINO_FARM_USER_ACTIVE_STAKE_SCALED_OFFSET),
+    pendingDepositStakeScaled: readU128LE(data, base + KAMINO_FARM_USER_PENDING_DEPOSIT_STAKE_SCALED_OFFSET),
+    pendingWithdrawalUnstakeScaled: readU128LE(
+      data,
+      base + KAMINO_FARM_USER_PENDING_WITHDRAWAL_UNSTAKE_SCALED_OFFSET,
+    ),
+    delegatee: readPubkey(data, base + KAMINO_FARM_USER_DELEGATEE_OFFSET),
+  }
+}
+
+export function decodeKaminoScopeDatedPrice(data: Buffer, priceId: bigint): KaminoScopeDatedPrice {
+  const priceOffset = KAMINO_SCOPE_ACCOUNT_DISCRIMINATOR_LEN
+    + KAMINO_SCOPE_ORACLE_PRICES_ARRAY_OFFSET
+    + (Number(priceId) * KAMINO_SCOPE_DATED_PRICE_SIZE)
+  return {
+    value: readU64LE(data, priceOffset + KAMINO_SCOPE_PRICE_VALUE_OFFSET),
+    exp: readU64LE(data, priceOffset + KAMINO_SCOPE_PRICE_EXP_OFFSET),
+    lastUpdatedSlot: readU64LE(data, priceOffset + KAMINO_SCOPE_LAST_UPDATED_SLOT_OFFSET),
+    unixTimestamp: readU64LE(data, priceOffset + KAMINO_SCOPE_UNIX_TIMESTAMP_OFFSET),
+  }
+}
+
+export function kaminoFarmUsesScopeOracle(farm: KaminoFarmStateView): boolean {
+  return farm.scopeOraclePriceId !== U64_MAX
+}
+
+export function getKaminoFarmScopePricesAddress(farm: KaminoFarmStateView): PublicKey | null {
+  if (!kaminoFarmUsesScopeOracle(farm) || farm.scopePrices.equals(DEFAULT_PUBLIC_KEY)) {
+    return null
+  }
+  return farm.scopePrices
+}
+
+export function convertKaminoStakeToAmount(
+  stake: bigint,
+  totalStake: bigint,
+  totalAmount: bigint,
+): bigint {
+  if (stake === 0n) {
+    return 0n
+  }
+  if (totalStake === 0n) {
+    return totalAmount
+  }
+  return (stake * totalAmount) / totalStake
+}
+
+export function calculateKaminoFarmPrincipalAmount(
+  farm: KaminoFarmStateView,
+  user: KaminoFarmUserStateView,
+): bigint {
+  const activeAmount = convertKaminoStakeToAmount(
+    user.activeStakeScaled,
+    farm.totalActiveStakeScaled,
+    farm.totalStakedAmount,
+  )
+  const pendingStake = user.pendingDepositStakeScaled + user.pendingWithdrawalUnstakeScaled
+  const pendingAmount = convertKaminoStakeToAmount(
+    pendingStake,
+    farm.totalPendingStakeScaled,
+    farm.totalPendingAmount,
+  )
+  return activeAmount + pendingAmount
+}
+
+function getCurrentFarmTs(
+  farm: KaminoFarmStateView,
+  params: { currentSlot: bigint; currentUnixTimestamp: bigint },
+): bigint {
+  return farm.timeUnit === KaminoFarmTimeUnit.Slots
+    ? params.currentSlot
+    : params.currentUnixTimestamp
+}
+
+// Read-only mirror of KFarms RewardScheduleCurve::most_recent_curve_starting_point and
+// RewardScheduleCurve::get_cumulative_amount_issued_since_last_ts.
+// Source:
+// https://github.com/Kamino-Finance/kfarms/blob/ae4be1b33808bae692edd9b06aecfac24714b100/programs/kfarms/src/state.rs#L344-L397
+// Differences:
+// - operates on decoded JS views
+// - throws JS errors instead of returning Anchor errors
+function getCumulativeAmountIssuedSinceLastTs(
+  rewardScheduleCurve: KaminoFarmRewardSchedulePoint[],
+  lastIssuedTs: bigint,
+  currentTs: bigint,
+): bigint {
+  if (lastIssuedTs > currentTs) {
+    throw new Error("Kamino farm reward schedule has lastIssuedTs > currentTs")
+  }
+
+  let startIndex = rewardScheduleCurve.length - 1
+  for (let i = 0; i < rewardScheduleCurve.length; i += 1) {
+    if (rewardScheduleCurve[i].tsStart > lastIssuedTs) {
+      if (i === 0) {
+        throw new Error("Kamino farm reward schedule first point starts after lastIssuedTs")
+      }
+      startIndex = i - 1
+      break
+    }
+  }
+
+  let cumulativeAmount = 0n
+  for (let i = startIndex; i < rewardScheduleCurve.length; i += 1) {
+    const point = rewardScheduleCurve[i]
+    if (point.tsStart >= currentTs) {
+      break
+    }
+
+    const startTs = point.tsStart > lastIssuedTs ? point.tsStart : lastIssuedTs
+    const endTs = i < rewardScheduleCurve.length - 1 && rewardScheduleCurve[i + 1].tsStart < currentTs
+      ? rewardScheduleCurve[i + 1].tsStart
+      : currentTs
+    cumulativeAmount += point.rewardPerTimeUnit * (endTs - startTs)
+  }
+
+  return cumulativeAmount
+}
+
+function applyKaminoFarmScopePrice(
+  farm: KaminoFarmStateView,
+  amount: bigint,
+  scopePrice: KaminoScopeDatedPrice | null,
+  currentTs: bigint,
+): bigint {
+  if (!kaminoFarmUsesScopeOracle(farm)) {
+    return amount
+  }
+  if (!scopePrice) {
+    throw new Error(`Missing scope prices for Kamino farm ${farm.scopePrices.toBase58()}`)
+  }
+  if (currentTs < scopePrice.unixTimestamp) {
+    throw new Error("Kamino farm scope price timestamp is in the future")
+  }
+  if (currentTs - scopePrice.unixTimestamp > farm.scopeOracleMaxAge) {
+    throw new Error("Kamino farm scope price is too old")
+  }
+  return (amount * scopePrice.value) / tenPow(Number(scopePrice.exp))
+}
+
+// Read-only mirror of KFarms refresh_global_reward.
+// Source:
+// https://github.com/Kamino-Finance/kfarms/blob/ae4be1b33808bae692edd9b06aecfac24714b100/programs/kfarms/src/farm_operations.rs#L759-L850
+// Differences:
+// - custody farms only
+// - operates on copied views and returns projected reward info
+export function projectKaminoFarmGlobalReward(
+  farm: KaminoFarmStateView,
+  rewardInfo: KaminoFarmRewardInfoView,
+  scopePrice: KaminoScopeDatedPrice | null,
+  params: { currentSlot: bigint; currentUnixTimestamp: bigint },
+): KaminoFarmRewardInfoView {
+  const currentTs = getCurrentFarmTs(farm, params)
+  if (currentTs === rewardInfo.lastIssuanceTs) {
+    return rewardInfo
+  }
+
+  if (farm.totalActiveStakeScaled === 0n) {
+    return {
+      ...rewardInfo,
+      lastIssuanceTs: currentTs,
+    }
+  }
+
+  const cumulativeAmount = getCumulativeAmountIssuedSinceLastTs(
+    rewardInfo.rewardScheduleCurve,
+    rewardInfo.lastIssuanceTs,
+    currentTs,
+  )
+
+  const rewardTypeAmount = rewardInfo.rewardType === KaminoFarmRewardType.Constant
+    ? cumulativeAmount * farm.totalStakedAmount
+    : cumulativeAmount
+  const decimalAdjustedAmount = rewardTypeAmount / tenPow(rewardInfo.rewardsPerSecondDecimals)
+  const oracleAdjustedAmount = applyKaminoFarmScopePrice(farm, decimalAdjustedAmount, scopePrice, currentTs)
+
+  if (oracleAdjustedAmount === 0n) {
+    return rewardInfo
+  }
+
+  const rewards = oracleAdjustedAmount < rewardInfo.rewardsAvailable
+    ? oracleAdjustedAmount
+    : rewardInfo.rewardsAvailable
+  const rewardTimesWad = rewards * DECIMAL_WAD
+  const addedRewardPerShareScaled = farm.isDelegated
+    ? rewardTimesWad / farm.totalActiveStakeScaled
+    : (rewardTimesWad * DECIMAL_WAD) / farm.totalActiveStakeScaled
+
+  return {
+    ...rewardInfo,
+    lastIssuanceTs: currentTs,
+    rewardsIssuedUnclaimed: rewardInfo.rewardsIssuedUnclaimed + rewards,
+    rewardsIssuedCumulative: rewardInfo.rewardsIssuedCumulative + rewards,
+    rewardsAvailable: rewardInfo.rewardsAvailable - rewards,
+    rewardPerShareScaled: rewardInfo.rewardPerShareScaled + addedRewardPerShareScaled,
+  }
+}
+
+// Read-only mirror of KFarms refresh_global_rewards.
+// Source:
+// https://github.com/Kamino-Finance/kfarms/blob/ae4be1b33808bae692edd9b06aecfac24714b100/programs/kfarms/src/farm_operations.rs#L852-L862
+// Differences:
+// - operates on copied reward infos
+export function projectKaminoFarmGlobalRewards(
+  farm: KaminoFarmStateView,
+  scopePrice: KaminoScopeDatedPrice | null,
+  params: { currentSlot: bigint; currentUnixTimestamp: bigint },
+): KaminoFarmRewardInfoView[] {
+  return farm.rewardInfos.map((rewardInfo) =>
+    projectKaminoFarmGlobalReward(farm, rewardInfo, scopePrice, params),
+  )
+}
+
+// Read-only mirror of KFarms user_refresh_reward.
+// Source:
+// https://github.com/Kamino-Finance/kfarms/blob/ae4be1b33808bae692edd9b06aecfac24714b100/programs/kfarms/src/farm_operations.rs#L553-L592
+// Differences:
+// - returns projected tally / rewards instead of mutating UserState
+// - clamps small negative valuation deltas to zero instead of throwing so
+//   read-only AUM can tolerate post-harvest rounding drift
+export function projectKaminoFarmUserReward(
+  farm: KaminoFarmStateView,
+  user: KaminoFarmUserStateView,
+  rewardInfo: KaminoFarmRewardInfoView,
+  rewardIndex: number,
+): { rewardsTallyScaled: bigint; rewardsIssuedUnclaimed: bigint } {
+  const rewardsTallyScaled = user.rewardsTallyScaled[rewardIndex] ?? 0n
+  const rewardsIssuedUnclaimed = user.rewardsIssuedUnclaimed[rewardIndex] ?? 0n
+  const rewardPerShareTimesStake = rewardInfo.rewardPerShareScaled * user.activeStakeScaled
+  const newRewardTallyScaled = farm.isDelegated
+    ? rewardPerShareTimesStake
+    : rewardPerShareTimesStake / DECIMAL_WAD
+  if (newRewardTallyScaled < rewardsTallyScaled) {
+    return {
+      rewardsTallyScaled,
+      rewardsIssuedUnclaimed,
+    }
+  }
+  const reward = (newRewardTallyScaled - rewardsTallyScaled) / DECIMAL_WAD
+  return {
+    rewardsTallyScaled: rewardsTallyScaled + (reward * DECIMAL_WAD),
+    rewardsIssuedUnclaimed: rewardsIssuedUnclaimed + reward,
+  }
+}
+
+// Read-only mirror of KFarms user_refresh_all_rewards.
+// Source:
+// https://github.com/Kamino-Finance/kfarms/blob/ae4be1b33808bae692edd9b06aecfac24714b100/programs/kfarms/src/farm_operations.rs#L595-L605
+// Differences:
+// - returns projected arrays instead of mutating UserState
+export function projectKaminoFarmUserRewards(
+  farm: KaminoFarmStateView,
+  user: KaminoFarmUserStateView,
+  projectedRewardInfos: KaminoFarmRewardInfoView[],
+): KaminoFarmProjectedRewards {
+  const projectedRewardsTallyScaled = [...user.rewardsTallyScaled]
+  const projectedRewardsIssuedUnclaimed = [...user.rewardsIssuedUnclaimed]
+  if (user.activeStakeScaled === 0n) {
+    return {
+      projectedRewardInfos,
+      projectedRewardsTallyScaled,
+      projectedRewardsIssuedUnclaimed,
+    }
+  }
+
+  for (let rewardIndex = 0; rewardIndex < farm.numRewardTokens; rewardIndex += 1) {
+    const projected = projectKaminoFarmUserReward(farm, user, projectedRewardInfos[rewardIndex], rewardIndex)
+    projectedRewardsTallyScaled[rewardIndex] = projected.rewardsTallyScaled
+    projectedRewardsIssuedUnclaimed[rewardIndex] = projected.rewardsIssuedUnclaimed
+  }
+
+  return {
+    projectedRewardInfos,
+    projectedRewardsTallyScaled,
+    projectedRewardsIssuedUnclaimed,
+  }
+}
+
+export function applyKaminoFarmTreasuryFee(reward: bigint, treasuryFeeBps: bigint): bigint {
+  const rewardTreasury = (reward * treasuryFeeBps) / BPS_DIV_FACTOR
+  return reward - rewardTreasury
+}