@exodus/solana-api 1.3.3 → 1.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/solana-api",
-  "version": "1.3.3",
+  "version": "1.4.1",
   "description": "Exodus internal Solana asset API wrapper",
   "main": "src/index.js",
   "files": [
@@ -14,7 +14,7 @@
   },
   "dependencies": {
     "@exodus/asset-json-rpc": "^1.0.0",
-    "@exodus/solana-lib": "^1.2.29",
+    "@exodus/solana-lib": "^1.3.1",
     "lodash": "^4.17.11",
     "url-join": "4.0.0",
     "wretch": "^1.5.2"
@@ -22,5 +22,5 @@
   "devDependencies": {
     "node-fetch": "~1.6.3"
   },
-  "gitHead": "69134d5324df0b3977a84b39e1098876a5ebffe7"
+  "gitHead": "49f3f78ac41acaf405e2849cccb2f9ecd0060424"
 }

package/src/index.js

@@ -3,11 +3,15 @@ import createApi from '@exodus/asset-json-rpc'
 import {
   getMetadataAccount,
   deserializeMetaplexMetadata,
-  tokens,
+  getTransactionSimulationParams,
+  filterAccountsByOwner,
   SYSTEM_PROGRAM_ID,
   STAKE_PROGRAM_ID,
   TOKEN_PROGRAM_ID,
+  SOL_DECIMAL,
+  computeBalance,
 } from '@exodus/solana-lib'
+import assets from '@exodus/assets'
 import assert from 'assert'
 import lodash from 'lodash'
 import urljoin from 'url-join'
@@ -21,6 +25,7 @@ const RPC_URL = 'https://solana.a.exodus.io' // https://vip-api.mainnet-beta.sol
 class Api {
   constructor(rpcUrl) {
     this.setServer(rpcUrl)
+    this.setTokens(assets)
   }
 
   setServer(rpcUrl) {
@@ -28,12 +33,21 @@ class Api {
     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',
@@ -136,7 +150,7 @@ class Api {
         if (txDetail === null) return
 
         const timestamp = txDetail.blockTime * 1000
-        const parsedTx = Api.parseTransaction(address, txDetail, tokenAccountsByOwner)
+        const parsedTx = this.parseTransaction(address, txDetail, tokenAccountsByOwner)
         if (!parsedTx.from) return // cannot parse it
 
         transactions.push({
@@ -157,16 +171,7 @@ class Api {
     return { transactions, newCursor }
   }
 
-  parseTransaction(...args) {
-    // alias
-    return Api.parseTransaction(...args)
-  }
-
-  static parseTransaction(
-    ownerAddress: string,
-    txDetails: Object,
-    tokenAccountsByOwner: ?Array
-  ): Object {
+  parseTransaction(ownerAddress: string, txDetails: Object, tokenAccountsByOwner: ?Array): Object {
     const { fee, preTokenBalances, postTokenBalances } = txDetails.meta
     let { instructions, accountKeys } = txDetails.transaction.message
     instructions = instructions
@@ -301,10 +306,14 @@ class Api {
 
         // group by owner and supported token
         const preBalances = preTokenBalances.filter((t) => {
-          return accountIndexes[t.accountIndex].owner === ownerAddress && isTokenSupported(t.mint)
+          return (
+            accountIndexes[t.accountIndex].owner === ownerAddress && this.isTokenSupported(t.mint)
+          )
         })
         const postBalances = postTokenBalances.filter((t) => {
-          return accountIndexes[t.accountIndex].owner === ownerAddress && isTokenSupported(t.mint)
+          return (
+            accountIndexes[t.accountIndex].owner === ownerAddress && this.isTokenSupported(t.mint)
+          )
         })
 
         if (preBalances.length && preBalances.length === postBalances.length) {
@@ -315,8 +324,8 @@ class Api {
           const isSending = Math.sign(amount) <= 0
 
           const mint = lodash.get(postBalances, '[0].mint', '')
-          const { tokenName, ticker } = tokens.find(({ mintAddress }) => mintAddress === mint) || {
-            tokenName: 'unknown',
+          const { name, ticker } = this.tokens[mint] || {
+            name: 'unknown',
             ticker: 'UNKNOWN',
           }
 
@@ -324,7 +333,7 @@ class Api {
             owner: isSending ? ownerAddress : TOKEN_PROGRAM_ID.toBase58(),
             token: {
               tokenAccountAddress: '', // token account is closed after the swap
-              tokenName,
+              tokenName: name,
               ticker,
             },
             from: isSending ? ownerAddress : TOKEN_PROGRAM_ID.toBase58(),
@@ -361,15 +370,15 @@ class Api {
       const { pubkey, account } = entry
 
       const mint = lodash.get(account, 'data.parsed.info.mint')
-      const token = tokens.find(({ mintAddress }) => mintAddress === mint) || {
-        tokenName: 'unknown',
+      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.tokenName,
+        tokenName: token.name,
         ticker: token.ticker,
         balance,
         mintAddress: mint,
@@ -409,6 +418,18 @@ class Api {
     }
   }
 
+  // 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',
@@ -560,10 +581,91 @@ class Api {
     console.log(`tx ${JSON.stringify(result)} sent!`)
     return result || null
   }
-}
 
-function isTokenSupported(mint: string) {
-  return !!tokens.find(({ mintAddress }) => mintAddress === mint)
+  simulateTransaction = async (transaction, options) => {
+    const {
+      value: { accounts },
+    } = await this.api.post({
+      method: 'simulateTransaction',
+      params: [transaction.serialize({ verifySignatures: false }).toString('base64'), 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 _getTokenBalance = async (address) => {
+      try {
+        return await this.getTokenBalance(address)
+      } catch (error) {
+        if (error.message && error.message.includes('could not find account')) {
+          return '0'
+        }
+        throw error
+      }
+    }
+
+    const resolveTokens = tokenAccounts.map(async (account) => {
+      const [_tokenMetaPlex, currentAmount, decimal] = await Promise.all([
+        this.getMetaplexMetadata(account.mint),
+        _getTokenBalance(account.address),
+        this.getDecimals(account.mint),
+      ])
+
+      const balance = computeBalance(account.amount, currentAmount)
+      const tokenMetaPlex = _tokenMetaPlex || { name: null, symbol: null }
+      return {
+        name: tokenMetaPlex.name,
+        symbol: tokenMetaPlex.symbol,
+        balance,
+        decimal,
+        type: 'TOKEN',
+      }
+    })
+
+    const accounts = await Promise.all([...resolveSols, ...resolveTokens])
+    accounts.forEach((account) => {
+      if (account.balance > 0) {
+        willReceive.push(account)
+      } else {
+        willSend.push(account)
+      }
+    })
+
+    return {
+      willReceive,
+      willSend,
+    }
+  }
+
+  /**
+   * Simulate transaction and return side effects
+   */
+  simulateAndRetrieveSideEffects = async (transaction, publicKey: string) => {
+    const { config, accountAddresses } = getTransactionSimulationParams(transaction)
+    const futureAccountsState = await this.simulateTransaction(transaction, config)
+    const { solAccounts, tokenAccounts } = filterAccountsByOwner(
+      futureAccountsState,
+      accountAddresses,
+      publicKey
+    )
+
+    return this.resolveSimulationSideEffects(solAccounts, tokenAccounts)
+  }
 }
 
 export default new Api()