@exodus/solana-api 2.0.13 → 2.0.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/solana-api",
-  "version": "2.0.13",
+  "version": "2.0.16",
   "description": "Exodus internal Solana asset API wrapper",
   "main": "src/index.js",
   "files": [
@@ -14,15 +14,13 @@
   },
   "dependencies": {
     "@exodus/asset-json-rpc": "^1.0.0",
-    "@exodus/asset-lib": "^3.6.2",
+    "@exodus/asset-lib": "^3.6.0",
     "@exodus/assets": "^8.0.71",
     "@exodus/assets-base": "^8.0.150",
-    "@exodus/fetch": "^1.2.0",
     "@exodus/models": "^8.7.2",
     "@exodus/nfts-core": "^0.5.0",
-    "@exodus/solana-lib": "^1.3.15",
+    "@exodus/solana-lib": "^1.3.14",
     "bn.js": "^4.11.0",
-    "debug": "^4.1.1",
     "lodash": "^4.17.11",
     "url-join": "4.0.0",
     "wretch": "^1.5.2"
@@ -30,5 +28,5 @@
   "devDependencies": {
     "node-fetch": "~2.6.0"
   },
-  "gitHead": "3c0551a25d29f31be43d522e742d5754cd7deb5f"
+  "gitHead": "9ec7084bcdfe14f1c6f11df393351885773046a6"
 }

package/src/api.js

@@ -20,21 +20,17 @@ import lodash from 'lodash'
 import urljoin from 'url-join'
 import wretch, { Wretcher } from 'wretch'
 import { magicEden } from '@exodus/nfts-core'
-import { Connection } from './connection'
 
 // Doc: https://docs.solana.com/apps/jsonrpc-api
 
 const RPC_URL = 'https://solana.a.exodus.io' // https://vip-api.mainnet-beta.solana.com/, https://api.mainnet-beta.solana.com, https://solana-api.projectserum.com
-const WS_ENDPOINT = 'wss://solana.a.exodus.io/ws'
 
 // Tokens + SOL api support
 export class Api {
-  constructor(rpcUrl, wsUrl) {
+  constructor(rpcUrl) {
     this.setServer(rpcUrl)
-    this.setWsEndpoint(wsUrl)
     this.setTokens(assets)
     this.tokensToSkip = {}
-    this.connections = {}
   }
 
   setServer(rpcUrl) {
@@ -42,10 +38,6 @@ export class Api {
     this.api = createApi(this.rpcUrl)
   }
 
-  setWsEndpoint(wsUrl) {
-    this.wsUrl = wsUrl || WS_ENDPOINT
-  }
-
   setTokens(assets = {}) {
     const solTokens = lodash.pickBy(assets, (asset) => asset.assetType === 'SOLANA_TOKEN')
     this.tokens = lodash.mapKeys(solTokens, (v) => v.mintAddress)
@@ -57,100 +49,76 @@ export class Api {
     })
   }
 
-  async watchAddress({
-    address,
-    tokensAddresses = [],
-    handleAccounts,
-    handleTransfers,
-    handleReconnect,
-    reconnectDelay,
-  }) {
-    const conn = new Connection({
-      endpoint: this.wsUrl,
-      address,
-      tokensAddresses,
-      callback: (updates) =>
-        this.handleUpdates({ updates, address, handleAccounts, handleTransfers }),
-      reconnectCallback: handleReconnect,
-      reconnectDelay,
-    })
-
-    this.connections[address] = conn
-    return conn.start()
-  }
-
-  async unwatchAddress({ address }) {
-    if (this.connections[address]) {
-      await this.connections[address].stop()
-      delete this.connections[address]
-    }
-  }
-
-  async handleUpdates({ updates, address, handleAccounts, handleTransfers }) {
-    // console.log(`got ws updates from ${address}:`, updates)
-    if (handleTransfers) return handleTransfers(updates)
-  }
-
-  async rpcCall(method, params = [], { address = '', forceHttp = false } = {}) {
-    // ws request
-    const connection = this.connections[address] || lodash.sample(Object.values(this.connections)) // pick random connection
-    if (lodash.get(connection, 'isOpen') && !lodash.get(connection, 'shutdown') && !forceHttp) {
-      return connection.sendMessage(method, params)
-    }
-    // http fallback
-    return this.api.post({ method, params })
-  }
-
   isTokenSupported(mint: string) {
     return !!this.tokens[mint]
   }
 
   async getEpochInfo(): number {
-    const { epoch } = await this.rpcCall('getEpochInfo')
+    const { epoch } = await this.api.post({
+      method: 'getEpochInfo',
+    })
     return Number(epoch)
   }
 
   async getStakeActivation(address): string {
-    const { state } = await this.rpcCall('getStakeActivation', [address])
+    const { state } = await this.api.post({
+      method: 'getStakeActivation',
+      params: [address],
+    })
     return state
   }
 
   async getRecentBlockHash(): string {
-    const result = await this.rpcCall(
-      'getRecentBlockhash',
-      [{ commitment: 'finalized', encoding: 'jsonParsed' }],
-      { forceHttp: true }
-    )
-    return lodash.get(result, 'value.blockhash')
+    const {
+      value: { blockhash },
+    } = await this.api.post({
+      method: 'getRecentBlockhash',
+    })
+    return blockhash
   }
 
   // Transaction structure: https://docs.solana.com/apps/jsonrpc-api#transaction-structure
   async getTransactionById(id: string) {
-    return this.rpcCall('getConfirmedTransaction', [id, { encoding: 'jsonParsed' }])
+    const result = await this.api.post({
+      method: 'getTransaction',
+      params: [id, { encoding: 'jsonParsed', maxSupportedTransactionVersion: 0 }],
+    })
+    return result
   }
 
   async getFee(): number {
-    const result = await this.rpcCall('getRecentBlockhash', [
-      { commitment: 'finalized', encoding: 'jsonParsed' },
-    ])
-    return lodash.get(result, 'value.feeCalculator.lamportsPerSignature')
+    const {
+      value: {
+        feeCalculator: { lamportsPerSignature },
+      },
+    } = await this.api.post({
+      method: 'getRecentBlockhash',
+    })
+    return lamportsPerSignature
   }
 
   async getBalance(address: string): number {
-    const result = await this.rpcCall('getBalance', [address, { encoding: 'jsonParsed' }], {
-      address,
+    const res = await this.api.post({
+      method: 'getBalance',
+      params: [address],
     })
-    return lodash.get(result, 'value', 0)
+    return res.value || 0
   }
 
   async getBlockTime(slot: number) {
     // might result in error if executed on a validator with partial ledger (https://github.com/solana-labs/solana/issues/12413)
-    return this.rpcCall('getBlockTime', [slot])
+    return this.api.post({
+      method: 'getBlockTime',
+      params: [slot],
+    })
   }
 
   async getConfirmedSignaturesForAddress(address: string, { until, before, limit } = {}): any {
     until = until || undefined
-    return this.rpcCall('getSignaturesForAddress', [address, { until, before, limit }], { address })
+    return this.api.post({
+      method: 'getSignaturesForAddress',
+      params: [address, { until, before, limit }],
+    })
   }
 
   /**
@@ -557,8 +525,13 @@ export class Api {
   }
 
   async getSupply(mintAddress: string): string {
-    const result = await this.rpcCall('getTokenSupply', [mintAddress])
-    return lodash.get(result, 'value.amount')
+    const {
+      value: { amount },
+    } = await this.api.post({
+      method: 'getTokenSupply',
+      params: [mintAddress],
+    })
+    return amount
   }
 
   async getWalletTokensList({ tokenAccounts }) {
@@ -584,11 +557,10 @@ export class Api {
   }
 
   async getTokenAccountsByOwner(address: string, tokenTicker: ?string): Array {
-    const { value: accountsList } = await this.rpcCall(
-      'getTokenAccountsByOwner',
-      [address, { programId: TOKEN_PROGRAM_ID.toBase58() }, { encoding: 'jsonParsed' }],
-      { address }
-    )
+    const { value: accountsList } = await this.api.post({
+      method: 'getTokenAccountsByOwner',
+      params: [address, { programId: TOKEN_PROGRAM_ID.toBase58() }, { encoding: 'jsonParsed' }],
+    })
 
     const tokenAccounts = []
     for (let entry of accountsList) {
@@ -633,7 +605,10 @@ export class Api {
   async isAssociatedTokenAccountActive(tokenAddress: string) {
     // Returns the token balance of an SPL Token account.
     try {
-      await this.rpcCall('getTokenAccountBalance', [tokenAddress])
+      await this.api.post({
+        method: 'getTokenAccountBalance',
+        params: [tokenAddress],
+      })
       return true
     } catch (e) {
       return false
@@ -642,16 +617,21 @@ export class Api {
 
   // Returns account balance of a SPL Token account.
   async getTokenBalance(tokenAddress: string) {
-    const result = await this.rpcCall('getTokenAccountBalance', [tokenAddress])
-    return lodash.get(result, 'value.amount')
+    const {
+      value: { amount },
+    } = await this.api.post({
+      method: 'getTokenAccountBalance',
+      params: [tokenAddress],
+    })
+
+    return amount
   }
 
   async getAccountInfo(address: string) {
-    const { value } = await this.rpcCall(
-      'getAccountInfo',
-      [address, { encoding: 'jsonParsed', commitment: 'single' }],
-      { address }
-    )
+    const { value } = await this.api.post({
+      method: 'getAccountInfo',
+      params: [address, { encoding: 'jsonParsed', commitment: 'single' }],
+    })
     return value
   }
 
@@ -670,8 +650,8 @@ export class Api {
   }
 
   async getDecimals(tokenMintAddress: string) {
-    const result = await this.rpcCall('getTokenSupply', [tokenMintAddress])
-    return lodash.get(result, 'value.decimals', null)
+    const res = await this.api.post({ method: 'getTokenSupply', params: [tokenMintAddress] })
+    return lodash.get(res, 'value.decimals', null)
   }
 
   async getAddressType(address: string) {
@@ -715,22 +695,24 @@ export class Api {
   }
 
   async getStakeAccountsInfo(address: string) {
-    const params = [
-      STAKE_PROGRAM_ID.toBase58(),
-      {
-        filters: [
-          {
-            memcmp: {
-              offset: 12,
-              bytes: address,
+    // get staked amount and other info
+    const res = await this.api.post({
+      method: 'getProgramAccounts',
+      params: [
+        STAKE_PROGRAM_ID.toBase58(),
+        {
+          filters: [
+            {
+              memcmp: {
+                offset: 12,
+                bytes: address,
+              },
             },
-          },
-        ],
-        encoding: 'jsonParsed',
-      },
-    ]
-    const res = await this.rpcCall('getProgramAccounts', params, { address })
-
+          ],
+          encoding: 'jsonParsed',
+        },
+      ],
+    })
     const accounts = {}
     let totalStake = 0
     let locked = 0
@@ -779,15 +761,29 @@ export class Api {
   }
 
   async getMinimumBalanceForRentExemption(size: number) {
-    return this.rpcCall('getMinimumBalanceForRentExemption', [size])
+    const minimumBalance = await this.api.post({
+      method: 'getMinimumBalanceForRentExemption',
+      params: [size],
+    })
+
+    return minimumBalance
   }
 
   async getProgramAccounts(programId: string, config) {
-    return this.rpcCall('getProgramAccounts', [programId, config])
+    const response = await this.api.post({
+      method: 'getProgramAccounts',
+      params: [programId, config],
+    })
+
+    return response
   }
 
   async getMultipleAccounts(pubkeys: string[], config) {
-    const response = await this.rpcCall('getMultipleAccounts', [pubkeys, config])
+    const response = await this.api.post({
+      method: 'getMultipleAccounts',
+      params: [pubkeys, config],
+    })
+
     return response && response.value ? response.value : []
   }
 
@@ -797,8 +793,10 @@ export class Api {
   broadcastTransaction = async (signedTx: string): string => {
     console.log('Solana broadcasting TX:', signedTx) // base64
 
-    const params = [signedTx, { encoding: 'base64', commitment: 'finalized' }]
-    const result = await this.rpcCall('sendTransaction', params, { forceHttp: true })
+    const result = await this.api.post({
+      method: 'sendTransaction',
+      params: [signedTx, { encoding: 'base64', commitment: 'singleGossip' }],
+    })
 
     console.log(`tx ${JSON.stringify(result)} sent!`)
     return result || null
@@ -807,7 +805,10 @@ export class Api {
   simulateTransaction = async (encodedTransaction, options) => {
     const {
       value: { accounts },
-    } = await this.rpcCall('simulateTransaction', [encodedTransaction, options])
+    } = await this.api.post({
+      method: 'simulateTransaction',
+      params: [encodedTransaction, options],
+    })
 
     return accounts
   }

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

@@ -4,11 +4,7 @@ import assert from 'minimalistic-assert'
 
 const DEFAULT_POOL_ADDRESS = '9QU2QSxhb24FUX3Tu2FpczXjpK3VYrvRudywSZaM29mF' // Everstake
 
-const DEFAULT_REMOTE_CONFIG = {
-  rpcs: [],
-  ws: [],
-  staking: { enabled: true, pool: DEFAULT_POOL_ADDRESS },
-}
+const DEFAULT_REMOTE_CONFIG = { rpcs: [], staking: { enabled: true, pool: DEFAULT_POOL_ADDRESS } }
 
 export class SolanaMonitor extends BaseMonitor {
   constructor({ api, includeUnparsed = false, ...args }) {
@@ -18,45 +14,11 @@ export class SolanaMonitor extends BaseMonitor {
     this.cursors = {}
     this.assets = {}
     this.includeUnparsed = includeUnparsed
-    this.addHook('before-stop', (...args) => this.beforeStop(...args))
-  }
-
-  async beforeStop() {
-    const walletAccounts = await this.aci.getWalletAccounts({ assetName: this.asset.name })
-    return Promise.all(walletAccounts.map((walletAccount) => this.stopListener({ walletAccount })))
-  }
-
-  async initWalletAccount({ walletAccount }) {
-    if (this.tickCount[walletAccount] === 0) {
-      await this.startListener({ walletAccount })
-    }
-  }
-
-  async startListener({ walletAccount }) {
-    const address = await this.aci.getReceiveAddress({ assetName: this.asset.name, walletAccount })
-    return this.api.watchAddress({
-      address,
-      /*
-      // OPTIONAL. Relying on polling through ws
-      tokensAddresses: [], // needed for ASA subs
-      handleAccounts: (updates) => this.accountsCallback({ updates, walletAccount }),
-      handleTransfers: (txs) => {
-        // new SOL tx, ticking monitor
-        this.tick({ walletAccount }) // it will cause refresh for both sender/receiver. Without necessarily fetching the tx if it's not finalized in the node.
-      },
-      */
-    })
-  }
-
-  async stopListener({ walletAccount }) {
-    const address = await this.aci.getReceiveAddress({ assetName: this.asset.name, walletAccount })
-    return this.api.unwatchAddress({ address })
   }
 
   setServer(config = {}) {
-    const { rpcs, ws, staking = {} } = { ...DEFAULT_REMOTE_CONFIG, ...config }
+    const { rpcs, staking = {} } = { ...DEFAULT_REMOTE_CONFIG, ...config }
     this.api.setServer(rpcs[0])
-    this.api.setWsEndpoint(ws[0])
     this.staking = staking
   }
 
@@ -73,9 +35,6 @@ export class SolanaMonitor extends BaseMonitor {
   }
 
   async tick({ walletAccount, refresh }) {
-    // Check for new wallet account
-    await this.initWalletAccount({ walletAccount })
-
     const assetName = this.asset.name
     this.assets = await this.aci.getAssetsForNetwork({ baseAssetName: assetName })
     this.api.setTokens(this.assets)

package/src/connection.js

@@ -1,237 +0,0 @@
-import ms from 'ms'
-import delay from 'delay'
-import url from 'url'
-import lodash from 'lodash'
-import debugLogger from 'debug'
-import { WebSocket } from '@exodus/fetch'
-
-// WS subscriptions: https://docs.solana.com/developing/clients/jsonrpc-api#subscription-websocket
-
-const SOLANA_DEFAULT_ENDPOINT = 'wss://solana.a.exodus.io/ws'
-const DEFAULT_RECONNECT_DELAY = ms('15s')
-const PING_INTERVAL = ms('50s')
-const TIMEOUT = ms('20s')
-
-const debug = debugLogger('exodus:solana-api')
-
-export class Connection {
-  constructor({
-    endpoint = SOLANA_DEFAULT_ENDPOINT,
-    address,
-    tokensAddresses = [],
-    callback,
-    reconnectCallback = () => {},
-    reconnectDelay = DEFAULT_RECONNECT_DELAY,
-  }) {
-    this.address = address
-    this.tokensAddresses = tokensAddresses
-    this.endpoint = endpoint
-    this.callback = callback
-    this.reconnectCallback = reconnectCallback
-    this.reconnectDelay = reconnectDelay
-
-    this.shutdown = false
-    this.ws = null
-    this.rpcQueue = {}
-    this.messageQueue = []
-    this.inProcessMessages = false
-    this.pingTimeout = null
-    this.reconnectTimeout = null
-    this.txCache = {}
-  }
-
-  newSocket(reqUrl) {
-    // eslint-disable-next-line
-    const obj = url.parse(reqUrl)
-    obj.protocol = 'wss:'
-    reqUrl = url.format(obj)
-    debug('Opening WS to:', reqUrl)
-    const ws = new WebSocket(`${reqUrl}`)
-    ws.onmessage = this.onMessage.bind(this)
-    ws.onopen = this.onOpen.bind(this)
-    ws.onclose = this.onClose.bind(this)
-    ws.onerror = this.onError.bind(this)
-    return ws
-  }
-
-  get isConnecting() {
-    return !!(this.ws && this.ws.readyState === WebSocket.CONNECTING)
-  }
-
-  get isOpen() {
-    return !!(this.ws && this.ws.readyState === WebSocket.OPEN)
-  }
-
-  get isClosing() {
-    return !!(this.ws && this.ws.readyState === WebSocket.CLOSING)
-  }
-
-  get isClosed() {
-    return !!(!this.ws || this.ws.readyState === WebSocket.CLOSED)
-  }
-
-  get running() {
-    return !!(!this.isClosed || this.inProcessMessages || this.messageQueue.length)
-  }
-
-  get connectionState() {
-    if (this.isConnecting) return 'CONNECTING'
-    else if (this.isOpen) return 'OPEN'
-    else if (this.isClosing) return 'CLOSING'
-    else if (this.isClosed) return 'CLOSED'
-    return 'NONE'
-  }
-
-  doPing() {
-    if (this.ws) {
-      this.ws.ping()
-      this.pingTimeout = setTimeout(this.doPing.bind(this), PING_INTERVAL)
-    }
-  }
-
-  doRestart() {
-    // debug('Restarting WS:')
-    this.reconnectTimeout = setTimeout(async () => {
-      try {
-        debug('reconnecting ws...')
-        this.start()
-        await this.reconnectCallback()
-      } catch (e) {
-        console.log(`Error in reconnect callback: ${e.message}`)
-      }
-    }, this.reconnectDelay)
-  }
-
-  onMessage(evt) {
-    try {
-      const json = JSON.parse(evt.data)
-      debug('new ws msg:', json)
-      if (!json.error) {
-        if (lodash.get(this.rpcQueue, json.id)) {
-          // json-rpc reply
-          clearTimeout(this.rpcQueue[json.id].timeout)
-          this.rpcQueue[json.id].resolve(json.result)
-          delete this.rpcQueue[json.id]
-        } else if (json.method) {
-          const msg = { method: json.method, ...lodash.get(json, 'params.result', json.result) }
-          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)
-      debug('Cannot parse msg:', evt.data)
-    }
-  }
-
-  onOpen(evt) {
-    debug('Opened WS')
-    // subscribe to each addresses (SOL and ASA addr)
-
-    this.tokensAddresses.concat(this.address).forEach((address) => {
-      // sub for account state changes
-      this.ws.send(
-        JSON.stringify({
-          jsonrpc: '2.0',
-          method: 'accountSubscribe',
-          params: [
-            address,
-            {
-              encoding: 'jsonParsed',
-            },
-          ],
-          id: 1,
-        })
-      )
-      // sub for incoming/outcoming txs
-      this.ws.send(
-        JSON.stringify({
-          jsonrpc: '2.0',
-          method: 'logsSubscribe',
-          params: [{ mentions: [address] }, { commitment: 'finalized' }],
-          id: 2,
-        })
-      )
-    })
-    // this.doPing()
-  }
-
-  onError(evt) {
-    debug('Error on WS:', evt.data)
-  }
-
-  onClose(evt) {
-    debug('Closing WS')
-    clearTimeout(this.pingTimeout)
-    clearTimeout(this.reconnectTimeout)
-    if (!this.shutdown) {
-      this.doRestart()
-    }
-  }
-
-  async sendMessage(method, params = []) {
-    return new Promise((resolve, reject) => {
-      if (this.isClosed || this.shutdown) return reject(new Error('connection not started'))
-      const id = Math.floor(Math.random() * 1e7) + 1
-
-      this.rpcQueue[id] = { resolve, reject }
-      this.rpcQueue[id].timeout = setTimeout(() => {
-        delete this.rpcQueue[id]
-        reject(new Error('solana ws: reply timeout'))
-      }, TIMEOUT)
-      this.ws.send(JSON.stringify({ jsonrpc: '2.0', method, params, id }))
-    })
-  }
-
-  async processMessages() {
-    if (this.inProcessMessages) return null
-    this.inProcessMessages = true
-    try {
-      while (this.messageQueue.length) {
-        const items = this.messageQueue.splice(0, this.messageQueue.length)
-        await this.callback(items)
-      }
-    } catch (e) {
-      console.log(`Solana: error processing streams: ${e.message}`)
-    } finally {
-      this.inProcessMessages = false
-    }
-  }
-
-  async close() {
-    clearTimeout(this.reconnectTimeout)
-    clearTimeout(this.pingTimeout)
-    if (this.ws && (this.isConnecting || this.isOpen)) {
-      // this.ws.send(JSON.stringify({ method: 'close' }))
-      await delay(ms('1s')) // allow for the 'close' round-trip
-      await this.ws.close()
-      await this.ws.terminate()
-    }
-  }
-
-  async start() {
-    try {
-      if (!this.isClosed || this.shutdown) return
-      this.ws = this.newSocket(this.endpoint)
-    } catch (e) {
-      console.log('Solana: error starting WS:', e)
-      this.doRestart()
-    }
-  }
-
-  async stop() {
-    if (this.shutdown) return
-    this.shutdown = true
-    await this.close()
-    while (this.running) {
-      await delay(ms('1s'))
-    }
-  }
-} // Connection