@exodus/solana-api 3.11.1 → 3.11.2

package/CHANGELOG.md

@@ -3,6 +3,15 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [3.11.2](https://github.com/ExodusMovement/assets/compare/@exodus/solana-api@3.11.1...@exodus/solana-api@3.11.2) (2024-10-10)
+
+
+### Bug Fixes
+
+* SOL doc old references ([#4168](https://github.com/ExodusMovement/assets/issues/4168)) ([73e5516](https://github.com/ExodusMovement/assets/commit/73e5516109f9a3c2012198ef8aa68fc0a5032d5d))
+
+
+
 ## [3.11.1](https://github.com/ExodusMovement/assets/compare/@exodus/solana-api@3.11.0...@exodus/solana-api@3.11.1) (2024-09-11)
 
 

package/README.md

@@ -1,4 +1,4 @@
 # Solana Api · [![npm version](https://img.shields.io/badge/npm-private-blue.svg?style=flat)](https://www.npmjs.com/package/@exodus/solana-api)
 
-- To get all transactions data from an address we gotta call 3 rpcs `getConfirmedSignaturesForAddress2` (get txIds) -> `getConfirmedTransaction` (get tx details) -> `getBlockTime` (get tx timestamp). Pretty annoying and resource-consuming backend-side. (https://github.com/solana-labs/solana/issues/12411)
+- To get all transactions data from an address we gotta call 3 rpcs `getSignaturesForAddress` (get txIds) -> `getTransaction` (get tx details) -> `getBlockTime` (get tx timestamp). Pretty annoying and resource-consuming backend-side. (https://github.com/solana-labs/solana/issues/12411)
 - calling `getBlockTime` might results in an error if the slot/block requested is too old (https://github.com/solana-labs/solana/issues/12413), looks like some Solana validators can choose to not keep all the ledger blocks (fix in progress by solana team).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/solana-api",
-  "version": "3.11.1",
+  "version": "3.11.2",
   "description": "Exodus internal Solana asset API wrapper",
   "type": "module",
   "main": "src/index.js",
@@ -47,7 +47,7 @@
     "@exodus/assets-testing": "^1.0.0",
     "@exodus/solana-web3.js": "^1.63.1-exodus.9-rc2"
   },
-  "gitHead": "732c0d1ea9b13de6eac6edc49aa8ab866575d8d7",
+  "gitHead": "45abf17ba22cc6a66b112118ee2157dc55bcbde0",
   "bugs": {
     "url": "https://github.com/ExodusMovement/assets/issues?q=is%3Aissue+is%3Aopen+label%3Asolana-api"
   },

package/src/api.js

@@ -1,4 +1,5 @@
 import createApiCJS from '@exodus/asset-json-rpc'
+import { memoize } from '@exodus/basic-utils'
 import { retry } from '@exodus/simple-retry'
 import {
   buildRawTransaction,
@@ -20,6 +21,7 @@ import urljoin from 'url-join'
 import wretch from 'wretch'
 
 import { Connection } from './connection.js'
+import { getStakeActivation } from './get-stake-activation/index.js'
 
 const createApi = createApiCJS.default || createApiCJS
 
@@ -38,10 +40,10 @@ export class Api {
     this.tokensToSkip = {}
     this.txsLimit = txsLimit
     this.connections = {}
-    this.getSupply = lodash.memoize(async (mintAddress) => {
+    this.getSupply = memoize(async (mintAddress) => {
       // cached getSupply
       const result = await this.rpcCall('getTokenSupply', [mintAddress])
-      return lodash.get(result, 'value.amount')
+      return result?.value?.amount
     })
   }
 
@@ -126,9 +128,9 @@ export class Api {
     return Number(epoch)
   }
 
-  async getStakeActivation(address) {
-    const { state } = await this.rpcCall('getStakeActivation', [address])
-    return state
+  async getStakeActivation(stakeAddress) {
+    const { status } = await getStakeActivation(this, stakeAddress)
+    return status
   }
 
   async getRecentBlockHash(commitment) {
@@ -148,13 +150,6 @@ export class Api {
     ])
   }
 
-  async getFee() {
-    const result = await this.rpcCall('getRecentBlockhash', [
-      { commitment: 'finalized', encoding: 'jsonParsed' },
-    ])
-    return lodash.get(result, 'value.feeCalculator.lamportsPerSignature')
-  }
-
   async getPriorityFee(transaction) {
     // https://docs.helius.dev/solana-rpc-nodes/alpha-priority-fee-api
     const result = await this.rpcCall('getPriorityFeeEstimate', [

package/src/get-stake-activation/delegation.js

@@ -0,0 +1,153 @@
+const WARMUP_COOLDOWN_RATE = 0.09
+
+function getStakeHistoryEntry(epoch, stakeHistory) {
+  for (const entry of stakeHistory) {
+    if (entry.epoch === epoch) {
+      return entry
+    }
+  }
+
+  return null
+}
+
+function getStakeAndActivating(
+  delegation, // Delegation
+  targetEpoch, // number
+  stakeHistory // StakeHistoryEntry[]
+) {
+  if (delegation.activationEpoch === delegation.deactivationEpoch) {
+    // activated but instantly deactivated; no stake at all regardless of target_epoch
+    return {
+      effective: 0,
+      activating: 0,
+    }
+  }
+
+  if (targetEpoch === delegation.activationEpoch) {
+    // all is activating
+    return {
+      effective: 0,
+      activating: delegation.stake,
+    }
+  }
+
+  if (targetEpoch < delegation.activationEpoch) {
+    // not yet enabled
+    return {
+      effective: 0,
+      activating: 0,
+    }
+  }
+
+  let currentEpoch = delegation.activationEpoch
+  let entry = getStakeHistoryEntry(currentEpoch, stakeHistory)
+  if (entry !== null) {
+    // target_epoch > self.activation_epoch
+
+    // loop from my activation epoch until the target epoch summing up my entitlement
+    // current effective stake is updated using its previous epoch's cluster stake
+    let currentEffectiveStake = 0
+    while (entry !== null) {
+      currentEpoch++
+      const remaining = delegation.stake - currentEffectiveStake
+      const weight = Number(remaining) / Number(entry.activating)
+      const newlyEffectiveClusterStake = Number(entry.effective) * WARMUP_COOLDOWN_RATE
+      const newlyEffectiveStake = Math.max(1, Math.round(weight * newlyEffectiveClusterStake))
+
+      currentEffectiveStake += newlyEffectiveStake
+      if (currentEffectiveStake >= delegation.stake) {
+        currentEffectiveStake = delegation.stake
+        break
+      }
+
+      if (currentEpoch >= targetEpoch || currentEpoch >= delegation.deactivationEpoch) {
+        break
+      }
+
+      entry = getStakeHistoryEntry(currentEpoch, stakeHistory)
+    }
+
+    return {
+      effective: currentEffectiveStake,
+      activating: delegation.stake - currentEffectiveStake,
+    }
+  }
+
+  // no history or I've dropped out of history, so assume fully effective
+  return {
+    effective: delegation.stake,
+    activating: 0,
+  }
+}
+
+export function getStakeActivatingAndDeactivating(delegation, targetEpoch, stakeHistory) {
+  const { effective, activating } = getStakeAndActivating(delegation, targetEpoch, stakeHistory)
+
+  // then de-activate some portion if necessary
+  if (targetEpoch < delegation.deactivationEpoch) {
+    return {
+      effective,
+      activating,
+      deactivating: 0,
+    }
+  }
+
+  if (targetEpoch === delegation.deactivationEpoch) {
+    // can only deactivate what's activated
+    return {
+      effective,
+      activating: 0,
+      deactivating: effective,
+    }
+  }
+
+  let currentEpoch = delegation.deactivationEpoch
+  let entry = getStakeHistoryEntry(currentEpoch, stakeHistory)
+  if (entry !== null) {
+    // target_epoch > self.activation_epoch
+    // loop from my deactivation epoch until the target epoch
+    // current effective stake is updated using its previous epoch's cluster stake
+    let currentEffectiveStake = effective
+    while (entry !== null) {
+      currentEpoch++
+      // if there is no deactivating stake at prev epoch, we should have been
+      // fully undelegated at this moment
+      if (entry.deactivating === 0) {
+        break
+      }
+
+      // I'm trying to get to zero, how much of the deactivation in stake
+      //   this account is entitled to take
+      const weight = Number(currentEffectiveStake) / Number(entry.deactivating)
+
+      // portion of newly not-effective cluster stake I'm entitled to at current epoch
+      const newlyNotEffectiveClusterStake = Number(entry.effective) * WARMUP_COOLDOWN_RATE
+      const newlyNotEffectiveStake = Math.max(1, Math.round(weight * newlyNotEffectiveClusterStake))
+
+      currentEffectiveStake -= newlyNotEffectiveStake
+      if (currentEffectiveStake <= 0) {
+        currentEffectiveStake = 0
+        break
+      }
+
+      if (currentEpoch >= targetEpoch) {
+        break
+      }
+
+      entry = getStakeHistoryEntry(currentEpoch, stakeHistory)
+    }
+
+    // deactivating stake should equal to all of currently remaining effective stake
+    return {
+      effective: currentEffectiveStake,
+      deactivating: currentEffectiveStake,
+      activating: 0,
+    }
+  }
+
+  return {
+    effective: 0,
+    activating: 0,
+    deactivating: 0,
+  }
+}

package/src/get-stake-activation/index.js

@@ -0,0 +1,63 @@
+import { getStakeActivatingAndDeactivating } from './delegation.js'
+
+const SYSVAR_STAKE_HISTORY_ADDRESS = 'SysvarStakeHistory1111111111111111111111111'
+
+// Extracted from https://github.com/anza-xyz/solana-rpc-client-extensions/blob/main/js/src/rpc.ts
+
+export async function getStakeActivation(api, stakeAddress) {
+  const [epoch, stakeAccount, stakeHistory] = await Promise.all([
+    api.getEpochInfo(),
+    (async () => {
+      const stakeAccount = await api.getAccountInfo(stakeAddress)
+      if (stakeAccount.data.discriminant === 0) {
+        throw new Error('data.discriminant is 0')
+      }
+
+      return stakeAccount
+    })(),
+    (async () => {
+      return api.getAccountInfo(SYSVAR_STAKE_HISTORY_ADDRESS)
+    })(),
+  ])
+
+  const rentExemptReserve = stakeAccount.data.parsed.info.meta.rentExemptReserve
+  if (stakeAccount.data.parsed.discriminant === 1) {
+    return {
+      status: 'inactive',
+      active: 0,
+      inactive: stakeAccount.lamports - rentExemptReserve,
+    }
+  }
+
+  // THE HARD PART
+  const { effective, activating, deactivating } = stakeAccount.data.parsed.info.stake
+    ? getStakeActivatingAndDeactivating(
+        stakeAccount.data.parsed.info.stake.delegation,
+        epoch,
+        stakeHistory.data.parsed.info
+      )
+    : {
+        effective: 0,
+        activating: 0,
+        deactivating: 0,
+      }
+
+  let status
+  if (deactivating > 0) {
+    status = 'deactivating'
+  } else if (activating > 0) {
+    status = 'activating'
+  } else if (effective > 0) {
+    status = 'active'
+  } else {
+    status = 'inactive'
+  }
+
+  const inactive = stakeAccount.lamports - effective - rentExemptReserve
+
+  return {
+    status,
+    active: effective,
+    inactive,
+  }
+}

package/src/index.js

@@ -4,7 +4,6 @@ import assetsList from '@exodus/solana-meta'
 
 import { Api } from './api.js'
 
-export { default as SolanaFeeMonitor } from './fee-monitor.js'
 export { SolanaMonitor, SolanaAutoWithdrawMonitor } from './tx-log/index.js'
 export { createAccountState } from './account-state.js'
 export { getSolStakedFee, getStakingInfo, getUnstakingFee } from './staking-utils.js'

package/src/tx-log/solana-auto-withdraw-monitor.js

@@ -1,10 +1,7 @@
 import { Timer } from '@exodus/timer'
-import lodash from 'lodash'
 import assert from 'minimalistic-assert'
 import ms from 'ms'
 
-const { get } = lodash
-
 const INTERVAL = ms('30s')
 
 export class SolanaAutoWithdrawMonitor {
@@ -53,9 +50,9 @@ export class SolanaAutoWithdrawMonitor {
   async tryWithdraw({ accountState, walletAccount }) {
     const stakingInfo = accountState.stakingInfo
     const feeData = await this.aci.getFeeData({ assetName: this.assetName })
-    const fee = get(feeData, 'fee', this.asset.currency.ZERO)
+    const fee = feeData?.fee ?? this.asset.currency.ZERO
 
-    const solBalance = get(accountState, 'balance', this.asset.currency.ZERO)
+    const solBalance = accountState?.balance ?? this.asset.currency.ZERO
     if (solBalance.lt(fee) || stakingInfo.withdrawable.isZero) return []
 
     const promises = await this.createAndSendStake(

package/src/txs-utils.js

@@ -1,13 +1,8 @@
-import lodash from 'lodash'
-
-const { get } = lodash
-
 const isSolanaTx = (tx) => tx.coinName === 'solana'
 export const isSolanaStaking = (tx) =>
-  isSolanaTx(tx) && ['createAccountWithSeed', 'delegate'].includes(get(tx, 'data.staking.method'))
+  isSolanaTx(tx) && ['createAccountWithSeed', 'delegate'].includes(tx?.data?.staking?.method)
 export const isSolanaUnstaking = (tx) =>
-  isSolanaTx(tx) && get(tx, 'data.staking.method') === 'undelegate'
-export const isSolanaWithdrawn = (tx) =>
-  isSolanaTx(tx) && get(tx, 'data.staking.method') === 'withdraw'
+  isSolanaTx(tx) && tx?.data?.staking?.method === 'undelegate'
+export const isSolanaWithdrawn = (tx) => isSolanaTx(tx) && tx?.data?.staking?.method === 'withdraw'
 export const isSolanaRewardsActivityTx = (tx) =>
   [isSolanaStaking, isSolanaUnstaking, isSolanaWithdrawn].some((fn) => fn(tx))

package/src/fee-monitor.js

@@ -1,19 +0,0 @@
-import { FeeMonitor } from '@exodus/asset-lib'
-
-export default class SolanaFeeMonitor extends FeeMonitor {
-  #api
-
-  constructor({ updateFee, interval = '1m', assetName = 'solana', api }) {
-    super({ updateFee, interval, assetName })
-    this.#api = api
-  }
-
-  async fetchFee() {
-    const fee = await this.#api.getFee()
-    if (fee === undefined) throw new Error('Failed to fetch fee')
-
-    return {
-      fee: `${fee} Lamports`,
-    }
-  }
-}