@exodus/solana-api 2.0.16 → 2.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/solana-api",
-  "version": "2.0.16",
+  "version": "2.1.1",
   "description": "Exodus internal Solana asset API wrapper",
   "main": "src/index.js",
   "files": [
@@ -14,19 +14,25 @@
   },
   "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.4.1",
+    "@exodus/solana-web3.js": "1.31.0-exodus.3",
+    "@ungap/url-search-params": "^0.2.2",
+    "bignumber.js": "^9.0.1",
     "bn.js": "^4.11.0",
+    "debug": "^4.1.1",
     "lodash": "^4.17.11",
+    "tweetnacl": "^1.0.3",
     "url-join": "4.0.0",
     "wretch": "^1.5.2"
   },
   "devDependencies": {
     "node-fetch": "~2.6.0"
   },
-  "gitHead": "9ec7084bcdfe14f1c6f11df393351885773046a6"
+  "gitHead": "cafda9efb741487bae7db4c3187c8b69d3553151"
 }

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,107 @@ 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 })
+  }
+
+  getTokenByAddress(mint: string) {
+    return this.tokens[mint]
+  }
+
   isTokenSupported(mint: string) {
-    return !!this.tokens[mint]
+    return !!this.getTokenByAddress(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
+  async getRecentBlockHash(commitment?: string): Promise<string> {
+    const result = await this.rpcCall(
+      'getRecentBlockhash',
+      [{ commitment: 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: 'getTransaction',
-      params: [id, { encoding: 'jsonParsed', maxSupportedTransactionVersion: 0 }],
-    })
-    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
+  async getFee(): Promise<number> {
+    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 })
   }
 
   /**
@@ -525,13 +564,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,11 +590,12 @@ export class Api {
     return tokensMint
   }
 
-  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' }],
-    })
+  async getTokenAccountsByOwner(address: string, tokenTicker: ?string): Promise<Array> {
+    const { value: accountsList } = await this.rpcCall(
+      'getTokenAccountsByOwner',
+      [address, { programId: TOKEN_PROGRAM_ID.toBase58() }, { encoding: 'jsonParsed' }],
+      { address }
+    )
 
     const tokenAccounts = []
     for (let entry of accountsList) {
@@ -605,10 +640,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
@@ -617,21 +649,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
   }
 
@@ -650,8 +677,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) {
@@ -695,24 +722,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
@@ -761,29 +786,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 : []
   }
 
@@ -793,10 +804,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
@@ -805,10 +814,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/index.js

@@ -2,6 +2,7 @@ import { Api } from './api'
 export * from './api'
 export * from './tx-log'
 export * from './account-state'
+export * from './pay'
 
 // At some point we would like to exclude this export. Default export should be the whole asset "plugin" ready to be injected.
 // Clients should not call an specific server api directly.

package/src/pay/fetchTransaction.js

@@ -0,0 +1,139 @@
+// @flow
+import nacl from 'tweetnacl'
+import { fetchival } from '@exodus/fetch'
+import ms from 'ms'
+import { SystemInstruction, Transaction, PublicKey } from '@exodus/solana-web3.js'
+import api from '..'
+import BigNumber from 'bignumber.js'
+import {
+  TOKEN_PROGRAM_ID,
+  decodeTokenProgramInstruction,
+  SYSTEM_PROGRAM_ID,
+} from '@exodus/solana-lib'
+
+export class FetchTransactionError extends Error {
+  name = 'FetchTransactionError'
+}
+
+export class ParseTransactionError extends Error {
+  name = 'ParseTransactionError'
+}
+
+const isTransferCheckedInstruction = (decodedInstruction) =>
+  decodedInstruction.type === 'transferChecked'
+const isTransferInstruction = (decodedInstruction) => decodedInstruction.type === 'transfer'
+const isSplAccount = (account) =>
+  account && account.owner === 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA'
+
+export async function fetchTransaction({
+  account,
+  link,
+  commitment,
+}: {
+  account: string,
+  link: string | URL,
+  commitment?: string,
+}) {
+  const response = await fetchival(String(link), {
+    mode: 'cors',
+    cache: 'no-cache',
+    credentials: 'omit',
+    timeout: ms('10s'),
+    headers: {
+      Accept: 'application/json',
+      'Content-Type': 'application/json',
+    },
+  }).post({ account })
+  if (!response || !response.transaction) throw new FetchTransactionError('missing transaction')
+  const { transaction: txString } = response
+  if (typeof txString !== 'string') throw new FetchTransactionError('invalid transaction')
+  const transaction = Transaction.from(Buffer.from(txString, 'base64'))
+
+  const { signatures, feePayer, recentBlockhash } = transaction
+  if (signatures.length) {
+    if (!feePayer) throw new FetchTransactionError('missing fee payer')
+    if (!feePayer.equals(signatures[0].publicKey))
+      throw new FetchTransactionError('invalid fee payer')
+    if (!recentBlockhash) throw new FetchTransactionError('missing recent blockhash')
+
+    // A valid signature for everything except `account` must be provided.
+    const message = transaction.serializeMessage()
+    for (const { signature, publicKey } of signatures) {
+      if (signature) {
+        if (!nacl.sign.detached.verify(message, signature, publicKey.toBuffer()))
+          throw new FetchTransactionError('invalid signature')
+      } else if (publicKey.equals(new PublicKey(account))) {
+        // If the only signature expected is for `account`, ignore the recent blockhash in the transaction.
+        if (signatures.length === 1) {
+          transaction.recentBlockhash = await api.getRecentBlockHash(commitment)
+        }
+      } else {
+        throw new FetchTransactionError('missing signature')
+      }
+    }
+  } else {
+    // Ignore the fee payer and recent blockhash in the transaction and initialize them.
+    transaction.feePayer = account
+    transaction.recentBlockhash = await api.getRecentBlockHash(commitment)
+  }
+
+  return parseInstructions(transaction)
+}
+
+async function parseInstructions(transaction: Transaction) {
+  // Make a copy of the instructions we're going to mutate it.
+  const instructions = transaction.instructions.slice()
+
+  if (!instructions || !Array.isArray(instructions) || instructions.length !== 1)
+    throw new ParseTransactionError('Invalid transaction instructions')
+
+  // Transfer instruction must be the last instruction
+  const instruction = instructions.pop()
+  if (!instruction) throw new ParseTransactionError('missing transfer instruction')
+
+  const isTokenTransfer = instruction.programId.equals(TOKEN_PROGRAM_ID)
+  const isSolNativeTransfer = instruction.programId.equals(SYSTEM_PROGRAM_ID)
+
+  if (isTokenTransfer) {
+    const decodedInstruction = decodeTokenProgramInstruction(instruction)
+    if (
+      !isTransferCheckedInstruction(decodedInstruction) &&
+      !isTransferInstruction(decodedInstruction)
+    )
+      throw new ParseTransactionError('invalid token transfer')
+
+    const [, mint, destination, owner] = instruction.keys
+
+    const splToken = mint.pubkey.toBase58()
+    let asset
+    let recipient = destination.pubkey.toBase58()
+    if (splToken) {
+      if (!api.isTokenSupported(splToken))
+        throw new ParseTransactionError(`spl-token ${splToken} is not supported`)
+      asset = api.getTokenByAddress(splToken)
+
+      const account = await api.getAccountInfo(recipient)
+      if (isSplAccount(account)) recipient = account.data.parsed.info.owner
+    }
+
+    return {
+      amount: asset.currency
+        .baseUnit(new BigNumber(decodedInstruction.data.amount).toString())
+        .toDefaultString(),
+      decimals: decodedInstruction.data.decimals,
+      recipient,
+      sender: owner.pubkey.toBase58(),
+      splToken,
+      asset,
+    }
+  } else if (isSolNativeTransfer) {
+    const decodedTransaction = SystemInstruction.decodeTransfer(instruction)
+    return {
+      sender: decodedTransaction.fromPubkey.toString(),
+      amount: decodedTransaction.lamports.toString(),
+      recipient: decodedTransaction.toPubkey.toString(),
+    }
+  }
+
+  throw new Error('Invalid transfer instruction')
+}

package/src/pay/index.js

@@ -0,0 +1,4 @@
+export * from './parseURL.js'
+export * from './prepareSendData.js'
+export * from './validateBeforePay'
+export * from './fetchTransaction'

package/src/pay/parseURL.js

@@ -0,0 +1,117 @@
+// @flow
+import { PublicKey } from '@exodus/solana-lib'
+import BigNumber from 'bignumber.js'
+import assets from '@exodus/assets'
+import URLSearchParams from '@ungap/url-search-params'
+import api from '..'
+
+const SOLANA_PROTOCOL = 'solana:'
+const HTTPS_PROTOCOL = 'https:'
+
+export class ParseURLError extends Error {
+  name = 'ParseURLError'
+}
+
+export type TransactionRequestURL = {
+  link: URL,
+  label?: string,
+  message?: string,
+}
+
+export type TransferRequestURL = {
+  recipient: string,
+  reference?: Array<string>,
+  amount?: string,
+  splToken?: string,
+  message?: string,
+  memo?: string,
+}
+
+export type ParsedURL = TransactionRequestURL | TransferRequestURL
+
+export function parseURL(url: string | URL): ParsedURL {
+  if (typeof url === 'string') {
+    if (url.length > 2048) throw new ParseURLError('length invalid')
+    url = new URL(url)
+  }
+  if (url.protocol !== SOLANA_PROTOCOL) throw new ParseURLError('protocol invalid')
+  if (!url.pathname) throw new ParseURLError('pathname missing')
+  return /[:%]/.test(url.pathname) ? parseTransactionRequestURL(url) : parseTransferRequestURL(url)
+}
+
+function parseTransactionRequestURL(url: URL): TransactionRequestURL {
+  const link = new URL(decodeURIComponent(url.pathname))
+  const searchParams = new URLSearchParams(url.search)
+  if (link.protocol !== HTTPS_PROTOCOL) throw new ParseURLError('link invalid')
+
+  const label = searchParams.get('label') || undefined
+  const message = searchParams.get('message') || undefined
+
+  return {
+    link,
+    label,
+    message,
+  }
+}
+
+function parseTransferRequestURL(url: URL): TransferRequestURL {
+  let recipient: PublicKey
+  try {
+    recipient = new PublicKey(url.pathname)
+  } catch (error) {
+    throw new Error('ParseURLError: recipient invalid')
+  }
+
+  const searchParams = new URLSearchParams(url.search)
+
+  let amount: BigNumber
+  const amountParam = searchParams.get('amount')
+  if (amountParam) {
+    if (!/^\d+(\.\d+)?$/.test(amountParam)) throw new Error('ParseURLError: amount invalid')
+    amount = new BigNumber(amountParam)
+    if (amount.isNaN()) throw new Error('ParseURLError: amount NaN')
+    if (amount.isNegative()) throw new Error('ParseURLError: amount negative')
+  }
+
+  let splToken: PublicKey
+  const splTokenParam = searchParams.get('spl-token')
+  if (splTokenParam) {
+    try {
+      splToken = new PublicKey(splTokenParam)
+    } catch (error) {
+      throw new ParseURLError('spl-token invalid')
+    }
+  }
+
+  let asset = assets.solana
+  if (splToken) {
+    if (!api.isTokenSupported(splToken))
+      throw new ParseURLError(`spl-token ${splToken} is not supported`)
+    asset = api.getTokenByAddress(splToken)
+  }
+
+  let reference: PublicKey[]
+  const referenceParams = searchParams.getAll('reference')
+  if (referenceParams.length) {
+    try {
+      reference = referenceParams.map((reference) => new PublicKey(reference))
+    } catch (error) {
+      throw new ParseURLError('reference invalid')
+    }
+  }
+
+  const label = searchParams.get('label') || undefined
+  const message = searchParams.get('message') || undefined
+  const memo = searchParams.get('memo') || undefined
+
+  return {
+    asset,
+    recipient: recipient.toString(),
+    amount: amount ? amount.toString(10) : undefined,
+    splToken: splToken ? splToken.toString() : undefined,
+    reference,
+    label,
+    message,
+    memo,
+  }
+}

package/src/pay/prepareSendData.js

@@ -0,0 +1,26 @@
+// @flow
+import assert from 'assert'
+
+import type { ParsedURL } from './parseURL'
+
+export function prepareSendData(parsedData: ParsedURL, { asset, feeAmount, walletAccount }) {
+  const { amount: amountStr, recipient, splToken, ...options } = parsedData
+
+  assert(amountStr, 'PrepareTxError: Missing amount')
+  assert(recipient, 'PrepareTxError: Missing recipient')
+
+  const amount = asset.currency.defaultUnit(amountStr)
+
+  return {
+    asset: asset.name,
+    baseAsset: asset.baseAsset,
+    customMintAddress: splToken,
+    feeAmount,
+    receiver: {
+      address: recipient,
+      amount,
+    },
+    walletAccount,
+    ...options,
+  }
+}

package/src/pay/validateBeforePay.js

@@ -0,0 +1,37 @@
+// @flow
+import api from '..'
+import NumberUnit from '@exodus/currency'
+
+export class ValidateError extends Error {
+  name = 'ValidateError'
+}
+
+type PaymentRequest = {
+  asset: Object,
+  senderInfo: Object,
+  feeAmount: NumberUnit,
+  recipient: string,
+  amount: number,
+  checkEnoughBalance?: boolean,
+}
+
+export async function validateBeforePay({
+  asset,
+  senderInfo,
+  amount,
+  feeAmount = 0,
+  recipient,
+  checkEnoughBalance = true,
+}: PaymentRequest) {
+  const isNative = asset.name === asset.baseAsset.name
+  const recipientInfo = await api.getAccountInfo(recipient)
+  if (!recipientInfo) throw new ValidateError(`recipient ${recipient} not found`)
+
+  if (checkEnoughBalance) {
+    const totalAmountMustPay = asset.currency.defaultUnit(amount).add(feeAmount)
+    const currentBalance = isNative ? senderInfo.balance : senderInfo.tokenBalances[asset.name]
+    if (totalAmountMustPay.gt(currentBalance)) throw new ValidateError(`insufficient funds`)
+  }
+
+  return true
+}

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)