@exodus/solana-api 2.5.3 → 2.5.5

package/lib/connection.js

@@ -1,263 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.Connection = void 0;
-
-var _ms = _interopRequireDefault(require("ms"));
-
-var _delay = _interopRequireDefault(require("delay"));
-
-var _url = _interopRequireDefault(require("url"));
-
-var _lodash = _interopRequireDefault(require("lodash"));
-
-var _debug = _interopRequireDefault(require("debug"));
-
-var _fetch = require("@exodus/fetch");
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-const SOLANA_DEFAULT_ENDPOINT = 'wss://solana.a.exodus.io/ws';
-const DEFAULT_RECONNECT_DELAY = (0, _ms.default)('15s');
-const PING_INTERVAL = (0, _ms.default)('60s');
-const TIMEOUT = (0, _ms.default)('50s');
-const debug = (0, _debug.default)('exodus:solana-api');
-
-class Connection {
-  constructor({
-    endpoint = SOLANA_DEFAULT_ENDPOINT,
-    address,
-    tokensAddresses = [],
-    callback,
-    reconnectCallback = () => {},
-    reconnectDelay = DEFAULT_RECONNECT_DELAY
-  }) {
-    this.address = address;
-    this.tokensAddresses = tokensAddresses;
-    this.endpoint = endpoint;
-    this.callback = callback;
-    this.reconnectCallback = reconnectCallback;
-    this.reconnectDelay = reconnectDelay;
-    this.shutdown = false;
-    this.ws = null;
-    this.rpcQueue = {};
-    this.messageQueue = [];
-    this.inProcessMessages = false;
-    this.pingTimeout = null;
-    this.reconnectTimeout = null;
-    this.txCache = {};
-  }
-
-  newSocket(reqUrl) {
-    // eslint-disable-next-line
-    const obj = _url.default.parse(reqUrl);
-
-    obj.protocol = 'wss:';
-    reqUrl = _url.default.format(obj);
-    debug('Opening WS to:', reqUrl);
-    const ws = new _fetch.WebSocket(`${reqUrl}`);
-    ws.onmessage = this.onMessage.bind(this);
-    ws.onopen = this.onOpen.bind(this);
-    ws.onclose = this.onClose.bind(this);
-    ws.onerror = this.onError.bind(this);
-    return ws;
-  }
-
-  get isConnecting() {
-    return !!(this.ws && this.ws.readyState === _fetch.WebSocket.CONNECTING);
-  }
-
-  get isOpen() {
-    return !!(this.ws && this.ws.readyState === _fetch.WebSocket.OPEN);
-  }
-
-  get isClosing() {
-    return !!(this.ws && this.ws.readyState === _fetch.WebSocket.CLOSING);
-  }
-
-  get isClosed() {
-    return !!(!this.ws || this.ws.readyState === _fetch.WebSocket.CLOSED);
-  }
-
-  get running() {
-    return !!(!this.isClosed || this.inProcessMessages || this.messageQueue.length);
-  }
-
-  get connectionState() {
-    if (this.isConnecting) return 'CONNECTING';else if (this.isOpen) return 'OPEN';else if (this.isClosing) return 'CLOSING';else if (this.isClosed) return 'CLOSED';
-    return 'NONE';
-  }
-
-  doPing() {
-    if (this.ws) {
-      this.ws.ping();
-      this.pingTimeout = setTimeout(this.doPing.bind(this), PING_INTERVAL);
-    }
-  }
-
-  doRestart() {
-    // debug('Restarting WS:')
-    this.reconnectTimeout = setTimeout(async () => {
-      try {
-        debug('reconnecting ws...');
-        this.start();
-        await this.reconnectCallback();
-      } catch (e) {
-        console.log(`Error in reconnect callback: ${e.message}`);
-      }
-    }, this.reconnectDelay);
-  }
-
-  onMessage(evt) {
-    try {
-      const json = JSON.parse(evt.data);
-      debug('new ws msg:', json);
-
-      if (!json.error) {
-        if (_lodash.default.get(this.rpcQueue, json.id)) {
-          // json-rpc reply
-          clearTimeout(this.rpcQueue[json.id].timeout);
-          this.rpcQueue[json.id].resolve(json.result);
-          delete this.rpcQueue[json.id];
-        } else if (json.method) {
-          const msg = {
-            method: json.method,
-            ..._lodash.default.get(json, 'params.result', json.result)
-          };
-          debug('pushing msg to queue', msg);
-          this.messageQueue.push(msg); // sub results
-        }
-
-        this.processMessages();
-      } else {
-        if (_lodash.default.get(this.rpcQueue, json.id)) {
-          this.rpcQueue[json.id].reject(new Error(json.error.message));
-          clearTimeout(this.rpcQueue[json.id].timeout);
-          delete this.rpcQueue[json.id];
-        } else debug('Unsupported WS message:', json.error.message);
-      }
-    } catch (e) {
-      debug(e);
-      debug('Cannot parse msg:', evt.data);
-    }
-  }
-
-  onOpen(evt) {
-    debug('Opened WS'); // subscribe to each addresses (SOL and ASA addr)
-
-    this.tokensAddresses.concat(this.address).forEach(address => {
-      // sub for account state changes
-      this.ws.send(JSON.stringify({
-        jsonrpc: '2.0',
-        method: 'accountSubscribe',
-        params: [address, {
-          encoding: 'jsonParsed'
-        }],
-        id: 1
-      })); // sub for incoming/outcoming txs
-
-      this.ws.send(JSON.stringify({
-        jsonrpc: '2.0',
-        method: 'logsSubscribe',
-        params: [{
-          mentions: [address]
-        }, {
-          commitment: 'finalized'
-        }],
-        id: 2
-      }));
-    }); // this.doPing()
-  }
-
-  onError(evt) {
-    debug('Error on WS:', evt.data);
-  }
-
-  onClose(evt) {
-    debug('Closing WS');
-    clearTimeout(this.pingTimeout);
-    clearTimeout(this.reconnectTimeout);
-
-    if (!this.shutdown) {
-      this.doRestart();
-    }
-  }
-
-  async sendMessage(method, params = []) {
-    return new Promise((resolve, reject) => {
-      if (this.isClosed || this.shutdown) return reject(new Error('connection not started'));
-      const id = Math.floor(Math.random() * 1e7) + 1;
-      this.rpcQueue[id] = {
-        resolve,
-        reject
-      };
-      this.rpcQueue[id].timeout = setTimeout(() => {
-        delete this.rpcQueue[id];
-        debug(`ws timeout command: ${method} - ${JSON.stringify(params)} - ${id}`);
-        reject(new Error('solana ws: reply timeout'));
-      }, TIMEOUT);
-      if (typeof this.rpcQueue[id].timeout.unref === 'function') this.rpcQueue[id].timeout.unref();
-      this.ws.send(JSON.stringify({
-        jsonrpc: '2.0',
-        method,
-        params,
-        id
-      }));
-    });
-  }
-
-  async processMessages() {
-    if (this.inProcessMessages) return null;
-    this.inProcessMessages = true;
-
-    try {
-      while (this.messageQueue.length) {
-        const items = this.messageQueue.splice(0, this.messageQueue.length);
-        await this.callback(items);
-      }
-    } catch (e) {
-      console.log(`Solana: error processing streams: ${e.message}`);
-    } finally {
-      this.inProcessMessages = false;
-    }
-  }
-
-  async close() {
-    clearTimeout(this.reconnectTimeout);
-    clearTimeout(this.pingTimeout);
-
-    if (this.ws && (this.isConnecting || this.isOpen)) {
-      // this.ws.send(JSON.stringify({ method: 'close' }))
-      await (0, _delay.default)((0, _ms.default)('1s')); // allow for the 'close' round-trip
-
-      await this.ws.close();
-      await this.ws.terminate();
-    }
-  }
-
-  async start() {
-    try {
-      if (!this.isClosed || this.shutdown) return;
-      this.ws = this.newSocket(this.endpoint);
-    } catch (e) {
-      console.log('Solana: error starting WS:', e);
-      this.doRestart();
-    }
-  }
-
-  async stop() {
-    if (this.shutdown) return;
-    this.shutdown = true;
-    await this.close();
-
-    while (this.running) {
-      await (0, _delay.default)((0, _ms.default)('1s'));
-    }
-  }
-
-} // Connection
-
-
-exports.Connection = Connection;

package/lib/index.js

@@ -1,68 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-var _exportNames = {};
-exports.default = void 0;
-
-var _basicUtils = require("@exodus/basic-utils");
-
-var _assets = require("@exodus/assets");
-
-var _solanaMeta = _interopRequireDefault(require("@exodus/solana-meta"));
-
-var _api = require("./api");
-
-Object.keys(_api).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
-  if (key in exports && exports[key] === _api[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _api[key];
-    }
-  });
-});
-
-var _txLog = require("./tx-log");
-
-Object.keys(_txLog).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
-  if (key in exports && exports[key] === _txLog[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _txLog[key];
-    }
-  });
-});
-
-var _accountState = require("./account-state");
-
-Object.keys(_accountState).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
-  if (key in exports && exports[key] === _accountState[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _accountState[key];
-    }
-  });
-});
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-// These are not the same asset objects as the wallet creates, so they should never be returned to the wallet.
-// Initially this may be violated by the Solana code until the first monitor tick updates assets with setTokens()
-const assets = (0, _assets.connectAssets)((0, _basicUtils.keyBy)(_solanaMeta.default, asset => asset.name)); // At some point we would like to exclude this export. Default export should be the whole asset "plugin" ready to be injected.
-// Clients should not call an specific server api directly.
-
-const serverApi = new _api.Api({
-  assets
-});
-var _default = serverApi;
-exports.default = _default;

package/lib/tx-log/index.js

@@ -1,18 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-
-var _solanaMonitor = require("./solana-monitor");
-
-Object.keys(_solanaMonitor).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _solanaMonitor[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _solanaMonitor[key];
-    }
-  });
-});

package/lib/tx-log/solana-monitor.js

@@ -1,357 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.SolanaMonitor = void 0;
-
-var _assetLib = require("@exodus/asset-lib");
-
-var _lodash = _interopRequireDefault(require("lodash"));
-
-var _minimalisticAssert = _interopRequireDefault(require("minimalistic-assert"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-const DEFAULT_POOL_ADDRESS = '9QU2QSxhb24FUX3Tu2FpczXjpK3VYrvRudywSZaM29mF'; // Everstake
-
-const DEFAULT_REMOTE_CONFIG = {
-  rpcs: [],
-  ws: [],
-  staking: {
-    enabled: true,
-    pool: DEFAULT_POOL_ADDRESS
-  }
-};
-
-class SolanaMonitor extends _assetLib.BaseMonitor {
-  constructor({
-    api,
-    includeUnparsed = false,
-    ...args
-  }) {
-    super(args);
-    (0, _minimalisticAssert.default)(api, 'api is required');
-    this.api = api;
-    this.cursors = {};
-    this.assets = {};
-    this.includeUnparsed = includeUnparsed;
-    this.addHook('before-stop', (...args) => this.beforeStop(...args));
-  }
-
-  async beforeStop() {
-    const walletAccounts = await this.aci.getWalletAccounts({
-      assetName: this.asset.name
-    });
-    return Promise.all(walletAccounts.map(walletAccount => this.stopListener({
-      walletAccount
-    })));
-  }
-
-  async initWalletAccount({
-    walletAccount
-  }) {
-    if (this.tickCount[walletAccount] === 0) {
-      await this.startListener({
-        walletAccount
-      });
-    }
-  }
-
-  async startListener({
-    walletAccount
-  }) {
-    const address = await this.aci.getReceiveAddress({
-      assetName: this.asset.name,
-      walletAccount
-    });
-    return this.api.watchAddress({
-      address
-      /*
-      // OPTIONAL. Relying on polling through ws
-      tokensAddresses: [], // needed for ASA subs
-      handleAccounts: (updates) => this.accountsCallback({ updates, walletAccount }),
-      handleTransfers: (txs) => {
-        // new SOL tx, ticking monitor
-        this.tick({ walletAccount }) // it will cause refresh for both sender/receiver. Without necessarily fetching the tx if it's not finalized in the node.
-      },
-      */
-
-    });
-  }
-
-  async stopListener({
-    walletAccount
-  }) {
-    const address = await this.aci.getReceiveAddress({
-      assetName: this.asset.name,
-      walletAccount
-    });
-    return this.api.unwatchAddress({
-      address
-    });
-  }
-
-  setServer(config = {}) {
-    const {
-      rpcs,
-      ws,
-      staking = {}
-    } = { ...DEFAULT_REMOTE_CONFIG,
-      ...config
-    };
-    this.api.setServer(rpcs[0]);
-    this.api.setWsEndpoint(ws[0]);
-    this.staking = staking;
-  }
-
-  hasNewCursor({
-    walletAccount,
-    cursorState
-  }) {
-    const {
-      cursor
-    } = cursorState;
-    return this.cursors[walletAccount] !== cursor;
-  }
-
-  async emitUnknownTokensEvent({
-    tokenAccounts
-  }) {
-    const tokensList = await this.api.getWalletTokensList({
-      tokenAccounts
-    });
-    const unknownTokensList = tokensList.filter(mintAddress => {
-      return !this.api.tokens[mintAddress];
-    });
-
-    if (unknownTokensList.length > 0) {
-      this.emit('unknown-tokens', unknownTokensList);
-    }
-  }
-
-  async tick({
-    walletAccount,
-    refresh
-  }) {
-    // Check for new wallet account
-    await this.initWalletAccount({
-      walletAccount
-    });
-    const assetName = this.asset.name;
-    this.assets = await this.aci.getAssetsForNetwork({
-      baseAssetName: assetName
-    });
-    this.api.setTokens(this.assets);
-    const accountState = await this.aci.getAccountState({
-      assetName,
-      walletAccount
-    });
-    const address = await this.aci.getReceiveAddress({
-      assetName,
-      walletAccount
-    });
-    const {
-      logItemsByAsset,
-      hasNewTxs,
-      cursorState
-    } = await this.getHistory({
-      address,
-      accountState,
-      walletAccount,
-      refresh
-    });
-    let staking = accountState.mem;
-    const cursorChanged = this.hasNewCursor({
-      walletAccount,
-      cursorState
-    });
-
-    if (refresh || cursorChanged) {
-      staking = await this.updateStakingInfo({
-        walletAccount,
-        address
-      });
-      this.cursors[walletAccount] = cursorState.cursor;
-    }
-
-    await this.updateTxLogByAsset({
-      walletAccount,
-      logItemsByAsset,
-      refresh
-    });
-
-    if (refresh || hasNewTxs || cursorChanged) {
-      const tokenAccounts = await this.api.getTokenAccountsByOwner(address);
-      await this.emitUnknownTokensEvent({
-        tokenAccounts
-      });
-      const account = await this.getAccount({
-        address,
-        staking,
-        tokenAccounts
-      });
-      await this.updateState({
-        account,
-        cursorState,
-        walletAccount
-      });
-    }
-  }
-
-  async getHistory({
-    address,
-    accountState,
-    refresh
-  } = {}) {
-    let cursor = refresh ? '' : accountState.cursor;
-    const baseAsset = this.asset;
-    const {
-      transactions,
-      newCursor
-    } = await this.api.getTransactions(address, {
-      cursor,
-      includeUnparsed: this.includeUnparsed
-    });
-    const mappedTransactions = [];
-
-    for (const tx of transactions) {
-      const assetName = _lodash.default.get(tx, 'token.tokenName', baseAsset.name);
-
-      const asset = this.assets[assetName];
-      if (assetName === 'unknown' || !asset) continue; // skip unknown tokens
-
-      const coinAmount = asset.currency.baseUnit(tx.amount).toDefault();
-      const item = {
-        coinName: assetName,
-        txId: tx.id,
-        from: [tx.from],
-        coinAmount,
-        confirmations: 1,
-        // tx.confirmations, // avoid multiple notifications
-        date: tx.date,
-        error: tx.error,
-        data: {
-          staking: tx.staking || null,
-          unparsed: !!tx.unparsed,
-          swapTx: !!(tx.data && tx.data.inner)
-        }
-      };
-
-      if (tx.owner === address) {
-        // send transaction
-        item.to = tx.to;
-        item.feeAmount = baseAsset.currency.baseUnit(tx.fee).toDefault(); // in SOL
-
-        item.coinAmount = item.coinAmount.negate();
-
-        if (tx.to === tx.owner) {
-          item.selfSend = true;
-          item.coinAmount = asset.currency.ZERO;
-        }
-      } else if (tx.unparsed) {
-        if (tx.fee !== 0) item.feeAmount = baseAsset.currency.baseUnit(tx.fee).toDefault(); // in SOL
-
-        item.data.meta = tx.data.meta;
-      }
-
-      if (asset.assetType === 'SOLANA_TOKEN' && item.feeAmount && item.feeAmount.isPositive) {
-        const feeAsset = asset.feeAsset;
-        const feeItem = { ..._lodash.default.clone(item),
-          coinName: feeAsset.name,
-          tokens: [asset.name],
-          coinAmount: feeAsset.currency.ZERO
-        };
-        mappedTransactions.push(feeItem);
-      }
-
-      mappedTransactions.push(item);
-    } // logItemsByAsset = { 'solana:': [...], 'serum': [...] }
-
-
-    return {
-      logItemsByAsset: _lodash.default.groupBy(mappedTransactions, item => item.coinName),
-      hasNewTxs: transactions.length > 0,
-      cursorState: {
-        cursor: newCursor
-      }
-    };
-  }
-
-  async getAccount({
-    address,
-    staking,
-    tokenAccounts
-  }) {
-    const tokens = Object.keys(this.assets).filter(name => name !== this.asset.name);
-    const [solBalance, splBalances] = await Promise.all([this.api.getBalance(address), this.api.getTokensBalance({
-      address,
-      filterByTokens: tokens,
-      tokenAccounts
-    })]);
-    const stakedBalance = this.asset.currency.baseUnit(staking.locked).toDefault();
-    const withdrawableBalance = this.asset.currency.baseUnit(staking.withdrawable).toDefault();
-    const pendingBalance = this.asset.currency.baseUnit(staking.pending).toDefault();
-    const balance = this.asset.currency.baseUnit(solBalance).toDefault().add(stakedBalance).add(withdrawableBalance).add(pendingBalance);
-
-    const tokenBalances = _lodash.default.mapValues(splBalances, (balance, name) => this.assets[name].currency.baseUnit(balance).toDefault());
-
-    return {
-      balance,
-      tokenBalances
-    };
-  }
-
-  async updateState({
-    account,
-    cursorState,
-    walletAccount
-  }) {
-    const {
-      balance,
-      tokenBalances
-    } = account;
-    const newData = {
-      balance,
-      tokenBalances,
-      ...cursorState
-    };
-    return this.updateAccountState({
-      newData,
-      walletAccount
-    });
-  }
-
-  async updateStakingInfo({
-    walletAccount,
-    address
-  }) {
-    const stakingInfo = await this.api.getStakeAccountsInfo(address);
-    const rewards = await this.api.getRewards(Object.keys(stakingInfo.accounts));
-    const mem = {
-      loaded: true,
-      staking: this.staking,
-      isDelegating: Object.values(stakingInfo.accounts).some(({
-        state
-      }) => ['active', 'activating', 'inactive'].includes(state)),
-      // true if at least 1 account is delegating
-      locked: this.asset.currency.baseUnit(stakingInfo.locked).toDefault(),
-      withdrawable: this.asset.currency.baseUnit(stakingInfo.withdrawable).toDefault(),
-      pending: this.asset.currency.baseUnit(stakingInfo.pending).toDefault(),
-      // still undelegating (not yet available for withdraw)
-      earned: this.asset.currency.baseUnit(rewards).toDefault(),
-      accounts: stakingInfo.accounts // Obj
-
-    };
-    await this.updateAccountState({
-      walletAccount,
-      newData: {
-        mem
-      }
-    });
-    return mem;
-  }
-
-}
-
-exports.SolanaMonitor = SolanaMonitor;