@exodus/solana-api 2.5.3 → 2.5.4

package/lib/api.js

@@ -1,1049 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.Api = void 0;
-
-var _bn = _interopRequireDefault(require("bn.js"));
-
-var _assetJsonRpc = _interopRequireDefault(require("@exodus/asset-json-rpc"));
-
-var _simpleRetry = require("@exodus/simple-retry");
-
-var _solanaLib = require("@exodus/solana-lib");
-
-var _assert = _interopRequireDefault(require("assert"));
-
-var _lodash = _interopRequireDefault(require("lodash"));
-
-var _urlJoin = _interopRequireDefault(require("url-join"));
-
-var _wretch = _interopRequireWildcard(require("wretch"));
-
-var _nftsCore = require("@exodus/nfts-core");
-
-var _connection = require("./connection");
-
-function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-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
-
-const WS_ENDPOINT = 'wss://solana.a.exodus.io/ws'; // Tokens + SOL api support
-
-class Api {
-  constructor({
-    rpcUrl,
-    wsUrl,
-    assets
-  }) {
-    this.broadcastTransaction = async (signedTx, options) => {
-      console.log('Solana broadcasting TX:', signedTx); // base64
-
-      const defaultOptions = {
-        encoding: 'base64',
-        preflightCommitment: 'finalized'
-      };
-      const params = [signedTx, { ...defaultOptions,
-        ...options
-      }];
-      const errorMessagesToRetry = ['Blockhash not found'];
-      const broadcastTxWithRetry = (0, _simpleRetry.retry)(async () => {
-        try {
-          const result = await this.rpcCall('sendTransaction', params, {
-            forceHttp: true
-          });
-          console.log(`tx ${JSON.stringify(result)} sent!`);
-          return result || null;
-        } catch (error) {
-          if (error.message && !errorMessagesToRetry.find(errorMessage => error.message.includes(errorMessage))) {
-            error.finalError = true;
-          }
-
-          console.warn(`Error broadcasting tx. Retrying...`, error);
-          throw error;
-        }
-      }, {
-        delayTimesMs: ['6s', '6s', '8s', '10s']
-      });
-      return broadcastTxWithRetry();
-    };
-
-    this.simulateTransaction = async (encodedTransaction, options) => {
-      const {
-        value: {
-          accounts
-        }
-      } = await this.rpcCall('simulateTransaction', [encodedTransaction, options]);
-      return accounts;
-    };
-
-    this.resolveSimulationSideEffects = async (solAccounts, tokenAccounts) => {
-      const willReceive = [];
-      const willSend = [];
-      const resolveSols = solAccounts.map(async account => {
-        const currentAmount = await this.getBalance(account.address);
-        const balance = (0, _solanaLib.computeBalance)(account.amount, currentAmount);
-        return {
-          name: 'SOL',
-          symbol: 'SOL',
-          balance,
-          decimal: _solanaLib.SOL_DECIMAL,
-          type: 'SOL'
-        };
-      });
-
-      const _wrapAndHandleAccountNotFound = (fn, defaultValue) => {
-        return async (...params) => {
-          try {
-            return await fn.apply(this, params);
-          } catch (error) {
-            if (error.message && error.message.includes('could not find account')) {
-              return defaultValue;
-            }
-
-            throw error;
-          }
-        };
-      };
-
-      const _getTokenBalance = _wrapAndHandleAccountNotFound(this.getTokenBalance, '0');
-
-      const _getDecimals = _wrapAndHandleAccountNotFound(this.getDecimals, 0);
-
-      const _getSupply = _wrapAndHandleAccountNotFound(this.getSupply, '0');
-
-      const resolveTokens = tokenAccounts.map(async account => {
-        try {
-          const [_tokenMetaPlex, currentAmount, decimal] = await Promise.all([this.getMetaplexMetadata(account.mint), _getTokenBalance(account.address), _getDecimals(account.mint)]);
-          const tokenMetaPlex = _tokenMetaPlex || {
-            name: null,
-            symbol: null
-          };
-          let nft = {
-            collectionId: null,
-            collectionName: null,
-            collectionTitle: null,
-            title: null
-          }; // Only perform an NFT check (getSupply) if decimal is zero
-
-          if (decimal === 0 && (await _getSupply(account.mint)) === '1') {
-            try {
-              const {
-                id: collectionId,
-                collectionName,
-                collectionTitle,
-                title
-              } = await _nftsCore.magicEden.api.getNFTByMintAddress(account.mint);
-              nft = {
-                collectionId,
-                collectionTitle,
-                collectionName,
-                title
-              };
-              tokenMetaPlex.name = tokenMetaPlex.name || collectionTitle;
-              tokenMetaPlex.symbol = tokenMetaPlex.symbol || collectionName;
-            } catch (error) {
-              console.warn(error);
-            }
-          }
-
-          const balance = (0, _solanaLib.computeBalance)(account.amount, currentAmount);
-          return {
-            balance,
-            decimal,
-            nft,
-            address: account.address,
-            mint: account.mint,
-            name: tokenMetaPlex.name,
-            symbol: tokenMetaPlex.symbol,
-            type: 'TOKEN'
-          };
-        } catch (error) {
-          console.warn(error);
-          return {
-            balance: null
-          };
-        }
-      });
-      const accounts = await Promise.all([...resolveSols, ...resolveTokens]);
-      accounts.forEach(account => {
-        if (account.balance === null) {
-          return;
-        }
-
-        if (account.balance > 0) {
-          willReceive.push(account);
-        } else {
-          willSend.push(account);
-        }
-      });
-      return {
-        willReceive,
-        willSend
-      };
-    };
-
-    this.simulateAndRetrieveSideEffects = async (message, publicKey, transactionMessage) => {
-      const {
-        config,
-        accountAddresses
-      } = (0, _solanaLib.getTransactionSimulationParams)(transactionMessage || message);
-      const signatures = new Array(message.header.numRequiredSignatures || 1).fill(null);
-      const encodedTransaction = (0, _solanaLib.buildRawTransaction)(Buffer.from(message.serialize()), signatures).toString('base64');
-      const futureAccountsState = await this.simulateTransaction(encodedTransaction, config);
-      const {
-        solAccounts,
-        tokenAccounts
-      } = (0, _solanaLib.filterAccountsByOwner)(futureAccountsState, accountAddresses, publicKey);
-      return this.resolveSimulationSideEffects(solAccounts, tokenAccounts);
-    };
-
-    this.setServer(rpcUrl);
-    this.setWsEndpoint(wsUrl);
-    this.setTokens(assets);
-    this.tokensToSkip = {};
-    this.connections = {};
-  }
-
-  setServer(rpcUrl) {
-    this.rpcUrl = rpcUrl || RPC_URL;
-    this.api = (0, _assetJsonRpc.default)(this.rpcUrl);
-  }
-
-  setWsEndpoint(wsUrl) {
-    this.wsUrl = wsUrl || WS_ENDPOINT;
-  }
-
-  setTokens(assets = {}) {
-    const solTokens = _lodash.default.pickBy(assets, asset => asset.assetType === 'SOLANA_TOKEN');
-
-    this.tokens = _lodash.default.mapKeys(solTokens, v => v.mintAddress);
-  }
-
-  request(path, contentType = 'application/json') {
-    return (0, _wretch.default)((0, _urlJoin.default)(this.rpcUrl, path)).headers({
-      'Content-type': contentType
-    });
-  }
-
-  async watchAddress({
-    address,
-    tokensAddresses = [],
-    handleAccounts,
-    handleTransfers,
-    handleReconnect,
-    reconnectDelay
-  }) {
-    const conn = new _connection.Connection({
-      endpoint: this.wsUrl,
-      address,
-      tokensAddresses,
-      callback: updates => this.handleUpdates({
-        updates,
-        address,
-        handleAccounts,
-        handleTransfers
-      }),
-      reconnectCallback: handleReconnect,
-      reconnectDelay
-    });
-    this.connections[address] = conn;
-    return conn.start();
-  }
-
-  async unwatchAddress({
-    address
-  }) {
-    if (this.connections[address]) {
-      await this.connections[address].stop();
-      delete this.connections[address];
-    }
-  }
-
-  async handleUpdates({
-    updates,
-    address,
-    handleAccounts,
-    handleTransfers
-  }) {
-    // console.log(`got ws updates from ${address}:`, updates)
-    if (handleTransfers) return handleTransfers(updates);
-  }
-
-  async rpcCall(method, params = [], {
-    address = '',
-    forceHttp = false
-  } = {}) {
-    // ws request
-    const connection = this.connections[address] || _lodash.default.sample(Object.values(this.connections)); // pick random connection
-
-
-    if (_lodash.default.get(connection, 'isOpen') && !_lodash.default.get(connection, 'shutdown') && !forceHttp) {
-      return connection.sendMessage(method, params);
-    } // http fallback
-
-
-    return this.api.post({
-      method,
-      params
-    });
-  }
-
-  getTokenByAddress(mint) {
-    return this.tokens[mint];
-  }
-
-  isTokenSupported(mint) {
-    return !!this.getTokenByAddress(mint);
-  }
-
-  async getEpochInfo() {
-    const {
-      epoch
-    } = await this.rpcCall('getEpochInfo');
-    return Number(epoch);
-  }
-
-  async getStakeActivation(address) {
-    const {
-      state
-    } = await this.rpcCall('getStakeActivation', [address]);
-    return state;
-  }
-
-  async getRecentBlockHash(commitment) {
-    const result = await this.rpcCall('getRecentBlockhash', [{
-      commitment: commitment || 'finalized',
-      encoding: 'jsonParsed'
-    }], {
-      forceHttp: true
-    });
-    return _lodash.default.get(result, 'value.blockhash');
-  } // Transaction structure: https://docs.solana.com/apps/jsonrpc-api#transaction-structure
-
-
-  async getTransactionById(id) {
-    return this.rpcCall('getTransaction', [id, {
-      encoding: 'jsonParsed',
-      maxSupportedTransactionVersion: 0
-    }]);
-  }
-
-  async getFee() {
-    const result = await this.rpcCall('getRecentBlockhash', [{
-      commitment: 'finalized',
-      encoding: 'jsonParsed'
-    }]);
-    return _lodash.default.get(result, 'value.feeCalculator.lamportsPerSignature');
-  }
-
-  async getBalance(address) {
-    const result = await this.rpcCall('getBalance', [address, {
-      encoding: 'jsonParsed'
-    }], {
-      address
-    });
-    return _lodash.default.get(result, '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.rpcCall('getBlockTime', [slot]);
-  }
-
-  async getConfirmedSignaturesForAddress(address, {
-    until,
-    before,
-    limit
-  } = {}) {
-    until = until || undefined;
-    return this.rpcCall('getSignaturesForAddress', [address, {
-      until,
-      before,
-      limit
-    }], {
-      address
-    });
-  }
-  /**
-   * Get transactions from an address
-   */
-
-
-  async getTransactions(address, {
-    cursor,
-    before,
-    limit,
-    includeUnparsed = false
-  } = {}) {
-    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 = this.parseTransaction(address, txDetail, tokenAccountsByOwner, {
-          includeUnparsed
-        });
-        if (!parsedTx.from && !includeUnparsed) return; // cannot parse it
-        // split dexTx in separate txs
-
-        if (parsedTx.dexTxs) {
-          parsedTx.dexTxs.forEach(tx => {
-            transactions.push({
-              timestamp,
-              date: new Date(timestamp),
-              ...tx
-            });
-          });
-          delete parsedTx.dexTxs;
-        }
-
-        transactions.push({
-          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(ownerAddress, txDetails, tokenAccountsByOwner, {
-    includeUnparsed = false
-  } = {}) {
-    let {
-      fee,
-      preBalances,
-      postBalances,
-      preTokenBalances,
-      postTokenBalances,
-      innerInstructions
-    } = txDetails.meta;
-    preBalances = preBalances || [];
-    postBalances = postBalances || [];
-    preTokenBalances = preTokenBalances || [];
-    postTokenBalances = postTokenBalances || [];
-    innerInstructions = innerInstructions || [];
-    let {
-      instructions,
-      accountKeys
-    } = txDetails.transaction.message;
-
-    const getUnparsedTx = () => {
-      const ownerIndex = accountKeys.findIndex(accountKey => accountKey.pubkey === ownerAddress);
-      const feePaid = ownerIndex === 0 ? fee : 0;
-      return {
-        unparsed: true,
-        amount: ownerIndex === -1 ? 0 : postBalances[ownerIndex] - preBalances[ownerIndex] + feePaid,
-        fee: feePaid,
-        data: {
-          meta: txDetails.meta
-        }
-      };
-    };
-
-    const getInnerTxsFromBalanceChanges = () => {
-      const ownPreTokenBalances = preTokenBalances.filter(balance => balance.owner === ownerAddress);
-      const ownPostTokenBalances = postTokenBalances.filter(balance => balance.owner === ownerAddress);
-      return ownPostTokenBalances.map(postBalance => {
-        const tokenAccount = tokenAccountsByOwner.find(tokenAccount => tokenAccount.mintAddress === postBalance.mint);
-        const preBalance = ownPreTokenBalances.find(balance => balance.accountIndex === postBalance.accountIndex);
-        const preAmount = new _bn.default(_lodash.default.get(preBalance, 'uiTokenAmount.amount', '0'), 10);
-        const postAmount = new _bn.default(_lodash.default.get(postBalance, 'uiTokenAmount.amount', '0'), 10);
-        const amount = postAmount.sub(preAmount);
-        if (!tokenAccount || amount.isZero()) return null; // This is not perfect as there could be multiple same-token transfers in single
-        // transaction, but our wallet only supports one transaction with single txId
-        // so we are picking first that matches (correct token + type - send or receive)
-
-        const match = innerInstructions.find(inner => {
-          const targetOwner = amount.isNeg() ? ownerAddress : null;
-          return inner.token.mintAddress === tokenAccount.mintAddress && targetOwner === inner.owner;
-        }); // It's possible we won't find a match, because our innerInstructions only contain
-        // spl-token transfers, but balances of SPL tokens can change in different ways too.
-        // for now, we are ignoring this to simplify as those cases are not that common, but
-        // they should be handled eventually. It was already a scretch to add unparsed txs logic
-        // to existing parser, expanding it further is not going to end well.
-        // this probably should be refactored from ground to handle all those transactions
-        // as a core part of it in the future
-
-        if (!match) return null;
-        const {
-          from,
-          to,
-          owner
-        } = match;
-        return {
-          id: txDetails.transaction.signatures[0],
-          slot: txDetails.slot,
-          owner,
-          from,
-          to,
-          amount: amount.abs().toString(),
-          // inconsistent with the rest, but it can and did overflow
-          fee: 0,
-          token: tokenAccount,
-          data: {
-            inner: true
-          }
-        };
-      }).filter(ix => !!ix);
-    };
-
-    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
-    }));
-    innerInstructions = innerInstructions.reduce((acc, val) => {
-      return acc.concat(val.instructions);
-    }, []).map(ix => {
-      const type = _lodash.default.get(ix, 'parsed.type');
-
-      const isTransferTx = ix.parsed && ix.program === 'spl-token' && type === 'transfer';
-
-      const source = _lodash.default.get(ix, 'parsed.info.source');
-
-      const destination = _lodash.default.get(ix, 'parsed.info.destination');
-
-      const amount = Number(_lodash.default.get(ix, 'parsed.info.amount', 0));
-      const tokenAccount = tokenAccountsByOwner.find(({
-        tokenAccountAddress
-      }) => {
-        return [source, destination].includes(tokenAccountAddress);
-      });
-      const isSending = !!tokenAccountsByOwner.find(({
-        tokenAccountAddress
-      }) => {
-        return [source].includes(tokenAccountAddress);
-      }); // owner if it's a send tx
-
-      const instruction = {
-        id: txDetails.transaction.signatures[0],
-        slot: txDetails.slot,
-        owner: isSending ? ownerAddress : null,
-        from: source,
-        to: destination,
-        amount,
-        token: tokenAccount,
-        fee: isSending ? fee : 0
-      };
-      return isTransferTx && tokenAccount ? instruction : null;
-    }).filter(ix => !!ix); // program:type tells us if it's a SOL or Token transfer
-
-    const solanaTx = _lodash.default.find(instructions, ix => {
-      if (![ix.source, ix.destination].includes(ownerAddress)) return false;
-      return ix.program === 'system' && ix.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'
-    });
-
-    const hasSolanaTx = solanaTx && !preTokenBalances.length && !postTokenBalances.length; // only SOL moved and no tokens movements
-
-    let tx = {};
-
-    if (hasSolanaTx) {
-      // 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,
-          stakeAddresses: [stakeTx.newAccount],
-          stake: stakeTx.lamports
-        }
-      };
-    } else if (stakeWithdraw) {
-      const stakeAccounts = _lodash.default.map(_lodash.default.filter(instructions, {
-        program: 'stake',
-        type: 'withdraw'
-      }), 'stakeAccount');
-
-      tx = {
-        owner: stakeWithdraw.withdrawAuthority,
-        from: stakeWithdraw.stakeAccount,
-        to: stakeWithdraw.destination,
-        amount: stakeWithdraw.lamports,
-        fee,
-        staking: {
-          method: 'withdraw',
-          stakeAddresses: stakeAccounts,
-          stake: stakeWithdraw.lamports
-        }
-      };
-    } else if (stakeUndelegate) {
-      const stakeAccounts = _lodash.default.map(_lodash.default.filter(instructions, {
-        program: 'stake',
-        type: 'deactivate'
-      }), 'stakeAccount');
-
-      tx = {
-        owner: stakeUndelegate.stakeAuthority,
-        from: stakeUndelegate.stakeAuthority,
-        to: stakeUndelegate.stakeAccount,
-        // obsolete
-        amount: 0,
-        fee,
-        staking: {
-          method: 'undelegate',
-          stakeAddresses: stakeAccounts
-        }
-      };
-    } else {
-      // Token tx
-      _assert.default.ok(Array.isArray(tokenAccountsByOwner), 'tokenAccountsByOwner is required when parsing token tx');
-
-      let tokenTxs = _lodash.default.filter(instructions, ({
-        program,
-        type
-      }) => {
-        return program === 'spl-token' && ['transfer', 'transferChecked'].includes(type);
-      }) // 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 || _lodash.default.get(ix, 'tokenAmount.amount', 0)),
-          // supporting both types: transfer and transferChecked
-          fee: isSending ? fee : 0 // in lamports
-
-        };
-      });
-
-      if (tokenTxs.length) {
-        // found spl-token simple transfer/transferChecked instruction
-        // .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;
-        }, {});
-      } else if (preTokenBalances && postTokenBalances) {
-        // probably a DEX program is involved (multiple instructions), compute balance changes
-        const accountIndexes = _lodash.default.mapKeys(accountKeys, (x, i) => i);
-
-        Object.values(accountIndexes).forEach(acc => {
-          // filter by ownerAddress
-          const hasKnownOwner = !!_lodash.default.find(tokenAccountsByOwner, {
-            tokenAccountAddress: acc.pubkey
-          });
-          acc.owner = hasKnownOwner ? ownerAddress : null;
-        }); // group by owner and supported token
-
-        const preBalances = preTokenBalances.filter(t => {
-          return accountIndexes[t.accountIndex].owner === ownerAddress && this.isTokenSupported(t.mint);
-        });
-        const postBalances = postTokenBalances.filter(t => {
-          return accountIndexes[t.accountIndex].owner === ownerAddress && this.isTokenSupported(t.mint);
-        });
-
-        if (preBalances.length || postBalances.length) {
-          tx = {};
-
-          if (includeUnparsed && innerInstructions.length) {
-            // when using includeUnparsed for DEX tx we want to keep SOL tx as "unparsed"
-            // 1. we want to treat all SOL dex transactions as "Contract transaction", not "Sent SOL"
-            // 2. default behavior is not perfect. For example it doesn't see SOL-side tx in
-            //    SOL->SPL swaps on Raydium and Orca.
-            tx = getUnparsedTx(tx);
-            tx.dexTxs = getInnerTxsFromBalanceChanges();
-          } else {
-            if (solanaTx) {
-              // the base tx will be the one that moved solana.
-              tx = {
-                owner: solanaTx.source,
-                from: solanaTx.source,
-                to: solanaTx.destination,
-                amount: solanaTx.lamports,
-                // number
-                fee: ownerAddress === solanaTx.source ? fee : 0
-              };
-            } // If it has inner instructions then it's a DEX tx that moved SPL -> SPL
-
-
-            if (innerInstructions.length) {
-              tx.dexTxs = innerInstructions; // if tx involves only SPL swaps. Expand DEX ix (first element as tx base and the other kept there)
-
-              if (!tx.from && !solanaTx) {
-                tx = tx.dexTxs[0];
-                tx.dexTxs = innerInstructions.slice(1);
-              }
-            }
-          }
-        }
-      }
-    }
-
-    const unparsed = Object.keys(tx).length === 0;
-
-    if (unparsed && includeUnparsed) {
-      tx = getUnparsedTx(tx);
-    } // 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: sum 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 getSupply(mintAddress) {
-    const result = await this.rpcCall('getTokenSupply', [mintAddress]);
-    return _lodash.default.get(result, 'value.amount');
-  }
-
-  async getWalletTokensList({
-    tokenAccounts
-  }) {
-    const tokensMint = [];
-
-    for (let account of tokenAccounts) {
-      const mint = account.mintAddress; // skip cached NFT
-
-      if (this.tokensToSkip[mint]) continue; // skip 0 balance
-
-      if (account.balance === '0') continue; // skip NFT
-
-      const supply = await this.getSupply(mint);
-
-      if (supply === '1') {
-        this.tokensToSkip[mint] = true;
-        continue;
-      } // OK
-
-
-      tokensMint.push(mint);
-    }
-
-    return tokensMint;
-  }
-
-  async getTokenAccountsByOwner(address, tokenTicker) {
-    const {
-      value: accountsList
-    } = await this.rpcCall('getTokenAccountsByOwner', [address, {
-      programId: _solanaLib.TOKEN_PROGRAM_ID.toBase58()
-    }, {
-      encoding: 'jsonParsed'
-    }], {
-      address
-    });
-    const tokenAccounts = [];
-
-    for (let entry of accountsList) {
-      const {
-        pubkey,
-        account
-      } = entry;
-
-      const mint = _lodash.default.get(account, 'data.parsed.info.mint');
-
-      const token = this.getTokenByAddress(mint) || {
-        name: 'unknown',
-        ticker: 'UNKNOWN'
-      };
-
-      const balance = _lodash.default.get(account, 'data.parsed.info.tokenAmount.amount', '0');
-
-      tokenAccounts.push({
-        tokenAccountAddress: pubkey,
-        owner: address,
-        tokenName: token.name,
-        ticker: token.ticker,
-        balance,
-        mintAddress: mint
-      });
-    } // eventually filter by token
-
-
-    return tokenTicker ? tokenAccounts.filter(({
-      ticker
-    }) => ticker === tokenTicker) : tokenAccounts;
-  }
-
-  async getTokensBalance({
-    address,
-    filterByTokens = [],
-    tokenAccounts
-  }) {
-    let accounts = tokenAccounts || (await this.getTokenAccountsByOwner(address));
-    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.rpcCall('getTokenAccountBalance', [tokenAddress]);
-      return true;
-    } catch (e) {
-      return false;
-    }
-  } // Returns account balance of a SPL Token account.
-
-
-  async getTokenBalance(tokenAddress) {
-    const result = await this.rpcCall('getTokenAccountBalance', [tokenAddress]);
-    return _lodash.default.get(result, 'value.amount');
-  }
-
-  async getAccountInfo(address) {
-    const {
-      value
-    } = await this.rpcCall('getAccountInfo', [address, {
-      encoding: 'jsonParsed',
-      commitment: 'single'
-    }], {
-      address
-    });
-    return value;
-  }
-
-  async isSpl(address) {
-    const {
-      owner
-    } = await this.getAccountInfo(address);
-    return owner === 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA';
-  }
-
-  async getMetaplexMetadata(tokenMintAddress) {
-    const metaplexPDA = (0, _solanaLib.getMetadataAccount)(tokenMintAddress);
-    const res = await this.getAccountInfo(metaplexPDA);
-
-    const data = _lodash.default.get(res, 'data[0]');
-
-    if (!data) return null;
-    return (0, _solanaLib.deserializeMetaplexMetadata)(Buffer.from(data, 'base64'));
-  }
-
-  async getDecimals(tokenMintAddress) {
-    const result = await this.rpcCall('getTokenSupply', [tokenMintAddress]);
-    return _lodash.default.get(result, 'value.decimals', null);
-  }
-
-  async getAddressType(address) {
-    // solana, token or null (unknown), meaning address has never been initialized
-    const value = await this.getAccountInfo(address);
-    if (value === null) return null;
-    const account = {
-      executable: value.executable,
-      owner: value.owner,
-      lamports: value.lamports
-    };
-    return account.owner === _solanaLib.SYSTEM_PROGRAM_ID.toBase58() ? 'solana' : account.owner === _solanaLib.TOKEN_PROGRAM_ID.toBase58() ? 'token' : null;
-  }
-
-  async getTokenAddressOwner(address) {
-    const value = await this.getAccountInfo(address);
-
-    const owner = _lodash.default.get(value, 'data.parsed.info.owner', null);
-
-    return owner;
-  }
-
-  async getAddressMint(address) {
-    const value = await this.getAccountInfo(address);
-
-    const mintAddress = _lodash.default.get(value, 'data.parsed.info.mint', null); // token mint
-
-
-    return mintAddress;
-  }
-
-  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) {
-    const params = [_solanaLib.STAKE_PROGRAM_ID.toBase58(), {
-      filters: [{
-        memcmp: {
-          offset: 12,
-          bytes: address
-        }
-      }],
-      encoding: 'jsonParsed'
-    }];
-    const res = await this.rpcCall('getProgramAccounts', params, {
-      address
-    });
-    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
-    };
-  }
-
-  async getRewards(stakingAddresses = []) {
-    if (!stakingAddresses.length) return 0; // custom endpoint!
-
-    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;
-  }
-
-  async getMinimumBalanceForRentExemption(size) {
-    return this.rpcCall('getMinimumBalanceForRentExemption', [size]);
-  }
-
-  async getProgramAccounts(programId, config) {
-    return this.rpcCall('getProgramAccounts', [programId, config]);
-  }
-
-  async getMultipleAccounts(pubkeys, config) {
-    const response = await this.rpcCall('getMultipleAccounts', [pubkeys, config]);
-    return response && response.value ? response.value : [];
-  }
-  /**
-   * Broadcast a signed transaction
-   */
-
-
-}
-
-exports.Api = Api;