@exodus/solana-api 1.2.12 → 1.2.14

package/lib/index.js

@@ -0,0 +1,512 @@
+"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;

package/package.json

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

package/src/index.js

@@ -1,431 +0,0 @@
-// @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'
-
-// 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)
-  }
-
-  async getCurrentEpoch(): 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.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.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',
-        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 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 }
-  }
-
-  /**
-   * 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()