@exodus/solana-api 1.4.1 → 1.4.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/solana-api",
-  "version": "1.4.1",
+  "version": "1.4.2",
   "description": "Exodus internal Solana asset API wrapper",
   "main": "src/index.js",
   "files": [
@@ -22,5 +22,5 @@
   "devDependencies": {
     "node-fetch": "~1.6.3"
   },
-  "gitHead": "49f3f78ac41acaf405e2849cccb2f9ecd0060424"
+  "gitHead": "d7cd72173e6645069824b0669559481e3ff762c2"
 }

package/src/index.js

@@ -35,7 +35,7 @@ class Api {
 
   setTokens(assets = {}) {
     const solTokens = lodash.pickBy(assets, (asset) => asset.assetType === 'SOLANA_TOKEN')
-    this.tokens = lodash.mapKeys(solTokens, (v) => v.mintAddress )
+    this.tokens = lodash.mapKeys(solTokens, (v) => v.mintAddress)
   }
 
   request(path, contentType = 'application/json'): Wretcher {
@@ -153,6 +153,18 @@ class Api {
         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),
@@ -172,7 +184,10 @@ class Api {
   }
 
   parseTransaction(ownerAddress: string, txDetails: Object, tokenAccountsByOwner: ?Array): Object {
-    const { fee, preTokenBalances, postTokenBalances } = txDetails.meta
+    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
@@ -181,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) => {
@@ -190,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 = {
@@ -316,30 +364,28 @@ class Api {
           )
         })
 
-        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 { name, ticker } = this.tokens[mint] || {
-            name: '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: name,
-              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)
+            }
           }
         }
       }
@@ -348,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 {