@exodus/solana-api 2.5.29 → 2.5.30

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/solana-api",
-  "version": "2.5.29",
+  "version": "2.5.30",
   "description": "Exodus internal Solana asset API wrapper",
   "main": "src/index.js",
   "files": [
@@ -34,5 +34,5 @@
   "devDependencies": {
     "@exodus/assets-testing": "file:../../../__testing__"
   },
-  "gitHead": "7ec211abf9ccbc6b8bc84440f3bc6da659aebaaf"
+  "gitHead": "5270d4cf5f0a0ae9486533f237e6abe6f026ed16"
 }

package/src/get-balances.js

@@ -1,21 +1,30 @@
+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 }) => {
+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: accountState?.tokenBalances?.[asset.name], spendableBalance: null }
+    return { balance, spendableBalance: balance }
   }
 
-  const zero = asset.currency.ZERO
-
-  const balance = accountState.balance || zero
-
-  const { locked, withdrawable, pending } = accountState.mem || Object.create(null)
-
   const balanceWithoutStaking = balance
-    .sub(locked || zero)
-    .sub(withdrawable || zero)
-    .sub(pending || zero)
+    .sub(locked)
+    .sub(withdrawable)
+    .sub(pending)
     .clampLowerZero()
 
   return {
@@ -23,3 +32,46 @@ export const getBalancesFactory = ({ stakingFeatureAvailable }) => ({ asset, acc
     spendableBalance: balanceWithoutStaking.sub(asset.accountReserve || zero).clampLowerZero(),
   }
 }
+
+const fixBalances = ({ txLog = TxSet.EMPTY, balance, locked, withdrawable, pending, asset }) => {
+  for (const tx of txLog) {
+    if ((tx.sent || tx.data.staking) && tx.pending && !tx.error) {
+      if (tx.coinAmount.unitType.equals(tx.feeAmount.unitType)) {
+        balance = balance.sub(tx.feeAmount)
+      }
+
+      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':
+            locked = locked.add(tx.coinAmount.abs())
+            break
+          case 'withdraw':
+            withdrawable = asset.currency.ZERO
+            break
+          case 'undelegate':
+            pending = pending.add(locked)
+            locked = asset.currency.ZERO
+            break
+        }
+      }
+    }
+  }
+  return {
+    balance: balance.clampLowerZero(),
+    locked: locked.clampLowerZero(),
+    withdrawable: withdrawable.clampLowerZero(),
+    pending: pending.clampLowerZero(),
+  }
+}
+
+const getBalanceFromAccountState = ({ asset, accountState }) => {
+  const isBase = asset.name === asset.baseAsset.name
+  return (
+    (isBase ? accountState?.balance : accountState?.tokenBalances?.[asset.name]) ||
+    asset.currency.ZERO
+  )
+}

package/src/tx-send.js

@@ -10,7 +10,6 @@ export const createAndBroadcastTXFactory = (api) => async (
 
   const {
     feeAmount,
-    shouldLog = true,
     method,
     stakeAddresses,
     seed,
@@ -33,21 +32,37 @@ export const createAndBroadcastTXFactory = (api) => async (
     reference,
     memo,
   } = options
-  let { recentBlockhash } = options
   const { baseAsset } = asset
   const from = await assetClientInterface.getReceiveAddress({
     assetName: baseAsset.name,
     walletAccount,
   })
-  const currentAccountState = await assetClientInterface.getAccountState({
-    assetName: baseAsset.name,
-    walletAccount,
-  })
 
-  recentBlockhash = recentBlockhash || (await api.getRecentBlockHash())
+  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
+    }
+  }
+
+  const recentBlockhash = options.recentBlockhash || (await api.getRecentBlockHash())
 
   let tokenParams = Object.create(null)
-  if (asset.assetType === 'SOLANA_TOKEN' || customMintAddress) {
+  if (isToken || customMintAddress) {
     const tokenMintAddress = customMintAddress || asset.mintAddress
     const tokenAddress = findAssociatedTokenAddress(address, tokenMintAddress)
     const [
@@ -95,7 +110,7 @@ export const createAndBroadcastTXFactory = (api) => async (
     creators,
   }
 
-  const unsignedTransaction = await createUnsignedTx({
+  const unsignedTransaction = createUnsignedTx({
     asset,
     from,
     to: address,
@@ -118,38 +133,33 @@ export const createAndBroadcastTXFactory = (api) => async (
   await baseAsset.api.broadcastTx(rawTx)
 
   const selfSend = from === address
-  const coinAmount = selfSend ? asset.currency.ZERO : amount.abs().negate()
-
-  if (shouldLog) {
-    const tx = {
-      txId,
-      confirmations: 0,
-      coinName: assetName,
-      coinAmount,
-      feeAmount,
-      feeCoinName: asset.feeAsset.name,
-      selfSend,
-      to: address,
-      data: {
-        // note
-      },
-      currencies: { [assetName]: asset.currency, [asset.feeAsset.name]: asset.feeAsset.currency },
-    }
-    await assetClientInterface.updateTxLogAndNotify({ assetName, walletAccount, txs: [tx] })
+  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 changes = Object.create(null)
-  if (asset.assetType === 'SOLANA_TOKEN') {
-    Object.assign(changes, {
-      balance: currentAccountState.balance.sub(feeAmount), // solana balance
-      tokenBalances: {
-        ...currentAccountState.tokenBalances,
-        [assetName]: currentAccountState.tokenBalances[assetName].sub(coinAmount.abs()),
-      }, // SPL token balance
-    })
+  if (isToken) {
     // write tx entry in solana for token fee
-    const tx = {
+    const txForFee = {
       txId,
+      confirmations: 0,
       coinName: baseAsset.name,
       coinAmount: baseAsset.currency.ZERO,
       tokens: [assetName],
@@ -162,45 +172,12 @@ export const createAndBroadcastTXFactory = (api) => async (
         [baseAsset.feeAsset.name]: baseAsset.feeAsset.currency,
       },
     }
-    await assetClientInterface.updateTxLogAndNotify({ assetName, walletAccount, txs: [tx] })
-  } else if (customMintAddress) {
-    Object.assign(changes, {
-      balance: currentAccountState.balance.sub(feeAmount), // solana balance
-    })
-  } else if (method) {
-    // staking: no changes
-  } else {
-    // SOL transfer
-    Object.assign(changes, {
-      balance: currentAccountState.balance.sub(coinAmount.abs()).sub(feeAmount),
+    await assetClientInterface.updateTxLogAndNotify({
+      assetName: baseAsset.name,
+      walletAccount,
+      txs: [txForFee],
     })
   }
 
-  if (method) {
-    const stakingData = { ...currentAccountState.mem }
-    switch (method) {
-      case 'delegate':
-        stakingData.isDelegating = true
-        stakingData.locked = stakingData.locked.add(amount)
-        break
-      case 'undelegate':
-        stakingData.isDelegating = false
-        stakingData.pending = stakingData.pending.add(stakingData.locked)
-        stakingData.locked = asset.currency.ZERO
-        break
-      case 'withdraw':
-        stakingData.withdrawable = asset.currency.ZERO
-        break
-    }
-
-    Object.assign(changes, { mem: stakingData })
-  }
-
-  await assetClientInterface.updateAccountState({
-    assetName: baseAsset.name,
-    walletAccount,
-    newData: changes,
-  })
-
   return { txId }
 }