@exodus/solana-api 1.2.14 → 1.2.16

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@exodus/solana-api",
-  "version": "1.2.14",
+  "version": "1.2.16",
   "description": "Exodus internal Solana asset API wrapper",
-  "main": "lib/index.js",
+  "main": "src/index.js",
   "files": [
-    "lib/",
+    "src/",
     "!src/__tests__"
   ],
   "author": "Exodus",
@@ -14,11 +14,13 @@
   },
   "dependencies": {
     "@exodus/asset-json-rpc": "^1.0.0",
-    "@exodus/solana-lib": "^1.2.14",
+    "@exodus/solana-lib": "^1.2.16",
     "lodash": "^4.17.11",
+    "url-join": "4.0.0",
     "wretch": "^1.5.2"
   },
   "devDependencies": {
     "node-fetch": "~1.6.3"
-  }
+  },
+  "gitHead": "882b8a97ef05cbd0fbd7da0b2ce457e0a0ae7e35"
 }

package/src/index.js

@@ -0,0 +1,465 @@
+// @flow
+import createApi from '@exodus/asset-json-rpc'
+import { tokens, SYSTEM_PROGRAM_ID, STAKE_PROGRAM_ID, TOKEN_PROGRAM_ID } from '@exodus/solana-lib'
+import assert from 'assert'
+import lodash from 'lodash'
+import urljoin from 'url-join'
+import wretch, { Wretcher } from 'wretch'
+
+// 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
+
+// Tokens + SOL api support
+class Api {
+  constructor(rpcUrl) {
+    this.setServer(rpcUrl)
+  }
+
+  setServer(rpcUrl) {
+    this.rpcUrl = rpcUrl || RPC_URL
+    this.api = createApi(this.rpcUrl)
+  }
+
+  request(path, contentType = 'application/json'): Wretcher {
+    return wretch(urljoin(this.rpcUrl, path)).headers({
+      'Content-type': contentType,
+    })
+  }
+
+  async getEpochInfo(): number {
+    const { epoch } = await this.api.post({
+      method: 'getEpochInfo',
+    })
+    return Number(epoch)
+  }
+
+  async getStakeActivation(address): string {
+    const { state } = await this.api.post({
+      method: 'getStakeActivation',
+      params: [address],
+    })
+    return state
+  }
+
+  async getRecentBlockHash(): string {
+    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.api.post({
+      method: 'getConfirmedTransaction',
+      params: [id, 'jsonParsed'],
+    })
+    return result
+  }
+
+  async getFee(): number {
+    const {
+      value: {
+        feeCalculator: { lamportsPerSignature },
+      },
+    } = await this.api.post({
+      method: 'getRecentBlockhash',
+    })
+    return lamportsPerSignature
+  }
+
+  async getBalance(address: string): number {
+    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.api.post({
+      method: 'getBlockTime',
+      params: [slot],
+    })
+  }
+
+  async getConfirmedSignaturesForAddress(address: string, { until, before, limit } = {}): any {
+    until = until || undefined
+    return this.api.post({
+      method: 'getConfirmedSignaturesForAddress2',
+      params: [address, { until, before, limit }],
+    })
+  }
+
+  /**
+   * Get transactions from an address
+   */
+  async getTransactions(address: string, { cursor, before, limit } = {}): any {
+    let transactions = []
+    // cursor is a txHash
+
+    try {
+      let until = cursor
+
+      const tokenAccountsByOwner = await this.getTokenAccountsByOwner(address) // Array
+      const tokenAccountAddresses = tokenAccountsByOwner
+        .filter(({ tokenName }) => tokenName !== 'unknown')
+        .map(({ tokenAccountAddress }) => tokenAccountAddress)
+      const accountsToCheck = [address, ...tokenAccountAddresses]
+
+      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')
+
+      // get txs details in parallel
+      const txsDetails = await Promise.all(txsId.map((tx) => this.getTransactionById(tx.signature)))
+      txsDetails.forEach((txDetail) => {
+        if (txDetail === null) return
+
+        const timestamp = txDetail.blockTime * 1000
+        const parsedTx = Api.parseTransaction(address, txDetail, tokenAccountsByOwner)
+        if (!parsedTx.from) return // cannot parse it
+
+        transactions.push({
+          timestamp,
+          date: new Date(timestamp),
+          ...parsedTx,
+        })
+      })
+    } catch (err) {
+      console.warn('Solana error:', err)
+      throw err
+    }
+
+    transactions = lodash.orderBy(transactions, ['timestamp'], ['desc'])
+
+    const newCursor = transactions[0] ? transactions[0].id : cursor
+
+    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,
+      }))
+
+    // program:type tells us if it's a SOL or Token transfer
+    const solanaTx = lodash.find(instructions, { program: 'system', type: 'transfer' }) // get SOL transfer
+    const stakeTx = lodash.find(instructions, { program: 'system', type: 'createAccountWithSeed' })
+    const stakeWithdraw = lodash.find(instructions, { program: 'stake', type: 'withdraw' })
+    const stakeUndelegate = lodash.find(instructions, { program: 'stake', type: 'deactivate' })
+
+    let tx
+    if (solanaTx) {
+      // Solana tx
+      const isSending = ownerAddress === solanaTx.source
+      tx = {
+        owner: solanaTx.source,
+        from: solanaTx.source,
+        to: solanaTx.destination,
+        amount: solanaTx.lamports, // number
+        fee: isSending ? fee : 0,
+      }
+    } else if (stakeTx) {
+      // start staking
+      tx = {
+        owner: stakeTx.base,
+        from: stakeTx.base,
+        to: stakeTx.base,
+        amount: stakeTx.lamports,
+        fee,
+        staking: {
+          method: 'createAccountWithSeed',
+          seed: stakeTx.seed,
+          stakeAddress: stakeTx.newAccount,
+          stake: stakeTx.lamports,
+        },
+      }
+    } else if (stakeWithdraw) {
+      // TODO: lodash.find above returns 1 occurence, there could be multiple withdraw instructions in the same tx.
+      tx = {
+        owner: stakeWithdraw.withdrawAuthority,
+        from: stakeWithdraw.stakeAccount,
+        to: stakeWithdraw.destination,
+        amount: stakeWithdraw.lamports,
+        fee,
+        staking: {
+          method: 'withdraw',
+          stakeAddress: stakeWithdraw.stakeAccount,
+          stake: stakeWithdraw.lamports,
+        },
+      }
+    } else if (stakeUndelegate) {
+      tx = {
+        owner: stakeUndelegate.stakeAuthority,
+        from: stakeUndelegate.stakeAuthority,
+        to: stakeUndelegate.stakeAccount,
+        amount: 0,
+        fee,
+        staking: {
+          method: 'undelegate',
+          stakeAddress: stakeUndelegate.stakeAccount,
+        },
+      }
+    } 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
+          const owner = isSending ? ownerAddress : null
+
+          delete tokenAccount.balance
+          delete tokenAccount.owner
+          return {
+            owner,
+            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 { value: accountsList } = await this.api.post({
+      method: 'getTokenAccountsByOwner',
+      params: [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',
+        ticker: 'UNKNOWN',
+      }
+      const balance = lodash.get(account, 'data.parsed.info.tokenAmount.amount', '0')
+      tokenAccounts.push({
+        tokenAccountAddress: pubkey,
+        owner: address,
+        tokenName: token.tokenName,
+        ticker: token.ticker,
+        balance,
+      })
+    }
+    // eventually filter by token
+    return tokenTicker
+      ? tokenAccounts.filter(({ ticker }) => ticker === tokenTicker)
+      : tokenAccounts
+  }
+
+  async getTokensBalance(address: string, filterByTokens = []) {
+    let accounts = await this.getTokenAccountsByOwner(address) // Tokens
+
+    const tokensBalance = accounts.reduce((acc, { tokenName, balance }) => {
+      if (tokenName === 'unknown' || (filterByTokens.length && !filterByTokens.includes(tokenName)))
+        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 { 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 === TOKEN_PROGRAM_ID.toBase58()
+      ? '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'
+  }
+
+  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,
+              },
+            },
+          ],
+          encoding: 'jsonParsed',
+        },
+      ],
+    })
+    const accounts = {}
+    let totalStake = 0
+    let locked = 0
+    let withdrawable = 0
+    let pending = 0
+    for (let entry of res) {
+      const addr = entry.pubkey
+      const lamports = lodash.get(entry, 'account.lamports', 0)
+      const delegation = lodash.get(entry, 'account.data.parsed.info.stake.delegation', {})
+      // could have no delegation if the created stake address did not perform a delegate transaction
+
+      accounts[addr] = delegation
+      accounts[addr].lamports = lamports // sol balance
+      accounts[addr].activationEpoch = Number(accounts[addr].activationEpoch) || 0
+      accounts[addr].deactivationEpoch = Number(accounts[addr].deactivationEpoch) || 0
+      let state = 'inactive'
+      if (delegation.activationEpoch) state = await this.getStakeActivation(addr)
+      accounts[addr].state = state
+      accounts[addr].isDeactivating = state === 'deactivating'
+      accounts[addr].canWithdraw = state === 'inactive'
+      accounts[addr].stake = Number(accounts[addr].stake) || 0 // active staked amount
+      totalStake += accounts[addr].stake
+      locked += ['active', 'activating'].includes(accounts[addr].state) ? lamports : 0
+      withdrawable += accounts[addr].canWithdraw ? lamports : 0
+      pending += accounts[addr].isDeactivating ? lamports : 0
+    }
+    return { accounts, totalStake, locked, withdrawable, pending }
+  }
+
+  async getInflationReward(stakingAddresses: Array, epoch: number) {
+    const rewards = await this.api.post({
+      method: 'getInflationReward',
+      params: [stakingAddresses, { epoch }],
+    })
+
+    return rewards
+  }
+
+  async getRewards(stakingAddresses = []) {
+    if (!stakingAddresses.length) return 0
+
+    const rewards = await this.request(`rewards?addresses=${stakingAddresses.join(',')}`)
+      .get()
+      .error(500, () => ({})) // addresses not found
+      .error(400, () => ({}))
+      .json()
+
+    // sum rewards for all addresses
+    const earnings = Object.values(rewards).reduce((total, x) => {
+      return total + x
+    }, 0)
+
+    return earnings
+  }
+
+  /**
+   * Broadcast a signed transaction
+   */
+  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' }],
+    })
+
+    console.log(`tx ${JSON.stringify(result)} sent!`)
+    return result || null
+  }
+}
+
+export default new Api()

package/lib/index.js

@@ -1,512 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _assetJsonRpc = _interopRequireDefault(require("@exodus/asset-json-rpc"));
-
-var _solanaLib = require("@exodus/solana-lib");
-
-var _assert = _interopRequireDefault(require("assert"));
-
-var _lodash = _interopRequireDefault(require("lodash"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
-// 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
-// Tokens + SOL api support
-
-class Api {
-  constructor(rpcUrl) {
-    _defineProperty(this, "broadcastTransaction", async signedTx => {
-      console.log('Solana broadcasting TX:', signedTx); // base64
-
-      const result = await this.api.post({
-        method: 'sendTransaction',
-        params: [signedTx, {
-          encoding: 'base64',
-          commitment: 'singleGossip'
-        }]
-      });
-      console.log(`tx ${JSON.stringify(result)} sent!`);
-      return result || null;
-    });
-
-    this.setServer(rpcUrl);
-  }
-
-  setServer(rpcUrl) {
-    this.rpcUrl = rpcUrl || RPC_URL;
-    this.api = (0, _assetJsonRpc.default)(this.rpcUrl);
-  }
-
-  async getCurrentEpoch() {
-    const {
-      epoch
-    } = await this.api.post({
-      method: 'getEpochInfo'
-    });
-    return Number(epoch);
-  }
-
-  async getStakeActivation(address) {
-    const {
-      state
-    } = await this.api.post({
-      method: 'getStakeActivation',
-      params: [address]
-    });
-    return state;
-  }
-
-  async 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) {
-    const result = await this.api.post({
-      method: 'getConfirmedTransaction',
-      params: [id, 'jsonParsed']
-    });
-    return result;
-  }
-
-  async getFee() {
-    const {
-      value: {
-        feeCalculator: {
-          lamportsPerSignature
-        }
-      }
-    } = await this.api.post({
-      method: 'getRecentBlockhash'
-    });
-    return lamportsPerSignature;
-  }
-
-  async getBalance(address) {
-    const res = await this.api.post({
-      method: 'getBalance',
-      params: [address]
-    });
-    return res.value || 0;
-  }
-
-  async getBlockTime(slot) {
-    // 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]
-    });
-  }
-
-  async getConfirmedSignaturesForAddress(address, {
-    until,
-    before,
-    limit
-  } = {}) {
-    until = until || undefined;
-    return this.api.post({
-      method: 'getConfirmedSignaturesForAddress2',
-      params: [address, {
-        until,
-        before,
-        limit
-      }]
-    });
-  }
-  /**
-   * Get transactions from an address
-   */
-
-
-  async getTransactions(address, {
-    cursor,
-    before,
-    limit
-  } = {}) {
-    let transactions = []; // cursor is a txHash
-
-    try {
-      let until = cursor;
-      const tokenAccountsByOwner = await this.getTokenAccountsByOwner(address); // Array
-
-      const tokenAccountAddresses = tokenAccountsByOwner.filter(({
-        tokenName
-      }) => tokenName !== 'unknown').map(({
-        tokenAccountAddress
-      }) => tokenAccountAddress);
-      const accountsToCheck = [address, ...tokenAccountAddresses];
-      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.default.uniqBy(txsId, 'signature'); // get txs details in parallel
-
-      const txsDetails = await Promise.all(txsId.map(tx => this.getTransactionById(tx.signature)));
-      txsDetails.forEach(txDetail => {
-        if (txDetail === null) return;
-        const timestamp = txDetail.blockTime * 1000;
-        const parsedTx = Api.parseTransaction(address, txDetail, tokenAccountsByOwner);
-        if (!parsedTx.from) return; // cannot parse it
-
-        transactions.push(_objectSpread({
-          timestamp,
-          date: new Date(timestamp)
-        }, parsedTx));
-      });
-    } catch (err) {
-      console.warn('Solana error:', err);
-      throw err;
-    }
-
-    transactions = _lodash.default.orderBy(transactions, ['timestamp'], ['desc']);
-    const newCursor = transactions[0] ? transactions[0].id : cursor;
-    return {
-      transactions,
-      newCursor
-    };
-  }
-
-  parseTransaction(...args) {
-    // alias
-    return Api.parseTransaction(...args);
-  }
-
-  static parseTransaction(ownerAddress, txDetails, tokenAccountsByOwner) {
-    const {
-      fee
-    } = txDetails.meta;
-    let {
-      instructions
-    } = txDetails.transaction.message;
-    instructions = instructions.filter(ix => ix.parsed) // only known instructions
-    .map(ix => _objectSpread({
-      program: ix.program,
-      // system or spl-token
-      type: ix.parsed.type
-    }, ix.parsed.info)); // program:type tells us if it's a SOL or Token transfer
-
-    const solanaTx = _lodash.default.find(instructions, {
-      program: 'system',
-      type: 'transfer'
-    }); // get SOL transfer
-
-
-    const stakeTx = _lodash.default.find(instructions, {
-      program: 'system',
-      type: 'createAccountWithSeed'
-    });
-
-    const stakeWithdraw = _lodash.default.find(instructions, {
-      program: 'stake',
-      type: 'withdraw'
-    });
-
-    const stakeUndelegate = _lodash.default.find(instructions, {
-      program: 'stake',
-      type: 'deactivate'
-    });
-
-    let tx;
-
-    if (solanaTx) {
-      // Solana tx
-      const isSending = ownerAddress === solanaTx.source;
-      tx = {
-        owner: solanaTx.source,
-        from: solanaTx.source,
-        to: solanaTx.destination,
-        amount: solanaTx.lamports,
-        // number
-        fee: isSending ? fee : 0
-      };
-    } else if (stakeTx) {
-      // start staking
-      tx = {
-        owner: stakeTx.base,
-        from: stakeTx.base,
-        to: stakeTx.owner,
-        amount: stakeTx.lamports,
-        fee,
-        staking: {
-          method: 'createAccountWithSeed',
-          seed: stakeTx.seed,
-          stakeAddress: stakeTx.newAccount,
-          stake: stakeTx.lamports
-        }
-      };
-    } else if (stakeWithdraw) {
-      // TODO: lodash.find above returns 1 occurence, there could be multiple withdraw instructions in the same tx.
-      tx = {
-        owner: stakeWithdraw.withdrawAuthority,
-        from: stakeWithdraw.stakeAccount,
-        to: stakeWithdraw.destination,
-        amount: stakeWithdraw.lamports,
-        fee,
-        staking: {
-          method: 'withdraw',
-          stakeAddress: stakeWithdraw.stakeAccount,
-          stake: stakeWithdraw.lamports
-        }
-      };
-    } else if (stakeUndelegate) {
-      tx = {
-        owner: stakeUndelegate.stakeAuthority,
-        from: stakeUndelegate.stakeAuthority,
-        to: stakeUndelegate.stakeAccount,
-        amount: 0,
-        fee,
-        staking: {
-          method: 'undelegate',
-          stakeAddress: stakeUndelegate.stakeAccount
-        }
-      };
-    } else {
-      // Token tx
-      _assert.default.ok(Array.isArray(tokenAccountsByOwner), 'tokenAccountsByOwner is required when parsing token tx');
-
-      let tokenTxs = _lodash.default.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.default.find(tokenAccountsByOwner, {
-          tokenAccountAddress: ix.source
-        });
-
-        const isSending = !!tokenAccount;
-        if (!isSending) tokenAccount = _lodash.default.find(tokenAccountsByOwner, {
-          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,
-          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 _objectSpread({
-      id: txDetails.transaction.signatures[0],
-      slot: txDetails.slot,
-      error: !(txDetails.meta.err === null)
-    }, tx);
-  }
-
-  async getTokenAccountsByOwner(address, tokenTicker) {
-    const {
-      value: accountsList
-    } = await this.api.post({
-      method: 'getTokenAccountsByOwner',
-      params: [address, {
-        programId: _solanaLib.TOKEN_PROGRAM_ID.toBase58()
-      }, {
-        encoding: 'jsonParsed'
-      }]
-    });
-    const tokenAccounts = [];
-
-    for (let entry of accountsList) {
-      const {
-        pubkey,
-        account
-      } = entry;
-
-      const mint = _lodash.default.get(account, 'data.parsed.info.mint');
-
-      const token = _solanaLib.tokens.find(({
-        mintAddress
-      }) => mintAddress === mint) || {
-        tokenName: 'unknown',
-        tokenSymbol: 'UNKNOWN'
-      };
-
-      const balance = _lodash.default.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 getTokensBalance(address, filterByTokens = []) {
-    let accounts = await this.getTokenAccountsByOwner(address); // Tokens
-
-    const tokensBalance = accounts.reduce((acc, {
-      tokenName,
-      balance
-    }) => {
-      if (tokenName === 'unknown' || filterByTokens.length && !filterByTokens.includes(tokenName)) 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) {
-    // 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) {
-    // solana, token or null (unknown), meaning address has never been initialized
-    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 === _solanaLib.SYSTEM_PROGRAM_ID.toBase58() ? 'solana' : account.owner === _solanaLib.TOKEN_PROGRAM_ID.toBase58() ? 'token' : null;
-  }
-
-  async isTokenAddress(address) {
-    const type = await this.getAddressType(address);
-    return type === 'token';
-  }
-
-  async isSOLaddress(address) {
-    const type = await this.getAddressType(address);
-    return type === 'solana';
-  }
-
-  async getStakeAccountsInfo(address) {
-    // get staked amount and other info
-    const res = await this.api.post({
-      method: 'getProgramAccounts',
-      params: [_solanaLib.STAKE_PROGRAM_ID.toBase58(), {
-        filters: [{
-          memcmp: {
-            offset: 12,
-            bytes: address
-          }
-        }],
-        encoding: 'jsonParsed'
-      }]
-    });
-    const accounts = {};
-    let totalStake = 0;
-    let locked = 0;
-    let withdrawable = 0;
-    let pending = 0;
-
-    for (let entry of res) {
-      const addr = entry.pubkey;
-
-      const lamports = _lodash.default.get(entry, 'account.lamports', 0);
-
-      const delegation = _lodash.default.get(entry, 'account.data.parsed.info.stake.delegation', {}); // could have no delegation if the created stake address did not perform a delegate transaction
-
-
-      accounts[addr] = delegation;
-      accounts[addr].lamports = lamports; // sol balance
-
-      accounts[addr].activationEpoch = Number(accounts[addr].activationEpoch) || 0;
-      accounts[addr].deactivationEpoch = Number(accounts[addr].deactivationEpoch) || 0;
-      let state = 'inactive';
-      if (delegation.activationEpoch) state = await this.getStakeActivation(addr);
-      accounts[addr].state = state;
-      accounts[addr].isDeactivating = state === 'deactivating';
-      accounts[addr].canWithdraw = state === 'inactive';
-      accounts[addr].stake = Number(accounts[addr].stake) || 0; // active staked amount
-
-      totalStake += accounts[addr].stake;
-      locked += ['active', 'activating'].includes(accounts[addr].state) ? lamports : 0;
-      withdrawable += accounts[addr].canWithdraw ? lamports : 0;
-      pending += accounts[addr].isDeactivating ? lamports : 0;
-    }
-
-    return {
-      accounts,
-      totalStake,
-      locked,
-      withdrawable,
-      pending
-    };
-  }
-  /**
-   * Broadcast a signed transaction
-   */
-
-
-}
-
-var _default = new Api();
-
-exports.default = _default;