@exodus/solana-api 2.5.31-alpha.2 → 2.5.31-alpha.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/solana-api",
-  "version": "2.5.31-alpha.2",
+  "version": "2.5.31-alpha.3",
   "description": "Exodus internal Solana asset API wrapper",
   "main": "src/index.js",
   "files": [
@@ -14,11 +14,6 @@
   "publishConfig": {
     "access": "restricted"
   },
-  "scripts": {
-    "test": "run -T jest",
-    "lint": "run -T eslint ./src",
-    "lint:fix": "yarn lint --fix"
-  },
   "dependencies": {
     "@exodus/asset-json-rpc": "^1.0.0",
     "@exodus/asset-lib": "^4.0.0",
@@ -37,7 +32,7 @@
     "wretch": "^1.5.2"
   },
   "devDependencies": {
-    "@exodus/assets-testing": "^1.0.0"
+    "@exodus/assets-testing": "file:../../../__testing__"
   },
   "gitHead": "9ec7084bcdfe14f1c6f11df393351885773046a6"
 }

package/src/account-state.js

@@ -27,7 +27,6 @@ export class SolanaAccountState extends AccountState {
       accounts: {}, // stake accounts
     },
   }
-
   static _tokens = [asset, ...tokens] // deprecated - will be removed
 
   static _postParse(data) {

package/src/api.js

@@ -98,7 +98,6 @@ export class Api {
     if (lodash.get(connection, 'isOpen') && !lodash.get(connection, 'shutdown') && !forceHttp) {
       return connection.sendMessage(method, params)
     }
-
     // http fallback
     return this.api.post({ method, params })
   }
@@ -121,7 +120,7 @@ export class Api {
     return state
   }
 
-  async getRecentBlockHash(commitment) {
+  async getRecentBlockHash(commitment?) {
     const result = await this.rpcCall(
       'getLatestBlockhash',
       [{ commitment: commitment || 'finalized', encoding: 'jsonParsed' }],
@@ -170,7 +169,7 @@ export class Api {
     // cursor is a txHash
 
     try {
-      const until = cursor
+      let until = cursor
 
       const tokenAccountsByOwner = await this.getTokenAccountsByOwner(address) // Array
       const tokenAccountAddresses = tokenAccountsByOwner
@@ -187,7 +186,7 @@ export class Api {
           })
         )
       )
-      let txsId = txsResultsByAccount.flat().slice(0, TXS_LIMIT) // merge arrays
+      let txsId = txsResultsByAccount.reduce((arr, row) => arr.concat(row), []).slice(0, TXS_LIMIT) // merge arrays
       txsId = lodash.uniqBy(txsId, 'signature')
 
       // get txs details in parallel
@@ -237,8 +236,14 @@ export class Api {
     tokenAccountsByOwner,
     { includeUnparsed = false } = {}
   ) {
-    let { fee, preBalances, postBalances, preTokenBalances, postTokenBalances, innerInstructions } =
-      txDetails.meta
+    let {
+      fee,
+      preBalances,
+      postBalances,
+      preTokenBalances,
+      postTokenBalances,
+      innerInstructions,
+    } = txDetails.meta
     preBalances = preBalances || []
     postBalances = postBalances || []
     preTokenBalances = preTokenBalances || []
@@ -377,7 +382,7 @@ 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 hasSolanaTx = solanaTx && preTokenBalances.length === 0 && postTokenBalances.length === 0 // only SOL moved and no tokens movements
+    const hasSolanaTx = solanaTx && !preTokenBalances.length && !postTokenBalances.length // only SOL moved and no tokens movements
 
     let tx = {}
     if (hasSolanaTx) {
@@ -444,7 +449,7 @@ export class Api {
         Array.isArray(tokenAccountsByOwner),
         'tokenAccountsByOwner is required when parsing token tx'
       )
-      const tokenTxs = lodash
+      let tokenTxs = lodash
         .filter(instructions, ({ program, type }) => {
           return program === 'spl-token' && ['transfer', 'transferChecked'].includes(type)
         }) // get Token transfer: could have more than 1 instructions
@@ -471,7 +476,7 @@ export class Api {
           }
         })
 
-      if (tokenTxs.length > 0) {
+      if (tokenTxs.length) {
         // 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) => {
@@ -504,10 +509,10 @@ export class Api {
           )
         })
 
-        if (preBalances.length > 0 || postBalances.length > 0) {
+        if (preBalances.length || postBalances.length) {
           tx = {}
 
-          if (includeUnparsed && innerInstructions.length > 0) {
+          if (includeUnparsed && innerInstructions.length) {
             // 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
@@ -527,7 +532,7 @@ export class Api {
             }
 
             // If it has inner instructions then it's a DEX tx that moved SPL -> SPL
-            if (innerInstructions.length > 0) {
+            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) {
@@ -567,7 +572,7 @@ export class Api {
 
   async getWalletTokensList({ tokenAccounts }) {
     const tokensMint = []
-    for (const account of tokenAccounts) {
+    for (let account of tokenAccounts) {
       const mint = account.mintAddress
 
       // skip cached NFT
@@ -580,7 +585,6 @@ export class Api {
         this.tokensToSkip[mint] = true
         continue
       }
-
       // OK
       tokensMint.push(mint)
     }
@@ -596,7 +600,7 @@ export class Api {
     )
 
     const tokenAccounts = []
-    for (const entry of accountsList) {
+    for (let entry of accountsList) {
       const { pubkey, account } = entry
 
       const mint = lodash.get(account, 'data.parsed.info.mint')
@@ -614,7 +618,6 @@ export class Api {
         mintAddress: mint,
       })
     }
-
     // eventually filter by token
     return tokenTicker
       ? tokenAccounts.filter(({ ticker }) => ticker === tokenTicker)
@@ -622,24 +625,18 @@ export class Api {
   }
 
   async getTokensBalance({ address, filterByTokens = [], tokenAccounts }) {
-    const accounts = tokenAccounts || (await this.getTokenAccountsByOwner(address))
+    let accounts = tokenAccounts || (await this.getTokenAccountsByOwner(address))
 
-    return accounts.reduce((acc, { tokenName, balance }) => {
-      if (
-        tokenName === 'unknown' ||
-        (filterByTokens.length > 0 && !filterByTokens.includes(tokenName))
-      )
+    const tokensBalance = accounts.reduce((acc, { tokenName, balance }) => {
+      if (tokenName === 'unknown' || (filterByTokens.length && !filterByTokens.includes(tokenName)))
         return acc // filter by supported tokens only
-      if (acc[tokenName]) {
-        acc[tokenName] += Number(balance)
-      }
+      if (!acc[tokenName]) acc[tokenName] = Number(balance)
       // e.g { 'serum': 123 }
-      else {
-        acc[tokenName] = Number(balance)
-      } // merge same token account balance
-
+      else acc[tokenName] += Number(balance) // merge same token account balance
       return acc
     }, {})
+
+    return tokensBalance
   }
 
   async isAssociatedTokenAccountActive(tokenAddress) {
@@ -647,7 +644,7 @@ export class Api {
     try {
       await this.rpcCall('getTokenAccountBalance', [tokenAddress])
       return true
-    } catch {
+    } catch (e) {
       return false
     }
   }
@@ -700,19 +697,20 @@ export class Api {
     return account.owner === SYSTEM_PROGRAM_ID.toBase58()
       ? 'solana'
       : account.owner === TOKEN_PROGRAM_ID.toBase58()
-        ? 'token'
-        : null
+      ? 'token'
+      : null
   }
 
   async getTokenAddressOwner(address) {
     const value = await this.getAccountInfo(address)
-    return lodash.get(value, 'data.parsed.info.owner', null)
+    const owner = lodash.get(value, 'data.parsed.info.owner', null)
+    return owner
   }
 
   async getAddressMint(address) {
     const value = await this.getAccountInfo(address)
-    // token mint
-    return lodash.get(value, 'data.parsed.info.mint', null)
+    const mintAddress = lodash.get(value, 'data.parsed.info.mint', null) // token mint
+    return mintAddress
   }
 
   async isTokenAddress(address) {
@@ -747,7 +745,7 @@ export class Api {
     let locked = 0
     let withdrawable = 0
     let pending = 0
-    for (const entry of res) {
+    for (let entry of res) {
       const addr = entry.pubkey
       const lamports = lodash.get(entry, 'account.lamports', 0)
       const delegation = lodash.get(entry, 'account.data.parsed.info.stake.delegation', {})
@@ -768,12 +766,11 @@ export class Api {
       withdrawable += accounts[addr].canWithdraw ? lamports : 0
       pending += accounts[addr].isDeactivating ? lamports : 0
     }
-
     return { accounts, totalStake, locked, withdrawable, pending }
   }
 
   async getRewards(stakingAddresses = []) {
-    if (stakingAddresses.length === 0) return 0
+    if (!stakingAddresses.length) return 0
 
     // custom endpoint!
     const rewards = await this.request('rewards')
@@ -783,9 +780,11 @@ export class Api {
       .json()
 
     // sum rewards for all addresses
-    return Object.values(rewards).reduce((total, x) => {
+    const earnings = Object.values(rewards).reduce((total, x) => {
       return total + x
     }, 0)
+
+    return earnings
   }
 
   async getMinimumBalanceForRentExemption(size) {
@@ -869,7 +868,6 @@ export class Api {
           if (error.message && error.message.includes('could not find account')) {
             return defaultValue
           }
-
           throw error
         }
       }
@@ -961,7 +959,7 @@ export class Api {
   simulateAndRetrieveSideEffects = async (
     message,
     publicKey,
-    transactionMessage // decompiled TransactionMessage
+    transactionMessage? // decompiled TransactionMessage
   ) => {
     const { config, accountAddresses } = getTransactionSimulationParams(
       transactionMessage || message

package/src/connection.js

@@ -67,8 +67,8 @@ export class Connection {
     debug('Opening WS to:', reqUrl)
     const ws = new WebSocket(`${reqUrl}`)
     ws.onmessage = this.onMessage.bind(this)
-    ws.addEventListener('open', this.onOpen.bind(this))
-    ws.addEventListener('close', this.onClose.bind(this))
+    ws.onopen = this.onOpen.bind(this)
+    ws.onclose = this.onClose.bind(this)
     ws.onerror = this.onError.bind(this)
     return ws
   }
@@ -90,14 +90,14 @@ export class Connection {
   }
 
   get running() {
-    return !!(!this.isClosed || this.inProcessMessages || this.messageQueue.length > 0)
+    return !!(!this.isClosed || this.inProcessMessages || this.messageQueue.length)
   }
 
   get connectionState() {
     if (this.isConnecting) return 'CONNECTING'
-    if (this.isOpen) return 'OPEN'
-    if (this.isClosing) return 'CLOSING'
-    if (this.isClosed) return 'CLOSED'
+    else if (this.isOpen) return 'OPEN'
+    else if (this.isClosing) return 'CLOSING'
+    else if (this.isClosed) return 'CLOSED'
     return 'NONE'
   }
 
@@ -125,13 +125,7 @@ export class Connection {
     try {
       const json = JSON.parse(evt.data)
       debug('new ws msg:', json)
-      if (json.error) {
-        if (lodash.get(this.rpcQueue, json.id)) {
-          this.rpcQueue[json.id].reject(new Error(json.error.message))
-          clearTimeout(this.rpcQueue[json.id].timeout)
-          delete this.rpcQueue[json.id]
-        } else debug('Unsupported WS message:', json.error.message)
-      } else {
+      if (!json.error) {
         if (lodash.get(this.rpcQueue, json.id)) {
           // json-rpc reply
           clearTimeout(this.rpcQueue[json.id].timeout)
@@ -142,8 +136,13 @@ export class Connection {
           debug('pushing msg to queue', msg)
           this.messageQueue.push(msg) // sub results
         }
-
         this.processMessages()
+      } else {
+        if (lodash.get(this.rpcQueue, json.id)) {
+          this.rpcQueue[json.id].reject(new Error(json.error.message))
+          clearTimeout(this.rpcQueue[json.id].timeout)
+          delete this.rpcQueue[json.id]
+        } else debug('Unsupported WS message:', json.error.message)
       }
     } catch (e) {
       debug(e)
@@ -200,7 +199,7 @@ export class Connection {
     if (this.inProcessMessages) return null
     this.inProcessMessages = true
     try {
-      while (this.messageQueue.length > 0) {
+      while (this.messageQueue.length) {
         const items = this.messageQueue.splice(0, this.messageQueue.length)
         await this.callback(items)
       }

package/src/get-balances.js

@@ -3,33 +3,35 @@ import { TxSet } from '@exodus/models'
 // staking may be a feature that may not be available for a given wallet.
 // In this case, The wallet should exclude the staking balance from the general balance
 
-export const getBalancesFactory =
-  ({ stakingFeatureAvailable }) =>
-  ({ asset, accountState, txLog }) => {
-    const zero = asset.currency.ZERO
-    const { balance, locked, withdrawable, pending } = fixBalances({
-      txLog,
-      balance: getBalanceFromAccountState({ asset, accountState }),
-      locked: accountState.mem?.locked || zero,
-      withdrawable: accountState.mem?.withdrawable || zero,
-      pending: accountState.mem?.pending || zero,
-      asset,
-    })
-    if (asset.baseAsset.name !== asset.name) {
-      return { balance, spendableBalance: balance }
-    }
+export const getBalancesFactory = ({ stakingFeatureAvailable }) => ({
+  asset,
+  accountState,
+  txLog,
+}) => {
+  const zero = asset.currency.ZERO
+  const { balance, locked, withdrawable, pending } = fixBalances({
+    txLog,
+    balance: getBalanceFromAccountState({ asset, accountState }),
+    locked: accountState.mem?.locked || zero,
+    withdrawable: accountState.mem?.withdrawable || zero,
+    pending: accountState.mem?.pending || zero,
+    asset,
+  })
+  if (asset.baseAsset.name !== asset.name) {
+    return { balance, spendableBalance: balance }
+  }
 
-    const balanceWithoutStaking = balance
-      .sub(locked)
-      .sub(withdrawable)
-      .sub(pending)
-      .clampLowerZero()
+  const balanceWithoutStaking = balance
+    .sub(locked)
+    .sub(withdrawable)
+    .sub(pending)
+    .clampLowerZero()
 
-    return {
-      balance: stakingFeatureAvailable ? balance : balanceWithoutStaking,
-      spendableBalance: balanceWithoutStaking.sub(asset.accountReserve || zero).clampLowerZero(),
-    }
+  return {
+    balance: stakingFeatureAvailable ? balance : balanceWithoutStaking,
+    spendableBalance: balanceWithoutStaking.sub(asset.accountReserve || zero).clampLowerZero(),
   }
+}
 
 const fixBalances = ({ txLog = TxSet.EMPTY, balance, locked, withdrawable, pending, asset }) => {
   for (const tx of txLog) {
@@ -38,7 +40,10 @@ const fixBalances = ({ txLog = TxSet.EMPTY, balance, locked, withdrawable, pendi
         balance = balance.sub(tx.feeAmount)
       }
 
-      if (tx.data.staking) {
+      if (!tx.data.staking) {
+        // coinAmount is negative for sent tx
+        balance = balance.sub(tx.coinAmount.abs())
+      } else {
         // staking tx
         switch (tx.data.staking?.method) {
           case 'delegate':
@@ -52,13 +57,9 @@ const fixBalances = ({ txLog = TxSet.EMPTY, balance, locked, withdrawable, pendi
             locked = asset.currency.ZERO
             break
         }
-      } else {
-        // coinAmount is negative for sent tx
-        balance = balance.sub(tx.coinAmount.abs())
       }
     }
   }
-
   return {
     balance: balance.clampLowerZero(),
     locked: locked.clampLowerZero(),

package/src/index.js

@@ -4,6 +4,7 @@ import assetsList from '@exodus/solana-meta'
 
 import { Api } from './api'
 
+export { Api }
 export { default as SolanaFeeMonitor } from './fee-monitor'
 export { SolanaMonitor } from './tx-log'
 export { SolanaAccountState } from './account-state'
@@ -25,5 +26,3 @@ const assets = connectAssets(keyBy(assetsList, (asset) => asset.name))
 // Clients should not call an specific server api directly.
 const serverApi = new Api({ assets })
 export default serverApi
-
-export { Api } from './api'

package/src/staking-utils.js

@@ -9,7 +9,9 @@ export const getSolStakedFee = ({ asset, stakingInfo, fee }) => {
   const { accounts } = stakingInfo
 
   const allPending = Object.entries(accounts).length
-  return allPending > 0 ? fee.mul(allPending) : currency.ZERO
+  const pendingFee = allPending > 0 ? fee.mul(allPending) : currency.ZERO
+
+  return pendingFee
 }
 
 export const getStakingInfo = (accountMem) => {

package/src/tx-log/solana-monitor.js

@@ -97,10 +97,10 @@ export class SolanaMonitor extends BaseMonitor {
 
   async getStakingAddressesFromTxLog({ assetName, walletAccount }) {
     const txLog = await this.aci.getTxLog({ assetName: this.asset.name, walletAccount })
-    const stakingAddresses = [...txLog]
+    const stakingAddresses = Array.from(txLog)
       .filter((tx) => _.get(tx, 'data.staking.stakeAddresses'))
       .map((tx) => tx.data.staking.stakeAddresses)
-    return _.uniq(stakingAddresses.flat())
+    return _.uniq(_.flatten(stakingAddresses))
   }
 
   balanceChanged({ account, newAccount }) {
@@ -173,7 +173,7 @@ export class SolanaMonitor extends BaseMonitor {
   }
 
   async getHistory({ address, accountState, refresh } = {}) {
-    const cursor = refresh ? '' : accountState.cursor
+    let cursor = refresh ? '' : accountState.cursor
     const baseAsset = this.asset
 
     const { transactions, newCursor } = await this.api.getTransactions(address, {
@@ -226,7 +226,6 @@ export class SolanaMonitor extends BaseMonitor {
 
         item.data.meta = tx.data.meta
       }
-
       if (asset.assetType === 'SOLANA_TOKEN' && item.feeAmount && item.feeAmount.isPositive) {
         const feeItem = {
           ..._.clone(item),
@@ -236,7 +235,6 @@ export class SolanaMonitor extends BaseMonitor {
         }
         mappedTransactions.push(feeItem)
       }
-
       mappedTransactions.push(item)
     }
 

package/src/tx-send.js

@@ -1,179 +1,183 @@
 import { createUnsignedTx, findAssociatedTokenAddress } from '@exodus/solana-lib'
 import assert from 'minimalistic-assert'
 
-export const createAndBroadcastTXFactory =
-  (api) =>
-  async ({ asset, walletAccount, address, amount, options = {} }, { assetClientInterface }) => {
-    const assetName = asset.name
-    assert(assetClientInterface, `assetClientInterface must be supplied in sendTx for ${assetName}`)
-
-    const {
-      feeAmount,
-      method,
-      stakeAddresses,
-      seed,
-      pool,
-      customMintAddress,
-      tokenStandard,
-      // <MagicEden>
-      initializerAddress,
-      initializerDepositTokenAddress,
-      takerAmount,
-      escrowAddress,
-      escrowBump,
-      pdaAddress,
-      takerAddress,
-      expectedTakerAmount,
-      expectedMintAddress,
-      metadataAddress,
-      creators,
-      // </MagicEden>
-      reference,
-      memo,
-    } = options
-    const { baseAsset } = asset
-    const from = await assetClientInterface.getReceiveAddress({
-      assetName: baseAsset.name,
-      walletAccount,
-    })
-
-    const isToken = asset.assetType === 'SOLANA_TOKEN'
-
-    // Check if receiver has address active when sending tokens.
-    if (isToken) {
-      // check address mint is the same
-      const targetMint = await api.getAddressMint(address) // null if it's a SOL address
-      if (targetMint && targetMint !== asset.mintAddress) {
-        const err = new Error('Wrong Destination Wallet')
-        err.reason = { mintAddressMismatch: true }
-        throw err
-      }
-    } else {
-      // sending SOL
-      const addressType = await api.getAddressType(address)
-      if (addressType === 'token') {
-        const err = new Error('Destination Wallet is a Token address')
-        err.reason = { wrongAddressType: true }
-        throw err
-      }
+export const createAndBroadcastTXFactory = (api) => async (
+  { asset, walletAccount, address, amount, options = {} },
+  { assetClientInterface }
+) => {
+  const assetName = asset.name
+  assert(assetClientInterface, `assetClientInterface must be supplied in sendTx for ${assetName}`)
+
+  const {
+    feeAmount,
+    method,
+    stakeAddresses,
+    seed,
+    pool,
+    customMintAddress,
+    tokenStandard,
+    // <MagicEden>
+    initializerAddress,
+    initializerDepositTokenAddress,
+    takerAmount,
+    escrowAddress,
+    escrowBump,
+    pdaAddress,
+    takerAddress,
+    expectedTakerAmount,
+    expectedMintAddress,
+    metadataAddress,
+    creators,
+    // </MagicEden>
+    reference,
+    memo,
+  } = options
+  const { baseAsset } = asset
+  const from = await assetClientInterface.getReceiveAddress({
+    assetName: baseAsset.name,
+    walletAccount,
+  })
+
+  const isToken = asset.assetType === 'SOLANA_TOKEN'
+
+  // Check if receiver has address active when sending tokens.
+  if (isToken) {
+    // check address mint is the same
+    const targetMint = await api.getAddressMint(address) // null if it's a SOL address
+    if (targetMint && targetMint !== asset.mintAddress) {
+      const err = new Error('Wrong Destination Wallet')
+      err.reason = { mintAddressMismatch: true }
+      throw err
     }
-
-    const recentBlockhash = options.recentBlockhash || (await api.getRecentBlockHash())
-
-    let tokenParams = Object.create(null)
-    if (isToken || customMintAddress) {
-      const tokenMintAddress = customMintAddress || asset.mintAddress
-      const tokenAddress = findAssociatedTokenAddress(address, tokenMintAddress)
-      const [destinationAddressType, isAssociatedTokenAccountActive, fromTokenAccountAddresses] =
-        await Promise.all([
-          api.getAddressType(address),
-          api.isAssociatedTokenAccountActive(tokenAddress),
-          api.getTokenAccountsByOwner(from),
-        ])
-
-      const fromTokenAddresses = fromTokenAccountAddresses.filter(
-        ({ mintAddress }) => mintAddress === tokenMintAddress
-      )
-
-      tokenParams = {
-        tokenMintAddress,
-        destinationAddressType,
-        isAssociatedTokenAccountActive,
-        fromTokenAddresses,
-        tokenStandard,
-      }
-    }
-
-    const stakingParams = {
-      method,
-      stakeAddresses,
-      seed,
-      pool,
+  } else {
+    // sending SOL
+    const addressType = await api.getAddressType(address)
+    if (addressType === 'token') {
+      const err = new Error('Destination Wallet is a Token address')
+      err.reason = { wrongAddressType: true }
+      throw err
     }
+  }
 
-    const magicEdenParams = {
-      method,
-      initializerAddress,
-      initializerDepositTokenAddress,
-      takerAmount,
-      escrowAddress,
-      escrowBump,
-      pdaAddress,
-      takerAddress,
-      expectedTakerAmount,
-      expectedMintAddress,
-      metadataAddress,
-      creators,
+  const recentBlockhash = options.recentBlockhash || (await api.getRecentBlockHash())
+
+  let tokenParams = Object.create(null)
+  if (isToken || customMintAddress) {
+    const tokenMintAddress = customMintAddress || asset.mintAddress
+    const tokenAddress = findAssociatedTokenAddress(address, tokenMintAddress)
+    const [
+      destinationAddressType,
+      isAssociatedTokenAccountActive,
+      fromTokenAccountAddresses,
+    ] = await Promise.all([
+      api.getAddressType(address),
+      api.isAssociatedTokenAccountActive(tokenAddress),
+      api.getTokenAccountsByOwner(from),
+    ])
+
+    const fromTokenAddresses = fromTokenAccountAddresses.filter(
+      ({ mintAddress }) => mintAddress === tokenMintAddress
+    )
+
+    tokenParams = {
+      tokenMintAddress,
+      destinationAddressType,
+      isAssociatedTokenAccountActive,
+      fromTokenAddresses,
+      tokenStandard,
     }
+  }
 
-    const unsignedTransaction = createUnsignedTx({
-      asset,
-      from,
-      to: address,
-      amount,
-      fee: feeAmount,
-      recentBlockhash,
-      reference,
-      memo,
-      ...tokenParams,
-      ...stakingParams,
-      ...magicEdenParams,
-    })
-
-    const { txId, rawTx } = await assetClientInterface.signTransaction({
-      assetName: baseAsset.name,
-      unsignedTx: unsignedTransaction,
-      walletAccount,
-    })
+  const stakingParams = {
+    method,
+    stakeAddresses,
+    seed,
+    pool,
+  }
 
-    await baseAsset.api.broadcastTx(rawTx)
+  const magicEdenParams = {
+    method,
+    initializerAddress,
+    initializerDepositTokenAddress,
+    takerAmount,
+    escrowAddress,
+    escrowBump,
+    pdaAddress,
+    takerAddress,
+    expectedTakerAmount,
+    expectedMintAddress,
+    metadataAddress,
+    creators,
+  }
 
-    const selfSend = from === address
-    const isStakingTx = ['delegate', 'undelegate', 'withdraw'].includes(method)
-    const coinAmount = isStakingTx
-      ? amount.abs()
-      : selfSend
-        ? asset.currency.ZERO
-        : amount.abs().negate()
+  const unsignedTransaction = createUnsignedTx({
+    asset,
+    from,
+    to: address,
+    amount,
+    fee: feeAmount,
+    recentBlockhash,
+    reference,
+    memo,
+    ...tokenParams,
+    ...stakingParams,
+    ...magicEdenParams,
+  })
+
+  const { txId, rawTx } = await assetClientInterface.signTransaction({
+    assetName: baseAsset.name,
+    unsignedTx: unsignedTransaction,
+    walletAccount,
+  })
+
+  await baseAsset.api.broadcastTx(rawTx)
+
+  const selfSend = from === address
+  const isStakingTx = ['delegate', 'undelegate', 'withdraw'].includes(method)
+  const coinAmount = isStakingTx
+    ? amount.abs()
+    : selfSend
+    ? asset.currency.ZERO
+    : amount.abs().negate()
+
+  const data = isStakingTx ? { staking: stakingParams } : Object.create(null)
+  const tx = {
+    txId,
+    confirmations: 0,
+    coinName: assetName,
+    coinAmount,
+    feeAmount,
+    feeCoinName: asset.feeAsset.name,
+    selfSend,
+    to: address,
+    data,
+    currencies: { [assetName]: asset.currency, [asset.feeAsset.name]: asset.feeAsset.currency },
+  }
+  await assetClientInterface.updateTxLogAndNotify({ assetName, walletAccount, txs: [tx] })
 
-    const data = isStakingTx ? { staking: stakingParams } : Object.create(null)
-    const tx = {
+  if (isToken) {
+    // write tx entry in solana for token fee
+    const txForFee = {
       txId,
       confirmations: 0,
-      coinName: assetName,
-      coinAmount,
+      coinName: baseAsset.name,
+      coinAmount: baseAsset.currency.ZERO,
+      tokens: [assetName],
       feeAmount,
-      feeCoinName: asset.feeAsset.name,
-      selfSend,
+      feeCoinName: baseAsset.feeAsset.name,
       to: address,
-      data,
-      currencies: { [assetName]: asset.currency, [asset.feeAsset.name]: asset.feeAsset.currency },
-    }
-    await assetClientInterface.updateTxLogAndNotify({ assetName, walletAccount, txs: [tx] })
-
-    if (isToken) {
-      // write tx entry in solana for token fee
-      const txForFee = {
-        txId,
-        confirmations: 0,
-        coinName: baseAsset.name,
-        coinAmount: baseAsset.currency.ZERO,
-        tokens: [assetName],
-        feeAmount,
-        feeCoinName: baseAsset.feeAsset.name,
-        to: address,
-        selfSend,
-        currencies: {
-          [baseAsset.name]: baseAsset.currency,
-          [baseAsset.feeAsset.name]: baseAsset.feeAsset.currency,
-        },
-      }
-      await assetClientInterface.updateTxLogAndNotify({
-        assetName: baseAsset.name,
-        walletAccount,
-        txs: [txForFee],
-      })
+      selfSend,
+      currencies: {
+        [baseAsset.name]: baseAsset.currency,
+        [baseAsset.feeAsset.name]: baseAsset.feeAsset.currency,
+      },
     }
-
-    return { txId }
+    await assetClientInterface.updateTxLogAndNotify({
+      assetName: baseAsset.name,
+      walletAccount,
+      txs: [txForFee],
+    })
   }
+
+  return { txId }
+}