@exodus/solana-api 1.4.0 → 1.4.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/solana-api",
-  "version": "1.4.0",
+  "version": "1.4.2",
   "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.3.0",
+    "@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": "158aae6b4aeb871b1566b2500456a5f475ef9d5f"
+  "gitHead": "d7cd72173e6645069824b0669559481e3ff762c2"
 }

package/src/index.js

@@ -5,13 +5,13 @@ import {
   deserializeMetaplexMetadata,
   getTransactionSimulationParams,
   filterAccountsByOwner,
-  tokens,
   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'
@@ -25,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) {
@@ -32,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',
@@ -140,9 +150,21 @@ 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
 
+        // 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),
@@ -161,17 +183,11 @@ class Api {
     return { transactions, newCursor }
   }
 
-  parseTransaction(...args) {
-    // alias
-    return Api.parseTransaction(...args)
-  }
-
-  static parseTransaction(
-    ownerAddress: string,
-    txDetails: Object,
-    tokenAccountsByOwner: ?Array
-  ): Object {
-    const { fee, preTokenBalances, postTokenBalances } = txDetails.meta
+  parseTransaction(ownerAddress: string, txDetails: Object, tokenAccountsByOwner: ?Array): Object {
+    let { fee, preTokenBalances, postTokenBalances, innerInstructions } = txDetails.meta
+    preTokenBalances = preTokenBalances || []
+    postTokenBalances = postTokenBalances || []
+    innerInstructions = innerInstructions || []
     let { instructions, accountKeys } = txDetails.transaction.message
     instructions = instructions
       .filter((ix) => ix.parsed) // only known instructions
@@ -180,6 +196,38 @@ class Api {
         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) => {
@@ -189,9 +237,10 @@ class Api {
     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 (solanaTx) {
+    if (hasSolanaTx) {
       // Solana tx
       const isSending = ownerAddress === solanaTx.source
       tx = {
@@ -305,36 +354,38 @@ 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) {
-          // parse and compute pre-balances/post-balances difference (1 token per tx spported at the moment)
-          const amount =
-            Number(lodash.get(postBalances, '[0].uiTokenAmount.amount', 0)) -
-            Number(lodash.get(preBalances, '[0].uiTokenAmount.amount', 0))
-          const isSending = Math.sign(amount) <= 0
-
-          const mint = lodash.get(postBalances, '[0].mint', '')
-          const { tokenName, ticker } = tokens.find(({ mintAddress }) => mintAddress === mint) || {
-            tokenName: 'unknown',
-            ticker: 'UNKNOWN',
+        if (preBalances.length || postBalances.length) {
+          tx = {}
+
+          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,
+            }
           }
 
-          tx = {
-            owner: isSending ? ownerAddress : TOKEN_PROGRAM_ID.toBase58(),
-            token: {
-              tokenAccountAddress: '', // token account is closed after the swap
-              tokenName,
-              ticker,
-            },
-            from: isSending ? ownerAddress : TOKEN_PROGRAM_ID.toBase58(),
-            to: ownerAddress, // DEX always interact with the owner address
-            amount,
-            fee: isSending ? fee : 0, // in lamports
+          // 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)
+            }
           }
         }
       }
@@ -343,7 +394,7 @@ class Api {
     // 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:  sull all the amounts with destination included in tokenAccountsByOwner (aggregating by ticker)
+    // 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 {
@@ -365,15 +416,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,
@@ -663,8 +714,4 @@ class Api {
   }
 }
 
-function isTokenSupported(mint: string) {
-  return !!tokens.find(({ mintAddress }) => mintAddress === mint)
-}
-
 export default new Api()