@exodus/solana-api 1.2.0 → 1.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/solana-api",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "description": "Exodus internal Solana asset API wrapper",
   "main": "src/index.js",
   "files": [
@@ -13,8 +13,9 @@
     "access": "restricted"
   },
   "dependencies": {
+    "@exodus/solana-lib": "^1.2.1",
     "@exodus/solana-web3.js": "^0.87.1-exodus3",
     "lodash": "^4.17.11"
   },
-  "gitHead": "912e3574f02b1886ed0c6616a7d35f20de533dbd"
+  "gitHead": "e599da7c7470f8bd73b9902e267736d5543bf27d"
 }

package/src/index.js

@@ -1,10 +1,14 @@
 // @flow
 import { Connection, PublicKey } from '@exodus/solana-web3.js'
+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/
 
 const RPC_URL = 'https://api.mainnet-beta.solana.com' // https://solana-api.projectserum.com
 
+// Tokens + SOL api support
 class Api {
   constructor(rpcUrl) {
     this.setServer(rpcUrl)
@@ -22,7 +26,11 @@ class Api {
 
   // Transaction structure: https://docs.solana.com/apps/jsonrpc-api#transaction-structure
   async getTransactionById(id: string) {
-    return this.connection.getConfirmedTransaction(id)
+    const { result } = await this.connection._rpcRequest('getConfirmedTransaction', [
+      id,
+      'jsonParsed',
+    ])
+    return result
   }
 
   async getFee(): number {
@@ -41,11 +49,11 @@ class Api {
     return this.connection.getBlockTime(slot)
   }
 
-  async getConfirmedSignaturesForAddress(address: string, { before, until, limit } = {}): any {
+  async getConfirmedSignaturesForAddress(address: string, { until, before, limit } = {}): any {
     until = until || undefined
     return this.connection.getConfirmedSignaturesForAddress2(new PublicKey(address), {
-      before,
       until,
+      before,
       limit,
     })
   }
@@ -53,7 +61,7 @@ class Api {
   /**
    * Get transactions from an address
    */
-  async getTransactions(address: string, { cursor, limit } = {}): any {
+  async getTransactions(address: string, { cursor, before, limit, tokenTicker } = {}): any {
     let transactions = []
     // cursor is a txHash
 
@@ -62,9 +70,17 @@ class Api {
 
       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?)
+      }
+
       for (let tx of txsId) {
         // get tx details
         const [txDetails, blockTime] = await Promise.all([
@@ -74,26 +90,10 @@ class Api {
         if (txDetails === null) continue
 
         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
-        const amount = Math.abs(
-          isSending ? preBalances[0] - postBalances[0] - fee : postBalances[1] - preBalances[1]
-        )
-
         transactions.push({
-          id: tx.signature,
-          memo: tx.memo,
-          slot: tx.slot,
           timestamp,
           date: new Date(timestamp),
-          fee, // lamports
-          from,
-          to,
-          amount, // lamports
-          error: !(txDetails.meta.err === null),
+          ...Api.parseTransaction(address, txDetails, tokenAccountsByOwner),
         })
       }
     } catch (err) {
@@ -106,6 +106,144 @@ class Api {
     return { transactions, newCursor }
   }
 
+  parseTransaction(...args) {
+    // alias
+    return Api.parseTransaction(...args)
+  }
+
+  static parseTransaction(
+    ownerAddress: string,
+    txDetails: Object,
+    tokenAccountsByOwner: ?Array
+  ): Object {
+    const { fee } = txDetails.meta
+    let { instructions } = txDetails.transaction.message
+    instructions = instructions
+      .filter((ix) => ix.parsed) // only known instructions
+      .map((ix) => ({
+        program: ix.program, // system or spl-token
+        type: ix.parsed.type, // transfer, createAccount, initializeAccount
+        ...ix.parsed.info,
+      }))
+
+    const solanaTx = lodash.find(instructions, { program: 'system', type: 'transfer' }) // get SOL transfer
+    // program:type tells us if it's a SOL or Token transfer
+
+    let tx
+    if (solanaTx) {
+      // Solana tx
+      const isSending = ownerAddress === solanaTx.source
+      tx = {
+        from: solanaTx.source,
+        to: solanaTx.destination,
+        amount: solanaTx.lamports, // number
+        fee: isSending ? fee : 0,
+      }
+    } else {
+      // Token tx
+      assert.ok(
+        Array.isArray(tokenAccountsByOwner),
+        'tokenAccountsByOwner is required when parsing token tx'
+      )
+      let tokenTxs = lodash
+        .filter(instructions, { program: 'spl-token', type: 'transfer' }) // get Token transfer: could have more than 1 instructions
+        .map((ix) => {
+          // add token details based on source/destination address
+          let tokenAccount = lodash.find(tokenAccountsByOwner, { tokenAccountAddress: ix.source })
+          const isSending = !!tokenAccount
+          if (!isSending)
+            tokenAccount = lodash.find(tokenAccountsByOwner, {
+              tokenAccountAddress: ix.destination,
+            }) // receiving
+          if (!tokenAccount) return null // no transfers with our addresses involved
+          delete tokenAccount.balance
+          delete tokenAccount.owner
+
+          return {
+            token: tokenAccount,
+            from: ix.source,
+            to: ix.destination,
+            amount: Number(ix.amount), // token
+            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
+        if (!finalTx.token) return ix // init finalTx (support just 1 token type per tx)
+        if (finalTx.token.ticker === ix.token.ticker) finalTx.amount += ix.amount
+        return finalTx
+      }, {})
+    }
+
+    // How tokens tx are parsed:
+    // 0. compute incoming or outgoing tx: it's outgoing if spl-token:transfer has source/destination included in tokenAccountsByOwner
+    // 1. if it's a sent tx: sum all instructions amount (spl-token:transfer)
+    // 2. if it's an incoming tx:  sull all the amounts with destination included in tokenAccountsByOwner (aggregating by ticker)
+    // QUESTION: How do I know what are my tokens addresses deterministically? It's not possible, gotta use tokenAccountsByOwner
+
+    return {
+      id: txDetails.transaction.signatures[0],
+      slot: txDetails.slot,
+      error: !(txDetails.meta.err === null),
+      ...tx,
+    }
+  }
+
+  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 tokenAccounts = []
+    for (let entry of accountsList) {
+      const { pubkey, account } = entry
+
+      const mint = lodash.get(account, 'data.parsed.info.mint')
+      const token = tokens.find(({ mintAddress }) => mintAddress === mint) || {
+        tokenName: 'unknown',
+        tokenSymbol: 'UNKNOWN',
+      }
+      const balance = lodash.get(account, 'data.parsed.info.tokenAmount.amount', '0')
+      tokenAccounts.push({
+        tokenAccountAddress: pubkey,
+        owner: address,
+        tokenName: token.tokenName,
+        ticker: token.tokenSymbol,
+        balance,
+      })
+    }
+    // eventually filter by token
+    return tokenTicker
+      ? tokenAccounts.filter(({ ticker }) => ticker === tokenTicker)
+      : tokenAccounts
+  }
+
+  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)
+      ? 'solana'
+      : account.owner.equals(TOKEN_PROGRAM_ID)
+      ? 'token'
+      : null
+  }
+
+  async isTokenAddress(address: string) {
+    const type = await this.getAddressType(address)
+    return type === 'token'
+  }
+
+  async isSOLaddress(address: string) {
+    const type = await this.getAddressType(address)
+    return type === 'solana'
+  }
+
   /**
    * Broadcast a signed transaction
    */