@exodus/solana-api 3.25.4 → 3.26.0

package/src/tx-parser.js

@@ -0,0 +1,533 @@
+import lodash from 'lodash'
+
+import {
+  isSolTransferInstruction,
+  isSplMintInstruction,
+  isSplTransferInstruction,
+} from './txs-utils.js'
+
+const ZERO = BigInt(0)
+
+export const parseTransaction = (
+  ownerAddress,
+  txDetails,
+  tokenAccountsByOwner,
+  { includeUnparsed = false } = {}
+) => {
+  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 feePayerPubkey = accountKeys[0].pubkey
+  const ownerIsFeePayer = feePayerPubkey === ownerAddress
+  const txId = txDetails.transaction.signatures[0]
+
+  const getUnparsedTx = () => {
+    const ownerIndex = accountKeys.findIndex((accountKey) => accountKey.pubkey === ownerAddress)
+    const feePaid = ownerIndex === 0 ? fee : 0
+
+    return {
+      unparsed: true,
+      amount: ownerIndex === -1 ? 0 : postBalances[ownerIndex] - preBalances[ownerIndex] + feePaid,
+      fee: feePaid,
+      data: {
+        meta: txDetails.meta,
+      },
+    }
+  }
+
+  const getInnerTxsFromBalanceChanges = () => {
+    const ownPreTokenBalances = preTokenBalances.filter((balance) => balance.owner === ownerAddress)
+    const ownPostTokenBalances = postTokenBalances.filter(
+      (balance) => balance.owner === ownerAddress
+    )
+
+    return ownPostTokenBalances
+      .map((postBalance) => {
+        const tokenAccount = tokenAccountsByOwner.find(
+          (tokenAccount) => tokenAccount.mintAddress === postBalance.mint
+        )
+
+        const preBalance = ownPreTokenBalances.find(
+          (balance) => balance.accountIndex === postBalance.accountIndex
+        )
+
+        const preAmount = BigInt(preBalance?.uiTokenAmount?.amount ?? '0')
+        const postAmount = BigInt(postBalance?.uiTokenAmount?.amount ?? '0')
+
+        const amount = postAmount - preAmount
+
+        if (!tokenAccount || amount === ZERO) return null
+
+        // This is not perfect as there could be multiple same-token transfers in single
+        // transaction, but our wallet only supports one transaction with single txId
+        // so we are picking first that matches (correct token + type - send or receive)
+        const match = innerInstructions.find((inner) => {
+          const targetOwner = amount < ZERO ? ownerAddress : null
+          return inner.token.mintAddress === tokenAccount.mintAddress && targetOwner === inner.owner
+        })
+
+        // It's possible we won't find a match, because our innerInstructions only contain
+        // spl-token transfers, but balances of SPL tokens can change in different ways too.
+        // for now, we are ignoring this to simplify as those cases are not that common, but
+        // they should be handled eventually. It was already a scretch to add unparsed txs logic
+        // to existing parser, expanding it further is not going to end well.
+        // this probably should be refactored from ground to handle all those transactions
+        // as a core part of it in the future
+        if (!match) return null
+
+        const { from, to, owner } = match
+
+        return {
+          id: txId,
+          slot: txDetails.slot,
+          error: !(txDetails.meta.err === null),
+          owner,
+          from,
+          to,
+          amount: (amount < ZERO ? -amount : amount).toString(), // inconsistent with the rest, but it can and did overflow
+          fee: 0,
+          token: tokenAccount,
+          data: {
+            inner: true,
+          },
+        }
+      })
+      .filter((ix) => !!ix)
+  }
+
+  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,
+    }))
+
+  let solanaTransferTx = lodash.find(instructions, (ix) => {
+    if (![ix.source, ix.destination].includes(ownerAddress)) return false
+    return ix.program === 'system' && ix.type === 'transfer'
+  }) // get SOL transfer
+
+  // check if there is a temp account created & closed within the instructions when there is no direct solana transfer
+  const accountToRedeemToOwner = solanaTransferTx
+    ? undefined
+    : instructions.find(
+        ({ type, owner, destination }) =>
+          type === 'closeAccount' && owner === ownerAddress && destination === ownerAddress
+      )?.account
+
+  innerInstructions = innerInstructions
+    .reduce((acc, val) => {
+      return [...acc, ...val.instructions]
+    }, [])
+    .filter(
+      (ix) =>
+        ix.parsed &&
+        (isSplTransferInstruction({ program: ix.program, type: ix.parsed.type }) ||
+          isSplMintInstruction({ program: ix.program, type: ix.parsed.type }) ||
+          (!includeUnparsed &&
+            isSolTransferInstruction({ program: ix.program, type: ix.parsed.type })))
+    )
+    .map((ix) => {
+      let source = lodash.get(ix, 'parsed.info.source')
+      const destination = isSplMintInstruction({ program: ix.program, type: ix.parsed.type })
+        ? lodash.get(ix, 'parsed.info.account') // only for minting
+        : 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 authority = lodash.get(ix, 'parsed.info.authority')
+
+      if (accountToRedeemToOwner && destination === accountToRedeemToOwner) {
+        solanaTransferTx = {
+          from: authority || source,
+          to: ownerAddress,
+          amount,
+          fee,
+        }
+        return
+      }
+
+      if (
+        source === ownerAddress &&
+        isSolTransferInstruction({ program: ix.program, type: ix.parsed.type })
+      ) {
+        const lamports = Number(lodash.get(ix, 'parsed.info.lamports', 0))
+        if (solanaTransferTx) {
+          solanaTransferTx.lamports += lamports
+          solanaTransferTx.amount = solanaTransferTx.lamports
+          if (!Array.isArray(solanaTransferTx.to)) {
+            solanaTransferTx.data = {
+              sent: [
+                {
+                  address: solanaTransferTx.to,
+                  amount: lamports,
+                },
+              ],
+            }
+            solanaTransferTx.to = [solanaTransferTx.to]
+          }
+
+          solanaTransferTx.to.push(destination)
+          solanaTransferTx.data.sent.push({ address: destination, amount: lamports })
+        } else {
+          solanaTransferTx = {
+            source,
+            owner: source,
+            from: source,
+            to: [destination],
+            lamports,
+            amount: lamports,
+            data: {
+              sent: [
+                {
+                  address: destination,
+                  amount: lamports,
+                },
+              ],
+            },
+            fee,
+          }
+        }
+
+        return
+      }
+
+      const tokenAccount = tokenAccountsByOwner.find(({ tokenAccountAddress }) => {
+        return [source, destination].includes(tokenAccountAddress)
+      })
+      if (!tokenAccount) return
+
+      if (isSplMintInstruction({ program: ix.program, type: ix.parsed.type })) {
+        source = lodash.get(ix, 'parsed.info.mintAuthority')
+      }
+
+      const isSending = tokenAccountsByOwner.some(({ tokenAccountAddress }) => {
+        return [source].includes(tokenAccountAddress)
+      })
+
+      // owner if it's a send tx
+      return {
+        id: txId,
+        program: ix.program,
+        type: ix.parsed.type,
+        slot: txDetails.slot,
+        owner: isSending ? ownerAddress : null,
+        from: isSending ? ownerAddress : source,
+        to: isSending ? destination : ownerAddress,
+        amount,
+        token: tokenAccount,
+        // Attribute fee only when owner is the actual fee payer
+        fee: isSending && ownerIsFeePayer ? fee : 0,
+      }
+    })
+    .filter((ix) => !!ix)
+
+  // Collect inner instructions into batch sends
+  for (let i = 0; i < innerInstructions.length - 1; i++) {
+    const tx = innerInstructions[i]
+
+    for (let j = i + 1; j < innerInstructions.length; j++) {
+      const next = innerInstructions[j]
+      if (
+        tx.id === next.id &&
+        tx.token === next.token &&
+        tx.owner === ownerAddress &&
+        tx.from === next.from
+      ) {
+        if (!tx.data) {
+          tx.data = { sent: [{ address: tx.to, amount: tx.amount }] }
+          tx.to = [tx.to]
+          tx.fee = 0
+        }
+
+        tx.data.sent.push({
+          address: next.to,
+          amount: next.amount,
+        })
+        tx.to.push(next.to)
+
+        tx.amount += next.amount
+
+        innerInstructions.splice(j, 1)
+        j--
+      }
+    }
+  }
+
+  // program:type tells us if it's a SOL or Token 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' })
+
+  let tx = {}
+  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 {
+    if (solanaTransferTx) {
+      const isSending = ownerAddress === solanaTransferTx.source
+      tx = {
+        owner: solanaTransferTx.source,
+        from: solanaTransferTx.source,
+        to: solanaTransferTx.destination,
+        amount: solanaTransferTx.lamports, // number
+        fee: isSending && ownerIsFeePayer ? fee : 0,
+        data: solanaTransferTx.data,
+      }
+    }
+
+    const accountIndexes = accountKeys.reduce((acc, key, i) => {
+      const hasKnownOwner = tokenAccountsByOwner.some(
+        (tokenAccount) => tokenAccount.tokenAccountAddress === key.pubkey
+      )
+
+      acc[i] = {
+        ...key,
+        owner: hasKnownOwner ? ownerAddress : null, // not know (like in an outgoing tx)
+      }
+
+      return acc
+    }, Object.create(null)) // { 0: { pubkey, owner }, 1: { ... }, ... }
+
+    // Parse Token txs
+    const tokenTxs = _parseTokenTransfers({
+      instructions,
+      innerInstructions,
+      tokenAccountsByOwner,
+      ownerAddress,
+      fee: ownerIsFeePayer ? fee : 0,
+      accountIndexes,
+      preTokenBalances,
+      postTokenBalances,
+    })
+
+    if (tokenTxs.length > 0) {
+      // found spl-token simple transfer/transferChecked instruction
+      tx.tokenTxs = tokenTxs.map((tx) => ({
+        id: txId,
+        slot: txDetails.slot,
+        error: !(txDetails.meta.err === null),
+        ...tx,
+      }))
+    } else if (preTokenBalances && postTokenBalances) {
+      // probably a DEX program is involved (multiple instructions), compute balance changes
+      // group by owner and supported token
+      const preBalances = preTokenBalances.filter((t) => {
+        return accountIndexes[t.accountIndex].owner === ownerAddress
+      })
+      const postBalances = postTokenBalances.filter((t) => {
+        return accountIndexes[t.accountIndex].owner === ownerAddress
+      })
+
+      if (preBalances.length > 0 || postBalances.length > 0 || solanaTransferTx) {
+        tx = {}
+
+        if (includeUnparsed && innerInstructions.length > 0) {
+          // 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.dexTxs = getInnerTxsFromBalanceChanges()
+        } else {
+          if (solanaTransferTx) {
+            // the base tx will be the one that moved solana.
+            tx =
+              solanaTransferTx.from && solanaTransferTx.to
+                ? solanaTransferTx
+                : {
+                    owner: solanaTransferTx.source,
+                    from: solanaTransferTx.source,
+                    to: solanaTransferTx.destination,
+                    amount: solanaTransferTx.lamports, // number
+                    fee: ownerAddress === solanaTransferTx.source ? fee : 0,
+                  }
+          }
+
+          // If it has inner instructions then it's a DEX tx that moved SPL -> SPL
+          if (innerInstructions.length > 0) {
+            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 && !solanaTransferTx) {
+              tx = tx.dexTxs[0]
+              tx.dexTxs = innerInstructions.slice(1)
+            }
+          }
+        }
+      }
+    }
+  }
+
+  const unparsed = Object.keys(tx).length === 0
+
+  if (unparsed && includeUnparsed) {
+    tx = getUnparsedTx()
+  }
+
+  // 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: txId,
+    slot: txDetails.slot,
+    error: !(txDetails.meta.err === null),
+    ...tx,
+  }
+}
+
+function _parseTokenTransfers({
+  instructions,
+  innerInstructions = [],
+  tokenAccountsByOwner,
+  ownerAddress,
+  fee,
+  accountIndexes = {},
+  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) {
+        // receiving
+        tokenAccount = lodash.find(tokenAccountsByOwner, {
+          tokenAccountAddress: destination,
+        })
+      }
+
+      if (!tokenAccount) return // no transfers with our addresses involved
+
+      const owner = isSending ? ownerAddress : null
+
+      delete tokenAccount.balance
+      delete tokenAccount.owner
+
+      // If it's a sending tx we want to have the destination's owner as "to" address
+      let to = ownerAddress
+      let from = ownerAddress
+      if (isSending) {
+        to = destination // token account address (trying to get the owner below, we don't always have postTokenBalances...)
+        postTokenBalances.forEach((t) => {
+          if (accountIndexes[t.accountIndex].pubkey === destination) to = t.owner
+        })
+      } else {
+        // is receiving tx
+        from = source // token account address
+        preTokenBalances.forEach((t) => {
+          if (accountIndexes[t.accountIndex].pubkey === source) from = t.owner
+        })
+      }
+
+      tokenTxs.push({
+        owner,
+        token: tokenAccount,
+        from,
+        to,
+        amount: String(amount || tokenAmount?.amount || '0'), // supporting types: transfer, transferChecked, transferCheckedWithFee
+        fee: isSending ? fee : 0, // in lamports
+      })
+    }
+  })
+
+  innerInstructions.forEach((parsedIx) => {
+    const { type, program, amount, from, to } = parsedIx
+
+    // Handle token minting (mintTo, mintToChecked)
+    if (isSplMintInstruction({ program, type })) {
+      const {
+        token: { tokenAccountAddress },
+      } = parsedIx
+
+      // Check if the destination token account belongs to our owner
+      const tokenAccount = lodash.find(tokenAccountsByOwner, {
+        tokenAccountAddress,
+      })
+
+      if (!tokenAccount) return // not our token account
+
+      delete tokenAccount.balance
+      delete tokenAccount.owner
+
+      tokenTxs.push({
+        owner: null, // no owner for minting (it's created from thin air)
+        token: tokenAccount,
+        from, // mint address as the source
+        to, // our address as recipient
+        amount: String(amount || 0),
+        fee: 0, // no fee for receiving minted tokens
+      })
+    }
+  })
+
+  return tokenTxs
+}