@exodus/solana-api 2.0.12 → 2.0.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/solana-api",
-  "version": "2.0.12",
+  "version": "2.0.14",
   "description": "Exodus internal Solana asset API wrapper",
   "main": "src/index.js",
   "files": [
@@ -14,13 +14,15 @@
   },
   "dependencies": {
     "@exodus/asset-json-rpc": "^1.0.0",
-    "@exodus/asset-lib": "^3.6.0",
+    "@exodus/asset-lib": "^3.6.2",
     "@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.14",
+    "@exodus/solana-lib": "^1.3.15",
     "bn.js": "^4.11.0",
+    "debug": "^4.1.1",
     "lodash": "^4.17.11",
     "url-join": "4.0.0",
     "wretch": "^1.5.2"
@@ -28,5 +30,5 @@
   "devDependencies": {
     "node-fetch": "~2.6.0"
   },
-  "gitHead": "41f7a0666330e4ab63c7d38247bbf2fb7f4267fb"
+  "gitHead": "16410d60f413eda6aeb3372c23875b98c20de06c"
 }

package/src/api.js

@@ -20,17 +20,21 @@ 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) {
+  constructor(rpcUrl, wsUrl) {
     this.setServer(rpcUrl)
+    this.setWsEndpoint(wsUrl)
     this.setTokens(assets)
     this.tokensToSkip = {}
+    this.connections = {}
   }
 
   setServer(rpcUrl) {
@@ -38,6 +42,10 @@ 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)
@@ -49,76 +57,103 @@ 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.api.post({
-      method: 'getEpochInfo',
-    })
+    const { epoch } = await this.rpcCall('getEpochInfo')
     return Number(epoch)
   }
 
   async getStakeActivation(address): string {
-    const { state } = await this.api.post({
-      method: 'getStakeActivation',
-      params: [address],
-    })
+    const { state } = await this.rpcCall('getStakeActivation', [address])
     return state
   }
 
   async getRecentBlockHash(): string {
-    const {
-      value: { blockhash },
-    } = await this.api.post({
-      method: 'getRecentBlockhash',
-    })
-    return blockhash
+    const result = await this.rpcCall(
+      'getRecentBlockhash',
+      [{ commitment: 'finalized', encoding: 'jsonParsed' }],
+      { forceHttp: true }
+    )
+    return lodash.get(result, 'value.blockhash')
   }
 
   // Transaction structure: https://docs.solana.com/apps/jsonrpc-api#transaction-structure
   async getTransactionById(id: string) {
-    const result = await this.api.post({
-      method: 'getConfirmedTransaction',
-      params: [id, 'jsonParsed'],
-    })
-    return result
+    return this.rpcCall('getTransaction', [
+      id,
+      { encoding: 'jsonParsed', maxSupportedTransactionVersion: 0 },
+    ])
   }
 
   async getFee(): number {
-    const {
-      value: {
-        feeCalculator: { lamportsPerSignature },
-      },
-    } = await this.api.post({
-      method: 'getRecentBlockhash',
-    })
-    return lamportsPerSignature
+    const result = await this.rpcCall('getRecentBlockhash', [
+      { commitment: 'finalized', encoding: 'jsonParsed' },
+    ])
+    return lodash.get(result, 'value.feeCalculator.lamportsPerSignature')
   }
 
   async getBalance(address: string): number {
-    const res = await this.api.post({
-      method: 'getBalance',
-      params: [address],
+    const result = await this.rpcCall('getBalance', [address, { encoding: 'jsonParsed' }], {
+      address,
     })
-    return res.value || 0
+    return lodash.get(result, '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.api.post({
-      method: 'getBlockTime',
-      params: [slot],
-    })
+    return this.rpcCall('getBlockTime', [slot])
   }
 
   async getConfirmedSignaturesForAddress(address: string, { until, before, limit } = {}): any {
     until = until || undefined
-    return this.api.post({
-      method: 'getSignaturesForAddress',
-      params: [address, { until, before, limit }],
-    })
+    return this.rpcCall('getSignaturesForAddress', [address, { until, before, limit }], { address })
   }
 
   /**
@@ -221,7 +256,8 @@ export class Api {
 
       return {
         unparsed: true,
-        amount: postBalances[ownerIndex] - preBalances[ownerIndex] + feePaid,
+        amount:
+          ownerIndex === -1 ? 0 : postBalances[ownerIndex] - preBalances[ownerIndex] + feePaid,
         fee: feePaid,
         data: {
           meta: txDetails.meta,
@@ -524,13 +560,8 @@ export class Api {
   }
 
   async getSupply(mintAddress: string): string {
-    const {
-      value: { amount },
-    } = await this.api.post({
-      method: 'getTokenSupply',
-      params: [mintAddress],
-    })
-    return amount
+    const result = await this.rpcCall('getTokenSupply', [mintAddress])
+    return lodash.get(result, 'value.amount')
   }
 
   async getWalletTokensList({ tokenAccounts }) {
@@ -556,10 +587,11 @@ export class Api {
   }
 
   async getTokenAccountsByOwner(address: string, tokenTicker: ?string): Array {
-    const { value: accountsList } = await this.api.post({
-      method: 'getTokenAccountsByOwner',
-      params: [address, { programId: TOKEN_PROGRAM_ID.toBase58() }, { encoding: 'jsonParsed' }],
-    })
+    const { value: accountsList } = await this.rpcCall(
+      'getTokenAccountsByOwner',
+      [address, { programId: TOKEN_PROGRAM_ID.toBase58() }, { encoding: 'jsonParsed' }],
+      { address }
+    )
 
     const tokenAccounts = []
     for (let entry of accountsList) {
@@ -604,10 +636,7 @@ export class Api {
   async isAssociatedTokenAccountActive(tokenAddress: string) {
     // Returns the token balance of an SPL Token account.
     try {
-      await this.api.post({
-        method: 'getTokenAccountBalance',
-        params: [tokenAddress],
-      })
+      await this.rpcCall('getTokenAccountBalance', [tokenAddress])
       return true
     } catch (e) {
       return false
@@ -616,21 +645,16 @@ export class Api {
 
   // Returns account balance of a SPL Token account.
   async getTokenBalance(tokenAddress: string) {
-    const {
-      value: { amount },
-    } = await this.api.post({
-      method: 'getTokenAccountBalance',
-      params: [tokenAddress],
-    })
-
-    return amount
+    const result = await this.rpcCall('getTokenAccountBalance', [tokenAddress])
+    return lodash.get(result, 'value.amount')
   }
 
   async getAccountInfo(address: string) {
-    const { value } = await this.api.post({
-      method: 'getAccountInfo',
-      params: [address, { encoding: 'jsonParsed', commitment: 'single' }],
-    })
+    const { value } = await this.rpcCall(
+      'getAccountInfo',
+      [address, { encoding: 'jsonParsed', commitment: 'single' }],
+      { address }
+    )
     return value
   }
 
@@ -649,8 +673,8 @@ export class Api {
   }
 
   async getDecimals(tokenMintAddress: string) {
-    const res = await this.api.post({ method: 'getTokenSupply', params: [tokenMintAddress] })
-    return lodash.get(res, 'value.decimals', null)
+    const result = await this.rpcCall('getTokenSupply', [tokenMintAddress])
+    return lodash.get(result, 'value.decimals', null)
   }
 
   async getAddressType(address: string) {
@@ -694,24 +718,22 @@ export class Api {
   }
 
   async getStakeAccountsInfo(address: string) {
-    // 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,
-              },
+    const params = [
+      STAKE_PROGRAM_ID.toBase58(),
+      {
+        filters: [
+          {
+            memcmp: {
+              offset: 12,
+              bytes: address,
             },
-          ],
-          encoding: 'jsonParsed',
-        },
-      ],
-    })
+          },
+        ],
+        encoding: 'jsonParsed',
+      },
+    ]
+    const res = await this.rpcCall('getProgramAccounts', params, { address })
+
     const accounts = {}
     let totalStake = 0
     let locked = 0
@@ -760,29 +782,15 @@ export class Api {
   }
 
   async getMinimumBalanceForRentExemption(size: number) {
-    const minimumBalance = await this.api.post({
-      method: 'getMinimumBalanceForRentExemption',
-      params: [size],
-    })
-
-    return minimumBalance
+    return this.rpcCall('getMinimumBalanceForRentExemption', [size])
   }
 
   async getProgramAccounts(programId: string, config) {
-    const response = await this.api.post({
-      method: 'getProgramAccounts',
-      params: [programId, config],
-    })
-
-    return response
+    return this.rpcCall('getProgramAccounts', [programId, config])
   }
 
   async getMultipleAccounts(pubkeys: string[], config) {
-    const response = await this.api.post({
-      method: 'getMultipleAccounts',
-      params: [pubkeys, config],
-    })
-
+    const response = await this.rpcCall('getMultipleAccounts', [pubkeys, config])
     return response && response.value ? response.value : []
   }
 
@@ -792,10 +800,8 @@ export class Api {
   broadcastTransaction = async (signedTx: string): string => {
     console.log('Solana broadcasting TX:', signedTx) // base64
 
-    const result = await this.api.post({
-      method: 'sendTransaction',
-      params: [signedTx, { encoding: 'base64', commitment: 'singleGossip' }],
-    })
+    const params = [signedTx, { encoding: 'base64', commitment: 'finalized' }]
+    const result = await this.rpcCall('sendTransaction', params, { forceHttp: true })
 
     console.log(`tx ${JSON.stringify(result)} sent!`)
     return result || null
@@ -804,10 +810,7 @@ export class Api {
   simulateTransaction = async (encodedTransaction, options) => {
     const {
       value: { accounts },
-    } = await this.api.post({
-      method: 'simulateTransaction',
-      params: [encodedTransaction, options],
-    })
+    } = await this.rpcCall('simulateTransaction', [encodedTransaction, options])
 
     return accounts
   }

package/src/connection.js

@@ -0,0 +1,237 @@
+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

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

@@ -4,7 +4,11 @@ import assert from 'minimalistic-assert'
 
 const DEFAULT_POOL_ADDRESS = '9QU2QSxhb24FUX3Tu2FpczXjpK3VYrvRudywSZaM29mF' // Everstake
 
-const DEFAULT_REMOTE_CONFIG = { rpcs: [], staking: { enabled: true, pool: DEFAULT_POOL_ADDRESS } }
+const DEFAULT_REMOTE_CONFIG = {
+  rpcs: [],
+  ws: [],
+  staking: { enabled: true, pool: DEFAULT_POOL_ADDRESS },
+}
 
 export class SolanaMonitor extends BaseMonitor {
   constructor({ api, includeUnparsed = false, ...args }) {
@@ -14,11 +18,45 @@ 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, staking = {} } = { ...DEFAULT_REMOTE_CONFIG, ...config }
+    const { rpcs, ws, staking = {} } = { ...DEFAULT_REMOTE_CONFIG, ...config }
     this.api.setServer(rpcs[0])
+    this.api.setWsEndpoint(ws[0])
     this.staking = staking
   }
 
@@ -35,6 +73,9 @@ 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)