@subwallet/extension-base 1.3.41-0 → 1.3.42-0

package/cjs/services/request-service/index.js

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
+var _BitcoinRequestHandler = _interopRequireDefault(require("@subwallet/extension-base/services/request-service/handler/BitcoinRequestHandler"));
 var _CardanoRequestHandler = _interopRequireDefault(require("@subwallet/extension-base/services/request-service/handler/CardanoRequestHandler"));
 var _TonRequestHandler = _interopRequireDefault(require("./handler/TonRequestHandler"));
 var _handler = require("./handler");
@@ -19,13 +20,14 @@ class RequestService {
   #authRequestHandler;
   #substrateRequestHandler;
   #evmRequestHandler;
+  #bitcoinRequestHandler;
   #tonRequestHandler;
   #cardanoRequestHandler;
   #connectWCRequestHandler;
   #notSupportWCRequestHandler;
 
   // Common
-  constructor(chainService, settingService, keyringService) {
+  constructor(chainService, settingService, keyringService, feeService, transactionService) {
     this.#chainService = chainService;
     this.settingService = settingService;
     this.keyringService = keyringService;
@@ -36,6 +38,7 @@ class RequestService {
     this.#evmRequestHandler = new _handler.EvmRequestHandler(this);
     this.#tonRequestHandler = new _TonRequestHandler.default(this);
     this.#cardanoRequestHandler = new _CardanoRequestHandler.default(this);
+    this.#bitcoinRequestHandler = new _BitcoinRequestHandler.default(this, this.#chainService, feeService, transactionService);
     this.#connectWCRequestHandler = new _handler.ConnectWCRequestHandler(this);
     this.#notSupportWCRequestHandler = new _handler.NotSupportWCRequestHandler(this);
 
@@ -43,7 +46,7 @@ class RequestService {
     this.updateIconV2();
   }
   get numAllRequests() {
-    return this.allSubstrateRequests.length + this.numEvmRequests + this.numTonRequests + this.numCardanoRequests;
+    return this.allSubstrateRequests.length + this.numEvmRequests + this.numTonRequests + this.numCardanoRequests + this.numBitcoinRequests;
   }
   updateIconV2(shouldClose) {
     this.#popupHandler.updateIconV2(shouldClose);
@@ -156,6 +159,9 @@ class RequestService {
   get numCardanoRequests() {
     return this.#cardanoRequestHandler.numCardanoRequests;
   }
+  get numBitcoinRequests() {
+    return this.#bitcoinRequestHandler.numBitcoinRequests;
+  }
   get confirmationsQueueSubject() {
     return this.#evmRequestHandler.getConfirmationsQueueSubject();
   }
@@ -201,6 +207,25 @@ class RequestService {
     return this.#evmRequestHandler.updateConfirmation(id, type, payload, options, validator);
   }
 
+  // Bitcoin requests
+
+  get confirmationsQueueSubjectBitcoin() {
+    return this.#bitcoinRequestHandler.getConfirmationsQueueSubjectBitcoin();
+  }
+  addConfirmationBitcoin(id, url, type, payload) {
+    let options = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
+    let validator = arguments.length > 5 ? arguments[5] : undefined;
+    return this.#bitcoinRequestHandler.addConfirmationBitcoin(id, url, type, payload, options, validator);
+  }
+  async completeConfirmationBitcoin(request) {
+    return await this.#bitcoinRequestHandler.completeConfirmationBitcoin(request);
+  }
+  updateConfirmationBitcoin(id, type, payload) {
+    let options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+    let validator = arguments.length > 4 ? arguments[4] : undefined;
+    return this.#bitcoinRequestHandler.updateConfirmationBitcoin(id, type, payload, options, validator);
+  }
+
   // WalletConnect Connect requests
   getConnectWCRequest(id) {
     return this.#connectWCRequestHandler.getConnectWCRequest(id);
@@ -237,7 +262,7 @@ class RequestService {
 
   // General methods
   get numRequests() {
-    return this.numMetaRequests + this.numAuthRequests + this.numSubstrateRequests + this.numEvmRequests + this.numConnectWCRequests + this.numNotSupportWCRequests + this.numTonRequests + this.numCardanoRequests;
+    return this.numMetaRequests + this.numAuthRequests + this.numSubstrateRequests + this.numEvmRequests + this.numConnectWCRequests + this.numNotSupportWCRequests + this.numTonRequests + this.numCardanoRequests + this.numBitcoinRequests;
   }
   resetWallet() {
     this.#authRequestHandler.resetWallet();
@@ -245,6 +270,7 @@ class RequestService {
     this.#evmRequestHandler.resetWallet();
     this.#tonRequestHandler.resetWallet();
     this.#cardanoRequestHandler.resetWallet();
+    this.#bitcoinRequestHandler.resetWallet();
     this.#metadataRequestHandler.resetWallet();
     this.#connectWCRequestHandler.resetWallet();
     this.#notSupportWCRequestHandler.resetWallet();

package/cjs/services/rune-service/index.js

@@ -0,0 +1,105 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RunesService = void 0;
+var _SWError = require("@subwallet/extension-base/background/errors/SWError");
+var _constants = require("@subwallet/extension-base/services/chain-service/constants");
+var _apiRequestStrategy = require("@subwallet/extension-base/strategy/api-request-strategy");
+var _base = require("@subwallet/extension-base/strategy/api-request-strategy/context/base");
+var _utils = require("@subwallet/extension-base/strategy/api-request-strategy/utils");
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+const BITCOIN_API_URL = 'https://btc-api.koni.studio';
+const BITCOIN_API_URL_TEST = 'https://api-testnet.openbit.app';
+class RunesService extends _apiRequestStrategy.BaseApiRequestStrategy {
+  constructor(url) {
+    const context = new _base.BaseApiRequestContext();
+    super(context);
+    this.baseUrl = url;
+  }
+  headers = {
+    'Content-Type': 'application/json',
+    Authorization: `Bearer ${_constants._BTC_SERVICE_TOKEN}`
+  };
+  isRateLimited() {
+    return false;
+  }
+  getUrl(path) {
+    return `${this.baseUrl}/${path}`;
+  }
+  getAddressRunesInfo(address, params) {
+    return this.addRequest(async () => {
+      const _rs = await (0, _utils.getRequest)(this.getUrl(`rune/address/${address}`), params, this.headers);
+      const rs = await _rs.json();
+      if (rs.status_code !== 200) {
+        throw new _SWError.SWError('RuneScanService.getAddressRunesInfo', rs.message);
+      }
+      return rs.result;
+    }, 1);
+  }
+
+  // * Deprecated
+  getRuneCollectionsByBatch(params) {
+    return this.addRequest(async () => {
+      const url = this.getUrl('rune');
+      const rs = await (0, _utils.getRequest)(url, params);
+      if (rs.status !== 200) {
+        throw new _SWError.SWError('RuneScanService.getRuneCollectionsByBatch', await rs.text());
+      }
+      return await rs.json();
+    }, 1);
+  }
+
+  // * Deprecated
+  getAddressRuneTxs(address, params) {
+    return this.addRequest(async () => {
+      const url = this.getUrl(`address/${address}/txs`);
+      const rs = await (0, _utils.getRequest)(url, params);
+      if (rs.status !== 200) {
+        throw new _SWError.SWError('RuneScanService.getAddressRuneTxs', await rs.text());
+      }
+      return await rs.json();
+    }, 0);
+  }
+  getRuneMetadata(runeid) {
+    return this.addRequest(async () => {
+      const _rs = await (0, _utils.getRequest)(this.getUrl(`rune/metadata/${runeid}`), undefined, this.headers);
+      const rs = await _rs.json();
+      if (rs.status_code !== 200) {
+        throw new _SWError.SWError('RuneScanService.getRuneMetadata', rs.message);
+      }
+      return rs.result;
+    }, 0);
+  }
+  getAddressRuneUtxos(address) {
+    return this.addRequest(async () => {
+      const _rs = await (0, _utils.getRequest)(this.getUrl(`rune/address/${address}/rune/utxo`), undefined, this.headers);
+      const rs = await _rs.json();
+      if (rs.status_code !== 200) {
+        throw new _SWError.SWError('RuneScanService.getAddressRuneUtxos', rs.message);
+      }
+      return rs.result;
+    }, 0);
+  }
+
+  // Singleton
+
+  static getInstance() {
+    let isTestnet = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+    if (isTestnet) {
+      if (!RunesService.testnet) {
+        RunesService.testnet = new RunesService(BITCOIN_API_URL_TEST);
+      }
+      return RunesService.testnet;
+    } else {
+      if (!RunesService.mainnet) {
+        RunesService.mainnet = new RunesService(BITCOIN_API_URL);
+      }
+      return RunesService.mainnet;
+    }
+  }
+}
+exports.RunesService = RunesService;

package/cjs/services/transaction-service/helpers/index.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.isTonTransaction = exports.isSubstrateTransaction = exports.isCardanoTransaction = exports.getValidationId = exports.getTransactionId = exports.getBaseTransactionInfo = void 0;
+exports.isTonTransaction = exports.isSubstrateTransaction = exports.isCardanoTransaction = exports.isBitcoinTransaction = exports.getValidationId = exports.getTransactionId = exports.getBaseTransactionInfo = void 0;
 var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
 // Copyright 2019-2022 @subwallet/extension-base authors & contributors
 // SPDX-License-Identifier: Apache-2.0
@@ -32,7 +32,13 @@ const isCardanoTransaction = tx => {
   const cardanoTransactionConfig = tx;
   return cardanoTransactionConfig.cardanoPayload !== null && cardanoTransactionConfig.cardanoPayload !== undefined;
 };
+
+// TODO: [Review] this function
 exports.isCardanoTransaction = isCardanoTransaction;
+const isBitcoinTransaction = tx => {
+  return 'data' in tx && Array.isArray(tx.data.inputs);
+};
+exports.isBitcoinTransaction = isBitcoinTransaction;
 const typeName = type => {
   switch (type) {
     case _KoniTypes.ExtrinsicType.TRANSFER_BALANCE:

package/cjs/services/transaction-service/index.js

@@ -46,10 +46,6 @@ class TransactionService {
   }
   constructor(state) {
     this.state = state;
-    this.eventService = state.eventService;
-    this.historyService = state.historyService;
-    this.notificationService = state.notificationService;
-    this.chainService = state.chainService;
   }
   get allTransactions() {
     return Object.values(this.transactions);
@@ -81,6 +77,7 @@ class TransactionService {
       additionalValidator,
       address,
       chain,
+      chainType,
       extrinsicType
     } = validationResponse;
     const chainInfo = this.state.chainService.getChainInfoByKey(chain);
@@ -110,27 +107,30 @@ class TransactionService {
     const evmApi = this.state.chainService.getEvmApi(chainInfo.slug);
     const tonApi = this.state.chainService.getTonApi(chainInfo.slug);
     const cardanoApi = this.state.chainService.getCardanoApi(chainInfo.slug);
+    const bitcoinApi = this.state.chainService.getBitcoinApi(chainInfo.slug);
     // todo: should split into isEvmTx && isNoEvmApi. Because other chains type also has no Evm Api. Same to all blockchain.
     // todo: refactor check evmTransaction.
-    const isNoEvmApi = transaction && !(0, _helpers.isSubstrateTransaction)(transaction) && !(0, _helpers.isTonTransaction)(transaction) && !(0, _helpers.isCardanoTransaction)(transaction) && !evmApi;
+    const isNoEvmApi = transaction && !(0, _helpers.isSubstrateTransaction)(transaction) && !(0, _helpers.isTonTransaction)(transaction) && !(0, _helpers.isCardanoTransaction)(transaction) && !(0, _helpers.isBitcoinTransaction)(transaction) && !evmApi;
     const isNoTonApi = transaction && (0, _helpers.isTonTransaction)(transaction) && !tonApi;
     const isNoCardanoApi = transaction && (0, _helpers.isCardanoTransaction)(transaction) && !cardanoApi;
-    if (isNoEvmApi || isNoTonApi || isNoCardanoApi) {
+    const isNoBitcoinApi = transaction && (0, _helpers.isBitcoinTransaction)(transaction) && !bitcoinApi;
+    if (isNoEvmApi || isNoTonApi || isNoCardanoApi || isNoBitcoinApi) {
       validationResponse.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.CHAIN_DISCONNECTED, undefined));
     }
 
     // Estimate fee for transaction
     const id = (0, _getId.getId)();
-    const feeInfo = await this.state.feeService.subscribeChainFee(id, chain, 'evm');
+    const feeInfo = await this.state.feeService.subscribeChainFee(id, chain, chainType);
     const nativeTokenInfo = this.state.chainService.getNativeTokenInfo(chain);
     const tokenPayFeeSlug = transactionInput.tokenPayFeeSlug;
     const isNonNativeTokenPayFee = tokenPayFeeSlug && !(0, _utils2._isNativeTokenBySlug)(tokenPayFeeSlug);
-    const nonNativeTokenPayFeeInfo = isNonNativeTokenPayFee ? this.chainService.getAssetBySlug(tokenPayFeeSlug) : undefined;
+    const nonNativeTokenPayFeeInfo = isNonNativeTokenPayFee ? this.state.chainService.getAssetBySlug(tokenPayFeeSlug) : undefined;
     const priceMap = (await this.state.priceService.getPrice()).priceMap;
     validationResponse.estimateFee = await (0, _transfer.estimateFeeForTransaction)(validationResponse, transaction, chainInfo, evmApi, substrateApi, priceMap, feeInfo, nativeTokenInfo, nonNativeTokenPayFeeInfo, transactionInput.isTransferLocalTokenAndPayThatTokenAsFee);
     const chainInfoMap = this.state.chainService.getChainInfoMap();
 
     // Check account signing transaction
+
     (0, _transfer.checkSigningAccountForTransaction)(validationResponse, chainInfoMap);
     const nativeTokenAvailable = await this.state.balanceService.getTransferableBalance(address, chain, nativeTokenInfo.slug, extrinsicType);
 
@@ -193,7 +193,7 @@ class TransactionService {
   }
   fillTransactionDefaultInfo(transaction) {
     const isInternal = !transaction.url;
-    const transactionId = (0, _helpers.getTransactionId)(transaction.chainType, transaction.chain, isInternal, (0, _helpers2.isWalletConnectRequest)(transaction.id));
+    const transactionId = transaction.id || (0, _helpers.getTransactionId)(transaction.chainType, transaction.chain, isInternal, (0, _helpers2.isWalletConnectRequest)(transaction.id));
     return {
       ...transaction,
       createdAt: new Date().getTime(),
@@ -417,7 +417,7 @@ class TransactionService {
   }
   async sendTransaction(transaction) {
     // Send Transaction
-    const emitter = await (transaction.chainType === 'substrate' ? this.signAndSendSubstrateTransaction(transaction) : transaction.chainType === 'evm' ? this.signAndSendEvmTransaction(transaction) : transaction.chainType === 'cardano' ? this.signAndSendCardanoTransaction(transaction) : this.signAndSendTonTransaction(transaction));
+    const emitter = await (transaction.chainType === 'substrate' ? this.signAndSendSubstrateTransaction(transaction) : transaction.chainType === 'evm' ? this.signAndSendEvmTransaction(transaction) : transaction.chainType === 'cardano' ? this.signAndSendCardanoTransaction(transaction) : transaction.chainType === 'ton' ? this.signAndSendTonTransaction(transaction) : this.signAndSendBitcoinTransaction(transaction));
     const {
       eventsHandler,
       step
@@ -676,6 +676,7 @@ class TransactionService {
       extrinsicHash: transaction.extrinsicHash,
       time: transaction.createdAt,
       fee: transaction.estimateFee,
+      blockTime: undefined,
       blockNumber: 0,
       // Will be added in next step
       blockHash: '',
@@ -1065,6 +1066,24 @@ class TransactionService {
     if ([_KoniTypes.ExtrinsicType.STAKING_JOIN_POOL, _KoniTypes.ExtrinsicType.STAKING_BOND, _KoniTypes.ExtrinsicType.JOIN_YIELD_POOL, _KoniTypes.ExtrinsicType.MINT_LDOT, _KoniTypes.ExtrinsicType.MINT_QDOT, _KoniTypes.ExtrinsicType.MINT_SDOT, _KoniTypes.ExtrinsicType.MINT_STDOT, _KoniTypes.ExtrinsicType.MINT_VDOT, _KoniTypes.ExtrinsicType.MINT_VMANTA].includes(transaction.extrinsicType)) {
       this.handlePostEarningTransaction(id);
     }
+
+    // Trigger balance update for Bitcoin transactions after receiving extrinsicHash
+    if (_KoniTypes.ExtrinsicType.TRANSFER_BALANCE && transaction.chainType === 'bitcoin') {
+      const balanceService = this.state.balanceService;
+      const inputData = (0, _utils3.parseTransactionData)(transaction.data);
+      try {
+        const sender = _uiKeyring.default.getPair(inputData.from);
+        balanceService.refreshBalanceForAddress(sender.address, transaction.chain, inputData.tokenSlug, transaction.extrinsicType).catch(error => console.error('Failed to run balance subscription:', error));
+      } catch (e) {
+        console.error(e);
+      }
+      try {
+        const recipient = _uiKeyring.default.getPair(inputData.to);
+        balanceService.refreshBalanceForAddress(recipient.address, transaction.chain, inputData.tokenSlug, transaction.extrinsicType).catch(error => console.error('Failed to run balance subscription:', error));
+      } catch (e) {
+        console.error(e);
+      }
+    }
   }
   handlePostProcessing(id) {
     // must be done after success/failure to make sure the transaction is finalized
@@ -1104,6 +1123,7 @@ class TransactionService {
     let {
       blockHash,
       blockNumber,
+      blockTime,
       extrinsicHash,
       id
     } = _ref4;
@@ -1118,7 +1138,8 @@ class TransactionService {
       extrinsicHash,
       status: _KoniTypes.ExtrinsicStatus.SUCCESS,
       blockNumber: blockNumber || 0,
-      blockHash: blockHash || ''
+      blockHash: blockHash || '',
+      blockTime
     }).catch(console.error);
     const info = (0, _util.isHex)(extrinsicHash) ? extrinsicHash : (0, _helpers.getBaseTransactionInfo)(transaction, this.state.chainService.getChainInfoMap());
     this.state.notificationService.notify({
@@ -1193,14 +1214,14 @@ class TransactionService {
         errors,
         extrinsicHash
       });
-      this.historyService.updateHistoryByExtrinsicHash(transaction.extrinsicHash, {
+      this.state.historyService.updateHistoryByExtrinsicHash(transaction.extrinsicHash, {
         extrinsicHash: extrinsicHash || transaction.extrinsicHash,
         status: nextStatus,
         blockNumber: blockNumber || 0,
         blockHash: blockHash || ''
       }).catch(console.error);
-      const info = (0, _util.isHex)(transaction === null || transaction === void 0 ? void 0 : transaction.extrinsicHash) ? transaction === null || transaction === void 0 ? void 0 : transaction.extrinsicHash : (0, _helpers.getBaseTransactionInfo)(transaction, this.chainService.getChainInfoMap());
-      this.notificationService.notify({
+      const info = (0, _util.isHex)(transaction === null || transaction === void 0 ? void 0 : transaction.extrinsicHash) ? transaction === null || transaction === void 0 ? void 0 : transaction.extrinsicHash : (0, _helpers.getBaseTransactionInfo)(transaction, this.state.chainService.getChainInfoMap());
+      this.state.notificationService.notify({
         type: _KoniTypes.NotificationType.ERROR,
         title: (0, _i18next.t)('Transaction timed out'),
         message: (0, _i18next.t)('Transaction {{info}} timed out', {
@@ -1214,7 +1235,7 @@ class TransactionService {
         notifyViaBrowser: true
       });
     }
-    this.eventService.emit('transaction.timeout', transaction);
+    this.state.eventService.emit('transaction.timeout', transaction);
   }
   generateHashPayload(chain, transaction) {
     const chainInfo = this.state.chainService.getChainInfoByKey(chain);
@@ -1894,6 +1915,106 @@ class TransactionService {
     });
     return emitter;
   }
+  emitterEventTransaction = (emitter, eventData, chain, payload) => {
+    // Emit signed event
+    emitter.emit('signed', eventData);
+    // Add start info
+    emitter.emit('send', eventData);
+    const event = this.state.chainService.getBitcoinApi(chain).api.sendRawTransaction(payload);
+    event.on('extrinsicHash', txHash => {
+      eventData.extrinsicHash = txHash;
+      emitter.emit('extrinsicHash', eventData);
+    });
+    event.on('success', transactionStatus => {
+      console.log(transactionStatus);
+      eventData.blockHash = transactionStatus.block_hash || undefined;
+      eventData.blockNumber = transactionStatus.block_height || undefined;
+      eventData.blockTime = transactionStatus.block_time ? transactionStatus.block_time * 1000 : undefined;
+      emitter.emit('success', eventData);
+    });
+    event.on('error', error => {
+      eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNABLE_TO_SEND, error));
+      emitter.emit('error', eventData);
+    });
+  };
+  signAndSendBitcoinTransaction(_ref22) {
+    let {
+      address,
+      chain,
+      id,
+      transaction,
+      url
+    } = _ref22;
+    const tx = transaction;
+    // const bitcoinApi = this.state.chainService.getBitcoinApi(chain);
+    // const chainInfo = this.state.chainService.getChainInfoByKey(chain);
+
+    const accountPair = _uiKeyring.default.getPair(address);
+    const account = (0, _utils4.pairToAccount)(accountPair);
+    const payload = {
+      payload: undefined,
+      payloadJson: undefined,
+      account,
+      canSign: true,
+      hashPayload: tx.toHex(),
+      id
+    };
+    const emitter = new _eventemitter.default();
+    const eventData = {
+      id,
+      errors: [],
+      warnings: [],
+      extrinsicHash: id
+    };
+    const isInjected = !!account.isInjected;
+    // const isExternal = !!account.isExternal;
+
+    if (isInjected) {
+      throw new _TransactionError.TransactionError(_types.BasicTxErrorType.UNSUPPORTED);
+    } else {
+      this.state.requestService.addConfirmationBitcoin(id, url || _constants2.EXTENSION_REQUEST_URL, 'bitcoinSendTransactionRequest', payload, {}).then(_ref23 => {
+        let {
+          isApproved,
+          payload
+        } = _ref23;
+        if (isApproved) {
+          if (!payload) {
+            throw new Error('Bad signature');
+          }
+
+          // Emit signed event
+          emitter.emit('signed', eventData);
+          // Add start info
+          emitter.emit('send', eventData);
+          const bitcoinApi = this.state.chainService.getBitcoinApi(chain);
+          const event = bitcoinApi.api.sendRawTransaction(payload);
+          event.on('extrinsicHash', txHash => {
+            eventData.extrinsicHash = txHash;
+            emitter.emit('extrinsicHash', eventData);
+          });
+          event.on('success', transactionStatus => {
+            eventData.blockHash = transactionStatus.block_hash || undefined;
+            eventData.blockNumber = transactionStatus.block_height || undefined;
+            eventData.blockTime = transactionStatus.block_time ? transactionStatus.block_time * 1000 : undefined;
+            emitter.emit('success', eventData);
+          });
+          event.on('error', error => {
+            eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNABLE_TO_SEND, error));
+            emitter.emit('error', eventData);
+          });
+        } else {
+          this.removeTransaction(id);
+          eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.USER_REJECT_REQUEST));
+          emitter.emit('error', eventData);
+        }
+      }).catch(e => {
+        this.removeTransaction(id);
+        eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNABLE_TO_SIGN, e.message));
+        emitter.emit('error', eventData);
+      });
+    }
+    return emitter;
+  }
   handleTransactionTimeout(emitter, eventData) {
     const timeout = setTimeout(() => {
       const transaction = this.getTransaction(eventData.id);

package/cjs/services/transaction-service/utils.js

@@ -37,8 +37,8 @@ function getBlockExplorerAccountRoute(explorerLink) {
   if (explorerLink.includes('statescan.io')) {
     return '#/accounts';
   }
-  if (explorerLink.includes('explorer.zkverify.io')) {
-    return 'account';
+  if (explorerLink.includes('explorer.gen6.app')) {
+    return '#/accounts';
   }
   if (explorerLink.includes('astral.autonomys')) {
     return 'accounts';
@@ -49,7 +49,7 @@ function getBlockExplorerAccountRoute(explorerLink) {
   return 'address';
 }
 function getBlockExplorerTxRoute(chainInfo) {
-  if ((0, _utils._isPureEvmChain)(chainInfo)) {
+  if ((0, _utils._isPureEvmChain)(chainInfo) || (0, _utils._isPureBitcoinChain)(chainInfo)) {
     return 'tx';
   }
   if ((0, _utils._isPureCardanoChain)(chainInfo)) {
@@ -58,6 +58,9 @@ function getBlockExplorerTxRoute(chainInfo) {
   if (['aventus', 'deeper_network'].includes(chainInfo.slug)) {
     return 'transaction';
   }
+  if (['gen6_public'].includes(chainInfo.slug)) {
+    return '#/extrinsics';
+  }
   const explorerLink = (0, _utils._getBlockExplorerFromChain)(chainInfo);
   if (explorerLink && explorerLink.includes('statescan.io')) {
     return '#/extrinsics';

package/cjs/strategy/api-request-strategy/context/base.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BaseApiRequestContext = void 0;
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+class BaseApiRequestContext {
+  callRate = 2; // limit per interval check
+  limitRate = 2; // max rate per interval check
+  intervalCheck = 1000; // interval check in ms
+  maxRetry = 9; // interval check in ms
+  rollbackRateTime = 30 * 1000; // rollback rate time in ms
+  timeoutRollbackRate = undefined;
+  constructor(options) {
+    this.callRate = (options === null || options === void 0 ? void 0 : options.limitRate) || this.callRate;
+    this.limitRate = (options === null || options === void 0 ? void 0 : options.limitRate) || this.limitRate;
+    this.intervalCheck = (options === null || options === void 0 ? void 0 : options.intervalCheck) || this.intervalCheck;
+    this.maxRetry = (options === null || options === void 0 ? void 0 : options.maxRetry) || this.maxRetry;
+  }
+  reduceLimitRate() {
+    clearTimeout(this.timeoutRollbackRate);
+    this.callRate = Math.ceil(this.limitRate / 2);
+    this.timeoutRollbackRate = setTimeout(() => {
+      this.callRate = this.limitRate;
+    }, this.rollbackRateTime);
+  }
+}
+exports.BaseApiRequestContext = BaseApiRequestContext;

package/cjs/strategy/api-request-strategy/index.js

@@ -0,0 +1,90 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BaseApiRequestStrategy = void 0;
+var _SWError = require("@subwallet/extension-base/background/errors/SWError");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+class BaseApiRequestStrategy {
+  nextId = 0;
+  isRunning = false;
+  requestMap = {};
+  processInterval = undefined;
+  getId() {
+    return this.nextId++;
+  }
+  constructor(context) {
+    this.context = context;
+  }
+  addRequest(run, ordinal) {
+    const newId = this.getId();
+    return new Promise((resolve, reject) => {
+      this.requestMap[newId] = {
+        id: newId,
+        status: 'pending',
+        retry: -1,
+        ordinal,
+        run,
+        resolve,
+        reject
+      };
+      if (!this.isRunning) {
+        this.process();
+      }
+    });
+  }
+  process() {
+    this.stop();
+    this.isRunning = true;
+    const maxRetry = this.context.maxRetry;
+    const interval = setInterval(() => {
+      const remainingRequests = Object.values(this.requestMap);
+      if (remainingRequests.length === 0) {
+        this.isRunning = false;
+        clearInterval(interval);
+        return;
+      }
+
+      // Get first this.limit requests base on id
+      const requests = remainingRequests.filter(request => request.status !== 'running').sort((a, b) => a.id - b.id).sort((a, b) => a.ordinal - b.ordinal).slice(0, this.context.callRate);
+
+      // Start requests
+      requests.forEach(request => {
+        request.status = 'running';
+        request.run().then(rs => {
+          request.resolve(rs);
+        }).catch(e => {
+          const isRateLimited = this.isRateLimited(e);
+
+          // Limit rate
+          if (isRateLimited) {
+            if (request.retry < maxRetry) {
+              request.status = 'pending';
+              request.retry++;
+              this.context.reduceLimitRate();
+            } else {
+              // Reject request
+              request.reject(new _SWError.SWError('MAX_RETRY', String(e)));
+            }
+          } else {
+            request.reject(new _SWError.SWError('UNKNOWN', String(e)));
+          }
+        });
+      });
+    }, this.context.intervalCheck);
+    this.processInterval = interval;
+  }
+  stop() {
+    clearInterval(this.processInterval);
+    this.processInterval = undefined;
+  }
+  setContext(context) {
+    this.stop();
+    this.context = context;
+    this.process();
+  }
+}
+exports.BaseApiRequestStrategy = BaseApiRequestStrategy;

package/cjs/strategy/api-request-strategy/types.js

@@ -0,0 +1 @@
+"use strict";

package/cjs/strategy/api-request-strategy/utils/index.js

@@ -0,0 +1,33 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.postRequest = exports.getRequest = void 0;
+var _crossFetch = _interopRequireDefault(require("cross-fetch"));
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+const postRequest = function (url, body, headers) {
+  let jsonBody = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;
+  return (0, _crossFetch.default)(url, {
+    method: 'POST',
+    headers: headers || {
+      'Content-Type': 'application/json'
+    },
+    body: jsonBody ? JSON.stringify(body) : body
+  });
+};
+exports.postRequest = postRequest;
+const getRequest = (url, params, headers) => {
+  const queryString = params ? Object.keys(params).map(key => `${encodeURIComponent(key)}=${encodeURIComponent(params[key])}`).join('&') : '';
+  const _url = `${url}?${queryString}`;
+  return (0, _crossFetch.default)(_url, {
+    method: 'GET',
+    headers: headers || {
+      'Content-Type': 'application/json'
+    }
+  });
+};
+exports.getRequest = getRequest;

package/cjs/types/account/info/keyring.js

@@ -77,7 +77,7 @@ const ACCOUNT_CHAIN_TYPE_ORDINAL_MAP = {
   [AccountChainType.BITCOIN]: 5
 };
 exports.ACCOUNT_CHAIN_TYPE_ORDINAL_MAP = ACCOUNT_CHAIN_TYPE_ORDINAL_MAP;
-const SUPPORTED_ACCOUNT_CHAIN_TYPES = ['substrate', 'ethereum', 'ton', 'cardano'];
+const SUPPORTED_ACCOUNT_CHAIN_TYPES = [AccountChainType.SUBSTRATE, AccountChainType.ETHEREUM, AccountChainType.TON, AccountChainType.CARDANO, AccountChainType.BITCOIN];
 exports.SUPPORTED_ACCOUNT_CHAIN_TYPES = SUPPORTED_ACCOUNT_CHAIN_TYPES;
 let AccountActions;
 /**