@exodus/solana-api 2.0.4 → 2.0.5

package/src/tx-log/index.js

@@ -0,0 +1 @@
+export * from './solana-monitor'

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

@@ -0,0 +1,189 @@
+import { BaseMonitor } from '@exodus/asset-lib'
+import _ from 'lodash'
+import assert from 'minimalistic-assert'
+
+const DEFAULT_POOL_ADDRESS = '9QU2QSxhb24FUX3Tu2FpczXjpK3VYrvRudywSZaM29mF' // Everstake
+
+const DEFAULT_REMOTE_CONFIG = { rpcs: [], staking: { enabled: true, pool: DEFAULT_POOL_ADDRESS } }
+
+export class SolanaMonitor extends BaseMonitor {
+  constructor({ api, includeUnparsed = false, ...args }) {
+    super(args)
+    assert(api, 'api is required')
+    this.api = api
+    this.cursors = {}
+    this.assets = {}
+    this.includeUnparsed = includeUnparsed
+  }
+
+  setServer(config = {}) {
+    const { rpcs, staking = {} } = { ...DEFAULT_REMOTE_CONFIG, ...config }
+    this.api.setServer(rpcs[0])
+    this.staking = staking
+  }
+
+  hasNewCursor({ walletAccount, cursorState }) {
+    const { cursor } = cursorState
+    return this.cursors[walletAccount] !== cursor
+  }
+
+  async emitUnknownTokensEvent({ tokenAccounts }) {
+    const tokensList = await this.api.getWalletTokensList({ tokenAccounts })
+    if (tokensList.length > 0) {
+      this.emit('unknown-tokens', tokensList)
+    }
+  }
+
+  async tick({ walletAccount, refresh }) {
+    const assetName = this.asset.name
+    this.assets = await this.aci.getAssetsForNetwork({ baseAssetName: assetName })
+    this.api.setTokens(this.assets)
+
+    const accountState = await this.aci.getAccountState({ assetName, walletAccount })
+    const address = await this.aci.getReceiveAddress({ assetName, walletAccount })
+
+    const { logItemsByAsset, hasNewTxs, cursorState } = await this.getHistory({
+      address,
+      accountState,
+      walletAccount,
+      refresh,
+    })
+
+    let staking = accountState.mem
+
+    const cursorChanged = this.hasNewCursor({ walletAccount, cursorState })
+    if (refresh || cursorChanged) {
+      staking = await this.updateStakingInfo({ walletAccount, address })
+      this.cursors[walletAccount] = cursorState.cursor
+    }
+
+    await this.updateTxLogByAsset({ walletAccount, logItemsByAsset, refresh })
+    if (refresh || hasNewTxs || cursorChanged) {
+      const tokenAccounts = await this.api.getTokenAccountsByOwner(address)
+      await this.emitUnknownTokensEvent({ tokenAccounts })
+      const account = await this.getAccount({ address, staking, tokenAccounts })
+      await this.updateState({ account, cursorState, walletAccount })
+    }
+  }
+
+  async getHistory({ address, accountState, refresh } = {}) {
+    let cursor = refresh ? '' : accountState.cursor
+    const baseAsset = this.asset
+
+    const { transactions, newCursor } = await this.api.getTransactions(address, {
+      cursor,
+      includeUnparsed: this.includeUnparsed,
+    })
+
+    const mappedTransactions = []
+    for (const tx of transactions) {
+      const assetName = _.get(tx, 'token.tokenName', baseAsset.name)
+      const asset = this.assets[assetName]
+      if (assetName === 'unknown' || !asset) continue // skip unknown tokens
+
+      const coinAmount = asset.currency.baseUnit(tx.amount).toDefault()
+
+      const item = {
+        coinName: assetName,
+        txId: tx.id,
+        from: [tx.from],
+        coinAmount,
+        confirmations: 1, // tx.confirmations, // avoid multiple notifications
+        date: tx.date,
+        error: tx.error,
+        data: {
+          staking: tx.staking || null,
+          unparsed: !!tx.unparsed,
+        },
+      }
+
+      if (tx.owner === address) {
+        // send transaction
+        item.to = tx.to
+        item.feeAmount = baseAsset.currency.baseUnit(tx.fee).toDefault() // in SOL
+        item.coinAmount = item.coinAmount.negate()
+
+        if (tx.to === tx.owner) {
+          item.selfSend = true
+          item.coinAmount = asset.currency.ZERO
+        }
+      } else if (tx.unparsed) {
+        if (tx.fee !== 0) item.feeAmount = baseAsset.currency.baseUnit(tx.fee).toDefault() // in SOL
+
+        item.data.meta = tx.data.meta
+      }
+      if (asset.assetType === 'SOLANA_TOKEN' && item.feeAmount && item.feeAmount.isPositive) {
+        const feeAsset = asset.feeAsset
+        const feeItem = {
+          ..._.clone(item),
+          coinName: feeAsset.name,
+          tokens: [asset.name],
+          coinAmount: feeAsset.currency.ZERO,
+        }
+        mappedTransactions.push(feeItem)
+      }
+      mappedTransactions.push(item)
+    }
+
+    // logItemsByAsset = { 'solana:': [...], 'serum': [...] }
+
+    return {
+      logItemsByAsset: _.groupBy(mappedTransactions, (item) => item.coinName),
+      hasNewTxs: transactions.length > 0,
+      cursorState: { cursor: newCursor },
+    }
+  }
+
+  async getAccount({ address, staking, tokenAccounts }) {
+    const tokens = Object.keys(this.assets).filter((name) => name !== this.asset.name)
+    const [solBalance, splBalances] = await Promise.all([
+      this.api.getBalance(address),
+      this.api.getTokensBalance({ address, filterByTokens: tokens, tokenAccounts }),
+    ])
+
+    const stakedBalance = this.asset.currency.baseUnit(staking.locked).toDefault()
+    const withdrawableBalance = this.asset.currency.baseUnit(staking.withdrawable).toDefault()
+    const pendingBalance = this.asset.currency.baseUnit(staking.pending).toDefault()
+    const balance = this.asset.currency
+      .baseUnit(solBalance)
+      .toDefault()
+      .add(stakedBalance)
+      .add(withdrawableBalance)
+      .add(pendingBalance)
+
+    const tokenBalances = _.mapValues(splBalances, (balance, name) =>
+      this.assets[name].currency.baseUnit(balance).toDefault()
+    )
+
+    return {
+      balance,
+      tokenBalances,
+    }
+  }
+
+  async updateState({ account, cursorState, walletAccount }) {
+    const { balance, tokenBalances } = account
+    const newData = { balance, tokenBalances, ...cursorState }
+    return this.updateAccountState({ newData, walletAccount })
+  }
+
+  async updateStakingInfo({ walletAccount, address }) {
+    const stakingInfo = await this.api.getStakeAccountsInfo(address)
+    const rewards = await this.api.getRewards(Object.keys(stakingInfo.accounts))
+    const mem = {
+      loaded: true,
+      staking: this.staking,
+      isDelegating: Object.values(stakingInfo.accounts).some(({ state }) =>
+        ['active', 'activating', 'inactive'].includes(state)
+      ), // true if at least 1 account is delegating
+      locked: this.asset.currency.baseUnit(stakingInfo.locked).toDefault(),
+      withdrawable: this.asset.currency.baseUnit(stakingInfo.withdrawable).toDefault(),
+      pending: this.asset.currency.baseUnit(stakingInfo.pending).toDefault(), // still undelegating (not yet available for withdraw)
+      earned: this.asset.currency.baseUnit(rewards).toDefault(),
+      accounts: stakingInfo.accounts, // Obj
+    }
+
+    await this.updateAccountState({ walletAccount, newData: { mem } })
+    return mem
+  }
+}