@exponent-labs/exponent-sdk 0.9.2 → 0.9.3

package/src/exponentVaults/kamino-farms.ts

@@ -1,538 +0,0 @@
-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
-}