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

package/services/request-service/handler/AuthRequestHandler.js

@@ -2,12 +2,13 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { ALL_ACCOUNT_AUTH_TYPES } from '@subwallet/extension-base/constants';
-import { _isChainCardanoCompatible, _isChainEvmCompatible } from '@subwallet/extension-base/services/chain-service/utils';
+import { _isChainBitcoinCompatible, _isChainCardanoCompatible, _isChainEvmCompatible } from '@subwallet/extension-base/services/chain-service/utils';
 import { DAPP_CONNECT_BOTH_TYPE_ACCOUNT_URL, PREDEFINED_CHAIN_DAPP_CHAIN_MAP, WEB_APP_URL } from '@subwallet/extension-base/services/request-service/constants';
 import AuthorizeStore from '@subwallet/extension-base/stores/Authorize';
 import { createPromiseHandler, getDomainFromUrl, stripUrl } from '@subwallet/extension-base/utils';
 import { getId } from '@subwallet/extension-base/utils/getId';
 import { isCardanoAddress, isSubstrateAddress, isTonAddress } from '@subwallet/keyring';
+import { isBitcoinAddress } from '@subwallet/keyring/utils/address/validate';
 import { BehaviorSubject } from 'rxjs';
 import { isEthereumAddress } from '@polkadot/util-crypto';
 const AUTH_URLS_KEY = 'authUrls';
@@ -166,6 +167,18 @@ export default class AuthRequestHandler {
         }
       }
     }
+    if (options.accessType === 'bitcoin') {
+      const bitcoinChains = Object.values(chainInfoMaps).filter(_isChainBitcoinCompatible);
+      chainInfo = (defaultChain ? chainInfoMaps[defaultChain] : chainInfoMaps.bitcoin) || bitcoinChains[0]; // auto active cardano mainnet chain, because dont support switch network yet
+
+      if (options.autoActive) {
+        var _chainInfo5;
+        if (!needEnableChains.includes((_chainInfo5 = chainInfo) === null || _chainInfo5 === void 0 ? void 0 : _chainInfo5.slug)) {
+          var _chainInfo6;
+          needEnableChains.push((_chainInfo6 = chainInfo) === null || _chainInfo6 === void 0 ? void 0 : _chainInfo6.slug);
+        }
+      }
+    }
     needEnableChains = needEnableChains.filter(slug => {
       var _chainStateMap$slug;
       return !((_chainStateMap$slug = chainStateMap[slug]) !== null && _chainStateMap$slug !== void 0 && _chainStateMap$slug.active);
@@ -217,6 +230,9 @@ export default class AuthRequestHandler {
           if (isCardanoAddress(a) && !accountAuthTypes.includes('cardano')) {
             return true;
           }
+          if (isBitcoinAddress(a) && !accountAuthTypes.includes('bitcoin')) {
+            return true;
+          }
           return false;
         });
         backupAllowed.forEach(acc => {
@@ -365,6 +381,8 @@ export default class AuthRequestHandler {
           list.push(...allowedListByRequestType.filter(a => isTonAddress(a)));
         } else if (accountAuthType === 'cardano') {
           list.push(...allowedListByRequestType.filter(a => isCardanoAddress(a)));
+        } else if (accountAuthType === 'bitcoin') {
+          list.push(...allowedListByRequestType.filter(a => isBitcoinAddress(a)));
         }
         return list;
       }, []);

package/services/request-service/handler/BitcoinRequestHandler.d.ts

@@ -0,0 +1,22 @@
+import { BitcoinSignMessageResult, ConfirmationDefinitionsBitcoin, ConfirmationsQueueBitcoin, ConfirmationsQueueItemOptions, ConfirmationTypeBitcoin, RequestConfirmationCompleteBitcoin } from '@subwallet/extension-base/background/KoniTypes';
+import { ChainService } from '@subwallet/extension-base/services/chain-service';
+import RequestService from '@subwallet/extension-base/services/request-service';
+import TransactionService from '@subwallet/extension-base/services/transaction-service';
+import { BehaviorSubject } from 'rxjs';
+export default class BitcoinRequestHandler {
+    #private;
+    private readonly confirmationsQueueSubjectBitcoin;
+    private readonly confirmationsPromiseMap;
+    constructor(requestService: RequestService, chainService: ChainService, transactionService: TransactionService);
+    get numBitcoinRequests(): number;
+    getConfirmationsQueueSubjectBitcoin(): BehaviorSubject<ConfirmationsQueueBitcoin>;
+    addConfirmationBitcoin<CT extends ConfirmationTypeBitcoin>(id: string, url: string, type: CT, payload: ConfirmationDefinitionsBitcoin[CT][0]['payload'], options?: ConfirmationsQueueItemOptions, validator?: (input: ConfirmationDefinitionsBitcoin[CT][1]) => Error | undefined): Promise<ConfirmationDefinitionsBitcoin[CT][1]>;
+    updateConfirmationBitcoin<CT extends ConfirmationTypeBitcoin>(id: string, type: CT, payload: ConfirmationDefinitionsBitcoin[CT][0]['payload'], options?: ConfirmationsQueueItemOptions, validator?: (input: ConfirmationDefinitionsBitcoin[CT][1]) => Error | undefined): void;
+    signMessageBitcoin(confirmation: ConfirmationDefinitionsBitcoin['bitcoinSignatureRequest'][0]): BitcoinSignMessageResult;
+    private signTransactionBitcoin;
+    private signTransactionBitcoinWithPayload;
+    private signPsbt;
+    private decorateResultBitcoin;
+    completeConfirmationBitcoin(request: RequestConfirmationCompleteBitcoin): Promise<boolean>;
+    resetWallet(): void;
+}

package/services/request-service/handler/BitcoinRequestHandler.js

@@ -0,0 +1,414 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { BitcoinProviderError } from '@subwallet/extension-base/background/errors/BitcoinProviderError';
+import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
+import { BitcoinProviderErrorType } from '@subwallet/extension-base/background/KoniTypes';
+import { BasicTxErrorType } from '@subwallet/extension-base/types';
+import { createPromiseHandler } from '@subwallet/extension-base/utils';
+import { isInternalRequest } from '@subwallet/extension-base/utils/request';
+import keyring from '@subwallet/ui-keyring';
+import { Psbt } from 'bitcoinjs-lib';
+import * as bitcoin from 'bitcoinjs-lib';
+import { t } from 'i18next';
+import { BehaviorSubject } from 'rxjs';
+import { isArray, logger as createLogger } from '@polkadot/util';
+export default class BitcoinRequestHandler {
+  #requestService;
+  #chainService;
+  #transactionService;
+  #logger;
+  confirmationsQueueSubjectBitcoin = new BehaviorSubject({
+    bitcoinSignatureRequest: {},
+    bitcoinSendTransactionRequest: {},
+    bitcoinWatchTransactionRequest: {},
+    bitcoinSendTransactionRequestAfterConfirmation: {},
+    bitcoinSignPsbtRequest: {}
+  });
+  confirmationsPromiseMap = {};
+  constructor(requestService, chainService, transactionService) {
+    this.#requestService = requestService;
+    this.#chainService = chainService;
+    this.#transactionService = transactionService;
+    this.#logger = createLogger('BitcoinRequestHandler');
+  }
+  get numBitcoinRequests() {
+    let count = 0;
+    Object.values(this.confirmationsQueueSubjectBitcoin.getValue()).forEach(x => {
+      count += Object.keys(x).length;
+    });
+    return count;
+  }
+  getConfirmationsQueueSubjectBitcoin() {
+    return this.confirmationsQueueSubjectBitcoin;
+  }
+  async addConfirmationBitcoin(id, url, type, payload, options = {}, validator) {
+    const confirmations = this.confirmationsQueueSubjectBitcoin.getValue();
+    const confirmationType = confirmations[type];
+    const payloadJson = JSON.stringify(payload);
+    const isInternal = isInternalRequest(url);
+    if (['bitcoinSignatureRequest', 'bitcoinSendTransactionRequest', 'bitcoinSendTransactionRequestAfterConfirmation', 'bitcoinSignPsbtRequest'].includes(type)) {
+      const isAlwaysRequired = await this.#requestService.settingService.isAlwaysRequired;
+      if (isAlwaysRequired) {
+        this.#requestService.keyringService.lock();
+      }
+    }
+
+    // Check duplicate request
+    const duplicated = Object.values(confirmationType).find(c => c.url === url && c.payloadJson === payloadJson);
+    if (duplicated) {
+      throw new Error('Duplicate request');
+    }
+    confirmationType[id] = {
+      id,
+      url,
+      isInternal,
+      payload,
+      payloadJson,
+      ...options
+    };
+    const promise = new Promise((resolve, reject) => {
+      this.confirmationsPromiseMap[id] = {
+        validator: validator,
+        resolver: {
+          resolve: resolve,
+          reject: reject
+        }
+      };
+    });
+    this.confirmationsQueueSubjectBitcoin.next(confirmations);
+    if (!isInternal) {
+      this.#requestService.popupOpen();
+    }
+    this.#requestService.updateIconV2();
+    return promise;
+  }
+  updateConfirmationBitcoin(id, type, payload, options = {}, validator) {
+    const confirmations = this.confirmationsQueueSubjectBitcoin.getValue();
+    const confirmationType = confirmations[type];
+
+    // Check duplicate request
+    const exists = confirmationType[id];
+    if (!exists) {
+      throw new Error('Request does not exist');
+    }
+    const payloadJson = JSON.stringify(payload);
+    confirmationType[id] = {
+      ...exists,
+      payload,
+      payloadJson,
+      ...options
+    };
+    if (validator) {
+      this.confirmationsPromiseMap[id].validator = validator;
+    }
+    this.confirmationsQueueSubjectBitcoin.next(confirmations);
+  }
+  signMessageBitcoin(confirmation) {
+    const {
+      address,
+      payload
+    } = confirmation.payload;
+    const pair = keyring.getPair(address);
+    if (pair.isLocked) {
+      keyring.unlockPair(pair.address);
+    }
+
+    // Check if payload is a string
+    if (typeof payload === 'string') {
+      // Assume BitcoinSigner is an instance that implements the BitcoinSigner interface
+      return {
+        signature: pair.bitcoin.signMessage(payload),
+        message: payload,
+        address
+      }; // Assuming compressed = false
+    } else if (payload instanceof Uint8Array) {
+      // Check if payload is a byte array (Uint8Array)
+      // Convert Uint8Array to string
+      const payloadString = Buffer.from(payload).toString('hex');
+
+      // Assume BitcoinSigner is an instance that implements the BitcoinSigner interface
+      return {
+        signature: pair.bitcoin.signMessage(payloadString),
+        message: payload.toString(),
+        address
+      }; // Assuming compressed = false
+    } else {
+      // Handle the case where payload is invalid
+      throw new Error('Invalid payload type');
+    }
+  }
+  signTransactionBitcoin(request) {
+    // Extract necessary information from the BitcoinSendTransactionRequest
+    const {
+      address,
+      hashPayload
+    } = request.payload;
+    const pair = keyring.getPair(address);
+
+    // Unlock the pair if it is locked
+    if (pair.isLocked) {
+      keyring.unlockPair(pair.address);
+    }
+    const psbt = Psbt.fromHex(hashPayload);
+
+    // Finalize all inputs in the Psbt
+    // Sign the Psbt using the pair's bitcoin object
+    const signedTransaction = pair.bitcoin.signTransaction(psbt, psbt.txInputs.map((v, i) => i));
+    signedTransaction.finalizeAllInputs();
+    return signedTransaction.extractTransaction().toHex();
+  }
+  async signTransactionBitcoinWithPayload(request) {
+    const transaction = this.#transactionService.getTransaction(request.id);
+    const {
+      chain,
+      emitterTransaction,
+      id
+    } = transaction;
+    const {
+      from
+    } = transaction.data;
+    const {
+      promise,
+      reject,
+      resolve
+    } = createPromiseHandler();
+    if (!emitterTransaction) {
+      throw new BitcoinProviderError(BitcoinProviderErrorType.INTERNAL_ERROR);
+    }
+    const eventData = {
+      id,
+      errors: [],
+      warnings: [],
+      extrinsicHash: id
+    };
+    emitterTransaction.on('extrinsicHash', data => {
+      if (!data.extrinsicHash) {
+        reject(BitcoinProviderErrorType.INTERNAL_ERROR);
+      } else {
+        resolve(data.extrinsicHash);
+      }
+    });
+    emitterTransaction.on('error', error => {
+      reject(error);
+    });
+    try {
+      const chainInfo = this.#chainService.getChainInfoByKey(chain);
+      const psbt = transaction.transaction;
+      const pair = keyring.getPair(from);
+
+      // Unlock the pair if it is locked
+      if (pair.isLocked) {
+        keyring.unlockPair(pair.address);
+      }
+
+      // Finalize all inputs in the Psbt
+      // Sign the Psbt using the pair's bitcoin object
+      const signedTransaction = pair.bitcoin.signTransaction(psbt, psbt.txInputs.map((v, i) => i));
+      signedTransaction.finalizeAllInputs();
+      const signature = signedTransaction.extractTransaction().toHex();
+      this.#transactionService.emitterEventTransaction(emitterTransaction, eventData, chainInfo.slug, signature);
+    } catch (e) {
+      emitterTransaction.emit('error', {
+        ...eventData,
+        errors: [new TransactionError(BasicTxErrorType.INTERNAL_ERROR, e.message)]
+      });
+    }
+    return promise;
+  }
+  async signPsbt(request) {
+    // Extract necessary information from the BitcoinSendTransactionRequest
+    const {
+      address,
+      payload
+    } = request.payload;
+    const {
+      allowedSighash,
+      autoFinalized = true,
+      broadcast,
+      network,
+      psbt: psbtHex,
+      signAtIndex
+    } = payload;
+    const transaction = this.#transactionService.getTransaction(request.id);
+    const bitcoinNetwork = network === 'bitcoinTestnet' ? bitcoin.networks.testnet : bitcoin.networks.bitcoin;
+    const psbt = bitcoin.Psbt.fromHex(psbtHex, {
+      network: bitcoinNetwork
+    });
+    let eventData = {
+      id: request.id,
+      errors: [],
+      warnings: [],
+      extrinsicHash: request.id
+    };
+    const pair = keyring.getPair(address);
+
+    // Unlock the pair if it is locked
+    if (pair.isLocked) {
+      keyring.unlockPair(pair.address);
+    }
+    const signAtIndexGenerate = signAtIndex ? isArray(signAtIndex) ? signAtIndex : [signAtIndex] : [...Array(psbt.inputCount)].map((_, i) => i);
+    let psptSignedTransaction = null;
+
+    // Sign the Psbt using the pair's bitcoin object
+    try {
+      psptSignedTransaction = pair.bitcoin.signTransaction(psbt, signAtIndexGenerate, allowedSighash);
+    } catch (e) {
+      if (transaction) {
+        var _transaction$emitterT;
+        (_transaction$emitterT = transaction.emitterTransaction) === null || _transaction$emitterT === void 0 ? void 0 : _transaction$emitterT.emit('error', {
+          ...eventData,
+          errors: [new TransactionError(BasicTxErrorType.INVALID_PARAMS, e.message)],
+          id: transaction.id,
+          extrinsicHash: transaction.id
+        });
+      }
+      throw new Error(e.message);
+    }
+    if (!psptSignedTransaction) {
+      throw new Error('Unable to sign');
+    }
+    if (!broadcast) {
+      if (autoFinalized) {
+        for (const index of signAtIndexGenerate) {
+          psptSignedTransaction.finalizeInput(index);
+        }
+      }
+      return {
+        psbt: psptSignedTransaction.toHex()
+      };
+    }
+    if (!transaction) {
+      throw new BitcoinProviderError(BitcoinProviderErrorType.INTERNAL_ERROR);
+    }
+    const {
+      chain,
+      emitterTransaction,
+      id
+    } = transaction;
+    eventData = {
+      id,
+      errors: [],
+      warnings: [],
+      extrinsicHash: id
+    };
+    if (!emitterTransaction) {
+      throw new BitcoinProviderError(BitcoinProviderErrorType.INTERNAL_ERROR);
+    }
+    const chainInfo = this.#chainService.getChainInfoByKey(chain);
+    try {
+      if (!autoFinalized) {
+        throw new Error('Unable to send transaction without autoFinalized');
+      }
+      psptSignedTransaction.finalizeAllInputs();
+    } catch (e) {
+      emitterTransaction.emit('error', {
+        ...eventData,
+        errors: [new TransactionError(BasicTxErrorType.INVALID_PARAMS, e.message)]
+      });
+      throw new Error(e.message);
+    }
+    const hexTransaction = psptSignedTransaction.extractTransaction().toHex();
+    this.#transactionService.emitterEventTransaction(emitterTransaction, eventData, chainInfo.slug, hexTransaction);
+    const {
+      promise,
+      reject,
+      resolve
+    } = createPromiseHandler();
+    emitterTransaction.on('extrinsicHash', data => {
+      if (!data.extrinsicHash || !psptSignedTransaction) {
+        reject(BitcoinProviderErrorType.INTERNAL_ERROR);
+      } else {
+        var _psptSignedTransactio;
+        resolve({
+          psbt: (_psptSignedTransactio = psptSignedTransaction) === null || _psptSignedTransactio === void 0 ? void 0 : _psptSignedTransactio.toHex(),
+          txid: data.extrinsicHash
+        });
+      }
+    });
+    emitterTransaction.on('error', error => {
+      reject(error);
+    });
+    return promise;
+  }
+  async decorateResultBitcoin(t, request, result) {
+    if (t === 'bitcoinSignatureRequest') {
+      result.payload = this.signMessageBitcoin(request);
+    } else if (t === 'bitcoinSendTransactionRequest') {
+      result.payload = this.signTransactionBitcoin(request);
+    } else if (t === 'bitcoinSignPsbtRequest') {
+      result.payload = await this.signPsbt(request);
+    } else if (t === 'bitcoinSendTransactionRequestAfterConfirmation') {
+      result.payload = await this.signTransactionBitcoinWithPayload(request);
+    }
+    if (t === 'bitcoinSignatureRequest' || t === 'bitcoinSendTransactionRequest' || t === 'bitcoinSignPsbtRequest' || t === 'bitcoinSendTransactionRequestAfterConfirmation') {
+      const isAlwaysRequired = await this.#requestService.settingService.isAlwaysRequired;
+      if (isAlwaysRequired) {
+        this.#requestService.keyringService.lock();
+      }
+    }
+  }
+  async completeConfirmationBitcoin(request) {
+    const confirmations = this.confirmationsQueueSubjectBitcoin.getValue();
+    for (const ct in request) {
+      const type = ct;
+      const result = request[type];
+      const {
+        id,
+        isApproved
+      } = result;
+      const {
+        resolver,
+        validator
+      } = this.confirmationsPromiseMap[id];
+      const confirmation = confirmations[type][id];
+      if (!resolver || !confirmation) {
+        this.#logger.error(t('Unable to proceed. Please try again'), type, id);
+        throw new Error('Unable to proceed. Please try again');
+      }
+      if (isApproved) {
+        try {
+          // Fill signature for some special type
+          await this.decorateResultBitcoin(type, confirmation, result);
+          const error = validator && validator(result);
+          if (error) {
+            resolver.reject(error);
+          }
+        } catch (e) {
+          resolver.reject(e);
+        }
+      }
+
+      // Delete confirmations from queue
+      delete this.confirmationsPromiseMap[id];
+      delete confirmations[type][id];
+      this.confirmationsQueueSubjectBitcoin.next(confirmations);
+
+      // Update icon, and close queue
+      this.#requestService.updateIconV2(this.#requestService.numAllRequests === 0);
+      resolver.resolve(result);
+    }
+    return true;
+  }
+  resetWallet() {
+    const confirmations = this.confirmationsQueueSubjectBitcoin.getValue();
+    for (const [type, requests] of Object.entries(confirmations)) {
+      for (const confirmation of Object.values(requests)) {
+        const {
+          id
+        } = confirmation;
+        const {
+          resolver
+        } = this.confirmationsPromiseMap[id];
+        if (!resolver || !confirmation) {
+          console.error('Not found confirmation', type, id);
+        } else {
+          resolver.reject(new Error('Reset wallet'));
+        }
+        delete this.confirmationsPromiseMap[id];
+        delete confirmations[type][id];
+      }
+    }
+    this.confirmationsQueueSubjectBitcoin.next(confirmations);
+  }
+}

package/services/request-service/index.d.ts

@@ -1,8 +1,9 @@
-import { AuthRequestV2, ConfirmationDefinitions, ConfirmationDefinitionsCardano, ConfirmationDefinitionsTon, ConfirmationsQueue, ConfirmationsQueueCardano, ConfirmationsQueueItemOptions, ConfirmationsQueueTon, ConfirmationType, ConfirmationTypeCardano, ConfirmationTypeTon, RequestConfirmationComplete, RequestConfirmationCompleteCardano, RequestConfirmationCompleteTon } from '@subwallet/extension-base/background/KoniTypes';
+import { AuthRequestV2, ConfirmationDefinitions, ConfirmationDefinitionsBitcoin, ConfirmationDefinitionsCardano, ConfirmationDefinitionsTon, ConfirmationsQueue, ConfirmationsQueueBitcoin, ConfirmationsQueueCardano, ConfirmationsQueueItemOptions, ConfirmationsQueueTon, ConfirmationType, ConfirmationTypeBitcoin, ConfirmationTypeCardano, ConfirmationTypeTon, RequestConfirmationComplete, RequestConfirmationCompleteBitcoin, RequestConfirmationCompleteCardano, RequestConfirmationCompleteTon } from '@subwallet/extension-base/background/KoniTypes';
 import { AccountAuthType, AuthorizeRequest, MetadataRequest, RequestAuthorizeTab, RequestSign, ResponseSigning, SigningRequest } from '@subwallet/extension-base/background/types';
 import { ChainService } from '@subwallet/extension-base/services/chain-service';
 import { KeyringService } from '@subwallet/extension-base/services/keyring-service';
 import SettingService from '@subwallet/extension-base/services/setting-service/SettingService';
+import TransactionService from '@subwallet/extension-base/services/transaction-service';
 import { WalletConnectNotSupportRequest, WalletConnectSessionRequest } from '@subwallet/extension-base/services/wallet-connect-service/types';
 import { MetadataDef } from '@subwallet/extension-inject/types';
 import { BehaviorSubject } from 'rxjs';
@@ -12,7 +13,7 @@ export default class RequestService {
     #private;
     readonly settingService: SettingService;
     readonly keyringService: KeyringService;
-    constructor(chainService: ChainService, settingService: SettingService, keyringService: KeyringService);
+    constructor(chainService: ChainService, settingService: SettingService, keyringService: KeyringService, transactionService: TransactionService);
     get numAllRequests(): number;
     updateIconV2(shouldClose?: boolean): void;
     getAddressList(value?: boolean): Record<string, boolean>;
@@ -48,6 +49,7 @@ export default class RequestService {
     get numEvmRequests(): number;
     get numTonRequests(): number;
     get numCardanoRequests(): number;
+    get numBitcoinRequests(): number;
     get confirmationsQueueSubject(): BehaviorSubject<ConfirmationsQueue>;
     get confirmationsQueueSubjectTon(): BehaviorSubject<ConfirmationsQueueTon>;
     get confirmationsQueueSubjectCardano(): BehaviorSubject<ConfirmationsQueueCardano>;
@@ -60,6 +62,10 @@ export default class RequestService {
     completeConfirmationTon(request: RequestConfirmationCompleteTon): Promise<boolean>;
     completeConfirmationCardano(request: RequestConfirmationCompleteCardano): Promise<boolean>;
     updateConfirmation<CT extends ConfirmationType>(id: string, type: CT, payload: ConfirmationDefinitions[CT][0]['payload'], options?: ConfirmationsQueueItemOptions, validator?: (input: ConfirmationDefinitions[CT][1]) => Error | undefined): void;
+    get confirmationsQueueSubjectBitcoin(): BehaviorSubject<ConfirmationsQueueBitcoin>;
+    addConfirmationBitcoin<CT extends ConfirmationTypeBitcoin>(id: string, url: string, type: CT, payload: ConfirmationDefinitionsBitcoin[CT][0]['payload'], options?: ConfirmationsQueueItemOptions, validator?: (input: ConfirmationDefinitionsBitcoin[CT][1]) => Error | undefined): Promise<ConfirmationDefinitionsBitcoin[CT][1]>;
+    completeConfirmationBitcoin(request: RequestConfirmationCompleteBitcoin): Promise<boolean>;
+    updateConfirmationBitcoin<CT extends ConfirmationTypeBitcoin>(id: string, type: CT, payload: ConfirmationDefinitionsBitcoin[CT][0]['payload'], options?: ConfirmationsQueueItemOptions, validator?: (input: ConfirmationDefinitionsBitcoin[CT][1]) => Error | undefined): void;
     getConnectWCRequest(id: string): import("@subwallet/extension-base/services/wallet-connect-service/types").RequestWalletConnectSession;
     get connectWCSubject(): BehaviorSubject<WalletConnectSessionRequest[]>;
     get allConnectWCRequests(): WalletConnectSessionRequest[];

package/services/request-service/index.js

@@ -1,6 +1,7 @@
 // Copyright 2019-2022 @subwallet/extension-base authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+import BitcoinRequestHandler from '@subwallet/extension-base/services/request-service/handler/BitcoinRequestHandler';
 import CardanoRequestHandler from '@subwallet/extension-base/services/request-service/handler/CardanoRequestHandler';
 import TonRequestHandler from "./handler/TonRequestHandler.js";
 import { AuthRequestHandler, ConnectWCRequestHandler, EvmRequestHandler, MetadataRequestHandler, NotSupportWCRequestHandler, PopupHandler, SubstrateRequestHandler } from "./handler/index.js";
@@ -12,13 +13,14 @@ export default class RequestService {
   #authRequestHandler;
   #substrateRequestHandler;
   #evmRequestHandler;
+  #bitcoinRequestHandler;
   #tonRequestHandler;
   #cardanoRequestHandler;
   #connectWCRequestHandler;
   #notSupportWCRequestHandler;
 
   // Common
-  constructor(chainService, settingService, keyringService) {
+  constructor(chainService, settingService, keyringService, transactionService) {
     this.#chainService = chainService;
     this.settingService = settingService;
     this.keyringService = keyringService;
@@ -29,6 +31,7 @@ export default class RequestService {
     this.#evmRequestHandler = new EvmRequestHandler(this);
     this.#tonRequestHandler = new TonRequestHandler(this);
     this.#cardanoRequestHandler = new CardanoRequestHandler(this);
+    this.#bitcoinRequestHandler = new BitcoinRequestHandler(this, this.#chainService, transactionService);
     this.#connectWCRequestHandler = new ConnectWCRequestHandler(this);
     this.#notSupportWCRequestHandler = new NotSupportWCRequestHandler(this);
 
@@ -36,7 +39,7 @@ export default 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);
@@ -148,6 +151,9 @@ export default class RequestService {
   get numCardanoRequests() {
     return this.#cardanoRequestHandler.numCardanoRequests;
   }
+  get numBitcoinRequests() {
+    return this.#bitcoinRequestHandler.numBitcoinRequests;
+  }
   get confirmationsQueueSubject() {
     return this.#evmRequestHandler.getConfirmationsQueueSubject();
   }
@@ -185,6 +191,21 @@ export default class RequestService {
     return this.#evmRequestHandler.updateConfirmation(id, type, payload, options, validator);
   }
 
+  // Bitcoin requests
+
+  get confirmationsQueueSubjectBitcoin() {
+    return this.#bitcoinRequestHandler.getConfirmationsQueueSubjectBitcoin();
+  }
+  addConfirmationBitcoin(id, url, type, payload, options = {}, validator) {
+    return this.#bitcoinRequestHandler.addConfirmationBitcoin(id, url, type, payload, options, validator);
+  }
+  async completeConfirmationBitcoin(request) {
+    return await this.#bitcoinRequestHandler.completeConfirmationBitcoin(request);
+  }
+  updateConfirmationBitcoin(id, type, payload, options = {}, validator) {
+    return this.#bitcoinRequestHandler.updateConfirmationBitcoin(id, type, payload, options, validator);
+  }
+
   // WalletConnect Connect requests
   getConnectWCRequest(id) {
     return this.#connectWCRequestHandler.getConnectWCRequest(id);
@@ -221,7 +242,7 @@ export default 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();
@@ -229,6 +250,7 @@ export default class RequestService {
     this.#evmRequestHandler.resetWallet();
     this.#tonRequestHandler.resetWallet();
     this.#cardanoRequestHandler.resetWallet();
+    this.#bitcoinRequestHandler.resetWallet();
     this.#metadataRequestHandler.resetWallet();
     this.#connectWCRequestHandler.resetWallet();
     this.#notSupportWCRequestHandler.resetWallet();

package/services/rune-service/index.d.ts

@@ -0,0 +1,17 @@
+import { RuneMetadata, RunesCollectionInfoResponse, RunesInfoByAddressFetchedData, RuneTxsResponse, RuneUtxoResponse } from '@subwallet/extension-base/services/chain-service/handler/bitcoin/strategy/types';
+import { BaseApiRequestStrategy } from '@subwallet/extension-base/strategy/api-request-strategy';
+export declare class RunesService extends BaseApiRequestStrategy {
+    baseUrl: string;
+    private constructor();
+    private headers;
+    isRateLimited(): boolean;
+    getUrl(path: string): string;
+    getAddressRunesInfo(address: string, params: Record<string, string>): Promise<RunesInfoByAddressFetchedData>;
+    getRuneCollectionsByBatch(params: Record<string, string>): Promise<RunesCollectionInfoResponse>;
+    getAddressRuneTxs(address: string, params: Record<string, string>): Promise<RuneTxsResponse>;
+    getRuneMetadata(runeid: string): Promise<RuneMetadata>;
+    getAddressRuneUtxos(address: string): Promise<RuneUtxoResponse>;
+    private static mainnet;
+    private static testnet;
+    static getInstance(isTestnet?: boolean): RunesService;
+}