@exodus/solana-api 2.5.0 → 2.5.3

package/lib/connection.js

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

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

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

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