@exodus/solana-api 2.5.18 → 2.5.20

package/lib/connection.js

@@ -0,0 +1,262 @@
+"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).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 _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];
+    }
+  });
+});
+
+var _pay = require("./pay");
+
+Object.keys(_pay).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _pay[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _pay[key];
+    }
+  });
+});
+// 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();
+var _default = serverApi;
+exports.default = _default;

package/lib/pay/fetchTransaction.js

@@ -0,0 +1,157 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ParseTransactionError = exports.FetchTransactionError = void 0;
+exports.fetchTransaction = fetchTransaction;
+
+var _tweetnacl = _interopRequireDefault(require("tweetnacl"));
+
+var _fetch = require("@exodus/fetch");
+
+var _ms = _interopRequireDefault(require("ms"));
+
+var _solanaWeb = require("@exodus/solana-web3.js");
+
+var _ = _interopRequireDefault(require(".."));
+
+var _bignumber = _interopRequireDefault(require("bignumber.js"));
+
+var _solanaLib = require("@exodus/solana-lib");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+class FetchTransactionError extends Error {
+  constructor(...args) {
+    super(...args);
+    this.name = 'FetchTransactionError';
+  }
+
+}
+
+exports.FetchTransactionError = FetchTransactionError;
+
+class ParseTransactionError extends Error {
+  constructor(...args) {
+    super(...args);
+    this.name = 'ParseTransactionError';
+  }
+
+}
+
+exports.ParseTransactionError = ParseTransactionError;
+
+const isTransferCheckedInstruction = decodedInstruction => decodedInstruction.type === 'transferChecked';
+
+const isTransferInstruction = decodedInstruction => decodedInstruction.type === 'transfer';
+
+const isSplAccount = account => account && account.owner === 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA';
+
+async function fetchTransaction({
+  account,
+  link,
+  commitment
+}) {
+  const response = await (0, _fetch.fetchival)(String(link), {
+    mode: 'cors',
+    cache: 'no-cache',
+    credentials: 'omit',
+    timeout: (0, _ms.default)('10s'),
+    headers: {
+      Accept: 'application/json',
+      'Content-Type': 'application/json'
+    }
+  }).post({
+    account
+  });
+  if (!response || !response.transaction) throw new FetchTransactionError('missing transaction');
+  const {
+    transaction: txString
+  } = response;
+  if (typeof txString !== 'string') throw new FetchTransactionError('invalid transaction');
+
+  const transaction = _solanaWeb.Transaction.from(Buffer.from(txString, 'base64'));
+
+  const {
+    signatures,
+    feePayer,
+    recentBlockhash
+  } = transaction;
+
+  if (signatures.length) {
+    if (!feePayer) throw new FetchTransactionError('missing fee payer');
+    if (!feePayer.equals(signatures[0].publicKey)) throw new FetchTransactionError('invalid fee payer');
+    if (!recentBlockhash) throw new FetchTransactionError('missing recent blockhash'); // A valid signature for everything except `account` must be provided.
+
+    const message = transaction.serializeMessage();
+
+    for (const {
+      signature,
+      publicKey
+    } of signatures) {
+      if (signature) {
+        if (!_tweetnacl.default.sign.detached.verify(message, signature, publicKey.toBuffer())) throw new FetchTransactionError('invalid signature');
+      } else if (publicKey.equals(new _solanaWeb.PublicKey(account))) {
+        // If the only signature expected is for `account`, ignore the recent blockhash in the transaction.
+        if (signatures.length === 1) {
+          transaction.recentBlockhash = await _.default.getRecentBlockHash(commitment);
+        }
+      } else {
+        throw new FetchTransactionError('missing signature');
+      }
+    }
+  } else {
+    // Ignore the fee payer and recent blockhash in the transaction and initialize them.
+    transaction.feePayer = account;
+    transaction.recentBlockhash = await _.default.getRecentBlockHash(commitment);
+  }
+
+  return parseInstructions(transaction);
+}
+
+async function parseInstructions(transaction) {
+  // Make a copy of the instructions we're going to mutate it.
+  const instructions = transaction.instructions.slice();
+  if (!instructions || !Array.isArray(instructions) || instructions.length !== 1) throw new ParseTransactionError('Invalid transaction instructions'); // Transfer instruction must be the last instruction
+
+  const instruction = instructions.pop();
+  if (!instruction) throw new ParseTransactionError('missing transfer instruction');
+  const isTokenTransfer = instruction.programId.equals(_solanaLib.TOKEN_PROGRAM_ID);
+  const isSolNativeTransfer = instruction.programId.equals(_solanaLib.SYSTEM_PROGRAM_ID);
+
+  if (isTokenTransfer) {
+    const decodedInstruction = (0, _solanaLib.decodeTokenProgramInstruction)(instruction);
+    if (!isTransferCheckedInstruction(decodedInstruction) && !isTransferInstruction(decodedInstruction)) throw new ParseTransactionError('invalid token transfer');
+    const [, mint, destination, owner] = instruction.keys;
+    const splToken = mint.pubkey.toBase58();
+    let asset;
+    let recipient = destination.pubkey.toBase58();
+
+    if (splToken) {
+      if (!_.default.isTokenSupported(splToken)) throw new ParseTransactionError(`spl-token ${splToken} is not supported`);
+      asset = _.default.getTokenByAddress(splToken);
+      const account = await _.default.getAccountInfo(recipient);
+      if (isSplAccount(account)) recipient = account.data.parsed.info.owner;
+    }
+
+    return {
+      amount: asset.currency.baseUnit(new _bignumber.default(decodedInstruction.data.amount).toString()).toDefaultString(),
+      decimals: decodedInstruction.data.decimals,
+      recipient,
+      sender: owner.pubkey.toBase58(),
+      splToken,
+      asset
+    };
+  } else if (isSolNativeTransfer) {
+    const decodedTransaction = _solanaWeb.SystemInstruction.decodeTransfer(instruction);
+
+    return {
+      sender: decodedTransaction.fromPubkey.toString(),
+      amount: decodedTransaction.lamports.toString(),
+      recipient: decodedTransaction.toPubkey.toString()
+    };
+  }
+
+  throw new Error('Invalid transfer instruction');
+}

package/lib/pay/index.js

@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _parseURL = require("./parseURL.js");
+
+Object.keys(_parseURL).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _parseURL[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _parseURL[key];
+    }
+  });
+});
+
+var _prepareSendData = require("./prepareSendData.js");
+
+Object.keys(_prepareSendData).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _prepareSendData[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _prepareSendData[key];
+    }
+  });
+});
+
+var _validateBeforePay = require("./validateBeforePay");
+
+Object.keys(_validateBeforePay).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _validateBeforePay[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _validateBeforePay[key];
+    }
+  });
+});
+
+var _fetchTransaction = require("./fetchTransaction");
+
+Object.keys(_fetchTransaction).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _fetchTransaction[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _fetchTransaction[key];
+    }
+  });
+});

package/lib/pay/parseURL.js

@@ -0,0 +1,120 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ParseURLError = void 0;
+exports.parseURL = parseURL;
+
+var _solanaLib = require("@exodus/solana-lib");
+
+var _bignumber = _interopRequireDefault(require("bignumber.js"));
+
+var _assets = _interopRequireDefault(require("@exodus/assets"));
+
+var _urlSearchParams = _interopRequireDefault(require("@ungap/url-search-params"));
+
+var _ = _interopRequireDefault(require(".."));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const SOLANA_PROTOCOL = 'solana:';
+const HTTPS_PROTOCOL = 'https:';
+
+class ParseURLError extends Error {
+  constructor(...args) {
+    super(...args);
+    this.name = 'ParseURLError';
+  }
+
+}
+
+exports.ParseURLError = ParseURLError;
+
+function parseURL(url) {
+  if (typeof url === 'string') {
+    if (url.length > 2048) throw new ParseURLError('length invalid');
+    url = new URL(url);
+  }
+
+  if (url.protocol !== SOLANA_PROTOCOL) throw new ParseURLError('protocol invalid');
+  if (!url.pathname) throw new ParseURLError('pathname missing');
+  return /[:%]/.test(url.pathname) ? parseTransactionRequestURL(url) : parseTransferRequestURL(url);
+}
+
+function parseTransactionRequestURL(url) {
+  const link = new URL(decodeURIComponent(url.pathname));
+  const searchParams = new _urlSearchParams.default(url.search);
+  if (link.protocol !== HTTPS_PROTOCOL) throw new ParseURLError('link invalid');
+  const label = searchParams.get('label') || undefined;
+  const message = searchParams.get('message') || undefined;
+  return {
+    link,
+    label,
+    message
+  };
+}
+
+function parseTransferRequestURL(url) {
+  let recipient;
+
+  try {
+    recipient = new _solanaLib.PublicKey(url.pathname);
+  } catch (error) {
+    throw new Error('ParseURLError: recipient invalid');
+  }
+
+  const searchParams = new _urlSearchParams.default(url.search);
+  let amount;
+  const amountParam = searchParams.get('amount');
+
+  if (amountParam) {
+    if (!/^\d+(\.\d+)?$/.test(amountParam)) throw new Error('ParseURLError: amount invalid');
+    amount = new _bignumber.default(amountParam);
+    if (amount.isNaN()) throw new Error('ParseURLError: amount NaN');
+    if (amount.isNegative()) throw new Error('ParseURLError: amount negative');
+  }
+
+  let splToken;
+  const splTokenParam = searchParams.get('spl-token');
+
+  if (splTokenParam) {
+    try {
+      splToken = new _solanaLib.PublicKey(splTokenParam);
+    } catch (error) {
+      throw new ParseURLError('spl-token invalid');
+    }
+  }
+
+  let asset = _assets.default.solana;
+
+  if (splToken) {
+    if (!_.default.isTokenSupported(splToken)) throw new ParseURLError(`spl-token ${splToken} is not supported`);
+    asset = _.default.getTokenByAddress(splToken);
+  }
+
+  let reference;
+  const referenceParams = searchParams.getAll('reference');
+
+  if (referenceParams.length) {
+    try {
+      reference = referenceParams.map(reference => new _solanaLib.PublicKey(reference));
+    } catch (error) {
+      throw new ParseURLError('reference invalid');
+    }
+  }
+
+  const label = searchParams.get('label') || undefined;
+  const message = searchParams.get('message') || undefined;
+  const memo = searchParams.get('memo') || undefined;
+  return {
+    asset,
+    recipient: recipient.toString(),
+    amount: amount ? amount.toString(10) : undefined,
+    splToken: splToken ? splToken.toString() : undefined,
+    reference,
+    label,
+    message,
+    memo
+  };
+}

package/lib/pay/prepareSendData.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.prepareSendData = prepareSendData;
+
+var _assert = _interopRequireDefault(require("assert"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function prepareSendData(parsedData, {
+  asset,
+  feeAmount,
+  walletAccount
+}) {
+  const {
+    amount: amountStr,
+    recipient,
+    splToken,
+    ...options
+  } = parsedData;
+  (0, _assert.default)(amountStr, 'PrepareTxError: Missing amount');
+  (0, _assert.default)(recipient, 'PrepareTxError: Missing recipient');
+  const amount = asset.currency.defaultUnit(amountStr);
+  return {
+    asset: asset.name,
+    baseAsset: asset.baseAsset,
+    customMintAddress: splToken,
+    feeAmount,
+    receiver: {
+      address: recipient,
+      amount
+    },
+    walletAccount,
+    ...options
+  };
+}