@exodus/solana-api 2.5.18 → 2.5.20

package/lib/pay/validateBeforePay.js

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ValidateError = void 0;
+exports.validateBeforePay = validateBeforePay;
+
+var _ = _interopRequireDefault(require(".."));
+
+var _currency = _interopRequireDefault(require("@exodus/currency"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+class ValidateError extends Error {
+  constructor(...args) {
+    super(...args);
+    this.name = 'ValidateError';
+  }
+
+}
+
+exports.ValidateError = ValidateError;
+
+async function validateBeforePay({
+  asset,
+  senderInfo,
+  amount,
+  feeAmount = 0,
+  recipient,
+  checkEnoughBalance = true
+}) {
+  const isNative = asset.name === asset.baseAsset.name;
+  const recipientInfo = await _.default.getAccountInfo(recipient);
+  if (!recipientInfo) throw new ValidateError(`recipient ${recipient} not found`);
+
+  if (checkEnoughBalance) {
+    const totalAmountMustPay = asset.currency.defaultUnit(amount).add(feeAmount);
+    const currentBalance = isNative ? senderInfo.balance : senderInfo.tokenBalances[asset.name];
+    if (totalAmountMustPay.gt(currentBalance)) throw new ValidateError(`insufficient funds`);
+  }
+
+  return true;
+}

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,354 @@
+"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
+    });
+
+    if (tokensList.length > 0) {
+      this.emit('unknown-tokens', tokensList);
+    }
+  }
+
+  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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/solana-api",
-  "version": "2.5.18",
+  "version": "2.5.20",
   "description": "Exodus internal Solana asset API wrapper",
   "main": "src/index.js",
   "files": [
@@ -23,7 +23,7 @@
     "@exodus/models": "^10.1.0",
     "@exodus/nfts-core": "^0.5.0",
     "@exodus/simple-retry": "^0.0.6",
-    "@exodus/solana-lib": "^1.6.10",
+    "@exodus/solana-lib": "^1.6.11",
     "@exodus/solana-meta": "^1.0.3",
     "bn.js": "^4.11.0",
     "debug": "^4.1.1",
@@ -34,5 +34,5 @@
   "devDependencies": {
     "@exodus/assets-testing": "file:../../../__testing__"
   },
-  "gitHead": "1210a44d1b6a8fc0375589f7e2439aa3fd0f6b01"
+  "gitHead": "9ec7084bcdfe14f1c6f11df393351885773046a6"
 }