@exodus/solana-api 1.0.1 → 1.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/solana-api",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "Exodus internal Solana asset API wrapper",
   "main": "src/index.js",
   "files": [
@@ -13,12 +13,8 @@
     "access": "restricted"
   },
   "dependencies": {
-    "fetchival": "~0.3.2",
-    "lodash": "^4.17.11",
-    "ms": "~0.7.1"
+    "@exodus/solana-web3.js": "0.87.1-exodus1",
+    "lodash": "^4.17.11"
   },
-  "devDependencies": {
-    "node-fetch": "~1.6.3"
-  },
-  "gitHead": "7afc2c44aff00085db4d14b7696a3fc88f165628"
+  "gitHead": "f18544ae45db87c7efec7d8139e1e04c51e0fc32"
 }

package/src/index.js

@@ -1,8 +1,7 @@
 // @flow
-import ms from 'ms'
-import fetchival from 'fetchival'
+import { Connection, PublicKey } from '@exodus/solana-web3.js'
 
-// Doc: https://docs.solana.com/apps/jsonrpc-api
+// Doc: https://solana-labs.github.io/solana-web3.js/
 
 const RPC_URL = 'https://api.mainnet-beta.solana.com' // https://solana-api.projectserum.com
 
@@ -13,111 +12,41 @@ class Api {
 
   setServer(rpcUrl) {
     this.rpcUrl = rpcUrl || RPC_URL
+    this.connection = new Connection(this.rpcUrl)
   }
 
-  request(path) {
-    return fetchival(this.rpcUrl, {
-      timeout: ms('15s'),
-      headers: { 'Content-Type': 'application/json' },
-    })(path)
-  }
-
-  async getRecentBlockHash() {
-    try {
-      const { result, error } = await this.request('').post({
-        jsonrpc: '2.0',
-        id: getCurrentTime(),
-        method: 'getRecentBlockhash',
-        params: [],
-      })
-      if (error) throw new Error(error.message)
-      return result.value.blockhash
-    } catch (err) {
-      console.log(err)
-      throw new Error(JSON.stringify(await concatStream(err.response)))
-    }
+  async getRecentBlockHash(): string {
+    const { blockhash } = await this.connection.getRecentBlockhash()
+    return blockhash
   }
 
   // Transaction structure: https://docs.solana.com/apps/jsonrpc-api#transaction-structure
   async getTransactionById(id: string) {
-    try {
-      const { result, error } = await this.request('').post({
-        jsonrpc: '2.0',
-        id: getCurrentTime(),
-        method: 'getConfirmedTransaction',
-        params: [id, 'json'],
-      })
-      if (error) throw new Error(error.message)
-      return result
-    } catch (err) {
-      console.log(err)
-      throw new Error(JSON.stringify(await concatStream(err.response)))
-    }
+    return this.connection.getConfirmedTransaction(id)
   }
 
   async getFee(): number {
-    try {
-      const { result, error } = await this.request('').post({
-        jsonrpc: '2.0',
-        id: getCurrentTime(),
-        method: 'getFees',
-        params: [],
-      })
-      if (error) throw new Error(error.message)
-      return result.value.feeCalculator.lamportsPerSignature
-    } catch (err) {
-      throw new Error(JSON.stringify(await concatStream(err.response)))
-    }
+    const {
+      feeCalculator: { lamportsPerSignature },
+    } = await this.connection.getRecentBlockhash()
+    return lamportsPerSignature
   }
 
   async getBalance(address: string): number {
-    try {
-      const { result, error } = await this.request('').post({
-        jsonrpc: '2.0',
-        id: getCurrentTime(),
-        method: 'getBalance',
-        params: [address],
-      })
-      if (error) throw new Error(error.message)
-      return result.value || 0
-    } catch (err) {
-      console.log(err)
-      throw new Error(JSON.stringify(await concatStream(err.response)))
-    }
+    return this.connection.getBalance(new PublicKey(address))
   }
 
-  async getBlockTime(slot: number): any {
-    try {
-      const { result, error } = await this.request('').post({
-        jsonrpc: '2.0',
-        id: getCurrentTime(),
-        method: 'getBlockTime',
-        params: [slot],
-      })
-      // might result in error if executed on a validator with partial ledger (https://github.com/solana-labs/solana/issues/12413)
-      if (error) console.log(error.message)
-      return result
-    } catch (err) {
-      console.log(err)
-      throw new Error(JSON.stringify(await concatStream(err.response)))
-    }
+  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)
   }
 
-  async getConfirmedSignaturesForAddress(address: string, { before, until, limit }): any {
-    try {
-      until = until || undefined
-      const { result, error } = await this.request('').post({
-        jsonrpc: '2.0',
-        id: getCurrentTime(),
-        method: 'getConfirmedSignaturesForAddress2',
-        params: [address, { before, until, limit }],
-      })
-      if (error) throw new Error(error.message)
-      return result
-    } catch (err) {
-      console.log(err)
-      throw new Error(JSON.stringify(await concatStream(err.response)))
-    }
+  async getConfirmedSignaturesForAddress(address: string, { before, until, limit } = {}): any {
+    return this.connection.getConfirmedSignaturesForAddress2(new PublicKey(address), {
+      before,
+      until,
+      limit,
+    })
   }
 
   /**
@@ -137,13 +66,15 @@ class Api {
 
       for (let tx of txsId) {
         // get tx details
-        const txDetails = await this.getTransactionById(tx.signature)
+        const [txDetails, blockTime] = await Promise.all([
+          this.getTransactionById(tx.signature),
+          this.getBlockTime(tx.slot),
+        ])
         if (txDetails === null) continue
 
-        const timestamp = (await this.getBlockTime(tx.slot)) * 1000
-
-        const from = txDetails.transaction.message.accountKeys[0]
-        const to = txDetails.transaction.message.accountKeys[1]
+        const timestamp = blockTime * 1000
+        const from = txDetails.transaction.keys[0].toString()
+        const to = txDetails.transaction.keys[1].toString()
         let { preBalances, postBalances, fee } = txDetails.meta
         const isSending = address === from
         fee = !isSending ? 0 : fee
@@ -161,17 +92,11 @@ class Api {
           from,
           to,
           amount, // lamports
-          error: !(txDetails.meta.status.Ok === null),
+          error: !(txDetails.meta.err === null),
         })
       }
     } catch (err) {
       console.warn('Solana error:', err)
-      if (err.response) {
-        const error = new Error(JSON.stringify(await concatStream(err.response)))
-        error.status = err.response.status
-        error.statusText = err.response.statusText
-        throw error
-      }
       throw err
     }
 
@@ -184,20 +109,10 @@ class Api {
    * Broadcast a signed transaction
    */
   broadcastTransaction = async (signedTx: string): string => {
-    console.log('Solana broadcasting TX:', signedTx)
-
-    const { result, error } = await this.request('')
-      .post({
-        jsonrpc: '2.0',
-        id: getCurrentTime(),
-        method: 'sendTransaction',
-        params: [signedTx],
-      })
-      .catch(async (err) => {
-        throw new Error(JSON.stringify(await concatStream(err.response)))
-      })
+    console.log('Solana broadcasting TX:', signedTx) // base64
 
-    if (error) throw new Error(error.message)
+    const { message, ...result } = await this.connection.sendEncodedTransaction(signedTx)
+    if (message) throw new Error(message)
 
     console.log(`tx ${result} sent!`)
     return result || null
@@ -205,37 +120,3 @@ class Api {
 }
 
 export default new Api()
-
-function getCurrentTime() {
-  const date = new Date()
-  return date.getTime()
-}
-
-function concatStream(response) {
-  const stream = response.body
-  if (typeof stream !== 'object')
-    throw new Error(`${response.status} - ${response.statusText || 'Server Error'}`)
-  if ('locked' in stream) {
-    // fetch browser
-    try {
-      return response.json()
-    } catch (e) {
-      return response.text()
-    }
-  }
-  return new Promise((resolve, reject) => {
-    let result = ''
-    stream.on('data', (chunk) => {
-      result += chunk.toString()
-    })
-    stream.on('end', () => {
-      try {
-        const parsed = JSON.parse(result)
-        resolve(parsed)
-      } catch (e) {
-        resolve(result) // plain text
-      }
-    })
-    stream.on('error', (err) => reject(err))
-  })
-}