@exodus/solana-api 3.12.1 → 3.13.1

package/CHANGELOG.md

@@ -3,6 +3,26 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [3.13.1](https://github.com/ExodusMovement/assets/compare/@exodus/solana-api@3.13.0...@exodus/solana-api@3.13.1) (2025-01-09)
+
+
+### Bug Fixes
+
+
+* fix: missing token transaction when parsing solana transactions (#4788)
+
+
+
+## [3.13.0](https://github.com/ExodusMovement/assets/compare/@exodus/solana-api@3.12.1...@exodus/solana-api@3.13.0) (2025-01-08)
+
+
+### Features
+
+
+* feat: add SOL waitForTransactionStatus method (#4800)
+
+
+
 ## [3.12.1](https://github.com/ExodusMovement/assets/compare/@exodus/solana-api@3.12.0...@exodus/solana-api@3.12.1) (2025-01-02)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/solana-api",
-  "version": "3.12.1",
+  "version": "3.13.1",
   "description": "Transaction monitors, fee monitors, RPC with the blockchain node, and other networking code for Solana",
   "type": "module",
   "main": "src/index.js",
@@ -47,7 +47,7 @@
     "@exodus/assets-testing": "^1.0.0",
     "@exodus/solana-web3.js": "^1.63.1-exodus.9-rc3"
   },
-  "gitHead": "8a6a0d1a70d14e86a9cf4d47b8884939f10be724",
+  "gitHead": "8593d378a2c8054dea5d94dac3bf96b124842903",
   "bugs": {
     "url": "https://github.com/ExodusMovement/assets/issues?q=is%3Aissue+is%3Aopen+label%3Asolana-api"
   },

package/src/api.js

@@ -16,13 +16,13 @@ import {
 } from '@exodus/solana-lib'
 import BN from 'bn.js'
 import lodash from 'lodash'
-import assert from 'minimalistic-assert'
 import ms from 'ms'
 import urljoin from 'url-join'
 import wretch from 'wretch'
 
 import { Connection } from './connection.js'
 import { getStakeActivation } from './get-stake-activation/index.js'
+import { isSplTransferInstruction } from './txs-utils.js'
 
 const createApi = createApiCJS.default || createApiCJS
 
@@ -178,6 +178,32 @@ export class Api {
     return this.rpcCall('getBlockTime', [slot])
   }
 
+  async waitForTransactionStatus(txIds, status = 'finalized', timeoutMs = ms('1m')) {
+    if (!Array.isArray(txIds)) txIds = [txIds]
+    const startTime = Date.now()
+
+    while (true) {
+      const response = await this.rpcCall('getSignatureStatuses', [
+        txIds,
+        { searchTransactionHistory: true },
+      ])
+      const data = response.value
+      const allTxsAreConfirmed = data.every((elem) => elem?.confirmationStatus === status)
+      if (allTxsAreConfirmed) {
+        return true
+      }
+
+      // Check if the timeout has elapsed
+      if (Date.now() - startTime >= timeoutMs) {
+        // timeout
+        throw new Error('waitForTransactionStatus timeout')
+      }
+
+      // Wait for the specified interval before the next request
+      await new Promise((resolve) => setTimeout(resolve, ms('10s')))
+    }
+  }
+
   async getSignaturesForAddress(address, { until, before, limit } = {}) {
     until = until || undefined
     return this.rpcCall('getSignaturesForAddress', [address, { until, before, limit }], { address })
@@ -224,7 +250,8 @@ export class Api {
         const parsedTx = this.parseTransaction(address, txDetail, tokenAccountsByOwner, {
           includeUnparsed,
         })
-        if (!parsedTx.from && !includeUnparsed) return // cannot parse it
+
+        if (!parsedTx.from && parsedTx.tokenTxs?.length === 0 && !includeUnparsed) return // cannot parse it
 
         // split dexTx in separate txs
         if (parsedTx.dexTxs) {
@@ -238,11 +265,24 @@ export class Api {
           delete parsedTx.dexTxs
         }
 
-        transactions.push({
-          timestamp,
-          date: new Date(timestamp),
-          ...parsedTx,
-        })
+        if (parsedTx.tokenTxs?.length > 0) {
+          parsedTx.tokenTxs.forEach((tx) => {
+            transactions.push({
+              timestamp,
+              date: new Date(timestamp),
+              ...tx,
+            })
+          })
+          delete parsedTx.tokenTxs
+        }
+
+        if (parsedTx.from) {
+          transactions.push({
+            timestamp,
+            date: new Date(timestamp),
+            ...parsedTx,
+          })
+        }
       })
     } catch (err) {
       console.warn('Solana error:', err)
@@ -375,30 +415,22 @@ export class Api {
       .reduce((acc, val) => {
         return [...acc, ...val.instructions]
       }, [])
+      .filter(
+        (ix) => ix.parsed && isSplTransferInstruction({ program: ix.program, type: ix.parsed.type })
+      )
       .map((ix) => {
-        const type = lodash.get(ix, 'parsed.type')
-        const isTransferTx =
-          ix.parsed &&
-          ix.program === 'spl-token' &&
-          ['transfer', 'transferChecked', 'transferCheckedWithFee'].includes(type)
-
-        if (!isTransferTx) return null
-
         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) ||
             lodash.get(ix, 'parsed.info.tokenAmount.amount', 0)
         )
-        const txId = txDetails.transaction.signatures[0]
-        if (accountToRedeemToOwner && destination === accountToRedeemToOwner) {
-          const getOwnerOrAccount = (account) =>
-            account && account === accountToRedeemToOwner ? ownerAddress : account
+        const authority = lodash.get(ix, 'parsed.info.authority')
 
+        if (accountToRedeemToOwner && destination === accountToRedeemToOwner) {
           solanaTransferTx = {
-            id: txId,
-            from: getOwnerOrAccount(source),
-            to: getOwnerOrAccount(destination),
+            from: authority || source,
+            to: ownerAddress,
             amount,
             fee,
           }
@@ -415,17 +447,14 @@ export class Api {
         })
 
         // owner if it's a send tx
-        const instruction = {
-          id: txId,
-          slot: txDetails.slot,
+        return {
           owner: isSending ? ownerAddress : null,
-          from: source,
-          to: destination,
+          from: isSending ? ownerAddress : source,
+          to: isSending ? destination : ownerAddress,
           amount,
           token: tokenAccount,
           fee: isSending ? fee : 0,
         }
-        return tokenAccount ? instruction : null
       })
       .filter((ix) => !!ix)
 
@@ -434,21 +463,9 @@ export 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 hasOnlySolanaTx =
-      solanaTransferTx && preTokenBalances.length === 0 && postTokenBalances.length === 0 // only SOL moved and no tokens movements
 
     let tx = {}
-    if (hasOnlySolanaTx) {
-      // Solana tx
-      const isSending = ownerAddress === solanaTransferTx.source
-      tx = {
-        owner: solanaTransferTx.source,
-        from: solanaTransferTx.source,
-        to: solanaTransferTx.destination,
-        amount: solanaTransferTx.lamports, // number
-        fee: isSending ? fee : 0,
-      }
-    } else if (stakeTx) {
+    if (stakeTx) {
       // start staking
       tx = {
         owner: stakeTx.base,
@@ -497,64 +514,49 @@ export class Api {
         },
       }
     } else {
-      // Token tx
-      assert(
-        Array.isArray(tokenAccountsByOwner),
-        'tokenAccountsByOwner is required when parsing token tx'
-      )
+      if (solanaTransferTx) {
+        const isSending = ownerAddress === solanaTransferTx.source
+        tx = {
+          owner: solanaTransferTx.source,
+          from: solanaTransferTx.source,
+          to: solanaTransferTx.destination,
+          amount: solanaTransferTx.lamports, // number
+          fee: isSending ? fee : 0,
+        }
+      }
 
-      const tokenTxs = lodash
-        .filter(instructions, ({ program, type }) => {
-          return (
-            program === 'spl-token' &&
-            ['transfer', 'transferChecked', 'transferCheckedWithFee'].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 types: transfer, transferChecked, transferCheckedWithFee
-            fee: isSending ? fee : 0, // in lamports
-          }
-        })
+      // Parse Token txs
+      const tokenTxs = this._parseTokenTransfers({
+        instructions,
+        tokenAccountsByOwner,
+        ownerAddress,
+        fee,
+        preTokenBalances,
+        postTokenBalances,
+      })
 
       if (tokenTxs.length > 0) {
         // 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
-        }, {})
+        tx.tokenTxs = tokenTxs.map((tx) => ({
+          id: txDetails.transaction.signatures[0],
+          slot: txDetails.slot,
+          ...tx,
+        }))
       } 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
-          // eslint-disable-next-line unicorn/prefer-array-some
-          const hasKnownOwner = !!lodash.find(tokenAccountsByOwner, {
-            tokenAccountAddress: acc.pubkey,
-          })
-          // eslint-disable-next-line @exodus/mutable/no-param-reassign-prop-only
-          acc.owner = hasKnownOwner ? ownerAddress : null
-        })
+        const accountIndexes = accountKeys.reduce((acc, key, i) => {
+          const hasKnownOwner = tokenAccountsByOwner.some(
+            (tokenAccount) => tokenAccount.tokenAccountAddress === key.pubkey
+          )
+
+          acc[i] = {
+            ...key,
+            owner: hasKnownOwner ? ownerAddress : null,
+          }
+
+          return acc
+        }, Object.create(null))
 
         // group by owner and supported token
         const preBalances = preTokenBalances.filter((t) => {
@@ -627,6 +629,54 @@ export class Api {
     }
   }
 
+  _parseTokenTransfers({
+    instructions,
+    tokenAccountsByOwner,
+    ownerAddress,
+    fee,
+    preTokenBalances,
+    postTokenBalances,
+  }) {
+    if (
+      preTokenBalances.length === 0 &&
+      postTokenBalances.length === 0 &&
+      !Array.isArray(tokenAccountsByOwner)
+    )
+      return []
+
+    const tokenTxs = []
+
+    instructions.forEach((instruction) => {
+      const { type, program, source, destination, amount, tokenAmount } = instruction
+
+      if (isSplTransferInstruction({ program, type })) {
+        let tokenAccount = lodash.find(tokenAccountsByOwner, { tokenAccountAddress: source })
+        const isSending = !!tokenAccount
+        if (!isSending)
+          tokenAccount = lodash.find(tokenAccountsByOwner, {
+            tokenAccountAddress: destination,
+          }) // receiving
+        if (!tokenAccount) return // no transfers with our addresses involved
+
+        const owner = isSending ? ownerAddress : null
+
+        delete tokenAccount.balance
+        delete tokenAccount.owner
+
+        tokenTxs.push({
+          owner,
+          token: tokenAccount,
+          from: isSending ? ownerAddress : source,
+          to: isSending ? destination : ownerAddress,
+          amount: Number(amount || tokenAmount?.amount || 0), // supporting types: transfer, transferChecked, transferCheckedWithFee
+          fee: isSending ? fee : 0, // in lamports
+        })
+      }
+    })
+
+    return tokenTxs
+  }
+
   async getWalletTokensList({ tokenAccounts }) {
     const tokensMint = []
     for (const account of tokenAccounts) {

package/src/txs-utils.js

@@ -1,3 +1,9 @@
+const TRANSFER_INSTRUCTION_TYPES = new Set([
+  'transfer',
+  'transferChecked',
+  'transferCheckedWithFee',
+])
+
 const isSolanaTx = (tx) => tx.coinName === 'solana'
 export const isSolanaStaking = (tx) =>
   isSolanaTx(tx) && ['createAccountWithSeed', 'delegate'].includes(tx?.data?.staking?.method)
@@ -6,3 +12,6 @@ export const isSolanaUnstaking = (tx) =>
 export const isSolanaWithdrawn = (tx) => isSolanaTx(tx) && tx?.data?.staking?.method === 'withdraw'
 export const isSolanaRewardsActivityTx = (tx) =>
   [isSolanaStaking, isSolanaUnstaking, isSolanaWithdrawn].some((fn) => fn(tx))
+
+export const isSplTransferInstruction = ({ program, type }) =>
+  program === 'spl-token' && TRANSFER_INSTRUCTION_TYPES.has(type)