@trezor/connect/lib/backend/BackendManager.js

High-level javascript interface for Trezor hardware wallet.

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.BackendManager = void 0;
const constants_1 = require("../constants");
const Blockchain_1 = require("./Blockchain");
const DataManager_1 = require("../data/DataManager");
const events_1 = require("../events");
const DEFAULT_IDENTITY = 'default';
class BackendManager {
  instances = {};
  reconnect = {};
  custom = {};
  preferred = {};
  get(shortcut, identity = DEFAULT_IDENTITY) {
    return this.instances[`${shortcut}/${identity}`] ?? null;
  }
  async getOrConnect({
    coinInfo,
    postMessage,
    identity
  }) {
    const coinIdentity = `${coinInfo.shortcut}/${identity ?? DEFAULT_IDENTITY}`;
    let backend = this.instances[coinIdentity];
    if (!backend) {
      backend = new Blockchain_1.Blockchain({
        coinInfo: this.patchCoinInfo(coinInfo),
        identity,
        debug: DataManager_1.DataManager.getSettings('debug'),
        proxy: DataManager_1.DataManager.getSettings('proxy'),
        postMessage,
        onDisconnected: pendingSubscriptions => {
          const reconnectAttempts = pendingSubscriptions ? 0 : undefined;
          this.onDisconnect({
            coinInfo,
            postMessage,
            identity
          }, reconnectAttempts);
        }
      });
      this.setInstance(coinIdentity, backend);
    }
    const reconnect = this.clearReconnect(coinIdentity);
    try {
      const info = await backend.init();
      this.setPreferred(coinInfo.shortcut, info.url);
      return backend;
    } catch (error) {
      this.onDisconnect({
        coinInfo,
        postMessage,
        identity
      }, reconnect?.attempts);
      throw error;
    }
  }
  dispose() {
    Object.keys(this.reconnect).filter(this.getReconnectFilter()).forEach(this.clearReconnect, this);
    Object.values(this.instances).forEach(i => i.disconnect());
  }
  reconnectAll(coin) {
    const backends = Object.values(this.instances).filter(backend => !coin || coin.shortcut === backend.coinInfo.shortcut);
    backends.forEach(i => i.disconnect());
    return Promise.all(backends.map(this.getOrConnect, this));
  }
  isSupported(coinInfo) {
    const info = this.custom[coinInfo.shortcut] || coinInfo.blockchainLink;
    if (!info) {
      throw constants_1.ERRORS.TypedError('Backend_NotSupported');
    }
  }
  setCustom(shortcut, blockchainLink) {
    this.setPreferred(shortcut, undefined);
    if (blockchainLink) {
      this.custom[shortcut] = blockchainLink;
    } else {
      delete this.custom[shortcut];
    }
  }
  setInstance(coinIdentity, instance) {
    if (!instance) delete this.instances[coinIdentity];else this.instances[coinIdentity] = instance;
  }
  setPreferred(shortcut, url) {
    if (!url) delete this.preferred[shortcut];else this.preferred[shortcut] = url;
  }
  onDisconnect({
    coinInfo,
    postMessage,
    identity
  }, reconnectAttempt) {
    const coinIdentity = `${coinInfo.shortcut}/${identity ?? DEFAULT_IDENTITY}`;
    this.setInstance(coinIdentity, undefined);
    if (reconnectAttempt === undefined || reconnectAttempt === 4) {
      this.setPreferred(coinInfo.shortcut, undefined);
    }
    if (reconnectAttempt === undefined) {
      return;
    }
    const timeout = Math.min(2500 * reconnectAttempt, 20000);
    const time = Date.now() + timeout;
    const handle = setTimeout(() => {
      this.getOrConnect({
        coinInfo,
        postMessage,
        identity
      }).catch(() => {});
    }, timeout);
    clearTimeout(this.reconnect[coinIdentity]?.handle);
    this.reconnect[coinIdentity] = {
      attempts: reconnectAttempt + 1,
      handle
    };
    postMessage((0, events_1.createBlockchainMessage)(events_1.BLOCKCHAIN.RECONNECTING, {
      coin: coinInfo,
      identity,
      time
    }));
  }
  clearReconnect(coinIdentity) {
    const reconnect = this.reconnect[coinIdentity];
    clearTimeout(reconnect?.handle);
    delete this.reconnect[coinIdentity];
    return reconnect;
  }
  patchCoinInfo(coinInfo) {
    const custom = this.custom[coinInfo.shortcut];
    const preferred = this.preferred[coinInfo.shortcut];
    const url = preferred ? [preferred] : custom?.url ?? coinInfo.blockchainLink?.url;
    return {
      ...coinInfo,
      blockchainLink: {
        ...coinInfo.blockchainLink,
        ...custom,
        url
      }
    };
  }
  getReconnectFilter(coinInfo) {
    return key => !coinInfo || key.startsWith(`${coinInfo.shortcut}/`);
  }
}
exports.BackendManager = BackendManager;
//# sourceMappingURL=BackendManager.js.map