@exodus/solana-api 2.0.4 → 2.0.5

package/src/index.js

@@ -1,863 +1,3 @@
-// @flow
-import createApi from '@exodus/asset-json-rpc'
-import {
-  getMetadataAccount,
-  deserializeMetaplexMetadata,
-  getTransactionSimulationParams,
-  filterAccountsByOwner,
-  SYSTEM_PROGRAM_ID,
-  STAKE_PROGRAM_ID,
-  TOKEN_PROGRAM_ID,
-  SOL_DECIMAL,
-  computeBalance,
-  SolanaWeb3Message,
-  buildRawTransaction,
-} from '@exodus/solana-lib'
-import assets from '@exodus/assets'
-import assert from 'assert'
-import lodash from 'lodash'
-import urljoin from 'url-join'
-import wretch, { Wretcher } from 'wretch'
-import { magicEden } from '@exodus/nfts-core'
-
-// Doc: https://docs.solana.com/apps/jsonrpc-api
-
-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
-
-// Tokens + SOL api support
-export class Api {
-  constructor(rpcUrl) {
-    this.setServer(rpcUrl)
-    this.setTokens(assets)
-    this.tokensToSkip = {}
-  }
-
-  setServer(rpcUrl) {
-    this.rpcUrl = rpcUrl || RPC_URL
-    this.api = createApi(this.rpcUrl)
-  }
-
-  setTokens(assets = {}) {
-    const solTokens = lodash.pickBy(assets, (asset) => asset.assetType === 'SOLANA_TOKEN')
-    this.tokens = lodash.mapKeys(solTokens, (v) => v.mintAddress)
-  }
-
-  request(path, contentType = 'application/json'): Wretcher {
-    return wretch(urljoin(this.rpcUrl, path)).headers({
-      'Content-type': contentType,
-    })
-  }
-
-  isTokenSupported(mint: string) {
-    return !!this.tokens[mint]
-  }
-
-  async getEpochInfo(): number {
-    const { epoch } = await this.api.post({
-      method: 'getEpochInfo',
-    })
-    return Number(epoch)
-  }
-
-  async getStakeActivation(address): string {
-    const { state } = await this.api.post({
-      method: 'getStakeActivation',
-      params: [address],
-    })
-    return state
-  }
-
-  async getRecentBlockHash(): string {
-    const {
-      value: { blockhash },
-    } = await this.api.post({
-      method: 'getRecentBlockhash',
-    })
-    return blockhash
-  }
-
-  // Transaction structure: https://docs.solana.com/apps/jsonrpc-api#transaction-structure
-  async getTransactionById(id: string) {
-    const result = await this.api.post({
-      method: 'getConfirmedTransaction',
-      params: [id, 'jsonParsed'],
-    })
-    return result
-  }
-
-  async getFee(): number {
-    const {
-      value: {
-        feeCalculator: { lamportsPerSignature },
-      },
-    } = await this.api.post({
-      method: 'getRecentBlockhash',
-    })
-    return lamportsPerSignature
-  }
-
-  async getBalance(address: string): number {
-    const res = await this.api.post({
-      method: 'getBalance',
-      params: [address],
-    })
-    return res.value || 0
-  }
-
-  async getBlockTime(slot: number) {
-    // might result in error if executed on a validator with partial ledger (https://github.com/solana-labs/solana/issues/12413)
-    return this.api.post({
-      method: 'getBlockTime',
-      params: [slot],
-    })
-  }
-
-  async getConfirmedSignaturesForAddress(address: string, { until, before, limit } = {}): any {
-    until = until || undefined
-    return this.api.post({
-      method: 'getSignaturesForAddress',
-      params: [address, { until, before, limit }],
-    })
-  }
-
-  /**
-   * Get transactions from an address
-   */
-  async getTransactions(
-    address: string,
-    { cursor, before, limit, includeUnparsed = false } = {}
-  ): any {
-    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.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.orderBy(transactions, ['timestamp'], ['desc'])
-
-    const newCursor = transactions[0] ? transactions[0].id : cursor
-
-    return { transactions, newCursor }
-  }
-
-  parseTransaction(
-    ownerAddress: string,
-    txDetails: Object,
-    tokenAccountsByOwner: ?Array,
-    { includeUnparsed = false } = {}
-  ): Object {
-    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: postBalances[ownerIndex] - preBalances[ownerIndex] + feePaid,
-        fee: feePaid,
-        data: {
-          meta: txDetails.meta,
-        },
-      }
-    }
-
-    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.get(ix, 'parsed.type')
-        const isTransferTx = ix.parsed && ix.program === 'spl-token' && type === 'transfer'
-        const source = lodash.get(ix, 'parsed.info.source')
-        const destination = lodash.get(ix, 'parsed.info.destination')
-        const amount = Number(lodash.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.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.find(instructions, { program: 'system', type: 'createAccountWithSeed' })
-    const stakeWithdraw = lodash.find(instructions, { program: 'stake', type: 'withdraw' })
-    const stakeUndelegate = lodash.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.map(
-        lodash.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.map(
-        lodash.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.ok(
-        Array.isArray(tokenAccountsByOwner),
-        'tokenAccountsByOwner is required when parsing token tx'
-      )
-      let tokenTxs = lodash
-        .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.find(tokenAccountsByOwner, { tokenAccountAddress: ix.source })
-          const isSending = !!tokenAccount
-          if (!isSending)
-            tokenAccount = lodash.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.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.mapKeys(accountKeys, (x, i) => i)
-        Object.values(accountIndexes).forEach((acc) => {
-          // filter by ownerAddress
-          const hasKnownOwner = !!lodash.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 = innerInstructions.map((i) => ({ ...i, fee: 0 }))
-          } 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: string): string {
-    const {
-      value: { amount },
-    } = await this.api.post({
-      method: 'getTokenSupply',
-      params: [mintAddress],
-    })
-    return amount
-  }
-
-  async getWalletTokensList({ address, 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: string, tokenTicker: ?string): Array {
-    const { value: accountsList } = await this.api.post({
-      method: 'getTokenAccountsByOwner',
-      params: [address, { programId: TOKEN_PROGRAM_ID.toBase58() }, { encoding: 'jsonParsed' }],
-    })
-
-    const tokenAccounts = []
-    for (let entry of accountsList) {
-      const { pubkey, account } = entry
-
-      const mint = lodash.get(account, 'data.parsed.info.mint')
-      const token = this.tokens[mint] || {
-        name: 'unknown',
-        ticker: 'UNKNOWN',
-      }
-      const balance = lodash.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: string) {
-    // Returns the token balance of an SPL Token account.
-    try {
-      await this.api.post({
-        method: 'getTokenAccountBalance',
-        params: [tokenAddress],
-      })
-      return true
-    } catch (e) {
-      return false
-    }
-  }
-
-  // Returns account balance of a SPL Token account.
-  async getTokenBalance(tokenAddress: string) {
-    const {
-      value: { amount },
-    } = await this.api.post({
-      method: 'getTokenAccountBalance',
-      params: [tokenAddress],
-    })
-
-    return amount
-  }
-
-  async getAccountInfo(address: string) {
-    const { value } = await this.api.post({
-      method: 'getAccountInfo',
-      params: [address, { encoding: 'jsonParsed', commitment: 'single' }],
-    })
-    return value
-  }
-
-  async isSpl(address: string) {
-    const { owner } = await this.getAccountInfo(address)
-    return owner === 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA'
-  }
-
-  async getMetaplexMetadata(tokenMintAddress: string) {
-    const metaplexPDA = getMetadataAccount(tokenMintAddress)
-    const res = await this.getAccountInfo(metaplexPDA)
-    const data = lodash.get(res, 'data[0]')
-    if (!data) return null
-
-    return deserializeMetaplexMetadata(Buffer.from(data, 'base64'))
-  }
-
-  async getDecimals(tokenMintAddress: string) {
-    const res = await this.api.post({ method: 'getTokenSupply', params: [tokenMintAddress] })
-    return lodash.get(res, 'value.decimals', null)
-  }
-
-  async getAddressType(address: string) {
-    // 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 === SYSTEM_PROGRAM_ID.toBase58()
-      ? 'solana'
-      : account.owner === TOKEN_PROGRAM_ID.toBase58()
-        ? 'token'
-        : null
-  }
-
-  async getTokenAddressOwner(address: string) {
-    const value = await this.getAccountInfo(address)
-    const owner = lodash.get(value, 'data.parsed.info.owner', null)
-    return owner
-  }
-
-  async getAddressMint(address) {
-    const value = await this.getAccountInfo(address)
-    const mintAddress = lodash.get(value, 'data.parsed.info.mint', null) // token mint
-    return mintAddress
-  }
-
-  async isTokenAddress(address: string) {
-    const type = await this.getAddressType(address)
-    return type === 'token'
-  }
-
-  async isSOLaddress(address: string) {
-    const type = await this.getAddressType(address)
-    return type === 'solana'
-  }
-
-  async getStakeAccountsInfo(address: string) {
-    // get staked amount and other info
-    const res = await this.api.post({
-      method: 'getProgramAccounts',
-      params: [
-        STAKE_PROGRAM_ID.toBase58(),
-        {
-          filters: [
-            {
-              memcmp: {
-                offset: 12,
-                bytes: address,
-              },
-            },
-          ],
-          encoding: 'jsonParsed',
-        },
-      ],
-    })
-    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.get(entry, 'account.lamports', 0)
-      const delegation = lodash.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: number) {
-    const minimumBalance = await this.api.post({
-      method: 'getMinimumBalanceForRentExemption',
-      params: [size],
-    })
-
-    return minimumBalance
-  }
-
-  /**
-   * Broadcast a signed transaction
-   */
-  broadcastTransaction = async (signedTx: string): string => {
-    console.log('Solana broadcasting TX:', signedTx) // base64
-
-    const result = await this.api.post({
-      method: 'sendTransaction',
-      params: [signedTx, { encoding: 'base64', commitment: 'singleGossip' }],
-    })
-
-    console.log(`tx ${JSON.stringify(result)} sent!`)
-    return result || null
-  }
-
-  simulateTransaction = async (encodedTransaction, options) => {
-    const {
-      value: { accounts },
-    } = await this.api.post({
-      method: 'simulateTransaction',
-      params: [encodedTransaction, options],
-    })
-
-    return accounts
-  }
-
-  resolveSimulationSideEffects = async (solAccounts, tokenAccounts) => {
-    const willReceive = []
-    const willSend = []
-
-    const resolveSols = solAccounts.map(async (account) => {
-      const currentAmount = await this.getBalance(account.address)
-      const balance = computeBalance(account.amount, currentAmount)
-      return {
-        name: 'SOL',
-        symbol: 'SOL',
-        balance,
-        decimal: 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,
-        }
-
-        // Only perform an NFT check (getSupply) if decimal is zero
-        if (decimal === 0 && (await _getSupply(account.mint)) === '1') {
-          try {
-            const {
-              id: collectionId,
-              collectionName,
-              collectionTitle,
-            } = await magicEden.api.getNFTByMintAddress(account.mint)
-            nft = {
-              collectionId,
-              collectionTitle,
-              collectionName,
-            }
-            tokenMetaPlex.name = tokenMetaPlex.name || collectionTitle
-            tokenMetaPlex.symbol = tokenMetaPlex.symbol || collectionName
-          } catch (error) {
-            console.warn(error)
-          }
-        }
-
-        const balance = 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,
-    }
-  }
-
-  /**
-   * Simulate transaction and return side effects
-   */
-  simulateAndRetrieveSideEffects = async (
-    transactionMessage: SolanaWeb3Message,
-    publicKey: string
-  ) => {
-    const { config, accountAddresses } = getTransactionSimulationParams(transactionMessage)
-    const signatures = new Array(transactionMessage.header.numRequiredSignatures || 1).fill(null)
-    const encodedTransaction = buildRawTransaction(
-      transactionMessage.serialize(),
-      signatures
-    ).toString('base64')
-    const futureAccountsState = await this.simulateTransaction(encodedTransaction, config)
-    const { solAccounts, tokenAccounts } = filterAccountsByOwner(
-      futureAccountsState,
-      accountAddresses,
-      publicKey
-    )
-
-    return this.resolveSimulationSideEffects(solAccounts, tokenAccounts)
-  }
-}
-
-export default new Api()
+export * from './api'
+export * from './tx-log'
+export * from './account-state'