@exodus/solana-api 2.5.20 → 2.5.21

package/lib/api.js

@@ -1,1161 +0,0 @@
-'use strict'
-
-Object.defineProperty(exports, '__esModule', {
-  value: true,
-})
-exports.Api = void 0
-
-var _bn = _interopRequireDefault(require('bn.js'))
-
-var _assetJsonRpc = _interopRequireDefault(require('@exodus/asset-json-rpc'))
-
-var _simpleRetry = require('@exodus/simple-retry')
-
-var _fetch = require('@exodus/fetch')
-
-var _solanaLib = require('@exodus/solana-lib')
-
-var _assets = _interopRequireDefault(require('@exodus/assets'))
-
-var _assert = _interopRequireDefault(require('assert'))
-
-var _lodash = _interopRequireDefault(require('lodash'))
-
-var _urlJoin = _interopRequireDefault(require('url-join'))
-
-var _wretch = _interopRequireWildcard(require('wretch'))
-
-var _nftsCore = require('@exodus/nfts-core')
-
-var _connection = require('./connection')
-
-function _getRequireWildcardCache() {
-  if (typeof WeakMap !== 'function') return null
-  var cache = new WeakMap()
-  _getRequireWildcardCache = function() {
-    return cache
-  }
-  return cache
-}
-
-function _interopRequireWildcard(obj) {
-  if (obj && obj.__esModule) {
-    return obj
-  }
-  if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) {
-    return { default: obj }
-  }
-  var cache = _getRequireWildcardCache()
-  if (cache && cache.has(obj)) {
-    return cache.get(obj)
-  }
-  var newObj = {}
-  var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor
-  for (var key in obj) {
-    if (Object.prototype.hasOwnProperty.call(obj, key)) {
-      var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null
-      if (desc && (desc.get || desc.set)) {
-        Object.defineProperty(newObj, key, desc)
-      } else {
-        newObj[key] = obj[key]
-      }
-    }
-  }
-  newObj.default = obj
-  if (cache) {
-    cache.set(obj, newObj)
-  }
-  return newObj
-}
-
-function _interopRequireDefault(obj) {
-  return obj && obj.__esModule ? obj : { default: obj }
-}
-
-const RPC_URL = 'https://solana.a.exodus.io' // https://vip-api.mainnet-beta.solana.com/, https://api.mainnet-beta.solana.com, https://solana-api.projectserum.com
-
-const WS_ENDPOINT = 'wss://solana.a.exodus.io/ws' // Tokens + SOL api support
-
-class Api {
-  constructor(rpcUrl, wsUrl) {
-    this.broadcastTransaction = async (signedTx, options) => {
-      console.log('Solana broadcasting TX:', signedTx) // base64
-
-      const defaultOptions = {
-        encoding: 'base64',
-        preflightCommitment: 'finalized',
-      }
-      const params = [signedTx, { ...defaultOptions, ...options }]
-      const errorMessagesToRetry = ['Blockhash not found']
-      const broadcastTxWithRetry = (0, _simpleRetry.retry)(
-        async () => {
-          try {
-            const result = await this.rpcCall('sendTransaction', params, {
-              forceHttp: true,
-            })
-            console.log(`tx ${JSON.stringify(result)} sent!`)
-            return result || null
-          } catch (error) {
-            if (
-              error.message &&
-              !errorMessagesToRetry.find((errorMessage) => error.message.includes(errorMessage))
-            ) {
-              error.finalError = true
-            }
-
-            console.warn(`Error broadcasting tx. Retrying...`, error)
-            throw error
-          }
-        },
-        {
-          delayTimesMs: ['6s', '6s', '8s', '10s'],
-        }
-      )
-      return broadcastTxWithRetry()
-    }
-
-    this.simulateTransaction = async (encodedTransaction, options) => {
-      const {
-        value: { accounts },
-      } = await this.rpcCall('simulateTransaction', [encodedTransaction, options])
-      return accounts
-    }
-
-    this.resolveSimulationSideEffects = async (solAccounts, tokenAccounts) => {
-      const willReceive = []
-      const willSend = []
-      const resolveSols = solAccounts.map(async (account) => {
-        const currentAmount = await this.getBalance(account.address)
-        const balance = (0, _solanaLib.computeBalance)(account.amount, currentAmount)
-        return {
-          name: 'SOL',
-          symbol: 'SOL',
-          balance,
-          decimal: _solanaLib.SOL_DECIMAL,
-          type: 'SOL',
-        }
-      })
-
-      const _wrapAndHandleAccountNotFound = (fn, defaultValue) => {
-        return async (...params) => {
-          try {
-            return await fn.apply(this, params)
-          } catch (error) {
-            if (error.message && error.message.includes('could not find account')) {
-              return defaultValue
-            }
-
-            throw error
-          }
-        }
-      }
-
-      const _getTokenBalance = _wrapAndHandleAccountNotFound(this.getTokenBalance, '0')
-
-      const _getDecimals = _wrapAndHandleAccountNotFound(this.getDecimals, 0)
-
-      const _getSupply = _wrapAndHandleAccountNotFound(this.getSupply, '0')
-
-      const resolveTokens = tokenAccounts.map(async (account) => {
-        try {
-          const [_tokenMetaPlex, currentAmount, decimal] = await Promise.all([
-            this.getMetaplexMetadata(account.mint),
-            _getTokenBalance(account.address),
-            _getDecimals(account.mint),
-          ])
-          const tokenMetaPlex = _tokenMetaPlex || {
-            name: null,
-            symbol: null,
-          }
-          let nft = {
-            collectionId: null,
-            collectionName: null,
-            collectionTitle: null,
-            title: null,
-          } // Only perform an NFT check (getSupply) if decimal is zero
-
-          if (decimal === 0 && (await _getSupply(account.mint)) === '1') {
-            try {
-              const {
-                id: collectionId,
-                collectionName,
-                collectionTitle,
-                title,
-              } = await _nftsCore.magicEden.api.getNFTByMintAddress(account.mint)
-              nft = {
-                collectionId,
-                collectionTitle,
-                collectionName,
-                title,
-              }
-              tokenMetaPlex.name = tokenMetaPlex.name || collectionTitle
-              tokenMetaPlex.symbol = tokenMetaPlex.symbol || collectionName
-            } catch (error) {
-              console.warn(error)
-            }
-          }
-
-          const balance = (0, _solanaLib.computeBalance)(account.amount, currentAmount)
-          return {
-            balance,
-            decimal,
-            nft,
-            address: account.address,
-            mint: account.mint,
-            name: tokenMetaPlex.name,
-            symbol: tokenMetaPlex.symbol,
-            type: 'TOKEN',
-          }
-        } catch (error) {
-          console.warn(error)
-          return {
-            balance: null,
-          }
-        }
-      })
-      const accounts = await Promise.all([...resolveSols, ...resolveTokens])
-      accounts.forEach((account) => {
-        if (account.balance === null) {
-          return
-        }
-
-        if (account.balance > 0) {
-          willReceive.push(account)
-        } else {
-          willSend.push(account)
-        }
-      })
-      return {
-        willReceive,
-        willSend,
-      }
-    }
-
-    this.simulateAndRetrieveSideEffects = async (message, publicKey, transactionMessage) => {
-      const { config, accountAddresses } = (0, _solanaLib.getTransactionSimulationParams)(
-        transactionMessage || message
-      )
-      const signatures = new Array(message.header.numRequiredSignatures || 1).fill(null)
-      const encodedTransaction = (0, _solanaLib.buildRawTransaction)(
-        Buffer.from(message.serialize()),
-        signatures
-      ).toString('base64')
-      const futureAccountsState = await this.simulateTransaction(encodedTransaction, config)
-      const { solAccounts, tokenAccounts } = (0, _solanaLib.filterAccountsByOwner)(
-        futureAccountsState,
-        accountAddresses,
-        publicKey
-      )
-      return this.resolveSimulationSideEffects(solAccounts, tokenAccounts)
-    }
-
-    this.simulateTransactionV1 = async (network, transactions, publicKey, origin) => {
-      ;(0, _assert.default)(
-        ['mainnet', 'devnet', 'testnet'].includes(network),
-        'invalid network provided'
-      )
-      ;(0, _assert.default)(Array.isArray(transactions), 'transactions was not an array')
-      ;(0, _assert.default)(typeof origin === 'string', 'origin must be a string')
-      const body = JSON.stringify({
-        transactions,
-        userAccount: publicKey,
-        metadata: {
-          origin,
-        },
-      })
-      const response = await (0, _fetch.fetch)(
-        `https://api.blowfish.xyz/solana/v0/${network}/scan/transactions`,
-        {
-          method: 'POST',
-          headers: {
-            'Content-Type': 'application/json',
-            'X-Api-Key': 'afd98abb-c464-413a-8947-6c29e6b6e393',
-          },
-          body,
-        }
-      )
-
-      if (!response.ok) {
-        throw new Error(await response.text())
-      }
-
-      return response.json()
-    }
-
-    this.setServer(rpcUrl)
-    this.setWsEndpoint(wsUrl)
-    this.setTokens(_assets.default)
-    this.tokensToSkip = {}
-    this.connections = {}
-  }
-
-  setServer(rpcUrl) {
-    this.rpcUrl = rpcUrl || RPC_URL
-    this.api = (0, _assetJsonRpc.default)(this.rpcUrl)
-  }
-
-  setWsEndpoint(wsUrl) {
-    this.wsUrl = wsUrl || WS_ENDPOINT
-  }
-
-  setTokens(assets = {}) {
-    const solTokens = _lodash.default.pickBy(assets, (asset) => asset.assetType === 'SOLANA_TOKEN')
-
-    this.tokens = _lodash.default.mapKeys(solTokens, (v) => v.mintAddress)
-  }
-
-  request(path, contentType = 'application/json') {
-    return (0, _wretch.default)((0, _urlJoin.default)(this.rpcUrl, path)).headers({
-      'Content-type': contentType,
-    })
-  }
-
-  async watchAddress({
-    address,
-    tokensAddresses = [],
-    handleAccounts,
-    handleTransfers,
-    handleReconnect,
-    reconnectDelay,
-  }) {
-    const conn = new _connection.Connection({
-      endpoint: this.wsUrl,
-      address,
-      tokensAddresses,
-      callback: (updates) =>
-        this.handleUpdates({
-          updates,
-          address,
-          handleAccounts,
-          handleTransfers,
-        }),
-      reconnectCallback: handleReconnect,
-      reconnectDelay,
-    })
-    this.connections[address] = conn
-    return conn.start()
-  }
-
-  async unwatchAddress({ address }) {
-    if (this.connections[address]) {
-      await this.connections[address].stop()
-      delete this.connections[address]
-    }
-  }
-
-  async handleUpdates({ updates, address, handleAccounts, handleTransfers }) {
-    // console.log(`got ws updates from ${address}:`, updates)
-    if (handleTransfers) return handleTransfers(updates)
-  }
-
-  async rpcCall(method, params = [], { address = '', forceHttp = false } = {}) {
-    // ws request
-    const connection =
-      this.connections[address] || _lodash.default.sample(Object.values(this.connections)) // pick random connection
-
-    if (
-      _lodash.default.get(connection, 'isOpen') &&
-      !_lodash.default.get(connection, 'shutdown') &&
-      !forceHttp
-    ) {
-      return connection.sendMessage(method, params)
-    } // http fallback
-
-    return this.api.post({
-      method,
-      params,
-    })
-  }
-
-  getTokenByAddress(mint) {
-    return this.tokens[mint]
-  }
-
-  isTokenSupported(mint) {
-    return !!this.getTokenByAddress(mint)
-  }
-
-  async getEpochInfo() {
-    const { epoch } = await this.rpcCall('getEpochInfo')
-    return Number(epoch)
-  }
-
-  async getStakeActivation(address) {
-    const { state } = await this.rpcCall('getStakeActivation', [address])
-    return state
-  }
-
-  async getRecentBlockHash(commitment) {
-    const result = await this.rpcCall(
-      'getRecentBlockhash',
-      [
-        {
-          commitment: commitment || 'finalized',
-          encoding: 'jsonParsed',
-        },
-      ],
-      {
-        forceHttp: true,
-      }
-    )
-    return _lodash.default.get(result, 'value.blockhash')
-  } // Transaction structure: https://docs.solana.com/apps/jsonrpc-api#transaction-structure
-
-  async getTransactionById(id) {
-    return this.rpcCall('getTransaction', [
-      id,
-      {
-        encoding: 'jsonParsed',
-        maxSupportedTransactionVersion: 0,
-      },
-    ])
-  }
-
-  async getFee() {
-    const result = await this.rpcCall('getRecentBlockhash', [
-      {
-        commitment: 'finalized',
-        encoding: 'jsonParsed',
-      },
-    ])
-    return _lodash.default.get(result, 'value.feeCalculator.lamportsPerSignature')
-  }
-
-  async getBalance(address) {
-    const result = await this.rpcCall(
-      'getBalance',
-      [
-        address,
-        {
-          encoding: 'jsonParsed',
-        },
-      ],
-      {
-        address,
-      }
-    )
-    return _lodash.default.get(result, 'value', 0)
-  }
-
-  async getBlockTime(slot) {
-    // might result in error if executed on a validator with partial ledger (https://github.com/solana-labs/solana/issues/12413)
-    return this.rpcCall('getBlockTime', [slot])
-  }
-
-  async getConfirmedSignaturesForAddress(address, { until, before, limit } = {}) {
-    until = until || undefined
-    return this.rpcCall(
-      'getSignaturesForAddress',
-      [
-        address,
-        {
-          until,
-          before,
-          limit,
-        },
-      ],
-      {
-        address,
-      }
-    )
-  }
-  /**
-   * Get transactions from an address
-   */
-
-  async getTransactions(address, { cursor, before, limit, includeUnparsed = false } = {}) {
-    let transactions = [] // cursor is a txHash
-
-    try {
-      let until = cursor
-      const tokenAccountsByOwner = await this.getTokenAccountsByOwner(address) // Array
-
-      const tokenAccountAddresses = tokenAccountsByOwner
-        .filter(({ tokenName }) => tokenName !== 'unknown')
-        .map(({ tokenAccountAddress }) => tokenAccountAddress)
-      const accountsToCheck = [address, ...tokenAccountAddresses]
-      const txsResultsByAccount = await Promise.all(
-        accountsToCheck.map((addr) =>
-          this.getConfirmedSignaturesForAddress(addr, {
-            until,
-            before,
-            limit,
-          })
-        )
-      )
-      let txsId = txsResultsByAccount.reduce((arr, row) => arr.concat(row), []) // merge arrays
-
-      txsId = _lodash.default.uniqBy(txsId, 'signature') // get txs details in parallel
-
-      const txsDetails = await Promise.all(txsId.map((tx) => this.getTransactionById(tx.signature)))
-      txsDetails.forEach((txDetail) => {
-        if (txDetail === null) return
-        const timestamp = txDetail.blockTime * 1000
-        const parsedTx = this.parseTransaction(address, txDetail, tokenAccountsByOwner, {
-          includeUnparsed,
-        })
-        if (!parsedTx.from && !includeUnparsed) return // cannot parse it
-        // split dexTx in separate txs
-
-        if (parsedTx.dexTxs) {
-          parsedTx.dexTxs.forEach((tx) => {
-            transactions.push({
-              timestamp,
-              date: new Date(timestamp),
-              ...tx,
-            })
-          })
-          delete parsedTx.dexTxs
-        }
-
-        transactions.push({
-          timestamp,
-          date: new Date(timestamp),
-          ...parsedTx,
-        })
-      })
-    } catch (err) {
-      console.warn('Solana error:', err)
-      throw err
-    }
-
-    transactions = _lodash.default.orderBy(transactions, ['timestamp'], ['desc'])
-    const newCursor = transactions[0] ? transactions[0].id : cursor
-    return {
-      transactions,
-      newCursor,
-    }
-  }
-
-  parseTransaction(
-    ownerAddress,
-    txDetails,
-    tokenAccountsByOwner,
-    { includeUnparsed = false } = {}
-  ) {
-    let {
-      fee,
-      preBalances,
-      postBalances,
-      preTokenBalances,
-      postTokenBalances,
-      innerInstructions,
-    } = txDetails.meta
-    preBalances = preBalances || []
-    postBalances = postBalances || []
-    preTokenBalances = preTokenBalances || []
-    postTokenBalances = postTokenBalances || []
-    innerInstructions = innerInstructions || []
-    let { instructions, accountKeys } = txDetails.transaction.message
-
-    const getUnparsedTx = () => {
-      const ownerIndex = accountKeys.findIndex((accountKey) => accountKey.pubkey === ownerAddress)
-      const feePaid = ownerIndex === 0 ? fee : 0
-      return {
-        unparsed: true,
-        amount:
-          ownerIndex === -1 ? 0 : postBalances[ownerIndex] - preBalances[ownerIndex] + feePaid,
-        fee: feePaid,
-        data: {
-          meta: txDetails.meta,
-        },
-      }
-    }
-
-    const getInnerTxsFromBalanceChanges = () => {
-      const ownPreTokenBalances = preTokenBalances.filter(
-        (balance) => balance.owner === ownerAddress
-      )
-      const ownPostTokenBalances = postTokenBalances.filter(
-        (balance) => balance.owner === ownerAddress
-      )
-      return ownPostTokenBalances
-        .map((postBalance) => {
-          const tokenAccount = tokenAccountsByOwner.find(
-            (tokenAccount) => tokenAccount.mintAddress === postBalance.mint
-          )
-          const preBalance = ownPreTokenBalances.find(
-            (balance) => balance.accountIndex === postBalance.accountIndex
-          )
-          const preAmount = new _bn.default(
-            _lodash.default.get(preBalance, 'uiTokenAmount.amount', '0'),
-            10
-          )
-          const postAmount = new _bn.default(
-            _lodash.default.get(postBalance, 'uiTokenAmount.amount', '0'),
-            10
-          )
-          const amount = postAmount.sub(preAmount)
-          if (!tokenAccount || amount.isZero()) return null // This is not perfect as there could be multiple same-token transfers in single
-          // transaction, but our wallet only supports one transaction with single txId
-          // so we are picking first that matches (correct token + type - send or receive)
-
-          const match = innerInstructions.find((inner) => {
-            const targetOwner = amount.isNeg() ? ownerAddress : null
-            return (
-              inner.token.mintAddress === tokenAccount.mintAddress && targetOwner === inner.owner
-            )
-          }) // It's possible we won't find a match, because our innerInstructions only contain
-          // spl-token transfers, but balances of SPL tokens can change in different ways too.
-          // for now, we are ignoring this to simplify as those cases are not that common, but
-          // they should be handled eventually. It was already a scretch to add unparsed txs logic
-          // to existing parser, expanding it further is not going to end well.
-          // this probably should be refactored from ground to handle all those transactions
-          // as a core part of it in the future
-
-          if (!match) return null
-          const { from, to, owner } = match
-          return {
-            id: txDetails.transaction.signatures[0],
-            slot: txDetails.slot,
-            owner,
-            from,
-            to,
-            amount: amount.abs().toString(),
-            // inconsistent with the rest, but it can and did overflow
-            fee: 0,
-            token: tokenAccount,
-            data: {
-              inner: true,
-            },
-          }
-        })
-        .filter((ix) => !!ix)
-    }
-
-    instructions = instructions
-      .filter((ix) => ix.parsed) // only known instructions
-      .map((ix) => ({
-        program: ix.program,
-        // system or spl-token
-        type: ix.parsed.type,
-        // transfer, createAccount, initializeAccount
-        ...ix.parsed.info,
-      }))
-    innerInstructions = innerInstructions
-      .reduce((acc, val) => {
-        return acc.concat(val.instructions)
-      }, [])
-      .map((ix) => {
-        const type = _lodash.default.get(ix, 'parsed.type')
-
-        const isTransferTx = ix.parsed && ix.program === 'spl-token' && type === 'transfer'
-
-        const source = _lodash.default.get(ix, 'parsed.info.source')
-
-        const destination = _lodash.default.get(ix, 'parsed.info.destination')
-
-        const amount = Number(_lodash.default.get(ix, 'parsed.info.amount', 0))
-        const tokenAccount = tokenAccountsByOwner.find(({ tokenAccountAddress }) => {
-          return [source, destination].includes(tokenAccountAddress)
-        })
-        const isSending = !!tokenAccountsByOwner.find(({ tokenAccountAddress }) => {
-          return [source].includes(tokenAccountAddress)
-        }) // owner if it's a send tx
-
-        const instruction = {
-          id: txDetails.transaction.signatures[0],
-          slot: txDetails.slot,
-          owner: isSending ? ownerAddress : null,
-          from: source,
-          to: destination,
-          amount,
-          token: tokenAccount,
-          fee: isSending ? fee : 0,
-        }
-        return isTransferTx && tokenAccount ? instruction : null
-      })
-      .filter((ix) => !!ix) // program:type tells us if it's a SOL or Token transfer
-
-    const solanaTx = _lodash.default.find(instructions, (ix) => {
-      if (![ix.source, ix.destination].includes(ownerAddress)) return false
-      return ix.program === 'system' && ix.type === 'transfer'
-    }) // get SOL transfer
-
-    const stakeTx = _lodash.default.find(instructions, {
-      program: 'system',
-      type: 'createAccountWithSeed',
-    })
-
-    const stakeWithdraw = _lodash.default.find(instructions, {
-      program: 'stake',
-      type: 'withdraw',
-    })
-
-    const stakeUndelegate = _lodash.default.find(instructions, {
-      program: 'stake',
-      type: 'deactivate',
-    })
-
-    const hasSolanaTx = solanaTx && !preTokenBalances.length && !postTokenBalances.length // only SOL moved and no tokens movements
-
-    let tx = {}
-
-    if (hasSolanaTx) {
-      // Solana tx
-      const isSending = ownerAddress === solanaTx.source
-      tx = {
-        owner: solanaTx.source,
-        from: solanaTx.source,
-        to: solanaTx.destination,
-        amount: solanaTx.lamports,
-        // number
-        fee: isSending ? fee : 0,
-      }
-    } else if (stakeTx) {
-      // start staking
-      tx = {
-        owner: stakeTx.base,
-        from: stakeTx.base,
-        to: stakeTx.base,
-        amount: stakeTx.lamports,
-        fee,
-        staking: {
-          method: 'createAccountWithSeed',
-          seed: stakeTx.seed,
-          stakeAddresses: [stakeTx.newAccount],
-          stake: stakeTx.lamports,
-        },
-      }
-    } else if (stakeWithdraw) {
-      const stakeAccounts = _lodash.default.map(
-        _lodash.default.filter(instructions, {
-          program: 'stake',
-          type: 'withdraw',
-        }),
-        'stakeAccount'
-      )
-
-      tx = {
-        owner: stakeWithdraw.withdrawAuthority,
-        from: stakeWithdraw.stakeAccount,
-        to: stakeWithdraw.destination,
-        amount: stakeWithdraw.lamports,
-        fee,
-        staking: {
-          method: 'withdraw',
-          stakeAddresses: stakeAccounts,
-          stake: stakeWithdraw.lamports,
-        },
-      }
-    } else if (stakeUndelegate) {
-      const stakeAccounts = _lodash.default.map(
-        _lodash.default.filter(instructions, {
-          program: 'stake',
-          type: 'deactivate',
-        }),
-        'stakeAccount'
-      )
-
-      tx = {
-        owner: stakeUndelegate.stakeAuthority,
-        from: stakeUndelegate.stakeAuthority,
-        to: stakeUndelegate.stakeAccount,
-        // obsolete
-        amount: 0,
-        fee,
-        staking: {
-          method: 'undelegate',
-          stakeAddresses: stakeAccounts,
-        },
-      }
-    } else {
-      // Token tx
-      _assert.default.ok(
-        Array.isArray(tokenAccountsByOwner),
-        'tokenAccountsByOwner is required when parsing token tx'
-      )
-
-      let tokenTxs = _lodash.default
-        .filter(instructions, ({ program, type }) => {
-          return program === 'spl-token' && ['transfer', 'transferChecked'].includes(type)
-        }) // get Token transfer: could have more than 1 instructions
-        .map((ix) => {
-          // add token details based on source/destination address
-          let tokenAccount = _lodash.default.find(tokenAccountsByOwner, {
-            tokenAccountAddress: ix.source,
-          })
-
-          const isSending = !!tokenAccount
-          if (!isSending)
-            tokenAccount = _lodash.default.find(tokenAccountsByOwner, {
-              tokenAccountAddress: ix.destination,
-            }) // receiving
-
-          if (!tokenAccount) return null // no transfers with our addresses involved
-
-          const owner = isSending ? ownerAddress : null
-          delete tokenAccount.balance
-          delete tokenAccount.owner
-          return {
-            owner,
-            token: tokenAccount,
-            from: ix.source,
-            to: ix.destination,
-            amount: Number(ix.amount || _lodash.default.get(ix, 'tokenAmount.amount', 0)),
-            // supporting both types: transfer and transferChecked
-            fee: isSending ? fee : 0, // in lamports
-          }
-        })
-
-      if (tokenTxs.length) {
-        // found spl-token simple transfer/transferChecked instruction
-        // .reduce to sum/sub (based on isSending) all the same tokens amount (From instructions -> 1 single tx)
-        tx = tokenTxs.reduce((finalTx, ix) => {
-          if (!ix) return finalTx // skip null instructions
-
-          if (!finalTx.token) return ix // init finalTx (support just 1 token type per tx)
-
-          if (finalTx.token.ticker === ix.token.ticker) finalTx.amount += ix.amount
-          return finalTx
-        }, {})
-      } else if (preTokenBalances && postTokenBalances) {
-        // probably a DEX program is involved (multiple instructions), compute balance changes
-        const accountIndexes = _lodash.default.mapKeys(accountKeys, (x, i) => i)
-
-        Object.values(accountIndexes).forEach((acc) => {
-          // filter by ownerAddress
-          const hasKnownOwner = !!_lodash.default.find(tokenAccountsByOwner, {
-            tokenAccountAddress: acc.pubkey,
-          })
-          acc.owner = hasKnownOwner ? ownerAddress : null
-        }) // group by owner and supported token
-
-        const preBalances = preTokenBalances.filter((t) => {
-          return (
-            accountIndexes[t.accountIndex].owner === ownerAddress && this.isTokenSupported(t.mint)
-          )
-        })
-        const postBalances = postTokenBalances.filter((t) => {
-          return (
-            accountIndexes[t.accountIndex].owner === ownerAddress && this.isTokenSupported(t.mint)
-          )
-        })
-
-        if (preBalances.length || postBalances.length) {
-          tx = {}
-
-          if (includeUnparsed && innerInstructions.length) {
-            // when using includeUnparsed for DEX tx we want to keep SOL tx as "unparsed"
-            // 1. we want to treat all SOL dex transactions as "Contract transaction", not "Sent SOL"
-            // 2. default behavior is not perfect. For example it doesn't see SOL-side tx in
-            //    SOL->SPL swaps on Raydium and Orca.
-            tx = getUnparsedTx(tx)
-            tx.dexTxs = getInnerTxsFromBalanceChanges()
-          } else {
-            if (solanaTx) {
-              // the base tx will be the one that moved solana.
-              tx = {
-                owner: solanaTx.source,
-                from: solanaTx.source,
-                to: solanaTx.destination,
-                amount: solanaTx.lamports,
-                // number
-                fee: ownerAddress === solanaTx.source ? fee : 0,
-              }
-            } // If it has inner instructions then it's a DEX tx that moved SPL -> SPL
-
-            if (innerInstructions.length) {
-              tx.dexTxs = innerInstructions // if tx involves only SPL swaps. Expand DEX ix (first element as tx base and the other kept there)
-
-              if (!tx.from && !solanaTx) {
-                tx = tx.dexTxs[0]
-                tx.dexTxs = innerInstructions.slice(1)
-              }
-            }
-          }
-        }
-      }
-    }
-
-    const unparsed = Object.keys(tx).length === 0
-
-    if (unparsed && includeUnparsed) {
-      tx = getUnparsedTx(tx)
-    } // How tokens tx are parsed:
-    // 0. compute incoming or outgoing tx: it's outgoing if spl-token:transfer has source/destination included in tokenAccountsByOwner
-    // 1. if it's a sent tx: sum all instructions amount (spl-token:transfer)
-    // 2. if it's an incoming tx: sum all the amounts with destination included in tokenAccountsByOwner (aggregating by ticker)
-    // QUESTION: How do I know what are my tokens addresses deterministically? It's not possible, gotta use tokenAccountsByOwner
-
-    return {
-      id: txDetails.transaction.signatures[0],
-      slot: txDetails.slot,
-      error: !(txDetails.meta.err === null),
-      ...tx,
-    }
-  }
-
-  async getSupply(mintAddress) {
-    const result = await this.rpcCall('getTokenSupply', [mintAddress])
-    return _lodash.default.get(result, 'value.amount')
-  }
-
-  async getWalletTokensList({ tokenAccounts }) {
-    const tokensMint = []
-
-    for (let account of tokenAccounts) {
-      const mint = account.mintAddress // skip cached NFT
-
-      if (this.tokensToSkip[mint]) continue // skip 0 balance
-
-      if (account.balance === '0') continue // skip NFT
-
-      const supply = await this.getSupply(mint)
-
-      if (supply === '1') {
-        this.tokensToSkip[mint] = true
-        continue
-      } // OK
-
-      tokensMint.push(mint)
-    }
-
-    return tokensMint
-  }
-
-  async getTokenAccountsByOwner(address, tokenTicker) {
-    const { value: accountsList } = await this.rpcCall(
-      'getTokenAccountsByOwner',
-      [
-        address,
-        {
-          programId: _solanaLib.TOKEN_PROGRAM_ID.toBase58(),
-        },
-        {
-          encoding: 'jsonParsed',
-        },
-      ],
-      {
-        address,
-      }
-    )
-    const tokenAccounts = []
-
-    for (let entry of accountsList) {
-      const { pubkey, account } = entry
-
-      const mint = _lodash.default.get(account, 'data.parsed.info.mint')
-
-      const token = this.tokens[mint] || {
-        name: 'unknown',
-        ticker: 'UNKNOWN',
-      }
-
-      const balance = _lodash.default.get(account, 'data.parsed.info.tokenAmount.amount', '0')
-
-      tokenAccounts.push({
-        tokenAccountAddress: pubkey,
-        owner: address,
-        tokenName: token.name,
-        ticker: token.ticker,
-        balance,
-        mintAddress: mint,
-      })
-    } // eventually filter by token
-
-    return tokenTicker
-      ? tokenAccounts.filter(({ ticker }) => ticker === tokenTicker)
-      : tokenAccounts
-  }
-
-  async getTokensBalance({ address, filterByTokens = [], tokenAccounts }) {
-    let accounts = tokenAccounts || (await this.getTokenAccountsByOwner(address))
-    const tokensBalance = accounts.reduce((acc, { tokenName, balance }) => {
-      if (tokenName === 'unknown' || (filterByTokens.length && !filterByTokens.includes(tokenName)))
-        return acc // filter by supported tokens only
-
-      if (!acc[tokenName]) acc[tokenName] = Number(balance)
-      // e.g { 'serum': 123 }
-      else acc[tokenName] += Number(balance) // merge same token account balance
-
-      return acc
-    }, {})
-    return tokensBalance
-  }
-
-  async isAssociatedTokenAccountActive(tokenAddress) {
-    // Returns the token balance of an SPL Token account.
-    try {
-      await this.rpcCall('getTokenAccountBalance', [tokenAddress])
-      return true
-    } catch (e) {
-      return false
-    }
-  } // Returns account balance of a SPL Token account.
-
-  async getTokenBalance(tokenAddress) {
-    const result = await this.rpcCall('getTokenAccountBalance', [tokenAddress])
-    return _lodash.default.get(result, 'value.amount')
-  }
-
-  async getAccountInfo(address, encoding = 'jsonParsed') {
-    const { value } = await this.rpcCall(
-      'getAccountInfo',
-      [
-        address,
-        {
-          encoding,
-          commitment: 'single',
-        },
-      ],
-      {
-        address,
-      }
-    )
-    return value
-  }
-
-  async isSpl(address) {
-    const { owner } = await this.getAccountInfo(address)
-    return owner === 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA'
-  }
-
-  async getMetaplexMetadata(tokenMintAddress) {
-    const metaplexPDA = (0, _solanaLib.getMetadataAccount)(tokenMintAddress)
-    const res = await this.getAccountInfo(metaplexPDA, 'base64')
-
-    const data = _lodash.default.get(res, 'data[0]')
-
-    if (!data) return null
-    return (0, _solanaLib.deserializeMetaplexMetadata)(Buffer.from(data, 'base64'))
-  }
-
-  async getDecimals(tokenMintAddress) {
-    const result = await this.rpcCall('getTokenSupply', [tokenMintAddress])
-    return _lodash.default.get(result, 'value.decimals', null)
-  }
-
-  async getAddressType(address) {
-    // solana, token or null (unknown), meaning address has never been initialized
-    const value = await this.getAccountInfo(address)
-    if (value === null) return null
-    const account = {
-      executable: value.executable,
-      owner: value.owner,
-      lamports: value.lamports,
-    }
-    return account.owner === _solanaLib.SYSTEM_PROGRAM_ID.toBase58()
-      ? 'solana'
-      : account.owner === _solanaLib.TOKEN_PROGRAM_ID.toBase58()
-      ? 'token'
-      : null
-  }
-
-  async getTokenAddressOwner(address) {
-    const value = await this.getAccountInfo(address)
-
-    const owner = _lodash.default.get(value, 'data.parsed.info.owner', null)
-
-    return owner
-  }
-
-  async getAddressMint(address) {
-    const value = await this.getAccountInfo(address)
-
-    const mintAddress = _lodash.default.get(value, 'data.parsed.info.mint', null) // token mint
-
-    return mintAddress
-  }
-
-  async isTokenAddress(address) {
-    const type = await this.getAddressType(address)
-    return type === 'token'
-  }
-
-  async isSOLaddress(address) {
-    const type = await this.getAddressType(address)
-    return type === 'solana'
-  }
-
-  async getStakeAccountsInfo(address) {
-    const params = [
-      _solanaLib.STAKE_PROGRAM_ID.toBase58(),
-      {
-        filters: [
-          {
-            memcmp: {
-              offset: 12,
-              bytes: address,
-            },
-          },
-        ],
-        encoding: 'jsonParsed',
-      },
-    ]
-    const res = await this.rpcCall('getProgramAccounts', params, {
-      address,
-    })
-    const accounts = {}
-    let totalStake = 0
-    let locked = 0
-    let withdrawable = 0
-    let pending = 0
-
-    for (let entry of res) {
-      const addr = entry.pubkey
-
-      const lamports = _lodash.default.get(entry, 'account.lamports', 0)
-
-      const delegation = _lodash.default.get(entry, 'account.data.parsed.info.stake.delegation', {}) // could have no delegation if the created stake address did not perform a delegate transaction
-
-      accounts[addr] = delegation
-      accounts[addr].lamports = lamports // sol balance
-
-      accounts[addr].activationEpoch = Number(accounts[addr].activationEpoch) || 0
-      accounts[addr].deactivationEpoch = Number(accounts[addr].deactivationEpoch) || 0
-      let state = 'inactive'
-      if (delegation.activationEpoch) state = await this.getStakeActivation(addr)
-      accounts[addr].state = state
-      accounts[addr].isDeactivating = state === 'deactivating'
-      accounts[addr].canWithdraw = state === 'inactive'
-      accounts[addr].stake = Number(accounts[addr].stake) || 0 // active staked amount
-
-      totalStake += accounts[addr].stake
-      locked += ['active', 'activating'].includes(accounts[addr].state) ? lamports : 0
-      withdrawable += accounts[addr].canWithdraw ? lamports : 0
-      pending += accounts[addr].isDeactivating ? lamports : 0
-    }
-
-    return {
-      accounts,
-      totalStake,
-      locked,
-      withdrawable,
-      pending,
-    }
-  }
-
-  async getRewards(stakingAddresses = []) {
-    if (!stakingAddresses.length) return 0 // custom endpoint!
-
-    const rewards = await this.request(`rewards?addresses=${stakingAddresses.join(',')}`)
-      .get()
-      .error(500, () => ({})) // addresses not found
-      .error(400, () => ({}))
-      .json() // sum rewards for all addresses
-
-    const earnings = Object.values(rewards).reduce((total, x) => {
-      return total + x
-    }, 0)
-    return earnings
-  }
-
-  async getMinimumBalanceForRentExemption(size) {
-    return this.rpcCall('getMinimumBalanceForRentExemption', [size])
-  }
-
-  async getProgramAccounts(programId, config) {
-    return this.rpcCall('getProgramAccounts', [programId, config])
-  }
-
-  async getMultipleAccounts(pubkeys, config) {
-    const response = await this.rpcCall('getMultipleAccounts', [pubkeys, config])
-    return response && response.value ? response.value : []
-  }
-  /**
-   * Broadcast a signed transaction
-   */
-}
-
-exports.Api = Api