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

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

@@ -0,0 +1,427 @@
+// 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 { createBitcoinTransaction } from '@subwallet/extension-base/services/balance-service/transfer/bitcoin-transfer';
+import { BasicTxErrorType } from '@subwallet/extension-base/types';
+import { createPromiseHandler } from '@subwallet/extension-base/utils';
+import { getId } from '@subwallet/extension-base/utils/getId';
+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;
+  #feeService;
+  #logger;
+  confirmationsQueueSubjectBitcoin = new BehaviorSubject({
+    bitcoinSignatureRequest: {},
+    bitcoinSendTransactionRequest: {},
+    bitcoinWatchTransactionRequest: {},
+    bitcoinSendTransactionRequestAfterConfirmation: {},
+    bitcoinSignPsbtRequest: {}
+  });
+  confirmationsPromiseMap = {};
+  constructor(requestService, chainService, feeService, transactionService) {
+    this.#requestService = requestService;
+    this.#chainService = chainService;
+    this.#feeService = feeService;
+    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'].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 {
+      account,
+      payload
+    } = confirmation.payload;
+    const address = account.address;
+    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 {
+      account,
+      hashPayload
+    } = request.payload;
+    const address = account.address;
+    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,
+      feeCustom,
+      feeOption,
+      id
+    } = transaction;
+    const {
+      from,
+      to,
+      value
+    } = transaction.data;
+    if (!emitterTransaction) {
+      throw new BitcoinProviderError(BitcoinProviderErrorType.INTERNAL_ERROR);
+    }
+    const chainInfo = this.#chainService.getChainInfoByKey(chain);
+    const bitcoinApi = this.#chainService.getBitcoinApi(chain);
+    const eventData = {
+      id,
+      errors: [],
+      warnings: [],
+      extrinsicHash: id
+    };
+    const network = chainInfo.isTestnet ? bitcoin.networks.testnet : bitcoin.networks.bitcoin;
+    const feeInfo = await this.#feeService.subscribeChainFee(getId(), chain, 'bitcoin');
+    const [psbt] = await createBitcoinTransaction({
+      bitcoinApi,
+      chain,
+      from,
+      feeCustom,
+      feeOption,
+      feeInfo,
+      to,
+      transferAll: false,
+      value: value || '0',
+      network
+    });
+    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);
+    const {
+      promise,
+      reject,
+      resolve
+    } = createPromiseHandler();
+    emitterTransaction.on('extrinsicHash', data => {
+      if (!data.extrinsicHash) {
+        reject(BitcoinProviderErrorType.INTERNAL_ERROR);
+      } else {
+        resolve(data.extrinsicHash);
+      }
+    });
+    emitterTransaction.on('error', error => {
+      reject(error);
+    });
+    return promise;
+  }
+  async signPsbt(request) {
+    // Extract necessary information from the BitcoinSendTransactionRequest
+    const {
+      account,
+      payload
+    } = request.payload;
+    const {
+      allowedSighash,
+      broadcast,
+      psbt,
+      signAtIndex
+    } = payload;
+    const transaction = this.#transactionService.getTransaction(request.id);
+    let eventData = {
+      id: request.id,
+      errors: [],
+      warnings: [],
+      extrinsicHash: request.id
+    };
+
+    // todo: validate type of the account
+
+    if (Object.keys(account).length === 0) {
+      throw new BitcoinProviderError(BitcoinProviderErrorType.INVALID_PARAMS, 'Please connect to Wallet to try this request');
+    }
+    const pair = keyring.getPair(account.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) {
+      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 {
+      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,10 @@
-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 FeeService from '@subwallet/extension-base/services/fee-service/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 +14,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, feeService: FeeService, transactionService: TransactionService);
     get numAllRequests(): number;
     updateIconV2(shouldClose?: boolean): void;
     getAddressList(value?: boolean): Record<string, boolean>;
@@ -48,6 +50,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 +63,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, feeService, 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, feeService, 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;
+}

package/services/rune-service/index.js

@@ -0,0 +1,97 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { SWError } from '@subwallet/extension-base/background/errors/SWError';
+import { _BTC_SERVICE_TOKEN } from '@subwallet/extension-base/services/chain-service/constants';
+import { BaseApiRequestStrategy } from '@subwallet/extension-base/strategy/api-request-strategy';
+import { BaseApiRequestContext } from '@subwallet/extension-base/strategy/api-request-strategy/context/base';
+import { getRequest } from '@subwallet/extension-base/strategy/api-request-strategy/utils';
+const BITCOIN_API_URL = 'https://btc-api.koni.studio';
+const BITCOIN_API_URL_TEST = 'https://api-testnet.openbit.app';
+export class RunesService extends BaseApiRequestStrategy {
+  constructor(url) {
+    const context = new BaseApiRequestContext();
+    super(context);
+    this.baseUrl = url;
+  }
+  headers = {
+    'Content-Type': 'application/json',
+    Authorization: `Bearer ${_BTC_SERVICE_TOKEN}`
+  };
+  isRateLimited() {
+    return false;
+  }
+  getUrl(path) {
+    return `${this.baseUrl}/${path}`;
+  }
+  getAddressRunesInfo(address, params) {
+    return this.addRequest(async () => {
+      const _rs = await getRequest(this.getUrl(`rune/address/${address}`), params, this.headers);
+      const rs = await _rs.json();
+      if (rs.status_code !== 200) {
+        throw new SWError('RuneScanService.getAddressRunesInfo', rs.message);
+      }
+      return rs.result;
+    }, 1);
+  }
+
+  // * Deprecated
+  getRuneCollectionsByBatch(params) {
+    return this.addRequest(async () => {
+      const url = this.getUrl('rune');
+      const rs = await getRequest(url, params);
+      if (rs.status !== 200) {
+        throw new 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 getRequest(url, params);
+      if (rs.status !== 200) {
+        throw new SWError('RuneScanService.getAddressRuneTxs', await rs.text());
+      }
+      return await rs.json();
+    }, 0);
+  }
+  getRuneMetadata(runeid) {
+    return this.addRequest(async () => {
+      const _rs = await getRequest(this.getUrl(`rune/metadata/${runeid}`), undefined, this.headers);
+      const rs = await _rs.json();
+      if (rs.status_code !== 200) {
+        throw new SWError('RuneScanService.getRuneMetadata', rs.message);
+      }
+      return rs.result;
+    }, 0);
+  }
+  getAddressRuneUtxos(address) {
+    return this.addRequest(async () => {
+      const _rs = await getRequest(this.getUrl(`rune/address/${address}/rune/utxo`), undefined, this.headers);
+      const rs = await _rs.json();
+      if (rs.status_code !== 200) {
+        throw new SWError('RuneScanService.getAddressRuneUtxos', rs.message);
+      }
+      return rs.result;
+    }, 0);
+  }
+
+  // Singleton
+
+  static getInstance(isTestnet = 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;
+    }
+  }
+}

package/services/transaction-service/helpers/index.d.ts

@@ -1,11 +1,13 @@
 import { _ChainInfo } from '@subwallet/chain-list/types';
 import { CardanoTransactionConfig } from '@subwallet/extension-base/services/balance-service/transfer/cardano-transfer';
 import { TonTransactionConfig } from '@subwallet/extension-base/services/balance-service/transfer/ton-transfer';
-import { SWTransactionBase } from '@subwallet/extension-base/services/transaction-service/types';
+import { SWTransaction, SWTransactionBase } from '@subwallet/extension-base/services/transaction-service/types';
+import { Psbt } from 'bitcoinjs-lib';
 import { SubmittableExtrinsic } from '@polkadot/api/promise/types';
 export declare const getTransactionId: (chainType: string, chain: string, isInternal: boolean, isWalletConnect?: boolean) => string;
 export declare const getValidationId: (chainType: string, chain: string) => string;
 export declare const isSubstrateTransaction: (tx: SWTransactionBase['transaction']) => tx is SubmittableExtrinsic;
 export declare const isTonTransaction: (tx: SWTransactionBase['transaction']) => tx is TonTransactionConfig;
 export declare const isCardanoTransaction: (tx: SWTransactionBase['transaction']) => tx is CardanoTransactionConfig;
+export declare const isBitcoinTransaction: (tx: SWTransaction['transaction']) => tx is Psbt;
 export declare const getBaseTransactionInfo: (transaction: SWTransactionBase, chainInfoMap: Record<string, _ChainInfo>) => string;