@exodus/solana-api 3.25.4 → 3.26.1

package/src/ws-api.js

@@ -0,0 +1,263 @@
+import { PublicKey, Token, TOKEN_2022_PROGRAM_ID, TOKEN_PROGRAM_ID, U64 } from '@exodus/solana-lib'
+import lodash from 'lodash'
+
+import { Connection } from './connection.js'
+import { parseTransaction } from './tx-parser.js'
+
+// Helius Advanced WebSocket
+const WS_ENDPOINT = 'wss://solana-helius-wss.a.exodus.io/ws' // pointing to: wss://atlas-mainnet.helius-rpc.com/?api-key=<API_KEY>
+
+export class WsApi {
+  constructor({ rpcUrl, wsUrl, assets }) {
+    this.setWsEndpoint(wsUrl)
+    this.connections = Object.create(null)
+    this.accountSubscriptions = Object.create(null)
+  }
+
+  setWsEndpoint(wsUrl) {
+    this.wsUrl = wsUrl || WS_ENDPOINT
+  }
+
+  async watchAddress({ address, tokensAddresses = [], onMessage }) {
+    if (this.connections[address]) return // already subscribed
+    const conn = new Connection({
+      endpoint: this.wsUrl,
+      address,
+      tokensAddresses,
+      onConnectionReady: (evt) => {
+        // ws connected, can send subscribe requests (this is called on every re-connect as well)
+        console.log('SOL WS connected.')
+        this.sendSubscriptions({ address, tokensAddresses })
+      },
+      onConnectionClose: (evt) => {
+        this.accountSubscriptions = Object.create(null) // clear subs
+      },
+      onMsg: (json) => onMessage(json),
+    })
+
+    this.connections[address] = conn
+    return this.connections[address].start()
+  }
+
+  async accountSubscribe({ owner, account }) {
+    // could be SOL address or token account address
+    const conn = this.connections[owner]
+    if (!conn || !conn.isOpen) {
+      console.warn('SOL Connection is not open, cannot subscribe to', owner)
+      return
+    }
+
+    const subscriptions = this.accountSubscriptions[owner] || []
+    if (subscriptions?.includes(account)) return // already subscribed
+
+    conn.send({
+      jsonrpc: '2.0',
+      method: 'accountSubscribe',
+      params: [
+        account,
+        {
+          encoding: 'jsonParsed',
+          commitment: 'confirmed',
+        },
+      ],
+      id: ++conn.seq,
+    })
+
+    this.accountSubscriptions[owner] = [...subscriptions, account]
+  }
+
+  async sendSubscriptions({ address, tokensAddresses = [] }) {
+    const conn = this.connections[address]
+
+    const addresses = [address, ...tokensAddresses]
+
+    // 1. subscribe to each addresses (SOL and Token addresses) balance events
+    // transform this forEach in a for of to await each subscription:
+    for (const addr of addresses) {
+      await this.accountSubscribe({ owner: address, account: addr })
+    }
+
+    // 2. subscribe to transactions involving the addresses
+    if (conn) {
+      conn.send({
+        jsonrpc: '2.0',
+        id: ++conn.seq,
+        method: 'transactionSubscribe',
+        params: [
+          {
+            vote: false,
+            // failed: true,
+            accountInclude: addresses,
+          },
+          {
+            commitment: 'confirmed',
+            encoding: 'jsonParsed',
+            transactionDetails: 'full',
+            showRewards: false,
+            maxSupportedTransactionVersion: 255,
+          },
+        ],
+      })
+    }
+
+    // 3. subscribe to other events, for example use programSubscribe once Helius implements it into the Advanced WebSocket
+    // to get the new token accounts events and remove the need for the RPC call in the monitor tick
+  }
+
+  async unwatchAddress({ address }) {
+    if (this.connections[address]) {
+      await this.connections[address].stop()
+      delete this.connections[address]
+    }
+  }
+
+  parseAccountNotification({ address, walletAccount, tokenAccountsByOwner, result }) {
+    const isSolAccount = result.value.owner === '11111111111111111111111111111111' // System Program
+    if (isSolAccount) {
+      // SOL balance changed
+      const amount = result.value.lamports
+      return { solAddress: address, amount }
+    }
+
+    const isSplTokenAccount = result.value.owner === TOKEN_PROGRAM_ID.toBase58()
+    const isSpl2022TokenAccount = result.value.owner === TOKEN_2022_PROGRAM_ID.toBase58()
+
+    // SPL Token balance changed (both spl-token and spl-2022 have the first 165 bytes the same)
+    if (isSplTokenAccount || isSpl2022TokenAccount) {
+      const decoded = Token.decode(Buffer.from(result.value.data[0], 'base64'))
+      const tokenMintAddress = new PublicKey(decoded.mint).toBase58()
+      const solAddress = new PublicKey(decoded.owner).toBase58()
+      const amount = U64.fromBuffer(decoded.amount).toString()
+
+      return {
+        solAddress,
+        amount,
+        tokenMintAddress,
+      }
+    }
+  }
+
+  parseTransactionNotification({
+    address,
+    walletAccount,
+    baseAsset,
+    assets,
+    tokens,
+    tokenAccountsByOwner,
+    result,
+  }) {
+    const parsedTx = parseTransaction(address, result.transaction, tokenAccountsByOwner)
+    const timestamp = Date.now() // the notification event has no blockTime
+
+    if (!parsedTx.from && parsedTx.tokenTxs?.length === 0) return { logItemsByAsset: {} } // cannot parse it
+
+    const transactions = [] // because one single tx can have multiple instructions inside
+
+    if (parsedTx.dexTxs) {
+      parsedTx.dexTxs.forEach((tx) => {
+        transactions.push({
+          timestamp,
+          date: new Date(timestamp),
+          ...tx,
+        })
+      })
+      delete parsedTx.dexTxs
+    }
+
+    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,
+      })
+    }
+
+    const mappedTransactions = []
+    for (const tx of transactions) {
+      // we get the token name using the token.mintAddress
+      let tokenName = tokens.get(tx.token?.mintAddress)?.name
+      if (tx.token && !tokenName) {
+        tokenName = 'unknown' // unknown token
+      }
+
+      const assetName = tokenName ?? baseAsset.name
+      const asset = assets[assetName]
+      if (assetName === 'unknown' || !asset) return // skip unknown tokens
+      const feeAsset = asset.feeAsset
+
+      const coinAmount = tx.amount ? asset.currency.baseUnit(tx.amount) : asset.currency.ZERO
+
+      const item = {
+        coinName: assetName,
+        txId: tx.id,
+        from: [tx.from],
+        coinAmount,
+        confirmations: 1, // tx.confirmations, // avoid multiple notifications
+        date: tx.date,
+        error: tx.error,
+        data: {
+          staking: tx.staking || null,
+          unparsed: !!tx.unparsed,
+          swapTx: !!(tx.data && tx.data.inner),
+        },
+        currencies: { [assetName]: asset.currency, [feeAsset.name]: feeAsset.currency },
+      }
+
+      if (tx.owner === address) {
+        // send transaction
+        item.to = Array.isArray(tx.to) ? undefined : tx.to
+        item.feeAmount = baseAsset.currency.baseUnit(tx.fee) // in SOL
+        item.feeCoinName = baseAsset.name
+        item.coinAmount = item.coinAmount.negate()
+
+        if (tx.data?.sent) {
+          item.data.sent = tx.data.sent.map((s) => ({
+            address: s.address,
+            amount: asset.currency.baseUnit(s.amount).toDefaultString({ unit: true }),
+          }))
+        }
+
+        if (tx.to === tx.owner) {
+          item.selfSend = true
+          item.coinAmount = asset.currency.ZERO
+        }
+      } else if (tx.unparsed) {
+        if (tx.fee !== 0) {
+          item.feeAmount = baseAsset.currency.baseUnit(tx.fee) // in SOL
+          item.feeCoinName = baseAsset.name
+        }
+
+        item.data.meta = tx.data.meta
+      }
+
+      if (asset.name !== asset.baseAsset.name && item.feeAmount && item.feeAmount.isPositive) {
+        const feeItem = {
+          ...lodash.clone(item),
+          coinName: feeAsset.name,
+          tokens: [asset.name],
+          coinAmount: feeAsset.currency.ZERO,
+        }
+        mappedTransactions.push(feeItem)
+      }
+
+      mappedTransactions.push(item)
+    }
+
+    const logItemsByAsset = lodash.groupBy(mappedTransactions, (item) => item.coinName)
+    return {
+      logItemsByAsset,
+      cursorState: transactions[0]?.id ? { cursor: transactions[0].id } : {},
+    }
+  }
+}