@exodus/solana-api 1.2.3 → 1.2.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/solana-api",
-  "version": "1.2.3",
+  "version": "1.2.5",
   "description": "Exodus internal Solana asset API wrapper",
   "main": "src/index.js",
   "files": [
@@ -13,9 +13,13 @@
     "access": "restricted"
   },
   "dependencies": {
-    "@exodus/solana-lib": "^1.2.3",
-    "@exodus/solana-web3.js": "^0.87.1-exodus4",
-    "lodash": "^4.17.11"
+    "@exodus/asset-json-rpc": "^1.0.0",
+    "@exodus/solana-lib": "^1.2.5",
+    "lodash": "^4.17.11",
+    "wretch": "^1.5.2"
   },
-  "gitHead": "5be453e5b6c47cf82b8c80a83e8a4bebbb487a2e"
+  "devDependencies": {
+    "node-fetch": "~1.6.3"
+  },
+  "gitHead": "791e305a718246460d5ac93ed2eb7808955c0f5d"
 }

package/src/index.js

@@ -1,12 +1,12 @@
 // @flow
-import { Connection, PublicKey } from '@exodus/solana-web3.js'
+import createApi from '@exodus/asset-json-rpc'
 import { tokens, SYSTEM_PROGRAM_ID, TOKEN_PROGRAM_ID } from '@exodus/solana-lib'
 import assert from 'assert'
 import lodash from 'lodash'
 
-// Doc: https://solana-labs.github.io/solana-web3.js/
+// Doc: https://docs.solana.com/apps/jsonrpc-api
 
-const RPC_URL = 'https://api.mainnet-beta.solana.com' // https://solana-api.projectserum.com
+const RPC_URL = 'https://vip-api.mainnet-beta.solana.com/' // https://api.mainnet-beta.solana.com, https://solana-api.projectserum.com
 
 // Tokens + SOL api support
 class Api {
@@ -16,70 +16,91 @@ class Api {
 
   setServer(rpcUrl) {
     this.rpcUrl = rpcUrl || RPC_URL
-    this.connection = new Connection(this.rpcUrl)
+    this.api = createApi(this.rpcUrl)
   }
 
   async getRecentBlockHash(): string {
-    const { blockhash } = await this.connection.getRecentBlockhash()
+    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) {
-    const { result } = await this.connection._rpcRequest('getConfirmedTransaction', [
-      id,
-      'jsonParsed',
-    ])
+    const result = await this.api.post({
+      method: 'getConfirmedTransaction',
+      params: [id, 'jsonParsed'],
+    })
     return result
   }
 
   async getFee(): number {
     const {
-      feeCalculator: { lamportsPerSignature },
-    } = await this.connection.getRecentBlockhash()
+      value: {
+        feeCalculator: { lamportsPerSignature },
+      },
+    } = await this.api.post({
+      method: 'getRecentBlockhash',
+    })
     return lamportsPerSignature
   }
 
   async getBalance(address: string): number {
-    return this.connection.getBalance(new PublicKey(address))
+    const res = await this.api.post({
+      method: 'getBalance',
+      params: [address],
+    })
+    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.connection.getBlockTime(slot)
+    return this.api.post({
+      method: 'getBlockTime',
+      params: [slot],
+    })
   }
 
   async getConfirmedSignaturesForAddress(address: string, { until, before, limit } = {}): any {
     until = until || undefined
-    return this.connection.getConfirmedSignaturesForAddress2(new PublicKey(address), {
-      until,
-      before,
-      limit,
+    return this.api.post({
+      method: 'getConfirmedSignaturesForAddress2',
+      params: [address, { until, before, limit }],
     })
   }
 
   /**
    * Get transactions from an address
    */
-  async getTransactions(address: string, { cursor, before, limit, tokenTicker } = {}): any {
+  async getTransactions(address: string, { cursor, before, limit } = {}): any {
     let transactions = []
     // cursor is a txHash
 
     try {
       let until = cursor
 
-      const txsId = await this.getConfirmedSignaturesForAddress(address, {
-        until,
-        before,
-        limit,
-      })
-
-      let tokenAccountsByOwner // Array
-      if (txsId.length) tokenAccountsByOwner = await this.getTokenAccountsByOwner(address)
-
-      if (tokenTicker) {
-        // TODO: eventually filter txs by token ticker (is it done at monitor level?)
-      }
+      const tokenAccountsByOwner = await this.getTokenAccountsByOwner(address) // Array
+      const tokenAccountAddresses = tokenAccountsByOwner
+        .filter(({ tokenName }) => tokenName !== 'unknown')
+        .map(({ tokenAccountAddress }) => tokenAccountAddress)
+      const accountsToCheck = [address, ...tokenAccountAddresses]
+
+      console.log('accountsToCheck::', accountsToCheck)
+
+      const txsResultsByAccount = await Promise.all(
+        accountsToCheck.map((addr) =>
+          this.getConfirmedSignaturesForAddress(addr, {
+            until,
+            before,
+            limit,
+          })
+        )
+      )
+      let txsId = txsResultsByAccount.reduce((arr, row) => arr.concat(row), []) // merge arrays
+      txsId = lodash.uniqBy(txsId, 'signature')
 
       for (let tx of txsId) {
         // get tx details
@@ -101,6 +122,8 @@ class Api {
       throw err
     }
 
+    transactions = lodash.orderBy(transactions, ['timestamp'], ['desc'])
+
     const newCursor = transactions[0] ? transactions[0].id : cursor
 
     return { transactions, newCursor }
@@ -134,6 +157,7 @@ class Api {
       // Solana tx
       const isSending = ownerAddress === solanaTx.source
       tx = {
+        owner: solanaTx.source,
         from: solanaTx.source,
         to: solanaTx.destination,
         amount: solanaTx.lamports, // number
@@ -156,10 +180,12 @@ class Api {
               tokenAccountAddress: ix.destination,
             }) // receiving
           if (!tokenAccount) return null // no transfers with our addresses involved
+          const owner = isSending ? ownerAddress : null
+
           delete tokenAccount.balance
           delete tokenAccount.owner
-
           return {
+            owner,
             token: tokenAccount,
             from: ix.source,
             to: ix.destination,
@@ -167,6 +193,7 @@ class Api {
             fee: isSending ? fee : 0, // in lamports
           }
         })
+
       // .reduce to sum/sub (based on isSending) all the same tokens amount (From instructions -> 1 single tx)
       tx = tokenTxs.reduce((finalTx, ix) => {
         if (!ix) return finalTx // skip null instructions
@@ -191,13 +218,10 @@ class Api {
   }
 
   async getTokenAccountsByOwner(address: string, tokenTicker: ?string): Array {
-    const {
-      result: { value: accountsList },
-    } = await this.connection._rpcRequest('getTokenAccountsByOwner', [
-      address,
-      { programId: TOKEN_PROGRAM_ID.toBase58() },
-      { encoding: 'jsonParsed' },
-    ])
+    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) {
@@ -223,13 +247,51 @@ class Api {
       : tokenAccounts
   }
 
+  async getTokensBalance(address: string) {
+    let accounts = await this.getTokenAccountsByOwner(address) // Tokens
+
+    const tokensBalance = accounts.reduce((acc, { tokenName, balance }) => {
+      if (tokenName === 'unknown') return acc // filter by supported tokens only
+      if (!acc[tokenName]) acc[tokenName] = Number(balance)
+      // e.g { 'serum': 123 }
+      else acc[tokenName] += Number(balance) // merge same token account balance
+      return acc
+    }, {})
+
+    return tokensBalance
+  }
+
+  async isAssociatedTokenAccountActive(tokenAddress: string) {
+    // Returns the token balance of an SPL Token account.
+    try {
+      await this.api.post({
+        method: 'getTokenAccountBalance',
+        params: [tokenAddress],
+      })
+      return true
+    } catch (e) {
+      return false
+    }
+  }
+
   async getAddressType(address: string) {
     // solana, token or null (unknown), meaning address has never been initialized
-    const account = await this.connection.getAccountInfo(new PublicKey(address))
-    if (account === null) return null
-    return account.owner.equals(SYSTEM_PROGRAM_ID)
+    const { value } = await this.api.post({
+      method: 'getAccountInfo',
+      params: [address, { encoding: 'base64' }],
+    })
+    if (value === null) return null
+
+    const account = {
+      executable: value.executable,
+      owner: value.owner,
+      lamports: value.lamports,
+      data: value.data,
+    }
+
+    return account.owner === SYSTEM_PROGRAM_ID.toBase58()
       ? 'solana'
-      : account.owner.equals(TOKEN_PROGRAM_ID)
+      : account.owner === TOKEN_PROGRAM_ID.toBase58()
       ? 'token'
       : null
   }
@@ -250,10 +312,12 @@ class Api {
   broadcastTransaction = async (signedTx: string): string => {
     console.log('Solana broadcasting TX:', signedTx) // base64
 
-    const { message, ...result } = await this.connection.sendEncodedTransaction(signedTx)
-    if (message) throw new Error(message)
+    const result = await this.api.post({
+      method: 'sendTransaction',
+      params: [signedTx, { encoding: 'base64' }],
+    })
 
-    console.log(`tx ${result} sent!`)
+    console.log(`tx ${JSON.stringify(result)} sent!`)
     return result || null
   }
 }